output_description: Print the number of the pairs of pinholes that can be pointed by the compass.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N a b
      x_1 y_1
      :
      x_N y_N
attempt: import bisect
  import sys
  import random
  from collections import defaultdict
  
  
  class RandomizedBinarySearchTree:
      def __init__(self):
          self.children = [[-1], [-1]]
          self.values = [0]
          self.counts = [0]
          self.indices = set()
          self.root = 0
  
      def merge(self, left_root, right_root):
          children = self.children
          counts = self.counts
          li = left_root
          ri = right_root
          stack = []
          while li != 0 and ri != 0:
              if random.randrange(counts[li] + counts[ri]) < counts[li]:
                  stack.append((li, 1))
                  li = children[1][li]
              else:
                  stack.append((ri, 0))
                  ri = children[0][ri]
  
          i = li if li != 0 else ri
          while stack:
              pi, is_right = stack.pop()
              children[is_right][pi] = i
              counts[pi] = counts[children[0][pi]] + counts[children[1][pi]] + 1
              i = pi
  
          return i
  
      def split(self, root, x):
          i = root
          lefts, rights = self.children
          values = self.values
          counts = self.counts
          l_stack = []
          r_stack = []
          while i != 0:
              if x < values[i]:
                  r_stack.append(i)
                  i = lefts[i]
              else:
                  l_stack.append(i)
                  i = rights[i]
  
          li, ri = 0, 0
          while l_stack:
              pi = l_stack.pop()
              rights[pi] = li
              counts[pi] = counts[lefts[pi]] + counts[li] + 1
              li = pi
          while r_stack:
              pi = r_stack.pop()
              lefts[pi] = ri
              counts[pi] = counts[ri] + counts[rights[pi]] + 1
              ri = pi
  
          return li, ri
  
      def insert(self, x):
          if self.indices:
              ni = self.indices.pop()
              self.children[0][ni] = self.children[1][ni] = 0
              self.values[ni] = x
              self.counts[ni] = 1
          else:
              ni = len(self.values)
              self.children[0].append(0)
              self.children[1].append(0)
              self.values.append(x)
              self.counts.append(1)
  
          li, ri = self.split(self.root, x)
          self.root = self.merge(self.merge(li, ni), ri)
  
      def delete(self, x):
          li, mri = self.split(self.root, x - 1)
          mi, ri = self.split(mri, x)
  
          if mi == 0:
              self.root = self.merge(li, ri)
              return
  
          self.indices.add(mi)
          self.root = self.merge(li, ri)
          return
  
      def upper_bound(self, x, default=-1):
          i = self.root
          lefts, rights = self.children
          values = self.values
          counts = self.counts
          y = default
          c = counts[i]
          j = 0
          while i != 0:
              if x < values[i]:
                  y = values[i]
                  c = j + counts[lefts[i]]
                  i = lefts[i]
              else:
                  j += counts[lefts[i]] + 1
                  i = rights[i]
          return y, c
  
      def lower_bound(self, x, default=-1):
          i = self.root
          lefts, rights = self.children
          values = self.values
          counts = self.counts
          y = default
          c = counts[i]
          j = 0
          while i != 0:
              if x <= values[i]:
                  y = values[i]
                  c = j + counts[lefts[i]]
                  i = lefts[i]
              else:
                  j += counts[lefts[i]] + 1
                  i = rights[i]
          return y, c
  
      def get_k_th(self, k, default=-1):
          i = self.root
          children = self.children
          values = self.values
          counts = self.counts
          if counts[i] <= k:
              return default
          j = k
          while i != 0:
              left_count = counts[children[0][i]]
              if left_count == j:
                  return values[i]
              elif left_count > j:
                  i = children[0][i]
              else:
                  j -= left_count + 1
                  i = children[1][i]
          return default
  
      def debug_print(self):
          print("Lefts ", self.children[0])
          print("Rights", self.children[1])
          print("Values", self.values)
          print("Counts", self.counts)
          self._debug_print(self.root, 0)
  
      def _debug_print(self, i, depth):
          if i != -1:
              self._debug_print(self.children[0][i], depth + 1)
              print("      " * depth, self.values[i], self.counts[i])
              self._debug_print(self.children[1][i], depth + 1)
  
  
  def x_check(x_dict, rev_dict, nx, y, d):
      ret = set()
      counter = 0
      if nx in x_dict:
          rbst, lst = x_dict[nx]
          ny, _ = rbst.lower_bound(y - d, y + d + 1)
          while ny <= y + d:
              q = rev_dict[nx, ny]
              ret.add(q)
              rbst.delete(ny)
              ny, _ = rbst.lower_bound(y - d, y + d + 1)
          i = bisect.bisect_left(lst, y - d)
          j = bisect.bisect(lst, y + d)
          counter = j - i
      return ret, counter
  
  
  def y_check(y_dict, rev_dict, ny, x, d):
      ret = set()
      counter = 0
      if ny in y_dict:
          rbst, lst = y_dict[ny]
          nx, _ = rbst.lower_bound(x - d, x + d + 1)
          while nx <= x + d:
              q = rev_dict[nx, ny]
              ret.add(q)
              rbst.delete(nx)
              nx, _ = rbst.lower_bound(x - d, x + d + 1)
          i = bisect.bisect(lst, x - d)
          j = bisect.bisect_left(lst, x + d)
          counter = j - i
      return ret, counter
  
  
  n, a, b, *xy = map(int, sys.stdin.buffer.read().split())
  xxx = xy[0::2]
  yyy = xy[1::2]
  
  x_dict = defaultdict(lambda: [RandomizedBinarySearchTree(), []])
  y_dict = defaultdict(lambda: [RandomizedBinarySearchTree(), []])
  ppp = []
  rev_dict = {}
  for i in range(n):
      x = xxx[i] - yyy[i]
      y = xxx[i] + yyy[i]
      x_dict[x][0].insert(y)
      y_dict[y][0].insert(x)
      x_dict[x][1].append(y)
      y_dict[y][1].append(x)
      ppp.append((x, y))
      rev_dict[x, y] = i
  
  for _, lst in x_dict.values():
      lst.sort()
  for _, lst in y_dict.values():
      lst.sort()
  
  a -= 1
  b -= 1
  ax, ay = ppp[a]
  bx, by = ppp[b]
  d = max(abs(ax - bx), abs(ay - by))
  x_dict[ax][0].delete(ay)
  x_dict[bx][0].delete(by)
  y_dict[ay][0].delete(ax)
  y_dict[by][0].delete(bx)
  
  print(ppp)
  
  stack = [a, b]
  stacked = {a, b}
  ans = 0
  while stack:
      p = stack.pop()
      x, y = ppp[p]
  
      qqq = set()
      qs, c = x_check(x_dict, rev_dict, x - d, y, d)
      qqq.update(qs)
      ans += c
  
      qs, c = x_check(x_dict, rev_dict, x + d, y, d)
      qqq.update(qs)
      ans += c
  
      qs, c = y_check(y_dict, rev_dict, y - d, x, d)
      qqq.update(qs)
      ans += c
  
      qs, c = y_check(y_dict, rev_dict, y + d, x, d)
      qqq.update(qs)
      ans += c
  
      for q in qqq:
          if q not in stacked:
              stack.append(q)
              stacked.add(q)
  
  print(ans // 2)
  
problem_description: Statement
  
  There are N pinholes on the xy-plane. The i-th pinhole is located at
  (x_i,y_i).
  
  We will denote the Manhattan distance between the i-th and j-th pinholes as
  d(i,j)(=|x_i-x_j|+|y_i-y_j|).
  
  You have a peculiar pair of compasses, called _Manhattan Compass_. This
  instrument always points at two of the pinholes. The two legs of the compass
  are indistinguishable, thus we do not distinguish the following two states:
  the state where the compass points at the p-th and q-th pinholes, and the
  state where it points at the q-th and p-th pinholes.
  
  When the compass points at the p-th and q-th pinholes and d(p,q)=d(p,r), one
  of the legs can be moved so that the compass will point at the p-th and r-th
  pinholes.
  
  Initially, the compass points at the a-th and b-th pinholes. Find the number
  of the pairs of pinholes that can be pointed by the compass.
samples: [{"input": "5 1 2\n    1 1\n    4 3\n    6 1\n    5 5\n    4 8", "output": "4\n    \n\nInitially, the compass points at the first and second pinholes.\n\nSince d(1,2) = d(1,3), the compass can be moved so that it will point at the\nfirst and third pinholes.\n\nSince d(1,3) = d(3,4), the compass can also point at the third and fourth\npinholes.\n\nSince d(1,2) = d(2,5), the compass can also point at the second and fifth\npinholes.\n\nNo other pairs of pinholes can be pointed by the compass, thus the answer is\n4.\n\n* * *"}, {"input": "6 2 3\n    1 3\n    5 3\n    3 5\n    8 4\n    4 7\n    2 5", "output": "4\n    \n\n* * *"}, {"input": "8 1 2\n    1 5\n    4 3\n    8 2\n    4 7\n    8 8\n    3 3\n    6 6\n    4 8", "output": "7"}]