#include <bits/stdc++.h>

using i64 = int64_t;
constexpr int MAXN = 2e5 + 19;

struct BIT {
    int n;
    std::vector<int> tr;
    explicit BIT(int n) : n(n), tr(n + 1) {}
    void update(int x, int k) {
        for (; x <= n; x += x & -x) {
            tr[x] += k;
        }
    }
    int query(int rk) {
        int now = 0, tot = 0;
        for (int i = 20; i >= 0; --i) {
            if (now + (1 << i) <= n && tot + tr[now + (1 << i)] < rk) {
                now += 1 << i;
                tot += tr[now];
            }
        }
        return now + 1;
    }
};

struct DSU {
    std::vector<int> fa;
    explicit DSU(int n) : fa(n) {
        std::iota(fa.begin(), fa.end(), 0);
    }
    int find(int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    }
    void merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x != y) {
            fa[x] = y;
        }
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;

    std::vector<std::pair<int, int>> p(n);
    std::vector<int> a;
    for (int i = 0; i < n; ++i) {
        auto &[x, y] = p[i];
        std::cin >> x >> y;
    }

    auto work = [&](std::vector<std::pair<int, int>> p) {
        for (auto [x, y] : p) {
            a.push_back(x);
            a.push_back(y);
        }
        std::sort(a.begin(), a.end());
        std::vector<uint8_t> type(n * 2 + 1);
        DSU dsu(n * 2 + 1);
        for (auto [x, y] : p) {
            x = std::lower_bound(a.begin(), a.end(), x) - a.begin() + 1;
            y = std::lower_bound(a.begin(), a.end(), y) - a.begin() + 1;
            type[x] = 1;
            type[y] = 0;
            dsu.merge(x, y);
        }

        std::vector<uint8_t> used(n * 2 + 1);
        std::array<BIT, 2> mt{BIT{n * 2}, BIT{n * 2}};
        for (int i = 1; i <= n * 2; ++i) {
            mt[type[i]].update(i, 1);
        }

        i64 ans = 0;
        int paired = 0;
        for (int i = n * 2; i >= 1; --i) {
            if (used[i]) {
                continue;
            }
            ++paired;

            int x = mt[type[i] ^ 1].query(1);
            if (paired != n && dsu.find(x) == dsu.find(i)) {
                x = mt[type[i] ^ 1].query(2);
                assert(!used[x]);
            }

            used[i] = true;
            mt[type[i]].update(i, -1);
            used[x] = true;
            mt[type[x]].update(x, -1);

            dsu.merge(i, x);

            assert(type[i] != type[x]);

            ans += a[i - 1] - a[x - 1];
        }
        assert(paired == n);

        return ans;
    };

    i64 ans = work(p);
    for (auto &[x, y] : p) {
        x = -x, y = -y;
    }
    ans = std::max(ans, work(p));

    std::cout << ans << '\n';
}