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>
using namespace std;
const int maxlogn = 20;
const int maxn = (1 << maxlogn) | 1;
const int kcz = 998244353;
namespace polynomial {
long long G[2][24];
int rev[maxn];
inline long long qpow(long long a, int k) {
  long long res = 1;
  while (k) {
    if (k & 1) res = res * a % kcz;
    k >>= 1;
    if (k) a = a * a % kcz;
  }
  return res;
}
void init() {
  int i;
  G[1][23] = qpow(G[0][23] = qpow(3, (kcz - 1) >> 23), kcz - 2);
  for (i = 22; i >= 0; i--) {
    G[0][i] = G[0][i + 1] * G[0][i + 1] % kcz;
    G[1][i] = G[1][i + 1] * G[1][i + 1] % kcz;
  }
}
inline void calcrev(int logn) {
  register int i;
  rev[0] = 0;
  for (i = 1; i < (1 << logn); i++)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (logn - 1));
}
inline void DFT(long long *a, int logn, int flag) {
  register int i, j, k, mid;
  register long long t1, t2, t;
  for (i = 0; i < (1 << logn); i++)
    if (rev[i] < i) swap(a[rev[i]], a[i]);
  for (i = 1; i <= logn; i++)
    for (mid = 1 << (i - 1), j = 0; j < (1 << logn); j += 1 << i)
      for (k = 0, t = 1; k < mid; k++, t = t * G[flag][i] % kcz) {
        t1 = a[j | k], t2 = t * a[j | k | mid];
        a[j | k] = (t1 + t2) % kcz, a[j | k | mid] = (t1 - t2) % kcz;
      }
}
long long temp[maxn];
inline void inverse(const long long *f, long long *g, int n) {
  int logn, i;
  long long t, t1 = qpow(2, kcz - 2);
  for (logn = 0, g[0] = qpow(f[0], kcz - 2), t = t1; (1 << logn) < n; logn++) {
    memset(g + (1 << logn), 0, sizeof(long long) * (3 << logn));
    calcrev(logn + 2);
    DFT(g, logn + 2, 0);
    memcpy(temp, f, sizeof(long long) << (logn + 1));
    memset(temp + (1 << (logn + 1)), 0, sizeof(long long) << (logn + 1));
    DFT(temp, logn + 2, 0);
    for (i = 0; i < (4 << logn); i++)
      temp[i] = (2 * g[i] - g[i] * g[i] % kcz * temp[i]) % kcz;
    DFT(temp, logn + 2, 1);
    for (i = 0, (t *= t1) %= kcz; i < (2 << logn); i++)
      g[i] = t * temp[i] % kcz;
  }
  for (i = n; i < (1 << logn); i++) g[i] = 0;
}
long long h[maxn], ig[maxn];
inline void polysqrt(const long long *f, long long *g, int n) {
  int logn, i;
  long long t, t1 = qpow(2, kcz - 2);
  for (logn = 0, g[0] = 1, t = t1; (1 << logn) < n; logn++) {
    memset(g + (1 << logn), 0, sizeof(long long) * (3 << logn));
    inverse(g, ig, 2 << logn);
    memset(ig + (2 << logn), 0, sizeof(long long) * (2 << logn));
    memcpy(h, f, sizeof(long long) * (2 << logn));
    memset(h + (2 << logn), 0, sizeof(long long) * (2 << logn));
    calcrev(logn + 2);
    DFT(ig, logn + 2, 0), DFT(h, logn + 2, 0);
    for (i = 0; i < (4 << logn); i++) h[i] = h[i] * ig[i] % kcz;
    DFT(h, logn + 2, 1);
    for (i = 0, (t *= t1) %= kcz; i < (2 << logn); i++)
      g[i] = (t * h[i] + g[i]) % kcz * t1 % kcz;
  }
  for (i = n; i < (1 << logn); i++) g[i] = 0;
}
}  // namespace polynomial
using polynomial::init;
using polynomial::inverse;
using polynomial::polysqrt;
long long f[maxn], g[maxn];
int n;
int main() {
  int i, x, m;
  init();
  scanf("%d%d", &n, &m);
  memset(f, 0, sizeof(f));
  f[0] = 1;
  while (n--) scanf("%d", &x), f[x] = -4;
  polysqrt(f, g, m + 1);
  g[0]++;
  inverse(g, f, m + 1);
  for (i = 0; i <= m; i++) (f[i] <<= 1) %= kcz;
  for (i = 1; i <= m; i++) printf("%lld\n", (f[i] + kcz) % kcz);
  return 0;
}