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;
int q_pow(int x, int n) {
  int ret = 1;
  for (; n; n >>= 1, x = (long long)x * x % 998244353)
    if (n & 1) ret = (long long)ret * x % 998244353;
  return ret;
}
int A[100005 << 2], B[100005 << 2], tmp[100005], tx[100005], ty[100005], Q, n,
    m;
void NTT(int *a, int len, int flag) {
  int i, j, k, t, w, x, tmp;
  for (i = k = 0; i < len; i++) {
    if (i > k) swap(a[i], a[k]);
    for (j = len >> 1; (k ^= j) < j; j >>= 1)
      ;
  }
  for (k = 2; k <= len; k <<= 1) {
    t = k >> 1;
    x = q_pow(3, (998244353 - 1) / k);
    if (flag == -1) x = q_pow(x, 998244353 - 2);
    for (i = 0; i < len; i += k)
      for (w = 1, j = i; j < i + t; j++) {
        tmp = (long long)a[j + t] * w % 998244353;
        a[j + t] = (a[j] - tmp + 998244353) % 998244353;
        a[j] = (a[j] + tmp) % 998244353;
        w = (long long)w * x % 998244353;
      }
  }
  if (flag == -1)
    for (t = q_pow(len, 998244353 - 2), i = 0; i < len; i++)
      a[i] = (long long)t * a[i] % 998244353;
}
struct poly {
  vector<int> a;
  int len;
  poly() {}
  poly(int x) {
    len = 1;
    a.push_back(x);
  }
  void clear() {
    len = 0;
    a.clear();
  }
  void rev() { reverse(a.begin(), a.end()); }
  void resize(int x) {
    a.resize(x);
    len = x;
  }
  poly operator+(const poly &b) const {
    poly c;
    c.len = max(len, b.len);
    c.resize(c.len);
    for (int i = 0; i < len; i++) c.a[i] = a[i];
    for (int i = 0; i < b.len; i++) c.a[i] = (c.a[i] + b.a[i]) % 998244353;
    return c;
  }
  poly operator-(const poly &b) const {
    poly c;
    c.len = max(len, b.len);
    c.resize(c.len);
    for (int i = 0; i < len; i++) c.a[i] = a[i];
    for (int i = 0; i < b.len; i++)
      c.a[i] = (c.a[i] - b.a[i] + 998244353) % 998244353;
    return c;
  }
  poly operator*(const poly &b) const {
    poly c;
    c.len = len + b.len;
    int n = 1;
    while (n < c.len) n <<= 1;
    for (int i = 0; i < len; i++) A[i] = a[i];
    for (int i = len; i < n; i++) A[i] = 0;
    for (int i = 0; i < b.len; i++) B[i] = b.a[i];
    for (int i = b.len; i < n; i++) B[i] = 0;
    NTT(A, n, 1);
    NTT(B, n, 1);
    for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
    NTT(A, n, -1);
    for (int i = 0; i < c.len; i++) c.a.push_back(A[i]);
    return c;
  }
  poly operator+(const int &b) const {
    poly c;
    c.len = len;
    c.a = a;
    (c.a[0] += b) %= 998244353;
    return c;
  }
  poly operator*(const int &b) const {
    poly c;
    c.len = len;
    for (int i = 0; i < len; i++)
      c.a.push_back((long long)a[i] * b % 998244353);
    return c;
  }
  void get_inv(poly &b, int n) {
    if (n == 1) {
      b.a.push_back(q_pow(a[0], 998244353 - 2));
      b.len = 1;
      return;
    }
    get_inv(b, n >> 1);
    int t = n << 1;
    int lim = min(len, n);
    for (int i = 0; i < lim; i++) A[i] = a[i];
    for (int i = lim; i < t; i++) A[i] = 0;
    for (int i = 0; i < b.len; i++) B[i] = b.a[i];
    for (int i = b.len; i < t; i++) B[i] = 0;
    NTT(A, t, 1);
    NTT(B, t, 1);
    for (int i = 0; i < t; i++)
      A[i] = (2 - (long long)A[i] * B[i] % 998244353 + 998244353) * B[i] %
             998244353;
    NTT(A, t, -1);
    for (int i = 0; i < b.len; i++) b.a[i] = A[i];
    for (int i = b.len; i < n; i++) b.a.push_back(A[i]);
    b.len = n;
  }
  poly Dao() {
    poly c;
    c.len = len - 1;
    for (int i = 0; i < c.len; i++)
      c.a.push_back(a[i + 1] * (i + 1ll) % 998244353);
    return c;
  }
  poly Jifen() {
    poly c;
    c.len = len + 1;
    c.a.push_back(0);
    for (int i = 0; i < len; i++)
      c.a.push_back((long long)a[i] * q_pow(i + 1, 998244353 - 2) % 998244353);
    return c;
  }
  poly get_ln(int len) {
    poly b = Dao();
    poly c;
    get_inv(c, len);
    return (b * c).Jifen();
  }
  void get_mod(int b) {
    for (int i = b; i < len; i++) a.pop_back();
    len = b;
  }
  int get_val(int x) {
    int ret = a[0];
    for (int i = 1, tmp = x; i < len; tmp = (long long)tmp * x % 998244353, i++)
      ret = (ret + (long long)a[i] * tmp) % 998244353;
    return ret;
  }
  poly operator/(poly b) {
    rev();
    b.rev();
    poly c;
    int n = 1;
    while (n < (len - b.len + 1)) n <<= 1;
    b.get_inv(c, n);
    c.get_mod(len - b.len + 1);
    n = 1;
    while (n < len + c.len) n <<= 1;
    for (int i = 0; i < len; i++) A[i] = a[i];
    for (int i = len; i < n; i++) A[i] = 0;
    for (int i = 0; i < c.len; i++) B[i] = c.a[i];
    for (int i = c.len; i < n; i++) B[i] = 0;
    NTT(A, n, 1);
    NTT(B, n, 1);
    for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
    NTT(A, n, -1);
    for (int i = 0; i < c.len; i++) c.a[i] = A[i];
    c.rev();
    rev();
    b.rev();
    return c;
  }
  poly operator%(poly b) {
    rev();
    b.rev();
    poly c;
    int n = 1;
    while (n < (len - b.len + 1)) n <<= 1;
    b.get_inv(c, n);
    c.get_mod(len - b.len + 1);
    n = 1;
    while (n < len + c.len) n <<= 1;
    for (int i = 0; i < len; i++) A[i] = a[i];
    for (int i = len; i < n; i++) A[i] = 0;
    for (int i = 0; i < c.len; i++) B[i] = c.a[i];
    for (int i = c.len; i < n; i++) B[i] = 0;
    NTT(A, n, 1);
    NTT(B, n, 1);
    for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
    NTT(A, n, -1);
    for (int i = 0; i < c.len; i++) c.a[i] = A[i];
    c.rev();
    rev();
    b.rev();
    for (int i = 0; i < c.len; i++) A[i] = c.a[i];
    for (int i = c.len; i < n; i++) A[i] = 0;
    for (int i = 0; i < b.len; i++) B[i] = b.a[i];
    for (int i = b.len; i < n; i++) B[i] = 0;
    NTT(A, n, 1);
    NTT(B, n, 1);
    for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
    NTT(A, n, -1);
    c.len = b.len;
    c.resize(c.len);
    for (int i = 0; i < c.len; i++)
      c.a[i] = (a[i] - A[i] + 998244353) % 998244353;
    return c;
  }
} a, b;
void get_rot(const poly &a, poly &b, int len) {
  if (len == 1) {
    b.a.push_back(1);
    b.len = 1;
    return;
  }
  get_rot(a, b, len >> 1);
  poly c;
  c.clear();
  b.get_inv(c, len);
  b = b + (c * a);
  b = b * ((998244353 + 1) / 2);
  b.get_mod(len);
}
void get_exp(const poly &a, poly &b, int len) {
  if (len == 1) {
    b.a.push_back(1);
    b.len = 1;
    return;
  }
  get_exp(a, b, len >> 1);
  b = b * ((a - b.get_ln(len)) + 1);
  b.get_mod(len);
}
int main() {
  scanf("%d%d", &n, &m);
  a.resize(m + 1);
  a.a[0] = 1;
  for (int i = 1, x; i <= n; i++) {
    scanf("%d", &x);
    if (x <= m) a.a[x] = 998244353 - 4;
  }
  int len = 1;
  while (len <= m) len <<= 1;
  get_rot(a, b, len);
  b.a[0]++;
  a.clear();
  b.get_inv(a, len);
  for (int i = 1; i <= m; i++) printf("%d\n", (a.a[i] << 1) % 998244353);
}