#include <bits/stdc++.h>
using namespace std;
#define faster ios_base::sync_with_stdio(false); cin.tie(NULL)
#define Bit(mask , i) ((mask >> i) & 1)
#define fi first
#define se second
#define _LOG2(nl) 31 - __builtin_clz(nl)
#define c_bit(nl) __builtin_popcount(nl)
#define ii pair<long long , int>
#define lll pair<long long , pair<long long , long long>>
#define lii pair<long long , pair<long long , int>>
#define iii pair<int , pair<int , int>>
#define iiii pair<pair<int , int> , pair<int , int>>
#define llll pair<pair<__int128 , __int128> , pair<__int128 , __int128>>
#define li pair<long long , int>
#define db long double
#define onBit(mask , i) (mask | (1 << i))
#define offBit(mask , i) (mask & (~(1 << i)))

const long long INF = 1e16;
const int N = 5e5 + 7;
long long _min[21][N] , _max[21][N] , _min_b[21][N] , _min_c[21][N] , _min_d[21][N];
int n;

struct gv{
    long long c , s;
};

gv a[N];

bool cmp(gv x , gv y){
    return x.c < y.c;
}

void inp(){
    cin >> n;
    for (int i = 1 ; i <= n ; ++i){
        cin >> a[i].c >> a[i].s;
    }

    sort(a + 1 , a + n + 1 , cmp);
//    for (int i = 1 ; i <= n ; ++i){
//        cout << a[i].c << " " << a[i].s << '\n';
//    }
    for (int i = 1 ; i <= n ; ++i){
        _max[0][i] = a[i].s;
        _min[0][i] = a[i].s;
    }

    for (int j = 1 ; j <= 19 ; ++j){
        for (int i = 1 ; i + (1 << j) - 1 <= n ; ++i){
            _max[j][i] = max(_max[j - 1][i] , _max[j - 1][i + (1 << j - 1)]);
            _min[j][i] = min(_min[j - 1][i] , _min[j - 1][i + (1 << j - 1)]);
        }
    }
}

long long get_max(int l , int r){
    if (l > r) return 0;
    int k = _LOG2(r - l + 1);
    return max(_max[k][l] , _max[k][r - (1 << k) + 1]);
}

long long get_min(int l , int r){
    if (l > r) return INF;
    int k = _LOG2(r - l + 1);
    return min(_min[k][l] , _min[k][r - (1 << k) + 1]);
}

void ktao(){
    for (int i = 1 ; i < n ; ++i){
        _min_b[0][i] = a[i].c - get_min(i + 1 , n);
        _min_c[0][i] = a[i].c + get_max(i + 1 , n);
        _min_d[0][i] = a[i].c + get_max(i + 1 , n) - get_min(i + 1 , n);
    }
    _min_b[0][n] = a[n].c;
    _min_c[0][n] = a[n].c;
    _min_d[0][n] = a[n].c;

    for (int j = 1 ; j <= 19 ; ++j){
        for (int i = 1 ; i + (1 << j) - 1 <= n ; ++i){
            _min_b[j][i] = min(_min_b[j - 1][i] , _min_b[j - 1][i + (1 << j - 1)]);
            _min_c[j][i] = min(_min_c[j - 1][i] , _min_c[j - 1][i + (1 << j - 1)]);
            _min_d[j][i] = min(_min_d[j - 1][i] , _min_d[j - 1][i + (1 << j - 1)]);
        }
    }
}

long long get_min_b(int l , int r){
    if (l > r) return INF;
    int k = _LOG2(r - l + 1);
    return min(_min_b[k][l] , _min_b[k][r - (1 << k) + 1]);
}

long long get_min_c(int l , int r){
    if (l > r) return INF;
    int k = _LOG2(r - l + 1);
    return min(_min_c[k][l] , _min_c[k][r - (1 << k) + 1]);
}

long long get_min_d(int l , int r){
    if (l > r) return INF;
    int k = _LOG2(r - l + 1);
    return min(_min_d[k][l] , _min_d[k][r - (1 << k) + 1]);
}

long long sol(int id){
    long long res = INF;
    long long Max = get_max(1 , id - 1) , Min = get_min(1 , id - 1);
    if (id == n) return Max - Min;

    int l = id + 1 , r = n , mid , pos1 = n + 1;
    while (l <= r){
        mid = (l + r) >> 1;
        if (get_min(mid , n) >= Min && get_max(mid , n) <= Max){
            pos1 = mid;
            r = mid - 1;
        }
        else l = mid + 1;
    }
    if (pos1 <= n) res = min(res , a[pos1 - 1].c - a[id].c + Max - Min);

    l = id + 1 , r = n;
    int pos2 = id;
    while (l <= r){
        mid = (l + r) >> 1;
        if (get_min(mid , n) <= Min && get_max(mid , n) >= Max){
            pos2 = mid;
            l = mid + 1;
        }
        else r = mid - 1;
    }
    if (pos2 > id) res = min(res , get_min_d(id , pos2 - 1) - a[id].c);

    if (pos1 - pos2 <= 1) return res;
    if (get_max(pos2 + 1 , n) > Max){
        res = min(res , get_min_c(pos2 , pos1 - 2) - a[id].c - Min);
        if (pos1 > n)
            res = min(res , a[n].c - a[id].c + Max - Min);
    }
    if (get_min(pos2 + 1 , n) < Min){
        res = min(res , get_min_b(pos2 , pos1 - 2) - a[id].c + Max);
        if (pos1 > n)
            res = min(res , a[n].c - a[id].c + Max - Min);
    }

    return res;
}

void solve(){
    ktao();
    long long res = INF;
    for (int i = 1 ; i <= n ; ++i){
        res = min(res , sol(i));
    }

    cout << res;
}

int main(){
//    freopen("difmax.inp" , "r" , stdin);
//    freopen("difmax.out" , "w" , stdout);
    faster;
    inp();
    solve();
    return 0;
}