#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
{
	int x, y;
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
};

int sq(const Pt& p)
{
	return p.x * p.x + p.y * p.y;
}

int sgn(int x)
{
	return (0 < x) - (x < 0);
}

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

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

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

int orient(const Pt& p, const Pt& q, const Pt& r)
{
	return cross(q - p, r - p);
}

bool half(const Pt& p)
{
	assert(sgn(p.x) != 0 || sgn(p.y) != 0);
	return sgn(p.y) == -1 ||
		(sgn(p.y) == 0 && sgn(p.x) == -1);
}

void polarSortAround(const Pt& o, vector<pair<Pt, int>>& v)
{
	sort(ALL(v), [o](pair<Pt, int> pp, pair<Pt, int> qq)
	{
		Pt p = pp.F - o, q = qq.F - o;
		bool hp = half(p), hq = half(q);
		if (hp != hq)
			return hp < hq;
		int s = sgn(cross(p, q));
		if (s != 0)
			return s == 1;
		return sq(p) < sq(q);
	});
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin >> n;
	Pt o;
	cin >> o.x >> o.y;
	vector<pair<Pt, int>> v;
	int cntEq = 0;
	FOR(i, 1, n)
	{
		Pt p;
		cin >> p.x >> p.y;
		p = p - o;
		if (p.x == 0 && p.y == 0)
			cntEq++;
		else
		{
			v.PB({p, 1});
			v.PB({{-p.x, -p.y}, 0});
		}
	}
	v.PB({{1, 0}, 0});
	v.PB({{0, 1}, 0});
	v.PB({{-1, 0}, 0});
	v.PB({{0, -1}, 0});
	for (auto& [p, c] : v)
		p = perp(p);
	polarSortAround({0, 0}, v);
	n = SZ(v);
	VI pref(3 * n + 47);
	FOR(i, 0, SZ(pref) - 1)
		pref[i + 1] = pref[i] + v[i % n].S;
	int st = -1;
	int mn = n + 47, mx = 0;
	int ptr1 = 0, ptr2 = 0, ptr3 = 0;
	FOR(i, 0, n)
	{
		Pt p = v[i].F;
		if (p.x < 0 || p.y < 0)
			break;
		ptr1 = max(ptr1, st + i);
		while (cross(p, v[ptr1 % n].F) == 0 && dot(p, v[ptr1 % n].F) > 0 && ptr1 < n + i)
			ptr1++;
		ptr2 = max(ptr2, ptr1);
		while (cross(p, v[ptr2 % n].F) > 0)
			ptr2++;
		ptr3 = max(ptr3, ptr2);
		while (cross(p, v[ptr3 % n].F) == 0 && dot(p, v[ptr3 % n].F) < 0)
			ptr3++;
		mn = min(mn, pref[ptr2] - pref[ptr1]);
		mx = max(mx, pref[ptr3] - pref[i]);
	}
	mx += cntEq;
	cout << mn + 1 << " " << mx + 1 << "\n";
	return 0;
	
}