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;
int n, m, num = 1, c[100005], f[400005], ff[400005], h[400005], g[400005],
          r[400005];
int ksm(int aa, int k) {
  int bb = 1;
  while (k) {
    if (k & 1) bb = (long long)bb * aa % mod;
    aa = (long long)aa * aa % mod;
    k >>= 1;
  }
  return bb;
}
void ntt(int *c, int type) {
  for (int i = 0; i < num; ++i)
    if (i < r[i]) swap(c[i], c[r[i]]);
  for (int mid = 1; mid < num; mid <<= 1) {
    int w = ksm(3, (mod - 1) / (mid << 1));
    if (type == -1) w = ksm(w, mod - 2);
    for (int j = 0; j < num; j += (mid << 1)) {
      int ww = 1;
      for (int k = 0; k < mid; ++k) {
        int x = c[j + k], y = (long long)ww * c[j + mid + k] % mod;
        c[j + k] = (x + y) % mod;
        c[j + mid + k] = (x - y + mod) % mod;
        ww = (long long)w * ww % mod;
      }
    }
  }
  if (type == -1) {
    int inv = ksm(num, mod - 2);
    for (int i = 0; i < num; ++i) c[i] = (long long)c[i] * inv % mod;
  }
  return;
}
void inv(int k) {
  if (k == 1) {
    g[0] = ksm(h[0] % mod, mod - 2);
    return;
  }
  inv((k + 1) >> 1);
  num = 1;
  while (num < (k << 1)) num <<= 1;
  for (int i = 0; i < num; ++i)
    r[i] = (r[i >> 1] >> 1) | ((i & 1) ? num >> 1 : 0);
  for (int i = 0; i < k; ++i) ff[i] = h[i] % mod;
  for (int i = k; i < num; ++i) ff[i] = 0;
  ntt(ff, 1);
  ntt(g, 1);
  for (int i = 0; i < num; ++i)
    g[i] = (2 * g[i] % mod - (long long)g[i] * g[i] % mod * ff[i] % mod + mod) %
           mod;
  ntt(g, -1);
  for (int i = k; i < num; ++i) g[i] = 0;
  return;
}
void sqrt(int k) {
  if (k == 1) {
    h[0] = 1;
    return;
  }
  sqrt((k + 1) >> 1);
  num = 1;
  while (num < k + 1) num <<= 1;
  for (int i = 0; i < num; ++i) g[i] = 0;
  inv(k);
  for (int i = 0; i < k; ++i) ff[i] = f[i];
  for (int i = k; i < num; ++i) ff[i] = 0;
  ntt(ff, 1);
  ntt(h, 1);
  ntt(g, 1);
  for (int i = 0; i < num; ++i)
    h[i] = (long long)(ff[i] + (long long)h[i] * h[i] % mod) % mod * g[i] % mod;
  ntt(h, -1);
  for (int i = 0; i < num; ++i) h[i] = (long long)h[i] * ksm(2, mod - 2) % mod;
  for (int i = k; i < num; ++i) h[i] = 0;
  return;
}
int main() {
  scanf("%d%d", &n, &m);
  f[0] = 1;
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &c[i]);
    f[c[i]] = mod - 4;
  }
  sqrt(m + 1);
  h[0] = (h[0] + 1) % mod;
  memset(g, 0, sizeof(g));
  inv(m + 1);
  for (int i = 1; i <= m; ++i) printf("%d\n", (int)((long long)g[i] * 2 % mod));
  return 0;
}