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 = 400005;
const long long MOD = 998244353;
const long long G = 3, Ginv = 332748118, Inv2 = 499122177;
template <typename T>
inline void read(T &a) {
  T x = 0, flag = 1;
  char ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') flag = -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = (x << 1) + (x << 3) + ch - '0';
    ch = getchar();
  }
  a = flag * x;
}
long long ksm(long long x, long long k) {
  long long ret = 1;
  while (k) {
    if (k & 1) ret = (ret * x) % MOD;
    x = (x * x) % MOD;
    k >>= 1;
  }
  return ret;
}
int N, M, rev[MAXN];
long long cnt[MAXN], ans[MAXN], A[MAXN], B[MAXN], C[MAXN], D[MAXN];
void NTT(long long *a, int len, int type) {
  for (int i = 0; i < len; ++i) {
    if (i < rev[i]) {
      swap(a[i], a[rev[i]]);
    }
  }
  for (int i = 1; i < len; i <<= 1) {
    int p = i << 1;
    long long wn = ksm((type == 1) ? G : Ginv, (MOD - 1) / p);
    for (int j = 0; j < len; j += p) {
      long long wnk = 1;
      for (int k = 0; k < i; ++k) {
        long long A1 = a[j + k], A2 = wnk * a[j + k + i] % MOD;
        a[j + k] = (A1 + A2) % MOD;
        a[j + k + i] = (A1 - A2 + MOD) % MOD;
        wnk = wnk * wn % MOD;
      }
    }
  }
  if (type == -1) {
    long long Ninv = ksm(len, MOD - 2);
    for (int i = 0; i < len; ++i) {
      a[i] = a[i] * Ninv % MOD;
    }
  }
}
void Inv(int n, long long *a, long long *b) {
  if (n == 1) {
    b[0] = ksm(a[0], MOD - 2);
    return;
  }
  Inv(n >> 1, a, b);
  int m = (n << 1), len, bit;
  for (len = 1, bit = 0; len < m; len <<= 1) ++bit;
  for (int i = 0; i < len; ++i) {
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
  }
  copy(a, a + n, C);
  fill(C + n, C + len, 0);
  NTT(b, len, 1);
  NTT(C, len, 1);
  for (int i = 0; i < len; ++i) {
    b[i] = ((long long)2 - C[i] * b[i] % MOD + MOD) % MOD * b[i] % MOD;
  }
  NTT(b, len, -1);
  fill(b + n, b + len, 0);
}
void Sqrt(int n, long long *a, long long *b) {
  if (n == 1) {
    b[0] = a[0];
    return;
  }
  Sqrt(n >> 1, a, b);
  Inv(n, b, D);
  int m = (n << 1), len, bit;
  for (len = 1, bit = 0; len < m; len <<= 1) ++bit;
  for (int i = 0; i < len; ++i) {
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
  }
  copy(a, a + n, C);
  fill(C + n, C + len, 0);
  NTT(D, len, 1);
  NTT(C, len, 1);
  for (int i = 0; i < len; ++i) {
    D[i] = D[i] * C[i] % MOD;
  }
  NTT(D, len, -1);
  for (int i = 0; i < n; ++i) {
    b[i] = (b[i] + D[i]) % MOD * Inv2 % MOD;
  }
  fill(D + 0, D + len, 0);
}
void solve() {
  read(N);
  read(M);
  for (int i = 1; i <= N; ++i) {
    int x;
    read(x);
    ++cnt[x];
  }
  int len = 1;
  while (len <= M) len <<= 1;
  for (int i = 0; i < len; ++i) {
    cnt[i] = (MOD - cnt[i] * 4) % MOD;
  }
  ++cnt[0];
  Sqrt(len, cnt, B);
  B[0] = (B[0] + 1) % MOD;
  Inv(len, B, A);
  for (int i = 1; i <= M; ++i) {
    printf("%lld\n", A[i] * 2 % MOD);
  }
}
int main() {
  solve();
  return 0;
}