// Problem: A. 乘积的期望
// Memory Limit: 1024 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

// Author: Donomonayuas

#include <bits/stdc++.h>

#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define per(i, j, k) for (int i = (j); i >= (k); --i)
#define SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;

template<class T>inline void chkmn(T &x, T y) { if (y < x) x = y; }
template<class T>inline void chkmx(T &x, T y) { if (y > x) x = y; }

using namespace std;

template <int P>
class mod_int {
  using Z = mod_int;

private:
  static int mo(int x) { return x < 0 ? x + P : x; }

public:
  int x;
  int val() const { return x; }
  mod_int() : x(0) {}
  template <class T>
  mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
  bool operator==(const Z &rhs) const { return x == rhs.x; }
  bool operator!=(const Z &rhs) const { return x != rhs.x; }
  Z operator-() const { return Z(x ? P - x : 0); }
  Z pow(long long k) const {
    Z res = 1, t = *this;
    while (k) {
      if (k & 1) res *= t;
      if (k >>= 1) t *= t;
    }
    return res;
  }
  Z &operator++() {
    x < P - 1 ? ++x : x = 0;
    return *this;
  }
  Z &operator--() {
    x ? --x : x = P - 1;
    return *this;
  }
  Z operator++(int) {
    Z ret = x;
    x < P - 1 ? ++x : x = 0;
    return ret;
  }
  Z operator--(int) {
    Z ret = x;
    x ? --x : x = P - 1;
    return ret;
  }
  Z inv() const { return pow(P - 2); }
  Z &operator+=(const Z &rhs) {
    (x += rhs.x) >= P && (x -= P);
    return *this;
  }
  Z &operator-=(const Z &rhs) {
    (x -= rhs.x) < 0 && (x += P);
    return *this;
  }
  Z &operator*=(const Z &rhs) {
    x = 1ULL * x * rhs.x % P;
    return *this;
  }
  Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                 \
  friend T operator o(const Z &lhs, const Z &rhs) {\
    Z res = lhs;                                   \
    return res o## = rhs;                          \
  }
  setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
};
const int P = 998244353;
using Z = mod_int<P>;

const int maxn = 110;

int n, m, c, a[maxn];
Z mul, sum, s[maxn], pw[maxn][maxn], val[maxn], fac[maxn], ivf[maxn];
Z f[maxn][1 << 18], g[maxn][1 << 18], dp[maxn][maxn][maxn], dq[maxn][maxn];

namespace lag {
  int n;
  Z x[maxn], y[maxn];
  Z solve(int k) {
    Z ans = 0;
    rep (i, 1, n) {
      Z s1 = y[i], s2 = 1;
      rep (j, 1, n) if (i != j) {
        s1 = s1 * (k - x[j]);
        s2 = s2 * (x[i] - x[j]);
      }
      ans += s1 * s2.inv();
    }
    return ans;
  }
}

int main() {
  fac[0] = 1;
  rep (i, 1, maxn - 1) fac[i] = fac[i - 1] * i;
  ivf[maxn - 1] = fac[maxn - 1].inv();
  per (i, maxn - 1, 1) ivf[i - 1] = ivf[i] * i;
  cin.tie(nullptr) -> ios::sync_with_stdio(false);
  cin >> n >> m >> c;
  rep (i, 1, n - m + 1) cin >> a[i], sum += a[i];
  if (2 * m > n) {
    mul = Z(c).pow(2 * m - n);
    int tn = 2 * n - 2 * m, tm = n - m;
    n = tn, m = tm;
  } else {
    mul = 1;
  }
  Z ans = 0;
  if (3 * m > n) {
    rep (i, 1, 3 * m) {
      pw[i][0] = 1;
      rep (j, 1, n) pw[i][j] = pw[i][j - 1] * a[i];
    }
    // a[i] + a[i + m] + a[i + 2 * m] = c
    // i <= m, choose i, a[i] - a[i - 1] times
    // i > 2 * m, choose i - m + 1, a[i] - a[i + 1] times
    // choose m + 1, c - a[m] - a[2 * m + 1] times
    rep (C, 0, n) {
      rep (s, 0, C) {
        // a[m] = s
        rep (i, 0, n) rep (j, 0, C) rep (k, 0, C - j) dp[i][j][k] = 0;
        rep (i, 0, C) rep (j, 0, C - i) if (s + j <= C) {
          if (2 * m + 1 > n && j) continue;
          dp[1][i][j] = pw[1][i] * pw[m + 1][C - j - s] * ivf[i] * ivf[C - j - s] * i * (2 * m + 1 > n ? 1 : j) * (C - i - j);
        }
        rep (i, 2, m) {
          int lk = (2 * m + i - 1 > n ? 0 : C);
          rep (j, 0, C) rep (k, 0, lk) dq[j][k] = 0;
          rep (j, 0, C) rep (k, 0, C - j) if (dp[i - 1][j][k].val()) {
            rep (tj, j, C) dq[tj][k] += dp[i - 1][j][k] * pw[i][tj - j] * ivf[tj - j];
          }
          rep (tj, 0, C) rep (k, 0, lk) if (dq[tj][k].val()) {
            rep (tk, 0, k) dp[i][tj][tk] += dq[tj][k] * pw[m + i][k - tk] * ivf[k - tk] * tj * (2 * m + i > n ? 1 : tk) * (C - tj - tk);
          }
        }
        rep (i, 0, C) rep (j, 0, C - i) if (i == s) val[C] += fac[C] * dp[m][i][j] * pw[2 * m + 1][j] * ivf[j];
      }
      lag::x[C + 1] = C, lag::y[C + 1] = val[C] * Z(sum).pow(C).inv();
    }
    lag::n = n + 1;
    ans = lag::solve(c);
  } else {
    rep (i, 1, n) s[i] = s[i - 1] + a[i] / sum;
    f[0][0] = 1;
    rep (i, 1, n) {
      rep (j, 0, i - 1) rep (S, 0, (1 << (m - 1)) - 1) g[j][S] = f[j][S], f[j][S] = 0;
      rep (j, 0, i - 1) rep (S, 0, (1 << (m - 1)) - 1) if (g[j][S].val()) {
        if (!(S >> (m - 2) & 1)) {
          f[j][S << 1] += g[j][S] * __builtin_popcount(S);
          f[j + 1][S << 1 | 1] += g[j][S] * (c - j);
          f[j + 1][S << 1] += g[j][S] * (c - j) * (s[i] - s[max(0, i - m)]);
        }
        rep (k, 0, m - 2) if (S >> k & 1) {
          if ((S ^ (1 << k)) >> (m - 2) & 1) continue;
          f[j][(S ^ (1 << k)) << 1] += g[j][S] * (s[i - k - 1] - s[max(0, i - m)]);
        }
      }
    }
    rep (i, 0, n) ans += f[i][0];
  }
  cout << (ans * mul).val() << '\n';
}