#include<stdio.h>
#include<vector>
#include<cmath>
#include<algorithm>
#include<queue>

#define maxn 405
#define pb push_back
#define mp make_pair
#define INF (1<<29)
#define eps (1e-4)

using namespace std;

FILE*f=fopen("adapost.in","r");
FILE*g=fopen("adapost.out","w");

int n;
int L[maxn],R[maxn],viz[maxn];
double v[maxn*maxn],lim,Dist[maxn<<1],prep[maxn][maxn];
int S,D;
int Cp[maxn<<1][maxn<<1],F[maxn<<1][maxn<<1],inQ[maxn<<1],T[maxn<<1];
vector< pair<int,double> >G[maxn];
vector<int>V[maxn<<1]; queue<int>Q;
double cost[maxn<<1][maxn<<1];

struct pct{
    double x,y;
}A[maxn],B[maxn];

inline void citire () {

    fscanf(f,"%d",&n);
    for ( int i = 1 ; i <= n ; ++i ){
        fscanf(f,"%lf %lf",&A[i].x,&A[i].y);
    }
    for ( int i = 1 ; i <= n ; ++i ){
        fscanf(f,"%lf %lf",&B[i].x,&B[i].y);
    }
}

inline double dist ( const pct &a , const pct &b ){
    double d = (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y);
    return sqrt(d);
}

bool pairup ( int nod ){
    if ( viz[nod] ) return 0;
    viz[nod] = 1;

    for ( vector< pair<int,double> >::iterator itt = G[nod].begin() ; itt != G[nod].end() ; ++itt ){
        int nodvcn = itt->first; double cost = itt->second;
        if ( cost <= lim ){
            if ( !R[nodvcn] ){
                L[nod] = nodvcn; R[nodvcn] = nod;
                return 1;
            }
        }
    }

    for ( vector< pair<int,double> >::iterator itt = G[nod].begin() ; itt != G[nod].end() ; ++itt ){
        int nodvcn = itt->first; double cost = itt->second;
        if ( cost <= lim ){
            if ( pairup(R[nodvcn]) ){
                L[nod] = nodvcn; R[nodvcn] = nod;
                return 1;
            }
        }
    }

    return 0;
}

inline bool cuplaj () {

    for ( int i = 1 ; i <= n ; ++i ) L[i] = R[i] = 0;
    int ok = 1;
    do{
        ok = 0; for ( int i = 1 ; i <= n ; ++i ) viz[i] = 0;
        for ( int i = 1 ; i <= n ; ++i ){
            if ( !L[i] )
                ok |= pairup(i);
        }
    }while(ok);

    int cuplaj = 0;
    for ( int i = 1 ; i <= n ; ++i ){
        if ( L[i] ){
            ++cuplaj;
        }
    }

    return cuplaj == n;
}

inline void build () {

    for ( int i = 1 ; i <= n ; ++i ){
        G[i].clear();
    }

    for ( int i = 1 ; i <= n ; ++i ){
        for ( int j = 1 ; j <= n ; ++j ){
            if ( prep[i][j] <= lim ){
                G[i].pb(mp(j,prep[i][j]));
            }
        }
    }
}

inline void first () {

    int index = 0;
    for ( int i = 1 ; i <= n ; ++i ){
        for ( int j = 1 ; j <= n ; ++j ){
            v[++index] = dist(A[i],B[j]);
            prep[i][j] = v[index];
        }
    }
    sort(v+1,v+index+1);

    int p = 1,m,u = index;
    while ( p <= u ){
        m = (p + u) >> 1;
        lim = v[m];

        build();
        if ( cuplaj() ){
            u = m - 1;
        }
        else{
            p = m + 1;
        }
    }

    lim = v[p];
    fprintf(g,"%.5lf ",lim);
}

inline bool bellman_ford () {

    Q.push(S); inQ[S] = 1;

    for ( int i = 1 ; i <= D ; ++i ){
        Dist[i] = INF;
    }
    Dist[S] = 0;

    while ( !Q.empty() ){
        int nod = Q.front(); Q.pop(); inQ[nod] = 0;

        for ( vector<int>::iterator itt = V[nod].begin() ; itt != V[nod].end() ; ++itt ){
            int nodvcn = (*itt);
            if ( Dist[nodvcn] > Dist[nod] + cost[nod][nodvcn] && F[nod][nodvcn] < Cp[nod][nodvcn] ){
                Dist[nodvcn] = Dist[nod] + cost[nod][nodvcn]; T[nodvcn] = nod;
                if ( !inQ[nodvcn] ){
                    Q.push(nodvcn);
                    inQ[nodvcn] = 1;
                }
            }
        }
    }

    return Dist[D] != INF;
}

inline void flux () {
    double flow_cost = 0;

    while ( bellman_ford() ){

        int nod;
        for ( nod = D ; T[nod] ; nod = T[nod] ){
            ++F[T[nod]][nod];
            --F[nod][T[nod]];
        }

        flow_cost += Dist[D];
    }

    fprintf(g,"%.5lf\n",flow_cost);
}

inline bool equal ( const double &a , const double &b ){
    double dif = a-b;
    if ( dif < 0 )   dif = -dif;
    return dif < eps;
}

inline void second () {
    S = n+n+1; D = n+n+2;

    for ( int i = 1 ; i <= n ; ++i ){
        V[S].pb(i); V[i].pb(S);
        Cp[S][i] = 1;
    }

    for ( int i = 1 ; i <= n ; ++i ){
        for ( int j = 1 ; j <= n ; ++j ){
            int nod = j + n;
            cost[i][nod] = prep[i][j];

            if ( cost[i][nod] <= lim || equal(cost[i][nod],lim) ){
                V[i].pb(nod); V[nod].pb(i);
                Cp[i][nod] = 1;
                cost[nod][i] = -cost[i][nod];
            }
        }
    }

    for ( int i = 1 ; i <= n ; ++i ){
        int nod = i + n;
        V[nod].pb(D);
        Cp[nod][D] = 1;
    }

    flux();
}

int main () {

    citire();
    first();
    second();

    fclose(f);
    fclose(g);

    return 0;
}