/**************************************************************

     Problem: 3307

     User: rausen

     Language: C++

     Result: Accepted

     Time:5120 ms

     Memory:86068 kb

 ****************************************************************/

 #include <cstdio>

 #include <algorithm>

 using namespace std;

 const int N = 1e5 + ;

 const int Z = 1e9 + ;

 inline int read();

 struct seg {

     seg *ls, *rs;

     int mx, wmx;

     int tag;

     seg() {}

     #define Len (1 << 16)

     inline void* operator new(size_t) {

         static seg *mempool, *c;

         if (mempool == c)

             mempool = (c = new seg[Len]) + Len;

         return c++;

     }

     #undef Len

     inline void operator = (const seg &s) {

         mx = s.mx, wmx = s.wmx;

     }

     inline void update() {

         if (!ls && !rs) this -> mx = ;

         else if (!ls || !rs) *this = (ls ? *ls : *rs);

         else if (ls -> mx >= rs -> mx) *this = *ls;

         else *this = *rs;

     }

     inline void clear() {

         tag = , mx = ;

     }

     inline void push() {

         if (tag) {

             if (ls) ls -> clear();

             if (rs) rs -> clear();

             tag = ;

         }

     }

     #define mid (l + r >> 1)

     void modify(int l, int r, int pos, int d) {

         if (l == r) {

             mx += d, wmx = l;

             return;

         }

         push();

         if (pos <= mid) {

             if (!ls) ls = new()seg;

             ls -> modify(l, mid, pos, d);

         } else {

             if (!rs) rs = new()seg;

             rs -> modify(mid + , r, pos, d);

         }

         update();

     }

     #undef mid

 } *T;

 struct edge {

     int next, to;

     edge(int _n = , int _t = ) : next(_n), to(_t) {}

 } e[N << ];

 int first[N], tot;

 struct oper {

     int next, z, d;

     oper(int _n = , int _z = , int _d = ) : next(_n), z(_z), d(_d) {}

 } op[N << ];

 int First[N], tot_op;

 struct tree_node {

     int fa, son, top;

     int sz, dep;

 } tr[N];

 int n, m;

 int ans[N];

 inline void Add_Edges(int x, int y) {

     e[++tot] = edge(first[x], y), first[x] = tot;

     e[++tot] = edge(first[y], x), first[y] = tot;

 }

 #define y e[x].to

 void dfs(int p) {

     int x;

     tr[p].sz = ;

     for (x = first[p]; x; x = e[x].next)

         if (y != tr[p].fa) {

             tr[y].fa = p, tr[y].dep = tr[p].dep + ;

             dfs(y);

             tr[p].sz += tr[y].sz;

             if (tr[tr[p].son].sz < tr[y].sz) tr[p].son = y;

         }

 }

 void DFS(int p) {

     int x;

     if (!tr[p].son) return;

     tr[tr[p].son].top = tr[p].top, DFS(tr[p].son);

     for (x = first[p]; x; x = e[x].next)

         if (y != tr[p].fa && y != tr[p].son)

             tr[y].top = y, DFS(y);

 }

 #undef y

 inline void Add_oper(int x, int y, int z) {

     y = tr[y].son;

     op[++tot_op] = oper(First[x], z, ), First[x] = tot_op;

     op[++tot_op] = oper(First[y], z, -), First[y] = tot_op;

 }

 inline void work(int x, int y, int z) {

     while (tr[x].top != tr[y].top) {

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

         Add_oper(tr[x].top, x, z);

         x = tr[tr[x].top].fa;

     }

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

     Add_oper(y, x, z);

 }

 void get_ans(int p) {

     int x;

     for (x = First[p]; x; x = op[x].next)

         T -> modify(, Z, op[x].z, op[x].d);

     ans[p] = T -> mx ==  ?  : T -> wmx;

     if (tr[p].son) get_ans(tr[p].son);

 }

 int main() {

     int i, x, y, z;

     n = read(), m = read();

     for (i = ; i < n; ++i) Add_Edges(read(), read());

     dfs();

     tr[].top = , DFS();

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

         x = read(), y = read(), z = read();

         work(x, y, z);

     }

     T = new()seg;

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

         if (tr[i].top == i) {

             T -> clear();

             get_ans(i);

         }

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

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

     return ;

 }

 inline int read() {

     static int x;

     static char ch;

     x = , ch = getchar();

     while (ch < '' || '' < ch)

         ch = getchar();

     while ('' <= ch && ch <= '') {

         x = x *  + ch - '';

         ch = getchar();

     }

     return x;

 }