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 P = 998244353, g = 3, MAXN = 600005;
struct Int {
  int a;
  int operator=(int x) { return a = x; }
  Int operator+(Int x) {
    Int tmp;
    tmp = a + x.a;
    if (tmp.a >= P) tmp.a -= P;
    return tmp;
  }
  Int operator-(Int x) {
    Int tmp;
    tmp = a - x.a;
    if (tmp.a < 0) tmp.a += P;
    return tmp;
  }
  Int operator*(Int x) {
    Int tmp;
    tmp = (long long)(a)*x.a % P;
    return tmp;
  }
  Int Pow(int x) {
    Int tmp, ans;
    tmp = a;
    ans = 1;
    while (x) {
      if (x & 1) ans = ans * tmp;
      tmp = tmp * tmp;
      x >>= 1;
    }
    return ans;
  }
  Int inv() { return Pow(P - 2); }
  Int operator/(Int x) {
    Int tmp;
    tmp = a;
    tmp = tmp * x.inv();
    return tmp;
  }
} G, w[2][MAXN], t, a[MAXN], b[MAXN], c[MAXN], d[MAXN], e[MAXN], T;
void NTT(Int X[], int k, bool v) {
  int i, j, l;
  for (i = j = 0; i < k; i++) {
    if (i > j) swap(X[i], X[j]);
    for (l = k >> 1; (j ^= l) < l; l >>= 1)
      ;
  }
  for (i = 2; i <= k; i <<= 1)
    for (j = 0; j < k; j += i)
      for (l = 0; l < i >> 1; l++) {
        t = X[j + l + (i >> 1)] * w[v][(k / i) * l];
        X[j + l + (i >> 1)] = X[j + l] - t;
        X[j + l] = X[j + l] + t;
      }
  if (v)
    for (i = 0, t = k, t = t.inv(); i < k; i++) X[i] = X[i] * t;
}
void Mul(Int X[], Int Y[], int k) {
  k <<= 1;
  w[0][0] = w[0][k] = w[1][0] = w[1][k] = 1;
  G = g;
  G = G.Pow((P - 1) / k);
  int i;
  for (i = 1; i < k; i++) w[0][i] = w[0][i - 1] * G;
  for (i = 1; i < k; i++) w[1][i] = w[0][k - i];
  for (i = 0; i < k >> 1; i++) e[i] = Y[i];
  for (; i < k; i++) e[i] = 0;
  NTT(X, k, 0);
  NTT(e, k, 0);
  for (i = 0; i < k; i++) X[i] = X[i] * e[i];
  NTT(X, k, 1);
  k >>= 1;
  for (i = k; i < k << 1; i++) X[i] = 0;
}
void Inv(Int X[], Int Y[], int k) {
  if (k == 1) {
    Y[0] = X[0].inv();
    return;
  }
  Inv(X, Y, k >> 1);
  int i;
  for (i = 0; i < k; i++) d[i] = X[i];
  for (; i < k << 1; i++) d[i] = 0;
  Mul(d, Y, k);
  Mul(d, Y, k);
  for (i = 0; i < k; i++) Y[i] = Y[i] + Y[i] - d[i];
}
void Sqrt(Int X[], Int Y[], int k) {
  if (k == 1) {
    Y[0] = 1;
    return;
  }
  Sqrt(X, Y, k >> 1);
  int i;
  if (k == 32) {
    k++;
    k--;
  }
  for (i = 0; i < k << 1; i++) c[i] = 0;
  Inv(Y, c, k);
  Mul(c, X, k);
  for (i = 0; i < k; i++) Y[i] = (Y[i] + c[i]) * T;
}
int main() {
  int n, m, L, i;
  scanf("%d%d", &n, &m);
  m++;
  T = 2;
  T = T.inv();
  for (L = 1; L < m << 1; L <<= 1)
    ;
  while (n--) {
    scanf("%d", &i);
    a[i] = P - 4;
  }
  a[0] = 1;
  Sqrt(a, b, L);
  b[0] = b[0] + (Int){1};
  for (i = 0; i < L << 1; i++) c[i] = 0;
  Inv(b, c, L);
  for (i = 1; i < m; i++) {
    c[i] = c[i] + c[i];
    printf("%d\n", c[i].a);
  }
  return 0;
}