#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
 
typedef long long ll;

// (L, R, id)
// 降順に並べて (昇順に並べた上で後ろから見て) L の最大値を見る
struct data1{
    int left, right, id;
    // デフォルトコンストラクタとしても作用させるために、デフォルト引数を用意しておく。
    data1(int left=0, int right=0, int id=0) : left(left), right(right), id(id) {}
    bool operator<(const data1 &other){
        if(left == other.left){
            if(right == other.right){
                return id < other.id;
            }
            return right > other.right;
        }
        return left < other.left;
    }
};

// (R, L, id)
// 昇順に並べて R の最小値を見る
struct data2{
    int right, left, id;
    data2(int right=0, int left=0, int id=0) : right(right), left(left), id(id) {}
    bool operator<(const data2 &other){
        if(right == other.right){
            if(left == other.left){
                return id < other.id;
            }
            return left < other.left;
        }
        return right < other.right;
    }
};

template<typename Monoid>
struct SegmentTree{
    using F = function<Monoid(Monoid, Monoid)>;

    int sz;
    vector<Monoid> seg;

    const F f;      // モノイドに対して二項演算を行う関数オブジェクト
    const Monoid M1;

    SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1){
        sz = 1;
        while(sz < n)   sz <<= 1;
        seg.assign(2 * sz, M1);
    }

    void set(int k, const Monoid &x){
        seg[k + sz] = x;
    }

    void build(){
        for(int k = sz - 1; k > 0; --k){
            seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
        }
    }

    void update(int k, const Monoid &x){
        k += sz;
        seg[k] = x;
        while(k >>= 1){
            seg[k] = f(seg[k << 1], seg[k << 1 | 1]);
        }
    }

    Monoid query(int a, int b){
        Monoid L = M1, R = M1;
        for(a += sz, b += sz; a < b; a >>= 1, b >>= 1){
            if(a & 1)   L = f(L, seg[a++]);
            if(b & 1)   R = f(seg[--b], R);
        }
        return f(L, R);
    }

    Monoid operator[](const int &k) const{
        return seg[k + sz];
    }

    // type=true : find_last
    // type=false : find_first
    template<typename C>
    int find_subtree(int a, const C &check, Monoid &M, bool type){
        while(a < sz){
            Monoid nxt = type ? f(seg[a << 1 | type], M) : f(M, seg[a << 1 | type]);
            if(check(nxt))  a = a << 1 | type;
            else M = nxt, a = 2 * a + 1 - type;
        }
        return a = sz;
    }

    template<typename C>
    int find_first(int a, const C &check){
        Monoid L = M1;
        if(a <= 0){
            if(check(f(L, seg[1]))) return find_subtree(1, check, L, false);
            return -1;
        }
        int b = sz;
        for(a += sz, b += sz; a < b; a >>= 1, b >>= 1){
            if(a & 1){
                Monoid nxt = f(L, seg[a]);
                if(check(nxt))  return find_subtree(a, check, L, false);
                L = nxt;
                ++a;
            }
        }
        return -1;
    }

    template<typename C>
    int find_last(int b, const C &check){
        Monoid R = M1;
        if(b >= sz){
            if(check(f(seg[1], R))) return find_subtree(1, check, R, true);
            return -1;
        }
        int a = sz;
        for(b += sz; a < b; a >>= 1, b >>= 1){
            if(b & 1){
                Monoid nxt = f(seg[--b], R);
                if(check(nxt))  return sub_tree(b, check, R, true);
                R = nxt;
            }
        }
        return -1;
    }
};

int main(){
    int n;
    cin >> n;
    vector<data1> LR(n);    // L を昇順に並べる
    vector<data2> RL(n);    // R を昇順に並べる
    for(int i = 0; i < n; ++i){
        int l, r;
        cin >> l >> r;
        ++r;
        LR[i] = data1(l, r, i);
        RL[i] = data2(r, l, i);
    }
    sort(LR.begin(), LR.end());
    sort(RL.begin(), RL.end());

    // 一致する場合
    if(LR[n-1].id == RL[0].id){
        int res = RL[0].right - RL[0].left;
        int tmp = 0;
        for(int i = 0; i < n-1; ++i){
            tmp = max(tmp, LR[i].right - LR[i].left);
        }
        res += tmp;
        cout << res << "\n";
        return 0;
    }


    // セグ木構築
    // LR のある区間で R の最小値を取るセグ木
    SegmentTree<int> seg_LR_Rmin(n, [](int a, int b){return min(a, b);}, numeric_limits<int>::max());
    // LR のある区間で L の最大値を取るセグ木
    SegmentTree<int> seg_LR_Lmax(n, [](int a, int b){return max(a, b);}, 0);
    // RL のある区間で R の最小値を取るセグ木
    SegmentTree<int> seg_RL_Rmin(n, [](int a, int b){return min(a, b);}, numeric_limits<int>::max());
    // RL のある区間で L の最大値を取るセグ木
    SegmentTree<int> seg_RL_Lmax(n, [](int a, int b){return max(a, b);}, 0);
    // L の最大値と R の最小値に関わる部分は、単位元を入れておく。
    seg_LR_Lmax.set(0, 0);
    seg_LR_Rmin.set(0, numeric_limits<int>::max());
    seg_RL_Lmax.set(n-1, 0);
    seg_RL_Rmin.set(n-1, numeric_limits<int>::max());
    for(int i = 0; i < n; ++i){
        if(i != 0){
            seg_LR_Rmin.set(i, LR[i].right);
            seg_LR_Lmax.set(i, LR[i].left);
        }
        if(i != n-1){
            seg_RL_Rmin.set(i, RL[i].right);
            seg_RL_Lmax.set(i, RL[i].left);
        }
    }
    seg_LR_Rmin.build();
    seg_LR_Lmax.build();
    seg_RL_Rmin.build();
    seg_RL_Lmax.build();

    // 一致しない場合
    int res = 0;
    // 同日開催
    int tmp1 = 0;
    int tmp2 = 0;
    for(int i = 0; i < n-1; ++i){
        if(LR[i].id == RL[0].id)  continue;

        tmp1 = max(0, (RL[0].right - LR[n-1].left));
        tmp1 = max(tmp1, max(0, min({LR[0].right, seg_LR_Rmin.query(0, i), seg_LR_Rmin.query(i+1, n)}) - max(seg_LR_Lmax.query(0, i), seg_LR_Lmax.query(i+1, n))));
        tmp2 = LR[i].right - LR[i].left;

        res = max(res, tmp1 + tmp2);
    }

    // 別日開催
    // R の最小値を含む開催日
    // tmp2 以外を全て同日開催にする
    tmp1 = max(0, min(RL[0].right, seg_LR_Rmin.query(0, n-1)) - max(RL[0].left, seg_LR_Lmax.query(0, n-1)));
    tmp2 = LR[n-1].right - LR[n-1].left;    // L の最大値を含む開催日
    res = max(res, tmp1 + tmp2);
    // 貪欲法
    // tmp1 と同日開催しているコンテストを tmp2 側に入れていく
    for(int i = n-2; i >= 0; --i){
        if(LR[i].id == RL[0].id)    continue;
        
        tmp1 = RL[0].right - max(RL[0].left, seg_LR_Lmax.query(0, i+1));
        tmp2 = min(LR[n-1].right, seg_LR_Rmin.query(i+1, n)) - LR[n-1].left;

        res = max(res, tmp1 + tmp2);
    }
    
    tmp1 = RL[0].right - RL[0].left;    // tmp1 以外を全て同一開催にする
    tmp2 = max(0, min(LR[n-1].right, seg_RL_Rmin.query(1, n)) - max(LR[n-1].left, seg_RL_Lmax.query(1, n)));
    res = max(res, tmp1 + tmp2);
    // 貪欲法
    // tmp2 と同日開催しているコンテストを tmp1 側に入れていく
    for(int i = 1; i < n; ++i){
        if(RL[i].id == LR[n-1].id)  continue;
 
        tmp1 = RL[0].right - max(RL[0].left, seg_RL_Lmax.query(0, i+1));
        tmp2 = min(LR[n-1].right, seg_RL_Rmin.query(i+1, n)) - LR[n-1].left;
 
        res = max(res, tmp1 + tmp2);
    }

    cout << res << "\n";
}

Measured memory_bytes: 6656