Problem: Gerald is positioned in an old castle which consists of n halls connected with n - 1 corridors. It is exactly one way to go from any hall to any other one. Thus, the graph is a tree. Initially, at the moment of time 0, Gerald is positioned in hall 1. Besides, some other hall of the castle contains the treasure Gerald is looking for. The treasure's position is not known; it can equiprobably be in any of other n - 1 halls. Gerald can only find out where the treasure is when he enters the hall with the treasure. That very moment Gerald sees the treasure and the moment is regarded is the moment of achieving his goal. 

The corridors have different lengths. At that, the corridors are considered long and the halls are considered small and well lit. Thus, it is possible not to take the time Gerald spends in the halls into consideration. The castle is very old, that's why a corridor collapses at the moment when somebody visits it two times, no matter in which direction.

Gerald can move around the castle using the corridors; he will go until he finds the treasure. Naturally, Gerald wants to find it as quickly as possible. In other words, he wants to act in a manner that would make the average time of finding the treasure as small as possible. Each corridor can be used no more than two times. That's why Gerald chooses the strategy in such a way, so he can visit every hall for sure.

More formally, if the treasure is located in the second hall, then Gerald will find it the moment he enters the second hall for the first time — let it be moment t2. If the treasure is in the third hall, then Gerald will find it the moment he enters the third hall for the first time. Let it be the moment of time t3. And so on. Thus, the average time of finding the treasure will be equal to <image>.

Input

The first line contains the only integer n (2 ≤ n ≤ 105) — the number of halls in the castle. Next n - 1 lines each contain three integers. The i-th line contains numbers ai, bi and ti (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ti ≤ 1000) — the numbers of halls connected with the i-th corridor and the time needed to go along the corridor. Initially Gerald is in the hall number 1. It is guaranteed that one can get from any hall to any other one using corridors.

Output

Print the only real number: the sought expectation of time needed to find the treasure. The answer should differ from the right one in no less than 10 - 6.

Examples

Input

2
1 2 1


Output

1.0


Input

4
1 3 2
4 2 1
3 2 3


Output

4.333333333333334


Input

5
1 2 1
1 3 1
1 4 1
1 5 1


Output

4.0

Note

In the first test the castle only has two halls which means that the treasure is located in the second hall. Gerald will only need one minute to go to the second hall from the first one.

In the second test Gerald can only go from the first hall to the third one. He can get from the third room to the first one or to the second one, but he has already visited the first hall and can get nowhere from there. Thus, he needs to go to the second hall. He should go to hall 4 from there, because all other halls have already been visited. If the treasure is located in the third hall, Gerald will find it in a minute, if the treasure is located in the second hall, Gerald finds it in two minutes, if the treasure is in the fourth hall, Gerald will find it in three minutes. The average time makes 2 minutes.

In the third test Gerald needs to visit 4 halls: the second, third, fourth and fifth ones. All of them are only reachable from the first hall. Thus, he needs to go to those 4 halls one by one and return. Gerald will enter the first of those halls in a minute, in the second one — in three minutes, in the third one - in 5 minutes, in the fourth one - in 7 minutes. The average time is 4 minutes. 

Solution (in JAVA):

Solution:
import java.util.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.util.Collection;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {

    private Graph tree;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        tree = new Graph();
        tree.initGraphWithCost(n, n - 1);
        for (int i = 0; i < n-1; ++i) {
            int a = in.nextInt()-1;
            int b = in.nextInt()-1;
            int cost = in.nextInt();
            tree.addEdgeWithCost(a, b, cost);
        }
        fullSum = new long[n];
        count = new int[n];
        f = new long[n];
        out.println((double) rec(0, -1) / (n - 1));
    }

    long[] fullSum;
    int[] count;
    long[] f;

    private long rec(int v, int p) {
        int c = 0;
        for (int i = tree.first[v]; i != -1; i = tree.next[i]) {
            if (tree.to[i] != p) {
                ++c;
                rec(tree.to[i], v);
            }
        }
        Integer[] edges = new Integer[c];
        int car = 0;
        fullSum[v] = 0;
        count[v] = 1;
        for (int i = tree.first[v]; i != -1; i = tree.next[i]) {
            if (tree.to[i] != p) {
                edges[car++] = i;
                fullSum[v] += fullSum[tree.to[i]] + 2 * tree.cost[i];
                count[v] += count[tree.to[i]];
            }
        }
        Arrays.sort(edges, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Long.signum(count[tree.to[o2]] * (fullSum[tree.to[o1]] + tree.cost[o1] * 2) - count[tree.to[o1]] * (fullSum[tree.to[o2]]+ tree.cost[o2] * 2));
            }
        });
        f[v] = 0;
        long prev = 0;
        for (Integer e : edges) {
            f[v] += f[tree.to[e]] + count[tree.to[e]] * (prev + tree.cost[e]);
            prev += fullSum[tree.to[e]] + tree.cost[e] * 2;
        }
        return f[v];
    }
}

class Graph {
    public int[] from;
    public int[] to;
    public int[] first;
    public int[] next;
    public int[] cost;
    public int nVertex;
    public int nEdges;
    public int curEdge;

    public Graph() {}

    public void initGraphWithCost(int n, int m) {
        curEdge = 0;
        nVertex = n;
        nEdges = m;
        from = new int[m * 2];
        to = new int[m * 2];
        first = new int[n];
        next = new int[m * 2];
        cost = new int[m * 2];
        Arrays.fill(first, -1);
    }

    public void addEdgeWithCost(int a, int b, int c) {
        next[curEdge] = first[a];
        first[a] = curEdge;
        to[curEdge] = b;
        from[curEdge] = a;
        cost[curEdge] = c;
        ++curEdge;

        next[curEdge] = first[b];
        first[b] = curEdge;
        to[curEdge] = a;
        from[curEdge] = b;
        cost[curEdge] = c;
        ++curEdge;
    }

}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine().trim();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}