#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

struct Pt
{
	LL x, y;
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
	Pt operator*(LL d) const
	{
		return {x * d, y * d};
	}
	Pt operator/(LL d) const
	{
		return {x / d, y / d};
	}
};

LL cross(const Pt& p, const Pt& q)
{
	return (LL)p.x * q.y - (LL)p.y * q.x;
}

Pt perp(const Pt& p)
{
	return {-p.y, p.x};
}

LL dot(const Pt& p, const Pt& q)
{
	return (LL)p.x * q.x + (LL)p.y * q.y;
}

struct Line
{
	Pt n;
	LL c;
	Line (const Pt& p, const Pt& q): n(perp(q - p)), c(-dot(n, p)) {}
};

bool parallel(const Line& l1, const Line& l2)
{
	return cross(l1.n, l2.n) == 0;
}

Pt inter(const Line& l1, const Line& l2)
{
	LL d = cross(l1.n, l2.n);
	Pt res = perp(l2.n * l1.c - l1.n * l2.c) / d;
	return res;
}

LL divFloor(LL p, LL q)
{
	assert(q > 0);
	LL res = p / q;
	while (res * q > p)
		res--;
	while ((res + 1) * q <= p)
		res++;
	return res;
}

// floor - EPS
LL f(LL p, LL q)
{
	if (q < 0)
	{
		p *= -1;
		q *= -1;
	}
	return divFloor(p - 1, q);
}

// ceil + EPS
LL g(LL p, LL q)
{
	if (q < 0)
	{
		p *= -1;
		q *= -1;
	}
	return divFloor(p, q) + 1;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin >> n;
	vector<Pt> v(n);
	for (Pt& p : v)
		cin >> p.x >> p.y;
	FOR(i, 0, n)
	{
		if (cross(v[(i + 1) % n] - v[i], v[(i + 3) % n] - v[(i + 2) % n]) < 0)
		{
			cout << "infinitely many\n";
			return 0;
		}
	}
	const int L = -6e6, R = 6e6;
	const int C = 5e6;
	LL ans = 0;
	bool inf = false;
	FOR(i, 0, n)
	{
		int mnX = R, mxX = L;
		Line l1 = {v[i], v[(i + 1) % n]}, l2 = {v[(i + 2) % n], v[(i + 1) % n]}, l3 = {v[(i + 2) % n], v[(i + 3) % n]};
		if (parallel(l1, l3))
		{
			mnX = L;
			mxX = R;
		}
		else
		{
			for (int x : {v[(i + 1) % n].x, v[(i + 2) % n].x, inter(l1, l3).x})
			{
				mnX = min(mnX, x - 4);
				mxX = max(mxX, x + 4);
			}
		}
		vector<Line> up, dwn;
		for (Line l : {l1, l2, l3})
		{
			if (l.n.y == 0)
			{
				int x = -l.c / l.n.x;
				if (l.n.x > 0)
				{
					mnX = max(mnX, x + 1);
				}
				else
				{
					mxX = min(mxX, x - 1);
				}
			}
			else if (l.n.y > 0)
			{
				up.PB(l);
			}
			else
			{
				dwn.PB(l);
			}
		}
		FOR(x, mnX, mxX + 1)
		{
			LL mnY = L, mxY = R;
			for (Line l : up)
			{
				mnY = max(mnY, g(-l.c - l.n.x * x, l.n.y));
			}
			for (Line l : dwn)
			{
				mxY = min(mxY, f(-l.c - l.n.x * x, l.n.y));
			}
			int dy = mxY - mnY + 1;
			if (dy > 0)
			{
				ans += dy;
				inf |= abs(x) > C || abs(mnY) > C || abs(mxY) > C;
			}
		}
		if (inf)
			break;
	}
	if (inf)
		cout << "infinitely many\n";
	else
		cout << ans << "\n";
	return 0;
}