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 MX = 500005;
const int mod = 998244353;
const int g = 3189;
const int inv2 = 998244354 / 2;
int c[MX], c4[MX], sc[MX], ic[MX], f[MX];
int qpow(int a, int b) {
  int as = 1;
  while (b) {
    if (b & 1) as = 1ll * as * a % mod;
    a = 1ll * a * a % mod;
    b >>= 1;
  }
  return as;
}
struct polynie {
  void NTT(int *a, int N, int op) {
    for (int i = 0, j = 0; i < N; ++i) {
      if (i < j) swap(a[i], a[j]);
      for (int l = N >> 1; (j ^= l) < l; l >>= 1)
        ;
    }
    for (int le = 2; le <= N; le <<= 1) {
      int md = le >> 1;
      int wn = qpow(g, (mod - 1) / le), w, x, y;
      if (op == -1) wn = qpow(wn, mod - 2);
      for (int i = 0; i < N; i += le) {
        int w = 1;
        for (int j = 0; j < md; ++j) {
          x = a[i + j];
          y = 1ll * w * a[i + j + md] % mod;
          a[i + j] = (x + y) % mod;
          a[i + j + md] = (x - y + mod) % mod;
          w = 1ll * w * wn % mod;
        }
      }
    }
  }
  void mult(int *a, int *b, int *c, int M) {
    int N = M;
    while (N > (N & -N)) N += (N & -N);
    NTT(a, N, 1);
    NTT(b, N, 1);
    memset(c, 0, sizeof(c));
    for (int i = (0); i < (N); ++i) c[i] = 1ll * a[i] * b[i] % mod;
    NTT(c, N, -1);
    int t = qpow(N, mod - 2);
    for (int i = (0); i < (N); ++i) c[i] = 1ll * c[i] * t % mod;
  }
  int qa[MX], qb[MX], qc[MX], qd[MX];
  void pqrt(int *a, int *b, int dg) {
    if (dg == 1) {
      b[0] = a[0];
      return;
    }
    pqrt(a, b, (dg + 1) >> 1);
    memset(qa, 0, sizeof(qa));
    memset(qb, 0, sizeof(qb));
    memset(qc, 0, sizeof(qc));
    memset(qd, 0, sizeof(qd));
    for (int i = (0); i < (dg); ++i) qa[i] = b[i];
    pinv(qa, qb, dg);
    for (int i = (0); i < (dg); ++i) qc[i] = a[i];
    mult(qc, qb, qd, dg + dg - 1);
    for (int i = (0); i < (dg); ++i) qd[i] = 1ll * (qd[i] + b[i]) * inv2 % mod;
    memset(b, 0, sizeof(b));
    for (int i = (0); i < (dg); ++i) b[i] = qd[i];
  }
  int ia[MX], ib[MX], ic[MX];
  void pinv(int *a, int *b, int dg) {
    if (dg == 1) {
      b[0] = qpow(a[0], mod - 2);
      return;
    }
    pinv(a, b, (dg + 1) >> 1);
    memset(ia, 0, sizeof(ia));
    memset(ib, 0, sizeof(ib));
    memset(ic, 0, sizeof(ic));
    for (int i = (0); i < (dg); ++i) ia[i] = a[i];
    for (int i = (0); i < (dg); ++i) ib[i] = b[i];
    int N = dg + dg - 1;
    while (N > (N & -N)) N += (N & -N);
    NTT(ia, N, 1);
    NTT(ib, N, 1);
    for (int i = (0); i < (N); ++i)
      ic[i] = 1ll * ib[i] * ((2 - 1ll * ib[i] * ia[i] % mod + mod) % mod) % mod;
    NTT(ic, N, -1);
    int t = qpow(N, mod - 2);
    memset(b, 0, sizeof(b));
    for (int i = (0); i < (dg); ++i) b[i] = 1ll * ic[i] * t % mod;
  }
} PLE;
int n, m, x;
int main() {
  scanf("%d%d", &n, &m);
  ++m;
  for (int i = (1); i <= (n); ++i) scanf("%d", &x), c4[x] = mod - 4;
  c4[0]++;
  PLE.pqrt(c4, sc, m);
  sc[0] = (sc[0] + 1) % mod;
  PLE.pinv(sc, ic, m);
  for (int i = (1); i < (m); ++i) printf("%d\n", 2ll * ic[i] % mod);
}