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 int N = 1 << 20;
const int mod = 998244353;
const int inv2 = (mod + 1) / 2;
const int G = 3;
const int invG = (mod + 1) / G;
inline long long fastpow(long long a, int b) {
  long long r = 1ll;
  for (; b; b >>= 1, (a *= a) %= mod)
    if (b & 1) (r *= a) %= mod;
  return r;
}
namespace NTT {
int rev[N];
inline void initRev(int n) {
  for (int i = 0; i < n; i++)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) ? (n >> 1) : 0);
}
inline void NTT(long long* f, int n, bool flag) {
  for (int i = 0; i < n; i++)
    if (i < rev[i]) std::swap(f[i], f[rev[i]]);
  for (int p = 2, q = 1; p <= n; q = (p <<= 1) >> 1) {
    long long rot = fastpow(flag ? invG : G, (mod - 1) / p);
    for (int i = 0; i < n; i += p) {
      long long cur = 1;
      for (int j = i; j < i + q; j++, (cur *= rot) %= mod) {
        long long tmp = f[j + q] * cur % mod;
        f[j + q] = (f[j] - tmp + mod) % mod, f[j] = (f[j] + tmp) % mod;
      }
    }
  }
  if (flag) {
    long long inv = fastpow(n, mod - 2);
    for (int i = 0; i < n; i++) (f[i] *= inv) %= mod;
  }
}
}  // namespace NTT
namespace FacInv {
long long fact[N], ifac[N], inv[N];
inline void prework(int n) {
  fact[0] = fact[1] = ifac[0] = ifac[1] = inv[0] = inv[1] = 1ll;
  for (int i = 2; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
  ifac[n] = fastpow(fact[n], mod - 2);
  for (int i = n - 1; i > 1; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
  for (int i = 2; i <= n; i++) inv[i] = inv[mod % i] * (mod - mod / i) % mod;
}
}  // namespace FacInv
using FacInv::fact;
using FacInv::ifac;
using FacInv::inv;
namespace Poly {
void polyInv(long long* f, long long* g, int n) {
  if (n == 1) {
    g[0] = fastpow(f[0], mod - 2);
    return;
  }
  polyInv(f, g, (n + 1) >> 1);
  int L = 1;
  while (L < (n * 3)) L <<= 1;
  static long long h[N];
  memcpy(h, f, n << 3);
  NTT::initRev(L), NTT::NTT(g, L, 0), NTT::NTT(h, L, 0);
  for (int i = 0; i < L; i++) (g[i] *= 2 - g[i] * h[i] % mod + mod) %= mod;
  NTT::NTT(g, L, 1), memset(g + n, 0, (L - n) << 3);
  memset(h, 0, L << 3);
}
void polyInt(long long* f, long long* g, int n) {
  for (int i = 1; i < n; i++) g[i] = f[i - 1] * inv[i] % mod;
  g[0] = 0;
}
void polyDer(long long* f, long long* g, int n) {
  for (int i = 1; i < n; i++) g[i - 1] = f[i] * i % mod;
  g[n - 1] = 0;
}
void polyLn(long long* f, long long* g, int n) {
  static long long h[N], p[N];
  int L = 1;
  while (L < (n << 1)) L <<= 1;
  polyDer(f, h, n), polyInv(f, p, n);
  NTT::initRev(L), NTT::NTT(h, L, 0), NTT::NTT(p, L, 0);
  for (int i = 0; i < L; i++) (h[i] *= p[i]) %= mod;
  NTT::NTT(h, L, 1), polyInt(h, g, n);
  memset(h, 0, L << 3), memset(p, 0, L << 3);
}
void polyExp(long long* f, long long* g, int n) {
  if (n == 1) {
    g[0] = 1;
    return;
  }
  polyExp(f, g, (n + 1) >> 1);
  int L = 1;
  while (L < (n << 1)) L <<= 1;
  static long long h[N];
  polyLn(g, h, n);
  for (int i = 0; i < n; i++) h[i] = (f[i] - h[i] + mod) % mod;
  h[0]++, NTT::initRev(L), NTT::NTT(h, L, 0), NTT::NTT(g, L, 0);
  for (int i = 0; i < L; i++) (g[i] *= h[i]) %= mod;
  NTT::NTT(g, L, 1), memset(g + n, 0, (L - n) << 3);
  memset(h, 0, L << 3);
}
void polySqrt(long long* f, long long* g, int n) {
  if (n == 1) {
    g[0] = 1;
    return;
  }
  polySqrt(f, g, (n + 1) >> 1);
  int L = 1;
  while (L < (n << 1)) L <<= 1;
  static long long h[N], p[N];
  polyInv(g, h, n);
  memcpy(p, f, n << 3);
  NTT::initRev(L), NTT::NTT(h, L, 0), NTT::NTT(p, L, 0);
  for (int i = 0; i < L; i++) (h[i] *= p[i]) %= mod;
  NTT::NTT(h, L, 1);
  for (int i = 0; i < n; i++) h[i] = (h[i] + g[i]) * inv2 % mod;
  memcpy(g, h, n << 3);
  memset(h, 0, L << 3), memset(p, 0, L << 3);
}
void polyPower(long long* f, long long* g, int n, long long k) {
  static long long h[N];
  polyLn(f, h, n), k %= mod;
  for (int i = 0; i < n; i++) (h[i] *= k) %= mod;
  memset(g, 0, n << 3), polyExp(h, g, n);
  memset(h, 0, n << 3);
}
}  // namespace Poly
long long f[N], g[N];
int n, m;
signed main() {
  FacInv::prework(N - 1);
  scanf("%d%d", &n, &m);
  for (int i = 1, c; i <= n; i++) scanf("%d", &c), g[c]++;
  for (int i = 0; i <= m; i++) g[i] = mod - 4 * g[i] % mod;
  g[0] = 1;
  Poly::polySqrt(g, f, m + 1);
  f[0]++;
  memset(g, 0, m + 1 << 3);
  Poly::polyInv(f, g, m + 1);
  for (int i = 1; i <= m; i++) printf("%lld\n", g[i] * 2 % mod);
  return 0;
}