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 N = 801 * 1001, MOD = 998244353, base = 1847;
const int NN = (1 << 19), L = 19;
int tv(int x, int y) {
  if (!y) return 1;
  long long ans = tv(x, y / 2);
  ans *= ans;
  ans %= MOD;
  if (y & 1) ans *= x;
  return ans % MOD;
}
int W[N];
int invv[N];
void ntt(vector<int>& v, bool inv) {
  int N = 1, l = 0;
  while (N != v.size()) N *= 2, l++;
  for (int i = 0; i < N; i++) {
    int x = invv[i] >> (L - l);
    if (x < i) swap(v[x], v[i]);
  }
  int base2 = tv(base, NN / N);
  for (int l = 2; l <= N; l *= 2) {
    int wn = tv(base2, N / l);
    if (inv) wn = tv(wn, MOD - 2);
    W[0] = 1;
    for (int i = 1; i < l / 2; i++) W[i] = 1ll * W[i - 1] * wn % MOD;
    for (int i = 0; i < N; i += l) {
      int xx = i + l / 2 - 1, yy = i - 1;
      for (int j = 0; j < l / 2; j++) {
        xx++, yy++;
        int x = 1ll * W[j] * v[xx] % MOD;
        int y = v[yy];
        v[xx] = y - x;
        v[yy] += x;
        if (v[yy] >= MOD) v[yy] -= MOD;
        if (v[xx] < 0) v[xx] += MOD;
      }
    }
  }
  if (inv) {
    int x = tv(N, MOD - 2);
    for (int i = 0; i < N; i++) v[i] = 1ll * v[i] * x % MOD;
  }
}
vector<int> vv;
void mul(vector<int> a, vector<int> b, vector<int>& ans, bool f = 0) {
  int N = 1;
  while (N < a.size()) N *= 2;
  N *= 2;
  a.resize(N);
  b.resize(N);
  ntt(a, 0);
  ntt(b, 0);
  ans.resize(N);
  for (int i = 0; i < N; i++) ans[i] = 1ll * a[i] * b[i] % MOD;
  vv = ans;
  ntt(ans, 1);
}
int c[N], a[N], lazy[N];
inline int mod(int& x) {
  if (x >= MOD) x -= MOD;
}
inline int md(int x) {
  if (x >= MOD) x -= MOD;
  return x;
}
void solve(int l, int r) {
  if (r - l == 1) return;
  int mid = (l + r) / 2;
  solve(l, mid);
  vector<int> lx, cx;
  for (int i = l; i < mid; i++) lx.push_back(a[i]);
  for (int i = 0; i < r - l; i++) cx.push_back(c[i]);
  vector<int> LAZY;
  for (int i = 0; i < r - l; i++) LAZY.push_back(lazy[i]);
  vector<int> vz;
  mul(LAZY, lx, vz);
  for (int i = mid; i < r; i++) a[i] += md(2 * vz[i - l]), mod(a[i]);
  vector<int> v2, vx;
  mul(cx, lx, vx);
  mul(vx, lx, v2);
  int N = vx.size();
  for (int i = mid; i < r; i++)
    if (i >= 2 * l) a[i] += v2[i - 2 * l], mod(a[i]);
  for (int i = 0; i < N; i++) lazy[l + i] += vx[i], mod(lazy[i + l]);
  solve(mid, r);
  for (int i = 0; i < N; i++) {
    lazy[i + l] -= vx[i];
    if (lazy[i + l] < 0) lazy[i + l] += MOD;
  }
}
int32_t main() {
  ios::sync_with_stdio(0), cin.tie(0);
  for (int i = 0; i < NN; i++) {
    for (int j = 0; j < L; j++)
      if (i & (1 << j)) invv[i] |= (1 << (L - 1 - j));
  }
  int n, m;
  cin >> n >> m;
  int x;
  while (n--) cin >> x, c[x] = 1;
  a[0] = 1;
  solve(0, m + 1);
  for (int i = 1; i <= m; i++) cout << a[i] << '\n';
}