#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()

mt19937 rnd(234);
const ll inf = 1e18;

struct DSU {
    int n;
    vector<int> t;

    void build(int _n) {
        n = _n;
        t.resize(n);
        for (int i = 0; i < n; i += 1) {
            t[i] = i;
        }
    }

    int get(int v) {
        if (t[v] == v) {
            return v;
        }
        return (t[v] = get(t[v]));
    }

    void merge(int a, int b) {
        a = get(a);
        b = get(b);
        if (a == b) {
            return;
        }
        t[a] = b;
    }
};

struct grp {
    set<int> usd;
    set<int> not_usd;
    ll sm_pwr = 0;

    int sz() {
        return (int)usd.size() + (int)not_usd.size();
    }

    int usd_sz() {
        return (int)usd.size();
    }
};

int n;
vector<vector<int>> g;
vector<ll> rs;
vector<grp> grps;
DSU dsu;
vector<int> cur_grp;
vector<ll> pwr;
vector<int> dltd;

void unlink(int v) {
    int t = cur_grp[v];
    if (t == -1) {
        return;
    }
    cur_grp[v] = -1;
    grps[t].usd.erase(v);
    grps[t].not_usd.insert(v);
    grps[t].sm_pwr -= pwr[v];
    grps[t].sm_pwr -= grps[t].usd_sz() * 2;
    pwr[v] += grps[t].sz() - 1;
}

void link(int v, int t) {
    if (cur_grp[v] == t) {
        return;
    }
    unlink(v);
    pwr[v] -= grps[t].sz() - 1;
    grps[t].sm_pwr += grps[t].usd_sz() * 2;
    grps[t].sm_pwr += pwr[v];
    grps[t].not_usd.erase(v);
    grps[t].usd.insert(v);
    cur_grp[v] = t;
}

void join(int v, int t, ll &sm) {
    unlink(v);
    sm -= pwr[v] * (pwr[v] - 1);
    pwr[v] += grps[t].sz();
    sm += pwr[v] * (pwr[v] - 1);
    grps[t].not_usd.insert(v);
    sm += grps[t].sm_pwr * 2;
    link(v, t);
}

void unjoin(int v, int t, ll &sm) {
    unlink(v);
    sm -= grps[t].sm_pwr * 2;
    grps[t].not_usd.erase(v);
    sm -= pwr[v] * (pwr[v] - 1);
    pwr[v] -= grps[t].sz();
    sm += pwr[v] * (pwr[v] - 1);
}

void link_all(int t) {
    while (!grps[t].not_usd.empty()) {
        int v = *grps[t].not_usd.begin();
        link(v, t);
    }
}

void solve() {
    ll sm = 0;
    pwr.assign(n, 0);
    for (int i = 0; i < n; i += 1) {
        ll f = (int)g[i].size();
        pwr[i] = f;
        sm += f * (f - 1);
    }
    grps.assign(n, grp());
    dsu.build(n);
    cur_grp.assign(n, -1);
    dltd.assign(n, false);
    rs.resize(n);
    for (int i = 0; i < n; i += 1) {
        rs[i] = sm;

        dltd[i] = true;
        int v = i;
        for (auto to : g[v]) {
            if (dltd[to]) {
                int t = dsu.get(to);
                link_all(t);
                unjoin(v, t, sm);
            } else {
                unlink(to);
                unlink(v);
                sm -= pwr[to] * (pwr[to] - 1);
                pwr[to] -= 1;
                sm += pwr[to] * (pwr[to] - 1);
                sm -= pwr[v] * (pwr[v] - 1);
                pwr[v] -= 1;
                sm += pwr[v] * (pwr[v] - 1);
            }
        }
        for (auto to : g[v]) {
            if (dltd[to]) {
                int t = dsu.get(to);
                link_all(t);
                vector<int> x;
                while (!grps[t].usd.empty()) {
                    int u = *grps[t].usd.begin();
                    grps[t].usd.erase(grps[t].usd.begin());
                    x.push_back(u);
                    unjoin(u, t, sm);
                }
                for (auto u : x) {
                    join(u, v, sm);
                }
                dsu.merge(t, v);
            } else {
                join(to, v, sm);
            }
        }
    }
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n;
    g.assign(n, vector<int>());
    for (int i = 0; i < n - 1; i += 1) {
        int u, v;
        cin >> u >> v;
        --u;
        --v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    solve();
    for (int i = 0; i < n; i += 1) {
        cout << rs[i] << "\n";
    }
    return 0;
}