#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;

using db = double;
using ldb = long double; 
#define _T template <class T>
#define _FT template<class T, class FT = typename common_type<T, double>::type>
#define _F(X, Y) using X = Y<T, FT>; using F##X = Y<FT>

_T constexpr T eps = 0;
template<> constexpr double eps<double> = 1e-9;
template<> constexpr long double eps<long double> = 1e-11;

_T int sign(T x) {
    return (x > eps<T>) - (x < -eps<T>);
}

_T int cmp(T x, T y) {
    return sign(x - y);
}

_FT struct Point {
    _F(P, Point);

    T x, y;

    Point() = default;
    Point(T x, T y) : x(x), y(y) {}
    template <class U, class FU>
    explicit Point(const Point<U, FU>& p) : x(p.x), y(p.y) {}

    T det(const P& p) const { return x * p.y - y * p.x; }
    T dot(const P& p) const { return x * p.x + y * p.y; }

    P operator+(const P& p) const { return {x + p.x, y + p.y}; }
    P operator-(const P& p) const { return {x - p.x, y - p.y}; }
    P operator*(T d) const { return {x * d, y * d}; }
    P operator-() const { return {-x, -y}; }

    FP operator/(FT d) const { return {x / d, y / d}; }

    int quad() const {
        return sign(y) ? sign(y) + (sign(y) > 0) : sign(x) - (sign(x) < 0);
    }

    struct paCmp {
        bool operator()(const P& p, const P& q) const {
            int x = p.quad(), y = q.quad();
            if (x != y) return x < y;
            const auto dt = p.det(q);
            return sign(dt) > 0;
        }
    };

    friend istream& operator>>(istream& is, P& p) {
        return is >> p.x >> p.y;
    }
    friend ostream& operator<<(ostream& os, const P& p) {
        return os << p.x << ' ' << p.y;
    }
};


_FT struct Line {
    _F(L, Line);
    _F(P, Point);

    P u, v;

    Line() = default;
    Line(P u, P v) : u(u), v(v) {}
    template <class U, class FU>
    explicit Line(const Line<U, FU>& l) : u(l.u), v(l.v) {}

    T cross(const P& p) const {  // uv.det(up)
        return (v.x - u.x) * (p.y - u.y) - (p.x - u.x) * (v.y - u.y);
    }
    int toLeft(const P& p) const { return sign(cross(p)); }

    FP getInter(const L& l) const {
        T c1 = l.cross(u), c2 = -l.cross(v);
        return (FP(u) * c2 + FP(v) * c1) / (c1 + c2);
    }

    struct paCmp {
        bool operator()(const L& l1, const L& l2) const {
            P d1 = l1.v - l1.u, d2 = l2.v - l2.u;
            if (sign(d1.det(d2)) == 0 && sign(d1.dot(d2)) >= 0)
                return l1.toLeft(l2.u) < 0;
            return typename P::paCmp()(d1, d2);
        }
    };
};


ll floor(ll x, ll y) {
    return x >= 0 ? x / y : (x + 1) / y - 1;
}

ll ceil(ll x, ll y) {
    return x <= 0 ? x / y : (x - 1) / y + 1;
}

_T ll euclid(T a, T b, T c, ll n) {
    if (n < 0) return -euclid(-a, b - a, c, -n);
    T p = floor(a, c), q = floor(b, c);
    if (p || q) {
        return n * (n - 1) / 2 * p + n * q +
               euclid(a - p * c, b - q * c, c, n);
    }
    ll m = a * n + b;
    return m < c ? 0 : euclid(c, T(m % c), a, m / c);
}

_T ll countHalfplaneInter(const vector<Line<T>>& l) {
    if (l.empty()) return 0;
    ll s = 0;
    vector<T> a, b, c;
    a.reserve(l.size());
    b.reserve(l.size());
    c.reserve(l.size());
    for (auto [u, v] : l) {
        a.emplace_back(v.y - u.y);
        b.emplace_back(u.x - v.x);
        c.emplace_back(u.x * -a.back() + u.y * -b.back());
    }
    int k = l.size() - 1;
    ll ux, uy, un,
       vx = 1ll * b[k] * c[0] - 1ll * b[0] * c[k],
       vy = 1ll * c[k] * a[0] - 1ll * c[0] * a[k],
       vn = a[k] * b[0] - a[0] * b[k];
    for (int i = 0; i < l.size(); i++) {
        int u = i - 1 >= 0 ? i - 1 : l.size() - 1,
            v = i + 1 < l.size() ? i + 1 : 0;
        ux = vx, uy = vy, un = vn,
        vx = 1ll * b[i] * c[v] - 1ll * b[v] * c[i],
        vy = 1ll * c[i] * a[v] - 1ll * c[v] * a[i],
        vn = a[i] * b[v] - a[v] * b[i];
        if (b[i] < 0)
            s -= euclid(a[i], c[i] - 1, -b[i], floor(vx, vn) + 1) -
                 euclid(a[i], c[i] - 1, -b[i], floor(ux - 1, un) + 1);
        if (b[i] > 0)
            s += euclid(-a[i], -c[i], b[i], floor(ux, un) + 1) -
                 euclid(-a[i], -c[i], b[i], floor(vx - 1, vn) + 1);
        if (b[i] < 0 && b[u] < 0 && ux % un == 0)
            s += floor(uy - 1, un);
        if (b[i] > 0 && b[v] > 0 && vx % vn == 0)
            s -= floor(vy, vn);
    }
    return s;
}

using P = Point<int>;
using L = Line<int>;

int cnt;
array<int, 2002> vis, prime, val;

void solve() {
    int n;
    cin >> n;
    vector<P> p(n);
    int V = 0;
    for (int i = 0; i < n; i++) {
        cin >> p[i];
        V = max({V, p[i].x, p[i].y});
    }
    reverse(p.begin(), p.end());

    vis[1] = 1;
    for (int i = 2; i <= V; i++) {
        if (!vis[i]) prime[++cnt] = i;
        for (int j = 1; j <= cnt && i * prime[j] <= V; j++)
            if (vis[i * prime[j]] = 0, i % prime[j] ==0) break;
    }

    vector<L> lll, q(100);

    for (int i = 0; i < n; i++) {
        lll.push_back({p[i], p[(i + 1) % n]});
    }

    sort(lll.begin(), lll.end(), L::paCmp());
    
    
    ll ans = 0;

    for (int xx = 1; xx <= V; xx++)
    {
        cnt = 0, vis.fill(0);
        vis[1]=1, val[1] = 1;
        for (int i = 2; i <= V; i++) {
            if (!vis[i]) val[i] = __gcd(xx, i);
            for (int j = 1; j <= cnt && i * prime[j] <= V; j++)
            {
                vis[i * prime[j]] = 1;
                if (i % prime[j] ==0) break;
                val[i * prime[j]] = val[i] * val[prime[j]];
            }
        }
        for (int yy = 1; yy <= V; yy++)
            if (val[yy] == 1)
                for (int x = xx, y = yy; x <= V && y <= V; x += xx, y += yy) {
                    auto l = lll;

                    auto halfplane = [&](vector<L>& l) {
                        auto check = [](const L& l1, const L& l2, const L& l3) {
                            return Line<db>(Point<db>(l1.u), Point<db>(l1.v)).toLeft(l2.getInter(l3)) < 0;
                        };
                        

                        vector<L> nw, nl;
                        auto mer = [&](P d) {
                            nl.clear();
                            for (int i = 0; i < n; i++) {
                                nl.push_back({lll[i].u - d, lll[i].v - d});
                            }
                            nw.resize(n + l.size());
                            merge(l.begin(), l.end(), nl.begin(), nl.end(), nw.begin(), L::paCmp());
                            swap(l, nw);
                        };
                        mer({x, y});
                        mer({-y, x});
                        mer({x - y, x + y});

                        // cout << l.size() << endl;
                        int st = 0, ed = -1;
                        for (int i = 0; i < l.size(); i++) {
                            P p = l[i].v - l[i].u;
                            if (i > 0 && (l[i - 1].v - l[i - 1].u).det(p) == 0 &&
                                sign((l[i - 1].v - l[i - 1].u).dot(p)) > 0)
                                continue;
                            while (ed > st && check(l[i], q[ed], q[ed - 1]))
                                ed--;
                            while (ed > st && check(l[i], q[st], q[st + 1]))
                                st++;
                            if (ed >= st && (q[ed].v - q[ed].u).det(p) <= 0)
                                return vector<L>{};
                            q[++ed] = l[i];
                        }
                        while (ed > st && check(q[st], q[ed], q[ed - 1]))
                            ed--;
                        while (ed > st && check(q[ed], q[st], q[st + 1]))
                            st++;
                        return vector<L>(q.begin() + st, q.begin() + ed + 1);
                    };



                    l = halfplane(l);

                    ll cnt = countHalfplaneInter(l);
                    if (!cnt) break;
                    ans += cnt;
                }
    }
    for (int x = 1, y = 0; x <= V; x++) {
        auto l = lll;

        auto halfplane = [&](vector<L>& l) {
            auto check = [](const L& l1, const L& l2, const L& l3) {
                return Line<db>(Point<db>(l1.u), Point<db>(l1.v)).toLeft(l2.getInter(l3)) < 0;
            };
            

            vector<L> nw, nl;
            auto mer = [&](P d) {
                nl.clear();
                for (int i = 0; i < n; i++) {
                    nl.push_back({lll[i].u - d, lll[i].v - d});
                }
                nw.resize(n + l.size());
                merge(l.begin(), l.end(), nl.begin(), nl.end(), nw.begin(), L::paCmp());
                swap(l, nw);
            };
            mer({x, y});
            mer({-y, x});
            mer({x - y, x + y});

            // cout << l.size() << endl;
            int st = 0, ed = -1;
            for (int i = 0; i < l.size(); i++) {
                P p = l[i].v - l[i].u;
                if (i > 0 && (l[i - 1].v - l[i - 1].u).det(p) == 0 &&
                    sign((l[i - 1].v - l[i - 1].u).dot(p)) > 0)
                    continue;
                while (ed > st && check(l[i], q[ed], q[ed - 1]))
                    ed--;
                while (ed > st && check(l[i], q[st], q[st + 1]))
                    st++;
                if (ed >= st && (q[ed].v - q[ed].u).det(p) <= 0)
                    return vector<L>{};
                q[++ed] = l[i];
            }
            while (ed > st && check(q[st], q[ed], q[ed - 1]))
                ed--;
            while (ed > st && check(q[ed], q[st], q[st + 1]))
                st++;
            return vector<L>(q.begin() + st, q.begin() + ed + 1);
        };



        l = halfplane(l);

        ll cnt = countHalfplaneInter(l);
        if (!cnt) break;
        ans += cnt;
    }
    cout << ans << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int tc = 1;
    // cin >> tc;
    while (tc--) {
        solve();
    }
    return 0;
}