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 p = 998244353, maxN = 524288;
const int g = 3, ig = 332748118;
int W[25][maxN + 5], iW[25][maxN + 5], inv[maxN + 5], R[maxN + 5];
int X, x, len;
int N, M, maxC, C[maxN + 5], sqrtC[maxN + 5], F[maxN + 5];
char c;
int qpow(int a, long long k, int tt) {
  int ans = 1;
  while (k) {
    if (k & 1) ans = 1LL * ans * a % tt;
    a = 1LL * a * a % tt;
    k >>= 1;
  }
  return ans;
}
void NTT(int d[], bool flg, int n0) {
  x = 1;
  len = 0;
  while (x < n0) x <<= 1, len++;
  for (int i = 0; i < x; i++) {
    R[i] = (R[i >> 1] >> 1) | ((i & 1) << (len - 1));
    if (i < R[i]) swap(d[i], d[R[i]]);
  }
  for (int i = 1, l = 1; i < x; i <<= 1, l++)
    for (int j = 0; j < x; j += (i << 1))
      for (int k = 0; k < i; k++) {
        int a0 = d[j + k],
            a1 = 1LL * (flg ? iW[l][k] : W[l][k]) * d[j + i + k] % p;
        d[j + k] = (a0 + a1) % p;
        d[j + i + k] = (a0 - a1 + p) % p;
      }
  if (flg)
    for (int i = 0; i < x; i++) d[i] = 1LL * d[i] * inv[x] % p;
}
int tmpans[maxN + 5], tmpd[maxN + 5];
void Inv(int d[], int ans[], int n0) {
  if (n0 == 1) {
    ans[0] = qpow(d[0], p - 2, p);
    return;
  }
  Inv(d, ans, n0 >> 1);
  for (int i = 0; i < n0; i++) tmpans[i] = ans[i], tmpd[i] = d[i];
  NTT(tmpans, 0, n0 << 1);
  NTT(tmpd, 0, n0 << 1);
  for (int i = 0; i < (n0 << 1); i++)
    tmpans[i] = 1LL * tmpans[i] * tmpans[i] % p * tmpd[i] % p;
  NTT(tmpans, 1, n0 << 1);
  for (int i = 0; i < n0; i++)
    ans[i] = ((long long)ans[i] + ans[i] - tmpans[i] + p) % p;
  for (int i = 0; i < (n0 << 1); i++) tmpans[i] = tmpd[i] = 0;
}
void Der(int d[], int ans[], int n0) {
  for (int i = 0; i < n0; i++) ans[i] = 1LL * d[i + 1] * (i + 1) % p;
}
void Int(int d[], int ans[], int n0) {
  for (int i = n0 - 1; i >= 0; i--) ans[i + 1] = 1LL * d[i] * inv[i + 1] % p;
  ans[0] = 0;
}
int derd[maxN + 5], invd[maxN + 5];
void Ln(int d[], int ans[], int n0) {
  Der(d, derd, n0);
  Inv(d, invd, n0);
  NTT(derd, 0, n0 << 1);
  NTT(invd, 0, n0 << 1);
  for (int i = 0; i < (n0 << 1); i++) derd[i] = 1LL * derd[i] * invd[i] % p;
  NTT(derd, 1, n0 << 1);
  Int(derd, ans, n0);
  for (int i = 0; i < (n0 << 1); i++) derd[i] = invd[i] = 0;
}
int lnans[maxN + 5];
void Exp(int d[], int ans[], int n0) {
  if (n0 == 1) {
    ans[0] = 1;
    return;
  }
  Exp(d, ans, n0 >> 1);
  Ln(ans, lnans, n0);
  for (int i = 0; i < n0; i++) lnans[i] = (d[i] - lnans[i] + p) % p;
  lnans[0] = (lnans[0] + 1) % p;
  NTT(lnans, 0, n0 << 1);
  NTT(ans, 0, n0 << 1);
  for (int i = 0; i < (n0 << 1); i++) ans[i] = 1LL * ans[i] * lnans[i] % p;
  NTT(ans, 1, n0 << 1);
  for (int i = 0; i < n0; i++) lnans[i] = 0;
  for (int i = n0; i < (n0 << 1); i++) ans[i] = lnans[i] = 0;
}
int lnd[maxN + 5];
void Qpow(int d[], int ans[], int n0, int k) {
  Ln(d, lnd, n0);
  for (int i = 0; i < n0; i++) lnd[i] = 1LL * lnd[i] * k % p;
  Exp(lnd, ans, n0);
}
int expd[maxN + 5], expnegd[maxN + 5];
int main() {
  scanf("%d%d", &N, &M);
  for (int i = 1; i <= N; i++) {
    int tmp;
    scanf("%d", &tmp);
    if (tmp <= M) maxC = max(maxC, tmp);
    if (tmp <= M) C[tmp] = 1;
  }
  M++;
  x = 1;
  while (x < (M << 1)) x <<= 1, len++;
  inv[1] = 1;
  for (int i = 2; i <= x; i++) inv[i] = 1LL * (p - p / i) * inv[p % i] % p;
  for (int i = 1; i <= len + 1; i++) {
    W[i][0] = 1;
    iW[i][0] = 1;
    W[i][1] = qpow(g, (p - 1) / (1 << i), p),
    iW[i][1] = qpow(ig, (p - 1) / (1 << i), p);
    for (int j = 2; j < (1 << (i - 1)); j++)
      W[i][j] = 1LL * W[i][j - 1] * W[i][1] % p,
      iW[i][j] = 1LL * iW[i][j - 1] * iW[i][1] % p;
  }
  X = x;
  for (int i = 1; i < (X >> 1); i++) C[i] = (-4LL * C[i] % p + p) % p;
  C[0] = 1;
  Qpow(C, sqrtC, X >> 1, inv[2]);
  sqrtC[0] = (sqrtC[0] + 1) % p;
  Inv(sqrtC, F, X >> 1);
  for (int i = 1; i < M; i++) printf("%d\n", 2LL * F[i] % p);
}