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

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)

using ll = long long;
using ld = long double;
ll INF = LLONG_MAX;

using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;

namespace output {
	void pr(int x) { cout << x; }
	void pr(long x) { cout << x; }
	void pr(ll x) { cout << x; }
	void pr(unsigned x) { cout << x; }
	void pr(unsigned long x) { cout << x; }
	void pr(unsigned long long x) { cout << x; }
	void pr(float x) { cout << x; }
	void pr(double x) { cout << x; }
	void pr(ld x) { cout << x; }
	void pr(char x) { cout << x; }
	void pr(const char* x) { cout << x; }
	void pr(const string& x) { cout << x; }
	void pr(bool x) { pr(x ? "true" : "false"); }
	template<class T> void pr(const complex<T>& x) { cout << x; }
	
	template<class T1, class T2> void pr(const pair<T1,T2>& x);
	template<class T> void pr(const T& x);
	
	template<class T, class... Ts> void pr(const T& t, const Ts&... ts) { 
		pr(t); pr(ts...); 
	}
	template<class T1, class T2> void pr(const pair<T1,T2>& x) { 
		pr("{",x.first,", ",x.second,"}"); 
	}
	template<class T> void pr(const T& x) { 
		pr("{"); // const iterator needed for vector<bool>
		bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0; 
		pr("}");
	}
	
	void print() { pr("\n"); } // print w/ spaces
	template<class T, class... Ts> void print(const T& t, const Ts&... ts) { 
		pr(t); if (sizeof...(ts)) pr(" "); print(ts...); 
	}
}

using namespace output;

template<class T> struct MinSeg { 
	const T ID = LLONG_MAX; // comb(ID,b) must equal b
	T combine(T a, T b) { return min(a, b);} 
	int n; vector<T> seg;
	void init(int _n) { n = _n; seg.assign(2*n,ID);}

	void update(int p, T value) {	// set value at position p
		seg[p += n] = value;
		for (p /= 2; p; p /= 2) seg[p] = combine(seg[2*p], seg[2*p+1]);
	}

	T query(int l, int r) {	 // sum on interval [l, r]
		T ra = ID, rb = ID; 
		for (l += n, r += n+1; l < r; l /= 2, r /= 2) {
			if (l&1) ra = combine(ra,seg[l++]);
			if (r&1) rb = combine(seg[--r],rb);
		}
		return combine(ra,rb);
	}
};

MinSeg<ll> minSeg;

int solve1(vector<pii> probs) {
	// Assume min(R) and max(R) are in same set
	auto minR = min_element(probs.begin(), probs.end(), [] (const pii lhs, const pii rhs) {
		return lhs.second < rhs.second || (lhs.second == rhs.second && lhs.first > rhs.first);
	});

	auto maxL = max_element(probs.begin(), probs.end(), [] (const pii lhs, const pii rhs) {
		return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second);
	});

	int largest = 0;
	for (auto it = probs.begin(); it != probs.end(); ++it) {
		if (it != minR && it != maxL) largest = max(largest, (*it).second - (*it).first);
	}
	return largest + max((*minR).second - (*maxL).first, 0);
}

pii minRP;
pii maxLP;
int solve2(vector<pii> probs) {
	// Assume min(R) and max(R) are in different sets

	auto minR = min_element(probs.begin(), probs.end(), [] (const pii lhs, const pii rhs) {
		return lhs.second < rhs.second || (lhs.second == rhs.second && lhs.first > rhs.first);
	});
	minRP = *minR;
	probs.erase(minR);

	auto maxL = max_element(probs.begin(), probs.end(), [] (const pii lhs, const pii rhs) {
		return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second);
	});
	maxLP = *maxL;
	probs.erase(maxL);

	sort(probs.begin(), probs.end());
	minSeg.init(probs.size());
	F0R(i, probs.size()) minSeg.update(i, probs[i].second);
	
	int best = max(minRP.second - minRP.first, 0) + max((int)minSeg.query(0, probs.size()-1) - maxLP.first, 0);
	F0R(i, probs.size()) {
		int r = (i != probs.size() - 1) ? minSeg.query(i+1, probs.size()-1) : maxLP.second;
		best = max(best, max(minRP.second - max(minRP.first, probs[i].first), 0) + max(min(maxLP.second, (int)r) - maxLP.first, 0));
	}
	if (probs.size() == 0) best = max(minRP.second - minRP.first, 0) + max(maxLP.second - maxLP.first, 0);
	return best;
}
int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

	int N; cin >> N;

	vector<pii> probs (N);
	F0R(i, N) {
		int L, R; cin >> L >> R; R++;
		probs[i] = {L, R};
	}

	print(max(solve1(probs),solve2(probs)));
	
}

Measured memory_bytes: 4224