#include <stdio.h>
#include <math.h>
#include <string.h>
#include <vector>
#include <algorithm>

using namespace std;

#define MAX_N 810
#define inf 1000000000

#define eps 0.000001

#define mp make_pair

int n, m, s, d, k;

int viz[MAX_N], cuplaj[MAX_N];

double dmin = inf, sol;

vector <int> G[MAX_N];

bool improve;

int C[MAX_N][MAX_N], F[MAX_N][MAX_N];
double cost[MAX_N][MAX_N];

int tata[MAX_N], h[MAX_N], pos[MAX_N];
double D[MAX_N];

struct punct {
    double x, y;
} A[MAX_N], B[MAX_N];

inline double dist(int p, int q) {
    return sqrt((A[p].x - B[q].x) * (A[p].x - B[q].x) + (A[p].y - B[q].y) * (A[p].y - B[q].y));
}

void get_graph(double k) {
    for (int i = 1; i <= n; i++)
        vector <int> ().swap(G[i]);

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (dist(i, j) <= k + eps)
                G[i].push_back(j);
}

bool cupleaza(int x) {
    if (viz[x])
        return false;
    viz[x] = 1;

    for (vector <int>::iterator it = G[x].begin(); it != G[x].end(); ++it)
        if (cuplaj[*it] == 0) {
            cuplaj[*it] = x;
            m++;
            return true;
        }

    for (vector <int>::iterator it = G[x].begin(); it != G[x].end(); ++it)
        if (cuplaj[*it] != x && cupleaza(cuplaj[*it])) {
            cuplaj[*it] = x;
            return true;
        }

    return false;
}

void get_dmin() {
    double value[MAX_N * MAX_N];

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            value[(i - 1) * n + j] = dist(i, j);
    sort(value + 1, value + n * n + 1);

    int left = 0, right = n * n + 1, mid = 0;
    while (left + 1 < right) {
        mid = (left + right) / 2;

        get_graph(value[mid]);

        memset(cuplaj, 0, sizeof(cuplaj)); m = 0;

        for (int i = 1; i <= n; i++) {
            memset(viz, 0, sizeof(viz));
            cupleaza(i);
        }

        if (m == n) {
            right = mid;
            dmin = min(dmin, value[mid]);
        }
        else
            left = mid;
    }
}

void build_flow_graph() {
    s = 1; d = 2 * n + 2;

    for (int i = 1; i <= d; i++)
        vector <int> ().swap(G[i]);

    for (int i = 1; i <= n; i++) {
        G[s].push_back(i + 1); C[s][i + 1] = 1;
        G[i + 1].push_back(s);

        G[n + i + 1].push_back(d); C[n + i + 1][d] = 1;
        G[d].push_back(n + i + 1);
    }

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            if (dist(i, j) <= dmin + eps) {
                G[i + 1].push_back(n + j + 1); cost[i + 1][n + j + 1] = dist(i, j); C[i + 1][n + j + 1] = 1;
                G[n + j + 1].push_back(i + 1); cost[n + j + 1][i + 1] = -cost[i + 1][n + j + 1];
            }
}

void heap_update(int x) {
    //down-heap
    while (x > 1 && D[h[x / 2]] > D[h[x]]) {
        swap(h[x], h[x / 2]);
        pos[h[x]] = x; pos[h[x / 2]] = x / 2;

        x /= 2;
    }

    //up-heap
    while ((x * 2 <= k && D[h[x * 2]] < D[h[x]]) || (x * 2 + 1 <= k && D[h[x * 2 + 1]] < D[h[x]])) {
        int nxt = x * 2;
        if (x * 2 + 1 <= k && D[h[x * 2 + 1]] < D[h[x * 2]])
            nxt = x * 2 + 1;

        swap(h[x], h[nxt]);
        pos[h[x]] = x; pos[h[nxt]] = nxt;

        x = nxt;
    }
}

double dijkstra() {
    for (int i = 1; i <= d; i++) {
        D[i] = inf;
        tata[i] = viz[i] = 0;
    }
    D[s] = 0;

    h[k = 1] = s; pos[s] = viz[s] = 1;
    while (k) {
        int nod = h[1];

        swap(h[1], h[k]);
        pos[h[1]] = 1; pos[h[k]] = 0; k--;
        heap_update(1);

        viz[nod] = 0;

        for (vector <int>::iterator it = G[nod].begin(); it != G[nod].end(); ++it) {
            if (C[nod][*it] > F[nod][*it] && D[*it] > D[nod] + cost[nod][*it]) {
                D[*it] = D[nod] + cost[nod][*it];

                if (viz[*it] == 0) {
                    h[++k] = *it;
                    pos[*it] = k;
                }

                heap_update(pos[*it]);
                viz[*it] = 1;
                tata[*it] = nod;
            }
        }
    }

    if (D[d] != inf) {
        improve = true;

        for (int i = d; i != s; i = tata[i]) {
            F[tata[i]][i]++;
            F[i][tata[i]]--;
        }

        return D[d];
    }

    return 0;
}

void solve() {
    get_dmin();

    build_flow_graph();

    improve = true;
    while (improve) {
        improve = false;

        sol += dijkstra();
    }

    printf("%lf %lf\n", dmin, sol);
}

int main() {

    freopen("adapost.in", "r", stdin);
    freopen("adapost.out", "w", stdout);

    scanf("%d", &n);

    for (int i = 1; i <= n; i++)
        scanf("%lf %lf", &A[i].x, &A[i].y);
    for (int i = 1; i <= n; i++)
        scanf("%lf %lf", &B[i].x, &B[i].y);

    solve();

    return 0;
}