#include <bits/stdc++.h>
#define re register
#define ull unsigned long long
#define mk(a,b) std::make_pair(a,b)
const ull p = 5, q = 23, mod = 11920928955078125;
namespace fm {
ull fmod, xx[110], C[110][110];
ull mul(re ull a, re ull b) {
    return (a * b - (ull)((long double)a * b / mod) * mod + mod) % mod;
}
struct poly {
    std::vector<ull>a;
    ull n;
    poly operator * (const poly &A) {
        poly c;
        c.n = n + A.n;

        for (re int i = 0; i <= c.n; i++)
            c.a.push_back(0);

        for (re int i = 0; i <= n; i++)
            for (re int j = 0; j <= A.n; j++)
                c.a[i + j] = (c.a[i + j] + mul(a[i], A.a[j])) % mod;

        while (c.n >= q)
            c.n--, c.a.pop_back();

        return c;
    }
    poly mov(re ull x) {
        poly c;
        c.n = n;
        xx[0] = 1;

        for (re int i = 0; i <= c.n; i++)
            c.a.push_back(0);

        for (re int i = 1; i <= n; i++)
            xx[i] = mul(x, xx[i - 1]);

        for (re int i = 0; i <= n; i++)
            for (re int j = 0; j <= i; j++)
                c.a[j] = (c.a[j] + mul(a[i], mul(xx[i - j], C[i][j]))) % mod;

        return c;
    }
    ull qry(re ull x) {
        re ull ans = 0;

        for (re int i = n; i >= 0; i--)
            ans = (mul(ans, x) + a[i]) % mod;

        return ans;
    }
} pl[110];
ull ex(re ull a, re ull b) {
    re ull ans = 1;

    for (; b; b >>= 1, a = mul(a, a))
        if (b & 1)
            ans = mul(ans, a);

    return ans;
}
ull facc(re ull a) {
    re ull ans = ex(fmod, a / mod), nw = 0, pw = mod / p;
    a %= mod;

    for (re int i = q - 1; i; i--, pw /= p)
        while (nw + pw <= a)
            ans = mul(ans, pl[i].qry(nw)), nw += pw;

    for (nw++; nw <= a; nw++)
        if (nw % p)
            ans = mul(ans, nw);

    return ans;
}
ull inv(re ull a) {
    re ull b = p - 1;

    for (re ull i = 1; i < q; i++)
        b *= p;

    b--;
    return ex(a, b);
}
ull fac(re ull a) {
    if (a == 0)
        return 1;

    return mul(facc(a), fac(a / p));
}
ull pr(re ull n) {
    re ull ans = 0;

    for (n /= p; n; n /= p)
        ans += n;

    return ans;
}
ull c(re ull n, re ull k) {
    if (n < k)
        return 0;

    re ull ans = mul(fac(n), inv(mul(fac(k), fac(n - k)))), pp = pr(n) - pr(k) - pr(n - k);

    if (pp >= q)
        return 0;

    for (re ull i = 1; i <= pp; i++)
        ans = mul(ans, p);

    return ans;
}
void init() {
    C[0][0] = 1;

    for (re int i = 1; i <= q; i++) {
        C[i][0] = 1;

        for (re int j = 1; j <= i; j++)
            C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
    }

    pl[1].a.push_back(1);
    pl[0].n = 1;
    pl[0].a.resize(2);
    pl[0].a[1] = 1;

    for (re ull j = 1; j < p; j++) {
        pl[0].a[0] = j, pl[1] = pl[1] * pl[0];
    }

    re ull pa = p;

    for (re ull i = 2; i <= q; i++) {
        pl[i].a.push_back(1);

        for (re ull j = 0; j < p; j++)
            pl[i] = pl[i] * pl[i - 1].mov(j * pa);

        pa *= p;
    }

    fmod = pl[q].qry(0);
}
}
ull mx, bs, ans, g[111][10011][3];
long long f[111][10011];
int n, m, k, w[110], v[110], dfn[110], dfr[110], ed[110], sz[110], sza, xx, tot;
bool vis[110];
std::vector<std::pair<int, int>>to[110];
int dis[110], dis1[110], fa[110], ddfn[110], edd[110];
void dfs1(re int a, re int fa) {
    dfn[a] = ++tot;
    dfr[tot] = a;
    vis[a] = 0;

    for (auto x : to[a])
        if (!vis[x.first] && x.first != fa) {
            dfs1(x.first, a);
        }

    ed[a] = tot;
}
void dsf(re int a) {
    ddfn[a] = ++tot;

    for (auto x : to[a])
        if (x.first != fa[a])
            fa[x.first] = a, dsf(x.first);

    edd[a] = tot;
}
void dss(re int *dis, re int a, re int fa) {
    for (auto x : to[a])
        if (x.first != fa)
            dis[x.first] = dis[a] + x.second, dss(dis, x.first, a);
}
int main() {
    fm::init();
    re int x, y, z;
    scanf("%d%d%d%llu", &n, &m, &k, &mx);

    for (re int i = 1; i <= n; i++)
        scanf("%d", &w[i]);

    for (re int i = 1; i <= n; i++)
        scanf("%d", &v[i]);

    for (re int i = 1; i < n; i++) {
        scanf("%d%d%d", &x, &y, &z);
        to[x].push_back(mk(y, z));
        to[y].push_back(mk(x, z));
    }

    dsf(1);

    for (re int i = 1; i <= n; i++) {
        tot = 0;
        dfs1(i, 0);

        for (re int i = 2; i <= tot + 1; i++)
            memset(f[i], 128, sizeof(f[i]));

        for (re int i = 1; i <= tot; i++) {
            for (re int j = 0; j <= m; j++) {
                if (f[ed[dfr[i]] + 1][j] < f[i][j]) {
                    f[ed[dfr[i]] + 1][j] = f[i][j];
                }

                if (j + w[dfr[i]] <= m && f[i + 1][j + w[dfr[i]]] < f[i][j] + v[dfr[i]]) {
                    f[i + 1][j + w[dfr[i]]] = f[i][j] + v[dfr[i]];
                }
            }
        }

        if (f[tot + 1][m] > bs)
            bs = f[tot + 1][m];
    }

    for (re int i = 0; i <= m; i++)
        g[1][i][0] = 1;

    for (re int ii = 1; ii <= n; ii++) {
        re ull nnm = 0, nnm1 = 0, ppa = 0;
        dis[ii] = 0;
        dss(dis, ii, 0);
        dis1[fa[ii]] = 0;

        if (ii != 1)
            dss(dis1, fa[ii], 0);

        for (re int j = 1; j <= n; j++)
            vis[j] = (1llu * dis[j] * v[j] > mx);

        tot = 0;
        dfs1(ii, 0);

        for (re int i = 2; i <= tot + 1; i++)
            memset(f[i], 128, sizeof(f[i])), memset(g[i], 0, sizeof(g[i]));

        for (re int i = 1; i <= tot; i++) {
            for (re int j = 0; j <= m; j++) {
#define kc(a) (ii==1||1llu*dis1[a]*v[a]>mx)
#define fc(a) (a==fa[ii])

                //if(fc(dfr[i])){printf("*-*%d %d\n",ii,dfr[i]);}
                if (f[ed[dfr[i]] + 1][j] == f[i][j]) {
                    g[ed[dfr[i]] + 1][j][2] += g[i][j][2];
                    g[ed[dfr[i]] + 1][j][1] += g[i][j][1];
                    g[ed[dfr[i]] + 1][j][0] += g[i][j][0];
                } else if (f[ed[dfr[i]] + 1][j] < f[i][j]) {
                    f[ed[dfr[i]] + 1][j] = f[i][j];
                    g[ed[dfr[i]] + 1][j][2] = g[i][j][2];
                    g[ed[dfr[i]] + 1][j][1] = g[i][j][1];
                    g[ed[dfr[i]] + 1][j][0] = g[i][j][0];
                }

                if (j + w[dfr[i]] <= m) {
                    if (f[i + 1][j + w[dfr[i]]] == f[i][j] + v[dfr[i]]) {
                        g[i + 1][j + w[dfr[i]]][kc(dfr[i]) ? 2 : (fc(dfr[i]) ? 1 : 0)] += g[i][j][0];
                        g[i + 1][j + w[dfr[i]]][kc(dfr[i]) ? 2 : 1] += g[i][j][1];
                        g[i + 1][j + w[dfr[i]]][2] += g[i][j][2];
                    } else if (f[i + 1][j + w[dfr[i]]] < f[i][j] + v[dfr[i]]) {
                        f[i + 1][j + w[dfr[i]]] = f[i][j] + v[dfr[i]];
                        g[i + 1][j + w[dfr[i]]][0] = 0;
                        g[i + 1][j + w[dfr[i]]][1] = 0;
                        g[i + 1][j + w[dfr[i]]][2] = 0;
                        g[i + 1][j + w[dfr[i]]][kc(dfr[i]) ? 2 : (fc(dfr[i]) ? 1 : 0)] += g[i][j][0];
                        g[i + 1][j + w[dfr[i]]][kc(dfr[i]) ? 2 : 1] += g[i][j][1];
                        g[i + 1][j + w[dfr[i]]][2] += g[i][j][2];
                    }
                }
            }
        }

        if (f[tot + 1][m] == bs)
            nnm1 = g[tot + 1][m][1];

        if (f[tot + 1][m] == bs)
            nnm = (g[tot + 1][m][0] + g[tot + 1][m][2]) % mod;

        //printf("****%d %llu %llu %llu\n",ii,nnm,nnm1,bs);
        ans = (ans + fm::c(nnm + nnm1, k) - fm::c(nnm1, k) + mod) % mod;
    }

    printf("%llu\n", ans);
}