#include <iostream>
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#include <iomanip>
#include <string>
#include <queue>
#include <numeric>
#include <functional>
#include <array>
#include <map>
#include <set>

#define INF 1000000007 //1000000000000000003
#define MOD 1000000007
#define MAX 200005

#define ll long long

//printf("%.10f", );
//cout << fixed << setprecision(10) << heikin << endl;
//vector<vector<int>> data(3, vector<int>(4, -1));

using namespace std;
using P = pair<long long, long long>;
using T = tuple<int, int, int>;
using edge = struct { int to; long long dist; };
const double PI = 3.141592653589793;
long long fact[MAX], inv[MAX];

int H, W;

long long dp[1005][1005];
long long a[1005][1005];

int dx[] = { -1,0,1,0 };
int dy[] = { 0,-1,0,1 };

double dist[8][8];

struct BridgeInfo {
	int town1;
	int town2;
	int year;
	BridgeInfo(int t1, int t2, int y) {
		town1 = t1;
		town2 = t2;
		year = y;
	}
};

struct People {
	int index;
	int town;
	int year;
	People(int i, int t, int y) {
		index = i;
		town = t;
		year = y;
	}
};

bool compare_by_second(pair<int, int> a, pair<int, int> b) {
	if (a.second != b.second) {
		return a.second < b.second;
	}
	else {
		return a.first < b.first;
	}
}

struct UnionFind {
	vector<int>uf;
	
	UnionFind(int size) :uf(size, -1) {};

	int root(int target) {
		if (uf[target] < 0)return target;
		else return uf[target] = root(uf[target]);
	}

	void merge(int a, int b) {
		a = root(a);
		b = root(b);
		if (a == b)return;
		if (uf[b] < uf[a])swap(a, b);
		uf[a] += uf[b];
		uf[b] = a;
	}
};

ll CalcPow(ll num, ll power) {
	if (power == 0)return 1;
	if (power % 2 == 0) {
		ll half = CalcPow(num, power / 2);
		return (half * half) % MOD;
	}
	else return (num * CalcPow(num, power - 1)) % MOD;
}

ll combination(ll all, ll select) {
	if (all < select) return 0;
	if (all < 0 || select < 0) return 0;
	return fact[all] * (inv[select] * inv[all - select] % MOD) % MOD;
}

void initCombination() {
	fact[0] = fact[1] = 1;
	for (int i = 2; i <= MAX; ++i) {
		fact[i] = fact[i-1] * i % MOD;
	}

	inv[MAX] = CalcPow(fact[MAX], MOD - 2);
	for (int i = MAX - 1; 0 <= i; --i) {
		inv[i] = (inv[i + 1] * (i + 1)) % MOD;
	}
}

int dfs(int y, int x) {
	if (dp[y][x] != -1)return dp[y][x];
	ll count = 1;
	for (int i = 0; i < 4;++i) {
		int ny = y + dy[i];
		int nx = x + dx[i];
		if (ny < 0 || H <= ny || nx < 0 || W <= nx)continue;
		if (a[y][x] < a[ny][nx]) {
			count = (count + dfs(ny, nx)) % MOD;
		}
	}
	dp[y][x] = count;
	return count;
}

int main() {
	int N;
	cin >> N;

	vector<P>xy(N);
	for (int i = 0; i < N; ++i) {
		int x, y;
		cin >> x >> y;
		xy[i] = make_pair(x, y);
	}

	//距離を保存しておく
	for (int i = 0; i < N; ++i) {
		for (int j = i + 1; j < N; ++j) {
			dist[i][j] = sqrt((pow(xy[i].first - xy[j].first, 2.0) + pow(xy[i].second - xy[j].second, 2.0)));
			dist[j][i] = dist[i][j];
		}
	}

	int array[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
	const int array_num = N;

	double d = 0;
	int prev = -1;
	vector<int>index;
	do {
		for (int i = 0; i < N; i++) {
			int current = array[i];
			index.emplace_back(array[i]);
			if (prev != -1) {
				d += dist[prev][current];
			}
			prev = current;
		}
		prev = -1;
	} while (std::next_permutation(array, array + N));

	double ret = 1;
	for (int i = 2; i <= N; ++i)ret *= i;
	double ans = d / ret;
	cout << fixed << setprecision(10) << ans << endl;
}

Measured memory_bytes: 2420