#pragma GCC optimize("O3,unroll-loops")
#include <bits/stdc++.h>
#define int long long
#define uint unsigned long long
using namespace std;
const int mod=1e9+7;

struct hld {
    int n;
    vector<vector<int>> g;
    vector<int> sz, par, depth, head, pos, rpos;
    hld(int n)
        : n(n), g(n), sz(n), par(n), depth(n), head(n), pos(n), rpos(n) {}
    void add_edge(int u, int v) {
        g[u].push_back(v);
        g[v].push_back(u);
    }
    void build(vector<int> roots = {0}) {
        int k = 0;
        for (int r : roots) {
            dfs_sz(r);
            head[r] = r;
            dfs_hld(r, k);
        }
    }
    void dfs_sz(int v) {
        sz[v] = 1;
        for (int &c : g[v]) {
            if (c == par[v]) continue;
            par[c] = v;
            depth[c] = depth[v] + 1;
            dfs_sz(c);
            sz[v] += sz[c];
            if (sz[c] > sz[g[v][0]] || g[v][0] == par[v]) swap(c, g[v][0]);
        }
    }
    void dfs_hld(int v, int &k) {
        pos[v] = k++;
        rpos[pos[v]] = v;
        for (int c : g[v]) {
            if (c == par[v]) continue;
            head[c] = (c == g[v][0] ? head[v] : c);
            dfs_hld(c, k);
        }
    }
    bool is_anc(int u, int v) {
        return pos[u] <= pos[v] && pos[v] < pos[u] + sz[u];
    }
    int lca(int u, int v) {
        while (!is_anc(head[u], v))
            u = par[head[u]];
        while (!is_anc(head[v], u))
            v = par[head[v]];
        return is_anc(u, v) ? u : v;
    }
};

struct node {
    int maxval;
    int lazy;
    node() : maxval(0), lazy(0) {}
    node(int x,int y) : maxval(x), lazy(y) {}

    friend ostream &operator<<(ostream &os, const node &node1) {
        os << "{ maxval: " << node1.maxval << " lazy: " << node1.lazy<<" } ";
        return os;
    }
};

void merge(int i, vector<node> &st) {
    st[i].maxval = max(st[i * 2].maxval, st[i * 2 + 1].maxval);
}

void push(int i, vector<node> &st) {
    st[i * 2].maxval += st[i].lazy;
    st[i * 2 + 1].maxval += st[i].lazy;
    st[i * 2].lazy += st[i].lazy;
    st[i * 2 + 1].lazy += st[i].lazy;
    st[i].lazy = 0;
}

void modify(int i, int lx, int rx, int l,int r, int v,vector<node> &st) {
    if (l >= rx || r <= lx)
        return;
    if (lx >= l && rx <= r) {
        st[i].maxval += v;
        st[i].lazy += v;
        return;
    }
    push(i,st);
    int m = (lx + rx) / 2;
    modify(i * 2, lx, m, l, r, v,st);
    modify(i * 2 + 1, m, rx, l, r, v,st);
    merge(i,st);
}

pair<int,int> first_right_more(int i, int lx,int rx, int l,int r, int v, vector<node> &st) {
    if (st[i].maxval < v || l >= rx || r <= lx)
        return {-1,-1};
    if (rx - lx == 1)
        return {lx,st[i].maxval};
    push(i,st);
    int m = (lx + rx) / 2;
    pair<int,int> res = first_right_more(i * 2 + 1, m, rx, l, r, v,st);
    if (res.first != -1)
        return res;
    return first_right_more(i * 2, lx, m, l, r, v,st);
}

void print_vec(vector<node> &x) {
    for (int i = 0; i < x.size(); i++) {
        cout << x[i] << " \n"[i == x.size() - 1];
    }
    cout << endl;
}

void solve() {
    int n;
    cin >>n;
    hld h(n);
    for(int i=0;i<n-1;i++) {
        int u,v;
        cin >>u>>v;
        u--,v--;
        h.add_edge(u,v);
    }
    if (n==1) {
        cout <<1<<"\n";
        return;
    }
    h.build();
    vector<pair<int,int> > chains;
    for(int i =0;i<n;i++) {
        if (h.sz[h.rpos[i]]==1) {
            chains.push_back({h.sz[h.head[h.rpos[i]]],h.rpos[i]});
        }
    }
    //sort in decreasing order of size
    sort(chains.begin(),chains.end(),greater<pair<int,int>>());

    int l1  = 1;
    while(l1<n)
        l1*=2;
    vector<node > st(2*l1,{-mod,0});
    for(int i=0;i<n;i++)
        st[l1+i].maxval = h.sz[h.rpos[i]];
    for(int i=l1-1;i>0;i--)
        merge(i,st);
    vector<int> ans(n+1,0);
    // print_vec(st);
    for(int k1=1;k1<=n;k1++) {
        assert(chains.size()>=1);
        while(chains.back().first<k1)
            chains.pop_back();
        vector<pair<pair<int,int>,int> > changes;
        for(int j = chains.size()-1;j>=0;j--) {
            while(true) {
                int from = h.pos[h.head[chains[j].second]];
                int to = h.pos[chains[j].second];
                assert(from<=to);
                pair<int,int> res = first_right_more(1,0,l1,from,to+1,k1,st);
                if (res.second < k1) {
                    break;
                }
                modify(1,0,l1,from,to+1,-res.second,st);
                changes.push_back({{from,to+1},res.second});
                ans[k1]++;
            }
            int head_child_left = first_right_more(1,0,l1,h.pos[h.head[chains[j].second]],h.pos[h.head[chains[j].second]]+1,-mod*mod,st).second;
            int dec = h.sz[h.head[chains[j].second]]-head_child_left;
            int next = h.par[h.head[chains[j].second]];
            int from = h.pos[h.head[next]];
            int to = h.pos[next];
            modify(1,0,l1,from,to+1,-dec,st);
            changes.push_back({{from,to+1},dec});
        }
        for(auto x:changes)
            modify(1,0,l1,x.first.first,x.first.second,x.second,st);
    }
    int a =0;
    for (int i=1;i<=n;i++) {
        a += ans[i];
    }
    cout <<a<<"\n";


}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
}