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 long long N = 262150;
const long long mod = 998244353;
long long qpow(long long p, long long q) {
  return (q & 1 ? p : 1) * (q ? qpow(p * p % mod, q / 2) : 1) % mod;
}
namespace cipolla {
inline long long le(long long x) { return qpow(x, (mod - 1) / 2); }
long long w;
struct comp {
  long long x, y;
  comp(long long a = 0, long long b = 0) {
    x = a;
    y = b;
  }
};
comp operator+(comp a, comp b) {
  return comp((a.x + b.x) % mod, (a.y + b.y) % mod);
}
comp operator-(comp a, comp b) {
  return comp((a.x - b.x + mod) % mod, (a.y - b.y + mod) % mod);
}
comp operator*(comp a, comp b) {
  return comp((a.x * b.x + a.y * b.y % mod * w) % mod,
              (a.x * b.y + a.y * b.x) % mod);
}
comp operator^(comp a, long long b) {
  comp o(1, 0);
  for (; b; a = a * a, b >>= 1)
    if (b & 1) o = o * a;
  return o;
}
long long calc(long long x) {
  x %= mod;
  long long a;
  while (true) {
    a = rand();
    w = (a * a - x + mod) % mod;
    if (le(w) == mod - 1) break;
  }
  comp s = comp(a, 1) ^ ((mod + 1) / 2);
  return min(s.x, mod - s.x);
}
}  // namespace cipolla
namespace po {
long long rev[N], inv[N], w[N], sz;
void presolve(long long l) {
  long long len = 1;
  sz = 0;
  while (len < l) len <<= 1, ++sz;
  for (long long i = 1; i < len; i++) {
    inv[i] = (i == 1 ? 1 : inv[mod % i] * (mod - mod / i) % mod);
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (sz - 1));
  }
  long long wn = qpow(3, (mod - 1) / len);
  w[len / 2] = 1;
  for (long long i = len / 2 + 1; i < len; i++) w[i] = w[i - 1] * wn % mod;
  for (long long i = len / 2 - 1; i; i--) w[i] = w[i << 1];
}
long long pre(long long l) {
  long long g;
  for (g = 1; g < l; g <<= 1)
    ;
  return g;
}
void ntt(long long *a, long long o, long long n) {
  static unsigned long long s[N];
  long long t = sz - __builtin_ctz(n), x;
  for (long long i = 0; i < n; i++) s[rev[i] >> t] = a[i];
  for (long long l = 1; l < n; l <<= 1)
    for (long long i = 0; i < n; i += l << 1)
      for (long long j = 0; j < l; j++) {
        x = s[i + j + l] * w[j + l] % mod;
        s[i + j + l] = s[i + j] + mod - x;
        s[i + j] += x;
      }
  for (long long i = 0; i < n; i++) a[i] = s[i] % mod;
  if (o) {
    x = qpow(n, mod - 2);
    for (long long i = 0; i < n; i++) a[i] = a[i] * x % mod;
    reverse(a + 1, a + n);
  }
}
void mult(long long n, long long *x, long long *y, long long *z) {
  static long long a[N], b[N];
  long long l = pre(n << 1);
  for (long long i = 0; i < l; i++) {
    a[i] = (i < n ? x[i] : 0);
    b[i] = (i < n ? y[i] : 0);
  }
  ntt(a, 0, l);
  ntt(b, 0, l);
  for (long long i = 0; i < l; i++) z[i] = a[i] * b[i] % mod;
  ntt(z, 1, l);
  for (long long i = n; i < l; i++) z[i] = 0;
}
void inve(long long len, long long *a, long long *b) {
  if (len == 1)
    *b = qpow(*a, mod - 2);
  else {
    inve((len + 1) / 2, a, b);
    static long long c[N];
    long long n = pre(len << 1);
    for (long long i = 0; i < n; i++) i < len ? c[i] = a[i] : b[i] = c[i] = 0;
    ntt(b, 0, n);
    ntt(c, 0, n);
    for (long long i = 0; i < n; i++)
      b[i] = ((b[i] + b[i] - b[i] * b[i] % mod * c[i]) % mod + mod) % mod;
    ntt(b, 1, n);
    for (long long i = len; i < n; i++) b[i] = 0;
  }
}
void sqrt(long long n, long long *a, long long *b) {
  if (n == 1)
    *b = cipolla::calc(*a);
  else {
    sqrt((n + 1) / 2, a, b);
    static long long c[N];
    inve(n, b, c);
    mult(n, a, c, c);
    for (long long i = 0; i < n; i++) b[i] = (b[i] + c[i]) * inv[2] % mod;
  }
}
void deri(long long n, long long *a, long long *b) {
  for (long long i = 0; i < n - 1; i++) b[i] = a[i + 1] * (i + 1) % mod;
  b[n - 1] = 0;
}
void inte(long long n, long long *a, long long *b) {
  for (long long i = n - 1; i > 0; --i) b[i] = a[i - 1] * inv[i] % mod;
  b[0] = 0;
}
void loge(long long n, long long *a, long long *b) {
  static long long c[N];
  inve(n, a, b);
  deri(n, a, c);
  mult(n, b, c, b);
  inte(n, b, b);
}
void expr(long long n, long long *a, long long *b) {
  if (n == 1)
    *b = 1;
  else {
    expr((n + 1) / 2, a, b);
    static long long c[N];
    loge(n, b, c);
    for (long long i = 0; i < n; i++) c[i] = (a[i] - c[i] + mod) % mod;
    c[0] = (c[0] + 1) % mod;
    mult(n, b, c, b);
  }
}
}  // namespace po
long long n, k, m, a[N], b[N], c[N];
signed main() {
  ios::sync_with_stdio(false);
  cin >> n >> m;
  po::presolve((m + 2) << 1);
  long long tmp;
  for (long long i = 1; i <= n; i++) cin >> tmp, c[tmp]++;
  for (long long i = 1; i <= m; i++) c[i] = ((-4 * c[i]) % mod + mod) % mod;
  ++m;
  c[0] = 1;
  po::sqrt(m, c, b);
  b[0]++;
  po::inve(m, b, a);
  for (long long i = 0; i <= m; i++) a[i] = 2 * a[i] % mod;
  for (long long i = 1; i < m; i++) cout << a[i] << endl;
}