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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
int circleAround[1 << 17];
double value[1 << 17];
int vertices[1 << 17];
struct my_struct {
  long long circle_around;
  long long value;
  int idx;
  bool operator<(const my_struct& rhs) const {
    return circle_around * rhs.value < rhs.circle_around * value;
  }
};
int main() {
  int n;
  cin >> n;
  vector<vector<pair<int, int> > > neighbours(n);
  int x, y, p;
  for (int i = 0; i < n - 1; i++) {
    scanf("%d", &x);
    scanf("%d", &y);
    scanf("%d", &p);
    x--;
    y--;
    neighbours[x].push_back(make_pair(y, p));
    neighbours[y].push_back(make_pair(x, p));
  }
  vector<vector<pair<int, int> > > children(n);
  vector<int> numChildren(n, 0);
  vector<bool> vis(n, false);
  queue<int> toProcess;
  toProcess.push(0);
  vis[0] = true;
  int cur;
  while (!toProcess.empty()) {
    cur = toProcess.front();
    toProcess.pop();
    for (int i = 0; i < neighbours[cur].size(); i++) {
      if (!vis[neighbours[cur][i].first]) {
        vis[neighbours[cur][i].first] = true;
        children[cur].push_back(neighbours[cur][i]);
        numChildren[cur]++;
        toProcess.push(neighbours[cur][i].first);
      }
    }
  }
  memset(circleAround, 0, sizeof(circleAround));
  memset(value, 0, sizeof(value));
  memset(vertices, 0, sizeof(vertices));
  vector<bool> used(n, false);
  for (int i = 0; i < n; i++) {
    if (numChildren[i] == 0) {
      used[i] = true;
      toProcess.push(i);
    }
  }
  double totalSum;
  while (!toProcess.empty()) {
    cur = toProcess.front();
    toProcess.pop();
    totalSum = 0;
    vertices[cur] = 1;
    for (int i = 0; i < children[cur].size(); i++) {
      circleAround[cur] += children[cur][i].second * 2;
      circleAround[cur] += circleAround[children[cur][i].first];
      vertices[cur] += vertices[children[cur][i].first];
    }
    vector<my_struct> arr(children[cur].size());
    for (int i = 0; i < children[cur].size(); i++) {
      arr[i].circle_around =
          circleAround[children[cur][i].first] + children[cur][i].second * 2;
      arr[i].value = vertices[children[cur][i].first];
      arr[i].idx = i;
    }
    sort(arr.begin(), arr.end());
    for (int i = 0; i < children[cur].size(); i++) {
      value[cur] += value[children[cur][arr[i].idx].first];
      value[cur] += children[cur][arr[i].idx].second *
                    vertices[children[cur][arr[i].idx].first];
      value[cur] += totalSum * vertices[children[cur][arr[i].idx].first];
      totalSum += arr[i].circle_around;
    }
    for (int i = 0; i < neighbours[cur].size(); i++) {
      if (!used[neighbours[cur][i].first]) {
        numChildren[neighbours[cur][i].first]--;
        if (numChildren[neighbours[cur][i].first] == 0) {
          used[neighbours[cur][i].first] = true;
          toProcess.push(neighbours[cur][i].first);
        }
      }
    }
  }
  printf("%.9lf\n", value[0] / (double)(n - 1));
  return 0;
}