using System;
using System.Collections.Generic;
using System.Linq;

public struct Point
{
    public int X;
    public int Y;

    public Point(Point p)
    {
        X = p.X;
        Y = p.Y;
    }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public static bool operator ==(Point a, Point b)
    {
        return (a.X == b.X && a.Y == b.Y);
    }

    public static bool operator !=(Point a, Point b)
    {
        return !(a == b);
    }

    //objと自分自身が等価のときはtrueを返す
    public override bool Equals(object obj)
    {
        if (!(obj is Point))
        {
            return false;
        }

        Point p = (Point)obj;
        return (X == p.X && Y == p.Y);
    }

    //Equalsがtrueを返すときに同じ値を返す
    public override int GetHashCode()
    {
        return (X << 16) ^ Y;
    }

    public Point Clone()
    {
        return new Point(X, Y);
    }

    public void Reverse()
    {
        X = -X;
        Y = -Y;
    }

    public static Point operator +(Point a, Point b)
    {
        return new Point(a.X + b.X, a.Y + b.Y);
    }

    public static Point operator -(Point a, Point b)
    {
        return new Point(a.X - b.X, a.Y - b.Y);
    }

    public static Point operator *(Point a, int i)
    {
        return new Point(a.X * i, a.Y * i);
    }

    public static Point operator /(Point a, int i)
    {
        return new Point(a.X / i, a.Y / i);
    }
    public static Point operator +(Point a)
    {
        return new Point(+a.X, +a.Y);
    }

    public static Point operator -(Point a)
    {
        return new Point(-a.X, -a.Y);
    }

    public override string ToString()
    {
        return string.Format("({0},{1})", X, Y);
    }

    public double Norm()
    {
        return Math.Sqrt(X * X + Y * Y);
    }

    public double Distance(Point that)
    {
        return (that - this).Norm();
    }
}

public static class Permutation
{
    public static int Factorial(int n)
    {
        if (n == 0)
        {
            return 1;
        }
        return n * Factorial(n - 1);
    }

    public static IEnumerable<int[]> GetPermutations(int n)
    {
        int max = Factorial(n);
        for (int i = 0; i < max; i++)
        {
            yield return GetPermutation(n, i);
        }
    }

    public static int[] GetPermutation(int n, int serialNum)
    {
        var m = new int[n];
        for (int i = 0; i < n; i++)
        {
            m[i] = i;
        }

        var perm = new int[n];
        int cur = 0;
        for (int i = n; i >= 1; i--)
        {
            int nn = serialNum % i;
            perm[cur++] = m[nn];
            for (int j = nn; j < i - 1; j++)
            {
                m[j] = m[j + 1];
            }
            serialNum = serialNum / i;
        }
        return perm;
    }
}
public class Solution
{
    public static void Main()
    {
        var n = int.Parse(Console.ReadLine());
        var cities = new Point[n];
        for (int i = 0; i < n; i++)
        {
            var vals = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            cities[i] = new Point(vals[0], vals[1]);
        }

        var perms = Permutation.GetPermutations(n).ToList();
        double sum = 0;
        foreach (var perm in perms)
        {
            double d = 0;
            var points = perm.Select(i => cities[i]).ToList();
            var prev = points[0];
            foreach (var p in points.Skip(1))
            {
                d += prev.Distance(p);
                prev = p;
            }
            sum += d;
        }

        var ave = sum / perms.Count;
        Console.WriteLine(ave);
    }
}

Measured memory_bytes: 19028