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>
struct MI {
 private:
  char bb[4096];
  FILE *f;
  char *bs, *be;
  char e;
  bool o, l;

 public:
  MI() : f(stdin) {}
  inline char get() {
    if (o) {
      o = 0;
      return e;
    }
    if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
    if (bs == be) {
      l = 1;
      return -1;
    };
    return *bs++;
  }
  inline void unget(char c) {
    o = 1;
    e = c;
  }
  template <typename T>
  inline T read() {
    T r;
    *this > r;
    return r;
  }
  template <typename T>
  inline MI &operator>(T &);
};
template <typename T>
struct Q {
  const static bool U = T(-1) >= T(0);
  inline void operator()(MI &t, T &r) const {
    r = 0;
    char c;
    bool y = 0;
    if (U)
      for (;;) {
        c = t.get();
        if (c == -1) goto E;
        if (isdigit(c)) break;
      }
    else
      for (;;) {
        c = t.get();
        if (c == -1) goto E;
        if (c == '-') {
          c = t.get();
          if (isdigit(c)) {
            y = 1;
            break;
          };
        } else if (isdigit(c))
          break;
        ;
      };
    for (;;) {
      if (c == -1) goto E;
      if (isdigit(c))
        r = r * 10 + (c ^ 48);
      else
        break;
      c = t.get();
    }
    t.unget(c);
  E:;
    if (y) r = -r;
  }
};
template <>
struct Q<char> {};
template <typename T>
inline MI &MI::operator>(T &t) {
  Q<T>()(*this, t);
  return *this;
}
template <typename T>
std::ostream &operator<(std::ostream &out, const T &t) {
  return out << t;
}
using std::cout;
MI cin;
const int mod = 998244353;
const int inv2 = 499122177;
inline void upd(int &x) { x += (x >> 31) & mod; }
inline int pro(int x) { return x + ((x >> 31) & mod); }
inline long long ksm(long long x, int p = mod - 2) {
  long long ret = 1;
  while (p) {
    if (p & 1) (ret *= x) %= mod;
    (x *= x) %= mod;
    p >>= 1;
  }
  return ret;
}
template <bool rev>
inline void ntt(int *v, int len) {
  static struct _ {
    int rt[30], irt[30], inv[30];
    _() {
      for (int i = 0, j = 1; i < 30; ++i, j <<= 1) {
        rt[i] = ksm(3, (mod - 1) / j);
        irt[i] = ksm(3, (long long)((mod - 1) / j) * (mod - 2) % (mod - 1));
        inv[i] = ksm(j);
      }
    }
  } _;
  assert(!(len & (len - 1)));
  for (int i = 0, j = 0; i < len; ++i) {
    if (i > j) std::swap(v[i], v[j]);
    for (int k = len >> 1; (j ^= k) < k; k >>= 1)
      ;
  }
  for (int i = 1, q = 2, c = 1; i < len; i = q, q <<= 1, ++c) {
    const int delta = (rev ? _.irt : _.rt)[c];
    for (int j = 0; j < len; j += i << 1)
      for (int k = 0, w = 1; k < i; ++k, w = (long long)w * delta % mod) {
        const int x = v[j | k], y = (long long)v[i | j | k] * w % mod;
        v[j | k] = pro(x + y - mod);
        v[i | j | k] = pro(x - y);
      }
  }
  if (!rev) return;
  for (int i = 0, r = _.inv[__builtin_ctz(len)]; i < len; ++i)
    v[i] = (long long)v[i] * r % mod;
}
struct poly : public std::vector<int> {
  static inline int round_up(int x) {
    return (x & (x - 1)) ? (1 << (32 - __builtin_clz(x))) : x;
  }
  poly() {}
  inline poly &from(const poly &a, int n) {
    resize(n);
    const int len = std::min(n, (int)a.size());
    std::copy(a.begin(), a.begin() + len, begin());
    std::fill(begin() + len, end(), 0);
    return (*this);
  }
  inline poly take(int n) const { return poly().from((*this), n); }
  template <bool rev>
  inline poly &ntt(int len) {
    resize(round_up(len), 0);
    ::ntt<rev>(data(), size());
    return (*this);
  }
  template <bool rev>
  inline poly &ntt() {
    return ntt<rev>(size());
  }
  inline poly &trim() {
    while (!empty() && !back()) pop_back();
    return (*this);
  }
  inline poly &operator*=(const poly &a) {
    static poly tmp;
    if (empty() || a.empty()) return clear(), (*this);
    const int l = size() + a.size() - 1, len = round_up(l);
    ntt<0>(len);
    (tmp = a).ntt<0>(len);
    for (int i = 0; i < len; ++i)
      (*this)[i] = (long long)(*this)[i] * tmp[i] % mod;
    return ntt<1>(len), resize(l), (*this);
  }
  inline poly &operator*=(int t) {
    for (int &d : (*this)) d = (long long)d * t % mod;
    return *this;
  }
  inline poly integral() const { return poly((*this)).inplace_integral(); }
  inline poly &inplace_integral() {
    if (empty()) return clear(), (*this);
    push_back(0);
    for (size_t i = size() - 1; i; --i)
      (*this)[i] = (long long)(*this)[i - 1] * ksm(i) % mod;
    (*this)[0] = 0;
    return (*this);
  }
  inline poly derivative() const { return poly((*this)).inplace_derivative(); }
  inline poly &inplace_derivative() {
    if (size() <= 1) return clear(), (*this);
    for (size_t i = 1; i < size(); ++i)
      (*this)[i - 1] = (long long)(*this)[i] * i % mod;
    return pop_back(), (*this);
  }
  inline poly reverse() const { return poly((*this)).inplace_reverse(); }
  inline poly &inplace_reverse() {
    return std::reverse(begin(), end()), (*this);
  }
  template <class Func>
  inline poly &newton(const poly &a, int len, int initial, const Func &trans) {
    static poly tmp;
    if (len == -1) len = a.size();
    if (a.empty()) return clear(), (*this);
    const int lim = round_up(len);
    clear();
    push_back(initial);
    for (int l = 2; l <= lim; l <<= 1) {
      tmp.from(a, l);
      trans(l, tmp);
    }
    return resize(len), (*this);
  }
  inline poly inv(int len = -1) const { return poly().from_inv((*this), len); }
  inline poly &from_inv(const poly &a, int len = -1) {
    assert(!a.empty());
    return newton(a, len, ksm(a[0]), [this](int l, poly &tmp) {
      const int q = l << 1;
      tmp.ntt<0>(q);
      ntt<0>(q);
      for (int i = 0; i < q; ++i)
        (*this)[i] = (long long)(*this)[i] *
                     pro(2 - (long long)(*this)[i] * tmp[i] % mod) % mod;
      ntt<1>();
      resize(l);
    });
  }
  inline poly ln(int len = -1) const { return poly().from_ln((*this), len); }
  inline poly &from_ln(const poly &a, int len = -1) {
    if (len == -1) len = a.size();
    assert(!a.empty() && a[0] == 1);
    from_inv(a, len);
    (*this) *= a.derivative();
    resize(len - 1);
    return inplace_integral();
  }
  inline poly exp(int len = -1) const { return poly().from_exp((*this), len); }
  inline poly &from_exp(const poly &a, int len = -1) {
    static poly t2;
    if (a.empty()) return clear(), push_back(1), (*this);
    assert(!a[0]);
    return newton(a, len, 1, [this](int l, poly &t1) {
      t2.from_ln((*this), l);
      for (int i = 0; i < l; ++i) t2[i] = pro(t1[i] - t2[i]);
      upd(t2[0] += 1 - mod);
      (*this) *= t2;
      resize(l);
    });
  }
  inline poly sqrt(int len = -1) const {
    return poly().from_sqrt((*this), len);
  }
  inline poly &from_sqrt(const poly &a, int len = -1) {
    if (a.empty()) return clear(), (*this);
    assert(a[0] == 1);
    return newton(a, len, 1, [this](int l, poly &tmp) {
      tmp *= inv(l);
      resize(l);
      for (int i = 0; i < l; ++i)
        (*this)[i] = (long long)pro((*this)[i] + tmp[i] - mod) * inv2 % mod;
    });
  }
  inline poly &from_division(const poly &a, const poly &b) {
    const int len = a.size() - b.size() + 1;
    assert(len >= 0);
    resize(len);
    std::reverse_copy(a.end() - len, a.end(), begin());
    (*this) *= b.reverse().inv(len);
    return resize(len), inplace_reverse();
  }
  inline poly &from_remainder(const poly &a, const poly &b, const poly &q) {
    const int m = b.size() - 1;
    from(b, m) *= q.take(m);
    resize(m);
    for (int i = 0; i < m; ++i) (*this)[i] = pro(a[i] - (*this)[i]);
    return (*this);
  }
  inline poly operator/(const poly &a) {
    return poly().from_division((*this), a);
  }
};
template <>
struct Q<poly> {};
int n, m;
poly A, B;
int main() {
  cin > n > m;
  A.resize(m + 1, 0);
  for (int i = 0; i < n; ++i) {
    const int x = (cin.read<int>());
    if (x <= m) ++A[x];
  }
  for (int i = 0; i <= m; ++i) A[i] = pro(-(long long)A[i] * 4 % mod);
  upd(A[0] += 1 - mod);
  B.from_sqrt(A);
  upd(B[0] += 1 - mod);
  A.from_inv(B);
  for (int i = 1; i <= m; ++i) cout < pro(A[i] + A[i] - mod) < ('\n');
}