#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<bitset>
#include<map>

#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)

using namespace std;

typedef long long LL;
typedef double db;

int get(){
	char ch;
	while(ch=getchar(),(ch<'0'||ch>'9')&&ch!='-');
	if (ch=='-'){
		int s=0;
		while(ch=getchar(),ch>='0'&&ch<='9')s=s*10+ch-'0';
		return -s;
	}
	int s=ch-'0';
	while(ch=getchar(),ch>='0'&&ch<='9')s=s*10+ch-'0';
	return s;
}

const int N = 1e+5+5;

int n,A,B;
struct point{
	int x,y;
	point(const int x_=0,const int y_=0){x=x_;y=y_;}
	void init(){x=get();y=get();}
}a[N];
map<int,int>idx,idy;
int kx,ky;
set<int>sx[N],sy[N];
map<int,int>tx[N],ty[N];
int ans;
int D;
struct node{
	int tot,l,r;
}tree[N*35];
int rtx[N],rty[N],tot;

void add(int &now,int l,int r,int x,int v){
	if (!now)now=++tot;
	tree[now].tot+=v;
	if (l==r)return;
	int mid=(l+r)/2;
	if (x<=mid)add(tree[now].l,l,mid,x,v);
	else add(tree[now].r,mid+1,r,x,v);
}

int gettot(int now,int l,int r,int x,int y){
	if (!now)return 0;
	if (x<=l&&r<=y)return tree[now].tot;
	int mid=(l+r)/2,cnt=0;
	if (x<=mid)cnt=gettot(tree[now].l,l,mid,x,y);
	if (y>mid)cnt+=gettot(tree[now].r,mid+1,r,x,y);
	return cnt;
}

int cnt[N];

void calc(int now){
	point u=a[now];
	
	if (idx[u.x-D]){
		int w=idx[u.x-D];
		set<int>::iterator p1=sx[w].upper_bound(u.y-D),p2=sx[w].upper_bound(u.y+D);
		if (p1!=p2){p2--;int l=idy[*p1],r=idy[*p2];cnt[now]+=gettot(rtx[w],1,n,l,r);}
	}
	
	if (idx[u.x+D]){
		int w=idx[u.x+D];
		set<int>::iterator p1=sx[w].lower_bound(u.y-D),p2=sx[w].lower_bound(u.y+D);
		if (p1!=p2){p2--;int l=idy[*p1],r=idy[*p2];cnt[now]+=gettot(rtx[w],1,n,l,r);}
	}
	
	if (idy[u.y-D]){
		int w=idy[u.y-D];
		set<int>::iterator p1=sy[w].lower_bound(u.x-D),p2=sy[w].lower_bound(u.x+D);
		if (p1!=p2){p2--;int l=idx[*p1],r=idx[*p2];cnt[now]+=gettot(rty[w],1,n,l,r);}
	}
	
	if (idy[u.y+D]){
		int w=idy[u.y+D];
		set<int>::iterator p1=sy[w].upper_bound(u.x-D),p2=sy[w].upper_bound(u.x+D);
		if (p1!=p2){p2--;int l=idx[*p1],r=idx[*p2];cnt[now]+=gettot(rty[w],1,n,l,r);}
	}
}

int numx[N],numy[N];
bool vis[N];
int que[N];
int he,ta;

void pushback(int now){
	sx[idx[a[now].x]].erase(a[now].y);
	sy[idy[a[now].y]].erase(a[now].x);
	vis[now]=1;
	que[++ta]=now;
}

void bfs(){
	he=0,ta=0;
	pushback(A);
	while(he<ta){
		int now=que[++he];
		point u=a[now];
		if (idx[u.x-D]){
			int w=idx[u.x-D];
			set<int>::iterator p1,p2;
			p1=sx[w].upper_bound(u.y-D);
			p2=sx[w].upper_bound(u.y+D);
			if (p1!=p2){
				p2--;
				int l=idy[*p1],r=idy[*p2];
				while(p1!=sx[w].end()&&(*p1)<=u.y+D){
					pushback(tx[w][(*p1)]);
					p1=sx[w].upper_bound(u.y-D);
				}
			}
		}
		
		if (idx[u.x+D]){
			int w=idx[u.x+D];
			set<int>::iterator p1,p2;
			p1=sx[w].lower_bound(u.y-D);
			p2=sx[w].lower_bound(u.y+D);
			if (p1!=p2){
				p2--;
				int l=idy[*p1],r=idy[*p2];
				while(p1!=sx[w].end()&&(*p1)<u.y+D){
					pushback(tx[w][*p1]);
					p1=sx[w].lower_bound(u.y-D);
				}
			}
		}
		
		if (idy[u.y-D]){
			int w=idy[u.y-D];
			set<int>::iterator p1=sy[w].lower_bound(u.x-D),p2=sy[w].lower_bound(u.x+D);
			if (p1!=p2){
				p2--;
				int l=idx[*p1],r=idx[*p2];
				while(p1!=sy[w].end()&&(*p1)<u.x+D){
					pushback(ty[w][*p1]);
					p1=sy[w].lower_bound(u.x-D);
				}
			}
		}
		
		if (idy[u.y+D]){
			int w=idy[u.y+D];
			set<int>::iterator p1=sy[w].upper_bound(u.x-D),p2=sy[w].upper_bound(u.x+D);
			if (p1!=p2){
				p2--;
				int l=idx[*p1],r=idx[*p2];
				while(p1!=sy[w].end()&&(*p1)<=u.x+D){
					pushback(ty[w][*p1]);
					p1=sy[w].upper_bound(u.x-D);
				}
			}
		}
	}
}

int main(){
	n=get();A=get();B=get();
	fo(i,1,n){
		a[i].init();
		a[i]=point(a[i].x+a[i].y,a[i].x-a[i].y);
		numx[i]=a[i].x;numy[i]=a[i].y;
	}
	D=max(abs(a[A].x-a[B].x),abs(a[A].y-a[B].y));
	sort(numx+1,numx+1+n);sort(numy+1,numy+1+n);
	fo(i,1,n){
		if (!idx[numx[i]])idx[numx[i]]=++kx;
		if (!idy[numy[i]])idy[numy[i]]=++ky;
	}
	fo(i,1,n){
		tx[idx[a[i].x]][a[i].y]=i;
		ty[idy[a[i].y]][a[i].x]=i;
		sx[idx[a[i].x]].insert(a[i].y);
		sy[idy[a[i].y]].insert(a[i].x);
		add(rtx[idx[a[i].x]],1,n,idy[a[i].y],1);
		add(rty[idy[a[i].y]],1,n,idx[a[i].x],1);
	}
	LL ans=0;
	fo(i,1,n)calc(i);
	bfs();
	fo(i,1,n)
	if (vis[i])ans=ans+cnt[i];
	printf("%lld\n",ans/2);
	return 0;
}

Measured memory_bytes: 99456