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)

use proconio::input;
use proconio::marker::Chars;
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused)]
const ALPHA_SMALL: [char; 26] = [
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
    't', 'u', 'v', 'w', 'x', 'y', 'z',
];
#[allow(unused)]
const ALPHA: [char; 26] = [
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
    'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
];
macro_rules! maxs {
    ($x:expr, $($y:expr), *) => {{
        let mut ret = $x;
        $(
            ret = max(ret, $y);
        )*
        ret
    }};
}
fn main() {
    input!(N: usize);
    let mut v = vec![];
    for _ in 0..N {
        input!(t: (i64, i64));
        v.push(t);
    }
    let mut w = vec![vec![0; 2]; N];
    for i in 0..N {
        for d in 0..2 {
            w[i][d] = f(v[i].0, v[i].1, d);
        }
    }

    //println!("{:?}", w);
    let mut ans = 0;
    for d in 0..2 {
        let mut m1 = w[0][d];
        let mut m2 = w[0][d];
        for i in 0..N {
            m1 = max(m1, w[i][d]);
            m2 = min(m2, w[i][d]);
            //println!("d = {}, m1 = {}, m2 ={}", d, m1, m2);
        }
        //println!("{}", m1 - m2);
        ans = max(ans, m1 - m2);
    }

    println!("{}", ans);
}

fn f(x: i64, y: i64, d: usize) -> i64 {
    if d == 0 {
        x - y
    } else {
        x + y
    }
}