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>
const int maxn = 1 << 18 | 7;
const int mod = 998244353, g = 3, inv2 = mod + 1 >> 1;
using namespace std;
int a[maxn];
int b[maxn];
int c[maxn];
int tmp[maxn];
int rev[maxn];
int bit[maxn];
inline int read() {
  int X = 0;
  char ch = getchar();
  while (ch < '0' || ch > '9') ch = getchar();
  while (ch >= '0' && ch <= '9') X = X * 10 + ch - '0', ch = getchar();
  return X;
}
inline int ksm(int a, int n) {
  int b = 1;
  while (n) {
    if (n & 1) b = 1ll * a * b % mod;
    a = 1ll * a * a % mod;
    n >>= 1;
  }
  return b;
}
inline void ntt(int *a, int n, int type) {
  for (int i = 0; i < n; i++) rev[i] = rev[i >> 1] >> 1 | (i & 1) << bit[n] - 1;
  for (int i = 0; i < n; i++)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int i = 1; i < n; i <<= 1) {
    int wn = ksm(g, (mod - 1) / (i << 1));
    if (type < 0) wn = ksm(wn, mod - 2);
    for (int j = 0; j < n; j += i << 1)
      for (int k = 0, w = 1; k < i; k++, w = 1ll * w * wn % mod) {
        int x = a[j + k], y = 1ll * w * a[i + j + k] % mod;
        a[j + k] = (x + y) % mod;
        a[i + j + k] = (x - y + mod) % mod;
      }
  }
  int invn = ksm(n, mod - 2);
  if (type < 0)
    for (int i = 0; i < n; i++) a[i] = 1ll * a[i] * invn % mod;
}
inline void poly_inv(int *a, int *b, int n) {
  if (n == 1) {
    b[0] = ksm(a[0], mod - 2);
    return;
  }
  poly_inv(a, b, n + 1 >> 1);
  int len = 1;
  while (len < n << 1) len <<= 1;
  for (int i = 0; i < n; i++) tmp[i] = a[i];
  for (int i = n; i < len; i++) tmp[i] = 0;
  ntt(tmp, len, 1);
  ntt(b, len, 1);
  for (int i = 0; i < len; i++)
    b[i] = 1ll * b[i] * (2 - 1ll * tmp[i] * b[i] % mod + mod) % mod;
  ntt(b, len, -1);
  for (int i = n; i < len; i++) b[i] = 0;
}
inline void poly_sqrt(int *a, int *b, int n) {
  if (n == 1) {
    b[0] = 1;
    return;
  }
  poly_sqrt(a, b, n + 1 >> 1);
  int len = 1;
  while (len < n << 1) len <<= 1;
  for (int i = 0; i < len; i++) c[i] = 0;
  poly_inv(b, c, n);
  for (int i = 0; i < n; i++) tmp[i] = a[i];
  for (int i = n; i < len; i++) tmp[i] = 0;
  ntt(tmp, len, 1);
  ntt(b, len, 1);
  ntt(c, len, 1);
  for (int i = 0; i < len; i++)
    b[i] = 1ll * (tmp[i] + 1ll * b[i] * b[i] % mod) * c[i] % mod * inv2 % mod;
  ntt(b, len, -1);
  for (int i = n; i < len; i++) b[i] = 0;
}
int main(void) {
  for (int i = 0; i <= 18; i++) bit[1 << i] = i;
  int n = read(), m = read() + 1;
  while (n--) a[read()] = mod - 4;
  a[0] = 1;
  poly_sqrt(a, b, m);
  b[0]++;
  memset(c, 0, sizeof c);
  poly_inv(b, c, m);
  for (int i = 1; i < m; i++) printf("%d\n", (c[i] << 1) % mod);
  return 0;
}