//thatsramen

#include <bits/stdc++.h>

#define eb emplace_back
#define pb push_back
#define ft first
#define sd second
#define pi pair<int, int>
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define dbg(...) dbg_out(__VA_ARGS__)

using ll = long long;
using ld = long double;
using namespace std;

//Constants
const ll INF = 5 * 1e18;
const int IINF = 2 * 1e9;
//const ll MOD = 1e9 + 7;
const ll MOD = 998244353;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ld PI = 3.14159265359;

//Templates
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) {return os << '(' << p.first << ", " << p.second << ')';}
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) {os << '['; string sep; for (const T &x : v) os << sep << x, sep = ", "; return os << ']';}
void dbg_out() {cerr << endl;}
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << H << ' '; dbg_out(T...); }
template<typename T> bool mins(T& x, T y) { if (x > y) { x = y; return true; } return false; }
template<typename T> bool maxs(T& x, T y) { if (x < y) { x = y; return true; } return false; }

//order_of_key(k): number of elements strictly less than k
//find_by_order(k): k-th element in the set

void setPrec() {cout << fixed << setprecision(15);}
void unsyncIO() {cin.tie(0)->sync_with_stdio(0);}
void setIn(string s) {freopen(s.c_str(), "r", stdin);}
void setOut(string s) {freopen(s.c_str(), "w", stdout);}
void setIO(string s = "") {
    unsyncIO(); setPrec();
    if(s.size()) setIn(s + ".in"), setOut(s + ".out");
}

// #define TEST_CASES

struct DSU {
    vector<int> e;
    vector<int> mn, mx;
    DSU (int n) : e(n + 5, -1), mn(n + 5, IINF), mx(n + 5, -IINF) {}
    int get(int x) { return e[x] <= -1 ? x : e[x] = get(e[x]); }
    int sz(int x) { return -e[get(x)]; }
    bool same(int x, int y) { return get(x) == get(y); }
    bool unite(int x, int y) {
        x = get(x), y = get(y);
        if (x == y) return false;
        if (-e[x] < -e[y]) swap(x, y);
        e[x] += e[y]; e[y] = x;
        mins(mn[x], mn[y]);
        maxs(mx[x], mx[y]);
        return true;
    }
};

void solve() {
    int n;
    cin >> n;
    vector<pi> ps(n), xs(n), ys(n);
    for (int i = 0; i < n; i++) {
        cin >> ps[i].ft >> ps[i].sd;
        xs[i] = {ps[i].ft + ps[i].sd, i};
        ys[i] = {ps[i].ft - ps[i].sd, i};
    }
    sort(all(xs)); sort(all(ys));
    vector<int> l(n), r(n);
    vector<DSU> dd(2, DSU(n + 5));
    DSU dsu(n + 5);
    vector<bool> vis(n + 5, false);
    queue<int> que;
    auto bfs = [&](int st, vector<pi> &ar, int par) {
        que.push(st);
        vis[st] = true;
        while (!que.empty()) {
            int v = que.front();
            que.pop();
            int i = l[v];
            while (i >= 0) {
                if (vis[i]) {
                    int nxt = dd[par].mn[dd[par].get(i)];
                    i = nxt - 1;
                    // dbg("nxt", min(dd[par].mn[dd[par].get(i)], i));
                    assert(i < 0 || !vis[i]);
                } else {
                    vis[i] = true;
                    // dbg("new edge:", ar[v].sd, ar[i].sd);
                    dsu.unite(ar[v].sd, ar[i].sd);
                    if (i + 1 < n && vis[i + 1]) {
                        dd[par].unite(i, i + 1);
                    }
                    if (i - 1 >= 0 && vis[i - 1]) {
                        dd[par].unite(i, i - 1);
                    }
                    que.push(i);
                    i--;
                }
            }
            i = r[v];
            while (i < n) {
                if (vis[i]) {
                    int nxt = dd[par].mx[dd[par].get(i)];
                    i = nxt + 1;
                    assert(i >= n || !vis[i]);
                } else {
                    vis[i] = true;
                    // dbg("new edge:", ar[v].sd, ar[i].sd);
                    dsu.unite(ar[v].sd, ar[i].sd);
                    if (i + 1 < n && vis[i + 1]) {
                        dd[par].unite(i, i + 1);
                    }
                    if (i - 1 >= 0 && vis[i - 1]) {
                        dd[par].unite(i, i - 1);
                    }
                    que.push(i);
                    i++;
                }
            }
        }
    };
    auto go = [&](ll d, vector<pi> &ar, int par) {
        for (int i = 0, j = 0; i < n; i++) {
            while (j < n && ar[i].ft - ar[j].ft >= d) {
                j++;
            } 
            l[i] = j - 1;
            vis[i] = false;
        }
        for (int i = n - 1, j = n - 1; i >= 0; i--) {
            while (j >= 0 && ar[j].ft - ar[i].ft >= d) {
                j--;
            } 
            r[i] = j + 1;
        }
        // dbg(ar);
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                bfs(i, ar, par);
            }
        }
    };
    auto ok = [&](ll d) -> bool {
        for (int i = 0; i < n; i++) {
            dd[0].e[i] = dd[1].e[i] = dsu.e[i] = -1;
        }
        iota(all(dd[0].mn), 0);
        iota(all(dd[0].mx), 0);
        iota(all(dd[1].mn), 0);
        iota(all(dd[1].mx), 0);
        // dbg("xs:");
        go(d, xs, 0);
        // dbg("ys:");
        go(d, ys, 1);
        return dsu.sz(0) == n;
    };
    ll lo = 1, hi = 2ll * 1000 * 1000 * 1000 + 5, res = 1;
    // ll lo = 1, hi = 30, res = 1;
    while (lo <= hi) {
        ll mi = (lo + hi) / 2;
        // dbg("here mi", mi);
        if (ok(mi)) {
            res = mi;
            lo = mi + 1;
        } else {
            hi = mi - 1;
        }
    }
    cout << res;
}

int main() {
    setIO();

    int tt = 1;
    #ifdef TEST_CASES
        cin >> tt;
    #endif

    while (tt--)
        solve();

    return 0;
}