#include <bits/stdc++.h>

#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)

#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)

#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}

using ll=long long;
using R=long double;
const R EPS=1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R& r){return(r > EPS)-(r < -EPS);}
inline R sq(R x){return sqrt(max(x,0.0L));}

const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};

// Problem Specific Parameter:
const ll inf=1LL<<40;
ll x[100010],y[100010];
ll nx[100010],ny[100010];

using edge=struct{int to;};
using G=vector<vector<edge>>;

void add_edge(G &graph,int from,int to){ 
	graph[from].push_back({to});
	graph[to].push_back({from});
}

using state=tuple<ll,ll,ll>;
ll n,d;

void making_edge(auto &graph,vector<state> &ary){
	vector<int> csum(n+1,0);

	//rep(i,n) cout << get<0>(ary[i]) << " " << get<1>(ary[i]) << endl;

	rep(i,n){
		ll cx,cy,idx;
		tie(cx,cy,idx)=ary[i];
		int lidx=lower_bound(_all(ary),state(cx+d,cy-d,-inf))-begin(ary);
		int uidx=upper_bound(_all(ary),state(cx+d,cy+d,inf))-begin(ary);
		if(lidx==uidx) continue;
		add_edge(graph,idx,get<2>(ary[lidx]));
		csum[lidx]++,csum[uidx-1]--;
		// cout << "Tar" << endl;
		// cout << cx << " " << cy << endl;
		// cout << get<0>(ary[lidx]) << " " << get<1>(ary[lidx]) << endl;
		// cout << get<0>(ary[uidx-1]) << " " << get<1>(ary[uidx-1]) << endl;
	}

	rep(i,1,n+1) csum[i]+=csum[i-1];
	rep(i,n) if(csum[i]>0) add_edge(graph,get<2>(ary[i]),get<2>(ary[i+1]));
}

int main(void){
	ll a,b;
	cin >> n >> a >> b;
	a--,b--;

	rep(i,n) cin >> x[i] >> y[i];
	d=abs(x[b]-x[a])+abs(y[b]-y[a]);

	{
		vector<ll> nx(n,0),ny(n,0);
		rep(i,n) nx[i]=x[i]-y[i],ny[i]=x[i]+y[i];
		rep(i,n) x[i]=nx[i],y[i]=ny[i];
	}

	G graph(n);

	vector<state> xyary,yxary;

	rep(i,n) xyary.push_back(state(x[i],y[i],i));
	sort(_all(xyary));
	making_edge(graph,xyary);
	
	rep(i,n) yxary.push_back(state(y[i],x[i],i));
	sort(_all(yxary));
	making_edge(graph,yxary);
	

	ll ans=0LL;

	{
		vector<int> visited(n,0);
		queue<int> q;
		visited[a]=true;
		q.push(a);

		xyary.clear();
		yxary.clear();
		while(!q.empty()){
			int v=q.front();q.pop();
			xyary.push_back(state(x[v],y[v],v));
			yxary.push_back(state(y[v],x[v],v));	
			for(auto &e:graph[v]){
				if(visited[e.to]) continue;
				visited[e.to]=1;
				q.push(e.to);
			}
		}
		sort(_all(xyary));
		sort(_all(yxary));
	}

	vector<int> visited(n,0);
	queue<int> q;
	visited[a]=true;
	q.push(a);

	
	while(!q.empty()){
		int v=q.front();q.pop();
		ans+=upper_bound(_all(xyary),state(x[v]+d,y[v]+d,inf))-lower_bound(_all(xyary),state(x[v]+d,y[v]-d,-inf));
		ans+=upper_bound(_all(yxary),state(y[v]+d,x[v]+d,inf))-lower_bound(_all(yxary),state(y[v]+d,x[v]-d,-inf));
		ans-=upper_bound(_all(yxary),state(y[v]+d,x[v]+d,inf))-lower_bound(_all(yxary),state(y[v]+d,x[v]+d,-inf));
		ans-=upper_bound(_all(yxary),state(y[v]-d,x[v]+d,inf))-lower_bound(_all(yxary),state(y[v]-d,x[v]+d,-inf));
		
		//cout << v << " " << x[v] << " " << y[v] << " "<< ans << endl;
		
		for(auto &e:graph[v]){
			if(visited[e.to]) continue;
			visited[e.to]=1;
			q.push(e.to);
		}
	}

	cout << ans << endl;
	return 0;
}

Measured memory_bytes: 15964