#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) {}

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

    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}; }

    P rotateCc2() const { return {-y, x}; }

    T abs2() const { return x * x + y * y; }
    T distTo2(const P& p) const { return (*this - p).abs2(); }
    
    FT abs() const { return sqrt(FT(abs2())); }
    FT distTo(const P& p) const { return (*this - p).abs(); }

    friend istream& operator>>(istream& is, P& p) {
        long long x, y;
        is >> x >> y, p = P(x, y);
        return is;
    }
    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) {}

    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)); }

    FT distTo(const P& p) const {
        return fabs((v - u).det(p - u) / u.distTo(v));
    }
};

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

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

_T T exgcd(T a, T b, T& x, T& y) {
    if (b == 0) {
        x = 1, y = 0;
        return a;
    }
    ll d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}

_T T euclid(T a, T b, T c, T 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);
    T m = a * n + b;
    return m < c ? 0 : euclid(c, m % c, a, m / c);
}


_T T countLine(T A, T B, T C, T x1, T x2, T y1, T y2) {
    if (x1 > x2 || y1 > y2) return 0;
    C = -C;
    assert(A || B);
    if (A < 0) tie(x1, x2) = make_pair(-x2, -x1), A = -A;
    if (B < 0) tie(y1, y2) = make_pair(-y2, -y1), B = -B;
    T x, y;
    T d = exgcd(A, B, x, y);
    if (C % d != 0) {
        return 0;
    }
    if (!A) return x2 - x1 + 1;
    if (!B) return y2 - y1 + 1;
    A /= d, B /= d, C /= d;
    x = x * (C % B) % B;
    y = (C - A * x) / B;
    T l = max(ceil(x1 - x, B), ceil(y - y2, A));
    T r = min(floor(x2 - x, B), floor(y - y1, A));
    return max(T(0), r - l + 1);
}


_T T count(const vector<Line<T>>& l) {
    T s = 0;
    vector<T> a, b, c;
    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());
    }
    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;
        T ux = b[u] * c[i] - b[i] * c[u],
          uy = c[u] * a[i] - c[i] * a[u],
          un = a[u] * b[i] - a[i] * b[u],
          vx = b[i] * c[v] - b[v] * c[i],
          vy = c[i] * a[v] - c[v] * a[i],
          vn = a[i] * b[v] - a[v] * b[i];
        T x1, x2, y1, y2;
        if (a[i] > 0) {
            y1 = ceil(uy, un), y2 = floor(vy, vn);
        } else {
            y1 = ceil(vy, vn), y2 = floor(uy, un); 
        }
        if (b[i] < 0) {
            x1 = ceil(ux, un), x2 = floor(vx, vn);
            s -= euclid(a[i], c[i] - 1, -b[i], x2 + 1) -
                 euclid(a[i], c[i] - 1, -b[i], x1);
        } else {
            x1 = ceil(vx, vn), x2 = floor(ux, un);
            if (b[i] > 0) {
                s += euclid(-a[i], -c[i], b[i], x2 + 1) -
                    euclid(-a[i], -c[i], b[i], x1);
            }
        }
        s -= countLine(a[i], b[i], c[i], x1, x2, y1, y2);
        if (ux % un == 0 && uy % un == 0) s++;
        
        if (b[i] < 0 && b[u] < 0 && ux % un == 0)
            s += ceil(uy, un) - 1;
        if (b[i] > 0 && b[v] > 0 && vx % vn == 0)
            s -= floor(vy, vn);
    }
    return s;
}

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


void solve() {
    int n;
    cin >> n;
    vector<P> p(n);
    for (int i = 0; i < n; i++) {
        cin >> p[i];
    }

    long long ans = 0;
    for (int i = 0; i < n; i++) {
        P a = p[i % n], b = p[(i + 1) % n], c = p[(i + 2) % n], d = p[(i + 3) % n];
        // cout << i << endl;
        if ((b - a).det(d - c) < 0) {
            cout << "infinitely many" << endl;
            return;
        } else if ((b - a).det(d - c) == 0) {
            if (cmp(L(a, b).distTo(c), 1.0) > 0) {
                cout << "infinitely many" << endl;
                return;
            }
            if (a.x == b.x || a.y == b.y) continue;
            if (b.x == c.x) {
                if (abs((ll)a.x - (ll)b.x) == 1) continue;
            }
            if (b.y == c.y) {
                if (abs((ll)a.y - (ll)b.y) == 1) continue;
            }
            cout << "infinitely many" << endl;
            return;
        } else {
            vector<L> l;
            l.push_back({a, b});
            l.push_back({c, d});
            l.push_back({c, b});
            ans += count(l);
        }
        cout << ans << endl;
    }
    cout << ans << endl;
}


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