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;
template <class T>
bool chkmin(T& a, T b) {
  return a > b ? a = b, true : false;
}
template <class T>
bool chkmax(T& a, T b) {
  return a < b ? a = b, true : false;
}
template <class T>
void read(T& a) {
  char c = getchar();
  T f = 1;
  a = 0;
  for (; !isdigit(c); c = getchar())
    if (c == '-') f = -1;
  for (; isdigit(c); c = getchar()) a = a * 10 + c - '0';
  a *= f;
}
template <class T>
void write(T a) {
  static int stk[60];
  int tp = 0;
  if (a < 0) putchar('-'), a = -a;
  do {
    stk[++tp] = a % 10;
    a /= 10;
  } while (a);
  while (tp) putchar(stk[tp--] + '0');
}
const int maxN = 4e5 + 5;
const int mo = 998244353, g = 3;
int pow_mod(int x, int t) {
  int ret = 1;
  while (t) {
    if (t & 1) ret = (long long)ret * x % mo;
    x = (long long)x * x % mo;
    t >>= 1;
  }
  return ret;
}
inline int MOD(int a) { return (a % mo + mo) % mo; }
struct Pol {
  int n;
  int a[maxN];
  Pol() {}
  Pol(int t) {
    n = 1;
    a[0] = t;
  }
  inline void lim(int t) { chkmin(n, t); }
  inline int& operator[](int x) { return a[x]; }
  inline const int& operator[](int x) const { return a[x]; }
  void print() const {
    for (int i = (0), _ = (n - 1); i <= _; ++i) printf("%d ", a[i]);
    puts("");
  }
};
int pw[maxN];
int N, M;
void ntt(int* a, int* b, int step, int n) {
  if (n == 1) {
    b[0] = a[0];
    return;
  }
  int m = (n >> 1);
  ntt(a, b, step << 1, m);
  ntt(a + step, b + m, step << 1, m);
  for (int i = (0), _ = (m - 1); i <= _; ++i) {
    int odd = b[i], even = (long long)pw[i * step] * b[i + m] % mo;
    b[i] = (odd + even) % mo;
    b[i + m] = (odd - even + mo) % mo;
  }
}
Pol operator*(const Pol& A, const Pol& B) {
  static int a[maxN];
  static int b[maxN];
  static int ta[maxN];
  static int tb[maxN];
  static Pol ret;
  int L = 1;
  while (L < A.n + B.n) L <<= 1;
  memset(a, 0, 4 * L);
  memset(b, 0, 4 * L);
  pw[0] = 1;
  int unit = pow_mod(g, (mo - 1) / L), Inv = (pow_mod(L, mo - 2));
  for (int i = (1), _ = (L - 1); i <= _; ++i)
    pw[i] = (long long)pw[i - 1] * unit % mo;
  for (int i = (0), _ = (A.n - 1); i <= _; ++i) a[i] = A[i];
  for (int i = (0), _ = (B.n - 1); i <= _; ++i) b[i] = B[i];
  ntt(a, ta, 1, L);
  ntt(b, tb, 1, L);
  unit = pow_mod(g, (mo - 1 - (mo - 1) / L));
  for (int i = (1), _ = (L - 1); i <= _; ++i)
    pw[i] = (long long)pw[i - 1] * unit % mo;
  for (int i = (0), _ = (L - 1); i <= _; ++i)
    a[i] = (long long)ta[i] * tb[i] % mo;
  ntt(a, ta, 1, L);
  for (int i = (0), _ = (L - 1); i <= _; ++i)
    ta[i] = (long long)ta[i] * Inv % mo;
  memcpy(ret.a, ta, 4 * L);
  ret.n = A.n + B.n - 1;
  return ret;
}
Pol operator*(const Pol& a, int b) {
  static Pol ret;
  memset(ret.a, 0, sizeof(ret.a));
  ret.n = a.n;
  for (int i = (0), _ = (ret.n - 1); i <= _; ++i)
    ret[i] = (long long)a[i] * b % mo;
  return ret;
}
Pol operator+(const Pol& a, const Pol& b) {
  static Pol ret;
  ret.n = max(a.n, b.n);
  for (int i = (0), _ = (ret.n - 1); i <= _; ++i) ret[i] = MOD(a[i] + b[i]);
  return ret;
}
Pol operator-(const Pol& a, const Pol& b) {
  static Pol ret;
  ret.n = max(a.n, b.n);
  for (int i = (0), _ = (ret.n - 1); i <= _; ++i) ret[i] = MOD(a[i] - b[i]);
  return ret;
}
Pol getinv(const Pol& a, int lim) {
  if (lim == 1) return Pol((pow_mod(a[0], mo - 2)));
  static Pol B_;
  static Pol B_2;
  static Pol lala;
  static Pol A;
  B_ = getinv(a, (lim + 1) >> 1);
  B_2 = B_ * 2;
  A = a;
  A.lim(lim);
  lala = A * B_;
  lala.lim(lim);
  lala = lala * B_;
  lala.lim(lim);
  B_2 = B_2 - lala;
  return B_2;
}
Pol sqrt(const Pol& a, int lim) {
  if (lim == 1) return Pol(sqrt(a[0]));
  static Pol B_;
  static Pol invB_;
  static Pol lala;
  static Pol A;
  B_ = sqrt(a, (lim + 1) >> 1);
  invB_ = getinv(B_, lim);
  A = a;
  A.lim(lim);
  invB_ = invB_ * A;
  invB_.lim(lim);
  lala = B_ + invB_;
  return lala * (pow_mod(2, mo - 2));
}
int main() {
  static Pol C;
  static Pol tmp1;
  static Pol tmp2;
  read(N);
  read(M);
  ++M;
  int mx = 0;
  for (int i = (1), _ = (N); i <= _; ++i) {
    int a;
    read(a);
    C[a] = 1;
    chkmax(mx, a);
  }
  C.n = mx + 1;
  tmp1 = 1 - C * 4;
  tmp1 = 1 + sqrt(tmp1, M);
  tmp1 = getinv(tmp1, M) * 2;
  for (int i = (1), _ = (M - 1); i <= _; ++i) printf("%d\n", tmp1[i]);
  puts("");
  return 0;
}