// Original C++ solution (slower):
#include <bits/stdc++.h>



#define int long long



using namespace std;



const int N = 100005;

vector <pair <int, int> > g[N];

vector <int> all, temp[N], pref_all, pref_temp[N];

int dp[N], ans[N], dist[N];

bool visited[N];



void dfs (int u, int p) {

    dp[u] = 1;

    for (int i = 0; i < g[u].size(); i++) {

        int v = g[u][i].first;

        if (v != p && !visited[v]) {

            dfs(v, u);

            dp[u] += dp[v];

        }

    }

}



int find_centroid (int u, int p, int sz) {

    for (int i = 0; i < g[u].size(); i++) {

        int v = g[u][i].first;

        if (v != p && !visited[v] && dp[v] > sz/2) return find_centroid(v, u, sz);

    }



    return u;

}



void redfs (int u, int p, int val, int branch) {

    all.push_back(val);

    temp[branch].push_back(val);



    dist[u] = val;

    for (int i = 0; i < g[u].size(); i++) {

        int v = g[u][i].first;

        if (v == p || visited[v]) continue;



        redfs(v, u, min(val,g[u][i].second), branch);

    }

}



void cal (int u, int p, int branch) {

    int pos_all = upper_bound(all.begin(), all.end(), dist[u]) - all.begin();

    int pos_temp = upper_bound(temp[branch].begin(), temp[branch].end(), dist[u]) - temp[branch].begin();

    ans[u] = ans[u] + pref_all[pos_all - 1] - pref_temp[branch][pos_temp - 1];



    pos_all = (int)all.size() - pos_all;

    pos_temp = (int)temp[branch].size() - pos_temp;

    ans[u] = ans[u] + (pos_all - pos_temp + 1) * dist[u];



    for (int i = 0; i < g[u].size(); i++) {

        int v = g[u][i].first;

        if (visited[v] || v == p) continue;



        cal(v, u, branch);

    }

}



void centroid (int root) {

    dfs(root, root);



    if(dp[root] == 1) return;

    int cen = find_centroid(root, root, dp[root]);

    visited[cen] = true;



    all.clear();

    pref_all.clear();

    for (int i = 0; i < g[cen].size(); i++) {

        int v = g[cen][i].first;

        if (visited[v]) continue;



        temp[v].clear();

        pref_temp[v].clear();

        redfs(v, cen, g[cen][i].second, v);

    }



    sort(all.begin(), all.end());

    pref_all.push_back(all[0]);

    for (int i = 1; i < all.size(); i++) pref_all.push_back(all[i] + pref_all[pref_all.size() - 1]);

    for (int i = 0; i < g[cen].size(); i++) {

        int v = g[cen][i].first;

        if (visited[v]) continue;



        sort(temp[v].begin(), temp[v].end());

        for (int j = 0; j < temp[v].size(); j++) {

            if (j == 0) pref_temp[v].push_back(temp[v][0]);

            else pref_temp[v].push_back(temp[v][j] + pref_temp[v][pref_temp[v].size() - 1]);

        }



        cal(v, cen, v);

    }



    ans[cen] += pref_all[pref_all.size() - 1];

    for (int i = 0; i < g[cen].size(); i++) {

        int v = g[cen][i].first;

        if (!visited[v]) centroid(v);

    }

}



signed main(){

    int n;

    scanf("%lld", &n);

    for (int i = 1; i <= n - 1; i++) {

        int u, v, w;

        scanf("%lld %lld %lld", &u, &v, &w);

        g[u].push_back(make_pair(v, w));

        g[v].push_back(make_pair(u, w));

    }



    memset(visited, 0, sizeof(visited));

    memset(ans, 0, sizeof(ans));

    centroid(1);



    for (int i = 1; i <= n; i++) printf("%lld\n", ans[i]);



    //cout << "dist " << dist[2] << "\n";

    //for (int i = 0; i < all.size(); i++) cout << all[i] << " ";

    //for (int i = 0; i < temp[2].size(); i++) cout << temp[2][i] << " ";

    //cout << dist[1] << " " << dist[2] << " " << dist[3];

    return 0;

}



/*

4

1 2 10

2 3 20

1 4 10

*/


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



using namespace std;

#define int long long

int n;

vector<pair<int, pair<int, int> > > d;



int par[100005];

long long res[100005];

int lazy[100005];



vector<int> child[100005];



void Union(int u, int v, int w)

{

    if (child[par[u]].size() > child[par[v]].size())

    {

        swap(u, v);

    }

    int k = par[u];

    lazy[par[v]] += w*child[k].size();

    for (int i = 0; i < child[k].size(); i++)

    {

        par[child[k][i]] = par[v];

        res[child[k][i]] += w*child[par[v]].size() - lazy[par[v]] + lazy[k];

    }

    for (int i = 0; i < child[k].size(); i++)

    {

        child[par[v]].push_back(child[k][i]);

    }

    lazy[k] = 0;

    child[k].clear();

}



signed main()

{

    ios::sync_with_stdio(false); cin.tie(0);

    cin >> n;

    for (int i = 1; i < n; i++)

    {

        int x, y, l; cin >> x >> y >> l;

        d.push_back({l,{x,y}});

    }

    for (int i = 1; i <= n; i++)

    {

        child[i].push_back(i);

        par[i] = i;

        lazy[i] = 0;

    }

    sort(d.begin(), d.end());

    memset(res, 0, sizeof res);

    memset(lazy, 0, sizeof lazy);

    reverse(d.begin(), d.end());

    for (int i = 0; i < n-1; i++)

    {

        Union(d[i].second.first, d[i].second.second, d[i].first);

    }

    for (int i = 1; i <= n; i++)

    {

        cout << res[i] + lazy[par[i]] << endl;

    }

}


// Fastest known solution for this problem: