import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.List;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.math.BigInteger;
import java.io.InputStream;
/**
@author Anuj Rana
*/
public class Main {
public static void main
(String[] args
) { InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
CLASSNAME solver = new CLASSNAME();
solver.solve(1, in, out);
out.close();
}
}
class CLASSNAME {
static long total=0;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n=in.readInt();
boolean[][] tree=new boolean[n+1][n+1];
//ArrayList<Integer> primes=new ArrayList<Integer>(IntegerUtils.generatePrimes(n));
boolean[] isPrime=IntegerUtils.generatePrimalityTable(100001);
for(int i=1;i<n;i++)
tree[in.readInt()][in.readInt()]=true;
for(int i=1;i<n;i++){
recurse(tree,isPrime,1,i);
}
// out.printLine(isPrime[2]);
// out.printLine(total);
out.printLine(total/((n*(n-1))/2.0));
}
static void recurse(boolean[][] tree,boolean[] isPrime,int sum,int level){
if(level>=tree[0].length)return;
for(int i=1;i<tree[0].length;i++){
if(tree[level][i]){
if(isPrime[sum]){
total++;
//System.out.println(level+" "+i);
}
recurse(tree,isPrime,sum+1,i);
}
}
}
}
class InputReader {
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
class OutputWriter {
}
public OutputWriter
(Writer writer
) { }
public void print
(Object...
objects) { for (int i = 0; i < objects.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(objects[i]);
}
}
public void printLine
(Object...
objects) { print(objects);
writer.println();
}
public void close() {
writer.close();
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.readInt();
return array;
}
}
class IntegerUtils {
public static int[] generatePrimes(int upTo) {
boolean[] isPrime = generatePrimalityTable(upTo);
IntList primes = new IntArrayList();
for (int i = 0; i <= upTo; i++) {
if (isPrime[i])
primes.add(i);
}
return primes.toArray();
}
public static boolean[] generatePrimalityTable(int upTo) {
boolean[] isPrime = new boolean[upTo+1];
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i <= upTo; i++) {
if (isPrime[i]) {
for (int j = i * i; j <= upTo; j += i)
isPrime[j] = false;
}
}
return isPrime;
}
public static long power(long base, long exponent, long mod) {
if (base >= mod)
base %= mod;
if (exponent == 0)
return 1 % mod;
long result = power(base, exponent >> 1, mod);
result = result * result % mod;
if ((exponent & 1) != 0)
result = result * base % mod;
return result;
}
}
abstract class IntCollection {
public abstract IntIterator iterator();
public abstract int size();
public abstract void add(int value);
public int[] toArray() {
int size = size();
int[] array = new int[size];
int i = 0;
for (IntIterator iterator = iterator(); iterator.isValid(); iterator.advance())
array[i++] = iterator.value();
return array;
}
public void addAll(IntCollection values) {
for (IntIterator it = values.iterator(); it.isValid(); it.advance()) {
add(it.value());
}
}
}
interface IntIterator {
/*
* @throws NoSuchElementException only if iterator already invalid
*/
public boolean isValid();
}
abstract class IntList extends IntCollection implements Comparable<IntList> {
public abstract int get(int index);
public IntIterator iterator() {
return new IntIterator() {
private int size = size();
private int index = 0;
if (!isValid())
return get(index);
}
if (!isValid())
index++;
}
public boolean isValid() {
return index < size;
}
};
}
public int hashCode() {
int hashCode = 1;
for (IntIterator i = iterator(); i.isValid(); i.advance())
hashCode = 31 * hashCode + i.value();
return hashCode;
}
public boolean equals
(Object obj
) { if (!(obj instanceof IntList))
return false;
IntList list = (IntList)obj;
if (list.size() != size())
return false;
IntIterator i = iterator();
IntIterator j = list.iterator();
while (i.isValid()) {
if (i.value() != j.value())
return false;
i.advance();
j.advance();
}
return true;
}
public int compareTo(IntList o) {
IntIterator i = iterator();
IntIterator j = o.iterator();
while (true) {
if (i.isValid()) {
if (j.isValid()) {
if (i.value() != j.value()) {
if (i.value() < j.value())
return -1;
else
return 1;
}
} else
return 1;
} else {
if (j.isValid())
return -1;
else
return 0;
}
i.advance();
j.advance();
}
}
}
class IntArrayList extends IntList {
private int[] array;
private int size;
public IntArrayList() {
this(10);
}
public IntArrayList(int capacity) {
array = new int[capacity];
}
public IntArrayList(IntList list) {
this(list.size());
addAll(list);
}
public int get(int index) {
if (index >= size)
return array[index];
}
public int size() {
return size;
}
public void add(int value) {
ensureCapacity(size + 1);
array[size++] = value;
}
public void ensureCapacity(int newCapacity) {
if (newCapacity > array.length) {
int[] newArray
= new int[Math.
max(newCapacity, array.
length << 1)]; System.
arraycopy(array,
0, newArray,
0, size
); array = newArray;
}
}
public int[] toArray() {
int[] array = new int[size];
System.
arraycopy(this.
array,
0, array,
0, size
); return array;
}
}