//#define NOSTDCPP
//#define Cpp11
#define Linux_System
#ifndef NOSTDCPP
	
#include <bits/stdc++.h>
	
#else
	
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <complex>
#include <cstring>
#include <cstdio>
#include <deque>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <istream>
#include <iterator>
#include <list>
#include <map>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
	
#endif
	
# ifdef Linux_System
# define getchar getchar_unlocked
# define putchar putchar_unlocked
# endif
	
# define RESET(_) memset(_, 0, sizeof(_))
# define RESET_(_, val) memset(_, val, sizeof(_))
# define fi first
# define se second
# define pb push_back
# define midf(x, y) ((x + y) >> 1)
# define DXA(_) ((_ << 1))
# define DXB(_) ((_ << 1) | 1)
	
# define next __Chtholly__
# define x1 __Mercury__
# define y1 __bbtl04__
# define index __ikooo__
	
using namespace std;
	
typedef long long ll;
typedef unsigned long long ull;
typedef vector <int> vi;
typedef set <int> si;
typedef pair <int, int> pii;
typedef long double ld;
	
const int MOD = 1e9 + 7;
const int maxn = 100009;
const int maxm = maxn << 1;
const int inf = 2e9;
const double pi = acos(-1.0);
const double eps = 1e-6;
	
ll myrand(ll mod){return ((ll)rand() << 32 ^ (ll)rand() << 16 ^ rand()) % mod;}
	
template <class T>
inline bool scan_d(T & ret)
{
	char c;
	int sgn;
	if(c = getchar(), c == EOF)return false;
	while(c != '-' && (c < '0' || c > '9'))c = getchar();
	sgn = (c == '-') ? -1 : 1;
	ret = (c == '-') ? 0 : (c - '0');
	while(c = getchar(), c >= '0' && c <= '9')
		ret = ret * 10 + (c - '0');
	ret *= sgn;
	return true;
}
#ifdef Cpp11
template <class T, class ... Args>
inline bool scan_d(T & ret, Args & ... args)
{
	scan_d(ret);
	scan_d(args...);
}
#define cin.tie(0); cin.tie(nullptr);
#define cout.tie(0); cout.tie(nullptr);
#endif
inline bool scan_ch(char &ch)
{
	if(ch = getchar(), ch == EOF)return false;
	while(ch == ' ' || ch == '\n')ch = getchar();
	return true;
}
	
template <class T>
inline void out_number(T x)
{
	if(x < 0)
	{
		putchar('-');
		out_number(- x);
		return ;
	}
	if(x > 9)out_number(x / 10);
	putchar(x % 10 + '0');
}
	
int v[maxm], prevv[maxm];
int info[maxn], deep[maxn], size[maxn];
int father[maxn], head[maxn], son[maxn], id[maxn], pid[maxn], nedge, cnt;
int n, m, k;
	
inline void insert(int x, int y)
{
	++ nedge;
	v[nedge] = y;
	prevv[nedge] = info[x];
	info[x] = nedge;
}
	
void dfs1(int u, int pre, int d)
{
	deep[u] = d;
	father[u] = pre;
	son[u] = 0;
	size[u] = 1;
	for(int i = info[u]; i; i = prevv[i])
	{
		if(v[i] != pre)
		{
			dfs1(v[i], u, d + 1);
			size[u] += size[v[i]];
			if(! son[u] || size[v[i]] > size[son[u]])
				son[u] = v[i];
		}
	}
}
	
void getpos(int u, int sp)
{
	head[u] = sp;
	id[u] = ++ cnt;
    pid[cnt] = u;
	if(son[u]) getpos(son[u], sp);
	for(int i = info[u]; i; i = prevv[i])
	{
		if(v[i] != son[u] && v[i] != father[u])
			getpos(v[i], v[i]);
	}
}
	
void init()
{
	nedge = 0;
    RESET_(deep, -1);
}
	
struct query
{
	int f, t, c;
}qqq[maxn];
	
int ans[maxn];
	
int Max[maxn << 2], tag[maxn << 2], place[maxn << 2];
	
inline void __copy(int x, const int y) {Max[x] = Max[y], place[x] = place[y];}
inline void __tag(int p, int v) {Max[p] += v; tag[p] += v;}
	
inline void pushup(int p)
{
	if(Max[DXA(p)] > Max[DXB(p)])
		__copy(p, DXA(p));
	else __copy(p, DXB(p));
}
	
inline void pushdown(int p)
{
	if(tag[p])
	{
		__tag(DXA(p), tag[p]);
		__tag(DXB(p), tag[p]);
		tag[p] = 0;
	}
}
	
void pre(int l, int r, int p)
{
	Max[p] = 0, tag[p] = 0, place[p] = l;
	if(l == r) return ;
	int mid = midf(l, r);
	pre(l, mid, DXA(p));
	pre(mid + 1, r, DXB(p));
	pushup(p);
}
	
int l, r, val;
void update(int nl, int nr, int p)
{
	if(l <= nl && nr <= r)
	{
		__tag(p, val);
		return ;
	}
	pushdown(p);
	int mid = midf(nl, nr);
	if(l <= mid) update(nl, mid, DXA(p));
	if(mid < r)  update(mid + 1, nr, DXB(p));
	pushup(p);
}
	
void __update__(int u, int v, int vv)
{
    int f1 = head[u], f2 = head[v];
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2])
        {
            swap(f1, f2);
            swap(u, v);
        }
        l = id[f1], r = id[u];
        val = 1;
        update(1, n, 1);
        u = father[f1]; f1 = head[u];
    }
    if(deep[u] > deep[v]) swap(u, v);
    l = id[u], r = id[v];
    val = 1;
    update(1, n, 1);
    val = -inf;
    while(true)
    {
    	if(Max[1] < k) break;
    	l = r = place[1];
    	update(1, n, 1);
    	ans[pid[l]] = vv;
	}
}
	
int main()
{
	init();
	scan_d(n);
	scan_d(m);
	scan_d(k);
	for(int i = 1, f, t; i < n; ++ i)
	{
		scan_d(f);
		scan_d(t);
		insert(f, t);
		insert(t, f);
	}
	pre(1, n, 1);
	dfs1(1, -1, 1);
	getpos(1, 1);
	for(int i = 1; i <= m; ++ i)
	{
		scan_d(qqq[i].f);
		scan_d(qqq[i].t);
		scan_d(qqq[i].c);
	}
	for(int i = m; i >= 1; -- i)
		__update__(qqq[i].f, qqq[i].t, qqq[i].c);
	for(int i = 1; i <= n; ++ i) out_number(ans[i]), putchar(i != n ? ' ' : '\n');
	return 0;
}