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 mod = 7 * 17 * (1 << 23) + 1;
struct mint {
  int x;
  mint() : x(0) {}
  mint(int y) {
    if ((x = y % mod + mod) >= mod) x -= mod;
  }
  mint &operator+=(const mint &m) {
    if ((x += m.x) >= mod) x -= mod;
    return *this;
  }
  mint &operator-=(const mint &m) {
    if ((x += mod - m.x) >= mod) x -= mod;
    return *this;
  }
  mint &operator*=(const mint &m) {
    x = 1LL * x * m.x % mod;
    return *this;
  }
  mint &operator/=(const mint &m) {
    x = (1LL * x * ex(m, mod - 2).x) % mod;
    return *this;
  }
  mint operator+(const mint &m) const { return mint(*this) += m; }
  mint operator-(const mint &m) const { return mint(*this) -= m; }
  mint operator*(const mint &m) const { return mint(*this) *= m; }
  mint operator/(const mint &m) const { return mint(*this) /= m; }
  bool operator<(const mint &m) const { return x < m.x; }
  bool operator>(const mint &m) const { return x > m.x; }
  bool operator==(const mint &m) const { return x == m.x; }
  bool operator&&(const mint &m) const { return x && m.x; }
  bool operator||(const mint &m) const { return x || m.x; }
  mint inv() { return ex(mint(x), mod - 2); }
  mint ex(mint a, long long t) {
    if (!t) return 1;
    mint res = ex(a, t / 2);
    res *= res;
    return (t & 1) ? res * a : res;
  }
  mint pow(int k) {
    mint ret = 1, y = x;
    for (; k > 0; y *= y, k >>= 1)
      if (k & 1) ret = ret * y;
    return ret;
  }
};
ostream &operator<<(ostream &os, const mint &m) {
  os << m.x;
  return os;
}
vector<mint> fmt(const vector<mint> &g, bool inv) {
  int e, N = g.size();
  assert((N & (N - 1)) == 0 and "f.size() must be power of 2");
  for (e = 0;; e++)
    if (N == (1 << e)) break;
  vector<mint> f = g;
  for (int m = 0; m < N; ++m) {
    int m2 = 0;
    for (int i = 0; i < e; ++i)
      if (m & (1 << i)) m2 |= (1 << (e - 1 - i));
    if (m < m2) swap(f[m], f[m2]);
  }
  for (int t = 1; t < N; t *= 2) {
    mint r = mint(3).pow((mod - 1) / (t * 2));
    if (inv) r = mint(1) / r;
    for (int i = 0; i < N; i += 2 * t) {
      mint power = 1;
      for (int j = 0; j < t; ++j) {
        mint x = f[i + j], y = f[i + t + j] * power;
        f[i + j] = x + y;
        f[i + t + j] = x - y;
        power = power * r;
      }
    }
  }
  if (inv)
    for (int i = 0; i < N; i++) f[i] = f[i] / N;
  return f;
}
vector<mint> poly_mul(const vector<mint> &f, const vector<mint> &g) {
  int N = max(f.size(), g.size()) * 2;
  vector<mint> t = f, u = g;
  t.resize(N);
  u.resize(N);
  t = fmt(t, 0), u = fmt(u, 0);
  for (int i = 0; i < N; ++i) t[i] *= u[i];
  t = fmt(t, 1);
  return t;
}
vector<mint> poly_inv(const vector<mint> &f) {
  int N = f.size();
  vector<mint> r(1, mint(1) / f[0]);
  for (int k = 2; k <= N; k <<= 1) {
    vector<mint> nr =
        poly_mul(poly_mul(r, r), vector<mint>(begin(f), begin(f) + k));
    nr.resize(k);
    for (int i = 0; i < k / 2; ++i) {
      nr[i] = mint(2) * r[i] - nr[i];
      nr[i + k / 2] = mint(0) - nr[i + k / 2];
    }
    r = nr;
  }
  return r;
}
const mint inv2 = mint((mod + 1) / 2);
vector<mint> poly_sqrt(const vector<mint> &f) {
  int N = f.size();
  vector<mint> s(1, 1);
  for (int k = 2; k <= N; k <<= 1) {
    s.resize(k);
    vector<mint> ns =
        poly_mul(poly_inv(s), vector<mint>(begin(f), begin(f) + k));
    ns.resize(k);
    for (int i = 0; i < k; ++i) s[i] = (s[i] + ns[i]) * inv2;
  }
  return s;
}
int N, M;
vector<mint> c, f;
void solve() {
  c[0] = mint(1);
  c = poly_sqrt(c);
  c[0] += mint(1);
  f = poly_inv(c);
  for (int i = 0; i < M; i++) cout << f[i + 1] * mint(2) << endl;
}
void input() {
  cin >> N >> M;
  int n = 1;
  while (n <= M) n <<= 1;
  c.resize(n, 0);
  for (int i = 0; i < N; i++) {
    int a;
    cin >> a;
    if (a > M) continue;
    c[a] = mint(-4);
  }
  N = n;
}
int main() {
  input();
  solve();
  return 0;
}