#include <bits/stdc++.h>

struct Vector {
    int64_t x, y;

    Vector() : x(0), y(0) { ; }
    Vector(int64_t x, int64_t y) : x(x), y(y) { ; }

    Vector operator-(const Vector& other) const {
        return Vector(x - other.x, y - other.y);
    }
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }
    Vector operator*(const int64_t& f) const {
        return Vector(x * f, y * f);
    }
    int64_t operator%(const Vector& other) const {
        return int64_t(x) * other.y - int64_t(y) * other.x;
    }
    int64_t operator*(const Vector& other) const {
        return int64_t(x) * other.x + int64_t(y) * other.y;
    }
    int64_t sq_len() const {
        return *this * *this;
    }
};

std::array<Vector, 2> fuck(std::array<Vector, 3> ar) {
    while (ar[0].sq_len() && ar[1].sq_len() && ar[2].sq_len()) {
        for (int f = (1 << 20); f >= 1; f >>= 1) {
            for (int i = 0; i < ar.size(); i++) {
                Vector dt = ar[i] * f;
                if (llabs(dt.x) > int(2e6) || llabs(dt.y) > int(2e6)) {
                    continue;
                }
                for (int j = 0; j < ar.size(); j++) {
                    if (i == j) {
                        continue;
                    }
                    if ((ar[j] + dt).sq_len() < ar[j].sq_len()) {
                        ar[j] = ar[j] + dt;
                    } else if ((ar[j] - dt).sq_len() < ar[j].sq_len()) {
                        ar[j] = ar[j] - dt;
                    }
                }
            }
        }
    }
    std::sort(ar.begin(), ar.end(), [&](const auto& a, const auto& b) { return a.sq_len() > b.sq_len(); });
    return {ar[0], ar[1]};
}

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;
    std::vector<Vector> input(n);
    for (auto& [x, y] : input) {
        std::cin >> x >> y;
    }
    for (int i = 1; i < n; i++) {
        input[i] = input[i] - input[0];
    }
    input.erase(input.begin());
    n = input.size();
    if (n <= 1) {
        std::cout << "-1\n";
        return 0;
    }

    std::array<Vector, 2> ar{{{0, 0}, {0, 0}}};
    for (auto p : input) {
        std::array<Vector, 3> ar2 = {ar[0], ar[1], p};
        ar = fuck(ar2);
    }
    if (ar[0] % ar[1]) {
        std::cout << llabs(ar[0] % ar[1]) << std::endl;
    } else {
        std::cout << "-1\n";
    }

    return 0;
}