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;
namespace ntt {
const int N = 1e6;
const long long MOD = 998244353;
const long long G = 3;
int n, len, bitr[N];
long long wi, invl, u, v, invl2;
long long w[N], tp[N], a[N], b[N];
long long calc(long long x, long long y) {
  static long long s;
  s = 1;
  while (y) {
    if (y & 1) (s *= x) %= MOD;
    (x *= x) %= MOD, y >>= 1;
  }
  return s;
}
void set(int n) {
  for (len = 1; len <= n; len <<= 1)
    ;
  invl = calc(len, MOD - 2);
  w[0] = 1, w[1] = calc(G, (MOD - 1) / len);
  for (int i = 0, j, k, l; i < len; bitr[j] = i++)
    for (j = 0, k = 1, l = i; k < len; k <<= 1, l >>= 1) j = (j << 1) + (l & 1);
  for (int i = 2; i <= len; i++) w[i] = w[i - 1] * w[1] % MOD;
}
void dft(long long *a, bool sig) {
  for (int i = 0; i < len; i++) tp[bitr[i]] = a[i];
  for (int i = 2, stp = len, cur, hal, j, k; i <= len; i <<= 1) {
    stp >>= 1, cur = sig ? len : 0, hal = i >> 1;
    for (j = 0; j < hal; j++, sig ? cur -= stp : cur += stp)
      for (k = j, wi = w[cur]; k < len; k += i) {
        u = tp[k], v = tp[k + hal] * wi % MOD;
        tp[k] = (u + v) % MOD;
        tp[k + hal] = (u - v + MOD) % MOD;
      }
  }
  for (int i = 0; i < len; i++) a[i] = tp[i];
}
void ntt(long long *ap, long long *bp, int na, int nb, long long *c) {
  for (int i = 0; i < na; i++) a[i] = ap[i];
  for (int i = 0; i < nb; i++) b[i] = bp[i];
  for (int i = na; i < len; i++) a[i] = 0;
  for (int i = nb; i < len; i++) b[i] = 0;
  dft(a, 0), dft(b, 0);
  for (int i = 0; i < len; i++) c[i] = a[i] * b[i] % MOD;
  dft(c, 1);
  for (int i = 0; i < len; i++) (c[i] *= invl) %= MOD;
}
void get_inv(long long *a, long long *inv_a, int n) {
  static long long tmp[N];
  if (n == 1) {
    inv_a[0] = calc(a[0], MOD - 2);
    return;
  }
  get_inv(a, inv_a, n >> 1);
  for (int i = 0; i < n; i++) tmp[i] = a[i], tmp[i + n] = 0;
  set(n);
  dft(tmp, 0), dft(inv_a, 0);
  for (int i = 0; i < len; i++)
    tmp[i] = inv_a[i] * (2 + MOD - tmp[i] * inv_a[i] % MOD) % MOD;
  dft(tmp, 1);
  for (int i = 0; i < len; i++) (tmp[i] *= invl) %= MOD;
  for (int i = 0; i < n; i++) inv_a[i] = tmp[i], inv_a[i + n] = 0;
}
void get_sqrt(long long *a, long long *sqrt_a, int n) {
  static long long tmp[N], c[N];
  if (n == 1) {
    invl2 = calc(2, MOD - 2);
    sqrt_a[0] = 1;
    return;
  }
  get_sqrt(a, sqrt_a, n >> 1);
  for (int i = 0; i < n; i++) tmp[i] = 0;
  get_inv(sqrt_a, tmp, n);
  for (int i = 0; i < n; i++) c[i] = a[i], c[n + i] = 0;
  set(n);
  dft(c, 0), dft(sqrt_a, 0), dft(tmp, 0);
  for (int i = 0; i < len; i++)
    sqrt_a[i] = (sqrt_a[i] + c[i] * tmp[i]) % MOD * invl2 % MOD;
  dft(sqrt_a, 1);
  for (int i = 0; i < n; i++) sqrt_a[i] = sqrt_a[i] * invl % MOD;
  for (int i = n; i < len; i++) sqrt_a[i] = 0;
}
void ni_ntt(long long *ap, long long *bp, int na, int nb, long long *c) {
  set(nb);
  nb = len;
  get_inv(bp, b, nb);
  set(nb);
  for (int i = 0; i < na; i++) a[i] = ap[i];
  for (int i = na; i < len; i++) a[i] = 0;
  dft(a, 0), dft(b, 0);
  for (int i = 0; i < len; i++) c[i] = b[i] * a[i] % MOD;
  dft(c, 1);
  for (int i = 0; i < len; i++) (c[i] *= invl) %= MOD;
}
}  // namespace ntt
const int N = 1e6;
const int MOD = 998244353;
long long a[N], b[N];
int n, m;
int main() {
  int n;
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= n; i++) {
    int x;
    scanf("%d", &x);
    if (x <= m) a[x] = 1;
  }
  for (int i = 1; i <= m; i++) a[i] = (MOD - 4 * a[i] % MOD) % MOD;
  a[0] = 1;
  int kn = 1;
  while (kn <= m) kn <<= 1;
  ntt::get_sqrt(a, b, kn);
  b[0]++;
  memset(a, 0, sizeof(a));
  ntt::get_inv(b, a, kn);
  for (int i = 1; i <= m; i++) printf("%d\n", a[i] * 2 % MOD);
  return 0;
}