#include <bits/stdc++.h>
#ifdef CKISEKI
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
using std::cerr;
template <typename ...T>
void debug_(const char *s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I>
void orange_(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif

#define all(v) begin(v),end(v)

using namespace std;

const int mod = 1000000007;
int modadd(int a, int b) {
    return a + b >= mod ? a + b - mod : a + b;
}
int modsub(int a, int b) {
    return a - b < 0 ? a - b + mod : a - b;
}
int modmul(int64_t a, int64_t b) {
    return static_cast<int>(a * b % mod);
}

int Rank(vector<int64_t> &d, int64_t x) {
    return upper_bound(d.begin(), d.end(), x) - d.begin();
}

struct Centroid {
    using G = vector<vector<pair<int,int>>>;
    vector<vector<int64_t>> Dist;
    vector<int> Pa, Dep;

    vector<vector<int64_t>> Sub, Sub2;
    vector<int> Cnt, Cnt2;

    vector<int> vis, sz, mx, tmp;
    void DfsSz(const G &g, int x) {
        vis[x] = true, sz[x] = 1, mx[x] = 0;
        for (auto [u, w]: g[x]) if (not vis[u]) {
            DfsSz(g, u); sz[x] += sz[u];
            mx[x] = max(mx[x], sz[u]);
        }
        tmp.push_back(x);
    }
    void DfsDist(const G &g, int x, int64_t D = 0) {
        Dist[x].push_back(D); vis[x] = true;
        for (auto [u, w]: g[x]) 
            if (not vis[u]) DfsDist(g, u, D + w);
    }
    void DfsCen(const G &g, int x, int D = 0, int p = -1) {
        tmp.clear(); DfsSz(g, x);
        int M = tmp.size(), C = -1;
        for (int u: tmp) {
            if (max(M - sz[u], mx[u]) * 2 <= M) C = u;
            vis[u] = false;
        }
        DfsDist(g, C);
        for (int u: tmp) vis[u] = false;
        Pa[C] = p, vis[C] = true, Dep[C] = D;
        for (auto [u, w]: g[C])
            if (not vis[u]) DfsCen(g, u, D + 1, C);
    }

    Centroid(int N, const G &g) : Sub(N), Sub2(N), Dist(N), Pa(N), Dep(N), vis(N), sz(N), mx(N) {
        DfsCen(g, 0);
        for (int i = 0; i < N; i++) {
            Mark(i);
        }

        for (int i = 0; i < N; i++) {
            sort(Sub[i].begin(), Sub[i].end());
            sort(Sub2[i].begin(), Sub2[i].end());
        }
    }
    void Mark(int v) {
        int x = v, z = -1;
        for (int i = Dep[v]; i >= 0; --i) {
            Sub[x].push_back(Dist[v][i]);
            // Sub[x] += Dist[v][i], Cnt[x]++;
            if (z != -1) {
                Sub2[z].push_back(Dist[v][i]);
                // Sub2[z] += Dist[v][i], Cnt2[z]++;
            }
            x = Pa[z = x];
        }
    }

    int64_t Query(int v, int64_t L) {
        int64_t res = 0;
        int x = v, z = -1;
        for (int i = Dep[v]; i >= 0; --i) {
            // res += Sub[x] + 1LL * Cnt[x] * Dist[v][i];
            res += Rank(Sub[x], L - Dist[v][i]);
            if (z != -1) {
                res -= Rank(Sub2[z], L - Dist[v][i]);
                // res -= Sub2[z] + 1LL * Cnt2[z] * Dist[v][i];
            }
            x = Pa[z = x];
        }
        return res;
    }
};

const int maxn = 100025;
int inv[maxn], fac[maxn], ifac[maxn];

int C(int n, int k) {
    if (k < 0 || n < k) return 0;
    return modmul(fac[n], modmul(ifac[k], ifac[n-k]));
}

struct Fenwick {
    vector<int> b;
    Fenwick(int n) : b(n + 1) {}
    void add(int p, int v) {
        for (++p; p < (int)b.size(); p += p & -p)
            b[p] += v;
    }
    int query(int p) {
        int r = 0;
        for (++p; p > 0; p -= p & -p)
            r += b[p];
        return r;
    }
};

int main() {
    inv[1] = 1;
    fac[0] = ifac[0] = 1;
    for (int i = 2; i < maxn; i++) {
        inv[i] = modmul(inv[mod % i], mod - mod / i);
    }
    for (int i = 1; i < maxn; i++) {
        fac[i] = modmul(fac[i - 1], i);
        ifac[i] = modmul(ifac[i - 1], inv[i]);
    }

    cin.tie(nullptr) -> sync_with_stdio(false);
    int N, K, L;
    cin >> N >> K >> L;

    vector<vector<pair<int,int>>> g(N);
    for (int i = 1; i < N; i++) {
        int A, B, C;
        cin >> A >> B >> C;
        --A, --B;
        g[A].emplace_back(B, C);
        g[B].emplace_back(A, C);
    }

    Centroid cent(N, g);

    int ans = 0;

    int st = 0;
    vector<int> tin(N), tout(N);

    vector<int> radius_cnt_1(N), radius_cnt_2(N);
    // radius_cnt_1[i] = #{ j, dis(i, j) <= L }
    // radius_cnt_2[i] = #{ j, dis(i, j) <= L - w }
    //     will become   #{ j, dis(i, j) <= L-w && dis(pa[i], j) <= L-w }
    vector<int> pa(N), pa_w(N);
    vector<int64_t> dep(N);

    const auto dfs = [&](auto self, int i, int f) -> void {
        tin[i] = st++;
        radius_cnt_1[i] = cent.Query(i, L);
        for (auto [j, w]: g[i]) {
            if (j == f) continue;
            radius_cnt_2[j] = cent.Query(i, L - w);
            pa[j] = i;
            pa_w[j] = w;
            dep[j] = dep[i] + w;
            self(self, j, i);
        }
        tout[i] = st;
    };
    dfs(dfs, 0, -1);

    auto u = dep;
    
    vector<tuple<int,int,int,int64_t>> evt;
    for (int i = 1; i < N; i++) {
        int w = pa_w[i];
        int l = tin[i];
        int r = tout[i];
        evt.emplace_back(l, i, 1, dep[i] + L - w - w);
        evt.emplace_back(r, i, -1, dep[i] + L - w - w);
        evt.emplace_back(l, i, -1, dep[i] + L - w);
        evt.emplace_back(r, i, 1, dep[i] + L - w);

        u.emplace_back(dep[i] + L - w - w);
        u.emplace_back(dep[i] + L - w);
    }

    for (int i = 1; i < N; i++) {
        evt.emplace_back(tin[i], i + N, 0, dep[i]);
    }

    sort(evt.begin(), evt.end());

    sort(u.begin(), u.end());

    Fenwick BIT(static_cast<int>(u.size()));

    for (int i = 0, j; i < (int)evt.size(); i = j) {
        for (j = i; j < (int)evt.size(); j++) {
            if (get<0>(evt[j]) != get<0>(evt[i]))
                break;
            auto [_, id, coef, d] = evt[j];
            d = lower_bound(u.begin(), u.end(), d) - u.begin();
            if (id >= N) {
                id -= N;
                BIT.add(d, 1);
            } else {
                radius_cnt_2[id] += coef * BIT.query(d);
            }
        }
    }


    for (int i = 0; i < N; i++) {
        ans = modadd(ans, C(radius_cnt_1[i], K));
    }
    for (int i = 1; i < N; i++) {
        ans = modsub(ans, C(radius_cnt_2[i], K));
    }

    orange(all(radius_cnt_1));
    orange(all(radius_cnt_2));

    cout << modmul(ans, fac[K]) << '\n';

    return 0;
}