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# (Mono-csc 3.5.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;
using static System.Array;

class Program
{
	public static void Main()
	{
        var n = int.Parse(ReadLine());
        var x = new int[n];
        var y = new int[n];
        var l = new int[n];
        var maxX = 0;
        var minX = int.MaxValue;
        var maxY = 0;
        var minY = int.MaxValue;
        for(int i = 0; i < n; i++)
        {
            var a = ReadLine().Split().Select(int.Parse).ToArray();
            x[i] = a[0];
            y[i] = a[1];
            l[i] = a[0] - 1 + a[1] - 1;
            maxX = Max(maxX, a[0]);
            minX = Min(minX, a[0]);
            maxY = Max(maxY, a[1]);
            minY = Min(minY, a[1]);
        }
        var max = l.Max() - l.Min();
        for(int i = 0; i < n; i++)
        {
            l[i] = Abs(maxX - x[i]) + y[i];
        }
        max = Max(max, l.Max() - l.Min());
        var maxXi = x.Select((a, i) => new { a, i }).Aggregate((a, working) => (a.a > working.a) ? a : working).i;
        var minXi = x.Select((a, i) => new { a, i }).Aggregate((a, working) => (a.a < working.a) ? a : working).i;
        var maxYi = y.Select((a, i) => new { a, i }).Aggregate((a, working) => (a.a > working.a) ? a : working).i;
        var minYi = y.Select((a, i) => new { a, i }).Aggregate((a, working) => (a.a < working.a) ? a : working).i;
        max = Max(max, Abs(x[maxXi] - x[minXi]) + Abs(y[maxXi] - y[minXi]));
        max = Max(max, Abs(x[maxYi] - x[minXi]) + Abs(y[maxYi] - y[minXi]));
        max = Max(max, Abs(x[maxXi] - x[minYi]) + Abs(y[maxXi] - y[minYi]));
        max = Max(max, Abs(x[maxYi] - x[minYi]) + Abs(y[maxYi] - y[minYi]));
        max = Max(max, Abs(x[maxXi] - x[maxYi]) + Abs(y[maxXi] - y[maxYi]));
        max = Max(max, Abs(x[minXi] - x[minYi]) + Abs(y[minXi] - y[minYi]));
        WriteLine(max);
    }
}