#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5, MOD = 1e9 + 7;
vector<int> adj[maxN];
vector<pair<int, int> > bes[maxN];
int prof[maxN], n, as = 0;
long long tot = 0;
string ans[maxN];
struct cmp {
  bool operator()(const vector<int> *a, const vector<int> *b) {
    return a->size() < b->size();
  }
};
void op(int nd, int an) {
  prof[nd] = nd, bes[nd].push_back(pair<int, int>(0, nd));
  for (int sn : adj[nd])
    if (sn != an)
      op(sn, nd),
          bes[nd].push_back(pair<int, int>(bes[sn].back().first + 1, sn));
  sort(bes[nd].begin(), bes[nd].end());
  prof[nd] = prof[bes[nd].back().second];
}
string pe(int a, int b) {
  return to_string(a + 1) + " " + to_string(b + 1) + " " + to_string(a + 1);
}
vector<int> *dfs(int nd, int an, pair<int, int> ot) {
  vector<vector<int> *> vc;
  ot.first++;
  pair<int, int> tm = max(ot, bes[nd].back());
  for (int i = 1; i + 1 < bes[nd].size(); i++)
    if (bes[nd][i].second != an) vc.push_back(dfs(bes[nd][i].second, nd, tm));
  if (bes[nd].back().second != an && bes[nd].size() > 1)
    vc.push_back(
        dfs(bes[nd].back().second, nd, max(ot, bes[nd][bes[nd].size() - 2])));
  for (int i = 0; i + 1 < vc.size(); i++)
    for (int j = 0; j < vc[i]->size(); j++)
      ans[as++] = pe((*vc[i])[j], prof[tm.second]),
      tot += vc[i]->size() - j + tm.first;
  if (vc.empty()) vc.push_back(new vector<int>());
  vc.back()->push_back(nd);
  return vc.back();
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  cin >> n;
  for (int i = 0; i + 1 < n; i++) {
    int u, v;
    cin >> u >> v;
    u--, v--;
    adj[u].push_back(v), adj[v].push_back(u);
  }
  op(0, -1);
  vector<int> vc = *dfs(0, -1, pair<int, int>(-1, -1));
  for (int j = 0; j + 1 < vc.size(); j++)
    ans[as++] = pe(vc[j], vc.back()), tot += vc.size() - j - 1;
  cout << tot << '\n';
  for (int i = 0; i < as; i++) cout << ans[i] << '\n';
}

### Prompt

In Cpp, your task is to solve the following 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

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5, MOD = 1e9 + 7;
vector<int> adj[maxN];
vector<pair<int, int> > bes[maxN];
int prof[maxN], n, as = 0;
long long tot = 0;
string ans[maxN];
struct cmp {
  bool operator()(const vector<int> *a, const vector<int> *b) {
    return a->size() < b->size();
  }
};
void op(int nd, int an) {
  prof[nd] = nd, bes[nd].push_back(pair<int, int>(0, nd));
  for (int sn : adj[nd])
    if (sn != an)
      op(sn, nd),
          bes[nd].push_back(pair<int, int>(bes[sn].back().first + 1, sn));
  sort(bes[nd].begin(), bes[nd].end());
  prof[nd] = prof[bes[nd].back().second];
}
string pe(int a, int b) {
  return to_string(a + 1) + " " + to_string(b + 1) + " " + to_string(a + 1);
}
vector<int> *dfs(int nd, int an, pair<int, int> ot) {
  vector<vector<int> *> vc;
  ot.first++;
  pair<int, int> tm = max(ot, bes[nd].back());
  for (int i = 1; i + 1 < bes[nd].size(); i++)
    if (bes[nd][i].second != an) vc.push_back(dfs(bes[nd][i].second, nd, tm));
  if (bes[nd].back().second != an && bes[nd].size() > 1)
    vc.push_back(
        dfs(bes[nd].back().second, nd, max(ot, bes[nd][bes[nd].size() - 2])));
  for (int i = 0; i + 1 < vc.size(); i++)
    for (int j = 0; j < vc[i]->size(); j++)
      ans[as++] = pe((*vc[i])[j], prof[tm.second]),
      tot += vc[i]->size() - j + tm.first;
  if (vc.empty()) vc.push_back(new vector<int>());
  vc.back()->push_back(nd);
  return vc.back();
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  cin >> n;
  for (int i = 0; i + 1 < n; i++) {
    int u, v;
    cin >> u >> v;
    u--, v--;
    adj[u].push_back(v), adj[v].push_back(u);
  }
  op(0, -1);
  vector<int> vc = *dfs(0, -1, pair<int, int>(-1, -1));
  for (int j = 0; j + 1 < vc.size(); j++)
    ans[as++] = pe(vc[j], vc.back()), tot += vc.size() - j - 1;
  cout << tot << '\n';
  for (int i = 0; i < as; i++) cout << ans[i] << '\n';
}

```