/* ECNA/NENA 2023 */
/* C - Convex Hull Extension */
#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}; }
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) {}
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)); }
};
_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)
{
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);
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;
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());
}
T ux, uy, un,
vx = b[k] * c[0] - b[0] * c[k],
vy = c[k] * a[0] - 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 = 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;
}
_T bool checkTwoLine(Point<T> a, Point<T> b, Point<T> c, Point<T> d) {
T dx = abs(b.x - a.x), dy = abs(b.y - a.y);
T g = __gcd(dx, dy);
dx /= g, dy /= g;
if (dx <= 1) {
auto e = b + Point<T>(0, 1);
if (Line<T>(e, e + b - a).toLeft(c) == 0) return 0;
e = b + Point<T>(0, -1);
if (Line<T>(e, e + b - a).toLeft(c) == 0) return 0;
}
if (dy <= 1) {
auto e = b + Point<T>(1, 0);
if (Line<T>(e, e + b - a).toLeft(c) == 0) return 0;
e = b + Point<T>(-1, 0);
if (Line<T>(e, e + b - a).toLeft(c) == 0) return 0;
}
return 1;
}
using P = Point<long long>;
using L = Line<long long>;
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];
int sgn = sign((b - a).det(d - c));
if (sgn <= 0) {
if (sgn < 0 || checkTwoLine(a, b, c, d)) {
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;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tc = 1;
// cin >> tc;
while (tc--) {
solve();
}
return 0;
}