#include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
#include <map>
//#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>

//#include <cv.h>
//#include <highgui.h>
#include <stdlib.h>
#include <string>

class Union_Find {
    public:
    std::vector<int> par;
    Union_Find() {}
    Union_Find(int n){
        par.resize(n, 0);
        for(int i = 0; i < n; i++){
            par[i] = i;
        }
    }

    void simplify(int x) {
        std::vector<int> path;
        while (par[x] != x) {
            path.push_back(x);
            x = par[x];
        }
        for (int p : path) {
            par[p] = x;
        }
    }
    
    int find(int x){
        simplify(x);
        return par[x];
    }
    
    void unite(int x, int y){
        x = find(x);
        y = find(y);
        if (x != y) {
            par[y] = x;
            // 改造する時は「根になっているノードの親を変更する」という原則が守られていることに注意。
        }
    }
};

std::pair<int, int> value_range(const std::vector<long long>& value_vec, const long long val_lb, const long long val_ub) {
    // first <= idx && idx < second なるidxが
    // val_lb <= value_vec[idx] && value_vec[idx] <= val_ub を満たすように、pairを返す。
    // そのようなidxが存在しない場合、{-1, -1}を返す。value_vecはソートされていることが前提。
    if (val_ub < val_lb || value_vec.size() == 0 || val_ub < value_vec[0] || value_vec.back() < val_lb) {
        return std::pair<int, int>({-1, -1});
    }

    int lb_idx, ub_idx;

    if (val_lb <= value_vec[0]) {
        lb_idx = 0;
    } else {
        int lb = 0;
        int ub = value_vec.size() - 1;
        while(lb + 1 < ub) {
            int mid = (lb + ub) / 2;
            if (val_lb <= value_vec[mid]) {
                ub = mid;
            } else {
                lb = mid;
            }
        }
        lb_idx = ub;
    }

    if (value_vec.back() <= val_ub) {
        ub_idx = value_vec.size();
    } else {
        int lb = 0;
        int ub = value_vec.size() - 1;
        while(lb + 1 < ub) {
            int mid = (lb + ub) / 2;
            if (value_vec[mid] <= val_ub) {
                lb = mid;
            } else {
                ub = mid;
            }
        }
        ub_idx = ub;
    }

    return std::pair<int, int>({lb_idx, ub_idx});

}

const int MAX_N = 100050;
int N;
long long x[MAX_N], y[MAX_N], D;
int a, b;

std::map<int, std::vector<int>> mp_add, mp_sub;
std::map<int, std::vector<long long>> mp_add_sub, mp_sub_add;

Union_Find uf = Union_Find(MAX_N);

long long distance(int i, int j) {
    return abs(x[i] - x[j]) + abs(y[i] - y[j]);
}

void unite_vector(const std::vector<int>& vec1, const std::vector<int>& vec2, const long long sgn) {
    int id1 = 0;
    int id2 = 0;

    //std::cout << "unite_vector_func:" << std::endl;

    while (true) {
        //if (sgn == -1 && vec1[id1] == 1) {
        //    std::cout << "unite_check:" << vec1[id1] << " " << vec2[id2] << std::endl;
        //}
        //std::cout << vec1[id1] << " " << vec2[id2] << std::endl;

        if (distance(vec1[id1], vec2[id2]) == D) {
            uf.unite(vec1[id1], vec2[id2]);
            //std::cout << "unite:" << vec1[id1] << " " << vec2[id2] << std::endl;
        }

        if (id1 == vec1.size() - 1 && id2 == vec2.size() - 1) {
            break;
        }

        if (id1 == vec1.size() - 1) {
            id2++;
        } else if (id2 == vec2.size() - 1) {
            id1++;
        } else {
            if (distance(vec1[id1+1], vec2[id2]) == D && distance(vec1[id1], vec2[id2+1]) == D) {
                uf.unite(vec1[id1+1], vec2[id2]);
                uf.unite(vec1[id1], vec2[id2+1]);
                id1++;
                id2++;
            } else if (distance(vec1[id1+1], vec2[id2]) == D) {
                id1++;
            } else if (distance(vec1[id1], vec2[id2+1]) == D) {
                id2++;
            } else if (x[vec1[id1+1]] + y[vec1[id1+1]] * sgn < x[vec2[id2+1]] + y[vec2[id2+1]] * sgn) {
                id1++;
            } else {
                id2++;
            }
        }
    }
}

int main(int argc, char **argv) {
    std::cin >> N >> a >> b;
    for (int i = 1; i <= N; i++) {
        std::cin >> x[i] >> y[i];
    }
    D = abs(x[a] - x[b]) + abs(y[a] - y[b]);
    //std::cout << "checkD:" << D << std::endl;

    for (int i = 1; i <= N; i++) {
        mp_add[x[i] + y[i]].push_back(i);
        mp_sub[x[i] - y[i]].push_back(i);

        //std::cout << i << " " << x[i] + y[i] << " " << x[i] - y[i] << std::endl;
    }

    /*
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            if (distance(i, j) == D) {
                std::cout << "edge:" << i << " " << j << " " << std::endl;
            }
        }
    }
    */

    //std::cout << "check:" << mp_add.size() << " " << mp_sub.size() << std::endl;

    for (auto itr = mp_add.begin(); itr != mp_add.end(); ++itr) {
        std::sort(itr->second.begin(), itr->second.end(),
            [](const int v1, const int v2) { return x[v1] - y[v1] < x[v2] - y[v2]; }
        );
        //if (itr->second.size() >= 2) {
        //    std::cout << "ch:" << itr->first << " " << itr->second.size() << std::endl;
        //}
        for (int i : itr->second) {
            mp_add_sub[itr->first].push_back(x[i] - y[i]);
        }
    }

    for (auto itr = mp_add.begin(); itr != mp_add.end(); ++itr) {
        //std::cout << "check2:" << itr->first << " " << itr->first + D << std::endl;
        if (mp_add.find(itr->first + D) != mp_add.end()) {
            unite_vector(itr->second, mp_add[itr->first + D], -1);
        }
    }

    for (auto itr = mp_sub.begin(); itr != mp_sub.end(); ++itr) {
        std::sort(itr->second.begin(), itr->second.end(),
            [](const int v1, const int v2) { return x[v1] + y[v1] < x[v2] + y[v2]; }
        );
        for (int i : itr->second) {
            mp_sub_add[itr->first].push_back(x[i] + y[i]);
        }
    }

    for (auto itr = mp_sub.begin(); itr != mp_sub.end(); ++itr) {
        if (mp_sub.find(itr->first + D) != mp_sub.end()) {
            unite_vector(itr->second, mp_sub[itr->first + D], 1);
        }
    }

    assert(uf.find(a) == uf.find(b));

    long long cnt = 0;
    long long cnt2 = 0;
    for (int i = 1; i <= N; i++) {
        if (uf.find(i) == uf.find(a)) {
            cnt++;
            /*
            if (mp_add.find(x[i] + y[i] + D) != mp_add.end()) {
                std::pair<int, int> range = value_range(mp_add_sub[x[i] + y[i] + D], x[i] - y[i] - D, x[i] - y[i] + D);
                if (range.first != -1) {
                    ret += range.second - range.first;
                }
            }
            */
        }
        if (mp_add.find(x[i] + y[i] + D) != mp_add.end()) {
            std::pair<int, int> range = value_range(mp_add_sub[x[i] + y[i] + D], x[i] - y[i] - D, x[i] - y[i] + D);
            if (range.first != -1) {
                cnt2 += range.second - range.first;
            }
        }
        //std::cout << i << " " << cnt2 << std::endl;
        if (mp_sub.find(x[i] - y[i] + D) != mp_sub.end()) {
            std::pair<int, int> range = value_range(mp_sub_add[x[i] - y[i] + D], x[i] + y[i] - D, x[i] + y[i] + D);
            if (range.first != -1) {
                cnt2 += range.second - range.first;
            }
        }
        //std::cout << i << " " << cnt2 << std::endl;
    }
    //std::cout << "cnt:" << cnt << " " << cnt2 << std::endl;

    long long ret = 0;
    for (int i = 1; i <= N; i++) {
        if (uf.find(i) == uf.find(a)) {
            if (mp_add.find(x[i] + y[i] + D) != mp_add.end()) {
                std::pair<int, int> range = value_range(mp_add_sub[x[i] + y[i] + D], x[i] - y[i] - D, x[i] - y[i] + D);
                if (range.first != -1) {
                    ret += range.second - range.first;
                }
            }

            if (mp_sub.find(x[i] - y[i] + D) != mp_sub.end()) {
                std::pair<int, int> range = value_range(mp_sub_add[x[i] - y[i] + D], x[i] + y[i] - D, x[i] + y[i] + D);
                if (range.first != -1) {
                    ret += range.second - range.first;
                    // addの方と重複するものは引いておく。
                    const std::vector<int> tmp = mp_sub[x[i] - y[i] + D];
                    if (x[i] == x[tmp[range.first]] || y[i] == y[tmp[range.first]]) {
                        ret--;
                    }
                    if (range.second - 1 != range.first) {
                        if (x[i] == x[tmp[range.second - 1]] || y[i] == y[tmp[range.second - 1]]) {
                            ret--;
                        }
                    }
                }
            }
        }
    }

    std::cout << ret << std::endl;
    
    return 0;
}



Measured memory_bytes: 40064