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 C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
// #include <atcoder/all> // NOTE: AtCoderライブラリ
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
// using namespace atcoder; // NOTE: AtCoderライブラリ
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef pair<int, int> pii;
// #define INF __INT32_MAX__
#define INF 1e9
#define LINF __LONG_LONG_MAX__

int N; 
vl X, Y; 

int solve1() {
    int res = -1;
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
            int d = abs(X[i] - X[j]) + abs(Y[i] - Y[j]);
            res = max(d, res);
        }
    }
    return res;
}

ll solve2() {
    vl z(N), w(N);
    rep(i, N) {
        z[i] = X[i] + Y[i];
        w[i] = X[i] - Y[i];
    }
    ll zmax = -1, wmax = -1, zmin = LINF, wmin = LINF;
    rep(i, N) {
        zmax = max(zmax, z[i]);
        wmax = max(wmax, w[i]);
        zmin = min(zmin, z[i]);
        wmin = min(wmin, w[i]);
    }

    return max(zmax - zmin, wmax - wmin);
}


int main() {
    cin >> N;
    X.resize(N); Y.resize(N);
    rep(i, N) cin >> X[i] >> Y[i];

    cout << solve2() << endl;
}