#include <iostream>

#include <cstdio>

#include <string.h>

#include <vector>

#include <algorithm>

#pragma comment(linker,"/STACk:10240000,10240000")

using namespace std;

const int maxn=;

vector<int>F[maxn];

int son[maxn],num[maxn],fa[maxn],top[maxn],p[maxn],fp[maxn],pos,depth[maxn],ans[maxn];

vector<int>P[maxn];

int loc,v;

struct SegmentItree{

    int num[maxn*],id[maxn*];

    void build(int o,int L, int R){

        num[o]=;

        id[o]=;

        if(L>=R){

             num[o]=; id[o]=L;

             return ;

        }

        int mid = (L+R)/;

        build(o*,L,mid );

        build(o*+,mid+,R);

    }

    void maintain(int o){

         num[o]=;

         id[o]=;

         if(num[o*]==&&num[o*+]==)return;

         if( num[o*] >= num[o*+] ){

            num[o]=num[o*];

            id[o]=id[o*];

         } else{

            num[o] =num[o*+];

            id[o]=id[o*+];

         }

    }

    void add(int o,int L, int R){

          if(L>=R){

             num[o]+=v;

            return ;

          }

          int mid = (L+R)>>;

          if(loc<=mid){

             add(o*,L,mid);

          }else{

             add(o*+, mid+,R);

          }

          maintain(o);

    }

}T;

void inti(int n){

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

    F[i].clear(),P[i].clear();

    pos=;

}

void dfs(int cur, int per,int dep){

    depth[cur]=dep;

    son[cur]=-;

    fa[cur]=per;

    num[cur]=;

    int Len= F[cur].size();

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

         int to = F[cur][i];

         if(to==per) continue;

         dfs(to,cur,dep+);

         num[cur]+=num[to];

         if( son[ cur ] == - || num[ son[cur] ]< num[to] ) son[cur]=to;

    }

}

void finde(int cur , int per, int xx){

      top[cur]=xx;

      pos++;

      p[cur]=pos;

      fp[pos]=cur;

      if(son[cur]!=-)

      finde(son[cur],cur,xx);

      int len = F[cur].size();

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

           int to= F[cur][i];

           if(to==per||to==son[cur])continue;

           finde(to,cur,to);

      }

}

void solve(int x, int y,int d){

    int f1=top[x],f2=top[y];

    while(f1!=f2){

         if(depth[f1]<depth[f2]){

             int temp = x; x=y; y= temp;

             temp=f1; f1=f2; f2=temp;

         }

         P[ p[f1] ].push_back(d);

         P[ p[x]+ ].push_back(-d);

         x=fa[f1];

         f1=top[x];

    }

    if(depth[x]>depth[y]){

        int temp = x; x = y ; y= temp;

    }

    P[p[x]].push_back(d);

    P[p[y]+].push_back(-d);

}

int main()

{

    int n,m;

    for(;;){

        scanf("%d%d",&n,&m);

        if(n==&&m==)break;

        inti(n);

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

             int a,b;

             scanf("%d%d",&a,&b);

             F[a].push_back(b);

             F[b].push_back(a);

        }

        dfs(,,);

        finde(,,);

        int N=;

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

             int a,b,d;

             scanf("%d%d%d",&a,&b,&d);

             solve(a,b,d);

            N=max(d,N);

        }

       memset(ans,,sizeof(ans));

       if(N!=){

        T.build(,,N);

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

             int L = P[i].size();

             for(int j=; j<L; ++j){

                 int to= P[i][j];

                 if(to>){

                     v=;

                     loc=to;

                 }else{

                     v=-;

                     loc=-to;

                 }

                 T.add(,,N);

             }

             if(T.num[]!=)

             ans[fp[i]]=T.id[];

             else ans[fp[i]]=;

        }

       }

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

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

    }

    return ;

}