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 void Rd(int &res) {
  char c;
  res = 0;
  while (c = getchar(), c < '0')
    ;
  do {
    res = (res << 1) + (res << 3) + (c ^ 48);
  } while (c = getchar(), c >= '0');
}
const int M = (int)1e5 + 5;
const int P = 998244353;
const int inv2 = (P + 1) >> 1;
int n, m;
int T[M << 2], rev[M << 2], F[M << 2], inv[M << 2], sq[M << 2];
inline void Add(int &a, int b) {
  a += b;
  if (a >= P) a -= P;
}
int Pow(int x, int k) {
  int rs = 1;
  while (k) {
    if (k & 1) rs = (long long)rs * x % P;
    x = (long long)x * x % P;
    k >>= 1;
  }
  return rs;
}
void NTT(int *A, int n, bool type) {
  for (int i = 0; i < n; i++)
    if (i < rev[i]) swap(A[i], A[rev[i]]);
  for (int k = 2; k <= n; k <<= 1) {
    int m = k >> 1, wn = Pow(3, (P - 1) / k);
    if (type) wn = Pow(wn, P - 2);
    for (int i = 0; i < n; i += k) {
      int w = 1;
      for (int j = 0; j < m; j++) {
        int l = A[i + j], r = A[i + j + m];
        A[i + j] = (l + (long long)r * w % P) % P;
        A[i + j + m] = (l - (long long)r * w % P + P) % P;
        w = (long long)w * wn % P;
      }
    }
  }
  if (type) {
    int inv = Pow(n, P - 2);
    for (int i = 0; i < n; i++) A[i] = (long long)A[i] * inv % P;
  }
}
void Poly_inv(int *A, int *B, int n) {
  static int tmp[M << 2];
  B[0] = Pow(A[0], P - 2);
  for (int k = 2, p = 2; k <= n; k <<= 1, p++) {
    int m = k >> 1;
    for (int i = 0; i < k + k; i++)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (p - 1));
    for (int i = 0; i < k; i++) tmp[i] = A[i];
    for (int i = k; i < k + k; i++) tmp[i] = 0;
    for (int i = m; i < k + k; i++) B[i] = 0;
    NTT(tmp, k + k, 0), NTT(B, k + k, 0);
    for (int i = 0; i < k + k; i++)
      B[i] = (2 * B[i] % P - (long long)B[i] * B[i] % P * tmp[i] % P + P) % P;
    NTT(B, k + k, 1);
    for (int i = k; i < k + k; i++) B[i] = 0;
  }
}
void Poly_sqrt(int *A, int *B, int n) {
  static int tmp1[M << 2], tmp2[M << 2];
  B[0] = 1;
  for (int k = 2, p = 2; k <= n; k <<= 1, p++) {
    int m = k >> 1;
    for (int i = 0; i < k + k; i++)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (p - 1));
    Poly_inv(B, tmp1, k);
    for (int i = 0; i < k; i++) tmp2[i] = A[i];
    for (int i = k; i < k + k; i++) tmp2[i] = 0;
    NTT(tmp1, k + k, 0), NTT(tmp2, k + k, 0);
    for (int i = 0; i < k + k; i++) tmp1[i] = (long long)tmp1[i] * tmp2[i] % P;
    NTT(tmp1, k + k, 1);
    for (int i = 0; i < k; i++) B[i] = (long long)inv2 * (B[i] + tmp1[i]) % P;
  }
}
int main() {
  Rd(n), Rd(m);
  int mx = m;
  for (int i = 1; i <= n; i++) {
    int c;
    Rd(c), T[c]++;
    mx = max(mx, c);
  }
  for (int i = 0; i <= mx; i++) F[i] = (long long)(P - 4) * T[i] % P;
  Add(F[0], 1);
  int p = 1;
  while ((1 << p) <= mx) p++;
  Poly_sqrt(F, sq, 1 << p);
  for (int i = 0; i < (1 << p); i++) F[i] = sq[i];
  Add(F[0], 1);
  Poly_inv(F, inv, 1 << p);
  for (int i = 0; i < (1 << p); i++) inv[i] = 2 * inv[i] % P;
  for (int i = 1; i <= m; i++) printf("%d\n", inv[i]);
  return 0;
}