#include<map>
#include<stack>
#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<string.h>
using namespace std;

typedef long long LL;
typedef vector<int> VI;

#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define EACH(i,c) for(__typeof((c).begin()) i=(c).begin(),i##_end=(c).end();i!=i##_end;++i)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)

template<class T> inline void amin(T &x, const T &y) { if (y<x) x=y; }
template<class T> inline void amax(T &x, const T &y) { if (x<y) x=y; }
template<class Iter> void rprintf(const char *fmt, Iter begin, Iter end) {
    for (bool sp=0; begin!=end; ++begin) { if (sp) putchar(' '); else sp = true; printf(fmt, *begin); }
    putchar('\n');
}

int N, A, B;
LL X[100111], Y[100111];
LL D;

struct Data {
    int id;
    int cnt;
    Data() {}
    Data(int id_, int cnt_) : id(id_), cnt(cnt_) {}
};
typedef map<LL, Data> mapD;
typedef map<LL, mapD> mapM;
mapM fromX, fromY;
map<LL, map<LL, int> > fromXid, fromYid;

void erase_point(int v) {
    auto it = fromXid.find(X[v]);
    it->second.erase(Y[v]);
    it = fromYid.find(Y[v]);
    it->second.erase(X[v]);
}

bool use[100111];
int ans[100111];

int main() {
    scanf("%d%d%d", &N, &A, &B);
    A--; B--;
    REP (i, N) {
	int x, y;
	scanf("%d%d", &x, &y);
	X[i] = x + y;
	Y[i] = x - y;
    }

    D = max(abs(X[A] - X[B]), abs(Y[A] - Y[B]));

    REP (i, N) {
	fromX[X[i]][Y[i]] = Data(i, 0);
	fromY[Y[i]][X[i]] = Data(i, 0);
	if (i != A) {
	    fromXid[X[i]][Y[i]] = i;
	    fromYid[Y[i]][X[i]] = i;
	}
    }

    stack<int> S; S.push(A);
    while (!S.empty()) {
	int v = S.top(); S.pop();

	if (1) {
	    auto it = fromX.find(X[v] + D);
	    if (it != fromX.end()) {
		mapD &ref = it->second;
		auto f = ref.lower_bound(Y[v] - D);
		if (f != ref.end()) f->second.cnt++;
		f = ref.lower_bound(Y[v] + D);
		if (f != ref.end()) f->second.cnt--;
	    }

	    it = fromX.find(X[v] - D);
	    if (it != fromX.end()) {
		mapD &ref = it->second;
		auto f = ref.upper_bound(Y[v] - D);
		if (f != ref.end()) f->second.cnt++;
		f = ref.upper_bound(Y[v] + D);
		if (f != ref.end()) f->second.cnt--;
	    }
	    ////
	    it = fromY.find(Y[v] - D);
	    if (it != fromY.end()) {
		mapD &ref = it->second;
		auto f = ref.lower_bound(X[v] - D);
		if (f != ref.end()) f->second.cnt++;
		f = ref.lower_bound(X[v] + D);
		if (f != ref.end()) f->second.cnt--;
	    }

	    it = fromY.find(Y[v] + D);
	    if (it != fromY.end()) {
		mapD &ref = it->second;
		auto f = ref.upper_bound(X[v] - D);
		if (f != ref.end()) f->second.cnt++;
		f = ref.upper_bound(X[v] + D);
		if (f != ref.end()) f->second.cnt--;
	    }
	}

	REP (k, 2) {
	    auto &from = (k? fromXid: fromYid);
	    LL x = (k? X[v]: Y[v]);
	    LL y = (k? Y[v]: X[v]);
	    REP (t, 2) {
		auto it = from.find(x + (t? D: -D));
		if (it != from.end()) {
		    auto &ref = it->second;
		    auto f = ref.lower_bound(y - D);
		    while (f != ref.end() && f->first <= y + D) {
			int w = f->second;
			S.push(w);
			f++;
			erase_point(w);
		    }
		}
	    }
	}


//	REP (i, N) {
//	    if (i != v && D == max(abs(X[v] - X[i]), abs(Y[v] - Y[i]))) {
//		ans[v]++;
//		if (!use[i]) {
//		    S.push(i);
//		    use[i] = true;
//		}
//	    }
//	}
    }

    EACH (e, fromX) {
	auto &ref = e->second;
	LL acc = 0;
	EACH (f, ref) {
	    acc += f->second.cnt;
	    ans[f->second.id] += acc;
	}
    }
    EACH (e, fromY) {
	auto &ref = e->second;
	LL acc = 0;
	EACH (f, ref) {
	    acc += f->second.cnt;
	    ans[f->second.id] += acc;
	}
    }

    LL sum = 0;
    REP (i, N) sum += ans[i];
//    eprintf("%lld\n", sum);
    printf("%lld\n", sum / 2);

    return 0;
}



Measured memory_bytes: 59648