Problem: Nezzar buys his favorite snack — n chocolate bars with lengths l_1,l_2,…,l_n. However, chocolate bars might be too long to store them properly! 

In order to solve this problem, Nezzar designs an interesting process to divide them into small pieces. Firstly, Nezzar puts all his chocolate bars into a black box. Then, he will perform the following operation repeatedly until the maximum length over all chocolate bars does not exceed k.

  * Nezzar picks a chocolate bar from the box with probability proportional to its length x. 
  * After step 1, Nezzar uniformly picks a real number r ∈ (0,x) and divides the chosen chocolate bar into two chocolate bars with lengths r and x-r. 
  * Lastly, he puts those two new chocolate bars into the black box. 



Nezzar now wonders, what is the expected number of operations he will perform to divide his chocolate bars into small pieces.

It can be shown that the answer can be represented as P/Q, where P and Q are coprime integers and Q not ≡ 0 (mod 998 244 353). Print the value of P⋅ Q^{-1} mod 998 244 353.

Input

The first line contains two integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2000).

The second line contains n integers l_1, l_2, …, l_n (1 ≤ l_i, ∑_{i=1}^{n} l_i ≤ 2000).

Output

Print a single integer — the expected number of operations Nezzar will perform to divide his chocolate bars into small pieces modulo 998 244 353.

Examples

Input


1 1
2


Output


4


Input


1 1
1


Output


0


Input


1 5
1234


Output


15630811


Input


2 1
2 3


Output


476014684


Input


10 33
10 20 30 40 50 60 70 80 90 100


Output


675105648

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

static struct FastInput {
  static constexpr int BUF_SIZE = 1 << 20;
  char buf[BUF_SIZE];
  size_t chars_read = 0;
  size_t buf_pos = 0;
  FILE *in = stdin;
  char cur = 0;
 
  inline char get_char() {
    if (buf_pos >= chars_read) {
      chars_read = fread(buf, 1, BUF_SIZE, in);
      buf_pos = 0;
      buf[0] = (chars_read == 0 ? -1 : buf[0]);
    }
    return cur = buf[buf_pos++];
  }
 
  inline void tie(int) {}
 
  inline explicit operator bool() {
    return cur != -1;
  }
 
  inline static bool is_blank(char c) {
    return c <= ' ';
  }
 
  inline bool skip_blanks() {
    while (is_blank(cur) && cur != -1) {
      get_char();
    }
    return cur != -1;
  }
 
  inline FastInput& operator>>(char& c) {
    skip_blanks();
    c = cur;
    return *this;
  }
  
  inline FastInput& operator>>(string& s) {
    if (skip_blanks()) {
      s.clear();
      do {
        s += cur;
      } while (!is_blank(get_char()));
    }
    return *this;
  }
 
  template <typename T>
  inline FastInput& read_integer(T& n) {
    // unsafe, doesn't check that characters are actually digits
    n = 0;
    if (skip_blanks()) {
      int sign = +1;
      if (cur == '-') {
        sign = -1;
        get_char();
      }
      do {
        n += n + (n << 3) + cur - '0';
      } while (!is_blank(get_char()));
      n *= sign;
    }
    return *this;
  }
 
  template <typename T>
  inline typename enable_if<is_integral<T>::value, FastInput&>::type operator>>(T& n) {
    return read_integer(n);
  }
  
  #if !defined(_WIN32) || defined(_WIN64)
  inline FastInput& operator>>(__int128& n) {
    return read_integer(n);
  }
  #endif
 
  template <typename T>
  inline typename enable_if<is_floating_point<T>::value, FastInput&>::type operator>>(T& n) {
    // not sure if really fast, for compatibility only
    n = 0;
    if (skip_blanks()) {
      string s;
      (*this) >> s;
      sscanf(s.c_str(), "%lf", &n);
    }
    return *this;
  }
} fast_input;
 
#define cin fast_input
 
static struct FastOutput {
  static constexpr int BUF_SIZE = 1 << 20;
  char buf[BUF_SIZE];
  size_t buf_pos = 0;
  static constexpr int TMP_SIZE = 1 << 20;
  char tmp[TMP_SIZE];
  FILE *out = stdout;
 
  inline void put_char(char c) {
    buf[buf_pos++] = c;
    if (buf_pos == BUF_SIZE) {
      fwrite(buf, 1, buf_pos, out);
      buf_pos = 0;
    }
  }
 
  ~FastOutput() {
    fwrite(buf, 1, buf_pos, out);
  }
 
  inline FastOutput& operator<<(char c) {
    put_char(c);
    return *this;
  }
 
  inline FastOutput& operator<<(const char* s) {
    while (*s) {
      put_char(*s++);
    }
    return *this;
  }
 
  inline FastOutput& operator<<(const string& s) {
    for (int i = 0; i < (int) s.size(); i++) {
      put_char(s[i]);
    }
    return *this;
  }
 
  template <typename T>
  inline char* integer_to_string(T n) {
    // beware of TMP_SIZE
    char* p = tmp + TMP_SIZE - 1;
    if (n == 0) {
      *--p = '0';
    } else {
      bool is_negative = false;
      if (n < 0) {
        is_negative = true;
        n = -n;
      }
      while (n > 0) {
        *--p = (char) ('0' + n % 10);
        n /= 10;
      }
      if (is_negative) {
        *--p = '-';
      }
    }
    return p;
  }
 
  template <typename T>
  inline typename enable_if<is_integral<T>::value, char*>::type stringify(T n) {
    return integer_to_string(n);
  }
 
  #if !defined(_WIN32) || defined(_WIN64)
  inline char* stringify(__int128 n) {
    return integer_to_string(n);
  }
  #endif
 
  template <typename T>
  inline typename enable_if<is_floating_point<T>::value, char*>::type stringify(T n) {
    sprintf(tmp, "%.17f", n);
    return tmp;
  }
 
  template <typename T>
  inline FastOutput& operator<<(const T& n) {
    auto p = stringify(n);
    for (; *p != 0; p++) {
      put_char(*p);
    }
    return *this;
  }
} fast_output;

// here puts define
 
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;

#define rint register int
#define rll register ll 
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fors(i, a, b) for (ll i = (a); i <= (b); ++i)
#define _fors(i, a, b) for (ll i = (a); i >= (b); --i)
#define mp(a, b) make_pair(a, b)
#define mt(a, b, c) make_tuple(a, b, c)
#define mem(A, b) memset(A, b, sizeof(A))
#define all(X) (X).begin(), (X).end()
#define y0 gawgfawgawg
#define y1 sdfyseyegeh
#define pb push_back
#define eb emplace_back
#define cout fast_output
#define endl '\n'

int start_time;

// here puts const

const int mod = 998244353;
const int _ = 55555;

// here puts pre variable

int inv[_], tab[_], itab[_];
int n, k;
int L, l[_];
int a[55][_], b[55][_];
int iL;
int cda[4*_], cdb[4*_];
int res[4*_];
int aa[55][_], siz[55];
int tp[55][_][2], tsiz[55][2];

// here puts function

inline int add(int a, int b) {
  return (((a + b) % mod) + mod) % mod;
}

inline int mul(int a, int b) {
  return (((1LL * a * b) % mod) + mod) % mod;
}

inline int qpow(int a, int p) {
  int ret = 1;
  while (p) {
    if (p & 1) ret = mul(ret, a);
    a = mul(a, a);
    p >>= 1;
  }
  return ret;
}

inline void NTT(int* a, int a_size, bool inverse) {
  int n = a_size;
  // 原地快速bit reversal
  for(int i = 0, j = 0; i < n; i++) {
    if(j > i) swap(a[i], a[j]);
    int k = n;
    while(j & (k >>= 1)) j &= ~k;
    j |= k;
  }

  int root = inverse ? inv[3] : 3;

  for(int step = 1; step < n; step <<= 1) {
    int alpha = (mod-1) / step / 2;
    // 为求高效，我们并不是依次执行各个完整的DFT合并，而是枚举下标k
    // 对于一个下标k，执行所有DFT合并中该下标对应的蝴蝶操作，即通过E[k]和O[k]计算X[k]
    int omega = qpow(root, alpha), omegak = 1;
    for(int k = 0; k < step; k++) {
      // 计算omega^k. 这个方法效率低，但如果用每次乘omega的方法递推会有精度问题。
      // 有更快更精确的递推方法，为了清晰起见这里略去
      for(int Ek = k; Ek < n; Ek += step << 1) { // Ek是某次DFT合并中E[k]在原始序列中的下标
        int Ok = Ek + step; // Ok是该DFT合并中O[k]在原始序列中的下标
        int t = mul(a[Ok], omegak); // 蝴蝶操作：x1 * omega^k
        a[Ok] = add(a[Ek], -t);  // 蝴蝶操作：y1 = x0 - t
        a[Ek] = add(a[Ek], t);         // 蝴蝶操作：y0 = x0 + t
      }
      omegak = mul(omegak, omega);
    }
  }

  if(inverse) {
    int invn = qpow(n, mod - 2);
    fors(i, 0, n-1) a[i] = mul(a[i], invn);
  }

  return ;
}

// 用FFT实现的快速多项式乘法
inline int NTT_mul(int* v1, int v1_size, int* v2, int v2_size) {
  if (v1_size == 0 || v2_size == 0) return 0;
  int s1 = v1_size, s2 = v2_size, S = 2;
  while(S < s1 + s2) S <<= 1;
  fors(i, 0, S-1) cda[i] = 0, cdb[i] = 0;
  for(int i = 0; i < s1; i++) cda[i] = v1[i];
  NTT(cda, S, false);
  for(int i = 0; i < s2; i++) cdb[i] = v2[i];
  NTT(cdb, S, false);
  for(int i = 0; i < S; i++) cda[i] = mul(cda[i], cdb[i]);
  NTT(cda, S, true);
  for(int i = 0; i < s1 + s2 - 1; i++) res[i] = cda[i]; // 虚部均为0
  return s1 + s2 - 1;
}


void main_init() {
  inv[1] = 1, tab[1] = 1, itab[1] = 1;
  tab[0] = 1, itab[0] = 1;
  fors(i, 2, 50000) {
    inv[i] = mul(-mod / i, inv[mod%i]); 
  }
  fors(i, 2, 50000) {
    tab[i] = mul(tab[i-1], i);
    itab[i] = mul(itab[i-1], inv[i]);
  }
  return ;
}

void solve() {
  cin >> n >> k;
  fors(i, 1, n) cin >> l[i];
  fors(i, 1, n) L += l[i];
  if (L <= k) { cout << 0 << endl; return ; }
  iL = qpow(L, mod - 2);
  fors(i, 1, n) {
    fors(t, 0, l[i] / k) {
      int up = add(mul(t, k), -l[i]);
      a[i][t] = mul(itab[t], qpow(mul(up, iL), t));
    }
    fors(t, 0, l[i] / k - 1) {
      int up = add(add(k, -l[i]), mul(t, k));
      b[i][t] = mul(itab[t], qpow(mul(up, iL), t));
    }
  }
  // fors(i, 1, 2) fors(j, 0, 3) cout << i << ' ' << j << ' ' << a[i][j] << ' ' << b[i][j] << endl; 
  aa[0][0] = 1; siz[0] = 1;
  fors(i, 1, n) {
    fors(j, 0, i - 1) {
      tsiz[j][0] = NTT_mul(a[i], l[i] != k ? l[i] / k + 1 : 1, aa[j], siz[j]);
      fors(jj, 0, tsiz[j][0] - 1) tp[j][jj][0] = res[jj];
    }
    fors(j, 1, i) {
      tsiz[j][1] = NTT_mul(b[i], l[i] != k ? l[i] / k : 0, aa[j-1], siz[j-1]);
      fors(jj, 0, tsiz[j][1] - 1) tp[j][jj][1] = res[jj];
    }
    fors(j, 0, i) {
      siz[j] = max(tsiz[j][0], tsiz[j][1]);
      fors(jj, 0, siz[j] - 1) {
        int tt0 = jj >= tsiz[j][0] ? 0 : tp[j][jj][0];
        int tt1 = jj >= tsiz[j][1] ? 0 : tp[j][jj][1];
        aa[j][jj] = add(tt0, -tt1);
      } 
    }
  }
  int ans = 0;
  fors(j, 0, n) {
    fors(i, 0, siz[j] - 1) {
      if (i == 0 && j == 0) continue;
      // cout << i << ' ' << j << ' ' << a[j][i] << endl;
      int A = mul(mul(add(i, j), k), iL);
      ans = add(ans, mul(aa[j][i], mul(-tab[i], qpow(qpow(A, i+1), mod - 2))));
    }
  }
  cout << ans << endl;
  return ;
}

signed main() {
  #ifdef Sakuyalove
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
  #endif
  ios::sync_with_stdio(false);
  cin.tie(0);
  start_time = clock();

  int T = 1;
  // cin >> T;
  while (T--) {
    main_init();
    solve();
  }

  #ifdef Sakuyalove
    cout << "time = " << clock() - start_time << endl;
  #endif

  return 0;
}