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 N = (1 << 20) + 10;
const int mod = 998244353, Gi = 332748118, i2 = 499122177;
int qp(int d, int k) {
  int f = 1;
  while (k) {
    if (k & 1) f = (1ll * (f) * (d) % mod);
    d = (1ll * (d) * (d) % mod), k >>= 1;
  }
  return f;
}
int C[N], sq[2][N], b[2][N], A[N], B[N], turn[N];
void NTT(int *a, int len, int typ) {
  for (int i = 1; i < len; i++)
    if (i < turn[i]) std::swap(a[i], a[turn[i]]);
  for (int le = 1; le < len; le <<= 1) {
    int wn = qp(typ ? 3 : Gi, (mod - 1) / (le << 1));
    for (int p = 0; p < len; p += le << 1) {
      int w = 1;
      for (int i = p; i < p + le; i++, w = (1ll * (w) * (wn) % mod)) {
        int tx = a[i], ty = (1ll * (w) * (a[i + le]) % mod);
        a[i] = ((tx + ty) % mod);
        a[i + le] = ((tx + mod - ty) % mod);
      }
    }
  }
  if (!typ) {
    int inv = qp(len, mod - 2);
    for (int i = 0; i < len; i++) a[i] = (1ll * (a[i]) * (inv) % mod);
  }
}
void polymul(int *a, int *b, int len) {
  int L = -1;
  for (int i = 1; i < len; i <<= 1) ++L;
  for (int i = 0; i < len; i++)
    turn[i] = turn[i >> 1] >> 1 | (i & 1) << L, A[i] = B[i] = 0;
  for (int i = 0; i < len >> 1; i++) A[i] = a[i], B[i] = b[i];
  NTT(A, len, 1), NTT(B, len, 1);
  for (int i = 0; i < len; i++) A[i] = (1ll * (A[i]) * (B[i]) % mod);
  NTT(A, len, 0);
  for (int i = 0; i < len; i++) a[i] = A[i];
}
void polyinv(int *a, int n) {
  int len = 2, cur = 0;
  b[cur][0] = qp(a[0], mod - 2);
  while (len <= (n << 2)) {
    cur ^= 1;
    for (int i = 0; i < len >> 1; i++)
      b[cur][i] = ((b[cur ^ 1][i] + b[cur ^ 1][i]) % mod);
    polymul(b[cur ^ 1], b[cur ^ 1], len);
    polymul(b[cur ^ 1], a, len);
    for (int i = 0; i < len; i++)
      b[cur][i] = ((b[cur][i] + mod - b[cur ^ 1][i]) % mod);
    len <<= 1;
  }
  for (int i = 0; i < n; i++) a[i] = b[cur][i];
}
void polysqrt(int *a, int n) {
  int len = 2, cur = 0;
  sq[cur][0] = 1;
  while (len <= (n << 2)) {
    cur ^= 1;
    for (int i = 0; i < len >> 1; i++)
      sq[cur][i] = (1ll * (sq[cur ^ 1][i]) * (i2) % mod);
    for (int i = 0; i < len >> 1; i++)
      sq[cur ^ 1][i] = ((sq[cur ^ 1][i] + sq[cur ^ 1][i]) % mod);
    polyinv(sq[cur ^ 1], len);
    polymul(sq[cur ^ 1], a, len);
    for (int i = 0; i < len; i++)
      sq[cur][i] = ((sq[cur][i] + sq[cur ^ 1][i]) % mod);
    len <<= 1;
  }
  for (int i = 0; i < n; i++) a[i] = sq[cur][i];
}
int main() {
  int n, m;
  scanf("%d%d", &n, &m);
  for (int c, i = 1; i <= n; i++) scanf("%d", &c), C[c] = 1;
  ++m;
  C[0] = 1;
  for (int i = 1; i < m; i++) C[i] = (mod - (C[i] << 2)) % mod;
  polysqrt(C, m);
  C[0] = ((C[0] + 1) % mod);
  polyinv(C, m);
  for (int i = 0; i < m; i++) C[i] = ((C[i] + C[i]) % mod);
  for (int i = 1; i < m; i++) printf("%d\n", C[i]);
  return 0;
}