#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int MAXN = 250 + 5;
const int MAXP = MAXN * 2;

struct Vector {
    ll x, y;
    Vector(void) {}
    Vector(ll _x, ll _y): x(_x), y(_y) {}
    inline ldb len(void) const {
        return sqrtl(x * x + y * y);
    }
    bool operator == (const Vector &oth) const {
        return x == oth.x && y == oth.y;
    }
    bool operator != (const Vector &oth) const {
        return !(*this == oth);
    }
    bool operator < (const Vector &oth) const {
        return x != oth.x ? x < oth.x : y < oth.y;
    }
}
;
typedef Vector Point;

Vector operator + (const Vector &p, const Vector &q) {
    return Vector(p.x + q.x, p.y + q.y);
}
Vector operator - (const Vector &p, const Vector &q) {
    return Vector(p.x - q.x, p.y - q.y);
}
ldb dist(const Vector &p, const Vector &q) {
    return sqrtl((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}
ll cross(const Vector &p, const Vector &q) {
    return p.x * q.y - p.y * q.x;
}

void make_Hull(vector<Vector> &p) {
    if (p.size() <= 1)
        return;

    sort(p.begin(), p.end());
    static Vector A[MAXP], B[MAXP];
    int sA = 0, sB = 0;

    for (const auto &t : p) {
        if (sA && A[sA].x == t.x)
            --sA;

        while (sA >= 2 && cross(t - A[sA], t - A[sA - 1]) <= 0)
            --sA;

        A[++sA] = t;
    }

    for (const auto &t : p) {
        if (sB && B[sB].x == t.x)
            continue;

        while (sB >= 2 && cross(t - B[sB], t - B[sB - 1]) >= 0)
            --sB;

        B[++sB] = t;
    }

    if (B[sB] == A[sA])
        --sB;

    p.resize(sA + sB);

    for (int i = 1; i <= sA; ++i)
        p[i - 1] = A[i];

    for (int i = 1; i <= sB; ++i)
        p[sA + sB - i] = B[i];

    if (p.size() > 1 && p[0] == p.back())
        p.pop_back();
}

struct Hull {
    vector<Vector> p;
    ldb len;
    Hull(void) {}
    Hull(const vector<Vector> &_p) {
        p = _p;
        sort(p.begin(), p.end());
        rebuild();
    }
    void initlen(void) {
        if (!p.size()) {
            len = 0;
            return;
        }

        len = dist(p[0], p.back());

        for (int i = 0; i + 1 < (int)p.size(); ++i)
            len += dist(p[i], p[i + 1]);
    }
    void rebuild(void) {
        make_Hull(p);
        initlen();
    }
    void merge(const Hull &oth) {
        p.insert(p.end(), oth.p.begin(), oth.p.end());
        rebuild();
    }
    void merge(const Hull &A, const Hull &B) {
        p = A.p;
        merge(B);
    }
    void swap(Hull &oth) {
        p.swap(oth.p);
        ::swap(len, oth.len);
    }
};
void swap(Hull &A, Hull &B) {
    A.swap(B);
}

#define lowbit(x) ((x)&-(x))

int n;
Vector a[MAXN][2];

namespace Subtask1 {
const int ALL = (1 << 15) + 5;

ldb f[ALL], dp[ALL];

void solve(void) {
    int all = (1 << n) - 1;

    for (int mask = 0; mask <= all; ++mask) {
        vector<Vector> p;

        for (int i = 1; i <= n; ++i)
            if ((mask >> (i - 1)) & 1)
                p.emplace_back(a[i][0]),
                               p.emplace_back(a[i][1]);

        f[mask] = Hull(p).len;
    }

    for (int mask = 1; mask <= all; ++mask) {
        dp[mask] = f[mask];

        int tmp = mask ^ lowbit(mask);

        for (int nxt = tmp; nxt; nxt = (nxt - 1)&tmp)
            dp[mask] = min(dp[mask], dp[nxt] + f[mask ^ nxt]);
    }

    printf("%.20lf", (double)dp[all]);
    exit(0);
}
}

namespace Subtask2 {
void solve(void) {
    vector<Hull> _hull(n);
    vector<Vector> P;

    for (int i = 1; i <= n; ++i) {
        _hull[i - 1] = Hull({a[i][0], a[i][1]});
        P.emplace_back(a[i][0]);
        P.emplace_back(a[i][1]);
    }

    ldb beg = Hull(P).len;
    ldb ans = beg;

    for (int i = 0; i < (int)P.size(); ++i)
        for (int j = 0; j < i; ++j) {
            auto gettype = [&](const Point & u) {
                if (u == P[i])
                    return 1;

                if (u == P[j])
                    return 2;

                return cross(u - P[j], P[i] - P[j]) > 0 ? 1 : 2;
            };

            vector<Vector> A, B;
            bool ok = 1;

            for (int k = 1; k <= n; ++k) {
                int x = gettype(a[k][0]);
                int y = gettype(a[k][1]);

                if (x != y) {
                    ok = 0;
                    break;
                }

                auto &V = x == 1 ? A : B;
                V.push_back(a[k][0]);
                V.push_back(a[k][1]);
            }

            if (!ok)
                continue;

            ans = min(ans, Hull(A).len + Hull(B).len);
        }

    mt19937 rnd((unsigned long long)new char ^time(0));

    for (int rn = 1; rn <= 3; ++rn) {
        int clock_lim = clock() + (rn == 1 ? 1.2 : rn == 2 ? 0.9 : 0.8) * CLOCKS_PER_SEC;
        auto hull = _hull;
        auto chkans = [&](void) {
            ldb cur = 0;

            for (const auto &t : hull)
                cur += t.len;

            ans = min(ans, cur);
        };

        while (hull.size() > 1 && clock() < clock_lim) {
            bool succeed = 0;

            for (int i = 0; i < (int)hull.size(); ++i)
                for (int j = i + 1; j < (int)hull.size(); ++j) {
                    Hull cur;
                    cur.merge(hull[i], hull[j]);

                    if (cur.len < hull[i].len + hull[j].len) {
                        hull[i].swap(cur);

                        if (j != (int)hull.size() - 1)
                            hull[j].swap(hull.back());

                        hull.pop_back();
                        succeed = 1;
                    }
                }

            chkans();

            if (succeed)
                continue;

            shuffle(hull.begin(), hull.end(), rnd);

            bool tle = 0;

            for (int i = 0; i < (int)hull.size() && !tle; ++i)
                for (int j = i + 1; j < (int)hull.size() && !tle; ++j) {
                    Hull cur;
                    vector<int> used(hull.size());
                    used[i] = used[j] = 1;
                    cur.merge(hull[i], hull[j]);
                    ldb totlen = hull[i].len + hull[j].len;

                    for (int k = 0; k < (int)hull.size(); ++k)
                        if (!used[k]) {
                            Hull nxt;
                            nxt.merge(cur, hull[k]);

                            if (nxt.len < cur.len + hull[k].len) {
                                succeed = 1;
                                used[k] = 1;
                                totlen += hull[k].len;
                                cur.swap(nxt);
                            }
                        }

                    if (succeed && cur.len < totlen) {
                        vector<Hull> nhull = {cur};

                        for (int k = 0; k < (int)hull.size(); ++k)
                            if (!used[k])
                                nhull.push_back(hull[k]);

                        hull.swap(nhull);
                        chkans();
                    }

                    if (clock() > clock_lim)
                        tle = 1;
                }
        }
    }

    printf("%.20lf", (double)ans);
    exit(0);
}
}

int main(void) {
    //  freopen("field.in","r",stdin);
    //  freopen("field.out","w",stdout);

    scanf("%d", &n);

    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= 1; ++j) {
            int x, y;
            scanf("%d%d", &x, &y);
            a[i][j] = Vector(x, y);
        }

    if (n <= 15)
        Subtask1::solve();
    else
        Subtask2::solve();

    return 0;
}