#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
int const maxn = 1e5 + 5, logg = 17, K = 12;
vector < int > g[maxn];
vector < int > G[maxn];
vector < vector < int > > go[maxn], in[maxn];
vector < int > open[maxn];
int h[maxn], up[maxn][logg], W[5 * maxn];
ll dp[maxn];
unordered_map < int, ll > dp_calc[maxn];
int cmp[maxn];
ll add[maxn];
ll f[(1 << K)];
ll val_one[K], val_two[K][K];

void dfs(int v) {
    cmp[v] = v;
    for (auto u : G[v]) {
        dfs(u);
        if (dp_calc[cmp[u]].size() > dp_calc[cmp[v]].size()) cmp[v] = cmp[u];
    }
    int N = G[v].size();
    assert(N <= K);
    for (int i = 0; i < N; i++) {
        val_one[i] = dp[G[v][i]];
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) val_two[i][j] = 0;
    }
    for (auto key : in[v]) {
        int ind_vertex = key[1], ind_path = key[0];
        int to = G[v][ind_vertex];
        val_one[ind_vertex] = max(val_one[ind_vertex], dp_calc[cmp[to]][ind_path] + add[cmp[to]] + W[ind_path]);
    }
    for (auto key : go[v]) {
        int ind_path = key[0], ind_v1 = key[1], ind_v2 = key[2];
        int u1 = G[v][ind_v1], u2 = G[v][ind_v2];
        ll value = dp_calc[cmp[u1]][ind_path] + dp_calc[cmp[u2]][ind_path] + add[cmp[u1]] + add[cmp[u2]] + W[ind_path];
        val_two[ind_v1][ind_v2] = max(val_two[ind_v1][ind_v2], value);
        val_two[ind_v2][ind_v1] = max(val_two[ind_v2][ind_v1], value);
    }
    for (int mask = 0; mask < (1 << N); mask++) f[mask] = 0;
    for (int mask = 0; mask < (1 << N) - 1; mask++) {
        for (int i = 0; i < N; i++) {
            if ((mask>>i)&1) continue;
            f[mask|(1 << i)] = max(f[mask|(1 << i)], f[mask] + val_one[i]);
            for (int j = i + 1; j < N; j++) {
                if ((mask>>j)&1) continue;
                f[mask|(1 << j)|(1 << i)] = max(f[mask|(1 << j)|(1 << i)], f[mask] + val_two[i][j]);
            }
        }

    }
    for (int i = 0; i < N; i++) {
        assert(val_one[i] >= 0);
        for (int j = 0; j < N; j++) assert(val_two[i][j] >= 0);
    }
    dp[v] = f[(1 << N) - 1];
    for (int i = 0; i < N; i++) {
        int msk = (((1 << N) - 1)^(1 << i));
        int u = G[v][i];
        add[cmp[u]] += f[msk];
    }
    for (auto u : G[v]) {
        if (cmp[v] == cmp[u]) continue;
        ll dd = add[cmp[u]] - add[cmp[v]];
        for (auto elem : dp_calc[cmp[u]]) {
            dp_calc[cmp[v]][elem.first] = elem.second + dd;
        }
    }
    ll dd = add[cmp[v]];
    for (auto key : open[v]) {
        dp_calc[cmp[v]][key] = dp[v] - dd;
    }
    //if (v == 4) cout << dp_calc[cmp[v]][1] + add[cmp[v]] << endl;
}

void calc(int v, int p) {
    up[v][0] = p;
    h[v] = h[p] + 1;
    for (int i = 1; i < logg; i++) up[v][i] = up[up[v][i - 1]][i - 1];
    for (auto u : g[v]) {
        if (u != p) {
            calc(u, v);
            G[v].push_back(u);
        }
    }
}

int numb(int v, int need) {
    for (int j = 0; j < G[v].size(); j++) {
        if (G[v][j] == need) return j;
    }
    assert(1 == 0);
}

int get_la(int v, int k) {
    for (int i = 0; i < logg; i++) {
        if ((k>>i)&1) v = up[v][i];
    }
    return v;
}

int get_lca(int u, int v) {
    if (h[u] > h[v]) u = get_la(u, h[u] - h[v]);
    else v = get_la(v, h[v] - h[u]);
    if (u == v) return v;
    for (int i = logg - 1; i >= 0; i--) {
        if (up[v][i] != up[u][i]) v = up[v][i], u = up[u][i];
    }
    return up[v][0];
}

main() {
#ifdef HOME
    freopen("input.txt", "r", stdin);
#endif // HOME
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n, m, k, u, v, w;
    cin >> n >> m >> k;
    ll ans = 0;
    for (int i = 1; i < n; i++) {
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    calc(1, 0);
    for (int i = 1; i <= m; i++) {
        cin >> u >> v >> w;
        W[i] = w;
        if (u == v) {
            ans += w;
            continue;
        }
        int lca = get_lca(u, v);
        if (u != lca && v != lca) {
            go[lca].push_back({i, numb(lca, get_la(u, h[u] - h[lca] - 1)), numb(lca, get_la(v, h[v] - h[lca] - 1))});
            open[u].push_back(i);
            open[v].push_back(i);
        } else if (u == lca) {
            in[lca].push_back({i, numb(lca, get_la(v, h[v] - h[lca] - 1))});
            open[v].push_back(i);
        } else {
            in[lca].push_back({i, numb(lca, get_la(u, h[u] - h[lca] - 1))});
            open[u].push_back(i);
        }
    }
    dfs(1);
    ans += dp[1];
    cout << ans << '\n';
    return 0;
}