#include <bits/stdc++.h>

using namespace std;

const int MAX_N = 400;
const double INF = 1000000;
const double eps = 1.e-6;

struct Punct {
  double x, y;
}s[MAX_N + 5], a[MAX_N + 5];

struct Date {
  int u, v;
  double d;
  bool operator < (const Date& other) const {
    return d - other.d < eps;
  }
}aux[MAX_N * MAX_N + 5];

double distanta(Punct a, Punct b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

vector<int>E[MAX_N + 5];
vector<int>G[(2 * MAX_N + 2) + 5];
int l[MAX_N + 5], r[MAX_N + 5];
bool viz[MAX_N + 5];

bool match(int nod) {
  if (viz[nod])
    return false;
  viz[nod] = 1;
  for (auto it:E[nod]) {
    if (l[it] == 0) {
      r[nod] = it;
      l[it] = nod;
      return true;
    }
  }
  for (auto it:E[nod]) {
    if (!viz[l[it]] && match(l[it])) {
      r[nod] = it;
      l[it] = nod;
      return true;
    }
  }
  return false;
}

int cuplaj(int med, int n) {
  for (int i = 1; i <= med; ++i)
    E[aux[i].u].push_back(aux[i].v);
  memset(l, 0, sizeof(l));
  memset(r, 0, sizeof(r));
  bool ok;
  do {
    ok = false;
    memset(viz, 0, sizeof(viz));
    for (int i = 1; i <= n; ++i) {
      if (r[i] == 0 && match(i))
        ok = true;
    }
  } while (ok);
  int ans = 0;
  for (int i = 1; i <= n; ++i) {
    E[i].clear();
    if (r[i])
      ans++;
  }
  return ans;
}

int nrv[(2 * MAX_N + 2) + 5];
bool inc[(2 * MAX_N + 2) + 5];
double dist[(2 * MAX_N + 2) + 5];
int from[(2 * MAX_N + 2) + 5];
int cr[(2 * MAX_N + 2) + 5][(2 * MAX_N + 2) + 5];
double cost[(2 * MAX_N + 2) + 5][(2 * MAX_N + 2) + 5];

double bellman(int s, int d, int n) {
  for (int i = 1; i <= n; ++i) {
    dist[i] = INF;
    nrv[i] = 0;
    inc[i] = 0;
  }
  inc[s] = 1;
  from[s] = s;
  nrv[s] = 1;
  dist[s] = 0;
  queue<int>q;
  q.push(s);
  while (!q.empty() && nrv[q.front()] < n) {
    int node = q.front();
    q.pop();
    inc[node] = 0;
    for (auto it:G[node]) {
      if (cr[node][it] > 0 && dist[node] + cost[node][it] - dist[it] < eps) {
        from[it] = node;
        dist[it] = dist[node] + cost[node][it];
        if (inc[it] == 0) {
          inc[it] = 1;
          q.push(it);
          nrv[it]++;
        }
      }
    }
  }
  return dist[d];
}

double cmcm(int s, int d, int n) {
  double ans = 0, dm;
  dm = bellman(s, d, n);
  while (dm != INF) {
    int aux = INF;
    int node = d;
    while (node != s) {
      aux = min(aux, cr[from[node]][node]);
      node = from[node];
    }
    node = d;
    while (node != s) {
      cr[from[node]][node] -= aux;
      cr[node][from[node]] += aux;
      node = from[node];
    }
    ans += dm * aux;
    dm = bellman(s, d, n);
  }

  return ans;
}

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

  int n;
  scanf("%d", &n);
  for (int i = 1; i <= n; ++i)
    scanf("%lf%lf", &s[i].x, &s[i].y);
  for (int i = 1; i <= n; ++i)
    scanf("%lf%lf", &a[i].x, &a[i].y);
  int k = 0;
  for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= n; ++j)
      aux[++k] = {i, j, distanta(s[i], a[j])};
  sort(aux + 1, aux + k + 1);
  int st = 1, dr = k;
  int last = 0;
  while (st <= dr) {
    int med = (st + dr) >> 1;
    if (cuplaj(med, n) == n) {
      last = med;
      dr = med - 1;
    } else {
      st = med + 1;
    }
  }

  printf("%.4f ", aux[last].d);

  //return 0;
  for (int i = 1; i <= last; ++i) {
    G[aux[i].u + 1].push_back(aux[i].v + n + 1);
    G[aux[i].v + n + 1].push_back(aux[i].u + 1);
    cr[aux[i].u + 1][aux[i].v + n + 1] = 1;
    cost[aux[i].u + 1][aux[i].v + n + 1] = aux[i].d;
    cost[aux[i].v + n + 1][aux[i].u + 1] = -aux[i].d;
  }
  for (int i = 2; i <= n + 1; ++i) {
    G[1].push_back(i);
    G[i].push_back(1);
    cr[1][i] = 1;
  }
  for (int i = n + 2; i <= 2 * n + 1; ++i) {
    G[i].push_back(2 * n + 2);
    G[2 * n + 2].push_back(i);
    cr[i][2 * n + 2] = 1;
  }
  printf("%.4f\n", cmcm(1, 2 * n + 2, 2 * n + 2));

  return 0;
}