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 = 6e5 + 5, mod = 998244353;
inline int read() {
  register char ch = getchar();
  register int f = 0;
  register long long x = 0;
  while (!isdigit(ch)) f |= (ch == '-'), ch = getchar();
  while (isdigit(ch))
    x = ((x << 1) + (x << 3) + (ch ^ 48)) % mod, ch = getchar();
  return f ? mod - x : x;
}
inline int ksm(int a, long long b) {
  int ans = 1;
  while (b) {
    if (b & 1) ans = 1ll * a * ans % mod;
    b >>= 1;
    a = 1ll * a * a % mod;
  }
  return ans;
}
int G = 3, Gn = ksm(G, mod - 2);
int f[N], g[N], n, k, g4[N], gsq[N], invg[N];
inline void fwt_or(int *f, int lim, int flag) {
  for (int l = 2; l <= lim; l <<= 1)
    for (int m = l >> 1, j = 0; j < lim; j += l)
      for (int i = j; i < j + m; ++i) (f[j + m] += flag * f[j]) %= mod;
}
inline void fwt_and(int *f, int lim, int flag) {
  for (int l = 2; l <= lim; l <<= 1)
    for (int m = l >> 1, j = 0; j < lim; j += l)
      for (int i = j; i < j + m; ++i) (f[j] += flag * f[j + m]) %= mod;
}
const int inv2 = ksm(2, mod - 2);
inline void fwt_xor(int *f, int lim, int flag) {
  for (int l = 2; l <= lim; l <<= 1)
    for (int m = l >> 1, j = 0; j < lim; j += l)
      for (int i = j; i < j + m; ++i) {
        int x = f[i], y = f[i + m];
        f[i] = (x + y) % mod;
        f[i + m] = (x + mod - y) % mod;
        if (flag == -1) {
          f[i] = 1ll * f[i] * inv2 % mod;
          f[i + m] = 1ll * f[i] * inv2 % mod;
        }
      }
}
inline int get_phi(int x) {
  int len = sqrt(x);
  int res = 1;
  for (int i = 2; i <= len; ++i) {
    if (!(x % i)) {
      x /= i;
      res = 1ll * res * (i - 1) % mod;
      while (!(x % i)) x /= i, res = 1ll * res * i % mod;
    }
  }
  if (x != 1) res = 1ll * res * (x - 1) % mod;
  return res;
}
inline int find_root(int x) {
  int phi = get_phi(x), p = phi;
  int len = sqrt(phi);
  static int s[N], cnt;
  cnt = 0;
  for (int i = 2; i <= len; ++i) {
    if (!(p % i)) {
      p /= i;
      s[++cnt] = i;
      while (!(p % i)) p /= i;
    }
  }
  if (p != 1) s[++cnt] = p;
  for (int i = 1; i <= cnt; ++i) cout << s[i] << " ";
  cout << endl;
  cout << phi << endl;
  for (int i = 2; i <= mod - 1; ++i) {
    int flag = 0;
    for (int j = 1; j <= cnt; ++j)
      if (ksm(i, phi / s[j]) == 1) {
        flag = 1;
        break;
      }
    if (!flag) return i;
  }
}
int fac[N], ifac[N];
inline void get_fac(int n) {
  fac[0] = ifac[0] = 1;
  for (int i = 1; i <= n; ++i) {
    fac[i] = 1ll * fac[i - 1] * i % mod;
    ifac[i] = 1ll * ifac[i - 1] * fac[i] % mod;
  }
  int inv = ksm(ifac[n], mod - 2);
  for (int i = n; i >= 1; --i) {
    ifac[i] = 1ll * ifac[i - 1] * inv % mod;
    inv = 1ll * fac[i] * inv % mod;
  }
}
struct FFT {
  int A[N], B[N], c[N], b2[N], bb[N], ib2[N], sa[N], rev[N];
  inline void NTT(int *a, int lim, int len, int flag) {
    for (int i = 1; i <= lim - 1; ++i)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (len - 1));
    for (int i = 1; i <= lim - 1; ++i)
      if (rev[i] > i) swap(a[i], a[rev[i]]);
    for (int l = 2; l <= lim; l <<= 1) {
      const int m = l >> 1, Gi = ksm(flag == 1 ? G : Gn, (mod + 1) / l);
      for (int j = 0; j < lim; j += l) {
        int g = 1;
        for (int i = j; i < j + m; ++i, g = 1ll * g * Gi % mod) {
          int x = a[i], y = 1ll * g * a[i + m] % mod;
          a[i] = (x + y) % mod;
          a[i + m] = (x + mod - y) % mod;
        }
      }
    }
  }
  inline void mul(int *a, int *b, int na, int nb, int *c) {
    int lim = 1, len = 0;
    while (lim <= na + nb) lim <<= 1, ++len;
    memcpy(A, a, (na + 1) * sizeof(int));
    memcpy(B, b, (nb + 1) * sizeof(int));
    fill(A + na + 1, A + lim, 0);
    fill(B + nb + 1, B + lim, 0);
    NTT(A, lim, len, 1);
    NTT(B, lim, len, 1);
    for (int i = 0; i <= lim - 1; ++i) A[i] = 1ll * A[i] * B[i] % mod;
    NTT(A, lim, len, -1);
    const int inv = ksm(lim, mod - 2);
    for (int i = 0; i <= na + nb; ++i) c[i] = 1ll * A[i] * inv % mod;
    fill(c + na + nb + 1, c + lim, 0);
  }
  inline void ni_ab(int *a, int *b, int n) {
    int lim = 1;
    while (lim <= n) lim <<= 1;
    b[0] = ksm(a[0], mod - 2);
    for (int xmod = 1, nlen = 2; xmod < lim; xmod <<= 1, ++nlen) {
      int nlim = xmod << 2;
      memcpy(B, b, xmod * sizeof(int));
      memcpy(A, a, (xmod << 1) * sizeof(int));
      fill(B + xmod, B + nlim, 0);
      fill(A + (xmod << 1), A + nlim, 0);
      NTT(A, nlim, nlen, 1);
      NTT(B, nlim, nlen, 1);
      for (int i = 0; i <= nlim - 1; ++i)
        A[i] =
            ((B[i] << 1) % mod + mod - 1ll * A[i] * B[i] % mod * B[i] % mod) %
            mod;
      NTT(A, nlim, nlen, -1);
      const int inv = ksm(nlim, mod - 2);
      for (int i = 0; i <= (xmod << 1) - 1; ++i) b[i] = 1ll * A[i] * inv % mod;
    }
    fill(b + n + 1, b + lim, 0);
  }
  inline void ln(int *a, int *b, int n) {
    int lim = 1, len = 0;
    while (lim <= n) lim <<= 1, ++len;
    for (int i = 0; i <= n - 1; ++i) bb[i] = 1ll * (i + 1) * a[i + 1] % mod;
    ni_ab(a, b2, n);
    mul(bb, b2, n - 1, n, b);
    for (int i = n; i >= 1; --i) b[i] = 1ll * b[i - 1] * ksm(i, mod - 2) % mod;
    b[0] = 0;
  }
  inline void sqrt(int *a, int *b, int n) {
    int lim = 1, len = 0;
    while (lim <= n) lim <<= 1, ++len;
    fill(b, b + lim, 0);
    fill(b2, b2 + lim, 0);
    b[0] = 1;
    for (int xmod = 1; xmod < lim; xmod <<= 1) {
      for (int i = 0; i <= xmod - 1; ++i) b2[i] = (b[i] << 1) % mod;
      ni_ab(b2, ib2, (xmod << 1) - 1);
      mul(b, b, xmod - 1, xmod - 1, bb);
      for (int i = 0; i <= (xmod << 1) - 1; ++i) bb[i] = (bb[i] + a[i]) % mod;
      mul(bb, ib2, (xmod << 1) - 1, (xmod << 1) - 1, b);
    }
  }
  inline void exp(int *a, int *b, int n) {
    int lim = 1;
    while (lim <= n) lim <<= 1;
    fill(b, b + lim, 0);
    b[0] = 1;
    for (int xmod = 1; xmod < lim; xmod <<= 1) {
      ln(b, ib2, (xmod << 1) - 1);
      for (int i = 0; i <= (xmod << 1) - 1; ++i)
        c[i] = (a[i] + mod - ib2[i]) % mod;
      c[0] = (c[0] + 1) % mod;
      mul(b, c, (xmod << 1) - 1, (xmod << 1) - 1, b);
    }
    fill(b + n + 1, b + lim, 0);
  }
  inline void pow(int *a, int *b, int n, int _k = k) {
    int lim = 1;
    while (lim <= n) lim <<= 1;
    ln(a, sa, n);
    for (int i = 0; i <= n; ++i) sa[i] = 1ll * sa[i] * _k % mod;
    exp(sa, b, n);
  }
} T;
int m;
signed main() {
  n = read();
  m = read();
  for (int i = 1; i <= n; ++i) g[read()] = 1;
  for (int i = 1; i <= m; ++i) g4[i] = 1ll * g[i] * (mod - 4) % mod;
  g4[0] = 1;
  T.sqrt(g4, invg, m);
  invg[0] = (invg[0] + 1) % mod;
  T.ni_ab(invg, f, m);
  for (int i = 1; i <= m; ++i) printf("%d\n", 1ll * f[i] * 2 % mod);
  return 0;
}