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;
inline int read() {
  int x = 0, ch = getchar(), f = 1;
  while (!isdigit(ch)) {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
  return x * f;
}
const int mo = 998244353, g = 3, N = 500005, iv2 = 499122177;
int rev[N];
long long A[N], B[N], T[N], P[N];
inline long long add(long long a, long long b) {
  a += b;
  if (a >= mo) a -= mo;
  if (a < 0) a += mo;
  return a;
}
long long pwr(long long a, long long b) {
  b = (b % (mo - 1) + mo - 1) % (mo - 1);
  long long res = 1;
  for (; b; b >>= 1, (a *= a) %= mo)
    if (b & 1) (res *= a) %= mo;
  return res;
}
void init_rev(int n) {
  for (int i = 1; i <= n - 1; ++i)
    if (i & 1)
      rev[i] = (rev[i >> 1] >> 1) ^ (n >> 1);
    else
      rev[i] = (rev[i >> 1] >> 1);
}
void ntt(long long *a, int n, int d = 1) {
  for (int i = 1; i <= n - 1; ++i)
    if (i > rev[i]) swap(a[i], a[rev[i]]);
  for (int m = 2; m <= n; m <<= 1) {
    long long wm = pwr(g, d * (mo - 1) / m);
    int k = m / 2;
    for (int i = 0; i < n; i += m) {
      long long w = 1;
      for (int j = i; j < i + k; ++j) {
        long long u = a[j], v = w * a[j + k] % mo;
        a[j] = add(u, v);
        a[j + k] = add(u, -v);
        (w *= wm) %= mo;
      }
    }
  }
  if (d == -1) {
    long long inv = pwr(n, mo - 2);
    for (int i = 0; i <= n - 1; ++i) (a[i] *= inv) %= mo;
  }
}
void poly_inv(long long *a, long long *b, int n) {
  if (n == 1) {
    b[0] = pwr(a[0], mo - 2);
    return;
  }
  poly_inv(a, b, n >> 1);
  memcpy(T, a, n * sizeof(long long));
  memset(T + n, 0, n * sizeof(long long));
  init_rev(n << 1);
  ntt(b, n << 1);
  ntt(T, n << 1);
  for (int i = 0; i < n << 1; ++i) b[i] = add(2, -T[i] * b[i] % mo) * b[i] % mo;
  ntt(b, n << 1, -1);
  memset(b + n, 0, n * sizeof(long long));
}
void poly_sqrt(long long *a, long long *b, int n) {
  static long long ta[N], tb[N];
  if (n == 1) {
    b[0] = 1;
    return;
  }
  poly_sqrt(a, b, n >> 1);
  memset(tb, 0, 2 * n * sizeof(long long));
  poly_inv(b, tb, n);
  memcpy(ta, a, n * sizeof(long long));
  memset(ta + n, 0, n * sizeof(long long));
  ntt(ta, n << 1);
  ntt(tb, n << 1);
  ntt(b, n << 1);
  for (int i = 0; i < n << 1; ++i)
    b[i] = add(b[i], ta[i] * tb[i] % mo) * iv2 % mo;
  ntt(b, n << 1, -1);
  memset(b + n, 0, n * sizeof(long long));
}
int main() {
  int n = read(), m = read();
  for (int i = 1; i <= n; ++i) {
    int x = read();
    A[x] = mo - 4;
  }
  int len = 1;
  while (len <= n || len <= m) len <<= 1;
  A[0] = 1;
  poly_sqrt(A, B, len);
  memset(A, 0, sizeof A);
  ++B[0];
  poly_inv(B, A, len);
  for (int i = 1; i <= m; ++i) printf("%I64d\n", add(A[i], A[i]));
  return 0;
}