import java.util.*

fun main(args: Array<String>) {
    val pw = java.io.PrintWriter(System.out)
    Problem.solve(Scanner(System.`in`), pw)
    pw.flush()
}

class Permutations<A : Comparable<A>>(val nums: Array<A>) {
    fun nextPermutation(): Array<A>? {
        var mark = -1
        for (i in nums.size - 1 downTo 1) {
            if (nums[i] > nums[i - 1]) {
                mark = i - 1
                break
            }
        }
        if (mark == -1) {
            reverse(nums, 0, nums.size - 1)
            return null
        }
        var idx = nums.size - 1
        for (i in nums.size - 1 downTo mark + 1) {
            if (nums[i] > nums[mark]) {
                idx = i
                break
            }
        }
        swap(nums, mark, idx)
        reverse(nums, mark + 1, nums.size - 1)
        return nums
    }

    private fun swap(nums: Array<A>, i: Int, j: Int) {
        val t = nums[i]
        nums[i] = nums[j]
        nums[j] = t
    }

    private fun reverse(nums: Array<A>, i: Int, j: Int) {
        var i = i
        var j = j
        while (i < j) {
            swap(nums, i, j)
            i++
            j--
        }
    }
}

object Problem {
    lateinit var dfs: (Int, Int) -> Unit

    fun solve(sc: Scanner, pw: java.io.PrintWriter) {
        val N = sc.next().toInt()
        val XY = Array(N) { Pair(sc.next().toInt(), sc.next().toInt()) }
        val X = XY.map { it.first }.toIntArray()
        val Y = XY.map { it.second }.toIntArray()

        val dist = Array(N) { DoubleArray(N) }
        for (i in 0 until N - 1) {
            for (j in (i + 1) until N) {
                val d = Math.sqrt(
                    ((X[i] - X[j]) * (X[i] - X[j]) + (Y[i] - Y[j]) * (Y[i] - Y[j])).toDouble()
                )
                dist[i][j] = d
                dist[j][i] = d
            }
        }
        var a: Array<Int>? = (0 until N).map { it }.toTypedArray()
        val p = Permutations(a!!)
        var sum = 0.0
        var n = 0
        while (a != null) {
            n += 1
            for (i in 1 until N) {
                sum += dist[a[i - 1]][a[i]]
            }
            a = p.nextPermutation()
        }
        pw.printf("%.10f\n", sum / n)
    }
}