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;
struct Diameter {
  vector<int> center;
  vector<int> path;
  int N;
  pair<vector<int>, vector<int>> calc_dist(int start, const vector<int> G[]) {
    vector<int> dist(N, -1), prev(N);
    dist[start] = 0;
    prev[start] = -1;
    queue<int> que;
    que.push(start);
    while (que.size()) {
      int i = que.front();
      que.pop();
      for (auto j : G[i]) {
        if (dist[j] == -1) {
          dist[j] = dist[i] + 1;
          prev[j] = i;
          que.push(j);
        }
      }
    }
    return {dist, prev};
  }
  int calculate(int n, const vector<int> G[]) {
    N = n;
    auto res1 = calc_dist(0, G);
    auto d1 = res1.first;
    int v1 = max_element(d1.begin(), d1.end()) - d1.begin();
    auto res2 = calc_dist(v1, G);
    auto d2 = res2.first;
    auto p2 = res2.second;
    int v2 = max_element(d2.begin(), d2.end()) - d2.begin();
    int diam = d2[v2];
    while (v2 != -1) {
      path.push_back(v2);
      if (d2[v2] == diam / 2 || d2[v2] == (diam + 1) / 2) center.push_back(v2);
      v2 = p2[v2];
    }
    return diam;
  }
};
int N;
vector<int> edges[200000];
int64_t ans = 0;
vector<vector<int>> ansv;
vector<int> DD[2];
set<int> path_st;
void dfs(int i, int p, int b, int eop) {
  for (int j : edges[i])
    if (j != p) dfs(j, i, b + 1, eop);
  if (!path_st.count(i)) {
    ans += b;
    ansv.push_back({i, eop, i});
  }
}
int main() {
  cin >> N;
  for (int i = 0; i < N - 1; i++) {
    int a, b;
    scanf("%d %d", &a, &b);
    a--;
    b--;
    edges[a].push_back(b);
    edges[b].push_back(a);
  }
  Diameter diam;
  int D = diam.calculate(N, edges);
  int64_t R = D / 2;
  auto path = diam.path;
  int e0 = path[0], e1 = path.back();
  for (int a : path) path_st.insert(a);
  if (D % 2) {
    int c0 = diam.center[0], c1 = diam.center[1];
    dfs(c0, c1, R + 1, e1);
    dfs(c1, c0, R + 1, e0);
  } else {
    int c = diam.center[0];
    int n0 = path[R - 1];
    for (int j : edges[c]) dfs(j, c, R + 1, (j == n0 ? e1 : e0));
  }
  while (path.size() >= 2) {
    ans += path.size() - 1;
    ansv.push_back({path[0], path.back(), path.back()});
    path.pop_back();
  }
  cout << ans << endl;
  for (auto& v : ansv) printf("%d %d %d\n", v[0] + 1, v[1] + 1, v[2] + 1);
  return 0;
}