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;
int getnum() {
  char ch = getchar();
  int x = 0, f = 1;
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * f;
}
const int MAX = 400010, mo = 998244353, phi = 998244352, g = 3;
int n, m;
int rev[MAX];
int G[MAX];
int A[MAX];
int B[MAX];
int b[2][MAX];
int c[2][MAX];
void get_read() {
  n = getnum();
  m = getnum();
  for (int i = 1; i <= n; ++i) ++G[getnum()];
}
int ksm(int a, int b) {
  int s = 1;
  while (b) {
    if (b & 1) s = 1LL * s * a % mo;
    a = 1LL * a * a % mo;
    b >>= 1;
  }
  return s;
}
void NTT(int *P, int N, int opt) {
  for (int i = 0; i < N; ++i)
    if (i < rev[i]) swap(P[i], P[rev[i]]);
  for (int i = 2; i <= N; i <<= 1) {
    int p = i >> 1, W = ksm(g, phi / i);
    for (int j = 0; j < N; j += i) {
      int w = 1;
      for (int k = j; k < j + p; ++k, w = 1LL * w * W % mo) {
        int X = P[k], Y = 1LL * w * P[k + p] % mo;
        P[k] = (X + Y) % mo;
        P[k + p] = (X - Y + mo) % mo;
      }
    }
  }
  if (opt == -1) reverse(P + 1, P + N);
}
void mul(int *P, int *Q, int bas) {
  memset(A, 0, sizeof(A));
  memset(B, 0, sizeof(B));
  for (int i = 0; i < bas; ++i) A[i] = P[i];
  for (int i = 0; i < bas; ++i) B[i] = Q[i];
  int N = bas << 1;
  NTT(A, N, 1);
  NTT(B, N, 1);
  for (int i = 0; i < N; ++i) A[i] = 1LL * A[i] * B[i] % mo;
  NTT(A, N, -1);
  for (int i = 0, inv = ksm(N, mo - 2); i < N; ++i)
    A[i] = 1LL * A[i] * inv % mo;
  for (int i = 0; i < bas; ++i) P[i] = A[i];
}
void INV(int *P, int n) {
  int cur = 0, bas = 1, N = 2, L = 1;
  memset(b[cur], 0, sizeof(b[cur]));
  b[cur][0] = ksm(P[0], mo - 2);
  while (bas <= (n << 1)) {
    cur ^= 1;
    memset(b[cur], 0, sizeof(b[cur]));
    for (int i = 0; i < bas; ++i) b[cur][i] = 2 * b[cur ^ 1][i] % mo;
    for (int i = 0; i < N; ++i)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
    mul(b[cur ^ 1], b[cur ^ 1], bas);
    mul(b[cur ^ 1], P, bas);
    for (int i = 0; i < bas; ++i)
      b[cur][i] = (b[cur][i] - b[cur ^ 1][i] + mo) % mo;
    bas <<= 1;
    N <<= 1;
    ++L;
  }
  for (int i = 0; i <= n; ++i) P[i] = b[cur][i];
}
void SQR(int *P, int n) {
  int cur = 0, bas = 1, N = 2, L = 1;
  memset(c[cur], 0, sizeof(c[cur]));
  c[cur][0] = 1;
  while (bas <= (n << 1)) {
    cur ^= 1;
    memset(c[cur], 0, sizeof(c[cur]));
    for (int i = 0; i < bas; ++i) c[cur][i] = 2 * c[cur ^ 1][i] % mo;
    INV(c[cur], bas - 1);
    for (int i = 0; i < N; ++i)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
    mul(c[cur ^ 1], c[cur ^ 1], bas);
    for (int i = 0; i < bas; ++i) c[cur ^ 1][i] = (c[cur ^ 1][i] + P[i]) % mo;
    mul(c[cur], c[cur ^ 1], bas);
    bas <<= 1;
    N <<= 1;
    ++L;
  }
  for (int i = 0; i <= n; ++i) P[i] = c[cur][i];
}
void get_work() {
  for (int i = 0; i <= m; ++i) G[i] = (-4LL * G[i] % mo + mo) % mo;
  ++G[0];
  SQR(G, m);
  ++G[0];
  INV(G, m);
  for (int i = 1; i <= m; ++i) printf("%d\n", G[i] * 2 % mo);
}
int main() {
  get_read();
  get_work();
  return 0;
}