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 N = 400005;
const int g = 3;
const int MOD = 998244353;
int ksm(int a, int b) {
  int res = 1;
  while (b) {
    if (b & 1) res = 1LL * res * a % MOD;
    a = 1LL * a * a % MOD, b >>= 1;
  }
  return res;
}
int W[2][N << 1];
void init(int n = 400000) {
  for (int len = 1; len <= n; len <<= 1) {
    int w = ksm(g, (MOD - 1) / len), iw = ksm(w, MOD - 2);
    W[0][len] = W[1][len] = 1;
    for (int k = 1; k < len; k++)
      W[0][len + k] = 1LL * W[0][len + k - 1] * w % MOD,
                 W[1][len + k] = 1LL * W[1][len + k - 1] * iw % MOD;
  }
  return;
}
vector<int> operator+(const vector<int> &F, const vector<int> &G) {
  vector<int> f = F, g = G;
  int n = f.size() - 1, m = g.size() - 1;
  int s = max(n, m);
  vector<int> res(s + 1);
  for (int i = 0; i <= s; i++) {
    if (i <= n) res[i] = (res[i] + f[i]) % MOD;
    if (i <= m) res[i] = (res[i] + g[i]) % MOD;
  }
  return res;
}
vector<int> operator-(const vector<int> &F, const vector<int> &G) {
  vector<int> f = F, g = G;
  int n = f.size() - 1, m = g.size() - 1;
  int s = max(n, m);
  vector<int> res(s + 1);
  for (int i = 0; i <= s; i++) {
    if (i <= n) res[i] = (res[i] + f[i]) % MOD;
    if (i <= m) res[i] = (res[i] - g[i] + MOD) % MOD;
  }
  return res;
}
vector<int> operator*(const vector<int> &F, const int &x) {
  vector<int> f = F;
  int n = f.size() - 1;
  for (int i = 0; i <= n; i++) f[i] = 1LL * f[i] * x % MOD;
  return f;
}
vector<int> operator*(const int &x, const vector<int> &F) { return F * x; }
vector<int> ntt(const vector<int> &F, const vector<int> &G,
                const function<int(int, int)> &mul) {
  vector<int> f = F, g = G;
  int n = f.size() - 1, m = g.size() - 1;
  m += n, n = 1;
  while (n <= m) n <<= 1;
  f.resize(n), g.resize(n);
  vector<int> rev(n);
  for (int i = 0; i < n; i++) {
    rev[i] = rev[i / 2] >> 1;
    if (i & 1) rev[i] |= n >> 1;
  }
  static const int BIT = 15;
  function<void(vector<int> &)> dft = [=](vector<int> &F) {
    int n = F.size();
    vector<unsigned long long> f(n);
    for (int i = 0; i < n; i++) f[i] = F[rev[i]];
    for (int len = 2; len <= n; len <<= 1) {
      if (len & (1 << BIT)) {
        for (int i = 0; i < n; i++) f[i] %= MOD;
      }
      for (int i = 0; i < n; i += len)
        for (int k = i; k < i + len / 2; k++) {
          unsigned long long l = f[k];
          int r = f[k + len / 2] * W[0][len + k - i] % MOD;
          f[k] = l + r;
          f[k + len / 2] = l + MOD - r;
        }
    }
    for (int i = 0; i < n; i++) F[i] = f[i] % MOD;
    return;
  };
  function<void(vector<int> &)> idft = [=](vector<int> &F) {
    int n = F.size();
    vector<unsigned long long> f(n);
    for (int i = 0; i < n; i++) f[i] = F[rev[i]];
    for (int len = 2; len <= n; len <<= 1) {
      if (len & (1 << BIT)) {
        for (int i = 0; i < n; i++) f[i] %= MOD;
      }
      for (int i = 0; i < n; i += len)
        for (int k = i; k < i + len / 2; k++) {
          unsigned long long l = f[k];
          int r = f[k + len / 2] * W[1][len + k - i] % MOD;
          f[k] = l + r;
          f[k + len / 2] = l + MOD - r;
        }
    }
    for (int i = 0; i < n; i++) F[i] = f[i] % MOD;
    return;
  };
  dft(f);
  dft(g);
  for (int i = 0; i < n; i++) f[i] = mul(f[i], g[i]);
  idft(f);
  int invn = ksm(n, MOD - 2);
  f.resize(m + 1);
  for (int i = 0; i <= m; i++) f[i] = 1LL * f[i] * invn % MOD;
  return f;
}
vector<int> operator*(const vector<int> &F, const vector<int> &G) {
  return ntt(F, G,
             [=](const int &x, const int &y) { return 1LL * x * y % MOD; });
}
vector<int> getinv(const vector<int> &F) {
  vector<int> f = F;
  int m = f.size() - 1;
  int n = 1;
  while (n <= m) n <<= 1;
  f.resize(n);
  vector<int> g = {ksm(f[0], MOD - 2)};
  for (int m = 2; m <= n; m <<= 1) {
    vector<int> t(f.begin(), f.begin() + m);
    g = ntt(t, g, [=](const int &x, const int &y) {
      return (2 * y - 1LL * y * y % MOD * x % MOD + MOD) % MOD;
    });
    g.resize(m);
  }
  g.resize(m + 1);
  return g;
}
int w;
struct Complex {
  int real, imag;
  bool operator==(const Complex &b) const {
    return real == b.real && imag == b.imag;
  }
  Complex operator*(const Complex &b) const {
    Complex res;
    res.real = (1LL * real * b.real + 1LL * w * imag % MOD * b.imag) % MOD;
    res.imag = (1LL * real * b.imag + 1LL * imag * b.real) % MOD;
    return res;
  }
  friend Complex ksm(Complex a, int b) {
    Complex res = (Complex){1, 0};
    while (b) {
      if (b & 1) res = res * a;
      a = a * a, b >>= 1;
    }
    return res;
  }
};
int cipolla(int n) {
  static mt19937 myrand(time(NULL));
  if (n == 0) return 0;
  function<bool(int)> check = [=](const int &n) {
    return ksm(n, (MOD - 1) / 2) == 1;
  };
  if (!check(n)) return -1;
  int a = myrand() % (MOD - 1) + 1;
  while (check((1LL * a * a - n + MOD) % MOD)) a = myrand() % (MOD - 1) + 1;
  w = (1LL * a * a - n + MOD) % MOD;
  Complex res = ksm((Complex){a, 1}, (MOD + 1) / 2);
  return res.real;
}
vector<int> sqrt(const vector<int> &F) {
  vector<int> f = F;
  int m = f.size() - 1;
  int n = 1;
  while (n <= m) n <<= 1;
  f.resize(n);
  int g0 = cipolla(f[0]);
  vector<int> g = {min(g0, MOD - g0)};
  int inv2 = ksm(2, MOD - 2);
  for (int m = 2; m <= n; m <<= 1) {
    vector<int> t(f.begin(), f.begin() + m);
    g.resize(m);
    g = g * inv2 + ntt(t, getinv(g), [=](const int &x, const int &y) {
          return 1LL * inv2 * x % MOD * y % MOD;
        });
    g.resize(m);
  }
  g.resize(m + 1);
  return g;
}
int n, m;
int c[N];
int main() {
  init();
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
  vector<int> g(m + 1);
  for (int i = 1; i <= n; i++)
    if (c[i] <= m) g[c[i]] = 1;
  vector<int> f = 2 * getinv((vector<int>){1} + sqrt((vector<int>){1} - 4 * g));
  for (int i = 1; i <= m; i++) printf("%d\n", f[i]);
  return 0;
}