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 Maxn = 100010 * 4;
int Mo = 998244353;
int P = 998244353, G = 3;
struct Polynomial {
  long long tA[Maxn], tB[Maxn], tmp[Maxn], sA[Maxn], Rev[Maxn];
  long long pw(long long a, int b, int Mo) {
    long long ans = 1;
    for (; b; b /= 2, a = a * a % Mo)
      if (b & 1) ans = a * ans % Mo;
    return ans;
  }
  int Getlen(int x) {
    while (x & (x - 1)) x += x & -x;
    return x;
  }
  void FFT(int N, long long *A, int ck) {
    long long w1 = pw(G, (P - 1) / N, P), Rev = pw(N, P - 2, P), Wx[Maxn];
    Wx[0] = 1;
    for (int i = 1; i <= N; i++) Wx[i] = w1 * Wx[i - 1] % P;
    for (int d = N / 2; d; d /= 2) {
      long long wn = 1, w = ck ? Wx[N - d] : Wx[d];
      for (int i = 0; i < N; i += d, wn = wn * w % P)
        for (int j = 0, p = 2 * i % N; j < d; j++)
          tmp[i + j] = (wn * A[p + d + j] + A[p + j]) % P;
      for (int i = 0; i < N; i++) A[i] = tmp[i];
    }
    if (ck)
      for (int i = 0; i < N; i++) A[i] = Rev * A[i] % Mo;
  }
  int Mul(long long *A, long long *B, long long *C, int nA, int nB) {
    int nC = nA + nB - 1, m = Getlen(nC);
    for (int i = 0; i < m; i++) tA[i] = tB[i] = 0;
    for (int i = 0; i < nA; i++) tA[i] = A[i];
    for (int i = 0; i < nB; i++) tB[i] = B[i];
    FFT(m, tA, 0);
    FFT(m, tB, 0);
    for (int i = 0; i < m; i++) C[i] = tA[i] * tB[i] % P;
    FFT(m, C, 1);
    return nC;
  }
  void Div(long long *A, long long *B, long long *D, long long *R, int nA,
           int nB) {
    reverse(A, A + nA);
    reverse(B, B + nB);
    int nD = nA - nB + 1, nR;
    Inv(nD, B, D);
    Mul(A, D, D, nD, nD);
    nR = Mul(B, D, R, nB, nD) - nD;
    for (int i = 0; i < nR; i++) R[i] = (A[i + nD] - R[i + nD]) % Mo;
    reverse(A, A + nA);
    reverse(B, B + nB);
    reverse(D, D + nD);
    reverse(R, R + nR);
  }
  void Inv(int t, long long *A, long long *B) {
    memset(sA, 0, sizeof(sA));
    for (int i = 0; i < t; i++) sA[i] = A[i];
    B[0] = pw(A[0], Mo - 2, Mo);
    t *= 2;
    for (int m = 2; m < t; m <<= 1) {
      for (int i = m / 2; i < m * 2; i++) B[i] = tA[i] = 0;
      for (int i = 0; i < m; i++) tA[i] = sA[i];
      FFT(m * 2, tA, 0);
      FFT(m * 2, B, 0);
      for (int i = 0; i < m * 2; i++) B[i] = (2 - tA[i] * B[i]) % P * B[i] % P;
      FFT(m * 2, B, 1);
    }
  }
  void Sqrt(int t, long long *A, long long *B) {
    int Rev2 = pw(2, Mo - 2, Mo);
    B[0] = 1;
    t <<= 1;
    for (int m = 2; m < t; m <<= 1) {
      Inv(m, B, Rev);
      Mul(A, Rev, Rev, m, m);
      for (int i = 0; i < m; i++) B[i] = (B[i] + Rev[i]) % P * Rev2 % Mo;
    }
  }
} Poly;
int a, deg, N, M;
long long A[Maxn], B[Maxn], C[Maxn];
int main() {
  scanf("%d%d", &N, &M);
  deg = Poly.Getlen(M + 1);
  for (int i = 1; i <= N; i++) {
    scanf("%d", &a);
    if (a > deg) continue;
    A[a] -= 4;
  }
  A[0] = 1;
  Poly.Sqrt(deg, A, B);
  B[0]++;
  Poly.Inv(deg, B, A);
  for (int i = 1; i <= M; i++) cout << (Mo + A[i] * 2 % Mo) % Mo << endl;
}