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 D = 23, C = 7 * 17, mod = C * (1 << D) + 1, G = 3, N = 262200;
inline long long power(long long x, long long y) {
  long long t = 1;
  for (; y; y >>= 1, x = x * x % mod)
    if (y & 1) t = t * x % mod;
  return t;
}
struct FFT_transform {
  int n, l;
  long long g;
  void setl(int len) {
    for (l = 0; (1 << l) < len * 2; ++l)
      ;
    n = 1 << l;
    g = power(G, C * (1 << (D - l)));
  }
  int rebit(int x) {
    int y = 0;
    for (int i = 0; i < l; ++i)
      if (x & (1 << i)) y |= 1 << (l - 1 - i);
    return y;
  }
  void DFT_inplace(long long *t, int sign) {
    for (int i = 0; i < n; ++i)
      if (i < rebit(i)) swap(t[i], t[rebit(i)]);
    for (int i = 1; i <= l; ++i) {
      int d = 1 << i;
      long long g1 = power(sign == 1 ? g : power(g, n - 1), 1 << (l - i));
      for (int j = 0; j < n; j += d) {
        long long w = 1;
        for (int k = j; k < j + d / 2; ++k) {
          long long t1 = t[k], t2 = t[k + d / 2] * w % mod;
          t[k] = (t1 + t2) % mod;
          t[k + d / 2] = (t1 - t2 + mod) % mod;
          w = w * g1 % mod;
        }
      }
    }
    if (sign == -1) {
      long long rn = power(n, mod - 2);
      for (int i = 0; i < n; ++i) t[i] = t[i] * rn % mod;
    }
  }
  void FFT1(long long *a, long long *b, long long *c, int h) {
    DFT_inplace(a, 1);
    if (a != b) DFT_inplace(b, 1);
    if (a != c && b != c) DFT_inplace(c, 1);
    for (int i = 0; i < n; ++i) a[i] = a[i] * b[i] % mod * c[i] % mod;
    DFT_inplace(a, -1);
    for (int i = h; i < n; ++i) a[i] = 0ll;
    fill(b, b + n, 0ll);
    fill(c, c + n, 0ll);
  }
} calc;
int n, m;
long long f[N] = {}, g[N] = {}, a[N] = {}, b[N] = {}, c[N] = {};
void work(int l, int r) {
  if (l == r) return;
  int mid = (l + r) >> 1;
  work(l, mid);
  calc.setl(r - l + 1);
  copy(f + l, f + mid + 1, a);
  if (l) {
    copy(f, f + r - l + 1, b);
    for (int i = 0; i <= r - l; ++i) b[i] = b[i] * 2 % mod;
  } else
    copy(f, f + mid - l + 1, b);
  copy(g, g + r - l + 1, c);
  calc.FFT1(a, b, c, r - l + 1);
  for (int i = mid + 1; i <= r; ++i) f[i] = (f[i] + a[i - l]) % mod;
  fill(a, a + r - l + 1, 0ll);
  work(mid + 1, r);
}
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1, x = 0; i <= n; ++i) {
    scanf("%d", &x);
    ++g[x];
  }
  f[0] = 1;
  work(0, m);
  for (int i = 1; i <= m; ++i) printf("%d\n", (int)f[i]);
  return 0;
}