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 thecold {
inline int read() {
  int res = 0;
  bool flag = false;
  char c = getchar();
  while (!isdigit(c)) flag = (c == '-'), c = getchar();
  while (isdigit(c)) res = res * 10 + (c ^ 48), c = getchar();
  return !flag ? res : -res;
}
const int Max_n = 1e5 + 5;
const int G = 3;
const int jzp = 998244353;
const int Gi = (jzp + 1) / 3;
int rev[Max_n << 2], len, lim;
inline void prepare(const int lenth) {
  lim = 0, len = 1;
  while (len <= lenth) len <<= 1, ++lim;
  for (int i = 1; i < len; ++i)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (lim - 1));
}
inline int add(const int x, const int y) {
  int ret = x + y;
  if (ret >= jzp) ret -= jzp;
  return ret;
}
int n, m, c[Max_n], cnt = 1e5, inv2;
inline int quickpow(long long x, long long y) {
  long long ret = 1;
  while (y) {
    if (y & 1) ret = ret * x % jzp;
    x = x * x % jzp, y >>= 1;
  }
  return ret;
}
inline void NTT(vector<int> &w, const int opt) {
  for (int i = 1; i < len; ++i)
    if (rev[i] > i) swap(w[rev[i]], w[i]);
  for (int dep = 1; dep <= lim; ++dep) {
    int base = quickpow(opt == 1 ? G : Gi, (jzp - 1) / (1 << dep));
    for (int i = 0; i < len; i += 1 << dep) {
      int q = 1;
      for (int j = 0; j < 1 << (dep - 1); ++j) {
        int ui = w[i + j], vi = 1ll * q * w[i + j + (1 << (dep - 1))] % jzp;
        w[i + j] = add(ui, vi), w[i + j + (1 << (dep - 1))] = add(ui, jzp - vi);
        q = 1ll * q * base % jzp;
      }
    }
  }
  if (opt == -1) {
    int inv = quickpow(len, jzp - 2);
    for (int i = 0; i < len; ++i) w[i] = 1ll * w[i] * inv % jzp;
  }
}
inline void solve_ni(const int mod, vector<int> w, vector<int> &q) {
  if (mod == 1) return q[0] = quickpow(w[0], jzp - 2), void();
  int mid = (mod + 1) >> 1;
  solve_ni(mid, w, q);
  vector<int> f, g;
  f.resize(0), g.resize(0);
  prepare(2 * mod);
  f.resize(len), g.resize(len), q.resize(len);
  f.clear(), g.clear();
  for (int i = 0; i < mod; ++i) f[i] = w[i];
  for (int i = 0; i < mid; ++i) g[i] = q[i];
  NTT(f, 1), NTT(g, 1);
  for (int i = 0; i < len; ++i)
    f[i] = 1ll * g[i] * add(2, jzp - 1ll * f[i] * g[i] % jzp) % jzp;
  NTT(f, -1);
  for (int i = 0; i < mod; ++i) q[i] = f[i];
}
inline void solve_sqrt(const int mod, vector<int> w, vector<int> &q) {
  if (mod == 1) return q[0] = 1, void();
  int mid = (mod + 1) >> 1;
  solve_sqrt(mid, w, q);
  for (int i = mid; i < mod; ++i) assert(q[i] == 0);
  vector<int> f, ni, g;
  f.resize(0), ni.resize(1), g.resize(0);
  solve_ni(mod, q, ni);
  prepare(mod * 2), f.resize(len), ni.resize(len), g.resize(len);
  f.clear();
  for (int i = 0; i < mod; ++i) f[i] = w[i];
  NTT(f, 1), NTT(ni, 1);
  for (int i = 0; i < len; ++i) f[i] = 1ll * f[i] * ni[i] % jzp;
  NTT(f, -1);
  for (int i = 0; i < mod; ++i) q[i] = 1ll * add(f[i], q[i]) * inv2 % jzp;
}
inline void main() {
  inv2 = quickpow(2, jzp - 2), n = read(), m = read();
  prepare(2e5);
  vector<int> g, ans;
  g.resize(0);
  g.resize(len), g[0] = 1;
  for (int i = 1; i <= n; ++i) g[read()] = jzp - 4;
  ans.resize(len);
  solve_sqrt(cnt + 1, g, ans);
  ans[0] = add(ans[0], 1);
  solve_ni(cnt + 1, ans, ans);
  for (int i = 1; i <= m; ++i) ans[i] = 2ll * ans[i] % jzp;
  for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
}
}  // namespace thecold
int main() {
  thecold::main();
  return 0;
}