#include "bits/stdc++.h"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

const int INFi = 2e9;
const ll INF = 1e18;
const int LG = 18;

const int N = 1e5 + 5;

vi g[N];

int up[N][20];
int h[N];

int lca(int v, int u) {
    if (h[v] < h[u]) swap(u, v);
    for (int i = 19; i >= 0; --i) {
        if (h[up[v][i]] >= h[u]) v = up[v][i];
    }
    if (u == v) return v;
    for (int i = 19; i >= 0; --i) {
        if (up[v][i] != up[u][i]) v = up[v][i], u = up[u][i];
    }
    return up[v][0];
}

int dist(int a, int b) {
    return h[a] + h[b] - 2 * h[lca(a, b)];
}

void dfs_lca(int v, int p) {
    up[v][0] = p;
    for (int i = 1; i < 20; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
    for (auto &u: g[v]) {
        if (u == p) continue;
        h[u] = h[v] + 1;
        dfs_lca(u, v);
    }
}

int kth_anc(int v, int k) {
    rep(i, LG) if ((1 << i) & k) v = up[v][i];
    return v;
}


vi lazy[N];
ll lazy_add[N];
const int M = 5e5 + 5;
ll cost[M];
int a[M], b[M], c[M];
int aU[M], bU[M];
vi st[N];
vi en[N];
ll dp1[N];
int ind[N];
bool used[M];

void dfs(int v, int p) {
    vi ch;
    for (auto &u: g[v]) {
        if (u == p) continue;
        dfs(u, v);
        ch.push_back(u);
    }
    int sz = (int) ch.size();
    assert(sz <= 12);
    vl dp(1 << sz, 0);
    dp[0] = 0;
    vl cost1(sz);
    rep(i, sz) {
        cost1[i] = dp1[ch[i]];
        ind[ch[i]] = i;
    }
    vector<vl> cost2(sz, vl(sz, -INF));
    for (auto &i: en[v]) {
        used[i] = true;
        if (a[i] == c[i]) {
            int u = bU[i];
            cost[i] += lazy_add[u];
            cost1[ind[u]] = max(cost1[ind[u]], cost[i]);
        } else {
            int au = aU[i];
            int bu = bU[i];
            cost[i] += lazy_add[au];
            cost[i] += lazy_add[bu];
            cost2[ind[au]][ind[bu]] = max(cost2[ind[au]][ind[bu]], cost[i]);
            cost2[ind[bu]][ind[au]] = max(cost2[ind[bu]][ind[au]], cost[i]);
        }
    }
    rep(mask, 1 << sz) {
        rep(i, sz) {
            if ((1 << i) & mask) continue;
            ckmax(dp[(1 << i) | mask], dp[mask] + cost1[i]); // add 1
            for(int j = i + 1; j < sz; ++j) {
                if ((1 << j) & mask) continue;
                ckmax(dp[(1 << i) | (1 << j) | mask], dp[mask] + cost2[i][j]); // add 2
            }
            break;
        }
        repr(i, sz) {
            if ((1 << i) & mask) continue;
            ckmax(dp[(1 << i) | mask], dp[mask] + cost1[i]); // add 1
            for(int j = i - 1; j >= 0; --j) {
                if ((1 << j) & mask) continue;
                ckmax(dp[(1 << i) | (1 << j) | mask], dp[mask] + cost2[i][j]); // add 2
            }
            break;
        }
    }
    rep(i, sz) {
        int u = ch[i];
        lazy_add[u] += dp[((1 << sz) - 1) ^ (1 << i)];
        if (lazy[u].size() < lazy[v].size()) {
            for(auto &j : lazy[u]) {
                if (used[j]) continue;
                cost[j] += lazy_add[u] - lazy_add[v];
                lazy[v].push_back(j);
            }
            lazy[u].clear();
        } else {
            for(auto &j : lazy[v]) {
                if (used[j]) continue;
                cost[j] += lazy_add[v] - lazy_add[u];
                lazy[u].push_back(j);
            }
            lazy[v].clear();
            swap(lazy[u], lazy[v]);
            swap(lazy_add[u], lazy_add[v]);
        }
    }
    dp1[v] = dp.back();
    for(auto &i : st[v]) {
        lazy[v].push_back(i);
        cost[i] += dp1[v] - lazy_add[v];
    }
}

void solve() {
    int n, m, k;
    cin >> n >> m >> k;
    rep(_, n - 1) {
        int x, y;
        cin >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    dfs_lca(1, 1);
    rep(i, m) {
        cin >> a[i] >> b[i] >> cost[i];
        c[i] = lca(a[i], b[i]);
        if (b[i] == c[i]) swap(a[i], b[i]);
        assert(b[i] != c[i]);
        if (c[i] != a[i]) {
            st[a[i]].push_back(i);
            aU[i] = kth_anc(a[i], h[a[i]] - h[c[i]] - 1);
        }
        st[b[i]].push_back(i);
        bU[i] = kth_anc(b[i], h[b[i]] - h[c[i]] - 1);
        en[c[i]].push_back(i);
    }
    dfs(1, -1);
    cout << dp1[1] << '\n';
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(12) << fixed;
    int t = 1;
    rep(i, t) {
        solve();
    }
    return 0;
}