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::fmt::Debug;
use std::str::FromStr;

pub struct TokenReader {
    reader: std::io::Stdin,
    tokens: Vec<String>,
    index: usize,
}

impl TokenReader {
    pub fn new() -> Self {
        Self {
            reader: std::io::stdin(),
            tokens: Vec::new(),
            index: 0,
        }
    }

    pub fn next<T>(&mut self) -> T
    where
        T: FromStr,
        T::Err: Debug,
    {
        if self.index >= self.tokens.len() {
            self.load_next_line();
        }
        self.index += 1;
        self.tokens[self.index - 1].parse().unwrap()
    }

    pub fn vector<T>(&mut self) -> Vec<T>
    where
        T: FromStr,
        T::Err: Debug,
    {
        if self.index >= self.tokens.len() {
            self.load_next_line();
        }
        self.index = self.tokens.len();
        self.tokens.iter().map(|tok| tok.parse().unwrap()).collect()
    }

    pub fn load_next_line(&mut self) {
        let mut line = String::new();
        self.reader.read_line(&mut line).unwrap();

        self.tokens = line
            .split_whitespace()
            .map(String::from)
            .collect();
        self.index = 0;
    }
}

fn max_dist(points: &Vec<(i64, i64)>) -> i64 {
    let mut res = 0;
    for &(x1, y1) in points.iter() {
        for &(x2, y2) in points.iter() {
            let dist = (x1 - x2).abs() + (y1 - y2).abs();
            res = std::cmp::max(res, dist);
        }
    }
    res
}

fn solve(points: &Vec<(i64, i64)>) -> i64 {
    let mut top = std::i64::MIN;
    let mut bot = std::i64::MAX;
    let mut left = std::i64::MAX;
    let mut right = std::i64::MIN;
    for &(x, y) in points.iter() {
        top = std::cmp::max(top, y);
        bot = std::cmp::min(bot, y);
        left = std::cmp::min(left, x);
        right = std::cmp::max(right, x);
    }

    let mut top_l = points[0];
    let mut top_r = points[0];
    let mut bot_l = points[0];
    let mut bot_r = points[0];
    let mut left_t = points[0];
    let mut left_b = points[0];
    let mut right_t = points[0];
    let mut right_b = points[0];

    for &(x, y) in points.iter() {
        if y == top && x <= top_l.0 { top_l = (x, y) };
        if y == top && x >= top_r.0 { top_r = (x, y) };
        if y == bot && x <= bot_l.0 { bot_l = (x, y) };
        if y == bot && x >= bot_r.0 { bot_r = (x, y) };
        if x == left && y >= left_t.1 { left_t = (x, y) };
        if x == left && y <= left_b.1 { left_b = (x, y) };
        if x == right && y >= right_t.1 { right_t = (x, y) };
        if x == right && y <= right_b.1 { right_b = (x, y) };
    }

    let all = vec![top_l, top_r, bot_l, bot_r, left_t, left_b, right_t, right_b];
    max_dist(&all)
}

fn main() {
    let mut reader = TokenReader::new();
    let n = reader.next();
    let points = (0..n).map(|_| (reader.next(), reader.next())).collect();

    let res = solve(&points);
    println!("{}", res);
}