Problem:
Score : 500 points

Problem Statement

There are N points on the 2D plane, i-th of which is located on (x_i, y_i).
There can be multiple points that share the same coordinate.
What is the maximum possible Manhattan distance between two distinct points?

Here, the Manhattan distance between two points (x_i, y_i) and (x_j, y_j) is defined by |x_i-x_j| + |y_i-y_j|.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq x_i,y_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_N y_N

Output

Print the answer.

Sample Input 1

3
1 1
2 4
3 2

Sample Output 1

4

The Manhattan distance between the first point and the second point is |1-2|+|1-4|=4, which is maximum possible.

Sample Input 2

2
1 1
1 1

Sample Output 2

0

Solution in Rust (1.42.0) (judge verdict: Accepted)

pub struct ProconReader<R: std::io::Read> {
    reader: R,
}

impl<R: std::io::Read> ProconReader<R> {
    pub fn new(reader: R) -> Self {
        Self { reader }
    }
    pub fn get<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .reader
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&byte| byte == b' ' || byte == b'\n' || byte == b'\r')
            .take_while(|&byte| byte != b' ' && byte != b'\n' && byte != b'\r')
            .collect::<Vec<_>>();
        std::str::from_utf8(&buf)
            .unwrap()
            .parse()
            .ok()
            .expect("Parse Error.")
    }
}

fn main() {
    let stdin = std::io::stdin();
    let mut rd = ProconReader::new(stdin.lock());

    let n: usize = rd.get();
    let xy: Vec<(i64, i64)> = (0..n)
        .map(|_| {
            let x: i64 = rd.get();
            let y: i64 = rd.get();
            (x, y)
        })
        .collect();
    let pts = vec![
        xy.iter()
            .max_by(|(x1, y1), (x2, y2)| (-x1 - y1).cmp(&(-x2 - y2)))
            .unwrap(),
        xy.iter()
            .max_by(|(x1, y1), (x2, y2)| (x1 + y1).cmp(&(x2 + y2)))
            .unwrap(),
        xy.iter()
            .max_by(|(x1, y1), (x2, y2)| (x1 - y1).cmp(&(x2 - y2)))
            .unwrap(),
        xy.iter()
            .max_by(|(x1, y1), (x2, y2)| (-x1 + y1).cmp(&(-x2 + y2)))
            .unwrap(),
    ];
    let mut ans = 0;
    for (x, y) in &xy {
        for (xx, yy) in &pts {
            ans = std::cmp::max(ans, (x - xx).abs() + (y - yy).abs());
        }
    }
    println!("{}", ans);
}