#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T,class U> using P = pair<T,U>;
template<class T> using vec = vector<T>;
template<class T> using vvec = vector<vec<T>>;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N,A,B,D;
    cin >> N >> A >> B;
    A--,B--;
    map<int,set<P<int,int>>> mps,mms;
    map<int,vec<P<int,int>>> mpv,mmv;
    vec<int> X(N),Y(N);
    for(int i=0;i<N;i++){
        int x,y;
        cin >> x >> y;
        X[i] = x,Y[i] = y;
        mps[x+y].insert({x,i});
        mms[x-y].insert({x,i});
        mpv[x+y].push_back({x,i});
        mmv[x-y].push_back({x,i});
    }
    D = abs(X[A]-X[B])+abs(Y[A]-Y[B]);
    for(auto& v:mpv) sort(v.second.begin(),v.second.end());
    for(auto& v:mmv) sort(v.second.begin(),v.second.end());
    queue<int> Q;
    ll ans = 0;
    const int inf = 1e9+7;
    Q.push(A),Q.push(B);
    struct point{
        int x,y;
    };

    vec<int> vis(N,0);
    auto ne = [&](int s,int t,set<P<int,int>>& st){
        if(st.empty()) return ;
        set<P<int,int>>::iterator it = st.upper_bound({s,-1});
        while(it!=st.end()){
            P<int,int> p = *it;
            if(t<p.first) break;
            if(!vis[p.second]){
                Q.push(p.second);
                vis[p.second] = 1;
            }
            it = st.erase(it);
        }
    };

    auto calc = [&](int s,int t,vec<P<int,int>>& v,ll& cnt){
        if(v.empty()) return ;
        int l = lower_bound(v.begin(),v.end(),P<int,int>(s,-1))-v.begin();
        int r = lower_bound(v.begin(),v.end(),P<int,int>(t,inf))-v.begin();
//        cerr << l << " " << r << " " << v.size() << endl;
        ans += r-l;
        r--;
        if(l>r) return ;
        if(s==v[l].first || (r>=0 && s==v[r].first)) cnt++;
        if(t==v[l].first || (r>=0 && t==v[r].first)) cnt++;
    };

    vis[A] = vis[B] = 1;
    while(!Q.empty()){
        int cur = Q.front(); Q.pop();
        point u = {X[cur],Y[cur]+D},d = {X[cur],Y[cur]-D};
        point l = {X[cur]-D,Y[cur]},r = {X[cur]+D,Y[cur]};
        ll c = 0;
        if(mpv.count(X[cur]+Y[cur]+D)){
            ne(u.x,r.x,mps[X[cur]+Y[cur]+D]);
            calc(u.x,r.x,mpv[X[cur]+Y[cur]+D],c);
        }
        if(mpv.count(X[cur]+Y[cur]-D)){
            ne(l.x,d.x,mps[X[cur]+Y[cur]-D]);
            calc(l.x,d.x,mpv[X[cur]+Y[cur]-D],c);
        }
        if(mmv.count(X[cur]-Y[cur]-D)){
            ne(l.x,u.x,mms[X[cur]-Y[cur]-D]);
            calc(l.x,u.x,mmv[X[cur]-Y[cur]-D],c);
        }
        if(mmv.count(X[cur]-Y[cur]+D)){
            ne(d.x,r.x,mms[X[cur]-Y[cur]+D]);
            calc(d.x,r.x,mmv[X[cur]-Y[cur]+D],c);
        }
//        cerr << cur << " " << c << endl;
        ans -= c/2;
    }
    cout << ans/2 << endl;
}