#include <cstdio>

#include <vector>

#include <algorithm>

#include <cstring>

#define lp p<<1

#define rp p<<1|1

#define ll long long

using namespace std;

const int maxn = 3e5 + ;

typedef pair<int, int> P;

int n, m;

int tot, head[maxn];

struct Edge{ int to, next; }edge[maxn<<];

vector<P> vec[maxn];

ll a[maxn<<], lazy[maxn<<], res[maxn];

inline void addedge(int u, int v) {

    edge[tot].to = v;

    edge[tot].next = head[u];

    head[u] = tot++;

}

inline void pushup(int p) {

    a[p] = a[lp] + a[rp];

}

inline void pushdown(int p, int llen, int rlen) {

    if (lazy[p]) {

        lazy[lp] += lazy[p];

        lazy[rp] += lazy[p];

        a[lp] += lazy[p] * llen;

        a[rp] += lazy[p] * rlen;

        lazy[p] = ;

    }

}

void build(int p, int l, int r) {

    a[p] = lazy[p] = ;

    if (l == r) return;

    int mid = l + r >> ;

    build(lp, l, mid);

    build(rp, mid + , r);

    pushup(p);

}

void update(int p, int l, int r, int x, int y, int z) {

    if (x <= l && y >= r) {

        a[p] += 1LL * z * (r - l + );

        lazy[p] += z;

        return;

    }

    int mid = l + r >> ;

    pushdown(p, mid - l + , r - mid);

    if (x <= mid) update(lp, l, mid, x, y, z);

    if (y > mid) update(rp, mid + , r, x, y, z);

    pushup(p);

}

ll query(int p, int l, int r, int u) {

    if (l == r) return a[p];

    int mid = l + r >> ;

    pushdown(p, mid - l + , r - mid);

    if (u <= mid) return query(lp, l, mid, u);

    return query(rp, mid + , r, u);

}

//截至这里 应该都是线段树的基本操作 没啥好说的

void dfs(int f, int u, int d) {

    for (int i = , sz = vec[u].size(); i < sz; i++) {

        // 因为线段树记录的是深度 所以就可以把当前结点以及深度差为k的全部更新一遍

        update(, , n, d, min(n, d + vec[u][i].first), vec[u][i].second);

    }

    //接下来dfs遍历的时候的update操作不会影响到父节点了 所以可以直接query得到答案

    res[u] = query(, , n, d);

    for (int i = head[u]; ~i; i = edge[i].next) {

        int v = edge[i].to;

        if (v == f) continue;

        // 深度位置是共享的 比如 1既连接2又连接3 上面更新了深度为1，2的 在线段树上 2代表的就是2和3的权值

        dfs(u, v, d + );

    }

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

        //回溯取消标记

        update(, , n, d, min(n, d + vec[u][i].first), -vec[u][i].second);

    }

}

int main() {

    scanf("%d", &n);

    tot = ;

    memset(head, -, sizeof(head));

    for (int i = , u, v; i < n - ; i++) {

        scanf("%d%d", &u, &v);

        addedge(u, v);

        addedge(v, u);

    }

    scanf("%d", &m);

    while (m--) {

        int v, d, x;

        scanf("%d%d%d", &v, &d, &x);

        vec[v].push_back(make_pair(d, x));

    }

    dfs(-, , );

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

        printf("%I64d", res[i]);

        if (i == n) puts("");

        else putchar(' ');

    }

    return ;

}