#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define fi first
#define se second

const int maxn = 1e5;

struct edge {
    int a, b;
    int wei;
    bool operator < (const edge & other) const {
        return wei < other.wei;
    }
};

int n;
int x[1 + maxn], y[1 + maxn];

vector<pii > endpoints;

void add(int a, int b) {
    endpoints.pb(mp(min(a, b), max(a, b)));
}

struct point {
    int x, y, idx;
    bool operator < (const point &other) const {
        return x + y < other.x + other.y;
    }
};

map<int, int> m;

void find_batch() {
    vector<point> points;
    for(int i = 1; i <= n; i++) {
        points.pb(point{x[i], y[i], i});
    }
    sort(points.begin(), points.end());
    for(point cur : points) {
        auto it = m.lower_bound(cur.x - cur.y);
        while(it != m.end()) {
            int other = it->se;
            if(x[other] > x[cur.idx]) {
                break;
            }
            it = m.erase(it);
            add(other, cur.idx);
        }
        m[cur.x - cur.y] = cur.idx;
    }
}

void find_relevant_edges() {
    find_batch();
    for(int i = 1; i <= n; i++) {
        y[i] *= -1;
    }
    find_batch();
    for(int i = 1; i <= n; i++) {
        swap(x[i], y[i]);
    }
    find_batch();
    for(int i = 1; i <= n; i++) {
        y[i] *= -1;
    }
    find_batch();
    /*for(int i = 1; i <= n; i++) {
        x[i] *= -1;
        y[i] *= -1;
    }
    find_batch();
    for(int i = 1; i <= n; i++) {
        x[i] *= -1;
    }
    find_batch();
    for(int i = 1; i <= n; i++) {
        swap(x[i], y[i]);
    }
    find_batch();
    for(int i = 1; i <= n; i++) {
        x[i] *= -1;
    }
    find_batch();*/
    //sort(endpoints.begin(), endpoints.end());
    //endpoints.resize(unique(endpoints.begin(), endpoints.end()) - endpoints.begin());
}

int par[1 + maxn];
int sz[1 + maxn];

void create_set(int a) {
    par[a] = a;
    sz[a] = 1;
}

int find_set(int a) {
    if(a == par[a]) {
        return a;
    }
    return find_set(par[a]);
}

bool union_sets(int a, int b) {
    a = find_set(a), b = find_set(b);
    if(a == b) {
        return false;
    }
    if(sz[a] > sz[b]) {
        swap(a, b);
    }
    sz[b] += sz[a];
    par[a] = b;
    return true;
}

void solve() {
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> x[i] >> y[i];
    }
    vector<edge> edges;
    find_relevant_edges();
    for(const pii &p : endpoints) {
        edges.pb(edge {p.fi, p.se, abs(x[p.fi] - x[p.se]) + abs(y[p.fi] - y[p.se])});
    }
    /*for(int i = 1; i <= n; i++) {
        for(int j = i + 1; j <= n; j++) {
            edges.pb(edge {i, j, abs(x[i] - x[j]) + abs(y[i] - y[j])});
        }
    }*/
    sort(edges.begin(), edges.end());
    for(int i = 1; i <= n; i++) {
        create_set(i);
    }
    int ans = 0;
    for(edge e : edges) {
        if(union_sets(e.a, e.b)) {
            ans = max(ans, e.wei);
        }
    }
    cout << ans << "\n";
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
}