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 int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 5;
const int MOD = 998244353;
const int G = 3;
const int Gi = 332748118;
int n, m;
int c[MAXN], Gn[MAXN], H[MAXN], Inv[MAXN], F[MAXN], r[MAXN];
int power(int x, int y) {
  int res = 1;
  while (y) {
    if (y & 1) res = 1ll * res * x % MOD;
    x = 1ll * x * x % MOD;
    y >>= 1;
  }
  return res;
}
const int inv2 = power(2, MOD - 2);
void NTT(int *a, int len, int flag) {
  for (int i = 0; i < len; i++) {
    if (i > r[i]) swap(a[i], a[r[i]]);
  }
  for (int i = 2; i <= len; i <<= 1) {
    int gn = power(flag == 1 ? G : Gi, (MOD - 1) / i);
    for (int j = 0; j < len; j += i) {
      int g = 1;
      for (int k = j; k < j + (i >> 1); k++) {
        int x = a[k];
        int y = 1ll * g * a[k + (i >> 1)] % MOD;
        a[k] = (x + y) % MOD;
        a[k + (i >> 1)] = (x - y + MOD) % MOD;
        g = 1ll * g * gn % MOD;
      }
    }
  }
  if (flag == -1) {
    int inv = power(len, MOD - 2);
    for (int i = 0; i < len; i++) a[i] = 1ll * a[i] * inv % MOD;
  }
}
void GetInv(int *a, int *res, int len) {
  static int tmp[MAXN];
  if (len == 1) {
    res[0] = power(a[0], MOD - 2);
    return;
  }
  GetInv(a, res, (len + 1) >> 1);
  int p = 1, cnt = 0;
  while (p < (len << 1)) {
    p <<= 1;
    cnt++;
  }
  for (int i = 0; i < p; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (cnt - 1));
  for (int i = 0; i < len; i++) tmp[i] = a[i];
  for (int i = len; i < p; i++) tmp[i] = 0;
  NTT(tmp, p, 1);
  NTT(res, p, 1);
  for (int i = 0; i < p; i++)
    res[i] =
        1ll * (2ll - 1ll * tmp[i] * res[i] % MOD + MOD) % MOD * res[i] % MOD;
  NTT(res, p, -1);
  for (int i = len; i < p; i++) res[i] = 0;
}
void Mul(int *a, int *b, int *res, int n, int m) {
  static int g[MAXN], f[MAXN];
  int p = 1, cnt = 0;
  while (p < (n + m)) {
    p <<= 1;
    cnt++;
  }
  for (int i = 0; i < p; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (cnt - 1));
  for (int i = 0; i < n; i++) f[i] = a[i];
  for (int i = n; i < p; i++) f[i] = 0;
  for (int i = 0; i < m; i++) g[i] = b[i];
  for (int i = m; i < p; i++) g[i] = 0;
  NTT(f, p, 1);
  NTT(g, p, 1);
  for (int i = 0; i < p; i++) res[i] = 1ll * f[i] * g[i] % MOD;
  NTT(res, p, -1);
}
void GetSqrt(int *a, int *res, int len) {
  static int tmp[MAXN];
  if (len == 1) {
    res[0] = 1;
    return;
  }
  GetSqrt(a, res, (len + 1) >> 1);
  for (int i = 0; i < (len << 1); i++) tmp[i] = 0;
  GetInv(res, tmp, len);
  Mul(a, tmp, tmp, len, len);
  for (int i = 0; i < len; i++)
    res[i] = 1ll * (tmp[i] + res[i]) % MOD * inv2 % MOD;
}
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= n; i++) {
    int x;
    scanf("%d", &x);
    c[x]++;
  }
  int len = 1;
  while (len < (m << 1)) len <<= 1;
  for (int i = 0; i < len; i++) Gn[i] = (MOD - 4 * c[i]) % MOD;
  Gn[0]++;
  GetSqrt(Gn, H, len);
  H[0] = (H[0] + 1) % MOD;
  GetInv(H, Inv, len);
  for (int i = 1; i <= m; i++) printf("%d\n", (Inv[i] + Inv[i]) % MOD);
  return 0;
}