#include <cstdio>

#include <cstring>

#include <queue>

#include <algorithm>

using namespace std;

const int N = 1e5 + ;

const int Lg = ;

int n, m, maxn = , tot = , head[N], ans[N];

int fa[N][Lg], dep[N], inx[N], iny[N], inv[N], val[N];

struct Edge {

    int to, nxt;

} e[N << ];

inline void add(int from, int to) {

    e[++tot].to = to;

    e[tot].nxt = head[from];

    head[from] = tot;

}

struct Innum {

    int val, id;

} in[N];

bool cmp(const Innum &x, const Innum &y) {

    if(x.val != y.val) return x.val < y.val;

    else return x.id < y.id;

}

inline void swap(int &x, int &y) {

    int t = x; x = y; y = t;

}

inline void chkMax(int &x, int y) {

    if(y > x) x = y;

}

inline int min(int x, int y) {

    return x > y ? y : x;

}

inline void read(int &X) {

    X = ; char ch = ; int op = ;

    for(; ch > '' || ch < ''; ch = getchar())

        if(ch == '-') op = -;

    for(; ch >= '' && ch <= ''; ch = getchar())

        X = (X << ) + (X << ) + ch - ;

    X *= op;

}

inline void discrete() {

    sort(in + , in +  + m, cmp);

    for(int cnt = , i = ; i <= m; i++) {

        if(in[i].val != in[i - ].val) ++cnt;

        chkMax(maxn, cnt);

        inv[in[i].id] = cnt;

        val[cnt] = in[i].val;

    }

}

void dfs(int x, int fat, int depth) {

    dep[x] = depth, fa[x][] = fat;

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

        fa[x][i] = fa[fa[x][i - ]][i - ];

    for(int i = head[x]; i; i = e[i].nxt) {

        int y = e[i].to;

        if(y == fat) continue;

        dfs(y, x, depth + );

    }

}

inline int getLca(int x, int y) {

    if(dep[x] < dep[y]) swap(x, y);

    for(int i = ; i >= ; i--)

        if(dep[fa[x][i]] >= dep[y])

            x = fa[x][i];

    if(x == y) return x;

    for(int i = ; i >= ; i--)

        if(fa[x][i] != fa[y][i])

            x = fa[x][i], y = fa[y][i];

    return fa[x][];

}

namespace PSegT {

    struct Node {

        int lc, rc, sum, col;

    } s[N * ];

    int root[N], nodeCnt = ;

    queue <int> Q;

    inline void push(int x) {

        Q.push(x);

    }

    inline int newNode() {

        if(Q.empty()) return ++nodeCnt;

        else {

            int res = Q.front();

            Q.pop();

            return res;

        }

    }

    #define lc(p) s[p].lc

    #define rc(p) s[p].rc

    #define sum(p) s[p].sum

    #define col(p) s[p].col

    #define mid ((l + r) >> 1)

    inline void up(int p) {

        if(!p) return;

        if(sum(lc(p)) < sum(rc(p))) col(p) = col(rc(p)), sum(p) = sum(rc(p));

        else col(p) = col(lc(p)), sum(p) = sum(lc(p));

    }

    void modify(int &p, int l, int r, int x, int v) {

        if(!p) p = newNode();

        if(l == r) {

            sum(p) += v;

            if(sum(p) > ) col(p) = l;

            else col(p) = ;

            return;

        }

        if(x <= mid) modify(lc(p), l, mid, x, v);

        else modify(rc(p), mid + , r, x, v);

        up(p);

    }

    int merge(int u, int v, int l, int r) {

        if(!u || !v) return u + v;

        int p = newNode();

        if(l == r) {

            sum(p) = sum(u) + sum(v);

            if(sum(p) > ) col(p) = l;

            else col(p) = ;

        } else {

            lc(p) = merge(lc(u), lc(v), l, mid);

            rc(p) = merge(rc(u), rc(v), mid + , r);

            up(p);

        }

        push(u), push(v);

        return p;

    }

} using namespace PSegT;

void solve(int x) {

    for(int i = head[x]; i; i = e[i].nxt) {

        int y = e[i].to;

        if(y == fa[x][]) continue;

        solve(y);

        root[x] = merge(root[x], root[y], , maxn);

    }

/*    printf("%d: ", x);

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

        printf("%d ", query(root[id[x] - 1], root[id[x]], 1, maxn, i));

    printf("\n");    */

    ans[x] = val[s[root[x]].col];

}

int main() {

    read(n), read(m);

    for(int x, y, i = ; i < n; i++) {

        read(x), read(y);

        add(x, y), add(y, x);

    }

    dfs(, , );

//    maxn = 1e5;

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

        read(inx[i]), read(iny[i]), read(inv[i]);

        in[i].id = i, in[i].val = inv[i];

    }

    discrete();

    for(int x, y, v, z, w, i = ; i <= m; i++) {

        x = inx[i], y = iny[i], v = inv[i];

        z = getLca(x, y), w = fa[z][];

/*        vec[x].push_back(pin(v, 1));

        vec[y].push_back(pin(v, 1));

        vec[z].push_back(pin(v, -1));

        if(w) vec[w].push_back(pin(v, -1));    */

        modify(root[x], , maxn, v, );

        modify(root[y], , maxn, v, );

        modify(root[z], , maxn, v, -);

        if(w) modify(root[w], , maxn, v, -);

    }            

/*    printf("\n");

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

        printf("%d: ", i);

        for(int j = 1; j <= maxn; j++)

            printf("%d ", query(root[id[i] - 1], root[id[i] + siz[i] - 1], 1, maxn, j));

        printf("\n");

    }

    printf("\n");    */

    solve();

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

        printf("%d\n", ans[i]);

    return ;

}