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: Wrong Answer)

use std::collections::*;
use std::io::*;
use std::*;
// template {{{
macro_rules! get {
    ($($t:tt),*; $n:expr) => {
        {
            let stdin = std::io::stdin();
            let ret = std::io::BufRead::lines(stdin.lock()).take($n).map(|line| {
                let line = line.unwrap();
                let mut it = line.split_whitespace();
                _get!(it; $($t),*)
            }).collect::<Vec<_>>();
            ret
        }
    };
    ($($t:tt),*) => {
        {
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut it = line.split_whitespace();
            _get!(it; $($t),*)
        }
    };
}
macro_rules! _get {
    ($it:ident; [char]) => {
        _get!($it; String).chars().collect::<Vec<_>>()
    };
    ($it:ident; [u8]) => {
        _get!($it; String).bytes().collect::<Vec<_>>()
    };
    ($it:ident; usize1) => {
        $it.next().unwrap().parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1
    };
    ($it:ident; [usize1]) => {
        $it.map(|s| s.parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1).collect::<Vec<_>>()
    };
    ($it:ident; [$t:ty]) => {
        $it.map(|s| s.parse::<$t>().unwrap_or_else(|e| panic!("{}", e))).collect::<Vec<_>>()
    };
    ($it:ident; $t:ty) => {
        $it.next().unwrap().parse::<$t>().unwrap_or_else(|e| panic!("{}", e))
    };
    ($it:ident; $($t:tt),+) => {
        ($(_get!($it; $t)),*)
    };
}
// }}}

fn distance(x: (i64, i64), y: (i64, i64)) -> i64 {
    (x.0 - y.0).abs() + (x.1 - y.1).abs()
}

fn cross3(a: (i64, i64), b: (i64, i64), c: (i64, i64)) -> i64 {
    (b.0 - a.0) * (c.1 - a.1) - (b.1 - a.1) * (c.0 - a.0)
}
fn cross(a: (i64, i64), b: (i64, i64), c: (i64, i64), d: (i64, i64)) -> i64 {
    (b.0 - a.0) * (d.1 - c.1) - (b.1 - a.1) * (d.0 - c.0)
}
fn convex_hull(ps: Vec<(i64, i64)>) -> Vec<(i64, i64)> {
    let mut ret: Vec<(i64, i64)> = Vec::new();
    let n = ps.len();
    for i in &ps {
        while ret.len() > 1 && cross3(ret[ret.len() - 1], ret[ret.len() - 2], *i) >= 0 {
            ret.pop();
        }
        ret.push(*i);
    }
    let t = ret.len();
    for i in n - 2..=0 {
        let p = ps[i];
        while ret.len() > t && cross3(ret[ret.len() - 1], ret[ret.len() - 2], p) >= 0 {
            ret.pop();
        }
        ret.push(p);
    }
    ret
}

fn rotating_calipers(ps: Vec<(i64, i64)>) -> i64 {
    let qs = convex_hull(ps);
    let n = qs.len();
    if n == 2 {
        return distance(qs[0], qs[1]);
    }
    let (mut i, mut j) = (0, 0);
    for k in 0..n {
        if qs[k] < qs[i] {
            i = k;
        }
        if qs[j] < qs[k] {
            j = k;
        }
    }
    let mut res = 0;
    let (si, sj) = (i, j);
    while i != si || j != sj {
        res = res.max(distance(qs[i], qs[j]));
        if cross(qs[i], qs[i - n + 1], qs[j], qs[j - n + 1]) < 0 {
            i = (i + 1) % n;
        } else {
            j = (j + 1) % n;
        }
    }
    res
}
fn main() {
    let n = get!(usize);
    let mut points = get!(i64,i64;n);
    let mut g = (0, 0);
    for i in &points {
        g.0 += i.0;
        g.1 += i.1;
    }
    g.0 /= n as i64;
    g.1 /= n as i64;
    let mut dis: Vec<_> = points.iter().map(|x| distance(*x, g)).collect();
    dis.sort();
    let ans = dis[n - 1] + dis[n - 2];
    println!("{}", ans);
}