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 int read() {
  int f = 1, k = 0;
  char c = getchar();
  while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
  while (c >= '0' && c <= '9') k = k * 10 + c - '0', c = getchar();
  return k * f;
}
const int P = 998244353, maxn = 8e5 + 100, G = 3;
inline int Pls(int a, const int b) {
  a += b;
  a >= P && (a -= P);
  return a;
}
inline int Minus(int a, const int b) {
  a -= b;
  a < 0 && (a += P);
  return a;
}
inline int Pow(int a, int b) {
  int ans = 1;
  for (; b; b >>= 1, a = 1ll * a * a % P)
    if (b & 1) ans = 1ll * ans * a % P;
  return ans;
}
inline int MOD(const int x) { return x >= P ? x - P : x; }
struct NTT {
  int R[maxn];
  inline void pre(int& n) {
    int L = 0, N = 1;
    for (; N < n; N <<= 1, ++L)
      ;
    ++L, N <<= 1;
    n = N;
    for (int i = 0; i < n; i++) R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
  }
  inline void main(int* a, const int n, const int f) {
    for (int i = 0; i < n; i++)
      if (i < R[i]) swap(a[i], a[R[i]]);
    for (int i = 1; i < n; i <<= 1) {
      int wn = Pow(G, (P - 1) / (i << 1));
      if (f == -1) wn = Pow(wn, P - 2);
      for (int j = 0; j < n; j += i << 1)
        for (int k = 0, now = 1; k < i; k++, now = 1ll * now * wn % P) {
          int x = a[j + k], y = 1ll * a[j + k + i] * now % P;
          a[j + k] = Pls(x, y);
          a[j + k + i] = Minus(x, y);
        }
    }
    if (f == -1)
      for (int i = 0, invn = Pow(n, P - 2); i < n; i++)
        a[i] = 1ll * a[i] * invn % P;
  }
  inline void mul(int* a, int* b, int n) {
    pre(n);
    static int tmp[maxn];
    memcpy(tmp, b, sizeof(int) * n);
    main(a, n, 1);
    main(tmp, n, 1);
    for (int i = 0; i < n; i++) a[i] = 1ll * a[i] * tmp[i] % P;
    main(a, n, -1);
  }
  inline void get_derivative(int* a, const int n) {
    for (int i = 0; i < n; i++) a[i] = 1ll * a[i + 1] * (i + 1) % P;
  }
  inline void get_origin(int* a, const int n) {
    for (int i = n; i; i--) a[i] = 1ll * a[i - 1] * Pow(i, P - 2) % P;
    a[0] = 0;
  }
  inline void getinv(int* a, int* b, const int n) {
    static int tmpa[maxn];
    memset(b, 0, sizeof(int) * maxn);
    b[0] = Pow(a[0], P - 2);
    for (int now = 2; now < n * 2; now <<= 1) {
      memset(tmpa, 0, sizeof(int) * n * 2);
      memcpy(tmpa, a, sizeof(int) * now);
      int tmplen = now;
      pre(tmplen);
      main(tmpa, tmplen, 1);
      main(b, tmplen, 1);
      for (int i = 0; i < tmplen; i++)
        b[i] = 1ll * b[i] * MOD(P + (2ll - 1ll * tmpa[i] * b[i]) % P) % P;
      main(b, tmplen, -1);
      memset(b + now, 0, sizeof(int) * now);
    }
  }
  inline void getln(int* a, const int n) {
    static int tmp[maxn];
    getinv(a, tmp, n);
    for (int i = n; i < n * 2; i++) tmp[i] = 0;
    int len = n;
    pre(len);
    main(tmp, len, 1);
    get_derivative(a, len);
    main(a, len, 1);
    for (int i = 0; i < len; i++) a[i] = 1ll * a[i] * tmp[i] % P;
    main(a, len, -1);
    get_origin(a, len);
  }
  inline void getexp(int* a, const int n) {
    static int TMP[maxn], ln[maxn], tmp[maxn];
    memset(TMP, 0, sizeof(TMP));
    TMP[0] = 1;
    for (int len = 2; len < n * 2; len <<= 1) {
      memset(ln, 0, sizeof(int) * len);
      memcpy(ln, TMP, sizeof(int) * len);
      memcpy(tmp, a, sizeof(int) * len);
      getln(ln, len);
      for (int i = len; i < len * 2; i++) ln[i] = 0;
      main(ln, len << 1, 1);
      main(TMP, len << 1, 1);
      main(tmp, len << 1, 1);
      for (int i = 0; i < len * 2; i++)
        TMP[i] = 1ll * TMP[i] * MOD((1ll - ln[i] + tmp[i]) % P + P) % P;
      main(TMP, len << 1, -1);
    }
    memcpy(a, TMP, sizeof(int) * n);
  }
  inline void ksm(int* a, const int n, const int k) {
    getln(a, n);
    for (int i = 0; i < n; i++) a[i] = 1ll * a[i] * k % P;
    getexp(a, n);
  }
} ntt;
int b[maxn], a[maxn];
signed main() {
  int n = read(), m = read(), N = m + 1;
  ntt.pre(N);
  for (int i = 1; i <= n; i++) a[read()] = P - 4;
  a[0] += 1;
  ntt.ksm(a, N, Pow(2, P - 2));
  a[0] = MOD(1 + a[0]);
  ntt.getinv(a, b, N);
  for (int i = 1; i <= m; i++) printf("%d\n", MOD(b[i] * 2));
}