#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
const double PI = acos(-1.0L);
const double EPS = 1e-12;


#define ff               first
#define ss               second
#define pb               push_back
#define all(x)           (x).begin(), (x).end()
#define mem0(x)          memset(x, 0, sizeof (x))
#define mem1(x)          memset(x, -1, sizeof (x))

typedef long long ll;
typedef vector <int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector <ii> vii;
typedef vector<vii> vvii;
typedef vector <ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef double T;
int n;
struct P
{
    T x, y;
    P() {}
    P(T x, T y) : x(x), y(y) {}

    P operator+(const P &p) const { return P(x + p.x, y + p.y); }
    P operator-(const P &p) const { return P(x - p.x, y - p.y); }
    P operator*(const double &c) const { return P(x * c, y * c); }
    P operator/(const double &c) const { return P(x / c, y / c); }
    T operator^(const P &p) const { return x * p.y - y * p.x; }
    T operator*(const P &p) const { return x * p.x + y * p.y; }
    bool operator==(const P &p) const
    {
        return abs(x - p.x) + abs(y - p.y) < EPS;
    }
    bool operator<(const P &p) const
    {
        return abs(x - p.x) > EPS ? p.x - x > EPS : p.y - y > EPS;
    }

    T norm2() const { return x * x + y * y; }
    double norm() const { return sqrt(norm2()); }
    double ang()
    {
        double a = atan2(y, x);
        if (a < 0) a += 2. * PI;
        return a;
    }
    P unit() { return (*this) / norm(); }
    P perp() { return P(-y, x); }
    P rot(P r) { return P((*this) ^ r, (*this) * r); }
    P rot(double a){ return rot(P(sin(a), cos(a))); }
};

double turn(P &a, P &b, P &c) { return (b - a) ^ (c - a); }

vector<P> convexHull(vector<P> &p)
{
    int n = p.size(), k = 0;
    vector<P> H(2 * n);
    sort(p.begin(), p.end());
    rep(i, n)
    {
        while (k >= 2 && turn(H[k - 2], H[k - 1], p[i]) <= 0) k--;
        H[k++] = p[i];
    }
    for (int i = n - 2, t = k + 1; i >= 0; i--)
    {
        while (k >= t && turn(H[k - 2], H[k - 1], p[i]) <= 0) k--;
        H[k++] = p[i];
    }
    H.resize(k - 1);
    return H;
}

ll dist(P &a, P &b){
    return abs(a.x - b.x) + abs(a.y-b.y);
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int T=1;
    while (T--){
        cin >> n;
        vector <P> a(n);
        vii R(n);
        for (int i = 0; i < n; ++i) {
            cin >> a[i].x >> a[i].y;
            R[i].ff = a[i].x; R[i].ss = a[i].y;
        }
        if (n == 2){
            cout << dist(a[0], a[1]) << "\n";
            return 0;
        }
        vector <P> CH = convexHull(a);
        ll ans = 0;
        int m = CH.size();
        for (int j = 0; j < m; ++j) {
            int L = j+1, R = j+m-1, M1, M2;
            while (L<=R){
                M1 = L + (R-L)/3;
                M2 = L + (R-L)/3*2;
                if (dist(CH[j], CH[M1%m]) > dist(CH[j], CH[M2%m])){
                    ans = max(ans, dist(CH[j], CH[M1%m]));
                    R = M2-1;
                }else{
                    ans = max(ans,dist(CH[j], CH[M2%m]));
                    L = M1+1;
                }
            }
        }
        cout << ans << "\n";
    }
}

Measured memory_bytes: 8224