import java.io.*
import java.util.*

fun square(x: Int) = x * x

fun solve(N: Int, x: IntArray, y: IntArray){
    fun dist(i: Int, j: Int) =
        Math.sqrt((square(x[i] - x[j]) + square(y[i] - y[j])).toDouble())
    val perms = (0 until N).toList().permutations()
    perms.map{
        perm -> perm.zipWithNext{ a, b -> dist(a,b) }.sum()
    }.average().let{ println(it) }
    return
}

fun <T, R> List<T>.zipWithNext(transform: (a: T, b:T) -> R): List<R>{
    return (0 until size - 1).map{ transform(this[it], this[it+1]) }
}

fun main(args: Array<String>) {
    fun StringArray(size: Int, init: (Int) -> String = { "\u0000" }): Array<String> {
        return Array<String>(size, init)
    }
    class Scanner(stream: InputStream) {
        private val reader = BufferedInputStream(stream).bufferedReader()
        private var st: StringTokenizer? = null
        fun next(): String {
            while (!(st?.hasMoreTokens() ?: false)) st = StringTokenizer(reader.readLine())
            return st!!.nextToken()
        }
    }
    val sc = Scanner(System.`in`)
    val N = sc.next().toInt()
    val x = IntArray(N)
    val y = IntArray(N)
    for (i in 0 until N) {
        x[i] = sc.next().toInt()
        y[i] = sc.next().toInt()
    }
    solve(N, x, y)
}


fun List<Int>.dot(other: List<Int>): Int =
        this.mapIndexed { index, value -> value * other[index] }.sum()

fun List<Long>.dot(other: List<Long>): Long =
        this.mapIndexed { index, value -> value * other[index] }.sum()

fun <T> concat(left: T, right: T): List<T> = listOf(left, right)
fun <T> concat(left: List<T>, right: T): List<T> = left + right
fun <T> concat(left: List<T>, right: List<T>): List<List<T>> = right.map{ concat(left, it) }

fun <T> product(vararg lists: List<T>): Sequence<List<T>> {
    fun <T> productTwoList(left: List<T>, right: List<T>): Sequence<List<T>> =
            left.asSequence().flatMap { leftElem -> right.asSequence().map { listOf(leftElem, it) } }

    fun <T> product2DListAnd1DList(list2D: Sequence<List<T>>, list1D: List<T>): Sequence<List<T>> =
            list2D.flatMap { seq -> list1D.asSequence().map { seq + it } }

    require(lists.size >= 2)
    return lists.asSequence()
            .drop(2)
            .fold(productTwoList(lists[0], lists[1])) { acc, suc -> product2DListAnd1DList(acc, suc) }
}

fun <T> Collection<T>.powerSet(): Set<Set<T>> = powerSet(this, setOf(setOf()))

private tailrec fun <T> powerSet(left: Collection<T>, acc: Set<Set<T>>): Set<Set<T>> = when {
    left.isEmpty() -> acc
    else -> powerSet(left.drop(1), acc + acc.map { it + left.first() })
}

fun <T> Set<T>.combinations(n: Int): Set<Set<T>> = when {
    n < 0 -> throw Error("n must be positive, but got $n")
    n == 0 -> setOf(setOf())
    n >= size -> setOf(toSet())
    else -> powerSet()
            .filter { it.size == n }
            .toSet()
}

fun <T> List<T>.insert(index: Int, element: T): List<T> = when {
    index < 0 || index > size -> throw Error("Can not insert to index = $index")
    index == 0 -> listOf(element) + this
    index == size -> this + element
    else -> dropLast(size - index) + element + drop(index)
}

fun <T> List<T>.permutations(): Set<List<T>> = when {
    isEmpty() -> setOf()
    size == 1 -> setOf(listOf(get(0)))
    else -> {
        val element = get(0)
        drop(1).permutations()
                .flatMap { sublist -> (0..sublist.size).map { i -> sublist.insert(i, element) } }
                .toSet()
    }
}

fun <T, R> Iterable<T>.scanLeft(initial: R, operation: (acc: R, T) -> R): Sequence<R> {
    var last = initial
    return this.asSequence().map { last = operation(last, it); last }
}
