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

typedef long long ll;
typedef __int128 LL;

const ll Mod = 11920928955078125ll;

#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define sc second

pll merge(pll a, pll b) {
    return (a.fi == b.fi) ? (pll(a.fi, a.sc + b.sc)) : (a.fi > b.fi ? a : b);
}
void Merge(pll &a, pll b) {
    a = merge(a, b);
}

void exgcd(ll a, ll b, ll &x, ll &y) {
    if (!b) {
        x = 1, y = 0;
    } else {
        exgcd(b, a % b, y, x);
        y -= (a / b) * x;
    }
}
ll inv(ll a) {
    ll x, y;
    exgcd(a, Mod, x, y);
    return (x < 0) ? (x + Mod) : x;
}

int n, m, K;
ll M;
int w[63], v[63];
vector<pii> G[63];

namespace subtask1 {

const int S = 23;
const int D = 1000;

typedef vector<ll> vec;

ll facK = -1;

vec F[D];
ll fac[D];
ll comb[S][S], pw[S];

vec poly_mov(vec f, ll t) {
    int n = f.size();
    pw[0] = 1;

    for (int i = 1; i < n; i++) {
        pw[i] = ((LL) pw[i - 1]) * t % Mod;
    }

    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            f[j] = (f[j] + ((LL) f[i]) * comb[i][j] % Mod * pw[i - j]) % Mod;
        }
    }

    return f;
}
vec operator * (vec a, vec b) {
    int k = min((signed)(a.size() + b.size()), S);
    vec rt(k, 0);

    for (int i = 0; i < (signed) a.size(); i++) {
        for (int j = 0; i + j < k && j < (signed) b.size(); j++) {
            rt[i + j] = (rt[i + j] + ((LL) a[i]) * b[j]) % Mod;
        }
    }

    return rt;
}

void prepare() {
    comb[0][0] = 1;

    for (int i = 1; i <= S; i++) {
        comb[i][0] = comb[i][i] = 1;

        for (int j = 1; j < i; j++) {
            comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
        }
    }

    F[0] = vec{1};

    for (int i = 1; i < D; i++) {
        F[i] = (i % 5) ? F[i - 1] * vec{i, 1} :
               F[i - 1];
    }

    fac[0] = 1;

    for (int i = 1; i < D; i++) {
        fac[i] = (i % 5) ? (((LL) fac[i - 1]) * i % Mod) : fac[i - 1];
    }
}

vec calc(ll n) {
    if (n < D) {
        return F[n];
    }

    ll k = n / 10 * 10;
    vec g = calc(k >> 1);
    g = g * poly_mov(g, k >> 1);

    for (ll i = k + 1; i <= n; i++) {
        if (i % 5) {
            g = g * vec{i, 1};
        }
    }

    return g;
}
ll factor(ll n) {
    if (n == K && facK != -1) {
        return facK;
    }

    ll ret = 1;

    while (n >= D) {
        ret = ((LL) ret) * calc(n)[0] % Mod;
        n /= 5;
    }

    while (n) {
        ret = ((LL) ret) * fac[n] % Mod;
        n /= 5;
    }

    if (n == K) {
        facK = ret;
    }

    return ret;
}

ll count5(ll n) {
    ll rt = 0;

    while (n) {
        rt += (n /= 5);
    }

    return rt;
}

ll solve(ll n, ll m) {
    if (n < m) {
        return 0;
    }

    ll foo = ((LL) factor(n - m)) * factor(m) % Mod;
    ll bar = factor(n);
    ll dif = count5(n) - count5(n - m) - count5(m);

    if (dif >= S) {
        return 0;
    }

    ll ret = ((LL) inv(foo)) * bar % Mod;

    while (dif--) {
        ret = ((LL) ret) * 5 % Mod;
    }

    assert(0 <= ret && ret < Mod);
    return ret;
}

}

bool limited = false;

namespace subtask2 {

int dfc;
int in[63], out[63], tour[63];

ll d[63];
pll f[63][10003];

void dfs(int p, int fa, ll dis) {
    d[p] = dis;

    if (limited && d[p] && M / d[p] < v[p]) {
        return;
    }

    in[p] = ++dfc;
    tour[dfc] = p;

    for (auto _ : G[p]) {
        int e = _.fi;

        if (e ^ fa) {
            dfs(e, p, dis + _.sc);
        }
    }

    out[p] = dfc;
}

pll solve(int p, int fa, ll dis) {
    dfc = 0;
    dfs(p, fa, dis);

    for (int i = 1; i <= dfc + 1; i++) {
        for (int j = 0; j <= m; j++) {
            f[i][j] = pll(-Mod, 0);
        }
    }

    f[dfc + 1][0] = pll(0, 1);

    for (int i = dfc; i; i--) {
        int p = tour[i];

        for (int j = 0; j <= m; j++) {
            f[i][j] = f[out[p] + 1][j];
        }

        for (int j = 0; j + w[p] <= m; j++) {
            pll t = f[i + 1][j];

            if (t.sc) {
                t.fi += v[p];
                Merge(f[i][j + w[p]], t);
            }
        }

    }

    pll ret(-Mod, 0);

    for (int i = 1; i <= m; i++) {
        Merge(ret, f[1][i]);
    }

    return ret;
}

}

void inc(ll &x) {
    if (x >= Mod) {
        x -= Mod;
    }
}
void dec(ll &x) {
    if (x < 0) {
        x += Mod;
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n >> m >> K >> M;

    for (int i = 1; i <= n; i++) {
        cin >> w[i];
    }

    for (int i = 1; i <= n; i++) {
        cin >> v[i];
    }

    vector<pair<pii, int>> E;

    for (int i = 1, u, v, w; i < n; i++) {
        cin >> u >> v >> w;
        E.emplace_back(pii(u, v), w);
        G[u].emplace_back(v, w);
        G[v].emplace_back(u, w);
    }

    ll mx = 0;

    for (int i = 1; i <= n; i++) {
        mx = max(mx, subtask2::solve(i, 0, 0).fi);
    }

    if (!mx) {
        cout << 0 << '\n';
        return 0;
    }

    ll ans = 0;
    subtask1::prepare();
    limited = true;

    for (int i = 1; i <= n; i++) {
        auto tmp = subtask2::solve(i, 0, 0);

        if (tmp.fi == mx) {
            inc(ans += subtask1::solve(tmp.sc, K));
        }
    }

    static pll F[10005];
    auto s2f = subtask2::f;

    for (auto e : E) {
        int u = e.fi.fi, v = e.fi.sc, w = e.sc;
        subtask2::solve(u, v, w);
        copy(s2f[1], subtask2::f[1] + m + 1, F);
        F[0] = pll(0, 0);

        for (int i = 1; i <= m; i++) {
            F[i] = merge(F[i], F[i - 1]);
        }

        subtask2::solve(v, u, w);
        auto G = s2f[1];
        pll tmp(-1, 0);

        for (int i = 1; i < m; i++) {
            if (F[m - i].sc && G[i].sc) {
                Merge(tmp, pll(F[m - i].fi + G[i].fi, F[m - i].sc * G[i].sc));
            }
        }

        if (tmp.fi == mx) {
            dec(ans -= subtask1::solve(tmp.sc, K));
        }
    }

    cout << ans << '\n';
    return 0;
}