#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

#define FOR(i, x, n) for(int i = x; i < n; i++)
#define F0R(i, n) FOR(i, 0, n)
#define ROF(i, x, n) for(int i = n - 1; i >= x; i--)
#define R0F(i, n) ROF(i, 0, n)

#define WTF cout << "WTF" << endl

#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define F first
#define S second
#define PB push_back
#define EP emplace_back

#define ALL(x) x.begin(), x.end()
#define RALL(x) x.rbegin(), x.rend()

using namespace std;

typedef long long LL;
typedef long double LD;

typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;

typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;

typedef complex<LD> Point;

const int N = 2e5 + 7;
const int INF = 1e9 + 7;
const int LOG = 22;
const int A = 26;
const int SQ = 320;
const int MOD = 1e9 + 7;

LL n;
LL ns[N][2], dists[N][2];
map<LL, vector<LL>> x, y;
LL allx, ally;

int main() {
    IOS;
    
    cin >> n;
    if (n <= 2) {
        cout << -1 << endl;
        return 0;
    }

    F0R(i, n) {
        cin >> ns[i][0] >> ns[i][1];
        x[ ns[i][0] ].PB(ns[i][1]);
        y[ ns[i][1] ].PB(ns[i][0]);
    }

    FOR(i, 1, n) {
        allx = __gcd(allx, abs(ns[i][0] - ns[i - 1][0]));
        ally = __gcd(ally, abs(ns[i][1] - ns[i - 1][1]));
    }

    LL xs_gc = 0, ys_gc = 0;
    
    F0R(_, 3) {
        VPLL dists;
        FOR(i, 1, n) {
            PLL x;
            x.F = ns[i][0] - ns[0][0];
            x.S = ns[i][1] - ns[0][1];
            if (x.F != 0 && x.S != 0) {
                dists.PB(x);
            }

            else if (x.F == 0) {
                ys_gc = __gcd(ys_gc, abs(x.S));
            }

            else if (x.S == 0) {
                xs_gc = __gcd(xs_gc, abs(x.F));
            }
        }

        FOR(i, 2, dists.size()) {
            if (dists[i - 1].F < 0) {
                dists[i - 1].F *= -1;
                dists[i - 1].S *= -1;
            }

            if (dists[i].F < 0) {
                dists[i].F *= -1;
                dists[i].S *= -1;
            }

            int g = __gcd(dists[i].F, dists[i - 1].F);
            ys_gc = __gcd(1ll * ys_gc, abs(1ll * dists[i].S * dists[i - 1].F / g - 1ll * dists[i - 1].S * dists[i].F / g));

            if (dists[i - 1].S < 0) {
                dists[i - 1].S *= -1;
                dists[i - 1].F *= -1;
            }

            if (dists[i].S < 0) {
                dists[i].S *= -1;
                dists[i].F *= -1;
            }
            g = __gcd(dists[i].S, dists[i - 1].S);
            xs_gc = __gcd(1ll * xs_gc, abs(1ll * dists[i].F * dists[i - 1].S / g - 1ll * dists[i - 1].F * dists[i].S / g));
        }

        if (_ == 0) {
            FOR(i, 1, n) if (ns[i][0] != ns[0][0]) {
                swap(ns[i], ns[0]);
            }
        }
        if (_ == 2) {
            FOR(i, 1, n) if (ns[i][1] != ns[0][1]) {
                swap(ns[i], ns[0]);
            }
        }
    }

    for(auto &[a, b] : x) {
        LL gc = 0;
        FOR(i, 1, b.size())
            gc = __gcd(abs(b[i - 1] - b[i]), gc);
        ys_gc = __gcd(ys_gc, gc);
        if (b.size() >= 2) xs_gc = __gcd(xs_gc, allx);
    }

    for(auto &[a, b] : y) {
        LL gc = 0;
        FOR(i, 1, b.size())
            gc = __gcd(abs(b[i - 1] - b[i]), gc);
        xs_gc = __gcd(xs_gc, gc);
        if (b.size() >= 2) ys_gc = __gcd(ys_gc, allx);
    }

    if (ys_gc == 0 || xs_gc == 0) {
        cout << -1 << endl;
        return 0;
    }
    cout  << 1ll * ys_gc * xs_gc << endl;
}