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;
static const int M = 131072 << 1;
static const int P = 998244353;
static const int inv2 = 499122177;
static const int groot = 3;
int Fast(int cnt, int x) {
  int res = 1;
  while (cnt) {
    if (cnt & 1) res = 1ll * res * x % P;
    cnt >>= 1;
    x = 1ll * x * x % P;
  }
  return res;
}
int len[M], lg[M], rev[M];
void fourier(int *atom, int n, int type) {
  for (int i = 0; i < n; ++i)
    if (i < rev[i]) swap(atom[i], atom[rev[i]]);
  for (int i = 2, m, wn, j, k, w, u, v; i <= n; i <<= 1) {
    m = i >> 1;
    wn = Fast(P - 1 + type * (P - 1) / i, groot);
    for (j = 0; j < n; j += i) {
      for (w = 1, k = 0; k < m; ++k) {
        u = atom[j + k], v = 1ll * atom[j + k + m] * w % P;
        atom[j + k] = (u + v) % P;
        atom[j + k + m] = (u - v) % P;
        w = 1ll * w * wn % P;
      }
    }
  }
  if (type < 0) {
    for (int i = 0, v = Fast(P - 2, n); i < n; ++i) {
      if (atom[i] < 0) atom[i] += P;
      atom[i] = 1ll * atom[i] * v % P;
    }
  }
}
void inverse(int *atom, int *goal, int n) {
  static int dup[M];
  if (n == 1) {
    goal[0] = Fast(P - 2, atom[0]);
    return;
  }
  int m = 1 + n >> 1;
  inverse(atom, goal, m);
  int sz = len[m - 1 + m - 1 + n - 1], h = lg[m - 1 + m - 1 + n - 1];
  memcpy(dup, atom, n << 2);
  memset(dup + n, 0, (sz - n) << 2);
  memset(goal + m, 0, (sz - m) << 2);
  for (int i = 1; i < sz; ++i)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (h - 1));
  fourier(goal, sz, 1);
  fourier(dup, sz, 1);
  for (int i = 0; i < sz; ++i)
    goal[i] = goal[i] * (2ll - 1ll * goal[i] * dup[i] % P) % P;
  fourier(goal, sz, -1);
}
void square(int *atom, int *goal, int n) {
  static int inv[M], dup[M];
  if (n == 1) {
    goal[0] = 1;
    return;
  }
  int m = 1 + n >> 1;
  square(atom, goal, m);
  int sz = len[n - 1 + n - 1], h = lg[n - 1 + n - 1];
  memset(goal + m, 0, (n - m) << 2);
  inverse(goal, inv, n);
  memcpy(dup, atom, n << 2);
  for (int i = 1; i < sz; ++i)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (h - 1));
  memset(dup + n, 0, (sz - n) << 2);
  memset(inv + n, 0, (sz - n) << 2);
  fourier(dup, sz, 1);
  fourier(inv, sz, 1);
  for (int i = 0; i < sz; ++i) dup[i] = 1ll * dup[i] * inv[i] % P;
  fourier(dup, sz, -1);
  for (int i = 0; i < n; ++i) goal[i] = 1ll * inv2 * (goal[i] + dup[i]) % P;
}
int f[M], h[M], tmp[M];
int main() {
  int n, m;
  scanf("%d%d", &n, &m);
  for (int i = 1, x; i <= n; ++i) {
    scanf("%d", &x);
    h[x] = 1;
  }
  len[0] = 1;
  for (int i = 1; i < M; ++i) {
    len[i] = len[i >> 1] << 1;
    lg[i] = lg[i >> 1] + 1;
  }
  ++m;
  for (int i = 0; i < m; ++i)
    if (h[i]) h[i] = P - 4;
  ++h[0];
  square(h, tmp, m);
  ++tmp[0];
  if (tmp[0] >= P) tmp[0] -= P;
  inverse(tmp, f, m);
  for (int i = 0; i < m; ++i) f[i] = (f[i] << 1) % P;
  for (int i = 1; i < m; ++i) printf("%d\n", f[i]);
  return 0;
}