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 <typename T>
inline void read(T &x) {
  x = 0;
  T k = 1;
  char c = getchar();
  while (!isdigit(c)) {
    if (c == '-') k = -1;
    c = getchar();
  }
  while (isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  x *= k;
}
const int N = 500000;
const int p = 998244353;
const int g = 3;
inline int qpow(int a, int b) {
  int ans = 1, base = a;
  while (b) {
    if (b & 1) ans = 1ll * ans * base % p;
    base = 1ll * base * base % p;
    b >>= 1;
  }
  return ans;
}
inline void ntt(int *A, int len, bool opt = 1) {
  for (int i = 1, j = len >> 1, k; i < len - 1; ++i) {
    if (i < j) swap(A[i], A[j]);
    k = len >> 1;
    while (j >= k) {
      j -= k, k >>= 1;
    }
    if (j < k) j += k;
  }
  for (int i = 2; i <= len; i <<= 1) {
    int n = i >> 1, wn = qpow(g, (p - 1) / i);
    if (!opt) wn = qpow(wn, p - 2);
    for (int j = 0; j < len; j += i) {
      int w = 1;
      for (int k = 0; k < n; ++k, w = 1ll * w * wn % p) {
        int u = 1ll * A[j + k + n] * w % p;
        A[j + k + n] = (A[j + k] - u + p) % p;
        A[j + k] = (A[j + k] + u) % p;
      }
    }
  }
  if (!opt) {
    int inv = qpow(len, p - 2);
    for (int i = 0; i < len; ++i) A[i] = 1ll * A[i] * inv % p;
  }
}
int Tmp_mul1[N], Tmp_mul2[N];
inline void mul(int *A, int *B, int *C, int lenA, int lenB) {
  int len = 1, lenC = lenA + lenB - 1;
  while (len < lenC) len <<= 1;
  memcpy(Tmp_mul1, A, lenA << 2);
  memcpy(Tmp_mul2, B, lenB << 2);
  memset(Tmp_mul1 + lenA, 0, (len - lenA) << 2);
  memset(Tmp_mul2 + lenB, 0, (len - lenB) << 2);
  ntt(Tmp_mul1, len);
  ntt(Tmp_mul2, len);
  for (int i = 0; i < len; ++i) C[i] = 1ll * Tmp_mul1[i] * Tmp_mul2[i] % p;
  ntt(C, len, 0);
  memset(C + lenC, 0, (len - lenC) << 2);
}
int Tmp_inv[N];
inline void inverse(int *A, int *Inv, int len) {
  Inv[0] = qpow(A[0], p - 2);
  for (int i = 2; i <= len; i <<= 1) {
    memcpy(Tmp_inv, A, i << 2);
    memset(Tmp_inv + i, 0, i << 2);
    ntt(Inv, i << 1);
    ntt(Tmp_inv, i << 1);
    for (int k = 0; k < i << 1; ++k)
      Inv[k] = Inv[k] * (2 - 1ll * Inv[k] * Tmp_inv[k] % p + p) % p;
    ntt(Inv, i << 1, 0);
    memset(Inv + i, 0, i << 2);
  }
}
const int g2 = 499122177;
int Tmp_sqrt1[N], Tmp_sqrt2[N];
void sqrt(int *A, int *Sqrt, int len) {
  Sqrt[0] = 1;
  for (int i = 1; i <= len; i <<= 1) {
    for (int j = 0; j < i; ++j) Tmp_sqrt2[j] = 2ll * Sqrt[j] % p;
    memset(Tmp_sqrt1, 0, i << 2);
    inverse(Tmp_sqrt2, Tmp_sqrt1, i);
    for (int j = i; j < (i << 1); ++j) Tmp_sqrt1[j] = 0;
    memcpy(Tmp_sqrt2, A, i << 2);
    memset(Tmp_sqrt2 + i, 0, i << 2);
    mul(Tmp_sqrt1, Tmp_sqrt2, Tmp_sqrt1, i, i);
    for (int j = 0; j < (i << 1); ++j)
      Sqrt[j] = (1ll * g2 * Sqrt[j] + Tmp_sqrt1[j]) % p;
  }
}
int a[N];
int Sqrt[N];
int Sqrt_inv[N];
int main() {
  int n, m, i, x, len = 1;
  read(n);
  read(m);
  for (i = 0; i < n; ++i) {
    read(x);
    if (x <= m) a[x] = p - 4;
  }
  a[0] = 1;
  while (len <= m) len <<= 1;
  sqrt(a, Sqrt, len);
  ++Sqrt[0];
  inverse(Sqrt, Sqrt_inv, len);
  for (i = 1; i <= m; ++i) printf("%d\n", (Sqrt_inv[i] << 1) % p);
}