#include<bits/stdc++.h>
using namespace std;

#define int long long
using db = double;

const db eps = 1e-9;
int sgn(db a) {
    if(a > eps) return 1;
    else if(a < -eps) return -1;
    else return 0;
}
// a < b : -1 | a == b : 0 | a > b : 1
int cmp(db a, db b) {
    return sgn(a - b);
}
// x in [a, b]
bool inmid(db x, db a, db b) {
    return sgn(x - a) * sgn(x - b) <= 0;
}

//点
struct point {
    db x, y;
    point operator + (const point &p) const {
        return {x + p.x, y + p.y};
    }
    point operator - (const point &p) const {
        return {x - p.x, y - p.y};
    }
    point operator * (db k) const {
        return {k * x , k * y};
    }
    point operator / (db k) const {
        return {x / k , y / k};
    }
    friend istream &operator >> (istream &is, point &p) {
        return is >> p.x >> p.y;
    }
    friend ostream &operator << (ostream &os, point &p) {
        return os << p.x << " " << p.y;
    }
    
};
db cross(point a, point b) {
    return a.x * b.y - a.y * b.x;
}
bool inmid(point p, point a, point b) {
    return inmid(p.x, a.x, b.x) && inmid(p.y, a.y, b.y);
}
point getLL(point a, point b, point c, point d) {
    db w1 = cross(a - c, d - c), w2 = cross(d - c, b - c);
    return (a * w2 + b * w1) / (w1 + w2);
}
int calc(db l, db r) {
    if (cmp(l, r) == 1) {
        swap(l, r);
    }
    int L = ceil(l), R = floor(r);
    if (cmp(L, l) == 0) {
        L++;
    }
    if (cmp(R, r) == 0) {
        R--;
    }
    return max(0ll, R - L + 1);
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    vector<point> A(n);
    for (int i = 0; i < n; i++) {
        cin >> A[i];
    }
    auto check = [&] (point a, point b, point c, point d) -> bool {
        if (sgn(cross(a - b, c - d)) == 1) {
            return 1;
        }
        if (sgn(cross(a - b, c - d)) == 0) {
            if (cmp(a.x, b.x) == 0) {
                if (!calc(a.x, c.x)) {
                    return 0;
                }
                return 1;   
            } else {
                bool ok = 0;
                for (int X = 1; X <= 1000000; X++) {
                    point p1 = getLL(a, b, {X, 0}, {X, 1});
                    point p2 = getLL(c, d, {X, 0}, {X, 1});
                    if (calc(p1.y, p2.y)) {
                        ok = 1;
                        break;
                    }
                }
                return ok;
            }
        }
        return 0;
    };
    auto work = [&] (array<point, 3> S, int a) {
        db l = 1e100, r = -1e100;
        for (int i = 0; i < 3; i++) {
            point p1 = S[i], p2 = S[(i + 1) % 3];
            point c = getLL(p1, p2, {a, 0}, {a, 1});
            if (inmid(c, p1, p2)) {
                l = min(l, c.y);
                r = max(r, c.y);
            }
        }
        return calc(l, r);
    };
    int ans = 0;
    for (int i = 0; i < n; i++) {
        point p1 = A[i], p2 = A[(i + n - 1) % n], q1 = A[(i + 1) % n], q2 = A[(i + 2) % n];
        if (check(p1, p2, q1, q2)) {
            cout << "infinitely many\n";
            return 0;
        }
        if (sgn(cross(p2 - p1, q2 - q1)) != 0) {
            point m = getLL(p1, p2, q1, q2);
            array<point, 3> s{p1, m, q1};
            db l = 1e100, r = -1e100;
            for (auto p : s) {
                l = min(l, p.x);
                r = max(r, p.x);
            }
            if (cmp(l, r) == 1) {
                swap(l, r);
            }
            int L = ceil(l), R = floor(r);
            if (cmp(L, l) == 0) {
                L++;
            }
            if (cmp(R, r) == 0) {
                R--;
            }
            for (int X = L; X <= R; X++) {
                ans += work(s, X);
            }
        }   
    }
    cout << ans << "\n";
    return 0;
}