#include <bits/stdc++.h>

typedef long long ll;
typedef unsigned long long ull;

using i64 = long long;
using u64 = unsigned long long;
using u128 = __uint128_t;

// Mod = 5^23
const u64 Mod = 11920928955078125;
const int P = 5, K = 23;

namespace Binom {

  struct Mont {
    Mont() : n_(0) {}

    Mont(u64 n) : n_(init(n)) {}

    static u64 init(u64 w) { return reduce(u128(w) * r2); }

    static u64 getInv() {
      assert(Mod & 1);
      inv = Mod;
      for (int i = 0; i < 5; ++i) inv *= 2 - inv * Mod;
      return inv;
    }

    static u64 reduce(u128 x) {
      u64 y = u64(x >> 64) - u64((u128(u64(x) * inv) * Mod) >> 64);
      return i64(y) < 0 ? y + Mod : y;
    }

    Mont &operator+=(Mont rhs) {
      n_ += rhs.n_ - Mod;
      if (i64(n_) < 0) n_ += Mod;
      return *this;
    }

    Mont operator+(Mont rhs) const { return Mont(*this) += rhs; }

    Mont &operator*=(Mont rhs) {
      n_ = reduce(u128(n_) * rhs.n_);
      return *this;
    }

    Mont operator*(Mont rhs) const { return Mont(*this) *= rhs; }

    Mont &operator-=(Mont rhs) {
      n_ -= rhs.n_;
      if (i64(n_) < 0) n_ += Mod;
      return *this;
    }

    Mont operator-(Mont rhs) const { return Mont(*this) -= rhs; }

    Mont operator-() const { return Mont(0) -= *this; }

    u64 get() const { return reduce(n_); }

    static u64 inv, r2;
    u64 n_;
  };

  u64 Mont::inv = Mont::getInv(), Mont::r2 = -u128(Mod) % Mod;

  Mont pow(const Mont &x, u64 k) {
    if (k == 0) return 1;
    Mont ret = pow(x * x, k >> 1);
    if (k & 1) ret *= x;
    return ret;
  }

  Mont inv(const Mont &x) {
    Mont ret = pow(x, P - 2);
    for (int rep = 0; rep != 5; ++rep) ret *= Mont(2) - ret * x;
    return ret;
  }

  const int ORD = 25;

  Mont pts[ORD + 1], nv[4], pw[K];
  ull qk;
  std::pair<Mont, ull> kres;

  Mont peval(ull k) {
    if (k <= ORD) return pts[k];
    int pk = 0;
    Mont a(1), b(1);
    auto mul = [&](ull x, int sgn) {
      while (x % P == 0) { pk += sgn; x /= P; }
      if (sgn == 1) a *= x;
      else b *= x;
    };
    auto ev = [&]() {
      if (pk >= K) return Mont(0);
      return pw[pk] * a;
    };
    Mont ra(0), rb(1);
    for (int i = 1; i <= ORD; ++i) { mul(i, -1); mul(k - i, 1); }
    for (int i = 0; i <= ORD; ++i) {
      Mont ca = ev();
      if ((ORD - i) & 1) ca = -ca;
      ra = (ca * rb * pts[i] + ra * b); rb *= b;
      if (i == ORD) break;
      mul(ORD - i, 1);
      mul(k - i - 1, -1);
      mul(i + 1, -1);
      mul(k - i, 1);
    }
    return ra * inv(rb);
  }

  Mont eval(ull k) { return peval(k) * pow(24, k); }

  std::pair<Mont, ull> fact(ull n) {
    Mont prod(1); ull pk = 0;
    while (n) {
      pk += n / P;
      prod *= eval(n / P);
      for (ull i = n / P * P + 1; i <= n; ++i) prod *= i;
      n /= P;
    }
    return std::make_pair(prod, pk);
  }

  void init(ull k) {
    pw[0] = 1;
    for (int i = 1; i != K; ++i) pw[i] = pw[i - 1] * P;
    for (int i = 1; i <= 4; ++i)
      nv[i - 1] = inv(i);
    pts[0] = 1;
    for (int i = 0; i < ORD; ++i) {
      pts[i + 1] = pts[i];
      for (int j = 0; j != 4; ++j) pts[i + 1] *= Mont(1) + Mont(i * P) * nv[j];
    }

    qk = k;
    kres = fact(k);
  }

  u64 query(ull n) {
    if (n < qk) return 0;
    auto pr = fact(n), qr = fact(n - qk);
    Mont prod = pr.first * inv(qr.first * kres.first);
    ull kk = pr.second - qr.second - kres.second;
    if (kk >= K) return 0;
    return (prod * pw[kk]).get();
  }
}

struct Tropic {
  ll v;
  Tropic(ll v = -1e18) : v(v) {}
  Tropic operator*(const Tropic& rhs) const { return v + rhs.v; }
  Tropic operator+=(const Tropic& rhs) { v = std::max(v, rhs.v); return *this; }
};

struct WTropic {
  ll v; ull c;
  WTropic(ll v = -1e18, ull c = 1) : v(v), c(c) {}
  WTropic operator*(const WTropic& rhs) const { return WTropic(v + rhs.v, c * rhs.c); }
  WTropic operator+=(const WTropic& rhs) {
    if (v < rhs.v) return (*this = rhs);
    if (v == rhs.v) c += rhs.c;
    return *this;
  }
};

const int N = 62;

int n, m, k; ull maxd;
int w[N], v[N];
std::vector<std::pair<int, int> > g[N];

std::valarray<Tropic> dfs1(int i, int p, std::valarray<Tropic> dp) {
  dp = dp.shift(-w[i]) * Tropic(v[i]);
  for (const auto& [b, c] : g[i]) if (b != p)
    dp += dfs1(b, i, dp);
  return dp;
}

std::valarray<WTropic> dfs2(int i, int p, int dist, std::valarray<WTropic> dp) {
  if (v[i] * (ull)dist > maxd) return std::valarray<WTropic>(m + 1);
  dp = dp.shift(-w[i]) * WTropic(v[i]);
  for (const auto& [b, c] : g[i]) if (b != p)
    dp += dfs2(b, i, c + dist, dp);
  return dp;
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr); std::cout.tie(nullptr);

  std::cin >> n >> m >> k >> maxd;
  for (int i = 1; i <= n; ++i) std::cin >> w[i];
  for (int i = 1; i <= n; ++i) std::cin >> v[i];
  for (int rep = 1; rep != n; ++rep) {
    int a, b, c; std::cin >> a >> b >> c;
    g[a].emplace_back(b, c);
    g[b].emplace_back(a, c);
  }
  ll max = -1e18;
  for (int i = 1; i <= n; ++i) max = std::max(max, dfs1(i, -1, std::valarray<Tropic>(Tropic(0), m + 1))[m].v);

  Binom::init(k);
  u64 ans = 0;

  for (int i = 1; i <= n; ++i) {
    WTropic val = dfs2(i, -1, 0, std::valarray<WTropic>(WTropic(0), m + 1))[m];
    if (val.v == max)
      if ((ans += Binom::query(val.c)) >= Mod) ans -= Mod;
  }
  for (int i = 1; i <= n; ++i) for (const auto& [b, c] : g[i]) if (i < b) {
    std::valarray<WTropic> cur(WTropic(0), m + 1);
    cur = dfs2(i, b, c, cur);
    cur = dfs2(b, i, c, cur);
    WTropic val = cur[m];
    if (val.v == max)
      if (i64(ans -= Binom::query(val.c)) < 0) ans += Mod;
  }

  std::cout << ans << '\n';

  return 0;
}