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

typedef long long lint;
typedef __int128 gint;
typedef long double louble;

#define so(a) ((int)((a).size()))

const char lf = '\n';

template<typename T1, typename T2> inline T1 max(T1 a, T2 b) {
    return a < b ? b : a;
}
template<typename T1, typename T2> inline T1 min(T1 a, T2 b) {
    return a < b ? a : b;
}

namespace ae86 {
const int bufl = 1 << 15;

char buf[bufl], *s = buf, *t = buf;

inline int fetch() {
    if (s == t) {
        t = (s = buf) + fread(buf, 1, bufl, stdin);

        if (s == t)
            return EOF;
    }

    return *s++;
}

inline lint ty() {
    lint a = 0;
    int b = 1, c = fetch();

    while (!isdigit(c))
        b ^= c == '-', c = fetch();

    while (isdigit(c))
        a = a * 10 + c - 48, c = fetch();

    return b ? a : -a;
}
}
using ae86::ty;

const int _ = 63, __ = 10007;
const lint mo = 11920928955078125, lg = 23;

inline lint upd(lint x) {
    return x + ((x >> 63)&mo);
}

template<typename T1, typename T2> inline T1 ad(T1 &a, T2 b) {
    return a = a + b >= mo ? a + b - mo : a + b;
}
template<typename T1, typename T2> inline T1 dl(T1 &a, T2 b) {
    return a = a >= b ? a - b : a - b + mo;
}
template<typename T1, typename T2> inline T1 add(T1 a, T2 b) {
    return a + b >= mo ? a + b - mo : a + b;
}
template<typename T1, typename T2> inline T1 del(T1 a, T2 b) {
    return a >= b ? a - b : a - b + mo;
}
template<typename T1, typename T2> inline T1 sfx(T1 a, T2 b) {
    return ((gint)(a) * b) % mo;
}

lint powa(lint a, lint t) {
    lint b = 1;

    while (t) {
        if (t & 1)
            b = sfx(b, a);

        a = sfx(a, a), t >>= 1;
    }

    return b;
}

void exgcd(lint a, lint b, gint &x, gint &y) {
    if (!b) {
        x = 1, y = 0;
        return;
    }

    exgcd(b, a % b, y, x), y -= x * (a / b);
}

lint inva(lint a) {
    gint x, y;
    exgcd(a, mo, x, y);
    return (x + mo) % mo;
}

namespace thefuck {
lint C[lg][lg] = {0};

struct pony {
    lint f[lg];

    lint &operator [](int x) {
        return f[x];
    }

    pony() {
        memset(f, 0, sizeof(f));
    }
    pony(lint f0) {
        memset(f, 0, sizeof(f)), f[0] = f0;
    }
    pony(lint f0, lint f1) {
        memset(f, 0, sizeof(f)), f[0] = f0, f[1] = f1;
    }

    friend pony operator * (pony a, pony b) {
        pony c;

        for (int i = 0; i < lg; i++)
            for (int j = 0; j + i < lg; j++)
                ad(c[i + j], sfx(a[i], b[j]));

        return c;
    }

    void nerf(lint dx) {
        static lint pw[lg] = {0}, ps[lg];
        memset(ps, 0, sizeof(ps)), pw[0] = 1;

        for (int i = 1; i < lg; i++)
            pw[i] = sfx(pw[i - 1], dx);

        for (int i = 0; i < lg; i++)
            for (int j = 0; j <= i; j++)
                ad(ps[j], sfx(f[i], sfx(pw[i - j], C[i][j])));

        memcpy(f, ps, sizeof(f));
    }
} jc[__];

void fuck() {
    for (int i = 0; i < lg; i++)
        C[i][0] = 1;

    for (int i = 1; i < lg; i++)
        for (int j = 1; j <= i; j++)
            C[i][j] = add(C[i - 1][j], C[i - 1][j - 1]);

    jc[0] = pony(1);

    for (int i = 1; i < __; i++)
        jc[i] = i % 5 ? (jc[i - 1] * pony(i, 1)) : jc[i - 1];
}

pony jcex(lint n) {
    if (n < __)
        return jc[n];

    lint a = (n / 10) * 10;
    pony l = jcex(a / 2), r = l;
    r.nerf(a / 2);
    l = l * r;

    for (lint i = a + 1; i <= n; i++)
        if (i % 5)
            l = l * pony(i, 1);

    return l;
}

pair<lint, lint> jiecheng(lint n) {
    pair<lint, lint> ans = make_pair(jcex(n)[0], n / 5);

    if (n >= 5) {
        pair<lint, lint> temp = jiecheng(n / 5);
        ans.first = sfx(ans.first, temp.first), ad(ans.second, temp.second);
    }

    return ans;
}

int K;

lint fucker(lint n) {
    if (n < 0 || n < K)
        return 0;

    pair<lint, lint> a = jiecheng(n), b = jiecheng(K), c = jiecheng(n - K);
    a.second -= b.second + c.second;
    a.first = sfx(sfx(a.first, powa(5, a.second)), inva(sfx(b.first, c.first)));
    return a.first;
}
}

int n, m;

namespace thetree {
vector<pair<int, int>> e[_];

inline void adde(int a, int b, int c) {
    e[a].emplace_back(b, c);
}
inline void addde(int a, int b, int c) {
    adde(a, b, c), adde(b, a, c);
}

int ban[_] = {0};
lint f[_][__] = {0}, fs[_][__] = {0}, mxf = 0;

int val[_] = {0}, co[_] = {0};
int dfn[_] = {0}, rdfn[_] = {0}, sz[_] = {0}, dcnt = 0;

void dfs(int x, int ff) {
    dfn[x] = ++dcnt, rdfn[dcnt] = x, sz[x] = 1;

    for (auto [b, c] : e[x])
        if (b != ff && !ban[b])
            dfs(b, x), sz[x] += sz[b];
}

pair<lint, lint> finding(int rt, int rt2) { // must choose rt and rt2 (if not 0)
    dcnt = 0, dfs(rt, 0);

    for (int i = 0; i <= m; i++)
        f[dcnt + 1][i] = 0, fs[dcnt + 1][i] = 1;

    for (int i = dcnt; i >= 1; i--)
        for (int j = 0, a = rdfn[i]; j <= m; j++) {
            if (a == rt2 && j < co[a])
                f[i][j] = fs[i][j] = 0;
            else if (a == rt2 || (j >= co[a] && f[i + 1][j - co[a]] + val[a] > f[i + sz[a]][j]))
                f[i][j] = f[i + 1][j - co[a]] + val[a], fs[i][j] = fs[i + 1][j - co[a]];
            else if (j < co[a] || f[i + 1][j - co[a]] + val[a] < f[i + sz[a]][j])
                f[i][j] = f[i + sz[a]][j], fs[i][j] = fs[i + sz[a]][j];
            else
                f[i][j] = f[i + sz[a]][j], fs[i][j] = fs[i + sz[a]][j] + fs[i + 1][j - co[a]];
        }

    return make_pair(f[1][m], fs[1][m]);
}

lint dis[_][_] = {0};
int fa[_] = {0};

void dfs2(int x, int ff, int via, lint xdep) {
    dis[via][x] = xdep, fa[x] = ff;

    for (auto [b, c] : e[x])
        if (b != ff)
            dfs2(b, x, via, xdep + c);
}

lint lim;

lint finder(int rt, int rt2) { // must choose rt and rt2 (if not 0)
    for (int i = 1; i <= n; i++)
        ban[i] = max(dis[rt][i], dis[rt2][i]) * val[i] > lim;

    if (ban[rt] || (rt2 && ban[rt2]))
        return 0;

    auto [temp, tims] = finding(rt, rt2);

    if (temp == mxf)
        return thefuck::fucker(tims);

    return 0;
}
}

int main() {
    ios::sync_with_stdio(0), cout.tie(nullptr);

    n = ty(), m = ty(), thefuck::K = ty(), thetree::lim = ty();

    for (int i = 1; i <= n; i++)
        thetree::co[i] = ty();

    for (int i = 1; i <= n; i++)
        thetree::val[i] = ty();

    for (int i = 1, a, b, c; i < n; i++)
        a = ty(), b = ty(), c = ty(), thetree::addde(a, b, c);

    for (int i = 1; i <= n; i++)
        thetree::mxf = max(thetree::mxf, thetree::finding(i, 0).first);

    if (thetree::mxf <= 0) {
        cout << 0 << lf;
        return 0;
    }

    for (int i = 1; i <= n; i++)
        thetree::dfs2(i, 0, i, 0);

    thefuck::fuck();
    lint ans = 0;

    for (int i = 1; i <= n; i++) {
        ad(ans, thetree::finder(i, 0));

        if (thetree::fa[i])
            dl(ans, thetree::finder(i, thetree::fa[i]));
    }

    cout << ans << lf;

    return 0;
}