#include <bits/stdc++.h>
#define int long long
using namespace std;
int read() {
    int x = 0, f = 1;
    char c = getchar();

    while (c > '9' || c < '0') {
        if (c == '-')
            f = -1;

        c = getchar();
    }

    while (c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = getchar();
    }

    return x * f;
}
const int N = 65, M = 10005, P = 11920928955078125;
int A[N], B[N], n, m, k, w[N], v[N];
int e[N][N], vis[N], X1, X2, idfn[N], sze[N], lead;
int ans, dp[N][M], f[N][M], MMX, MAX;
int mul(int x, int y) {
    int temp = (x * y - (int)((long double)x / P * y + 0.5) * P);
    return temp > 0 ? temp : temp + P;
}
void predfs(int u, int fa, int dis) {
    if (1ll * v[u]*dis > MAX)
        vis[u] = -1;

    idfn[++lead] = u;
    sze[u] = 1;

    for (int v = 1; v <= n; ++v)
        if (e[u][v] && v != fa) {
            predfs(v, u, dis + e[u][v]);
            sze[u] += sze[v];
        }
}
int qpow(int a, int b) {
    int res = 1;

    while (b) {
        if (b & 1)
            res = mul(res, a);

        a = mul(a, a);
        b >>= 1;
    }

    return res;
}
void exgcd(int a, int b, int &x, int &y) {
    if (!b)
        x = 1, y = 0;
    else
        exgcd(b, a % b, y, x), y -= mul(a / b, x);
}
int inv(int a) {
    int x, y;
    exgcd(a, P, x, y);
    return (x % P + P) % P;
}
int get(int n) {
    int res = 0;

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

    return res;
}
struct Poly {
    int a[25];
    Poly() {
        memset(a, 0, sizeof(a));
    }
    Poly operator * (const Poly &q)const {
        Poly res;

        for (int i = 0; i < 23; ++i)
            for (int j = 0; i + j < 23; ++j)
                (res.a[i + j] += mul(a[i], q.a[j])) %= P;

        return res;
    }
    Poly operator * (const int &q)const {
        Poly res;

        for (int i = 0; i < 23; ++i)
            res.a[i] = mul(a[i], q);

        return res;
    }
    Poly operator + (const Poly &q)const {
        Poly res;

        for (int i = 0; i < 23; ++i)
            res.a[i] = (a[i] + q.a[i]) % P;

        return res;
    }
    Poly mull(int k, int b) {
        Poly res;

        for (int i = 0; i < 23; ++i)
            (res.a[i] += mul(a[i], b)) %= P, (res.a[i + 1] += mul(a[i], k)) %= P;

        return res;
    }
} Py[100005], nw;
void init() {
    Py[0].a[0] = 1;

    for (int i = 1; i <= 100000; ++i) {
        Py[i] = Py[i - 1];

        if (i % 5)
            Py[i] = Py[i].mull(1, i);
    }
}
void go(int n) {
    if (n <= 100000)
        nw = Py[n];
    else {
        int d = n % 10;
        n -= d;
        go(n / 2);
        Poly fk, F;
        fk.a[0] = 1;

        for (int i = 0; i < 23; ++i) {
            F = F + fk * nw.a[i];
            fk = fk.mull(1, n / 2);
        }

        nw = nw * F;

        for (int i = n + 1; i <= n + d; ++i)
            if (i % 5)
                nw = nw.mull(1, i);
    }
}
int calc(int n) {
    go(n);
    return nw.a[0];
}
int fac(int n) {
    if (!n)
        return 1;

    return mul(calc(n), fac(n / 5));
}
int C(int n, int m) {
    if (n < m)
        return 0;

    return mul(mul(mul(fac(n), inv(fac(m))), inv(fac(n - m))), qpow(5, get(n) - get(m) - get(n - m)));
}
void Max(int &x, int y) {
    x = x > y ? x : y;
}
main() {
    init();
    //  while(1) {
    //      int x=read(),res=1;
    //      for(int i=1;i<=x;++i)
    //          res=mul(res,i);
    //      printf("%lld %lld\n",mul(calc(x,0),qpow(5,get(x))),res);
    //  }
    n = read();
    m = read();
    k = read();
    MAX = read();

    for (int i = 1; i <= n; ++i)
        w[i] = read();

    for (int i = 1; i <= n; ++i)
        v[i] = read();

    for (int i = 1; i < n; ++i) {
        A[i] = read();
        B[i] = read();
        e[A[i]][B[i]] = e[B[i]][A[i]] = read();
    }

    for (X1 = 1; X1 <= n; ++X1) {
        memset(dp, -0x3f, sizeof(dp));
        lead = 0;
        predfs(X1, 0, 0);
        memset(vis, 0, sizeof(vis));
        vis[X1] = 1;
        dp[1][0] = 0;

        for (int j = 1; j <= n; ++j) {
            int u = idfn[j];

            if (vis[u] != 1) {
                for (int a = 0; a <= m; ++a)
                    Max(dp[j + sze[u]][a], dp[j][a]);
            }

            if (vis[u] != -1) {
                for (int a = 0; a <= m - w[u]; ++a)
                    Max(dp[j + 1][a + w[u]], dp[j][a] + v[u]);
            }
        }

        for (int a = m; a >= 0; --a)
            Max(MMX, dp[n + 1][a]);
    }

    for (X1 = 1; X1 <= n; ++X1) {
        memset(vis, 0, sizeof(vis));
        memset(dp, -0x3f, sizeof(dp));
        memset(f, 0, sizeof(f));
        vis[X1] = 1;
        lead = 0;
        predfs(X1, 0, 0);
        dp[1][0] = 0;

        for (int j = 1; j <= n; ++j) {
            int u = idfn[j];

            if (vis[u] != 1) {
                for (int a = 0; a <= m; ++a)
                    Max(dp[j + sze[u]][a], dp[j][a]);
            }

            if (vis[u] != -1) {
                for (int a = 0; a <= m - w[u]; ++a)
                    Max(dp[j + 1][a + w[u]], dp[j][a] + v[u]);
            }
        }

        f[1][0] = 1;

        for (int j = 1; j <= n; ++j) {
            int u = idfn[j];

            if (vis[u] != 1) {
                for (int a = 0; a <= m; ++a)
                    if (dp[j + sze[u]][a] == dp[j][a])
                        f[j + sze[u]][a] += f[j][a];
            }

            if (vis[u] != -1) {
                for (int a = 0; a <= m - w[u]; ++a)
                    if (dp[j + 1][a + w[u]] == dp[j][a] + v[u])
                        f[j + 1][a + w[u]] += f[j][a];
            }
        }

        int res = 0;

        for (int a = m; a >= 0; --a)
            if (dp[n + 1][a] == MMX)
                res += f[n + 1][a];

        (ans += C(res, k)) %= P;
    }

    for (int i = 1; i < n; ++i) {
        X1 = A[i];
        X2 = B[i];
        memset(vis, 0, sizeof(vis));
        memset(dp, -0x3f, sizeof(dp));
        memset(f, 0, sizeof(f));

        if (e[X1][X2]*max(v[X1], v[X2]) > MAX)
            continue;

        vis[X1] = vis[X2] = 1;
        lead = 0;
        predfs(X1, X2, e[X1][X2]);
        predfs(X2, X1, e[X1][X2]);
        sze[X1] += sze[X2];
        dp[1][0] = 0;

        for (int j = 1; j <= n; ++j) {
            int u = idfn[j];

            if (vis[u] != 1) {
                for (int a = 0; a <= m; ++a)
                    Max(dp[j + sze[u]][a], dp[j][a]);
            }

            if (vis[u] != -1) {
                for (int a = 0; a <= m - w[u]; ++a)
                    Max(dp[j + 1][a + w[u]], dp[j][a] + v[u]);
            }
        }

        f[1][0] = 1;

        for (int j = 1; j <= n; ++j) {
            int u = idfn[j];

            if (vis[u] != 1) {
                for (int a = 0; a <= m; ++a)
                    if (dp[j + sze[u]][a] == dp[j][a])
                        f[j + sze[u]][a] += f[j][a];
            }

            if (vis[u] != -1) {
                for (int a = 0; a <= m - w[u]; ++a)
                    if (dp[j + 1][a + w[u]] == dp[j][a] + v[u])
                        f[j + 1][a + w[u]] += f[j][a];
            }
        }

        int res = 0;

        for (int a = m; a >= 0; --a)
            if (dp[n + 1][a] == MMX)
                res += f[n + 1][a];

        (ans -= C(res, k)) %= P;
    }

    printf("%lld", (ans + P) % P);
    return 0;
}