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;
void fast() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
}
namespace Polynomials {
struct cp {
  long double x, y;
  cp(long double x = 0, long double y = 0) : x(x), y(y) {}
  friend cp operator+(const cp& a, const cp& b) {
    return cp(a.x + b.x, a.y + b.y);
  }
  friend cp operator-(const cp& a, const cp& b) {
    return cp(a.x - b.x, a.y - b.y);
  }
  friend cp operator*(const cp& a, const cp& b) {
    return cp(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
  }
  friend cp operator/(const cp& a, double val) {
    return cp(a.x / val, a.y / val);
  }
  friend cp operator/(const cp& a, const cp& b) {
    return cp((a.x * b.x + a.y * b.y) / (b.x * b.x + b.y * b.y),
              (a.y * b.x - a.x * b.y) / (b.x * b.x + b.y * b.y));
  }
};
const int mod = 998244353, G = 3, iG = (mod + 1) / G;
const long double pi = acos(-1.0);
inline int fpw(int a, int b) {
  int res(1);
  for (; b; b >>= 1, a = (long long)a * a % mod)
    if (b & 1) res = (long long)res * a % mod;
  return res;
}
inline int add(int a, int b) { return (a += b) >= mod ? a - mod : a; }
inline int sub(int a, int b) { return (a -= b) < 0 ? a + mod : a; }
vector<int> rev;
void work(int len, int L) {
  rev.clear();
  rev.resize(len);
  for (int i = 0; i < len; ++i)
    rev[i] = ((rev[i >> 1] >> 1) | (i & 1) << (L - 1));
}
void NTT(vector<int>& a, int len, int tp) {
  for (int i = 0; i < len; ++i)
    if (i > rev[i]) swap(a[i], a[rev[i]]);
  for (int l = 2; l <= len; l <<= 1) {
    int mid = (l >> 1), wn = (fpw(tp == 1 ? G : iG, (mod - 1) / l));
    for (int j = 0; j < len; j += l) {
      int w(1);
      for (int k = 0; k < mid; ++k, w = (long long)w * wn % mod) {
        int x = a[j + k], y = (long long)w * a[j + k + mid] % mod;
        a[j + k] = add(x, y);
        a[j + k + mid] = sub(x, y);
      }
    }
  }
  if (tp == -1) {
    int re = fpw(len, mod - 2);
    for (int i = 0; i < len; ++i) a[i] = (long long)a[i] * re % mod;
  }
}
void FFT(vector<cp>& a, int n, int tp) {
  for (int i = 0; i < n; ++i)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int k = 1; k < n; k <<= 1) {
    cp wn(cos(pi / k), tp * sin(pi / k));
    for (int i = 0; i < n; i += (k << 1)) {
      cp w(1, 0);
      for (int j = 0; j < k; ++j, w = w * wn) {
        cp x = a[i + j], y = w * a[i + j + k];
        a[i + j] = x + y;
        a[i + j + k] = x - y;
      }
    }
  }
  if (tp == -1)
    for (int i = 0; i < n; ++i) a[i] = a[i] / double(n);
}
vector<int> operator*(vector<int> a, vector<int> b) {
  int len = 1, L = 0, sz = a.size() + b.size() - 1;
  while (len <= a.size() + b.size() - 2) len <<= 1, ++L;
  work(len, L);
  a.resize(len), b.resize(len);
  NTT(a, len, 1);
  NTT(b, len, 1);
  vector<int> c;
  c.resize(len);
  for (int i = 0; i < len; ++i) c[i] = (long long)a[i] * b[i] % mod;
  NTT(c, len, -1);
  c.resize(sz);
  return c;
}
vector<cp> operator*(vector<cp> a, vector<cp> b) {
  int len = 1, L = 0, sz = a.size() + b.size() - 1;
  while (len <= a.size() + b.size() - 2) len <<= 1, ++L;
  work(len, L);
  a.resize(len), b.resize(len);
  FFT(a, len, 1);
  FFT(b, len, 1);
  vector<cp> c;
  c.resize(len);
  for (int i = 0; i < len; ++i) c[i] = a[i] * b[i];
  FFT(c, len, -1);
  c.resize(sz);
  return c;
}
int BASE = 3e4;
vector<int> getinv(vector<int> a, int n) {
  a.resize(n);
  if (n == 1) {
    vector<int> r(1, fpw(a[0], mod - 2));
    return r;
  }
  vector<int> bp = getinv(a, n / 2 + n % 2);
  vector<int> res1 = bp * bp;
  res1.resize(n);
  res1 = res1 * a;
  res1.resize(n);
  vector<int> res2 = bp;
  res2.resize(n);
  for (int i = 0; i < n; ++i)
    res2[i] = (2ll * res2[i] % mod - res1[i] + mod) % mod;
  return res2;
}
vector<int> getsqrt(vector<int> a, int n) {
  a.resize(n);
  if (n == 1) {
    vector<int> res(1, 1);
    return res;
  }
  vector<int> bp = getsqrt(a, n / 2 + n % 2);
  bp.resize(n);
  vector<int> res = bp * bp;
  res.resize(n);
  for (int i = 0; i < res.size(); ++i) res[i] = add(res[i], a[i]);
  int inv2 = fpw(2, mod - 2);
  for (int i = 0; i < bp.size(); ++i) bp[i] = (long long)bp[i] * 2 % mod;
  res = res * getinv(bp, bp.size());
  res.resize(n);
  return res;
}
}  // namespace Polynomials
using namespace Polynomials;
int main() {
  fast();
  int n, m;
  cin >> n >> m;
  vector<int> A(m + 1), A2(m + 1), SQ(m + 1);
  for (int i = 1; i <= n; ++i) {
    int x;
    cin >> x;
    if (x <= m) A[x] = 1;
  }
  A2 = SQ = A;
  for (int i = 0; i <= m; ++i) SQ[i] = (mod - SQ[i] * 4LL % mod) % mod;
  SQ[0] = add(SQ[0], 1);
  SQ = getsqrt(SQ, m + 1);
  SQ[0] = add(SQ[0], 1);
  for (int i = 0; i <= m; ++i) A2[i] = (i == 0) * 2;
  vector<int> res = A2 * getinv(SQ, m + 1);
  res.resize(m + 1);
  for (int i = 1; i <= m; ++i) cout << res[i] << '\n';
  return 0;
}