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 std::swap;
const int N = (1 << 18) + 5, p = 998244353, G = 3;
int rev[N], invG, f[N], g[N], inv2;
inline int Dec(int x, int y) {
  x -= y;
  return x < 0 ? x + p : x;
}
inline int Plus(int x, int y) {
  x += y;
  return x >= p ? x - p : x;
}
inline void read(int &x) {
  x = 0;
  char ch = getchar();
  while (ch > '9' || ch < '0') ch = getchar();
  while (ch <= '9' && ch >= '0') x = x * 10 + (ch ^ 48), ch = getchar();
}
inline int quick_pow(int a, int b) {
  int ans = 1;
  while (b) {
    if (b & 1) ans = a * 1ll * ans % p;
    a = a * 1ll * a % p;
    b >>= 1;
  }
  return ans;
}
inline void butterfly(int n) {
  register int i;
  for (i = 0; i < n; ++i) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) ? n >> 1 : 0);
}
void NTT(int a[], bool op, int n) {
  register int i, j, mid;
  static int w[N];
  w[0] = 1;
  for (i = 0; i < n; ++i)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (mid = 1; mid < n; mid <<= 1) {
    int g1 = quick_pow(op ? G : invG, (p - 1) / (mid << 1));
    for (j = 1; j < mid; ++j) w[j] = w[j - 1] * 1ll * g1 % p;
    for (i = 0; i < n; i += mid << 1)
      for (j = 0; j < mid; ++j) {
        int x = a[i + j], y = a[i + j + mid] * 1ll * w[j] % p;
        a[i + j] = Plus(x, y), a[i + j + mid] = Dec(x, y);
      }
  }
  if (!op) {
    int invn = quick_pow(n, p - 2);
    for (i = 0; i < n; ++i) a[i] = a[i] * 1ll * invn % p;
  }
}
void Poly_Inv(int a[], int b[], int m) {
  int n;
  register int i, len;
  for (n = 1; n < m; n <<= 1)
    ;
  static int w[N], tmp[N], r[N];
  memset(w, 0, sizeof(int) * (n << 1));
  memset(r, 0, sizeof(int) * (n << 1));
  memset(tmp, 0, sizeof(int) * (n << 1));
  w[0] = quick_pow(a[0], p - 2);
  for (len = 2; len <= n; len <<= 1) {
    int Len = len << 1;
    memcpy(tmp, a, sizeof(int) * len);
    memcpy(r, w, sizeof(int) * (len >> 1));
    butterfly(Len);
    NTT(r, 1, Len), NTT(tmp, 1, Len);
    for (i = 0; i < Len; ++i) r[i] = r[i] * 1ll * r[i] % p * tmp[i] % p;
    NTT(r, 0, Len);
    for (i = 0; i < len; ++i) w[i] = Dec((w[i] << 1) % p, r[i]);
    memset(r + len, 0, sizeof(int) * len);
  }
  memcpy(b, w, sizeof(int) * n);
}
void Poly_Sqrt(int a[], int b[], int m) {
  int n;
  register int i, len;
  for (n = 1; n < m; n <<= 1)
    ;
  static int w[N], tmp[N], r[N];
  memset(w, 0, sizeof(int) * (n << 1));
  memset(r, 0, sizeof(int) * (n << 1));
  memset(tmp, 0, sizeof(int) * (n << 1));
  w[0] = a[0];
  for (len = 2; len <= n; len <<= 1) {
    int Len = len << 1;
    Poly_Inv(w, r, len);
    butterfly(Len);
    memcpy(tmp, a, sizeof(int) * len);
    NTT(r, 1, Len), NTT(tmp, 1, Len);
    for (i = 0; i < Len; ++i) r[i] = r[i] * 1ll * tmp[i] % p;
    NTT(r, 0, Len);
    for (i = 0; i < len; ++i)
      w[i] = Plus(inv2 * 1ll * w[i] % p, inv2 * 1ll * r[i] % p);
  }
  memcpy(b, w, sizeof(int) * n);
}
int main() {
  int n, m, x;
  register int i;
  read(n), read(m);
  f[0] = 1;
  for (i = 1; i <= n; ++i) read(x), f[x] = 1;
  for (i = 1; i <= m; ++i) f[i] = Dec(0, 4 * f[i]);
  invG = quick_pow(G, p - 2), inv2 = quick_pow(2, p - 2);
  Poly_Sqrt(f, g, m + 1);
  ++g[0];
  Poly_Inv(g, f, m + 1);
  for (i = 1; i <= m; ++i) printf("%d\n", f[i] * 2ll % p);
  return 0;
}