#include<map>
#include<set>
#include<bitset>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<stack>
#define REP(i,x,y) for(ll i=x;i<=y;i++)
#define SIZE(a) ll(a.size())
#define vll vector<ll> 
#define MEMSET(a, n, m) for(ll i=0;i<=n;i++) a[i] = m
#define BIT(n) (ll(1)<<n)
#define UNIQUE(v) v.erase(unique(v.begin(),v.end()),v.end()) 
#define UNIQUE_ARRAY(a,n) n = unique(a + 1, a + x + 1) - a - 1
#define SORT(a,n) sort(a+1,a+n+1)
#define SORT_O(a,n,order) sort(a+1,a+n+1,order)
#define PER(i,y,x) for(ll i=y;i>=x;i--)
typedef long long ll;
using namespace std;
/*
struct point
{
long long dist; long long name;
bool operator<(const point& rhs) const {
return dist > rhs.dist;
}
};
*/

struct point2 {
	ll x; ll y;
	bool operator<(const point2& rhs) const {
		if (x != rhs.x) {
			return x < rhs.x;
		}
		else return y < rhs.y;
	}

};

struct point1 {
	ll x; ll y;
	bool operator<(const point1& rhs) const {
		if (y != rhs.y) {
			return y < rhs.y;
		}
		else return x < rhs.x;
	}
};

set<point1> set1; set<point2> set2;
stack<point1> vis;
vector<point1> found1; vector<point2> found2;

point2 change12(point1 t) {
	return { t.x,t.y };
}

point1 change21(point2 t) {
	return { t.x,t.y };
}

point1 vert(point1 t,ll r, ll i,ll j) {
	return { t.x + r * i,t.y + r * j };
}

void fff(point1 p1, point1 p2, vector<point1> &v) {
	for (set<point1>::iterator it = set1.lower_bound(p1); it != set1.upper_bound(p2); it++) {
		v.push_back(*it);
	}
}

void ggg(point2 p1, point2 p2, vector<point1> &v) {
	for (set<point2>::iterator it = set2.upper_bound(p1); it != set2.lower_bound(p2); it++) {
		v.push_back(change21(*it));
	}
}

void tate(point1 cur, vector<point1>& v, ll dist) {
	point1 p1, p2, p3, p4;
	p1 = vert(cur, dist, -1, -1);
	p2 = vert(cur, dist, 1, -1);
	p3 = vert(cur, dist, -1, 1);
	p4 = vert(cur, dist, 1, 1);

	fff(p1, p2, v);
	fff(p3, p4, v);
	ggg(change12(p1), change12(p3), v);
	ggg(change12(p2), change12(p4), v);
}

void dfs(ll dist) {
	while (!vis.empty()) {
		point1 cur = vis.top();
		vis.pop();
		found1.push_back(cur);
		found2.push_back(change12(cur));
		vector<point1> v;
		tate(cur,v,dist);
		REP(i, 0, SIZE(v)-1) {
			point1 next = v[i];
			vis.push(next);
			set1.erase(next);
			set2.erase(change12(next));
		}
	}
}

bool order(point1 s, point1 t) {
	return s.x < t.x;
}

int main() {
	ll n, a, b;
	cin >> n >> a >> b;
	point1 start1, goal1;
	point2 start2, goal2;
	REP(i, 1, n) {
		ll e, f;
		cin >> e >> f;
		ll s, t;
		s = e + f;
		t = e - f;
		if (i == a) {
			start1 = { s,t };
			start2 = { s,t };
			vis.push(start1);
		}
		else if (i == b) {
			goal1 = { s,t };
			goal2 = { s,t };
			vis.push(goal1);
		}
		else {
			set1.insert({ s,t });
			set2.insert({ s,t });
		}
	}
	ll dist;
	dist = max(abs(goal1.x - start1.x), abs(goal1.y - start1.y));
	dfs(dist); // 
	sort(found1.begin(), found1.end());
	sort(found2.begin(), found2.end());
	ll ans = 0;
	REP(i, 0, SIZE(found1) - 1) {
		ans += lower_bound(found1.begin(), found1.end(), vert(found1[i], dist, 1, 1))
			- lower_bound(found1.begin(), found1.end(), vert(found1[i], dist, -1, 1));
		ans += upper_bound(found2.begin(), found2.end(), change12(vert(found1[i], dist, 1, 1)))
			- upper_bound(found2.begin(), found2.end(), change12(vert(found1[i], dist, 1, -1)));
	}
	cout << ans << endl;
}



Measured memory_bytes: 17968