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;
namespace TYC {
const int N = 1 << 18 | 5;
const int p = 998244353;
const int INV2 = (p + 1) >> 1;
namespace Poly {
int rev[N], w[N];
inline int qpow(int x, int tim) {
  int ans = 1;
  for (; tim; tim >>= 1, x = int((long long)x * x % p))
    if (tim & 1) ans = int((long long)ans * x % p);
  return ans;
}
inline void init(const int n) {
  for (int i = 0; i < n; i++)
    rev[i] = (rev[i >> 1] >> 1) | ((n >> 1) * (i & 1));
  w[0] = 1, w[1] = qpow(3, (p - 1) / n);
  for (int i = 2; i < n; i++) w[i] = int((long long)w[i - 1] * w[1] % p);
}
void NTT(int *a, const int n, const int type) {
  for (int i = 0; i < n; i++)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  if (type) reverse(w + 1, w + n);
  for (int len = 1; len < n; len <<= 1)
    for (int i = 0; i < n; i += len << 1)
      for (int k = 0; k < len; k++) {
        int x = a[i + k],
            y = int((long long)w[n / (len << 1) * k] * a[i + len + k] % p);
        a[i + k] = (x + y) % p;
        a[i + len + k] = (x - y + p) % p;
      }
  if (type) {
    reverse(w + 1, w + n);
    for (int i = 0, t = qpow(n, p - 2); i < n; i++)
      a[i] = int((long long)a[i] * t % p);
  }
}
void Mul(const int *A, const int *B, int *c, const int n) {
  static int len, a[N], b[N];
  for (len = 1; len <= (n << 1); len <<= 1)
    ;
  memcpy(a, A, sizeof(int[n]));
  memcpy(b, B, sizeof(int[n]));
  memset(a + n, 0, sizeof(int[len - n]));
  memset(b + n, 0, sizeof(int[len - n]));
  init(len);
  NTT(a, len, 0), NTT(b, len, 0);
  for (int i = 0; i < len; i++) c[i] = int((long long)a[i] * b[i] % p);
  NTT(c, len, 1);
  memset(c + n, 0, sizeof(int[len - n]));
}
void _inv(const int *A, int *b, const int n) {
  if (n == 1)
    b[0] = qpow(A[0], p - 2);
  else {
    int t = (n + 1) >> 1;
    _inv(A, b, t);
    static int len, a[N];
    for (len = 1; len <= (n << 1); len <<= 1)
      ;
    memcpy(a, A, sizeof(int[n]));
    memset(a + n, 0, sizeof(int[len - n]));
    memset(b + t, 0, sizeof(int[len - t]));
    init(len);
    NTT(a, len, 0), NTT(b, len, 0);
    for (int i = 0; i < len; i++)
      b[i] =
          int((2LL * b[i] % p - (long long)a[i] * b[i] % p * b[i] % p + p) % p);
    NTT(b, len, 1);
    memset(b + n, 0, sizeof(int[len - n]));
  }
}
void Inv(const int *A, int *b, const int n) {
  static int a[N];
  memcpy(a, A, sizeof(int[n]));
  memset(b, 0, sizeof(int[n]));
  _inv(a, b, n);
}
void _sqrt(const int *A, int *b, const int n) {
  if (n == 1)
    b[0] = 1;
  else {
    int t = (n + 1) >> 1;
    _sqrt(A, b, t);
    static int len, inv[N], a[N];
    for (len = 1; len <= (n << 1); len <<= 1)
      ;
    memcpy(a, A, sizeof(int[n]));
    memset(a + n, 0, sizeof(int[len - n]));
    Inv(b, inv, n);
    Mul(a, inv, a, n);
    for (int i = 0; i < n; i++) b[i] = int((long long)(b[i] + a[i]) * INV2 % p);
    memset(b + n, 0, sizeof(int[len - n]));
  }
}
void Sqrt(const int *A, int *b, const int n) {
  static int a[N];
  memcpy(a, A, sizeof(int[n]));
  memset(b, 0, sizeof(int[n]));
  _sqrt(a, b, n);
}
}  // namespace Poly
inline int read() {
  int x = 0, f = 0, ch = getchar();
  while (!isdigit(ch)) f |= (ch == '-'), ch = getchar();
  while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
  return f ? -x : x;
}
void work() {
  int n = read(), m = read() + 1;
  static int a[N], tmp[N];
  for (int i = 1; i <= n; i++) a[read()] = p - 4;
  a[0] = 1;
  Poly::Sqrt(a, tmp, m);
  (tmp[0] += 1) %= p;
  Poly::Inv(tmp, tmp, m);
  for (int i = 1; i < m; i++) printf("%d\n", int(2LL * tmp[i] % p));
}
}  // namespace TYC
int main() {
  TYC::work();
  return 0;
}