Problem: You are given an unweighted tree with n vertices. Then n - 1 following operations are applied to the tree. A single operation consists of the following steps: 

  1. choose two leaves; 
  2. add the length of the simple path between them to the answer; 
  3. remove one of the chosen leaves from the tree. 



Initial answer (before applying operations) is 0. Obviously after n - 1 such operations the tree will consist of a single vertex. 

Calculate the maximal possible answer you can achieve, and construct a sequence of operations that allows you to achieve this answer!

Input

The first line contains one integer number n (2 ≤ n ≤ 2·105) — the number of vertices in the tree. 

Next n - 1 lines describe the edges of the tree in form ai, bi (1 ≤ ai, bi ≤ n, ai ≠ bi). It is guaranteed that given graph is a tree.

Output

In the first line print one integer number — maximal possible answer. 

In the next n - 1 lines print the operations in order of their applying in format ai, bi, ci, where ai, bi — pair of the leaves that are chosen in the current operation (1 ≤ ai, bi ≤ n), ci (1 ≤ ci ≤ n, ci = ai or ci = bi) — choosen leaf that is removed from the tree in the current operation. 

See the examples for better understanding.

Examples

Input

3
1 2
1 3


Output

3
2 3 3
2 1 1


Input

5
1 2
1 3
2 4
2 5


Output

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

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, x, y, d1[N], d2[N], root1, root2, mx, in[N];
vector<int> g[N], leafs;
vector<pair<int, int> > q;
long long ans;
bool used[N];
void dfs1(int &node, int v = 1, int depth = 0, int pr = -1) {
  if (depth > mx) {
    node = v;
    mx = depth;
  }
  for (int to : g[v]) {
    if (to != pr) {
      dfs1(node, to, depth + 1, v);
    }
  }
}
void dfs2(int v, int *a, int depth = 0, int pr = -1) {
  a[v] = depth;
  for (int to : g[v]) {
    if (to != pr) {
      dfs2(to, a, depth + 1, v);
    }
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  for (int i = 1; i < n; i++) {
    cin >> x >> y;
    in[y]++;
    in[x]++;
    g[x].push_back(y);
    g[y].push_back(x);
  }
  int root1 = 1;
  dfs1(root1);
  mx = 0;
  dfs1(root2, root1);
  dfs2(root1, d1);
  dfs2(root2, d2);
  for (int i = 1; i <= n; i++) {
    if (in[i] == 1) {
      leafs.push_back(i);
    }
  }
  for (int i = 0; i < leafs.size(); i++) {
    int it = leafs[i];
    if (it == root1 || it == root2) {
      continue;
    }
    used[it] = true;
    if (d1[it] > d2[it]) {
      q.push_back(make_pair(root1, it));
      ans += d1[it];
    } else {
      q.push_back(make_pair(root2, it));
      ans += d2[it];
    }
    for (int to : g[it]) {
      in[to]--;
      if (in[to] == 1) {
        leafs.push_back(to);
      }
    }
  }
  cerr << root1 << " " << root2 << "\n";
  while (root1 != root2) {
    ans += d2[root1];
    q.push_back(make_pair(root2, root1));
    used[root1] = true;
    for (int to : g[root1]) {
      if (!used[to]) {
        root1 = to;
        break;
      }
    }
  }
  cout << ans << "\n";
  for (auto it : q) {
    cout << it.first << " " << it.second << " " << it.second << "\n";
  }
}