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 std::copy;
using std::fill;
using std::swap;
const int MaxN = 1 << 19;
const int mod_base = 119, mod_exp = 23;
const int mod_v = (mod_base << mod_exp) + 1;
const int primitive_root = 3;
int epsilon_num;
int eps[MaxN], inv_eps[MaxN], inv2;
int dec(int x, int v) {
  x -= v;
  return x < 0 ? x + mod_v : x;
}
int inc(int x, int v) {
  x += v;
  return x >= mod_v ? x - mod_v : x;
}
int pow(int x, int p) {
  int v = 1;
  for (; p; p >>= 1, x = (long long)x * x % mod_v)
    if (p & 1) v = (long long)x * v % mod_v;
  return v;
}
void init_eps(int num) {
  epsilon_num = num;
  int base = pow(primitive_root, (mod_v - 1) / num);
  int inv_base = pow(base, mod_v - 2);
  eps[0] = inv_eps[0] = 1;
  for (int i = 1; i != num; ++i) {
    eps[i] = (long long)eps[i - 1] * base % mod_v;
    inv_eps[i] = (long long)inv_eps[i - 1] * inv_base % mod_v;
  }
}
void transform(int n, int *x, int *w = eps) {
  for (int i = 0, j = 0; i != n; ++i) {
    if (i > j) swap(x[i], x[j]);
    for (int l = n >> 1; (j ^= l) < l; l >>= 1)
      ;
  }
  for (int i = 2; i <= n; i <<= 1) {
    int m = i >> 1, t = epsilon_num / i;
    for (int j = 0; j < n; j += i) {
      for (int p = 0, q = 0; p != m; ++p, q += t) {
        int z = (long long)x[j + m + p] * w[q] % mod_v;
        x[j + m + p] = dec(x[j + p], z);
        x[j + p] = inc(x[j + p], z);
      }
    }
  }
}
void inverse_transform(int n, int *x) {
  transform(n, x, inv_eps);
  int inv = pow(n, mod_v - 2);
  for (int i = 0; i != n; ++i) x[i] = (long long)x[i] * inv % mod_v;
}
void polynomial_inverse(int n, int *A, int *B) {
  static int T[MaxN];
  if (n == 1) {
    B[0] = pow(A[0], mod_v - 2);
    return;
  }
  int half = (n + 1) >> 1;
  polynomial_inverse(half, A, B);
  int p = 1;
  for (; p < n << 1; p <<= 1)
    ;
  fill(B + half, B + p, 0);
  transform(p, B);
  copy(A, A + n, T);
  fill(T + n, T + p, 0);
  transform(p, T);
  for (int i = 0; i != p; ++i)
    B[i] = (long long)B[i] * dec(2, (long long)T[i] * B[i] % mod_v) % mod_v;
  inverse_transform(p, B);
}
void polynomial_sqrt(int n, int *A, int *B) {
  static int T[MaxN], Z[MaxN];
  if (n == 1) {
    B[0] = 1;
    return;
  }
  int p = 1;
  for (; p < n << 1; p <<= 1)
    ;
  int half = (n + 1) >> 1;
  polynomial_sqrt(half, A, B);
  fill(B + half, B + n, 0);
  polynomial_inverse(n, B, T);
  for (int i = 0; i != n; ++i) T[i] = (long long)T[i] * inv2 % mod_v;
  fill(T + n, T + p, 0);
  transform(p, T);
  copy(A, A + n, Z);
  fill(Z + n, Z + p, 0);
  transform(p, Z);
  fill(B + half, B + p, 0);
  transform(p, B);
  for (int i = 0; i != p; ++i)
    B[i] = ((long long)B[i] * B[i] + Z[i]) % mod_v * T[i] % mod_v;
  inverse_transform(p, B);
}
int tmp[MaxN];
int A[MaxN], B[MaxN], C[MaxN], T[MaxN];
int main() {
  int n, m;
  std::scanf("%d %d", &n, &m);
  int min_v = ~0u >> 1;
  for (int i = 0; i != n; ++i) {
    std::scanf("%d", tmp + i);
    if (min_v > tmp[i]) min_v = tmp[i];
  }
  inv2 = mod_v - mod_v / 2;
  int p = 1;
  for (; p < (m + min_v + 1) << 1; p <<= 1)
    ;
  init_eps(p);
  A[0] = 1;
  for (int i = 0; i != n; ++i) {
    int x = tmp[i];
    T[x - min_v] = 2;
    A[x] = mod_v - 4;
  }
  polynomial_inverse(m + min_v + 1, T, C);
  polynomial_sqrt(m + min_v + 1, A, B);
  B[0] = dec(1, B[0]);
  for (int i = 1; i <= m + min_v; ++i) B[i] = mod_v - B[i];
  for (int i = 0; i <= m; ++i) B[i] = B[i + min_v];
  fill(B + m + 1, B + p, 0);
  fill(C + m + 1, C + p, 0);
  transform(p, B);
  transform(p, C);
  for (int i = 0; i != p; ++i) B[i] = (long long)B[i] * C[i] % mod_v;
  inverse_transform(p, B);
  for (int i = 1; i <= m; ++i) std::printf("%d\n", B[i]);
  return 0;
}