#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = N << 1, R = 1e5;

struct Node {
    int l, r;
    int max, pos; // max 表示物品最大值，pos 表示物品最大值对应的类型离散化后的编号
} tr[N * 4 * 17]; //为啥开这么大的空间？？

int root[N], cnt; //记录每个节点对应的线段树的根节点的下标

struct Query {
    int x, y, z;
} query[N]; //记录所有查询

int n, m;
int h[N], e[M], ne[M], idx; //邻接表
int res[N];                 //记录每个节点的答案

void add(int a, int b) { //添加边
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

#pragma region 求LCA的倍增模板
int depth[N], f[N][17]; // dep[i] 表示节点 i 的深度，fa[i][j] 表示节点 i 向上走 2^j 步到达的节点
void bfs(int t) {       //利用递推公式:f[i,j]=f[f[i,j-1],j-1]，在bfs遍历过程中，填充递推结果数组的值
    queue<int> q;
    q.push(t);
    depth[t] = 1; //根结点的深度是1
    while (q.size()) {
        int u = q.front();
        q.pop();
        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            if (depth[j]) continue;       //如果深度为0，表示没有访问过，防止走回头路
            depth[j] = depth[u] + 1;      //更新深度
            f[j][0] = u;                  //记录 j的 2^0 步可以跳到的节点是u
            for (int k = 1; k <= 16; k++) //利用递推式计算出距离j 2^1 ,2^2,2^3,....的是哪个节点
                f[j][k] = f[f[j][k - 1]][k - 1];
            q.push(j); //利用j继续扩展
        }
    }
}
//求a和b的最近公共祖先
int lca(int a, int b) {
    if (depth[a] < depth[b]) swap(a, b); //保证a在下，b在上
    for (int k = 16; k >= 0; k--)        //向上跳到b节点的同一层
        if (depth[f[a][k]] >= depth[b])
            a = f[a][k];
    if (a == b) return a; //都是一个节点了，返回谁都是一样的
    //开始一起向上跳
    for (int k = 16; k >= 0; k--)
        if (f[a][k] != f[b][k])
            a = f[a][k], b = f[b][k];
    //父层就是LCA
    return f[a][0];
}

#pragma endregion

void pushup(int u) { //用子节点信息更新父节点信息
    tr[u].max = max(tr[tr[u].l].max, tr[tr[u].r].max);
    //如果多个物品数量相同，优先记录最靠左的物品编号
    tr[u].pos = tr[tr[u].l].max >= tr[tr[u].r].max ? tr[tr[u].l].pos : tr[tr[u].r].pos;
}

void insert(int u, int l, int r, int x, int z) { //将 x 类型 + v
    if (l == r) {                                //找到指定类型
        tr[u].max += z;                          //修改物品个数
        tr[u].pos = tr[u].max ? l : 0;           //如果物品还有，保存下标，如果物品为空，为 0
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) {                    //递归左区间
        if (!tr[u].l) tr[u].l = ++cnt; //如果左子节点不存在，动态开点
        insert(tr[u].l, l, mid, x, z);
    } else {                           //递归右区间
        if (!tr[u].r) tr[u].r = ++cnt; //如果右子节点不存在，动态开点
        insert(tr[u].r, mid + 1, r, x, z);
    }
    pushup(u); //用子节点信息更新父节点信息
}

//线段树合并
int merge(int u, int v, int l, int r) {
    if (!u) return v;           //如果 u 不存在，直接返回 v
    if (!v) return u;           //如果 v 不存在，直接返回 u
    if (l == r) {               //如果是单独一个节点
        tr[u].max += tr[v].max; //节点合并
        tr[u].pos = tr[u].max ? l : 0;
        return u;
    }
    int mid = (l + r) >> 1;
    tr[u].l = merge(tr[u].l, tr[v].l, l, mid);     //合并左子节点
    tr[u].r = merge(tr[u].r, tr[v].r, mid + 1, r); //合并右子节点
    pushup(u);                                     //用子节点信息更新父节点信息
    return u;
}

// dfs求以每个节点为根节点的子树和
void dfs(int u) {
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (depth[j] <= depth[u]) continue;      //只能往下走
        dfs(j);                                  //搜索子节点
        root[u] = merge(root[u], root[j], 1, R); //合并
    }
    res[u] = tr[root[u]].pos; //记录当前节点的答案(子树和)
}

int main() {
    // OJ的环境不使用文件输入输出
#ifndef ONLINE_JUDGE
    freopen("P4556.out", "w", stdout);
    freopen("P4556.in", "r", stdin);
#endif
    //优化读入
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    memset(h, -1, sizeof h); //初始化邻接表
    cin >> n >> m;
    for (int i = 1; i < n; i++) {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a); //无向边
    }

    bfs(1); //预处理 depth[], f[][],下面要计算LCA，这个是基础数据

    //为每个节点开一个动态开点的线段树
    for (int i = 1; i <= n; i++) root[i] = ++cnt;

    for (int i = 0; i < m; i++)
        cin >> query[i].x >> query[i].y >> query[i].z; //从x到y的区间，发一个z类型的物品

    //树上差分
    for (int i = 0; i < m; i++) {
        int x = query[i].x, y = query[i].y, z = query[i].z;
        int p = lca(x, y);                                 //求出x,y的最近公共祖先
        insert(root[x], 1, R, z, 1);                       // c[x][z] + 1
        insert(root[y], 1, R, z, 1);                       // c[y][z] + 1
        insert(root[p], 1, R, z, -1);                      // c[lca(x, y)][z] - 1
        if (f[p][0]) insert(root[f[p][0]], 1, R, z, -1);   // c[fa(lca(x, y))][z] - 1
    }

    //求子树和+线段树合并
    dfs(1);

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

    return 0;
}