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>
const int maxl = 1024 * 256, P = 998244353, G0 = 3, G1 = (P + 1) / G0;
long long power(long long a, long long b) {
  long long ret = 1;
  while (b) {
    if (b & 1) ret = ret * a % P;
    a = a * a % P;
    b >>= 1;
  }
  return ret;
}
struct MUL {
  int lim, len, mp[maxl];
  long long X[maxl], Y[maxl];
  void init(int l) {
    lim = 1;
    len = -1;
    while (lim <= l) {
      lim <<= 1;
      ++len;
    }
    for (int i = 1; i < lim; ++i) mp[i] = (mp[i >> 1] >> 1) | ((i & 1) << len);
  }
  void ntt(long long S[maxl], int op) {
    for (int i = 1; i < lim; ++i)
      if (i < mp[i]) {
        long long t = S[i];
        S[i] = S[mp[i]];
        S[mp[i]] = t;
      }
    for (int i = 1; i < lim; i <<= 1) {
      int wn = power(op > 0 ? G0 : G1, (P - 1) / (i << 1));
      for (int j = 0; j < lim; j += (i << 1)) {
        long long w = 1;
        for (int k = 0; k < i; ++k, w = w * wn % P) {
          long long x = S[j + k], y = S[i + j + k] * w % P;
          S[j + k] = (x + y) % P;
          S[i + j + k] = (x - y + P) % P;
        }
      }
    }
    if (op < 0) {
      long long inv = power(lim, P - 2);
      for (int i = 0; i < lim; ++i) S[i] = S[i] * inv % P;
    }
  }
  void operator()(int n, int m, long long S[maxl], long long T[maxl],
                  long long R[maxl]) {
    init(n + m);
    for (int i = 0; i <= n; ++i) X[i] = S[i];
    for (int i = n + 1; i < lim; ++i) X[i] = 0;
    for (int i = 0; i <= m; ++i) Y[i] = T[i];
    for (int i = m + 1; i < lim; ++i) Y[i] = 0;
    ntt(X, 1);
    ntt(Y, 1);
    for (int i = 0; i < lim; ++i) X[i] = X[i] * Y[i] % P;
    ntt(X, -1);
    for (int i = 0; i <= n + m; ++i) R[i] = X[i];
    for (int i = n + m + 1; i < maxl; ++i) R[i] = 0;
  }
} mul;
struct INV {
  long long X[2][maxl];
  void operator()(int n, long long S[maxl], long long T[maxl]) {
    int lim = 1, cur = 0;
    X[cur][0] = power(S[0], P - 2);
    while (lim <= n) {
      cur ^= 1;
      for (int i = 0; i < lim; ++i) X[cur][i] = 2 * X[cur ^ 1][i] % P;
      for (int i = lim; i < (lim << 1); ++i) X[cur][i] = 0;
      mul(lim - 1, lim - 1, X[cur ^ 1], X[cur ^ 1], X[cur ^ 1]);
      lim <<= 1;
      mul(lim - 1, lim - 1, X[cur ^ 1], S, X[cur ^ 1]);
      for (int i = 0; i < lim; ++i)
        X[cur][i] = (X[cur][i] - X[cur ^ 1][i] + P) % P;
    }
    for (int i = 0; i <= n; ++i) T[i] = X[cur][i];
    for (int i = n + 1; i < maxl; ++i) T[i] = 0;
  }
} inv;
long long A[maxl], B[maxl], F[2][maxl];
void meow(int m) {
  int lim = 1, cur = 0;
  F[cur][0] = 1;
  while (lim <= m) {
    cur ^= 1;
    mul(lim - 1, (lim << 1) - 1, F[cur ^ 1], A, B);
    mul(lim - 1, (lim << 1) - 1, F[cur ^ 1], B, F[cur]);
    lim <<= 1;
    for (int i = 0; i < lim; ++i) B[i] = B[i] * 2 % P;
    B[0] = (B[0] - 1 + P) % P;
    inv(lim - 1, B, B);
    F[cur][0] = (F[cur][0] - 1 + P) % P;
    mul(lim - 1, lim - 1, B, F[cur], F[cur]);
  }
  for (int i = 1; i <= m; ++i) printf("%lld\n", F[cur][i]);
}
int main() {
  int n, m, t;
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &t);
    ++A[t];
  }
  meow(m);
  return 0;
}