#include <bits/stdc++.h>

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

struct BIT {
    int n;
    int tr[MAXN];
    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;
    }
} mt[2];

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;
        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);
    mt[0].n = n * 2;
    mt[1].n = 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);

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