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>
const long long mod = 998244353, g = 3, maxn = 1e6 + 9;
inline long long Read() {
  long long x(0), f(1);
  char c = getchar();
  while (c < '0' || c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    x = (x << 3) + (x << 1) + c - '0';
    c = getchar();
  }
  return x * f;
}
long long r[maxn], F[maxn];
inline long long Fir(long long n) {
  long long limit(1), len(0);
  while (limit < (n << 1)) {
    limit <<= 1;
    ++len;
  }
  for (long long i = 0; i < limit; ++i)
    r[i] = (r[i >> 1] >> 1) | ((i & 1) << len - 1);
  return limit;
}
inline long long Pow(long long base, long long b) {
  long long ret(1);
  while (b) {
    if (b & 1) ret = ret * base % mod;
    base = base * base % mod;
    b >>= 1;
  }
  return ret;
}
inline void NTT(long long *a, long long n, long long type) {
  for (long long i = 0; i < n; ++i)
    if (i < r[i]) std::swap(a[i], a[r[i]]);
  for (long long mid = 1; mid < n; mid <<= 1) {
    long long wn(Pow(g, (mod - 1) / (mid << 1)));
    if (type == -1) wn = Pow(wn, mod - 2);
    for (long long R = mid << 1, j = 0; j < n; j += R)
      for (long long k = 0, w = 1; k < mid; ++k, w = w * wn % mod) {
        long long x(a[j + k]), y(w * a[j + mid + k] % mod);
        a[j + k] = (x + y) % mod;
        a[j + mid + k] = (x - y + mod) % mod;
      }
  }
  if (type == -1) {
    long long ty(Pow(n, mod - 2));
    for (long long i = 0; i < n; ++i) a[i] = a[i] * ty % mod;
  }
}
void Solve_inv(long long deg, long long *a, long long *ans) {
  if (deg == 1) {
    ans[0] = Pow(a[0], mod - 2);
    return;
  }
  Solve_inv(deg + 1 >> 1, a, ans);
  for (long long i = 0; i < deg; ++i) F[i] = a[i];
  long long limit(Fir(deg));
  for (long long i = deg; i < limit; ++i) F[i] = 0;
  NTT(ans, limit, 1);
  NTT(F, limit, 1);
  for (long long i = 0; i < limit; ++i)
    ans[i] = (2ll - F[i] * ans[i] % mod + mod) % mod * ans[i] % mod;
  NTT(ans, limit, -1);
  for (long long i = deg; i < limit; ++i) ans[i] = 0;
}
long long _B[maxn], IB[maxn];
void Solve_kf(long long deg, long long *a, long long *ans) {
  if (deg == 1) {
    ans[0] = sqrt(a[0]);
    return;
  }
  Solve_kf(deg + 1 >> 1, a, ans);
  long long limit(Fir(deg));
  for (long long i = 0; i < deg; ++i) _B[i] = ans[i] * 2 % mod;
  for (long long i = deg; i < limit; ++i) _B[i] = 0;
  for (long long i = 0; i < limit; ++i) IB[i] = 0;
  Solve_inv(deg, _B, IB);
  limit = Fir(deg);
  for (long long i = 0; i < deg; ++i) F[i] = a[i];
  for (long long i = deg; i < limit; ++i) F[i] = 0;
  NTT(IB, limit, 1);
  NTT(ans, limit, 1);
  NTT(F, limit, 1);
  for (long long i = 0; i < limit; ++i)
    ans[i] = (F[i] + ans[i] * ans[i] % mod) % mod * IB[i] % mod;
  NTT(ans, limit, -1);
  for (long long i = deg; i < limit; ++i) ans[i] = 0;
}
long long n, m, N;
long long C[maxn], ans[maxn], ans2[maxn];
int main() {
  n = Read();
  m = Read();
  for (long long i = 1; i <= n; ++i) {
    long long val(Read());
    C[val] = 1ll;
  }
  N = m + 1ll;
  long long limit;
  for (long long i = 0; i < N; ++i) C[i] = C[i] * 4ll % mod;
  for (long long i = 0; i < N; ++i) C[i] = (mod - C[i]) % mod;
  C[0] = 1ll;
  Solve_kf(N, C, ans);
  limit = Fir(N);
  ans[0] = (ans[0] + 1ll) % mod;
  Solve_inv(N, ans, ans2);
  limit = Fir(N);
  NTT(ans2, limit, 1);
  for (long long i = 0; i < limit; ++i) ans2[i] = ans2[i] * 2ll % mod;
  NTT(ans2, limit, -1);
  for (long long i = 1; i < N; ++i) printf("%lld\n", ans2[i]);
  return 0;
}