
#include<cstring>
#include<string>
#include<vector>
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stack>
#include<queue>
#include<cmath>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<complex>
#include<sstream>
#include<climits>
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define all(X) (X).begin(),(X).end()
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int MAX_N = 100000;
int N;
ll x[MAX_N+1], y[MAX_N+1];
int a, b;
ll D;
bool rm[MAX_N+1];
set<pll> s1;
set<pll> s2;
vector<pll> v1;
vector<pll> v2;
map<pll, int> id;

int main() {
  cin >> N >> a >> b;
  for (int i = 1; i <= N; ++i) cin >> x[i] >> y[i];
  D = (abs(x[a]-x[b])+abs(y[a]-y[b]));

  for (int i = 1; i <= N; ++i) {
    int tx = x[i], ty = y[i];
    x[i] = tx - ty;
    y[i] = tx + ty;
  }


  for (int i = 1; i <= N; ++i) {
    s1.insert(pll(x[i], y[i]));
    s2.insert(pll(y[i], x[i]));
    id[pll(x[i], y[i])] = i;
  }

  queue<int> que;
  que.push(a);

  while (!que.empty()) {
    int v = que.front(); que.pop();
    if (rm[v]) {continue;}
    rm[v] = true;

    auto ite = s1.lower_bound(pll(x[v]-D, y[v]-D));

    while (ite != s1.end()) {
      if (ite->fi != x[v]-D || ite->sc > y[v]+D) break;
      pll tp = *ite;
      que.push(id[*ite]);
      s1.erase(ite++);
    }

    ite = s1.lower_bound(pll(x[v]+D, y[v]-D));
    while (ite != s1.end()) {
      if (ite->fi != x[v]+D || ite->sc > y[v]+D) break;
      que.push(id[*ite]);
      s1.erase(ite++);
    }

    ite = s2.upper_bound(pll(y[v]-D, x[v]-D));
    while (ite != s2.end()) {
      if (ite->fi != y[v]-D || ite->sc >= x[v]+D) break;
      que.push(id[pll(ite->sc, ite->fi)]);
      s2.erase(ite++);
    }

    ite = s2.upper_bound(pll(y[v]+D, x[v]-D));
    while (ite != s2.end()) {
      if (ite->fi != y[v]+D || ite->sc >= x[v]+D) break;
      que.push(id[pll(ite->sc, ite->fi)]);
      s2.erase(ite++);
    }

  }


  for (int i = 1; i <= N; ++i) {
    if (rm[i]) {
      v1.push_back(pll(x[i], y[i]));
      v2.push_back(pll(y[i], x[i]));
    }
  }

  sort(all(v1));
  sort(all(v2));

  ll ans = 0;
  for (int v = 1; v <= N; ++v) {
    if (rm[v]) {
      ans += upper_bound(all(v1), pll(x[v]-D, y[v]+D)) - lower_bound(all(v1), pll(x[v]-D, y[v]-D));

      ans += upper_bound(all(v1), pll(x[v]+D, y[v]+D)) - lower_bound(all(v1), pll(x[v]+D, y[v]-D));

      ans += lower_bound(all(v2), pll(y[v]+D, x[v]+D)) - upper_bound(all(v2), pll(y[v]+D, x[v]-D));

      ans += lower_bound(all(v2), pll(y[v]-D, x[v]+D)) - upper_bound(all(v2), pll(y[v]-D, x[v]-D));
    }
  }

  cout << ans / 2 << endl;

  return 0;
}

