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 maxn = 131072 << 2;
const int P = 998244353;
struct MOD {
  int x;
  MOD(int x_ = 0) : x(x_) {
    if (x < 0) x += P;
    if (x >= P) x -= P;
  }
  MOD operator+(const MOD& rhs) const { return MOD(x + rhs.x); }
  MOD operator-(const MOD& rhs) const { return MOD(x - rhs.x); }
  MOD operator-() const { return MOD(-x); }
  MOD operator*(const MOD& rhs) const { return MOD(int(1LL * x * rhs.x % P)); }
} w[maxn + 1];
MOD mypow(MOD x, int b) {
  MOD res = 1;
  while (b) {
    if (b & 1) res = res * x;
    x = x * x;
    b >>= 1;
  }
  return res;
}
void pre_ntt() {
  MOD dw = mypow(3, (P - 1) / maxn);
  w[0] = 1;
  for (int i = 1; i <= maxn; i++) w[i] = w[i - 1] * dw;
}
void ntt(vector<MOD>& v, int n, bool inv) {
  for (int i = 0, j = 0; i < n; i++) {
    if (i > j) swap(v[i], v[j]);
    for (int s = n >> 1; (j ^= s) < s; s >>= 1)
      ;
  }
  for (int s = 2; s <= n; s <<= 1) {
    int z = s >> 1;
    for (int i = 0; i < n; i += s)
      for (int j = 0; j < z; j++) {
        MOD x = v[i + z + j] * w[maxn / s * j];
        v[i + z + j] = v[i + j] - x;
        v[i + j] = v[i + j] + x;
      }
  }
  if (inv) {
    reverse(v.begin() + 1, v.end());
    MOD invn = mypow(n, P - 2);
    for (int i = 0; i < n; i++) v[i] = v[i] * invn;
  }
}
vector<int> conv(const vector<int>& a, const vector<int>& b) {
  int sz = 1;
  while (sz < a.size() + b.size() - 1) sz <<= 1;
  vector<MOD> fa(sz), fb(sz);
  for (int i = 0; i < a.size(); i++) fa[i] = a[i];
  for (int i = 0; i < b.size(); i++) fb[i] = b[i];
  ntt(fa, sz, 0);
  ntt(fb, sz, 0);
  for (int i = 0; i < sz; i++) fa[i] = fa[i] * fb[i];
  ntt(fa, sz, 1);
  vector<int> res(sz);
  for (int i = 0; i < sz; i++) res[i] = fa[i].x;
  while (!res.empty() && res.back() == 0) res.pop_back();
  return res;
}
vector<MOD> conv(const vector<MOD>& a, const vector<MOD>& b) {
  int sz = 1;
  while (sz < a.size() + b.size() - 1) sz <<= 1;
  vector<MOD> fa(sz), fb(sz);
  for (int i = 0; i < a.size(); i++) fa[i] = a[i];
  for (int i = 0; i < b.size(); i++) fb[i] = b[i];
  ntt(fa, sz, 0);
  ntt(fb, sz, 0);
  for (int i = 0; i < sz; i++) fa[i] = fa[i] * fb[i];
  ntt(fa, sz, 1);
  return fa;
}
vector<MOD> deriv(const vector<MOD>& a) {
  if (a.empty()) return {};
  vector<MOD> b(a.size() - 1);
  for (int i = 1; i < a.size(); i++) b[i - 1] = a[i] * i;
  return b;
}
vector<MOD> integ(const vector<MOD>& a) {
  vector<MOD> b(a.size() + 1);
  b[1] = 1;
  for (int i = 2; i < b.size(); i++) b[i] = b[P % i] * (-P / i);
  for (int i = 1; i < b.size(); i++) b[i] = b[i] * a[i - 1];
  return b;
}
vector<MOD> inverse(const vector<MOD>& a) {
  if (a.empty()) return {};
  vector<MOD> b({mypow(a[0], P - 2)}), fa;
  b.reserve(a.size() * 2);
  while (b.size() < a.size()) {
    int n = 2 * b.size();
    b.resize(2 * n, 0);
    fa.resize(2 * n);
    copy(a.begin(), a.begin() + min(n, (int)a.size()), fa.begin());
    fill(fa.begin() + min(n, (int)a.size()), fa.end(), 0);
    ntt(b, 2 * n, 0);
    ntt(fa, 2 * n, 0);
    for (int i = 0; i < 2 * n; i++) b[i] = b[i] * (-fa[i] * b[i] + 2);
    ntt(b, 2 * n, 1);
    b.resize(n);
  }
  b.resize(a.size());
  return b;
}
vector<MOD> log(const vector<MOD>& a) {
  vector<MOD> b = integ(conv(deriv(a), inverse(a)));
  b.resize(a.size());
  return b;
}
vector<MOD> exp(const vector<MOD>& a) {
  vector<MOD> b({MOD(1)});
  if (a.empty()) return b;
  while (b.size() < a.size()) {
    int n = min(b.size() * 2, a.size());
    b.resize(n);
    vector<MOD> v = log(b);
    for (int i = 0; i < n; i++) v[i] = a[i] - v[i];
    v[0] = v[0] + 1;
    b = conv(b, v);
    b.resize(n);
  }
  return b;
}
vector<MOD> pow(const vector<MOD>& a, int m) {
  vector<MOD> b(a.size());
  if (!m) {
    b[0] = 1;
    return b;
  }
  int p = 0;
  while (p < a.size() && a[p].x == 0) p++;
  if (1LL * m * p >= a.size()) return b;
  MOD mu = mypow(a[p], m), di = mypow(a[p], P - 2);
  vector<MOD> c(a.size() - m * p);
  for (int i = 0; i < c.size(); i++) c[i] = a[i + p] * di;
  c = log(c);
  for (auto& it : c) it = it * m;
  c = exp(c);
  for (int i = 0; i < c.size(); i++) b[i + m * p] = c[i] * mu;
  return b;
}
vector<MOD> sqrt(const vector<MOD>& a) {
  vector<MOD> b({MOD(1)});
  if (a.empty()) return {};
  while (b.size() < a.size()) {
    int n = min(b.size() * 2, a.size());
    vector<MOD> v = conv(b, b);
    v.resize(n);
    b.resize(n);
    for (int i = 0; i < b.size(); i++) v[i] = (v[i] + a[i]) * ((P + 1) >> 1);
    b = conv(v, inverse(b));
    b.resize(n);
  }
  return b;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  pre_ntt();
  int n, m;
  cin >> n >> m;
  int mm = 1e9;
  vector<int> tmp(n);
  for (int i = 0; i < n; i++) {
    cin >> tmp[i];
    mm = min(mm, tmp[i]);
  }
  vector<MOD> T(100001 + mm), TT(100001 + mm);
  for (int i = 0; i < n; i++) {
    TT[tmp[i]] = -4;
    T[tmp[i] - mm] = 2;
  }
  TT[0] = 1;
  TT = sqrt(TT);
  for (int i = 0; i < TT.size(); i++) TT[i] = -TT[i];
  TT[0] = TT[0] + 1;
  for (int i = 0; i + mm < TT.size(); i++) TT[i] = TT[i + mm];
  T = inverse(T);
  TT = conv(TT, T);
  for (int i = 1; i <= m; i++) cout << TT[i].x << '\n';
}