fun main(args: Array<String>) {
    val n = readLine()!!.toInt()
    val xyList = Array(n) { readLine()!!.split(" ").map(String::toInt).let { it[0] to it[1] } }

    fun calc(xi: Int, yi: Int, xj: Int, yj: Int): Double {
        return Math.sqrt(((xi - xj) * (xi - xj) + (yi - yj) * (yi - yj)).toDouble())
    }

    class Permutation<T> private constructor(
        private val baseIndex: Int,
        private var index: Int,
        val target: Array<T>?
    ) {
        private var subPermutation: Permutation<T>? = null

        constructor(objs: Array<T>) : this(0, 0, objs.clone())

        init {
            if (target == null || target.isEmpty()) {
                throw IllegalArgumentException("")
            }

            if (this.index < this.target.size - 1) {
                this.subPermutation = Permutation(this.baseIndex + 1, this.index + 1, this.target)
            }
        }

        operator fun next(): Boolean {
            if (this.subPermutation == null) {
                return false
            }
            val result = this.subPermutation!!.next()
            if (result) {
                return true
            }
            this.swap(this.baseIndex, this.index)
            ++this.index
            if (this.target!!.size <= this.index) {
                this.index = this.baseIndex
                return false
            }
            this.swap(this.index, this.baseIndex)
            return true
        }

        private fun swap(index1: Int, index2: Int) {
            val tmp = this.target!![index1]
            this.target[index1] = this.target[index2]
            this.target[index2] = tmp
        }
    }

    val permutation = Permutation((0 until n).toList().toTypedArray())
    var sum = 0.0
    do {

        val array = permutation.target!!
        for (i in 1 until n) {
            val pre = array[i - 1]
            val cur = array[i]

            val (xi, yi) = xyList[pre]
            val (xj, yj) = xyList[cur]

            sum += calc(xi, yi, xj, yj)
        }
    } while (permutation.next())


    //階乗
    fun factorial(i: Int): Long {
        return if (i == 1) {
            1
        } else {
            i * factorial(i - 1)
        }
    }

    println(sum / factorial(n))
}




