/**
 *    author:  otera    
**/
#include<iostream>
#include<string> 
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm> 
#include<functional>
#include<iomanip>
#include<queue>
#include<deque>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;

#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
const int inf=1e9+7;
const ll INF=1LL<<60 ;
const ll mod=1e9+7 ;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<int, int> P;
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
#define debug(x)  cerr << #x << " = " << (x) << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

int n, a, b;
vector<int> vx, vy;
map<P, int> mp;

int d, res;
vector<bool> seen;
vector<int> deg;
map<int, set<int>> mpx, mpy;
map<int, vector<int>> vecx, vecy;

void dfs(int v) {
    seen[v] = 1;
    res += deg[v];
    vector<int> nxt;
    for(auto ite = mpx[vx[v] + d].lower_bound(vy[v] - d); ite != mpx[vx[v] + d].end() and *ite <= vy[v] + d; ite = mpx[vx[v] + d].erase(ite)) {
        nxt.push_back(mp[P{vx[v] + d, *ite}]);
        mpy[*ite].erase(vx[v] + d);
    }
    for(auto ite = mpx[vx[v] - d].lower_bound(vy[v] - d); ite != mpx[vx[v] - d].end() and *ite <= vy[v] + d; ite = mpx[vx[v] - d].erase(ite)) {
        nxt.push_back(mp[P{vx[v] - d, *ite}]);
        mpy[*ite].erase(vx[v] - d);
    }
    for(auto ite = mpy[vy[v] + d].lower_bound(vx[v] - d); ite != mpy[vy[v] + d].end() and *ite <= vx[v] + d; ite = mpy[vy[v] + d].erase(ite)) {
        nxt.push_back(mp[P{*ite, vy[v] + d}]);
        mpx[*ite].erase(vy[v] + d);
    }
    for(auto ite = mpy[vy[v] - d].lower_bound(vx[v] - d); ite != mpy[vy[v] - d].end() and *ite <= vx[v] + d; ite = mpy[vy[v] - d].erase(ite)) {
        nxt.push_back(mp[P{*ite, vy[v] - d}]);
        mpx[*ite].erase(vy[v] - d);
    }
    for(int nv: nxt) if(!seen[nv]) dfs(nv);
}

void solve() {
	cin >> n >> a >> b;
    -- a, -- b;
    vx.resize(n), vy.resize(n);
    rep(i, n) {
        int x, y; cin >> x >> y;
        vx[i] = x + y, vy[i] = x - y;
        mp[P{x + y, x - y}] = i;
        mpx[vx[i]].insert(vy[i]);
        mpy[vy[i]].insert(vx[i]);
        vecx[vx[i]].push_back(vy[i]);
        vecy[vy[i]].push_back(vx[i]);
    }
    for(auto &p: vecx) sort(all(p.sc));
    for(auto &p: vecy) sort(all(p.sc));
    d = max(abs(vx[a] - vx[b]), abs(vy[a] - vy[b]));
    deg.assign(n, 0);
    rep(i, n) {
        deg[i] += upper_bound(all(vecx[vx[i] + d]), vy[i] + d) - lower_bound(all(vecx[vx[i] + d]), vy[i] - d);
        deg[i] += upper_bound(all(vecx[vx[i] - d]), vy[i] + d) - lower_bound(all(vecx[vx[i] - d]), vy[i] - d);
        deg[i] += upper_bound(all(vecy[vy[i] + d]), vx[i] + d) - lower_bound(all(vecy[vy[i] + d]), vx[i] - d);
        deg[i] += upper_bound(all(vecy[vy[i] - d]), vx[i] + d) - lower_bound(all(vecy[vy[i] - d]), vx[i] - d);
        if(mp.count(P{vx[i] - d, vy[i] - d})) -- deg[i];
        if(mp.count(P{vx[i] - d, vy[i] + d})) -- deg[i];
        if(mp.count(P{vx[i] + d, vy[i] + d})) -- deg[i];
        if(mp.count(P{vx[i] + d, vy[i] - d})) -- deg[i];
    }
    res = 0;
    seen.assign(n, 0);
    dfs(a);
    cout << res / 2 << endl;
}

signed main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	//cout << fixed << setprecision(10);
	//int t; cin >> t; rep(i, t)solve();
	solve();
    return 0;
}

Measured memory_bytes: 96024