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 = 998244353;
template <typename T>
struct modular {
  constexpr modular() : val(0) {}
  constexpr modular(const modular<T>& _m) : val(_m.val) {}
  template <typename U>
  constexpr modular(const U& _r = U()) {
    val = -MOD <= _r && _r < MOD ? _r : _r % MOD;
    if (val < 0) {
      val += MOD;
    }
  }
  const T operator()() { return val; }
  template <typename U>
  explicit operator U() const {
    return static_cast<U>(val);
  }
  modular<T>& operator+=(const modular<T>& _m) {
    if ((val += _m.val) >= MOD) {
      val -= MOD;
    }
    return *this;
  }
  modular<T>& operator-=(const modular<T>& _m) {
    if ((val -= _m.val) < 0) {
      val += MOD;
    }
    return *this;
  }
  modular<T>& operator*=(const modular<T>& _m) {
    val = modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val))
              .val;
    return *this;
  }
  modular<T>& operator/=(const modular<T>& _m) {
    T a = _m.val, b = MOD, u = 0, v = 1;
    while (a != 0) {
      T q = b / a;
      b -= q * a;
      swap(a, b);
      u -= q * v;
      swap(u, v);
    }
    return *this *= u;
  }
  modular<T>& operator=(const modular<T>& _m) {
    val = _m.val;
    return *this;
  }
  template <typename U>
  modular<T>& operator+=(const U& _r) {
    return *this += modular<T>(_r);
  }
  template <typename U>
  modular<T>& operator-=(const U& _r) {
    return *this -= modular<T>(_r);
  }
  template <typename U>
  modular<T>& operator*=(const U& _r) {
    return *this *= modular<T>(_r);
  }
  template <typename U>
  modular<T>& operator/=(const U& _r) {
    return *this /= modular<T>(_r);
  }
  template <typename U>
  modular<T>& operator=(const U& _r) {
    val = modular<T>(_r).val;
    return *this;
  }
  modular<T> operator-() { return modular<T>(-val); }
  template <typename U>
  friend bool operator==(const modular<U>&, const modular<U>&);
  friend std::istream& operator>>(std::istream& os, modular<T>& _m) {
    os >> _m.val;
    _m *= 1;
    return os;
  }
  friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) {
    return os << _m.val;
  }
  template <typename U>
  modular<T> exp(U e) {
    modular<T> res = 1;
    modular<T> b = val;
    if (e < 0) {
      b = 1 / b;
      e *= -1;
    }
    for (; e; e >>= 1) {
      if (e & 1) {
        res *= b;
      }
      b *= b;
    }
    return res;
  }

 private:
  T val;
};
template <typename T>
inline modular<T> operator+(const modular<T>& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) {
  return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const U& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) += _rhs;
}
template <typename T>
inline modular<T> operator-(const modular<T>& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const modular<T>& _lhs, const U& _rhs) {
  return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const U& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) -= _rhs;
}
template <typename T>
inline modular<T> operator*(const modular<T>& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) {
  return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const U& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) *= _rhs;
}
template <typename T>
inline modular<T> operator/(const modular<T>& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const modular<T>& _lhs, const U& _rhs) {
  return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const U& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) /= _rhs;
}
template <typename T>
inline bool operator==(const modular<T>& _lhs, const modular<T>& _rhs) {
  return _lhs.val == _rhs.val;
}
template <typename T, typename U>
inline bool operator==(const modular<T>& _lhs, const U& _rhs) {
  return _lhs == modular<T>(_rhs);
}
template <typename T, typename U>
inline bool operator==(const U& _lhs, const modular<T>& _rhs) {
  return modular<T>(_lhs) == _rhs;
}
template <typename T>
inline bool operator!=(const modular<T>& _lhs, const modular<T>& _rhs) {
  return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const modular<T>& _lhs, const U& _rhs) {
  return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const U& _lhs, const modular<T>& _rhs) {
  return !(_lhs == _rhs);
}
modular<int> GEN = 3;
const int FFTH = 18;
const int FFTN = 1 << FFTH;
int REV[FFTH][FFTN];
void build_rev() {
  for (int h = 0; h < FFTH; h++) {
    int n = 1 << (h + 1);
    REV[h][0] = 0;
    for (int i = 1; i < n; i++) {
      REV[h][i] = (REV[h][i >> 1] >> 1) | ((i & 1) << h);
    }
  }
}
bool is_build = false;
template <typename T = modular<int> >
struct Poly : vector<T> {
  using vector<T>::vector;
  Poly() {}
  Poly(initializer_list<T> list) : vector<T>(list) {}
};
template <typename T = modular<int> >
inline Poly<T>& ntt(Poly<T>& a, bool is_inv = false) {
  if (!is_build) {
    is_build = true;
    build_rev();
  }
  int n = a.size();
  assert(n > 1 && (n & (n - 1)) == 0);
  int h = 31 - __builtin_clz(n) - 1;
  if (is_inv) {
    T i_n = T(1) / n;
    for (int i = 0; i < n; i++) {
      a[i] *= i_n;
    }
    reverse(a.begin() + 1, a.end());
  }
  for (int i = 0; i < n; i++) {
    int j = REV[h][i];
    if (i < j) swap(a[i], a[j]);
  }
  for (int m = 1; m < n; m <<= 1) {
    int l = m << 1;
    assert((MOD - 1) % l == 0);
    T _w = GEN.exp((MOD - 1) / l);
    for (int i = 0; i < n; i += l) {
      T w = 1;
      for (int j = 0; j < m; j++) {
        T x = a[i + j];
        T y = w * a[i + j + m];
        a[i + j] = x + y;
        a[i + j + m] = x - y;
        w *= _w;
      }
    }
  }
  return a;
}
template <typename T = modular<int> >
Poly<T>& operator*=(Poly<T>& a, const Poly<T>& _p) {
  if (a.empty() || _p.empty()) {
    a.clear();
    return a;
  }
  int n = a.size() + _p.size() - 1;
  int old = n;
  if (n == 1) {
    a[0] *= _p[0];
    return a;
  }
  int _n = 1 << (31 - __builtin_clz(n));
  if (_n < n) n = _n << 1;
  auto p = _p;
  p.resize(n);
  ntt(p);
  a.resize(n);
  ntt(a);
  for (int i = 0; i < n; i++) {
    a[i] *= p[i];
  }
  ntt(a, true);
  a.resize(old);
  return a;
}
template <typename T = modular<int> >
Poly<T>& operator-=(Poly<T>& a, const Poly<T>& _p) {
  int n = _p.size();
  if (a.size() < n) {
    a.resize(n);
  }
  for (int i = 0; i < n; i++) {
    a[i] -= _p[i];
  }
  return a;
}
template <typename T = modular<int> >
Poly<T> inv(const Poly<T>& a, int n = 0) {
  assert(!a.empty());
  if (!n) n = a.size();
  Poly<T> res = {1 / a[0]};
  int k = 1;
  while (k < n) {
    k <<= 1;
    Poly<T> a_cut(a.begin(), a.begin() + min((int)a.size(), k));
    Poly<T> x = res * res * a_cut;
    res.resize(k);
    for (int i = k >> 1; i < min((int)x.size(), k); i++) {
      res[i] -= x[i];
    }
  }
  res.resize(n);
  return res;
}
template <typename T = modular<int> >
Poly<T> sqrt(const Poly<T>& a) {
  assert(!a.empty());
  int n = a.size();
  Poly<T> res = {1};
  int k = 1;
  T i2 = T(1) / 2;
  while (k < n) {
    k <<= 1;
    Poly<T> x(a.begin(), a.begin() + min((int)a.size(), k));
    res.resize(k);
    x *= inv(res);
    for (int i = k >> 1; i < min((int)x.size(), k); i++) {
      res[i] = x[i] * i2;
    }
  }
  res.resize(n);
  return res;
}
template <typename T = modular<int> >
inline Poly<T> operator*(const Poly<T>& _lhs, const Poly<T>& _rhs) {
  Poly<T> res(_lhs);
  return res *= _rhs;
}
using poly = Poly<modular<int> >;
void solve() {
  int n, m;
  cin >> n >> m;
  poly c(1 << 17);
  for (int i = 0; i < n; i++) {
    int x;
    cin >> x;
    c[x] = 1;
  }
  int sz = 1 << (31 - __builtin_clz(m + 1));
  if (sz < m + 1) sz <<= 1;
  c.resize(sz);
  for (modular<int>& x : c) {
    x *= -4;
  }
  c[0] += 1;
  c = sqrt(c);
  c[0] += 1;
  c = inv(c);
  for (modular<int>& x : c) {
    x *= 2;
  }
  for (int i = 1; i <= m; i++) {
    cout << c[i] << "\n";
  }
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  solve();
  cout << endl;
}