#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;
}