#include <bits/stdc++.h>
using namespace std;

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;

mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());

template <class F>
struct ycr {
	F f;
	template <class T> explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args> decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F> decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

struct GC {
	char buf[1<<16];
	size_t s = 0, e = 0;
	char operator()() {
		if (s >= e) {
			buf[0] = 0;
			s = 0;
			e = fread(buf, 1, sizeof(buf), stdin);
		}
		return buf[s++];
	}
} gc;
int scan_int() {
	char c;
	while ((c = gc()) < 40);
	if (c == '-') return -scan_int();
	int a = c - '0';
	while (isdigit(c = gc())) a = a * 10 + c - '0';
	return a;
}

template <class T> void setmax(T& a, const T& b) {
	if (a < b) a = b;
}

struct hldecomp {
	int n;
	vi ord;
	vc<array<int, 2>> idx;
	vc<pair<int, int>> heavy;
	vvc<int> ch;
	hldecomp(const vi& par) : n(sz(par)), ord(n), idx(n), heavy(n) {
		ch.resize(n);
		for (int i = 0; i < n; i++) {
			if (par[i] != -1) {
				ch[par[i]].push_back(i);
			}
		}
		vi s(n);
		int nidx = 0;
		for (int i = 0; i < n; i++) {
			if (par[i] != -1) continue;
			yc([&](auto self, int v) -> void {
				s[v] = 1;
				for (int w : ch[v]) {
					self(w);
					s[v] += s[w];
				}
				if (!ch[v].empty()) {
					auto mit = max_element(ch[v].begin(), ch[v].end(), [&](int a, int b) {
						return s[a] < s[b];
					});
					swap(*ch[v].begin(), *mit);
				}
			})(i);
			yc([&](auto self, int v, bool rt = true) -> void {
				ord[idx[v][0] = nidx++] = v;
				if (rt) {
					heavy[idx[v][0]] = {par[v] == -1 ? -1 : idx[par[v]][0], 1};
				} else {
					heavy[idx[v][0]] = heavy[idx[v][0]-1];
					heavy[idx[v][0]].second++;
				}
				bool crt = false;
				for (int w : ch[v]) {
					self(w, crt);
					crt = true;
				}
				idx[v][1] = nidx;
			})(i);
		}
		assert(n == nidx);
	}

	int lca(int a, int b) {
		a = idx[a][0], b = idx[b][0];
		while (true) {
			if (a > b) swap(a, b);
			if (a > b - heavy[b].second) {
				return ord[a];
			}
			b = heavy[b].first;
			if (b == -1) return -1;
		}
	}

	bool in_subtree(int a, int p) const {
		return idx[p][0] <= idx[a][0] && 
			idx[a][1] <= idx[p][1];
	}
};

template <class T> struct FT {
	vc<T> d;
	int s;
	FT(int n) { init(n); }
	void init(int n) {
		d.clear();
		d.resize(s = n);
	}
	void add(int i, T v) {
		for (; i < s; i |= i+1) d[i] += v;
	}
	T get(int i) {
		T res = 0;
		for (; i; i &= i-1) res += d[i-1];
		return res;
	}
};

int main() {
	//ios_base::sync_with_stdio(false), cin.tie(nullptr);

	int N, M, K;
	N = scan_int();
	M = scan_int();
	K = scan_int();

	vector<vector<int>> adj(N);
	for (int e = 0; e < N-1; e++) {
		int a = scan_int()-1;
		int b = scan_int()-1;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}

	vector<int> par(N);
	{
		yc([&](auto self, int cur, int prv) -> void {
			par[cur] = prv;
			for (int nxt : adj[cur]) {
				if (nxt == prv) continue;
				self(nxt, cur);
			}
		})(0, -1);
	}

	hldecomp hld(par);
	const auto& tree = hld.ch;

	struct P {
		int a, b, w;
	};
	vector<vector<P>> paths(N);
	for (int j = 0; j < M; j++) {
		int a = scan_int()-1;
		int b = scan_int()-1;
		int w = scan_int();
		int c = hld.lca(a, b);
		paths[c].push_back(P{a, b, w});
	}

	vector<ll> ans(N);
	FT<ll> ft_sum(N);

	vector<ll> cur_dp(1 << K);

	yc([&](auto self, int cur) -> void {
		for (int nxt : tree[cur]) {
			self(nxt);
		}

		const int num_ch = int(tree[cur].size());
		vector<ll> best(num_ch);
		vector<vector<ll>> best2(num_ch, vector<ll>(num_ch));

		auto update_sum = [&](int l, int r, ll x) -> void {
			ft_sum.add(l, x);
			ft_sum.add(r, -x);
		};
		auto get_sum = [&](int i) -> ll {
			const int idx = hld.idx[i][0];
			return ft_sum.get(idx+1);
		};
		auto get_which_ch = [&](int i) -> int {
			for (int c = 0; c < num_ch; c++) {
				if (hld.in_subtree(i, tree[cur][c])) return c;
			}
			assert(false);
		};
		auto get_val = [&](int i) -> ll {
			return get_sum(i);
		};

		for (auto [a, b, w] : paths[cur]) {
			if (b == cur) {
				swap(a, b);
			}
			if (a == cur) {
				const int b_ch = get_which_ch(b);
				const ll val = get_val(b) + w;
				setmax(best[b_ch], val);
			} else {
				int a_ch = get_which_ch(a);
				int b_ch = get_which_ch(b);
				const ll val = get_val(a) + get_val(b) + w;
				if (a_ch > b_ch) swap(a_ch, b_ch);
				setmax(best2[a_ch][b_ch], val);
			}
		}

		for (int m = 1; m < (1 << num_ch); m++) {
			const int i = __builtin_ctz(m);
			cur_dp[m] = cur_dp[m - (1 << i)] + max(best[i], ans[tree[cur][i]]);
			int o = m - (1 << i);
			while (o) {
				int j = __builtin_ctz(o);
				setmax(cur_dp[m], cur_dp[m - (1 << i) - (1 << j)] + best2[i][j]);
				o -= (1 << j);
			}
		}
		ans[cur] = cur_dp[(1 << num_ch) - 1];
		update_sum(hld.idx[cur][0], hld.idx[cur][0]+1, ans[cur]);
		for (int c = 0; c < num_ch; c++) {
			int nxt = tree[cur][c];
			update_sum(hld.idx[nxt][0], hld.idx[nxt][1], cur_dp[(1 << num_ch) - 1 - (1 << c)]);
		}

	})(0);
	cout << ans[0] << '\n';
}