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 MAXN = 100005;
const long long MOD = 998244353;
const long long G = 3;
int n, m, N;
int rev[MAXN << 2];
long long Inv;
long long fac[MAXN << 1];
long long inv[MAXN << 1];
long long wn[2][MAXN << 2];
void print(vector<long long> A) {
  for (int i = 0; i < A.size(); i++) cout << (A[i] + MOD) % MOD << ' ';
  cout << endl;
}
long long power(long long a, long long b) {
  long long res = 1;
  while (b) {
    if (b & 1) (res *= a) %= MOD;
    (a *= a) %= MOD;
    b >>= 1;
  }
  return res;
}
void INIT(int l) {
  fac[0] = 1;
  for (int i = 1; i <= (l << 1); i++) fac[i] = fac[i - 1] * i % MOD;
  inv[l << 1] = power(fac[l << 1], MOD - 2);
  for (int i = (l << 1); i >= 1; i--) inv[i - 1] = inv[i] * i % MOD;
}
void init(int l) {
  N = 1;
  while (N < l) N <<= 1;
  for (int i = 1; i < N; i++) rev[i] = (rev[i >> 1] >> 1) + (i & 1) * (N >> 1);
  Inv = power(N, MOD - 2);
  int half = N >> 1;
  for (int i = 0; i < half; i++) {
    wn[0][i + half] = power(G, (MOD + 1) * i / N);
    wn[1][i + half] = power((MOD + 1) / G, (MOD + 1) * i / N);
  }
  for (int i = half - 1; i >= 0; i--) {
    wn[0][i] = wn[0][i << 1];
    wn[1][i] = wn[1][i << 1];
  }
}
void NTT(vector<long long> &v, int inv) {
  v.resize(N);
  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 j = 0; j < N; j += (i << 1)) {
      vector<long long>::iterator l = v.begin() + j, r = v.begin() + j + i;
      long long *w = wn[inv == -1] + i, A;
      for (int k = 0; k < i; k++, l++, r++, w++) {
        A = *w * *r;
        *r = (*l - A) % MOD;
        *l = (*l + A) % MOD;
      }
    }
  if (inv == -1) {
    for (int i = 0; i < N; i++) (v[i] *= Inv) %= MOD;
  }
}
vector<long long> mul(vector<long long> A, vector<long long> B) {
  int l = A.size() + B.size() - 1;
  init(l);
  NTT(A, 1);
  NTT(B, 1);
  for (int i = 0; i < N; i++) (A[i] *= B[i]) %= MOD;
  NTT(A, -1);
  A.resize(l);
  return A;
}
vector<long long> INV(vector<long long> A) {
  int l = A.size();
  if (l == 1) {
    A[0] = power(A[0], MOD - 2);
    return A;
  }
  vector<long long> a = A;
  a.resize((l + 1) >> 1);
  vector<long long> b = INV(a);
  init(l << 1 | 1);
  NTT(A, 1);
  NTT(b, 1);
  for (int i = 0; i < N; i++) A[i] = (2 - A[i] * b[i] % MOD) * b[i] % MOD;
  NTT(A, -1);
  A.resize(l);
  return A;
}
vector<long long> DER(vector<long long> A) {
  int l = A.size();
  for (int i = 0; i < l - 1; i++) A[i] = A[i + 1] * (i + 1) % MOD;
  A.pop_back();
  return A;
}
vector<long long> DIF(vector<long long> A) {
  int l = A.size();
  if (!l)
    A.push_back(0);
  else
    A.push_back(A.back() * fac[l - 1] % MOD * inv[l] % MOD);
  for (int i = l - 1; i >= 1; i--)
    A[i] = A[i - 1] * fac[i - 1] % MOD * inv[i] % MOD;
  A[0] = 0;
  return A;
}
vector<long long> LN(vector<long long> A) {
  int l = A.size();
  A = DIF(mul(DER(A), INV(A)));
  A.resize(l);
  return A;
}
vector<long long> EXP(vector<long long> A) {
  int l = A.size();
  if (l == 1) {
    A[0] = 1;
    return A;
  }
  vector<long long> a = A;
  a.resize((l + 1) >> 1);
  vector<long long> b = EXP(a);
  b.resize(l);
  vector<long long> lnb = LN(b);
  init(l << 1 | 1);
  NTT(A, 1);
  NTT(b, 1);
  NTT(lnb, 1);
  for (int i = 0; i < N; i++) A[i] = (1 - lnb[i] + A[i]) * b[i] % MOD;
  NTT(A, -1);
  A.resize(l);
  return A;
}
vector<long long> POW(vector<long long> A, long long b) {
  int l = A.size();
  A = LN(A);
  for (int i = 0; i < l; i++) (A[i] *= b) %= MOD;
  return EXP(A);
}
int main() {
  scanf("%d%d", &n, &m);
  vector<long long> F;
  INIT(m);
  F.resize(m + 1);
  for (int a, i = 1; i <= n; i++) {
    scanf("%d", &a);
    if (a <= m) F[a] = -4;
  }
  F[0]++;
  F = POW(F, (MOD + 1) >> 1);
  F[0]++;
  F = INV(F);
  for (int i = 1; i <= m; i++) printf("%lld\n", (F[i] + MOD) * 2 % MOD);
  return 0;
}