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 mod = 998244353, G = 3, inv2 = 499122177;
int read() {
  int a = 0;
  bool opt = 0;
  char c = getchar();
  while (c < '0' || c > '9') opt |= c == '-', c = getchar();
  while (c >= '0' && c <= '9')
    a = (a << 3) + (a << 1) + (c ^ 48), c = getchar();
  return opt ? -a : a;
}
int ksm(int a, int n) {
  int ans = 1;
  while (n) {
    if (n & 1) ans = 1ll * ans * a % mod;
    a = 1ll * a * a % mod;
    n >>= 1;
  }
  return ans;
}
int n, m, x, A[262144], B[262144], fr[262144];
int maketable(int m) {
  int n = 1;
  while (n <= m) n <<= 1;
  for (int i = 1; i < n; ++i) {
    fr[i] = (fr[i >> 1] >> 1) | (i & 1 ? n >> 1 : 0);
  }
  return n;
}
void NTT(int* f, int n, bool opt) {
  int i, j, k;
  for (i = 0; i < n; ++i)
    if (fr[i] > i) swap(f[fr[i]], f[i]);
  for (i = 2; i <= n; i <<= 1) {
    int len = i >> 1;
    int tG = ksm(G, opt ? mod - 1 - (mod - 1) / i : (mod - 1) / i);
    for (int j = 0; j < n; j += i) {
      int buf = 1;
      for (int k = j; k < j + len; ++k) {
        int tmp = 1ll * f[k + len] * buf % mod;
        f[k + len] = f[k] < tmp ? f[k] - tmp + mod : f[k] - tmp;
        f[k] = f[k] + tmp > mod ? f[k] + tmp - mod : f[k] + tmp;
        buf = 1ll * buf * tG % mod;
      }
    }
  }
  if (opt) {
    int inv = ksm(n, mod - 2);
    for (int i = 0; i < n; ++i) f[i] = 1ll * f[i] * inv % mod;
  }
}
void Inv(int* f, int* g, int n) {
  static int tmp[262144];
  if (n == 1) {
    g[0] = ksm(f[0], mod - 2);
    return;
  }
  Inv(f, g, n + 1 >> 1);
  copy(f, f + n, tmp);
  int len = maketable(n << 1);
  NTT(tmp, len, 0);
  NTT(g, len, 0);
  for (int i = 0; i < len; ++i)
    g[i] =
        (2 * g[i] % mod - 1ll * tmp[i] * g[i] % mod * g[i] % mod + mod) % mod;
  NTT(g, len, 1);
  fill(tmp, tmp + len, 0);
  fill(g + n, g + len, 0);
}
void Sqrt(int* f, int* g, int n) {
  static int tmp[262144], inv[262144];
  if (n == 1) {
    g[0] = 1;
    return;
  }
  Sqrt(f, g, n + 1 >> 1);
  copy(f, f + n, tmp);
  Inv(g, inv, n);
  int len = maketable(n << 1);
  NTT(tmp, len, 0);
  NTT(inv, len, 0);
  for (int i = 0; i < len; ++i) tmp[i] = 1ll * tmp[i] * inv[i] % mod;
  NTT(tmp, len, 1);
  for (int i = 0; i < n; ++i) g[i] = 1ll * (g[i] + tmp[i]) * inv2 % mod;
  fill(tmp, tmp + len, 0);
  fill(inv, inv + len, 0);
  fill(g + n, g + len, 0);
}
int main() {
  n = read();
  m = read() + 1;
  for (int i = 1; i <= n; ++i) A[read()] = mod - 4;
  A[0] = 1;
  Sqrt(A, B, m);
  ++B[0];
  memset(A, 0, sizeof(A));
  Inv(B, A, m);
  for (int i = 1; i < m; ++i) cout << A[i] * 2 % mod << "\n";
  return 0;
}