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;
template <class T>
inline void Read(T &x) {
  int f = 1;
  char t = getchar();
  while (t < '0' || t > '9') {
    if (t == '-') f = -1;
    t = getchar();
  }
  x = 0;
  while (t >= '0' && t <= '9') {
    x = x * 10 + t - '0';
    t = getchar();
  }
  x *= f;
}
template <class T>
inline void chkmin(T &x, T y) {
  if (x > y) x = y;
}
template <class T>
inline void chkmax(T &x, T y) {
  if (x < y) x = y;
}
const int maxs = 523123;
const int maxn = 100005;
const int modulo = 998244353;
const int root = 3;
int n;
int m;
long long c[maxs];
void input() {
  int x;
  Read(n);
  Read(m);
  for (int i = 1; i <= n; i++) {
    Read(x);
    c[x] = 1;
  }
}
long long fpm(long long x, long long k) {
  long long res = 1;
  while (k > 0) {
    if (k & 1) res = res * x % modulo;
    x = x * x % modulo;
    k >>= 1;
  }
  return res;
}
int rev[maxs];
long long bit[maxs];
long long inv2;
void init(int N, int L) {
  long long d = fpm(root, (modulo - 1) / N);
  bit[0] = 1ll;
  for (int i = 1; i <= N; i++) bit[i] = bit[i - 1] * d % modulo;
  for (int i = 0; i <= N; i++) rev[i] = rev[i >> 1] >> 1 | ((i & 1) << (L - 1));
}
void dft(long long *res, int flag, int N, int L) {
  long long x, y;
  init(N, L);
  for (int i = 0; i < N; i++) {
    if (rev[i] < i) {
      swap(res[i], res[rev[i]]);
    }
  }
  for (int k = 1; k < N; k <<= 1) {
    for (int s = 0; s < N; s += (k << 1)) {
      for (int i = 0; i < k; i++) {
        x = res[s + i], y = res[s + k + i];
        if (flag == 1)
          y = y * bit[N / (k << 1) * i] % modulo;
        else
          y = y * bit[N - N / (k << 1) * i] % modulo;
        res[s + i] = (x + y) % modulo;
        res[s + k + i] = (x - y + modulo) % modulo;
      }
    }
  }
  if (flag == -1) {
    long long invnow = fpm(N, modulo - 2);
    for (int i = 0; i < N; i++) {
      res[i] = res[i] * invnow % modulo;
    }
  }
}
void getinv(int n, long long *res, long long *result) {
  static long long tmp[maxs];
  if (n == 1) {
    result[0] = fpm(res[0], modulo - 2);
    return;
  }
  getinv((n + 1) >> 1, res, result);
  int N = 1;
  int L = 0;
  while (N < n * 2) N <<= 1, L++;
  for (int i = (n + 1) >> 1; i < N; i++) result[i] = 0;
  for (int i = 0; i < n; i++) tmp[i] = res[i];
  for (int i = n; i < N; i++) tmp[i] = 0;
  dft(result, 1, N, L);
  dft(tmp, 1, N, L);
  for (int i = 0; i < N; i++) {
    result[i] = 2ll * result[i] % modulo -
                result[i] * result[i] % modulo * tmp[i] % modulo;
    result[i] = (result[i] % modulo + modulo) % modulo;
  }
  dft(result, -1, N, L);
}
void getsqrt(int n, long long *res, long long *result) {
  static long long inv_root[maxs];
  if (n == 1) {
    result[0] = 1;
    return;
  }
  getsqrt((n + 1) >> 1, res, result);
  int N = 1;
  int L = 0;
  while (N < n * 2) N <<= 1, L++;
  for (int i = (n + 1) >> 1; i < N; i++) result[i] = 0;
  getinv(n, result, inv_root);
  for (int i = n; i < N; i++) inv_root[i] = 0;
  dft(inv_root, 1, N, L);
  dft(result, 1, N >> 1, L - 1);
  for (int i = 0; i < (N >> 1); i++) {
    result[i] = result[i] * result[i] % modulo;
  }
  dft(result, -1, N >> 1, L - 1);
  for (int i = 0; i < n; i++) {
    result[i] = (result[i] + res[i]) % modulo * inv2 % modulo;
  }
  dft(result, 1, N, L);
  for (int i = 0; i < N; i++) {
    result[i] = result[i] * inv_root[i] % modulo;
  }
  dft(result, -1, N, L);
}
void solve() {
  static long long inv[maxs];
  static long long res[maxs];
  inv2 = fpm(2, modulo - 2);
  c[0] = 1;
  for (int i = 1; i <= m; i++) {
    c[i] = -c[i] * 4;
    c[i] = (c[i] % modulo + modulo) % modulo;
  }
  getsqrt(m + 1, c, inv);
  inv[0] = inv[0] + 1;
  for (int i = 0; i <= m; i++) {
    inv[i] = inv[i] * inv2 % modulo;
  }
  getinv(m + 1, inv, res);
  for (int i = 1; i <= m; i++) {
    printf("%d\n", (int)res[i]);
  }
}
int main() {
  input();
  solve();
  return 0;
}