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 N = 400005, P = 998244353;
using ll = long long;
namespace Poly {
int rev[N], lim, d;
ll wn[N + 1], inv[N];
ll qpow(ll a, ll b) {
  ll ret = 1;
  while (b) {
    if (b & 1) ret = ret * a % P;
    a = a * a % P;
    b >>= 1;
  }
  return ret;
}
void init(int n) {
  inv[1] = 1;
  for (int i = 2; i <= n; i++) inv[i] = ll(P - P / i) * inv[P % i] % P;
}
void FFTinit(int n) {
  int lst = lim;
  wn[0] = lim = 1;
  d = 0;
  while (lim < n) lim <<= 1, ++d;
  if (lim == lst) return;
  for (int i = 0; i < lim; i++)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (d - 1));
  int g = qpow(3, (P - 1) / lim);
  for (int i = 1; i <= lim; i++) wn[i] = wn[i - 1] * g % P;
}
void FFT(int a[], int fl) {
  for (int i = 0; i < lim; i++)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int s = 1; s < lim; s <<= 1) {
    int wnp = lim / s / 2;
    for (int i = 0; i < lim; i += s * 2)
      for (int j = 0; j < s; j++) {
        int x = a[i + j],
            y = a[i + j + s] * wn[fl == 1 ? wnp * j : lim - wnp * j] % P;
        a[i + j] = (x + y) % P;
        a[i + j + s] = (x + P - y) % P;
      }
  }
  if (fl == -1)
    for (int i = 0; i < lim; i++) a[i] = a[i] * inv[lim] % P;
}
template <typename T>
inline void clearArr(T a[], int cnt) {
  memset(a, 0, sizeof(T) * cnt);
}
using Poly = int[N];
void Add(Poly a, Poly b, int n, int m, Poly c) {
  clearArr(c, max(n, m));
  for (int i = 0; i < n; i++) c[i] = a[i];
  for (int i = 0; i < m; i++) c[i] = (c[i] + b[i]) % P;
}
void Mul(Poly a, Poly b, int n, int m, Poly c) {
  FFTinit(n + m - 1);
  static int ta[N], tb[N];
  for (int i = 0; i < n; i++) ta[i] = a[i];
  for (int i = 0; i < m; i++) tb[i] = b[i];
  clearArr(ta + n, lim - n);
  FFT(ta, 1);
  clearArr(tb + m, lim - m);
  FFT(tb, 1);
  for (int i = 0; i < lim; i++) ta[i] = ll(ta[i]) * tb[i] % P;
  FFT(ta, -1);
  for (int i = 0; i < n + m - 1; i++) c[i] = ta[i];
}
void Dev(Poly a, int n, Poly b) {
  b[n - 1] = 0;
  for (int i = 1; i < n; i++) b[i - 1] = ll(a[i]) * i % P;
}
void Inte(Poly a, int n, Poly b) {
  b[0] = 0;
  for (int i = 1; i < n; i++) b[i] = ll(a[i - 1]) * inv[i] % P;
}
void Inv(Poly a, int n, Poly b) {
  if (n == 1) {
    b[0] = qpow(a[0], P - 2);
    return;
  }
  Inv(a, (n + 1) / 2, b);
  static int ta[N];
  FFTinit(n * 2);
  clearArr(b + (n + 1) / 2, lim - (n + 1) / 2);
  for (int i = 0; i < n; i++) ta[i] = a[i];
  clearArr(ta + n, lim - n);
  FFT(ta, 1);
  FFT(b, 1);
  for (int i = 0; i < lim; i++)
    b[i] = b[i] * (P + 2 - ta[i] * 1ll * b[i] % P) % P;
  FFT(b, -1);
}
inline void Ln(Poly a, int n, Poly b) {
  static int ta[N], tb[N];
  Dev(a, n, ta);
  Inv(a, n, tb);
  Mul(ta, tb, n, n, ta);
  Inte(ta, n, b);
}
void Exp(Poly a, int n, Poly b) {
  if (n == 1) {
    b[0] = 1;
    return;
  }
  Exp(a, (n + 1) / 2, b);
  static int ta[N], tb[N];
  clearArr(b + (n + 1) / 2, n - (n + 1) / 2);
  Ln(b, n, tb);
  FFTinit(n * 2);
  for (int i = 0; i < n; i++) ta[i] = a[i];
  clearArr(ta + n, lim - n);
  clearArr(b + n, lim - n);
  clearArr(tb + n, lim - n);
  FFT(ta, 1);
  FFT(tb, 1);
  FFT(b, 1);
  for (int i = 0; i < lim; i++) b[i] = b[i] * (P + 1ll - tb[i] + ta[i]) % P;
  FFT(b, -1);
}
void Pow(Poly a, int n, int kk, Poly b) {
  static int tmp[N];
  Ln(a, n, tmp);
  for (int i = 0; i < n; i++) tmp[i] = ll(tmp[i]) * kk % P;
  Exp(tmp, n, b);
}
inline void Sqrt(Poly a, int n, Poly b) { Pow(a, n, inv[2], b); }
}  // namespace Poly
int n, m;
Poly::Poly f, g, h;
int main() {
  ios::sync_with_stdio(false);
  cin >> n >> m;
  ++m;
  Poly::init(N - 1);
  int t1;
  for (int i = 1; i <= n; i++) cin >> t1, g[t1] = 1;
  for (int i = 0; i < m; i++) g[i] *= 4, g[i] = -g[i];
  ++g[0];
  Poly::Sqrt(g, m, h);
  ++h[0];
  Poly::Inv(h, m, f);
  for (int i = 1; i < m; i++) f[i] = f[i] * 2 % P, cout << f[i] << endl;
  return 0;
}