#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 LL;
typedef long double ldb;
typedef pair<int, int> pii;
const int MAXN = 500 + 5;
const ldb eps = 1e-8;

inline int sgn(ldb x) {
    return x < -eps ? -1 : x > eps ? 1 : 0;
}

struct Vector {
    ll x, y;
    Vector(void) {}
    Vector(ll _x, ll _y): x(_x), y(_y) {}
    inline ldb len(void) const {
        return sqrtl((LL)x * x + (LL)y * y);
    }
};
typedef Vector Point;

bool operator == (const Vector &p, const Vector &q) {
    return p.x == q.x && p.y == q.y;
}
bool operator != (const Vector &p, const Vector &q) {
    return !(p == q);
}
bool operator < (const Vector &p, const Vector &q) {
    return p.x != q.x ? p.x < q.x : p.y < q.y;
}
bool operator > (const Vector &p, const Vector &q) {
    return q < p;
}
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 (p - q).len();
}
LL cross(const Vector &p, const Vector &q) {
    return (LL)p.x * q.y - (LL)p.y * q.x;
}

bool inter(Vector a, Vector b, Vector c, Vector d) {
    LL x = cross(a - c, d - c), y = cross(b - c, d - c);

    if (x == 0 || y == 0 || (x < 0) == (y < 0))
        return 0;

    x = cross(c - a, b - a), y = cross(d - a, b - a);

    if (x == 0 || y == 0 || (x < 0) == (y < 0))
        return 0;

    return 1;
}

struct Hull {
    vector<Vector> v;
    ldb len;
    inline void initlen(void) {
        if (v.size() <= 1) {
            len = 0;
            return;
        }

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

        for (int i = 0; i + 1 < (int)v.size(); ++i)
            len += dist(v[i], v[i + 1]);
    }
    inline bool chkin(Vector o) const {
        if (v.size() < 1)
            return 0;

        if (v.size() == 1)
            return v[0] == o;

        if (find(v.begin(), v.end(), o) != v.end())
            return 1;

        bool res = cross(v[0] - v.back(), o - v.back()) >= 0;

        for (int i = 0; i + 1 < (int)v.size() && res; ++i)
            res &= cross(v[i + 1] - v[i], o - v[i]) >= 0;

        return res;
    }
};

Vector p[MAXN];
Hull h[MAXN];

int fa[MAXN];
inline int find(int u) {
    return fa[u] == u ? u : fa[u] = find(fa[u]);
}

int main(void) {
    int n;
    scanf("%d", &n);
    static array<Vector, 2> beg[MAXN];

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

        sort(beg[i].begin(), beg[i].end());
    }

    sort(beg + 1, beg + n + 1);

    int pcnt = 2 * n;

    for (int i = 1; i <= n; ++i)
        p[2 * i - 1] = beg[i][0], p[2 * i] = beg[i][1];

    static pair<ldb, bool> cost[MAXN][MAXN];
    static ldb dis[MAXN][MAXN];
    vector<pii> alive;

    for (int i = 1; i <= pcnt; ++i)
        for (int j = 1; j <= pcnt; ++j) {
            dis[i][j] = dist(p[i], p[j]);
            cost[i][j] = {0, i != j};

            if (i != j)
                alive.emplace_back(i, j);
        }

    static bool added[MAXN][MAXN];
    auto add_edge = [&](int u, int v) {
        if (added[u][v])
            return;

        added[u][v] = added[v][u] = 1;
        int nsiz = 0, i, j;

        for (auto t : alive) {
            tie(i, j) = t;

            if (inter(p[u], p[v], p[i], p[j]))
                cost[i][j] = {0, 0};
            else
                alive[nsiz++] = {i, j};
        }

        alive.resize(nsiz);
    };

    ldb ans = 0;

    for (int i = 1; i <= pcnt; i += 2) {
        fa[i] = fa[i + 1] = i;
        h[i].v = {p[i], p[i + 1]};
        h[i].len = dist(p[i], p[i + 1]) * 2;
        ans += h[i].len;
        add_edge(i, i + 1);
    }

    static vector< tuple<int, int, ldb>> tocost[MAXN];
    auto delcost = [&](int rt) {
        for (auto t : tocost[rt]) {
            int i, j;
            ldb k;
            tie(i, j, k) = t;

            if (cost[i][j].second)
                cost[i][j].first -= k;
        }

        tocost[rt].clear();
    };

    for (int rt = pcnt - 1; rt >= 1; rt -= 2) {
        Vector key = p[rt] + p[rt + 1];
        key.x /= 2;
        key.y /= 2;

        auto rebuild = [&](void) {
            const auto &vec = h[rt].v;

            static int in[MAXN], on[MAXN], id[MAXN];
            memset(id, 0, sizeof(id));
            memset(on, -1, (pcnt + 1) << 2);

            for (int i = 1; i <= pcnt; ++i) {
                in[i] = find(i) == find(rt) || h[rt].chkin(p[i]);

                if (!in[i])
                    continue;

                for (int j = 0; j < (int)vec.size(); ++j)
                    if (p[i] == vec[j]) {
                        on[i] = j;
                        id[j] = i;
                        in[i] = 0;
                        break;
                    }
            }

            id[(int)vec.size()] = id[0];

            for (int i = 0; i < (int)vec.size(); ++i)
                add_edge(id[i], id[i + 1]);

            int nsiz = 0, i, j;

            for (auto t : alive) {
                tie(i, j) = t;

                if (in[i] || in[j]) {
                    cost[i][j] = {0, 0};
                    continue;
                } else if (on[i] != -1 && on[j] != -1 && (on[i] + 1) % (int)vec.size() != on[j]) {
                    cost[i][j] = {0, 0};
                    continue;
                }

                alive[nsiz++] = {i, j};

                auto u = p[i], v = p[j];
                int type_u = u.x != key.x ? u.x > key.x : u.y < key.y;
                int type_v = v.x != key.x ? v.x > key.x : v.y < key.y;

                if (type_u == type_v)
                    continue;

                if (type_u && cross(u - key, v - key) >= 0) {
                    ldb k = -h[rt].len;
                    tocost[rt].emplace_back(i, j, k);
                    cost[i][j].first += k;
                }

                if (type_v && cross(v - key, u - key) > 0) {
                    ldb k = h[rt].len;
                    tocost[rt].emplace_back(i, j, k);
                    cost[i][j].first += k;
                }
            }

            alive.resize(nsiz);
        };
        rebuild();

        static int id[MAXN];
        int tot = 0;

        for (int i = rt + 1; i <= pcnt; ++i)
            id[++tot] = i;

        sort(id + 1, id + tot + 1, [&](int i, int j) {
            return cross(p[i] - p[rt], p[j] - p[rt]) > 0;
        });

        while (1) {
            static pair<ldb, int> dp[MAXN];
            auto upd = [&](int i, int j) {
                if (!cost[i][j].second)
                    return;

                ldb nxt = dp[i].first + cost[i][j].first + dis[i][j];

                if (nxt < dp[j].first)
                    dp[j] = {nxt, i};
            };

            for (int i = rt; i <= pcnt; ++i)
                dp[i] = {1e18, -1};

            dp[rt] = {0, 0};

            for (int i = rt + 1; i <= pcnt; ++i)
                upd(rt, i);

            for (int it = 1; it <= tot; ++it) {
                int i = id[it];
                upd(i, rt);

                for (int jt = it + 1; jt <= tot; ++jt)
                    upd(i, id[jt]);
            }

            if (sgn(dp[rt].first) >= 0)
                break;

            ans += dp[rt].first;

            h[rt].v.clear();

            for (int u = dp[rt].second; u != rt; u = dp[u].second)
                h[rt].v.push_back(p[u]);

            h[rt].v.push_back(p[rt]);

            delcost(rt);
            reverse(h[rt].v.begin(), h[rt].v.end());
            h[rt].initlen();

            for (int i = rt + 1; i <= pcnt; ++i)
                if (find(i) == i && h[rt].chkin(p[i])) {
                    delcost(i);
                    fa[i] = rt;
                }

            rebuild();
        }
    }

    printf("%.20lf", (double)ans / 2);
    return 0;
}