#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> P3;
typedef pair<P ,P> PP;
constexpr ll MOD = ll(1e9+7);
constexpr int IINF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;

struct SCC {
    int N;
    vector<vector<int> > g, gr, g2i, t;
    vector<bool> visited;
    vector<int> i2g;
    stack<int> order;

    SCC(){}
    SCC(int n){init(n);}
    void init(int n){
        N = n;
        g.clear();
        g.resize(n);
        gr.clear();
        gr.resize(n);
        visited.resize(n);
        i2g.resize(n);
    }
    void add_edge(int u, int v) {
        g[u].emplace_back(v);
        gr[v].emplace_back(u);
    }

    void dfs(int x) {
        if (visited[x]) return;
        visited[x] = true;
        for (int i : g[x]) dfs(i);
        order.push(x);
    }

    void rdfs(int x, int k) {
        if (i2g[x] != -1) return;
        i2g[x] = k;
        for (int i : gr[x]) rdfs(i, k);
    }

    void build() {
        fill(visited.begin(), visited.end(), false);
        fill(i2g.begin(), i2g.end(), -1);
        for (int i = 0; i < N; i++) dfs(i);
        int p = 0;
        while (!order.empty()) {
            rdfs(order.top(), p++);
            order.pop();
        }
        /*
        g2i.clear();
        g2i.resize(p);
        for(int i=0;i<N;i++){
            g2i[i2g[i]].push_back(i);
        }
        t.resize(p);
        for(int i=0;i<N;i++){
            for (auto &to : g[i]) {
                int x = i2g[i], y = i2g[to];
                if (x == y) continue;
                t[x].push_back(y);
            }
        }
        for(int i=0;i<p;i++){
            sort(t[i].begin(), t[i].end());
            t[i].erase(unique(t[i].begin(), t[i].end()),t[i].end());
        }
        */
    }
};

struct TwoSAT {
    int N;
    SCC scc;
    vector<int> ls;
    TwoSAT(){}
    TwoSAT(int n):N(n),scc(n*2){}
    void init(int n){
        N = n;
        scc.init(n*2);
    }
    int neg(int a){return (a+N)%(N*2);}
    void add_edge(int a, int b){
        scc.add_edge(a,b);
    }
    void add_if(int a, int b){
        // a -> b <=> !b -> !a
        add_edge(a,b);
        add_edge(neg(b),neg(a));
    }
    void add_iff(int a, int b){
        // (a <=> b) <=> a -> b and b -> a
        add_edge(a,b);
        add_edge(b,a);
    }
    void add_or(int a, int b){
        // a or b <=> !a -> b and !b -> a
        add_if(neg(a),b);
    }
    void add_nand(int a, int b){
        // a nand b <=> a -> !b and b -> !a
        add_if(a, neg(b));
    }
    void add_xor(int a, int b){
        add_nand(a, b);
        add_or(a,b);
    }
    void set_true(int a){
        // a <=> !a -> a
        add_edge(neg(a), a);
    }
    void set_false(int a){
        // !a <=> a -> !a
        add_edge(a, neg(a));
    }
    bool build(){
        scc.build();
        bool ok = true;
        for(int i=0;i<N;i++){
            ok &= scc.i2g[i] != scc.i2g[neg(i)];
        }
        if(ok){
            for(int i=0;i<N;i++){
                if(scc.i2g[i] > scc.i2g[neg(i)]){
                    ls.push_back(1);
                }
                else{
                    ls.push_back(0);
                }
            }
        }
        return ok;
    }
};

int n, m = 1;
vector<P> pos;

void add(int a, int b, int x, int l, int r, int k, TwoSAT &ts){
    if(r <= a || b <= l) return;
    else if(a <= l && r <= b){
        ts.add_nand(x, k);
    }
    else{
        add(a,b,x,l,(l+r)/2,k*2+1,ts);
        add(a,b,x,(l+r)/2,r,k*2+2,ts);
    }
    return;
}

bool f(ll mid, TwoSAT ts){
    // i番目の葉の頂点から[i+1,j)にNANDの辺を張る
    for(int i=0;i<n*2;i++){
        int j = lower_bound(pos.begin(),pos.end(),P(pos[i].first+mid,-1)) - pos.begin();
        add(i+1,j,i+m-1,0,m,0,ts);
    }
    return ts.build();
}



int main(){
    cin >> n;
    // 直線上に並べる
    for(int i=0;i<n;i++){
        ll x, y;
        cin >> x >> y;
        pos.emplace_back(P(x,i));
        pos.emplace_back(P(y,i));
    }
    sort(pos.begin(), pos.end());

    // セグメント木上で2-SATを行う
    while(m < n*2) m <<= 1;
    TwoSAT ts(m*2-1);

    // x,yのいずれかは使用する制約を追加
    vector<int> idx(n, -1);
    for(int i=0;i<n*2;i++){
        int j = pos[i].second;
        if(idx[j] == -1) idx[j] = i;
        else ts.add_xor(idx[j]+m-1, i+m-1);
    }
    // 子が真ならば親も真
    for(int i=0;i<m-1;i++){
        ts.add_if(i*2+1,i);
        ts.add_if(i*2+2,i);
    }

    // dを二分探索
    ll ok = 0, ng = 1<<30;
    while(abs(ok-ng)>1){
        ll mid = (ok+ng)/2;
        if(f(mid, ts)){
            ok = mid;
        }
        else{
            ng = mid;
        }
    }
    cout << ok << endl;
    return 0;
}

Measured memory_bytes: 38972