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 mod = 998244353;
const long long MAXN = 4e5 + 5;
namespace polynomial {
long long omega[MAXN], inv[MAXN];
long long qpow(long long a, long long b) {
  long long c = 1;
  while (b) {
    if (b & 1) (c *= a) %= mod;
    (a *= a) %= mod;
    b >>= 1;
  }
  return c;
}
long long Fix(long long x) {
  long long p = 0;
  while ((1 << (p)) < x) p++;
  return (1 << (p));
}
void Ready(long long N) {
  long long g = 3, x = qpow(g, (mod - 1) / N);
  for (long long i = 0; i <= N - 1; i++) {
    omega[i] = (!i ? 1 : omega[i - 1] * x % mod);
    inv[i] = qpow(omega[i], mod - 2);
  }
}
void Transform(long long N, long long *A, long long *w) {
  long long p = 0;
  for (long long i = 0; i <= N - 1; i++) {
    if (p < i) swap(A[i], A[p]);
    for (long long t = N >> 1; (p ^= t) < t; t >>= 1)
      ;
  }
  for (long long l = 2; l <= N; l <<= 1) {
    long long d = l >> 1;
    for (long long j = 0; j < N; j += l)
      for (long long k = 0; k <= d - 1; k++) {
        long long tmp = A[j + k + d] * w[N / l * k] % mod;
        A[j + k + d] = (A[j + k] + mod - tmp) % mod;
        (A[j + k] += tmp) %= mod;
      }
  }
}
void DFT(long long N, long long *A) { Transform(N, A, omega); }
void IDFT(long long N, long long *A) {
  Transform(N, A, inv);
  long long Inv = qpow(N, mod - 2);
  for (long long i = 0; i <= N - 1; i++) (A[i] *= Inv) %= mod;
}
void Inv(long long deg, long long *A, long long *B) {
  static long long T[MAXN];
  if (deg == 1) {
    B[0] = qpow(A[0], mod - 2);
    return;
  }
  Inv((deg + 1) >> 1, A, B);
  long long len = Fix(deg << 1);
  Ready(len);
  copy(A, A + deg, T);
  fill(T + deg, T + len, 0);
  DFT(len, T);
  DFT(len, B);
  for (long long i = 0; i <= len - 1; i++)
    (B[i] *= (2 + mod - B[i] * T[i] % mod) % mod) %= mod;
  IDFT(len, B);
  fill(B + deg, B + len, 0);
}
void Sqrt(long long deg, long long *A, long long *B) {
  static long long invB[MAXN], T[MAXN];
  if (deg == 1) {
    B[0] = 1;
    return;
  }
  long long len = Fix(deg << 1);
  Sqrt((deg + 1) >> 1, A, B);
  fill(invB, invB + len, 0);
  Inv(deg, B, invB);
  copy(A, A + deg, T);
  fill(T + deg, T + len, 0);
  DFT(len, T);
  DFT(len, B);
  DFT(len, invB);
  long long inv2 = qpow(2, mod - 2);
  for (long long i = 0; i <= len - 1; i++)
    B[i] = (B[i] + T[i] * invB[i] % mod) % mod * inv2 % mod;
  IDFT(len, B);
  fill(B + deg, B + len, 0);
}
}  // namespace polynomial
using namespace polynomial;
long long N, M, H[MAXN], B[MAXN], S[MAXN], I[MAXN], len;
namespace solution {
void Solve() {
  scanf("%lld%lld", &N, &M);
  for (long long i = 1; i <= N; i++) {
    long long v;
    scanf("%lld", &v);
    B[v] = 1;
  }
  len = Fix((M + 1) << 1);
  Ready(len);
  for (long long i = 1; i <= M; i++) B[i] = (mod - 4 * B[i]) % mod;
  B[0] = 1;
  Sqrt(M + 1, B, H);
  (H[0] += 1) %= mod;
  Inv(M + 1, H, I);
  for (long long i = 1; i <= M; i++) printf("%lld\n", 2 * I[i] % mod);
}
}  // namespace solution
int main() {
  using namespace solution;
  Solve();
  return 0;
}