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;
const int INV2 = 499122177;
const int maxn = 300000 + 10;
int c[maxn];
inline int power(int a, int b) {
  int res = 1;
  for (; b; a = (long long)a * a % mod, b >>= 1)
    if (b & 1) res = (long long)res * a % mod;
  return res;
}
namespace Geass {
int n, lg;
int inv, g;
int rev[maxn], wn[maxn];
inline void init(int lim) {
  for (n = 1, lg = 0; n < lim; n <<= 1, lg++)
    ;
  for (int i = 0; i < n; i++)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (lg - 1));
  inv = power(n, mod - 2);
  g = power(3, (mod - 1) / n);
  wn[0] = 1;
  for (int i = 1; i <= n; i++) wn[i] = (long long)wn[i - 1] * g % mod;
}
inline void NTT(int *v, int op) {
  for (int i = 0; i < n; i++)
    if (i < rev[i]) swap(v[i], v[rev[i]]);
  for (int i = 1; i < n; i <<= 1)
    for (int p = i << 1, j = 0; j < n; j += p)
      for (int k = 0; k < i; k++) {
        int w = op == 1 ? wn[n / p * k] : wn[n - n / p * k];
        int x = v[j + k], y = (long long)v[j + k + i] * w % mod;
        v[j + k] = (x + y) % mod;
        v[j + k + i] = (x - y + mod) % mod;
      }
  if (op == -1)
    for (int i = 0; i < n; i++) v[i] = (long long)v[i] * inv % mod;
}
void Get_inv(int *a, int *b, int len) {
  if (len == 1) {
    b[0] = power(a[0], mod - 2);
    return;
  }
  Get_inv(a, b, (len + 1) >> 1);
  static int tmp[maxn];
  init(len << 1);
  for (int i = 0; i < len; i++) tmp[i] = a[i];
  for (int i = len; i < n; i++) tmp[i] = 0;
  NTT(tmp, 1), NTT(b, 1);
  for (int i = 0; i < n; i++)
    b[i] = (long long)b[i] *
           ((2 - (long long)tmp[i] * b[i] % mod + mod) % mod) % mod;
  NTT(b, -1);
  for (int i = len; i < n; i++) b[i] = 0;
}
void Get_sqrt(int *a, int *b, int len) {
  if (len == 1) {
    b[0] = 1;
    return;
  }
  Get_sqrt(a, b, (len + 1) >> 1);
  static int tmp[maxn], invt[maxn];
  init(len << 1);
  for (int i = 0; i < n; i++) invt[i] = 0;
  Get_inv(b, invt, len);
  for (int i = 0; i < len; i++) tmp[i] = a[i];
  for (int i = len; i < n; i++) tmp[i] = 0;
  NTT(tmp, 1);
  NTT(b, 1);
  NTT(invt, 1);
  for (int i = 0; i < n; i++)
    b[i] = (long long)INV2 * ((b[i] + (long long)tmp[i] * invt[i]) % mod) % mod;
  NTT(b, -1);
  for (int i = len; i < n; i++) b[i] = 0;
}
}  // namespace Geass
int main() {
  if (fopen("438E.in", "r") != NULL) {
    freopen("438E.in", "r", stdin);
    freopen("438E.out", "w", stdout);
  }
  static int tmp[maxn], res[maxn];
  int n, m;
  scanf("%d%d", &n, &m);
  m++;
  for (int i = 1, x; i <= n; i++) {
    scanf("%d", &x);
    if (x < m) c[x]++;
  }
  for (int i = 1; i < m; i++)
    if (c[i]) c[i] = mod - 4 * c[i];
  c[0] = 1;
  Geass::Get_sqrt(c, tmp, m);
  tmp[0]++;
  Geass::Get_inv(tmp, res, m);
  for (int i = 1; i < m; printf("%d\n", (res[i++] + mod) % mod))
    res[i] = (res[i] + res[i]) % mod;
  return 0;
}