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 g = 3;
const int phi = 998244352;
const int Mod = 998244353;
const int inv2 = Mod + 1 >> 1;
inline int Add(int x, int y) { return (x += y) > Mod ? x - Mod : x; }
inline int Sub(int x, int y) { return (x -= y) < 0 ? x + Mod : x; }
inline int Mul(int x, int y) { return 1ll * x * y % Mod; }
inline int Pow(int a, int p) {
  int ans = 1;
  while (p) {
    if (p & 1) ans = 1ll * a * ans % Mod;
    a = 1ll * a * a % Mod;
    p >>= 1;
  }
  return ans;
}
inline int Inv(int x) { return Pow(x, Mod - 2); }
istream &operator>>(istream &in, vector<int> &a) {
  for (unsigned i = 0, ed = a.size(); i < ed; ++i) in >> a[i];
  return in;
}
ostream &operator<<(ostream &out, vector<int> &a) {
  for (unsigned i = 0, ed = a.size(); i < ed; ++i) out << a[i] << " ";
  return out;
}
void NTT(vector<int> &a, int M, int op) {
  a.resize(M);
  vector<int> rev(M);
  int lg = __builtin_popcount(M - 1) - 1;
  for (unsigned i = 0, ed = rev.size(); i < ed; ++i)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << lg);
  for (unsigned i = 0, ed = a.size(); i < ed; ++i)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int i = 1; i < M; i <<= 1) {
    int W = Pow(g, (op * phi / (i << 1) + phi) % phi);
    for (int j = 0; j < M; j += i << 1) {
      for (int k = 0, w = 1; k < i; ++k, w = Mul(w, W)) {
        int x = a[j + k], y = Mul(a[j + k + i], w);
        a[j + k] = Add(x, y), a[j + k + i] = Sub(x, y);
      }
    }
  }
  if (op == -1) {
    int inv = Inv(M);
    for (unsigned i = 0, ed = a.size(); i < ed; ++i) a[i] = Mul(a[i], inv);
  }
}
vector<int> operator+(const vector<int> &a, const vector<int> &b) {
  vector<int> c(max(a.size(), b.size()));
  for (unsigned i = 0, ed = c.size(); i < ed; ++i)
    c[i] = Add((i < a.size() ? a[i] : 0), (i < b.size() ? b[i] : 0));
  return c;
}
vector<int> operator-(const vector<int> &a, const vector<int> &b) {
  vector<int> c(max(a.size(), b.size()));
  for (unsigned i = 0, ed = c.size(); i < ed; ++i)
    c[i] = Sub((i < a.size() ? a[i] : 0), (i < b.size() ? b[i] : 0));
  return c;
}
vector<int> operator*(vector<int> a, vector<int> b) {
  int size = a.size() + b.size() - 1, M = 1;
  for (; M < size; M <<= 1)
    ;
  NTT(a, M, 1);
  NTT(b, M, 1);
  vector<int> c(M);
  for (unsigned i = 0, ed = c.size(); i < ed; ++i) c[i] = Mul(a[i], b[i]);
  NTT(c, M, -1);
  c.resize(size);
  return c;
}
vector<int> Inv(vector<int> a) {
  int size = a.size(), M = 1;
  if (size == 1) return vector<int>(1, Inv(a[0]));
  vector<int> b(a);
  b.resize(size + 1 >> 1);
  b = Inv(b);
  for (; M < size * 2; M <<= 1)
    ;
  NTT(a, M, 1);
  NTT(b, M, 1);
  for (unsigned i = 0, ed = b.size(); i < ed; ++i)
    b[i] = Mul(b[i], Sub(2, Mul(b[i], a[i])));
  NTT(b, M, -1);
  b.resize(size);
  return b;
}
vector<int> operator/(const vector<int> &a, const vector<int> &b) {
  return a * Inv(b);
}
vector<int> Int(const vector<int> &a) {
  vector<int> b(a.size() + 1);
  vector<int> inv(b.size());
  inv[1] = 1;
  for (unsigned i = 2, ed = inv.size(); i < ed; ++i)
    inv[i] = Mul(Mod - Mod / i, inv[Mod % i]);
  for (unsigned i = 0, ed = a.size(); i < ed; ++i)
    b[i + 1] = Mul(inv[i + 1], a[i]);
  return b;
}
vector<int> Der(const vector<int> &a) {
  vector<int> b(a.size() - 1);
  for (unsigned i = 0, ed = b.size(); i < ed; ++i) b[i] = Mul(a[i + 1], i + 1);
  return b;
}
vector<int> Ln(const vector<int> &a) {
  vector<int> c(Int(Der(a) / a));
  c.resize(a.size());
  return c;
}
vector<int> Exp(const vector<int> &a) {
  vector<int> b(1, 1);
  for (unsigned i = 2, ed = a.size() * 2; i < ed; i <<= 1) {
    vector<int> c(a);
    c.resize(i);
    b = b + b * (c - Ln(b));
    b.resize(i << 1);
  }
  b.resize(a.size());
  return b;
}
vector<int> Sqr(const vector<int> &a) {
  int x = sqrt(a[0]);
  vector<int> b(1, x);
  for (unsigned i = 2, ed = a.size() * 2; i < ed; i <<= 1) {
    vector<int> c(a);
    c.resize(i);
    b = b + c / b;
    b.resize(i << 1);
    for (unsigned j = 0, ed = b.size(); j < ed; ++j) b[j] = Mul(b[j], inv2);
  }
  b.resize(a.size());
  return b;
}
vector<int> Pow(const vector<int> &a, int k) {
  return Exp(vector<int>(1, k) * Ln(a));
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  int n, m;
  cin >> n >> m;
  vector<int> c(n), a(m + 1);
  cin >> c;
  for (unsigned i = 0, ed = c.size(); i < ed; ++i)
    if (c[i] <= m) a[c[i]] = 1;
  vector<int> ans =
      vector<int>(1, 2) /
      (vector<int>(1, 1) + Sqr(vector<int>(1, 1) - vector<int>(1, 4) * a));
  for (int i = 1; i <= m; ++i) cout << ans[i] << endl;
  return 0;
}