Problem: Our child likes computer science very much, especially he likes binary trees.

Consider the sequence of n distinct positive integers: c1, c2, ..., cn. The child calls a vertex-weighted rooted binary tree good if and only if for every vertex v, the weight of v is in the set {c1, c2, ..., cn}. Also our child thinks that the weight of a vertex-weighted tree is the sum of all vertices' weights.

Given an integer m, can you for all s (1 ≤ s ≤ m) calculate the number of good vertex-weighted rooted binary trees with weight s? Please, check the samples for better understanding what trees are considered different.

We only want to know the answer modulo 998244353 (7 × 17 × 223 + 1, a prime number).

Input

The first line contains two integers n, m (1 ≤ n ≤ 105; 1 ≤ m ≤ 105). The second line contains n space-separated pairwise distinct integers c1, c2, ..., cn. (1 ≤ ci ≤ 105).

Output

Print m lines, each line containing a single integer. The i-th line must contain the number of good vertex-weighted rooted binary trees whose weight exactly equal to i. Print the answers modulo 998244353 (7 × 17 × 223 + 1, a prime number).

Examples

Input

2 3
1 2


Output

1
3
9


Input

3 10
9 4 3


Output

0
0
1
1
0
2
4
2
6
15


Input

5 10
13 10 6 4 15


Output

0
0
0
1
0
1
0
2
0
5

Note

In the first example, there are 9 good vertex-weighted rooted binary trees whose weight exactly equal to 3:

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
const int maxn = 1 << 18, mod = 998244353, proot = 3, base = (mod - 1) / maxn,
          inv2 = mod + 1 >> 1;
int w[maxn], rw[maxn];
inline int pow_mod(int x, int n) noexcept {
  int y = 1;
  while (n) {
    if (n & 1) {
      y = 1ll * y * x % mod;
    }
    x = 1ll * x * x % mod;
    n >>= 1;
  }
  return y;
}
void fft_init() {
  w[0] = rw[0] = 1;
  w[1] = pow_mod(proot, base);
  rw[1] = pow_mod(w[1], mod - 2);
  for (int i = 2; i < maxn; ++i) {
    w[i] = 1ll * w[i - 1] * w[1] % mod;
    rw[i] = 1ll * rw[i - 1] * rw[1] % mod;
  }
  return;
}
inline void swap(int &x, int &y) noexcept {
  x ^= y;
  y ^= x;
  x ^= y;
  return;
}
inline void dft(int n, int *a, int *W, bool rev = 0) noexcept {
  for (int i = 0, j = 0; i < n; ++i) {
    if (i > j) {
      swap(a[i], a[j]);
    }
    for (int k = n >> 1; (j ^= k) < k; k >>= 1)
      ;
  }
  for (int hl = 1, l = 2, stp = maxn / l; l <= n; hl = l, l <<= 1, stp >>= 1) {
    for (int i = 0; i < n; i += l) {
      for (int j = i, k = i | hl, p = 0; j < (i | hl); ++j, ++k, p += stp) {
        int t = 1ll * a[k] * W[p] % mod;
        a[k] = (a[j] - t + mod) % mod;
        (a[j] += t) %= mod;
      }
    }
  }
  if (rev) {
    int inv = pow_mod(n, mod - 2);
    for (int i = 0; i < n; ++i) {
      a[i] = 1ll * a[i] * inv % mod;
    }
  }
  return;
}
int a[maxn], b[maxn], c[maxn], tmp[maxn];
void inv(int N, int *a, int *b) {
  memset(b, 0, sizeof(int) * N << 1);
  b[0] = pow_mod(a[0], mod - 2);
  for (int m = 1, n = 2, nn = 4; n <= N; m = n, n = nn, nn <<= 1) {
    memcpy(tmp, a, sizeof(int) * n);
    memset(tmp + n, 0, sizeof(int) * n);
    dft(nn, b, w);
    dft(nn, tmp, w);
    for (int i = 0; i < nn; ++i) {
      b[i] = 1ll * b[i] * ((2ll - 1ll * b[i] * tmp[i]) % mod + mod) % mod;
    }
    dft(nn, b, rw, 1);
    memset(b + n, 0, sizeof(int) * n);
  }
  return;
}
void sqrrt(int N, int *a, int *b) {
  b[0] = 1;
  for (int m = 1, n = 2, nn = 4; n <= N; m = n, n = nn, nn <<= 1) {
    inv(n, b, c);
    memcpy(tmp, a, sizeof(int) * n);
    memset(tmp + n, 0, sizeof(int) * n);
    dft(nn, tmp, w);
    memset(c + n, 0, sizeof(int) * n);
    dft(nn, c, w);
    for (int i = 0; i < nn; ++i) {
      tmp[i] = 1ll * tmp[i] * c[i] % mod;
    }
    dft(nn, tmp, rw, 1);
    for (int i = 0; i < n; ++i) {
      b[i] = 1ll * inv2 * (b[i] + tmp[i]) % mod;
    }
  }
  return;
}
char s[10000000], *S;
inline void R(int &x) noexcept {
  x = 0;
  while (*S < '0' || *S > '9') {
    ++S;
  }
  while (*S >= '0' && *S <= '9') {
    (x *= 10) += *S - '0';
    ++S;
  }
  return;
}
inline void W(int x) noexcept {
  if (!x) {
    *S++ = '0';
  } else {
    static char c[12];
    char *t = c;
    while (x) {
      int y = x / 10;
      *t++ = x - y * 10 + '0';
      x = y;
    }
    while (t != c) {
      *S++ = *--t;
    }
  }
  *S++ = '\n';
  return;
}
int main() {
  fft_init();
  int N, m, n;
  fread(s, 1, 10000000, stdin);
  S = s;
  R(N);
  R(m);
  while (N--) {
    int x;
    R(x);
    a[x] = 998244349;
  }
  a[0] = 1;
  n = 1;
  while (n <= m) {
    n <<= 1;
  }
  sqrrt(n, a, b);
  ++b[0];
  inv(n, b, a);
  S = s;
  for (int i = 1; i <= m; ++i) {
    W((a[i] << 1) % mod);
  }
  fwrite(s, 1, S - s, stdout);
  return 0;
}