long long A,B,C,D,E,F,    I,J,K,  M,N,O,P,Q,R,S,T,U,V,  X,Y,Z;
//long long A,B,C,D,E,F,  H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z;
#include <string>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <iomanip>
#include <cmath>

//typedef pair<long long,long long> P;
//typedef pair<long long,P> P1;
//typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
//#define INF 100000000000000000//19桁
#define INF 1e18+5//19桁
#define mod 1000000007
#define fi first
#define se second
#define rep(i,x) for(long long i=0;i<x;i++)
#define repn(i,x) for(long long i=1;i<=x;i++)
#define REP(i,n,x) for(long long i=n;i<x;i++)
#define REPN(i,n,x) for(long long i=n+1;i<x;i++)
#define repn(i,x) for(long long i=1;i<=x;i++)
#define rrep(i,x) for(long long i=x-1;i>=0;i--)
#define rrepn(i,x) for(long long i=x;i>1;i--)
#define SORT(x) sort(x.begin(),x.end())
#define ERASE(x) x.erase(unique(x.begin(),x.end()),x.end())
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())
#define All(x) (x).begin(),(x).end()
#define rAll(x) (x).rbegin(),(x).rend()

#define ALL(v)  (v).begin(),(v).end()
//#define MAX(a,b) if(a>b)
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))


const string MINUSINF = "-";

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
void chmax(string &a, string b) {
    if (a == MINUSINF) a = b;
    else if (a.size() < b.size()) a = b;
    else if (a.size() == b.size()) {
        if (a < b) a = b;
    }
}


template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

#define pr printf
#define re return
#define CASET int ___T, case_n = 1; scanf("%d ", &___T); while (___T-- > 0)


int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }

stack<long long> sta;   
queue<long long> que;
deque<long long> dque;

set <string> s_set;



//最大公約数
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }

//最小公倍数
int lcm(int x, int y) { return x / gcd(x, y) * y; }

//最大公約数 複数個
int gcd(const vector<int> &v) {
	int ret = v[0];
	for (int i = 1; i < v.size(); i++)
		ret = gcd(ret, v[i]);
	return ret;
}

//最小公倍数 複数個
int lcm(const vector<int> &v) {
	int ret = v[0];
	for (int i = 1; i < v.size(); i++)
		ret = lcm(ret, v[i]);
	return ret;
}

struct Student {
  string name;
  int no, point;
};


// a < b ならtrueを返す
/*
bool comp(const Student& a, const Student& b) {
  if (a.name != b.name)
    return a.name < b.name; // 第一優先（アルファベット順）
  if (a.point != b.point)
    return a.point > b.point; // 第二優先（評価が高い順）
  return a.no < b.no;// 第三優先（番号が若い順）※ここまで来ない
}
*/

/*
bool cmp(const P&a,const P&b){
	return a.fi+a.se > b.fi+b.se;
}
*/


//	文字列置換
std::string replaceOtherStr(std::string &replacedStr, std::string from, std::string to) {
    const unsigned int pos = replacedStr.find(from);
    const int len = from.length();
 
    if (pos == std::string::npos || from.empty()) {
        return replacedStr;
    }
 
    return replacedStr.replace(pos, len, to);
}


//	素因数分解
void countPN(int n, std::vector<int> &count)//nを素因数に分解し、countを更新
{
	int m = n;
	for(int i=2 ; i*i<=n ; ++i)
	{
		while(m%i == 0)
		{
			m /= i;
			count[i]++;
		}
		if(m==1) break;
	}
	if(m!=1) count[m]++;

}

//	素因数分解 pair使用version
// たとえば 60 = 2^2 x 3 x 5 だったら {(2, 2), (3, 1), (5, 1)} を返す
vector<pair<long long, long long> > prime_factorize(long long n) {
    vector<pair<long long, long long> > res;
    for (long long p = 2; p * p <= n; ++p) {
        if (n % p != 0) continue;
        int num = 0;
        while (n % p == 0) { ++num; n /= p; }
        res.push_back(make_pair(p, num));
    }
    if (n != 1) res.push_back(make_pair(n, 1));
    return res;
}



//	コンビネーション
const int MAX_N = 2000000;
ll inv[MAX_N + 10];
ll fac[MAX_N + 10], facInv[MAX_N + 10];
class MATH{
public:
    MATH(){
        inverse();
        factroial();
    }
    ll nCk(ll n, ll k){// n! / k!*(n-k)!
        if(k < 0 || k > n) return 0;
        ll ret = fac[n];
        (ret *= facInv[k]) %= mod;
        (ret *= facInv[n - k]) %= mod;
        return ret;
    }
    ll nHk(ll n, ll k){// nHk = n+k-1 C k = (n+k-1)! / k! * (n-1)!
        if(n == 0 && k == 0) return 1;
        ll ret = fac[n + k - 1];
        (ret *= facInv[k]) %= mod;
        (ret *= facInv[n - 1]) %= mod;
        return ret;
    }
    ll nPk(ll n, ll k){//nPk = n! / (n-k)!
        if(k < 0 || k > n) return 0;
        ll ret = fac[n];
        (ret *= facInv[n - k]) %= mod;
        return ret;
    }
private:
    void inverse(void){
        inv[1] = 1;
        for (int i = 2; i <= MAX_N; ++i){
            // inv[i] = mod - (mod / i) * inv[mod % i] % mod;
            inv[i] = inv[mod % i] * (mod - mod / i) % mod;
        }
    }
    void factroial(void){
        fac[0] = facInv[0] = 1;
        for (int i = 1; i <= MAX_N; ++i){
            fac[i] = (fac[i - 1] * i) % mod;
            facInv[i] = (facInv[i - 1] * inv[i]) % mod;
        }
    }
};

 
void chmod(ll &M){
    if(M >= mod) M %= mod;
    else if(M < 0){
        M += (abs(M)/mod + 1)*mod;
        M %= mod;
    }
}
 
ll modpow(ll x, ll n){
    if(n==0) return 1;
    ll res=modpow(x, n/2);
 
    if(n%2==0) return res*res%mod;
    else return res*res%mod*x%mod;
}

//	いもす法
std::vector<int> getCumSum(std::vector<int> baseImos){
    int baseSize = baseImos.size();
    std::vector<int> cumSum(baseSize, 0);
    
    cumSum[0] = baseImos[0];
    for(int i=1; i<baseSize; i++){
        cumSum[i] = cumSum[i-1] + baseImos[i];
    }
    return cumSum;
}


//	BFS		(AGC033 A  Darker and Darker)
#define P pair<int,int>
using namespace std;

// マスの縦横]
int H,W;
// #,.を格納するマス
char MAT[1000][1000];

// 幅優先探索の深さを格納するマス
int depth[1000][1000];
// 隣り合う辺への移動量
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
// 答え
 
void BFS(){
	// 入力を受取り、キューに位置x,yを格納
	cin >> H >> W;
	queue<P> que;
	for (int i=0;i<H;i++){
		for (int j=0;j<W;j++){
			cin >> MAT[i][j];
			if (MAT[i][j]=='#'){
				depth[i][j] = 0;
				que.push(P(i,j));
			}
		}
	}
	// キューを前から取り出し、隣り合う辺が.か#か調べ.なら#に更新し、深さを1足す
	while (!que.empty()){
		P p = que.front();
		que.pop();
		for (int i=0;i<4;i++){
			int nx = p.first + dx[i];
			int ny = p.second + dy[i];
			if (nx>=0 && nx<H && ny>=0 && ny<W && MAT[nx][ny]!='#'){
				MAT[nx][ny] = '#';
				depth[nx][ny] = depth[p.first][p.second]+1;
				que.push(P(nx,ny));
			}
		}
	}
}

//	DFS		(ABC026 A  高橋君の給料)
typedef vector<int> vi;

/*
int dfs(vector<vi> ch, int u){
	if(ch[u].empty()) return 1;
	int mi = INF, ma = 0;
	for(int v : ch[u]){
		int r = dfs(ch, v);
		mi = MIN(mi, r);
		ma = MAX(ma, r);
	}
	return mi + ma + 1;
}
*/

//	DFS		(ABC029 C  Brute-force Attack)
/*
void dfs(int n, string s) {
  if (n == 0) cout << s << endl;
  else {
    dfs(n-1, s + "a");
    dfs(n-1, s + "b");
    dfs(n-1, s + "c");
  }
}
*/

using Edge = pair<int,int>;
using Graph = vector<vector<Edge> >;

vector<int> res;
Graph G;

//	DFS	& 二部グラフ	(ABC126 D  Even Relation 同色の2頂点の長さは偶数)

// v を c に塗る。p は v の親
void dfs(int v, int p, int c) {
    res[v] = c;
    for (auto e : G[v]) {
        if (e.first == p) continue;
        if (e.second & 1) dfs(e.first, v, 1-c);
        else dfs(e.first, v, c);
    }
}

//	DFS	(ABC138 D  Ki)
vector<int> g[200020];
int s[200020];
bool used[200020];

void dfs(int x){
	used[x]=1;
	for(auto y:g[x]){
		if(used[y]) continue;
		s[y]+=s[x];
		dfs(y);
	}
}

//	Union Find ＋ DP	(KUPC B ナップサック問題)	
struct UnionFind{
   vector<int> par;
   UnionFind(int n):par(n,-1){}
   int find(int x){
       if(par[x]<0)return x;
       return par[x]=find(par[x]);
   }
   bool unite(int x,int y){
       x=find(x);
       y=find(y);
       if(x==y)return false;
       if(par[x]>par[y]){
           par[y]+=par[x];
           par[x]=y;
       }
       else{
           par[x]+=par[y];
           par[y]=x;
       }
       return true;
   }
 
   bool same(int x,int y){
       return find(x)==find(y);
   }
   int size(int x){
       return -par[find(x)];
   }
};


//	再帰	(ABC119 C Synthetic Kadomatsu)	
vector<ll> L;

ll rec(ll i, ll a, ll b, ll c) {
    if (i == N) {
        if (!a || !b || !c) return INF; // A, B, C いずれも竹は 1 本は必ず使ってないとダメ
        return abs(a - A) + abs(b - B) + abs(c - C); // 合体してできた a, b, c を A, B, C にするコスト
    }

    // 今ある竹を採用しない場合
    ll res = rec(i+1, a, b, c);
    
    // A, B, C を使う場合。
    // (a ? 10 : 0) とかは、最初の 1 本目は合体コストなし、2 本目からはコスト 10 かかることを意味する
    chmin(res, rec(i+1, a + L[i], b, c) + (a ? 10 : 0));
    chmin(res, rec(i+1, a, b + L[i], c) + (b ? 10 : 0));
    chmin(res, rec(i+1, a, b, c + L[i]) + (c ? 10 : 0));
    
    return res;
}




long long sum,sum1,sum2,sum3,sum4;
long long flg,flg1,flg2,flg3,cnt,cnt1,cnt2,cnt3,cnt4;
long long wk,wk1,wk2,wk3,wk4;
long long ans;

bool f;

long long weight[110], value[110]; // 品物の個数は 100 個なので少し余裕持たせてサイズ 110 に
ll a[100010][3]; // a[i], b[i], c[i] をそれぞれまとめて a[i][0], a[i][1], a[i][2] にしてしまう
long long n,h[100005];
vector<long long> p, c;
int vis[200001];

vector<string> fi;
int Left[2100][2100], Right[2100][2100], Up[2100][2100], Down[2100][2100];

long long match[10] = {2,5,5,4,5,6,3,7,6};
vector<long long> box;



int main(){
	
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	long long max,max1,ans;
	long long min,min1;

	sum=sum1=sum2=sum3=sum4=0;
	flg=flg1=flg2=flg3=cnt=cnt1=cnt2=cnt3=cnt4=0;
	max=max1=0;
	wk=wk1=wk2=wk3=wk4=0;
	ans=0;
	min=min1=INF;

	
	//**************************ここからスタート******************************************
	std::cin >> N;
	//std::cin >> N >> M;
	//std::cin >> N >> M >> K;
	//std::cin >> N >> K;
	//std::cin >> A >> B;
	//std::cin >> A >> B >> C;
    
	//std::vector<long long> v(N);
	//std::vector<long long> w(N);
	//std::vector<long long> x(N);
	//std::vector<int> v(100, 0);
	//int a[26]={0};
	//vector<long long> flagment(N, 0);
	
	//vec.push_back(i);
	//accumulate(vec.begin(), vec.end(), 0)
    //v.resize
    
	// 配列入力1
	/*
	for(long long i=0; i<N; i++){
		std::cin >> v[i];
	}
	*/
	
	
	
	vector<pair<double, double> > p(N+1);
	for(long long i=1; i<=N; i++){
		double a, b;
		cin >> a >> b;
		p[i] = make_pair(a, b);
	}
    cnt=1;
	for(long long i=N; i>=1; i--){
		cnt=cnt*i;
	}
	int flg_array[N+1];
	//pr("%lld\n",cnt);
	for(long long j=1; j<=N; j++){
		flg_array[j]=0;
	}
	double aa;
	double bb;
	
	bb=0;
	for(long long i=1; i<=cnt; i++){
		ll j;
		ll k;
		j=N;
		while(j>0){
			
			if(flg_array[j]<N){
				flg_array[j]++;
			}	
			k=N;

			while(k>0){
				if(k==j){
					k--;
					continue;
				}
				if(flg_array[k]<N){
					flg_array[k]++;
					aa=(double)sqrt((double)pow(p[j].fi-p[k].fi,2)+(double)pow(p[j].se-p[k].se,2) );
					bb+=aa;
					//puts("a");
				}
				k--;
			}
			j--;
		}
	}
		
	
	if(1){
    	//printf("%lld",N);
    	//printf("%lld",N);
    	//puts("Yes");
    	//printf("%d",st.size());
    	//文字列の出力
    	//std::cout << s << std::endl;
    	//printf("%.6lf\n",aa);
    	printf("%.12f\n",bb/N);
    	//cout << sum << endl;
	}
	else{
		//puts("No");
	}
	return 0;
	
}


Measured memory_bytes: 13052