#include<iostream>
#include<vector>
#include<unordered_set>

std::vector<int> diameter_path(const std::vector<std::vector<int>> &g){
    const int n=g.size();
    std::vector<int> d(n);
    std::vector<int> par(n);
    const auto dfs=[&](auto &Self,int v,int p,int pval)->void{
        par[v]=p;
        d[v]=pval;
        for(int ne:g[v])if(ne!=p){
            Self(Self,ne,v,pval+1);
        }
        return;
    };
    dfs(dfs,0,-1,0);
    int MAX=0;
    int u=-1;
    for(int i=0;i<n;i++){
        if(MAX<d[i]){
            MAX=d[i];
            u=i;
        }
    }

    dfs(dfs,u,-1,0);
    MAX=0;
    int v=-1;
    for(int i=0;i<n;i++){
        if(MAX<d[i]){
            MAX=d[i];
            v=i;
        }
    }

    std::vector<int> ans(d[v]+1);
    for(int i=0;i<(int)ans.size();i++){
        ans[i]=v;
        v=par[v];
    }
    return ans;
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.precision(10);
/*------------------------------------*/
    
    int n;
    std::cin >> n;
    std::vector<std::vector<int>> g(n);
    for(int i=0;i<n-1;i++){
        int a,b;std::cin >> a >> b;
        a--,b--;
        g[a].emplace_back(b);
        g[b].emplace_back(a);
    }
    auto path=diameter_path(g);
    std::unordered_set<int> last;
    for(int i:path)last.insert(i);
    
    std::vector<int> ans(n);

    auto dfs=[&](auto &Self,int v,int p,int val)->int{
        ans[v]=val;
        int las=-1;
        for(int ne:g[v])if(ne!=p){
            if(last.count(ne))las=ne;
            else val=Self(Self,ne,v,val+1);
        }
        if(las!=-1)val=Self(Self,las,v,val+1);
        return val+1;
    };

    dfs(dfs,path.front(),-1,1);
    for(int i=0;i<n;i++)std::cout << ans[i] << " \n"[i+1==n];
}
/*
一応,diameter_path()が他に依存していないか確認.

解説AC.
沼ったが,「番号が小さい順にたどる」ことを考えると明らかになる.
一旦E[0]<E[1]...となるようにする.(あとで適切な頂点番号の振り直しを考える.)
dist(i,i+k)<=dist(i,i+1)+...+dist(i+k-1,i+k)なので, 各iに対してdist(i,i+1)<=E[i+1]-E[i]が成り立てばいい.
よって,この頂点順序で最小化するにはdist(i,i+1)=E[i+1]-E[i]にする.
結局max(E)は, dfsで全頂点たどる時の移動距離になる.
始点-終点の距離だけ移動をさぼれることを考えれば, 直径の端点を始点/終点にするのが最適.
*/
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <functional>



void solve() {
	int n;
	std::cin >> n;
	std::vector<int> a(n), b(n);
	std::vector<int> in(n, -1);
	std::vector<int64_t> ans(n + 1, 0);
	std::vector<std::pair<int, int>> io(n, std::pair<int, int>(-1, -1));
	std::vector<std::vector<std::pair<int, int>>> gr(n);
	for (int i = 1; i < n; i++) {
		std::cin >> a[i] >> b[i];
		a[i]--;
		b[i]--;
		gr[a[i]].push_back({ b[i], i });
		gr[b[i]].push_back({ a[i], i });
	}
	int e = 0;
	std::function<void(int, int)> dfs = [&](int v, int f) {
		in[v] = e++;
		for (auto &ed : gr[v]) {
			if (ed.first != f) {
				a[ed.second] = ed.first != a[ed.second];				
				io[ed.second].first = e;
				dfs(ed.first, v);
				io[ed.second].second = e;
			}
		}
	};
	dfs(0, -1);
	int q;
	std::cin >> q;
	for (int tt = 0; tt < q; tt++) {
		int p, t, x;
		std::cin >> t >> p >> x;
		t--;
		int l = io[p].first, r = io[p].second;
		t ^= a[p];
		if (t == 0) {
			ans[l] += x;
			ans[r] -= x;
		} else {
			ans[0] += x;
			ans[l] -= x;
			ans[r] += x;
		}
	}
	for (int i = 1; i < n; i++) {
		ans[i] += ans[i - 1];
	}
	for (int i = 0; i < n; i++) {
		std::cout << ans[in[i]] << " \n"[i == (n - 1)];
	}
}


int32_t main() {
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int t = 1;
	//std::cin >> t;
	while (t--) {
		solve();
	}


	return 0;
}