//---------- begin union_find ----------
mod union_find {
    pub struct UF {
        p: Vec<i32>,
    }
    #[allow(dead_code)]
    impl UF {
        pub fn new(n: usize) -> UF {
            UF {p: vec![-1; n] }
        }
        pub fn init(&mut self) {
            for p in self.p.iter_mut() {
                *p = -1;
            }
        }
        pub fn root(&mut self, mut x: usize) -> usize {
            while self.p[x] >= 0 {
                x = self.p[x] as usize;
            }
            x
        }
        pub fn same(&mut self, x: usize, y: usize) -> bool {
            self.root(x) == self.root(y)
        }
        pub fn unite(&mut self, mut x: usize, mut y: usize) {
            x = self.root(x);
            y = self.root(y);
            if x == y {
                return;
            }
            if self.p[x] > self.p[y] {
                let s = x;
                x = y;
                y = s;
            }
            self.p[x] += self.p[y];
            self.p[y] = x as i32;
        }
        pub fn get_size(&mut self, x: usize) -> usize {
            let r = self.root(x);
            (-self.p[r]) as usize
        }
    }
}
//---------- end union_find ----------

use std::io::Read;
use std::cmp::max;

fn func(p: (i64, i64, usize)) -> i64 {
    p.0 + p.1
}

fn run() {
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    let n: usize = it.next().unwrap().parse().unwrap();
    let a = it.next().unwrap().parse::<usize>().unwrap() - 1;
    let b = it.next().unwrap().parse::<usize>().unwrap() - 1;
    let mut p = Vec::with_capacity(n);
    for i in 0..n {
        let x: i64 = it.next().unwrap().parse().unwrap();
        let y: i64 = it.next().unwrap().parse().unwrap();
        p.push((x, y, i));
    }
    let d = (p[a].0 - p[b].0).abs() + (p[a].1 - p[b].1).abs();
    let mut u = union_find::UF::new(n);
    for _ in 0..4 {
        p.sort_by_key(|&p| (func(p), p.0));
        let mut l = 0;
        for i in 0..n {
            l = max(l, i + 1);
            while l < n && (func(p[l]) < func(p[i]) + d || (func(p[l]) == func(p[i]) + d && p[l].0 <= p[i].0)) {
                l += 1;
            }
            while l < n && func(p[l]) == func(p[i]) + d && p[l].1 >= p[i].1 {
                u.unite(p[i].2, p[l].2);
                l += 1;
            }
            l -= 1;
        }
        for p in p.iter_mut() {
            *p = (p.1, -p.0, p.2);
        }
    }
    let mut ans = 0;
    for _ in 0..4 {
        p.sort_by_key(|&p| (func(p), p.0));
        let mut l = 0;
        let mut r = 0;
        for i in 0..n {
            if !u.same(a, p[i].2) {
                continue;
            }
            l = max(l, i + 1);
            while l < n && (func(p[l]) < func(p[i]) + d || (func(p[l]) == func(p[i]) + d && p[l].0 <= p[i].0)) {
                l += 1;
            }
            r = max(l, r);
            while r < n && func(p[r]) == func(p[i]) + d && p[r].1 >= p[i].1 {
                r += 1;
            }
            ans += r - l;
        }
        for p in p.iter_mut() {
            *p = (p.1, -p.0, p.2);
        }
    }
    ans /= 2;
    println!("{}", ans);
}

fn main() {
    run();
}


Measured memory_bytes: 13560