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 MAX = 1000000 + 10;
const int Mod = 998244353;
const int alp = 3;
int n, S;
int C[MAX];
int dp[MAX];
namespace opt {
int N;
int a[MAX], b[MAX], w[MAX], tmp[MAX];
int Pow(int a, int b) {
  int k = 1;
  for (; b; b /= 2, a = (long long)a * a % Mod)
    if (b % 2 == 1) k = (long long)k * a % Mod;
  return k;
}
void FFT(int *a, int S, int d) {
  if (d == N) return;
  FFT(a, S, d << 1);
  FFT(a, S + d, d << 1);
  for (int i = S, j = S, p = 0; i < N / 2; i += d, j += d << 1, p += d) {
    int G = a[j], K = a[j + d];
    tmp[i] = ((long long)G + (long long)w[p] * K) % Mod;
    tmp[i + N / 2] = ((long long)G + (long long)w[p + N / 2] * K) % Mod;
  }
  for (int i = S; i < N; i += d) a[i] = tmp[i];
}
void conv(int *aa, int *bb, int *c, int n) {
  for (int i = 0; i < n; ++i) a[i] = aa[i], b[i] = bb[i];
  if (n <= 500) {
    for (int i = 0; i < n * 2; ++i) c[i] = 0;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j)
        c[i + j] = (c[i + j] + (long long)a[i] * b[j]) % Mod;
    for (int i = 0; i < n; ++i) a[i] = b[i] = 0;
    return;
  }
  N = 1;
  for (; N < n; N <<= 1)
    ;
  N <<= 1;
  w[0] = 1;
  w[1] = Pow(alp, (Mod - 1) / N);
  for (int i = 2; i <= N; ++i) w[i] = (long long)w[i - 1] * w[1] % Mod;
  FFT(a, 0, 1);
  FFT(b, 0, 1);
  for (int i = 0; i < N; ++i) a[i] = (long long)a[i] * b[i] % Mod;
  for (int i = 0; i < N; ++i) b[i] = a[i ? (N - i) : 0];
  FFT(b, 0, 1);
  int InvN = Pow(N, Mod - 2);
  for (int i = 0; i < N; ++i) {
    c[i] = (long long)b[i] * InvN % Mod;
    a[i] = b[i] = 0;
  }
}
}  // namespace opt
int a[MAX], b[MAX], c[MAX];
void solve(int l, int r) {
  if (r == l + 1) return;
  int mid = (l + r) / 2;
  solve(l, mid);
  int i;
  int need = r - l;
  for ((i) = (0); (i) != (need); ++(i)) a[i] = b[i] = 0;
  if (need <= l) {
    for ((i) = (0); (i) != (mid - l); ++(i)) a[i] = dp[i + l];
    for ((i) = (0); (i) != (need); ++(i)) b[i] = dp[i];
    opt::conv(a, b, c, need);
    for ((i) = (0); (i) != (need); ++(i)) {
      c[i] *= 2;
      if (c[i] >= Mod) c[i] -= Mod;
    }
  } else {
    for ((i) = (0); (i) != (mid - l); ++(i)) a[i] = b[i] = dp[i + l];
    opt::conv(a, b, c, need);
  }
  for ((i) = (0); (i) != (need); ++(i)) {
    a[i] = c[i];
    b[i] = C[i];
  }
  opt::conv(a, b, c, need);
  for ((i) = (mid); (i) != (r); ++(i)) {
    dp[i] += c[i - l];
    if (dp[i] >= Mod) dp[i] -= Mod;
  }
  solve(mid, r);
}
int main() {
  int i;
  scanf("%d%d", &n, &S);
  for ((i) = (1); (i) <= (n); ++(i)) {
    int a;
    scanf("%d", &a);
    C[a] = 1;
  }
  int N = 1;
  for (; N <= S; N *= 2)
    ;
  dp[0] = 1;
  solve(0, N);
  for ((i) = (1); (i) <= (S); ++(i)) printf("%d\n", dp[i]);
  return 0;
}