#include <iostream>
#include <set>
#include <vector>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
#include <queue>

using namespace std;

using ll = long long;
#define umap unordered_map
#define uset unordered_set
#define int ll

namespace std {
    template<typename T, typename U>
    struct hash<pair<T, U>> {
        size_t operator()(const pair<T, U> &a) const {
            return std::hash<T>()(a.first) ^ (std::hash<U>()(a.second) << 10);
        }
    };
}


struct State {
    pair<ll, ll> node;
    uset<pair<ll, ll>> seen;
    ll dist;

    bool operator < (const State & other) const {
        return dist > other.dist;
    }
};


signed main() {
    int cunt = 0;
    cin >> cunt;
    pair<ll, ll> c;
    uset<pair<ll, ll>> nodes;
    map<ll, vector<ll>> positions;
    for (int i = 0; i < cunt; ++i) {
        cin >> c.first;
        cin >> c.second;
        nodes.insert(c);

        positions[c.first].push_back(c.second);
    }

    for (auto & position : positions) {
        sort(position.second.begin(), position.second.end());
    }

    auto run = [&](pair<ll, ll> begin) -> ll {
        priority_queue<State> q;
        q.push({ begin, { begin }, 0 });

        while (!q.empty()) {
            State s = q.top();
            q.pop();

            if (s.seen.size() == nodes.size()) {
                return s.dist;
            }

            bool seenAll = true;
            for (auto neighbour : positions[s.node.first]) {
                pair<ll, ll> c = { s.node.first, neighbour };
                if (s.seen.count(c)) continue;

                seenAll = false;
                uset<pair<ll, ll>> nseen = s.seen;
                nseen.insert(c);
                State ns = { c, nseen, s.dist + abs(c.first - s.node.first) + abs(c.second - s.node.second) };
                q.push(ns);
            }

            if (seenAll) {
                auto nextLevel = positions.upper_bound(s.node.first);
                if (nextLevel == positions.end()) continue;

                for (auto neighbour : nextLevel->second) {
                    pair<ll, ll> c = { nextLevel->first, neighbour };
                    if (s.seen.count(c)) continue;

                    seenAll = false;
                    uset<pair<ll, ll>> nseen = s.seen;
                    nseen.insert(c);
                    State ns = { c, nseen, s.dist + abs(c.first - s.node.first) + abs(c.second - s.node.second) };
                    q.push(ns);
                }
            }
        }

        return -1;
    };

    ll sx = positions.begin()->first;
    pair<ll, ll> sa = { sx, positions[sx].front() };
    pair<ll, ll> sb = { sx, positions[sx].back() };
    ll correct = min(run(sa), run(sb));

    if (correct == -1) {
        goto ret;
    }
    cout << correct << endl;

    ret:
    return 0;
}