You're given a tree with n vertices rooted at 1.

We say that there's a k-ary heap of depth m located at u if the following holds:

  * For m = 1 u itself is a k-ary heap of depth 1. 
  * For m > 1 vertex u is a k-ary heap of depth m if at least k of its children are k-ary heaps of depth at least m - 1. 



Denote dpk(u) as maximum depth of k-ary heap in the subtree of u (including u). Your goal is to compute <image>.

Input

The first line contains an integer n denoting the size of the tree (2 ≤ n ≤ 3·105). 

The next n - 1 lines contain two integers u, v each, describing vertices connected by i-th edge.

It's guaranteed that the given configuration forms a tree.

Output

Output the answer to the task.

Examples

Input

4
1 3
2 3
4 3


Output

21


Input

4
1 2
2 3
3 4


Output

22

Note

Consider sample case one.

For k ≥ 3 all dpk will be equal to 1.

For k = 2 dpk is 2 if <image> and 1 otherwise.

For k = 1 dpk values are (3, 1, 2, 1) respectively.

To sum up, 4·1 + 4·1 + 2·2 + 2·1 + 3 + 1 + 2 + 1 = 21.
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
  x = 0;
  char c = getchar(), f = 0;
  for (; c < 48 || c > 57; c = getchar())
    if (!(c ^ 45)) f = 1;
  for (; c >= 48 && c <= 57; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
  f ? x = -x : x;
}
const int N = 300005;
struct edge {
  int to, nxt;
} e[N << 1];
int et, head[N];
int n, ln[N], dp[N][20];
long long rs = 0;
inline void adde(int x, int y) { e[++et] = (edge){y, head[x]}, head[x] = et; }
inline void dfs0(int x, int fa) {
  ln[x] = 1;
  for (int i = head[x]; i; i = e[i].nxt)
    if (e[i].to != fa) dfs0(e[i].to, x), ln[x] = max(ln[e[i].to] + 1, ln[x]);
  vector<int> v;
  dp[x][1] = n, rs += ln[x];
  for (int k = 2; k < 20; k++) {
    v.clear();
    for (int i = head[x]; i; i = e[i].nxt)
      if (e[i].to != fa) v.push_back(dp[e[i].to][k - 1]);
    sort(v.begin(), v.end(), greater<int>());
    int id = 0;
    for (; id < (int)v.size() && v[id] >= id + 1; id++)
      ;
    dp[x][k] = id;
  }
}
inline void dfs1(int x, int fa) {
  for (int i = head[x]; i; i = e[i].nxt)
    if (e[i].to != fa) dfs1(e[i].to, x);
  for (int i = head[x]; i; i = e[i].nxt)
    if (e[i].to != fa)
      for (int k = 1; k < 20; k++) dp[x][k] = max(dp[x][k], dp[e[i].to][k]);
}
int main() {
  read(n);
  for (int i = 1, x, y; i < n; i++) read(x), read(y), adde(x, y), adde(y, x);
  dfs0(1, 0), dfs1(1, 0);
  for (int i = 1; i <= n; i++)
    for (int j = 1; j < 20; j++) rs += max(dp[i][j] - 1, 0);
  return printf("%lld\n", rs), 0;
}
