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>
#pragma GCC optimize(2)
using namespace std;
namespace polynomial {
const int N = 1e5 + 10;
const int M = N << 3;
const int mod = 998244353;
const int G = 3;
const int SIZE = sizeof(int);
int w[M], rev[M];
vector<int> resize(vector<int> f, int n) {
  f.resize(n);
  return f;
}
int sub(int a, int b) {
  a -= b;
  if (a < 0)
    return a + mod;
  else
    return a;
}
int add(int a, int b) {
  a += b;
  if (a >= mod)
    return a - mod;
  else
    return a;
}
int inv(int x) {
  if (x < 2)
    return 1;
  else
    return (1ll * mod - mod / x) * inv(mod % x) % mod;
}
int qkpow(int a, int b) {
  if (b == 0) return 1;
  if (b == 1) return a;
  int t = qkpow(a, b / 2);
  t = (1ll * t * t) % mod;
  if (b % 2 == 1) t = (1ll * t * a) % mod;
  return t;
}
vector<int> operator+(vector<int> f, int a) {
  f[0] = add(f[0], a);
  return f;
}
vector<int> operator+(int a, vector<int> f) {
  f[0] = add(f[0], a);
  return f;
}
vector<int> operator+(vector<int> f, const vector<int> &g) {
  f.resize(max(f.size(), g.size()));
  for (int i = 0; i < f.size(); i++) f[i] = add(f[i], i < g.size() ? g[i] : 0);
  return f;
}
vector<int> operator-(vector<int> f, int a) {
  f[0] = sub(f[0], a);
  return f;
}
vector<int> operator-(int a, vector<int> f) {
  for (int i = 0; i < f.size(); i++) f[i] = sub(0, f[i]);
  f[0] = add(f[0], a);
  return f;
}
vector<int> operator-(vector<int> f, const vector<int> &g) {
  f.resize(max(f.size(), g.size()));
  for (int i = 0; i < f.size(); i++) f[i] = sub(f[i], i < g.size() ? g[i] : 0);
  return f;
}
vector<int> operator*(vector<int> f, int a) {
  for (int i = 0; i < f.size(); i++) f[i] = 1ll * f[i] * a % mod;
  return f;
}
vector<int> operator*(int a, vector<int> f) {
  for (int i = 0; i < f.size(); i++) f[i] = 1ll * f[i] * a % mod;
  return f;
}
namespace cipolla_namespace {
int t;
int sqrt_w;
pair<int, int> p;
pair<int, int> operator*(const pair<int, int> &a, const pair<int, int> &b) {
  return make_pair(
      (1ll * a.first * b.first + 1ll * a.second * b.second % mod * sqrt_w) %
          mod,
      (1ll * a.first * b.second + 1ll * a.second * b.first) % mod);
}
int cipolla(int first) {
  do {
    t = rand() % mod;
    sqrt_w = sub(1ll * t * t % mod, first);
  } while (qkpow(sqrt_w, (mod - 1) >> 1) != mod - 1);
  pair<int, int> s = make_pair(1, 0);
  pair<int, int> a = make_pair(t, 1);
  for (int b = (mod + 1) >> 1; b; b >>= 1, a = a * a)
    if (b & 1) s = s * a;
  return min(s.first, mod - s.first);
}
}  // namespace cipolla_namespace
using cipolla_namespace::cipolla;
void ntt(int *a, int lim) {
  for (int i = 0; i < lim; i++)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int len = 1; len < lim; len <<= 1) {
    for (int i = 0; i < lim; i += (len << 1)) {
      for (int j = 0; j < len; j++) {
        int x = a[i + j];
        int y = 1ll * w[j + len] * a[i + j + len] % mod;
        a[i + j] = add(x, y);
        a[i + j + len] = sub(x, y);
      }
    }
  }
}
void ntt_init() {
  int wn;
  for (int len = 1; (len << 1) < M; len <<= 1) {
    wn = qkpow(G, (mod - 1) / (len << 1));
    w[len] = 1;
    for (int i = 1; i < len; i++) w[i + len] = 1ll * w[i + len - 1] * wn % mod;
  }
}
int init(int len) {
  int lim = 1;
  int k = 0;
  while (lim < len) {
    lim <<= 1;
    k++;
  }
  for (int i = 0; i < lim; i++)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (k - 1));
  return lim;
}
vector<int> operator*(const vector<int> &f, const vector<int> &g) {
  int a[M] = {};
  int b[M] = {};
  int lim = init(f.size() + g.size() - 1);
  int inv_len = inv(lim);
  vector<int> ret;
  for (int i = 0; i < f.size(); i++) a[i] = f[i];
  for (int i = 0; i < g.size(); i++) b[i] = g[i];
  ntt(a, lim);
  ntt(b, lim);
  for (int i = 0; i < lim; i++) a[i] = 1ll * a[i] * b[i] % mod;
  reverse(a + 1, a + lim);
  ntt(a, lim);
  for (int i = 0; i < f.size() + g.size() - 1; i++)
    ret.push_back(1ll * a[i] * inv_len % mod);
  return ret;
}
vector<int> inv(const vector<int> &f) {
  int a[M] = {};
  int b[M] = {};
  vector<int> g;
  g.push_back(inv(f[0]));
  for (int len = 2; (len >> 1) < f.size(); len <<= 1) {
    int lim = init(len << 1);
    int inv_len = inv(lim);
    memset(&a[len], 0, len * SIZE);
    memset(&b[len], 0, len * SIZE);
    for (int i = 0; i < len; i++) a[i] = i < f.size() ? f[i] : 0;
    for (int i = 0; i < len; i++) b[i] = i < g.size() ? g[i] : 0;
    ntt(a, lim);
    ntt(b, lim);
    for (int i = 0; i < lim; i++) a[i] = (1ll * a[i] * b[i] % mod) * b[i] % mod;
    reverse(a + 1, a + lim);
    ntt(a, lim);
    g.resize(len);
    for (int i = 0; i < g.size(); i++)
      g[i] = sub(add(g[i], g[i]), 1ll * a[i] * inv_len % mod);
    g.resize(f.size());
  }
  g.resize(f.size());
  return g;
}
vector<int> sqrt(const vector<int> &f) {
  vector<int> g;
  g.push_back(cipolla(f[0]));
  for (int len = 2; (len >> 1) < f.size(); len <<= 1)
    g = resize(resize(resize(g * g, len) + f, len) * inv(resize(2 * g, len)),
               len);
  g.resize(f.size());
  return g;
}
vector<int> deri(const vector<int> &f) {
  vector<int> g;
  for (int i = 0; i < f.size() - 1; i++)
    g.push_back(1ll * (i + 1) * f[i + 1] % mod);
  g.push_back(0);
  return g;
}
vector<int> inte(vector<int> f) {
  vector<int> g;
  g.push_back(0);
  for (int i = 0; i < f.size() - 1; i++)
    g.push_back(1ll * inv(i + 1) * f[i] % mod);
  return g;
}
vector<int> ln(const vector<int> &f) {
  return inte(resize(deri(f) * inv(f), f.size()));
}
vector<int> exp(const vector<int> &f) {
  vector<int> g;
  g.push_back(1);
  for (int len = 2; (len >> 1) < f.size(); len <<= 1)
    g = resize(g * (1 - ln(resize(g, len)) + resize(f, len)), len);
  g.resize(f.size());
  return g;
}
void div(vector<int> f, vector<int> q, vector<int> &g, vector<int> &r) {
  int lenq = q.size();
  reverse(f.begin(), f.end());
  reverse(q.begin(), q.end());
  vector<int> _q = q;
  q = resize(q, f.size() - q.size() + 1);
  g = resize(f * inv(q), f.size() - lenq + 1);
  reverse(g.begin(), g.end());
  reverse(f.begin(), f.end());
  q = _q;
  reverse(q.begin(), q.end());
  r = resize(f - q * g, lenq - 1);
}
vector<int> qkpow(vector<int> a, int b) {
  int n = a.size();
  vector<int> s;
  s.push_back(1);
  while (b) {
    if (b & 1) s = resize(s * a, n);
    a = resize(a * a, n);
    b >>= 1;
  }
  return s;
}
};  // namespace polynomial
using namespace polynomial;
void read(int &x) {
  x = 0;
  int f = 1;
  char c = getchar();
  while ('0' > c || c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while ('0' <= c && c <= '9') {
    x = (x << 3) + (x << 1) + c - '0';
    c = getchar();
  }
  x *= f;
}
void write(int x) {
  if (x > 9) write(x / 10);
  putchar(x % 10 + '0');
}
int n, m;
vector<int> g;
vector<int> f;
int main() {
  ntt_init();
  cin >> n >> m;
  m++;
  g.resize(m);
  for (int i = 1; i <= n; i++) {
    int x;
    cin >> x;
    if (x < m) g[x] = 1;
  }
  g = 1 - 4 * g;
  g.resize(m);
  g = 1 + sqrt(g);
  g.resize(m);
  f = 2 * inv(g);
  f.resize(m);
  for (int i = 1; i < m; i++) cout << f[i] << '\n';
  return 0;
}