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 MN = 600000 + 5, P = 998244353, G = 3;
using namespace std;
template <typename T>
inline T &IN(T &in) {
  in = 0;
  char c = getchar();
  int f = 1;
  while (!isdigit(c)) {
    if (c == '-') f = -1;
    c = getchar();
  }
  while (isdigit(c)) in = in * 10 + c - '0', c = getchar();
  return in *= f;
}
int top, n, m, k;
long long h[MN], f[MN];
long long qp(long long a, long long b) {
  long long c = 1;
  for (; b; b >>= 1, a = a * a % P)
    if (b & 1) c = c * a % P;
  return c;
}
long long inv(long long a) { return qp(a, P - 2); }
long long qm(long long x) { return x >= P ? x - P : x; }
void ntt(long long *a, int n, int f) {
  for (int i = 0, j = 0; i < n; ++i) {
    if (i > j) swap(a[i], a[j]);
    for (int l = n >> 1; (j ^= l) < l; l >>= 1)
      ;
  }
  for (int i = 2; i <= n; i <<= 1) {
    long long gn = qp(G, (P - 1) / i);
    if (f == -1) gn = inv(gn);
    for (int j = 0, d = i / 2; j < n; j += i) {
      long long g = 1;
      for (int k = 0; k < d; ++k, g = g * gn % P) {
        long long x = a[j + k], y = a[j + k + d] * g % P;
        a[j + k] = qm(x + y), a[j + k + d] = qm(x - y + P);
      }
    }
  }
  if (f == -1) {
    long long Inv = qp(n, P - 2);
    for (int i = 0; i < n; ++i) a[i] = a[i] * Inv % P;
  }
}
void inv(int n, long long *a, long long *b) {
  if (n == 1) return b[0] = inv(a[0]), void();
  inv(n + 1 >> 1, a, b);
  static long long A[MN];
  int N = 1;
  while (N < n << 1) N <<= 1;
  for (int i = 0; i < n; ++i) A[i] = a[i];
  ntt(A, N, 1), ntt(b, N, 1);
  for (int i = 0; i < N; ++i) b[i] = (2 - A[i] * b[i] % P + P) * b[i] % P;
  ntt(b, N, -1);
  for (int i = n; i < N; ++i) b[i] = 0;
  for (int i = 0; i < N; ++i) A[i] = 0;
}
void work(int n, long long *a, long long *b) {
  if (n == 1) return b[0] = 1, void();
  work(n + 1 >> 1, a, b);
  static long long A[MN], B[MN];
  int N = 1;
  while (N < n * 3) N <<= 1;
  for (int i = 0; i < n; ++i) A[i] = a[i];
  ntt(A, N, 1), ntt(b, N, 1);
  for (int i = 0; i < N; ++i) {
    long long x = A[i], y = b[i];
    b[i] = (2 * x % P * y % P - 1 + P) % P;
    A[i] = (x * y % P * y % P - 1 + P) % P;
  }
  ntt(b, N, -1);
  for (int i = n; i < N; ++i) b[i] = 0;
  inv(n, b, B);
  ntt(B, N, 1);
  for (int i = 0; i < N; ++i) b[i] = A[i] * B[i] % P;
  ntt(b, N, -1);
  for (int i = n; i < N; ++i) b[i] = 0;
  for (int i = 0; i < N; ++i) A[i] = 0, B[i] = 0;
}
void input() {
  IN(n), IN(m);
  for (int i = 1, x; i <= n; ++i) IN(x), h[x]++;
  work(m + 1, h, f);
  for (int i = 1; i <= m; ++i) printf("%lld\n", f[i]);
}
int main() {
  input();
  return 0;
}