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 N = 6e5 + 10;
const int G = 3;
int n, m, c[N];
int rev[N];
int qpow(int a, int b) {
  b = (b % (mod - 1) + mod - 1) % (mod - 1);
  int res = 1;
  for (; b; b >>= 1, a = 1ll * a * a % mod)
    if (b & 1) res = 1ll * res * a % mod;
  return res;
}
void FFT(vector<int> &a, int type) {
  int lim = a.size();
  for (int i = 0; i < lim; i++)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int i = 2; i <= lim; i <<= 1) {
    int wn = qpow(qpow(G, type), (mod - 1) / i);
    for (int j = 0; j < lim; j += i) {
      for (int k = 0, w = 1; k < (i >> 1); k++, w = 1ll * w * wn % mod) {
        int x = a[j + k], y = 1ll * a[j + k + (i >> 1)] * w % mod;
        a[j + k] = (x + y) % mod;
        a[j + k + (i >> 1)] = (x - y + mod) % mod;
      }
    }
  }
  if (type == -1) {
    int ilim = qpow(lim, mod - 2);
    for (int i = 0; i < lim; i++) a[i] = 1ll * a[i] * ilim % mod;
  }
  return;
}
void initrever(int n, int &lim) {
  lim = 1;
  for (; lim < n; lim <<= 1)
    ;
  for (int i = 1; i < lim; i++) {
    rev[i] = rev[i >> 1] >> 1;
    if (i & 1) rev[i] |= (lim >> 1);
  }
  return;
}
void put(vector<int> &a) {
  for (int i = 0; i < a.size(); i++) cout << a[i] << " ";
  cout << endl;
  return;
}
vector<int> inverse(vector<int> &a) {
  vector<int> b(1), c;
  int lim = a.size();
  b[0] = qpow(a[0], mod - 2);
  for (int limit = 1; limit < lim; limit <<= 1) {
    int lmt;
    initrever(limit << 2, lmt);
    b.resize(lmt);
    c = a;
    c.resize(limit << 1);
    c.resize(lmt);
    FFT(b, 1), FFT(c, 1);
    for (int i = 0; i < lmt; i++)
      b[i] = 1ll * b[i] * (2 - 1ll * c[i] * b[i] % mod + mod) % mod;
    FFT(b, -1);
    b.resize(limit << 1);
  }
  return b;
}
vector<int> Sqr(vector<int> &a) {
  int lim = a.size();
  vector<int> b(1), c, d;
  b[0] = 1;
  int inv2 = qpow(2, mod - 2);
  for (int limit = 1; limit < lim; limit <<= 1) {
    int lmt;
    initrever(limit << 2, lmt);
    b.resize(limit << 1);
    d = inverse(b);
    d.resize(lmt);
    b.resize(lmt);
    c = a;
    c.resize(limit << 1);
    c.resize(lmt);
    FFT(b, 1), FFT(c, 1), FFT(d, 1);
    for (int i = 0; i < lmt; i++)
      b[i] = 1ll * (1ll * b[i] * b[i] % mod + c[i]) % mod * d[i] % mod * inv2 %
             mod;
    FFT(b, -1);
    b.resize(limit << 1);
  }
  return b;
}
int main() {
  scanf("%d%d", &n, &m);
  int lim, V = 0;
  for (int i = 1; i <= n; i++) {
    scanf("%d", &c[i]);
    V = max(V, c[i]);
  }
  V = max(m, V);
  initrever(V + 1, lim);
  vector<int> a(lim);
  for (int i = 1; i <= n; i++) a[c[i]] = 1;
  vector<int> d = a;
  for (int i = 0; i < lim; i++) d[i] = (mod - 1ll * d[i] * 4 % mod) % mod;
  d[0] = (d[0] + 1) % mod;
  d = Sqr(d);
  d[0] = (d[0] + 1) % mod;
  d = inverse(d);
  for (int i = 0; i < lim; i++) d[i] = 1ll * d[i] * 2 % mod;
  for (int i = 1; i <= m; i++) printf("%d\n", d[i]);
  return 0;
}