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 long long maxn = 1e6 + 10;
const long long mod = 998244353;
const long long G = 3;
const long long iG = (mod + 1) / 3;
const long long inv2 = (mod + 1) / 2;
inline long long read() {
  long long x = 0, f = 1;
  char c = getchar();
  while (c < '0' || c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    x = (x << 1) + (x << 3) + c - '0';
    c = getchar();
  }
  return x * f;
}
inline long long ksm(long long x, long long y) {
  long long res = 1;
  while (y) {
    if (y & 1) res = res * x % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return res;
}
long long tr[maxn];
long long n, m, a[maxn], b[maxn], c[maxn];
inline void ntt(long long *f, long long len, long long flag) {
  for (long long i = 0; i < len; i++)
    if (i < tr[i]) swap(f[i], f[tr[i]]);
  for (long long i = 2; i <= len; i <<= 1) {
    long long w = ksm(flag ? G : iG, (mod - 1) / i);
    for (long long j = 0, p = i >> 1; j < len; j += i) {
      long long wi = 1;
      for (long long k = j; k < j + p; k++) {
        long long tt = 1ll * wi * f[k + p] % mod;
        f[k + p] = (f[k] - tt + mod) % mod;
        f[k] = (f[k] + tt) % mod;
        wi = wi * w % mod;
      }
    }
  }
  if (flag == 0) {
    long long iv = ksm(len, mod - 2);
    for (long long i = 0; i < len; i++) f[i] = f[i] * iv % mod;
  }
}
inline void workinv(long long deg, long long *a, long long *b) {
  if (deg == 1) return void(b[0] = ksm(a[0], mod - 2));
  workinv((deg + 1) >> 1, a, b);
  long long len = 1;
  for (; len <= (deg << 1); len <<= 1)
    ;
  for (long long i = 0; i < len; i++)
    tr[i] = (tr[i >> 1] >> 1) | ((i & 1) ? len >> 1 : 0);
  for (long long i = 0; i < deg; i++) c[i] = a[i];
  for (long long i = deg; i < len; i++) c[i] = 0;
  ntt(c, len, 1);
  ntt(b, len, 1);
  for (long long i = 0; i < len; i++)
    b[i] = b[i] * (2 - b[i] * c[i] % mod + mod) % mod;
  ntt(b, len, 0);
  for (long long i = deg; i < len; i++) b[i] = 0;
}
long long f[maxn], g[maxn];
inline void worksqrt(long long deg, long long *a, long long *b) {
  if (deg == 1) return void(b[0] = 1);
  worksqrt((deg + 1) >> 1, a, b);
  long long len = 1;
  for (; len <= (deg << 1); len <<= 1)
    ;
  for (long long i = 0; i < len; i++) f[i] = g[i] = 0;
  for (long long i = 0; i < deg; i++) f[i] = a[i];
  workinv(deg, b, g);
  ntt(b, len, 1);
  ntt(f, len, 1);
  ntt(g, len, 1);
  for (long long i = 0; i < len; i++)
    b[i] = inv2 * g[i] % mod * (f[i] + b[i] * b[i] % mod) % mod;
  ntt(b, len, 0);
  for (long long i = deg; i < len; i++) b[i] = 0;
}
signed main() {
  n = read(), m = read() + 1;
  long long x;
  for (long long i = 0; i < n; i++) x = read(), a[x] = 1;
  a[0] = 1;
  for (long long i = 1; i < m; i++)
    if (a[i]) a[i] = mod - 4;
  worksqrt(m, a, b);
  b[0]++;
  for (long long i = 0; i < m << 1; i++) a[i] = b[i], b[i] = 0;
  workinv(m, a, b);
  for (long long i = 1; i < m; i++) printf("%lld ", 2 * b[i] % mod);
  return 0;
}