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 maxn = 1 << 18, mod = 998244353, proot = 3, base = (mod - 1) / maxn;
int w[maxn], rw[maxn];
inline int pow_mod(int x, int n) noexcept {
  int y = 1;
  while (n) {
    if (n & 1) {
      y = 1ll * y * x % mod;
    }
    x = 1ll * x * x % mod;
    n >>= 1;
  }
  return y;
}
void fft_init() {
  w[0] = rw[0] = 1;
  w[1] = pow_mod(proot, base);
  rw[1] = pow_mod(w[1], mod - 2);
  for (int i = 2; i < maxn; ++i) {
    w[i] = 1ll * w[i - 1] * w[1] % mod;
    rw[i] = 1ll * rw[i - 1] * rw[1] % mod;
  }
  return;
}
inline void swap(int &x, int &y) {
  x ^= y;
  y ^= x;
  x ^= y;
  return;
}
inline void dft(int n, int *a, bool rev = 0) {
  for (register int i = 0, j = 0; i < n; ++i) {
    if (i > j) {
      swap(a[i], a[j]);
    }
    for (int k = n >> 1; (j ^= k) < k; k >>= 1)
      ;
  }
  int *End = a + n;
  for (int hl = 1, l = 2; l <= n; hl = l, l <<= 1) {
    for (register int *i = a; i != End;) {
      int *tmp = i + hl, *W = (rev ? rw : w), *j = tmp, k = (maxn / l);
      for (; i != tmp; ++i, ++j) {
        long long t = 1ll * *j * *W;
        *j = ((long long)*i - t) % mod;
        *i = (t + *i) % mod;
        W += k;
      }
      i = j;
    }
  }
  if (rev) {
    int inv = pow_mod(n, mod - 2);
    for (register int *i = a; i != End; ++i) {
      *i = (1ll * *i * inv) % mod;
    }
  }
  return;
}
int a[maxn], b[maxn], c[maxn], tmp[maxn];
void inv(int N, int *a, int *b) {
  b[0] = pow_mod(a[0], mod - 2);
  for (int m = 1, n = 2, nn = 4; n <= N; m = n, n = nn, nn <<= 1) {
    memset(b + m, 0, sizeof(int) * (m + n));
    memcpy(tmp, a, sizeof(int) * n);
    memset(tmp + n, 0, sizeof(int) * n);
    dft(nn, b);
    dft(nn, tmp);
    for (int i = 0; i < nn; ++i) {
      b[i] = 1ll * b[i] * ((2ll - 1ll * b[i] * tmp[i]) % mod) % mod;
    }
    dft(nn, b, 1);
  }
  return;
}
void sqrrt(int N, int *a, int *b) {
  b[0] = 1;
  for (int m = 1, n = 2, nn = 4; n <= N; m = n, n = nn, nn <<= 1) {
    memset(b + m, 0, sizeof(int) * (n + m));
    inv(n, b, c);
    memcpy(tmp, a, sizeof(int) * n);
    memset(tmp + n, 0, sizeof(int) * n);
    dft(nn, tmp);
    dft(nn, b);
    memset(c + n, 0, sizeof(int) * n);
    dft(nn, c);
    for (int i = 0; i < nn; ++i) {
      b[i] = (1ll * tmp[i] * c[i] + b[i]) % mod;
      b[i] = ((b[i] & 1) ? (b[i] + mod >> 1) : (b[i] >> 1));
    }
    dft(nn, b, 1);
  }
  return;
}
int main() {
  fft_init();
  int N, m, n;
  scanf("%d%d", &N, &m);
  while (N--) {
    int x;
    scanf("%d", &x);
    a[x] = 998244349;
  }
  a[0] = 1;
  n = 1;
  while (n <= m) {
    n <<= 1;
  }
  sqrrt(n, a, b);
  (b[0] += 998244354) %= mod;
  inv(n, b, a);
  for (int i = 1; i <= m; ++i) {
    printf("%d\n", ((long long)(a[i] + mod) << 1) % mod);
  }
  return 0;
}