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>
#pragma GCC optimize(3)
using namespace std;
int n, m, a[262145], c[262145], f[262145];
int l, tt, inv, rev[262145], root[262145];
int ta1[262145], tb1[262145], ta2[262145], tb2[262145], tc2[262145];
inline int qpow(int a, int t) {
  register int res = 1;
  for (register int i = t; i; i >>= 1) {
    if (i & 1) res = (long long)res * a % 998244353;
    a = (long long)a * a % 998244353;
  }
  return res;
}
inline int add(int a, int b) {
  a += b;
  return a >= 998244353 ? a - 998244353 : a;
}
inline int sub(int a, int b) {
  a -= b;
  return a < 0 ? a + 998244353 : a;
}
inline void init(int n) {
  tt = 0;
  l = 1;
  while (l < n) l <<= 1, ++tt;
  inv = qpow(l, 998244353 - 2);
  for (int i = 1; i < l; ++i)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (tt - 1));
  register int half = l >> 1;
  root[half] = 1;
  root[half + 1] = qpow(3, (998244353 - 1) / l);
  for (int i = 2; i < half; ++i)
    root[half + i] = (long long)root[half + i - 1] * root[half + 1] % 998244353;
  for (int i = half - 1; i > 0; --i) root[i] = root[i << 1];
}
inline void ntt(int *a, int dft) {
  for (int i = 0; i < l; ++i)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (register int mid = 1; mid < l; mid <<= 1) {
    register int *nw = root + mid;
    for (register int r = mid << 1, i = 0; i < l; i += r) {
      register int *w = nw;
      for (register int j = i; j < i + mid; ++j) {
        int x = a[j], y = (long long)a[j + mid] * (*w) % 998244353;
        a[j] = add(x, y);
        a[j + mid] = sub(x, y);
        ++w;
      }
    }
  }
  if (dft == -1) {
    reverse(a + 1, a + l);
    for (int i = 0; i < l; ++i) a[i] = (long long)a[i] * inv % 998244353;
  }
}
inline void polymul(int *a, int *b, int *c) {
  ntt(a, 1);
  ntt(b, 1);
  for (int i = 0; i < l; ++i) c[i] = (long long)a[i] * b[i] % 998244353;
  ntt(c, -1);
}
void polyinv(int *a, int len) {
  ta1[0] = qpow(a[0], 998244353 - 2);
  for (int mid = 2; mid <= len; mid <<= 1) {
    for (int i = 0; i < mid; ++i) tb1[i] = a[i];
    for (int i = mid; i < (mid << 1); ++i) tb1[i] = 0;
    for (int i = (mid >> 1); i < (mid << 1); ++i) ta1[i] = 0;
    init(mid << 1);
    ntt(ta1, 1);
    ntt(tb1, 1);
    for (int i = 0; i < (mid << 1); ++i)
      ta1[i] = sub(add(ta1[i], ta1[i]),
                   (long long)ta1[i] * ta1[i] % 998244353 * tb1[i] % 998244353);
    ntt(ta1, -1);
  }
  memcpy(a, ta1, sizeof(int) * len);
}
void polysqrt(int *a, int len) {
  ta2[0] = 1;
  for (int mid = 2; mid <= len; mid <<= 1) {
    for (int i = 0; i < mid; ++i) tb2[i] = add(ta2[i], ta2[i]);
    polyinv(tb2, mid);
    for (int i = 0; i < mid; ++i) tc2[i] = a[i];
    for (int i = mid; i < (mid << 1); ++i) tc2[i] = 0;
    init(mid << 1);
    ntt(tb2, 1);
    ntt(tc2, 1);
    for (int i = 0; i < l; ++i) {
      long long st = tb2[i];
      tb2[i] = ta2[i];
      ta2[i] = st * tc2[i] % 998244353;
    }
    ntt(ta2, -1);
    for (int i = 0; i < mid; ++i)
      ta2[i] = add(ta2[i], (long long)tb2[i] * 499122177 % 998244353);
  }
  memcpy(a, ta2, sizeof(int) * len);
}
inline void solve() {
  int len = 1;
  while (len <= m) len <<= 1;
  polysqrt(c, len);
  c[0] = (c[0] + 1) % 998244353;
  polyinv(c, len);
}
int main() {
  scanf("%d%d", &n, &m);
  c[0] = 1;
  for (register int i = 1; i <= n; ++i) {
    int x;
    scanf("%d", &x);
    if (x <= m) c[x] = 998244353 - 4;
  }
  solve();
  for (register int i = 1; i <= m; ++i) printf("%d\n", add(c[i], c[i]));
}