// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;



#define fi first

#define se second

#define pb push_back

#define mp make_pair



typedef pair<int,int> ii;



int n,f[100005],up[100005];

long long ans[100005],sum[100005],cnt[100005];



vector<ii> graph[100005];

bool vis[100005];

vector<int> all;

vector<ii> tree[100005];



void dfs(int u,int p){

    f[u] = 1;

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

        int v = graph[u][i].fi;

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

            dfs(v,u);

            f[u]+=f[v];

        }

    }

}



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

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

        int v = graph[u][i].fi;

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

            if(2*f[v]>sz) return fin(v,u,sz);

        }

    }

    return u;

}



void dist(int u,int p,int id,int val){

    all.pb(val); tree[id].pb(mp(val,u)); up[u] = val;

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

        int v = graph[u][i].fi,w = graph[u][i].se;

        if(!vis[v] && v!=p)

            dist(v,u,id,min(w,val));

    }

}

void centroid(int cen){

    dfs(cen,cen);

    int u = fin(cen,cen,f[cen]);

    vis[u] = 1;

    all.clear();

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

        int v = graph[u][i].fi,w = graph[u][i].se;

        if(vis[v]) continue;

        tree[v].clear();

        dist(v,u,v,w);

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

    }

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

    for(int i = 0 ;i<all.size();i++)

        ans[u]+=all[i];

    sum[all.size()] = 0;

    for(int i = 0 ;i<all.size();i++){

        sum[i] = all[i];

        if(i == 0) continue;

        sum[i]+=sum[i-1];

    }

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

        int v = graph[u][i].fi;

        if(vis[v]) continue;

        cnt[tree[v].size()] = 0;

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

            cnt[j] = tree[v][j].fi;

            if(j == 0) continue;

            cnt[j]+=cnt[j-1];

        }

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

            //cout<<tree[v][j].fi<<" "<<tree[v][j].se<<"\n";

            int node = tree[v][j].se,val = up[node],it;

            ans[node]+=val;

            it = upper_bound(all.begin(),all.end(),val)-all.begin();

            if(it-1>=0)

            ans[node]+=sum[it-1];

            ans[node]+=val*(all.size()-it);

            it = lower_bound(tree[v].begin(),tree[v].end(),ii(val+1,-1))-tree[v].begin();

            if(it-1>=0)

            ans[node]-=cnt[it-1];

            ans[node]-=val*(tree[v].size()-it);

        }

    }

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

        int v = graph[u][i].fi;

        if(!vis[v])

            centroid(v);

    }

}



int main(){

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

    cin>>n;

    int u,v,w;

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

        cin>>u>>v>>w;

        graph[u].pb(mp(v,w));

        graph[v].pb(mp(u,w));

    }

    centroid(1);

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

        cout<<ans[i]<<"\n";

}


// Faster C++ solution for the same problem (measured speedup: 1.809756786762433x):
#include <bits/stdc++.h>

#define MOD 1000000007

#define int long long

#define pb push_back

#define bw(i,r,l) for (int i=r-1;i>=l;i--)

#define fw(i,l,r) for (int i=l;i<r;i++)

using namespace std;

typedef pair<int,int> ii;

typedef pair<int,ii> edge;

const int N=100005;

int n,par[N],sz[N],ans[N],lazy[N]; vector<edge> e; vector<int> child[100001];

int getp(int u) {

	if (u==par[u]) return u;

	return par[u]=getp(par[u]);

}

void joint(int u,int v,int val) {

	if (sz[u]>sz[v]) swap(u,v);

	//Now we only have to merge u into v

	while (child[u].size()) {

		child[v].pb(child[u].back());

		int temp=child[u].back();

		if (lazy[u]) ans[temp]+=lazy[u];

		ans[temp]+=val*sz[v];

		ans[temp]-=val*sz[u];

		ans[temp]-=lazy[v];

		child[u].pop_back();

	}

	lazy[v]+=sz[u]*val;

	sz[v]+=sz[u];

	par[u]=v;

}

signed main() {

	//freopen("aome.inp","r",stdin);

	ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

	cin>>n;

	fw (i,1,n) {

		int a,b,c; cin>>a>>b>>c; a--; b--;

		e.pb(edge(c,ii(a,b)));

	}

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

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

	/*

	Idea: Sort all edges based on their c values. Then if a and b doesn't belong to the same group,

	every item in b will connect to every item in a with a cost ofc.

	Merge the smaller group into the bigger one, so each item will be merged exactly log(N) times.

	To update the smaller group, just do it manually. To update the bigger group, we keep a lazy value

	for it, so if we need to update it later when merging we will also perform the lazy update.

	Call the larger group u, smaller one v. Every item in v is added c * sz[u], and otherwise.

	To successfully use lazy, erase all the elements in v by the supposed lazy value we will add.

	*/

	fw (i,0,n) {

		child[i].pb(i);

		sz[i]=1;

		par[i]=i;

		ans[i]=0;

		lazy[i]=0;

	}

	fw (i,0,e.size()) {

		int c=e[i].first,u=e[i].second.first,v=e[i].second.second;

		int pu=getp(u),pv=getp(v);

		if (pu==pv) continue;

		joint(pu,pv,c);

	}

	fw (i,0,n) ans[i]+=lazy[getp(i)];

	fw (i,0,n) cout<<ans[i]<<"\n";

}