#include <bits/stdc++.h>
using namespace std;
const int MAX_T = 20005, MAX_N = 55, MAX_M = 105;
const double pi = acos(-1);
template <class T>
inline void Read(T &x) {
  x = 0;
  int t = 1;
  char c = getchar();
  while (c < '0' || c > '9') {
    if (c == '-') t = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    x = x * 10 + c - '0';
    c = getchar();
  }
  x *= t;
}
class Complex {
 public:
  double r, i;
  inline Complex(const double &_r = 0, const double &_i = 0) { r = _r, i = _i; }
  inline friend Complex operator+(const Complex &a, const Complex &b) {
    return Complex(a.r + b.r, a.i + b.i);
  }
  inline friend Complex operator-(const Complex &a, const Complex &b) {
    return Complex(a.r - b.r, a.i - b.i);
  }
  inline friend Complex operator*(const Complex &a, const Complex &b) {
    return Complex(a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r);
  }
} A[1 << 16], B[1 << 16], W[2][17][1 << 17];
inline void Rader(Complex *y, int len) {
  for (int i = 1, j = len >> 1; i < len - 1; ++i) {
    if (i < j) swap(y[i], y[j]);
    int k = len >> 1;
    while (j >= k) {
      j -= k;
      k >>= 1;
    }
    if (j < k) j += k;
  }
}
inline void init() {
  for (int i = 2, bit = 1; bit <= 16; bit++, i <<= 1) {
    Complex wn = Complex(cos(2 * pi / i), sin(2 * pi / i));
    W[1][bit][0] = Complex(1, 0);
    for (int j = 1; j < i; ++j) W[1][bit][j] = W[1][bit][j - 1] * wn;
    wn = Complex(cos(-2 * pi / i), sin(-2 * pi / i));
    W[0][bit][0] = Complex(1, 0);
    for (int j = 1; j < i; ++j) W[0][bit][j] = W[0][bit][j - 1] * wn;
  }
}
inline void FFT(Complex *y, int len, int op) {
  Rader(y, len);
  for (int h = 2, bit = 1; h <= len; h <<= 1, bit++) {
    for (int j = 0; j < len; j += h) {
      for (int k = j; k < j + (h >> 1); ++k) {
        static Complex u, v;
        u = y[k], v = y[k + (h >> 1)] * W[op][bit][k - j];
        y[k] = u + v, y[k + h / 2] = u - v;
      }
    }
  }
  if (op == 0) {
    for (int i = 0; i < len; ++i) y[i].r /= len;
  }
}
class Edge {
 public:
  int u, v, w;
} e[MAX_M];
int N, M, T, X;
double prob[MAX_M][MAX_T], dp_e[MAX_M][MAX_T], dp_v[MAX_N][MAX_T];
vector<int> G[MAX_N];
inline void WorkEdge(int l, int r) {
  int mid = (l + r) >> 1;
  for (int i = 1; i <= M; ++i) {
    int u = e[i].u, v = e[i].v;
    int x = (r - l + 1), len = 1;
    while (len < (x + mid - l)) len <<= 1;
    for (int j = 0; j < len; ++j) A[j].r = A[j].i = B[j].r = B[j].i = 0;
    for (int j = 1; j <= r - l; ++j) A[j].r = prob[i][j], A[j].i = 0;
    for (int j = l; j <= mid; ++j) B[j - l].r = dp_v[v][j], B[j - l].i = 0;
    FFT(A, len, 1), FFT(B, len, 1);
    for (int j = 0; j < len; ++j) A[j] = A[j] * B[j];
    FFT(A, len, 0);
    for (int j = mid + 1; j <= r; ++j) dp_e[i][j] += A[j - l].r;
  }
}
int dist[MAX_N], dis[MAX_N][MAX_N];
double suf[MAX_M][MAX_T];
void solve(int L, int R) {
  if (L == R) {
    for (int i = 1; i <= M; ++i) {
      int u = e[i].u, v = e[i].v, w = e[i].w;
      double val = dp_e[i][L] + w + (double)dist[v] * suf[i][L + 1];
      if (val < dp_v[u][L]) dp_v[u][L] = val;
    }
    return;
  }
  int mid = (L + R) >> 1;
  solve(L, mid);
  WorkEdge(L, R);
  solve(mid + 1, R);
}
int main() {
  Read(N), Read(M), Read(T), Read(X);
  init();
  memset(dis, 0x3f, sizeof dis);
  for (int i = 1; i <= M; ++i) {
    int a, b, c;
    Read(a), Read(b), Read(c);
    e[i] = (Edge){a, b, c};
    G[a].push_back(i);
    dis[a][b] = min(dis[a][b], c);
    for (int j = 1; j <= T; ++j) Read(prob[i][j]), prob[i][j] /= 100000;
    for (int j = T; j; --j) suf[i][j] = prob[i][j] + suf[i][j + 1];
  }
  for (int i = 1; i <= N; ++i) dis[i][i] = 0;
  for (int k = 1; k <= N; ++k)
    for (int i = 1; i <= N; ++i)
      for (int j = 1; j <= N; ++j)
        if (dis[i][k] + dis[k][j] < dis[i][j])
          dis[i][j] = dis[i][k] + dis[k][j];
  for (int i = 1; i <= N; ++i) dist[i] = dis[i][N] + X;
  for (int i = 1; i <= N; ++i)
    for (int j = 0; j <= T; ++j) dp_v[i][j] = 1e9;
  for (int i = 0; i <= T; ++i) dp_v[N][i] = 0;
  solve(0, T);
  printf("%.7lf\n", dp_v[1][T]);
  return 0;
}
