#ifndef LOCAL
#pragma GCC optimize("O3")
#endif
#include <bits/stdc++.h>
using namespace std;
#define sim template <class c
#define mor > muu & operator<<(
#define ris return *this
#define eni(r) sim> typename enable_if <1 r sizeof(dud<c>(0)),muu&>::type operator<<(c g) {
sim> struct rge {c b,e ;};
sim> rge<c> range(c i, c j) {return rge<c>{i, j};}
sim> auto dud(c *r)-> decltype(cerr << *r);
sim> char dud(...);
struct muu {
	#ifdef LOCAL
	stringstream a;
	~muu() {cerr << a.str() << endl;}
	eni(<) a << boolalpha << g; ris;}
	eni(==) ris << range(begin(g), end(g));}
	sim, class m mor pair<m,c> r) {ris << "(" << r.first << ", " << r.second << ")";}
	sim mor rge<c> u) {
		a << "[";
		for (c i = u.b; i != u.e; ++i)
			*this << ", " + 2 * (i == u.b) << *i;
		ris << "]";
	}
	#else
	sim mor const c&) {ris;}
	#endif
	muu & operator()(){ris;}
};
#define debug (muu() << __FUNCTION__ << "#" << __LINE__ << ": ")
#define imie(r) "[" #r ": " << (r) << "] "
#define imask(r) "[" #r ": " << bitset<8 * sizeof(r)>(r) << "] "
#define arr(a, i) "[" #a imie(i) ": " << a[i] << "] "
#define arr2(a, i, j) "[" #a imie(i) imie(j) ": " << a[i][j] << "] "

using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
const int nax=107;
using ld=long double;
using pdd=pair<ld,ld>;
const ld eps=1e-9;

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld iloska(pdd a, pdd b)
{
	return a.first*b.first+a.second*b.second;
}

ld ilowek(pdd a, pdd b)
{
	return a.first*b.second-a.second*b.first;
}

ld dlu2(pdd v)
{
	return iloska(v, v);
}

ld dlu(pdd v)
{
	return sqrt(dlu2(v));
}

pdd reflect(pdd a, pdd b, pdd s)
{
	b = b - a;
	s = s - a;
	pdd rzut = s - b * (iloska(s, b) / iloska(b, b));
	return a + s - rzut * 2.0;
}

bool iszero(ld v)
{
	return abs(v)<eps;
}

bool iszero(pdd v)
{
	return iszero(v.first) && iszero(v.second);
}

int n;
pdd sta, kon;

pair <pdd,pdd> pro[nax];

vector <pdd> to_check;
int wyn;

pdd read()
{
	int a, b;
	scanf("%d%d", &a, &b);
	return {a, b};
}

void rek(vector < pair<pdd,pdd> > wek, pdd cel)
{
	debug() << wek << " " << cel;
	if (!iszero(cel))
	{
		to_check.push_back(cel/dlu(cel));
	}
	for (int i=0; i<(int)wek.size(); i++)
	{
		vector <pair<pdd,pdd> > trz;
		pdd nowcel=reflect(wek[i].first, wek[i].second, cel);
		for (int j=0; j<(int)wek.size(); j++)
		{
			if (i==j)
				continue;
			trz.push_back({reflect(wek[i].first, wek[i].second, wek[j].first), reflect(wek[i].first, wek[i].second, wek[j].second)});
		}
		rek(trz, nowcel);
	}
}

ld dist(pdd a, pdd b, pdd x, pdd y) {
	pdd xy = x - y;
	pdd v = b - a;
	pdd xa = x - a;
	ld den = xy.first * v.second - xy.second * v.first;
	if (iszero(den)) return -69;
	return (xy.first * xa.second - xy.second * xa.first) / den;
}

ld trafia(pdd a, pdd b, pdd g) {
	if (!iszero(ilowek(b - a, g - a)))
		return -1410;
	return iloska(g - a, b - a) / iloska(b - a, b - a);
}

void solve(pdd v, vector < pair<pdd,pdd> > wek)
{
	pdd sta={0, 0};
	debug() << "pacze " << v;
	while(1)
	{
		debug() << sta << " " << v << " " << wek;
		vector <pair<ld,int> > eve;
		for (int i=0; i<(int)wek.size(); i++)
		{
			ld x=dist(sta, v, wek[i].first, wek[i].second);
			if (x>0)
				eve.push_back({x, i});
		}
		
		ld x=trafia(sta, v, kon);
		if (x>0)
			eve.push_back({x, -1});
		
		//tutaj
		
		sort(eve.begin(), eve.end());
		if (eve.empty())
			break;
		if (eve[0].second==-1)
		{
			wyn++;
			debug() << "tak";
			break;
		}
		if ((int)eve.size()>1 && iszero(eve[0].first-eve[1].first))
			break;
		ld w=eve[0].first;
		int j=eve[0].second;
		pdd nsta=sta+(v-sta)*w;
		pdd nv=v+(v-sta)*w;
		sta=nsta;
		v=reflect(wek[j].first, wek[j].second, nv);
		swap(wek[j], wek.back());
		wek.pop_back();
	}
}

int main()
{
	scanf("%d", &n);
	sta=read();
	kon=read();
	kon=kon-sta;
	for (int i=0; i<n; i++)
	{
		pro[i].first=read();
		pro[i].second=read();
		pro[i].first=pro[i].first-sta;
		pro[i].second=pro[i].second-sta;
	}
	
	vector < pair<pdd,pdd> > daj;
	for (int i=0; i<n; i++)
		daj.push_back(pro[i]);
	rek(daj, kon);
	
	auto pom=to_check;
	to_check.clear();
	sort(pom.begin(), pom.end());
	debug() << pom;
	for (pdd i : pom)
	{
		int czy=1;
		for (int j=1; j<=(int)to_check.size() && j<=5; j++)
			if (iszero(i-to_check[(int)to_check.size()-j]))
				czy=0;
		if (czy)
			to_check.push_back(i);
	}
	debug() << to_check;
	for (pdd i : to_check)
		solve(i, daj);
	
	printf("%d\n", wyn);
	return 0;
}