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

int main() {
    int n;
    cin >> n;
    vector<pair<int, int>> intervals(n);
    for (int i = 0; i < n; i++) {
        cin >> intervals[i].first >> intervals[i].second;
    }

    // Sắp xếp theo thời gian kết thúc
    sort(intervals.begin(), intervals.end(), [](pair<int, int> a, pair<int, int> b) {
        if (a.second != b.second) return a.second < b.second;
        return a.first > b.first;
    });

    vector<int> dp(n);
    for (int i = 0; i < n; i++) {
        dp[i] = intervals[i].second - intervals[i].first;
    }

    int ans = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (intervals[i].first >= intervals[j].second) {
                dp[i] = max(dp[i], dp[j] + intervals[i].second - intervals[i].first);
            }
        }
        ans = max(ans, dp[i]);
    }

    cout << ans << endl;
    return 0;
}

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

struct Vip {
    int start, end;
};

bool compare(Vip a, Vip b) {
    return a.end < b.end;
}

int n;
Vip a[10005];
int Dp[10005];

// Tìm chỉ số lớn nhất j sao cho a[j].end <= x
int TKNP(int x) {
    int l = 0, r = n + 1;
    while (r - l > 1) {
        int mid = (l + r) / 2;
        if (a[mid].end <= x) l = mid;
        else r = mid;
    }
    return l;
}

main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i].start >> a[i].end;
    }
    sort(a + 1, a + n + 1, compare);

    for (int i = 1; i <= n; i++) {
        int time = a[i].end - a[i].start;
        int j = TKNP(a[i].start); // Tìm index thỏa mãn
        Dp[i] = max(Dp[i - 1], Dp[j] + time);
    }
    cout << Dp[n];
    return 0;
}

// Code tham khảo logic từ Solution 2
#include <bits/stdc++.h>
using namespace std;

struct Interval {
    int start, end, duration;
};

bool compareEnd(const Interval& a, const Interval& b) {
    return a.end < b.end;
}

int main() {
    int n;
    cin >> n;
    vector<Interval> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i].start >> a[i].end;
        a[i].duration = a[i].end - a[i].start;
    }

    // Sắp xếp theo thời gian kết thúc
    sort(a.begin(), a.end(), compareEnd);

    // Priority queue lưu các khoảng thời gian có thể ghép nối trước đó
    // Lưu {duration, end_time}
    priority_queue<pair<int, int>> pq;

    int max_time = 0;

    for (int i = 0; i < n; i++) {
        // Loại bỏ các khoảng đã qua mà không thể nối với interval hiện tại
        while (!pq.empty() && pq.top().second > a[i].start) {
            pq.pop();
        }

        int current_best = a[i].duration;
        if (!pq.empty()) {
            current_best = max(current_best, pq.top().first + a[i].duration);
        }

        // Cập nhật kết quả
        max_time = max(max_time, current_best);

        // Đẩy vào hàng đợi
        pq.push({current_best, a[i].end});
    }

    cout << max_time << endl;
    return 0;
}