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;
inline bool is_digit(int c) { return c >= '0' && c <= '9'; }
template <typename T>
inline void read(T &a) {
  int c = getchar();
  while (!is_digit(c)) c = getchar();
  a = c - '0';
  while (is_digit(c = getchar())) a = a * 10 + c - '0';
}
const int mod = 998244353, mod_root = 3;
inline void fmod(long long &a) {
  if (a >= mod) a -= mod;
}
inline long long pow(long long a, long long b) {
  a %= mod;
  long long ret = 1;
  for (; b; b >>= 1, a = a * a % mod)
    if (b & 1) ret = ret * a % mod;
  return ret;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
  if (!b) {
    x = 1, y = 0;
  } else {
    exgcd(b, a % b, y, x);
    y -= (a / b) * x;
  }
}
inline long long inv_num(long long a) { return pow(a, mod - 2); }
const int N = 2097152 + 5;
long long w_fwd[25], w_inv[25];
int b_inv[N];
inline void calc_w() {
  w_fwd[23] = pow(mod_root, 7 * 17);
  for (int i = 22; i >= 0; --i) w_fwd[i] = w_fwd[i + 1] * w_fwd[i + 1] % mod;
  w_inv[23] = inv_num(w_fwd[23]);
  for (int i = 22; i >= 0; --i) w_inv[i] = w_inv[i + 1] * w_inv[i + 1] % mod;
}
inline void calc_b_inv(int b) {
  for (int i = 1; i < (1 << b); ++i)
    b_inv[i] = b_inv[i >> 1] >> 1 | (i & 1) << (b - 1);
}
inline void fft(long long c[], int len, long long w1[25]) {
  for (int i = 0; i < len; ++i)
    if (i < b_inv[i]) swap(c[i], c[b_inv[i]]);
  for (int p = 0; (1 << p) < len; ++p)
    for (int i = 0, lp = 1 << p, lpp1 = lp << 1; i < len; i += lpp1) {
      long long w = 1;
      for (int j = i; j < i + lp; ++j, w = w * w1[p + 1] % mod) {
        long long a = c[j], b = c[j + lp] * w % mod;
        c[j] = (a + b) % mod;
        c[j + lp] = (a - b + mod) % mod;
      }
    }
}
inline void dft(long long c[], int len) { fft(c, len, w_fwd); }
inline void inv_dft(long long c[], int len) {
  fft(c, len, w_inv);
  long long il = inv_num(len);
  for (int i = 0; i < len; ++i) c[i] = c[i] * il % mod;
}
long long inv_poly_t1[N], inv_poly_t2[N];
inline void inv_poly(long long a[], long long b[], int len) {
  long long *t1 = inv_poly_t1, *t2 = inv_poly_t2;
  for (int i = 0; i < len; ++i) t1[i] = t2[i] = 0;
  t2[0] = inv_num(a[0]);
  for (int i = 0; (1 << i) < len; ++i) {
    int li = 1 << i, lip = li << 1, lipp = lip << 1;
    calc_b_inv(i + 2);
    for (int j = lip; j < lipp; ++j) t1[j] = 0;
    for (int j = 0; j < lip; ++j) t1[j] = a[j];
    dft(t1, lipp);
    dft(t2, lipp);
    for (int j = 0; j < lipp; ++j)
      t2[j] = (2 * t2[j] - t1[j] * t2[j] % mod * t2[j]) % mod;
    inv_dft(t2, lipp);
    for (int j = lip; j < lipp; ++j) t2[j] = 0;
  }
  for (int i = 0; i < len; ++i) b[i] = t2[i];
}
long long sqrt_poly_t1[N], sqrt_poly_t2[N], sqrt_poly_t3[N];
inline void sqrt_poly(long long a[], long long b[], int len) {
  long long *t1 = sqrt_poly_t1, *t2 = sqrt_poly_t2, *t3 = sqrt_poly_t3;
  if (a[0] != 1) throw "unsupported";
  b[0] = 1;
  for (int i = 0; (1 << i) < len; ++i) {
    int li = 1 << i, lip = li << 1, lipp = lip << 1;
    for (int j = 0; j < lip; ++j) t1[j] = a[j];
    for (int j = lip; j < lipp; ++j) t1[j] = 0;
    for (int j = 0; j < li; ++j) t2[j] = b[j];
    for (int j = li; j < lipp; ++j) t2[j] = 0;
    inv_poly(t2, t3, lip);
    calc_b_inv(i + 2);
    dft(t1, lipp);
    dft(t3, lipp);
    for (int j = 0; j < lipp; ++j) t1[j] = t1[j] * t3[j] % mod;
    inv_dft(t1, lipp);
    for (int j = 0; j < li; ++j) t1[j] = (t1[j] + b[j]) % mod;
    for (int j = 0; j < lip; ++j) b[j] = t1[j] * 499122177 % mod;
  }
}
int n, m;
long long main_t1[N], main_t2[N];
int main() {
  calc_w();
  scanf("%d%d", &n, &m);
  long long *t1 = main_t1, *t2 = main_t2;
  for (int i = 1; i <= n; ++i) {
    int cc;
    scanf("%d", &cc);
    ++t1[cc];
  }
  int b = 0;
  while ((1 << b) <= m) ++b;
  int len = 1 << b;
  for (int i = 1; i < len; ++i) t1[i] = (mod - t1[i] * 4 % mod) % mod;
  t1[0] = 1;
  for (int i = 0; i < len; ++i) t2[i] = 0;
  sqrt_poly(t1, t2, len);
  ++t2[0];
  for (int i = 0; i < len; ++i) t1[i] = 0;
  inv_poly(t2, t1, len);
  for (int i = 1; i <= m; ++i) printf("%I64d\n", (t1[i] * 2 % mod + mod) % mod);
  return 0;
}