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>
int read() {
  int res = 0, c;
  do c = getchar();
  while (c < '0' || c > '9');
  while ('0' <= c && c <= '9') {
    res = res * 10 + c - '0';
    c = getchar();
  }
  return res;
}
const int mod = 998244353;
long long powm(long long a, int k) {
  long long res = 1;
  while (k) {
    if (k & 1) res = res * a % mod;
    k >>= 1, a = a * a % mod;
  }
  return res;
}
int add(int a, int b) {
  a += b;
  return a < mod ? a : a - mod;
}
int sub(int a, int b) {
  a -= b;
  return a >= 0 ? a : a + mod;
}
std::vector<int> rc[20], irc[20], rvc[20];
const std::vector<int>& getRev(int k) {
  if (rvc[k].empty()) {
    int off = k - 1, siz = 1 << k;
    std::vector<int>& rev = rvc[k];
    rev.resize(siz);
    for (int i = 1; i < siz; ++i) rev[i] = rev[i >> 1] >> 1 | ((i & 1) << off);
  }
  return rvc[k];
}
typedef const std::vector<int>& (*Func)(int);
const std::vector<int>& getRoot(int k) {
  if (rc[k].empty()) {
    int siz = 1 << k;
    long long base = powm(3, (mod - 1) / siz);
    std::vector<int>& root = rc[k];
    root.resize(siz);
    root[0] = 1;
    for (int i = 1; i < siz; ++i)
      root[i] = static_cast<long long>(root[i - 1]) * base % mod;
  }
  return rc[k];
}
const std::vector<int>& getInvRoot(int k) {
  if (irc[k].empty()) {
    int siz = 1 << k;
    long long base = powm(3, (mod - 1) / siz);
    long long invBase = powm(base, mod - 2);
    std::vector<int>& invR = irc[k];
    invR.resize(siz);
    invR[0] = 1;
    for (int i = 1; i < siz; ++i)
      invR[i] = static_cast<long long>(invR[i - 1]) * invBase % mod;
  }
  return irc[k];
}
int* data(std::vector<int>& A) { return &*A.begin(); }
const int* data(const std::vector<int>& A) { return &*A.begin(); }
void NTT(int n, std::vector<int>& A, Func w) {
  int p = 0;
  while ((1 << p) != n) ++p;
  const std::vector<int>& rev = getRev(p);
  for (int i = 0; i < n; ++i)
    if (i < rev[i]) std::swap(A[i], A[rev[i]]);
  for (int i = 2, cp = 1; i <= n; i <<= 1, ++cp) {
    int m = i >> 1;
    const std::vector<int>& cw = w(cp);
    for (int j = 0; j < n; j += i)
      for (int k = 0; k < m; ++k) {
        int &x = A[j + k], &y = A[j + m + k];
        int t = static_cast<long long>(cw[k]) * y % mod;
        y = sub(x, t);
        x = add(x, t);
      }
  }
}
void DFT(int n, std::vector<int>& A) { NTT(n, A, getRoot); }
void IDFT(int n, std::vector<int>& A, int b, int e, bool lc = true,
          bool hc = true) {
  NTT(n, A, getInvRoot);
  long long div = powm(n, mod - 2);
  for (int i = b; i < e; ++i) A[i] = A[i] * div % mod;
  if (lc) memset(data(A), 0, sizeof(int) * b);
  if (hc) memset(data(A) + e, 0, sizeof(int) * (n - e));
}
void copy(std::vector<int>& dst, const std::vector<int>& src, int siz) {
  memcpy(data(dst), data(src), sizeof(int) * siz);
}
void fastInvIter(int n, const std::vector<int>& sf,
                 const std::vector<int>& dftg, std::vector<int>& g) {
  int h = n >> 1;
  std::vector<int> f(n);
  copy(f, sf, n);
  DFT(n, f);
  for (int i = 0; i < n; ++i)
    f[i] = static_cast<long long>(f[i]) * dftg[i] % mod;
  IDFT(n, f, h, n);
  DFT(n, f);
  for (int i = 0; i < n; ++i)
    f[i] = static_cast<long long>(f[i]) * dftg[i] % mod;
  IDFT(n, f, h, n, false);
  for (int i = h; i < n; ++i) g[i] = (f[i] ? mod - f[i] : 0);
}
const long long negInv2 = mod - (mod + 1) / 2;
void solve(int n, const std::vector<int>& sf, std::vector<int>& g,
           std::vector<int>& tg, std::vector<int>& itg, bool doInv = false) {
  if (n == 1) {
    g[0] = 1;
    tg[0] = itg[0] = mod - 1;
  } else {
    int h = n >> 1, p = n << 1;
    solve(h, sf, g, tg, itg, true);
    std::vector<int> dftitg(n);
    copy(dftitg, itg, h);
    DFT(n, dftitg);
    std::vector<int> f(p);
    copy(f, sf, n);
    DFT(p, f);
    {
      int p = n << 1;
      std::vector<int> A(p);
      copy(A, g, h);
      DFT(n, A);
      for (int i = 0; i < n; ++i)
        A[i] = static_cast<long long>(A[i]) * A[i] % mod;
      IDFT(n, A, 0, n);
      DFT(p, A);
      for (int i = 0; i < p; ++i)
        A[i] = static_cast<long long>(f[i]) * A[i] % mod;
      IDFT(p, A, h, n);
      DFT(n, A);
      for (int i = 0; i < n; ++i)
        A[i] = static_cast<long long>(A[i]) * dftitg[i] % mod;
      IDFT(n, A, h, n, false);
      for (int i = h; i < n; ++i) g[i] = (A[i] ? mod - A[i] : 0);
    }
    if (doInv) {
      copy(tg, g, n);
      DFT(p, tg);
      for (int i = 0; i < p; ++i)
        tg[i] = static_cast<long long>(f[i]) * tg[i] * 2 % mod;
      IDFT(p, tg, 0, n);
      tg[0] = mod - 1;
      fastInvIter(n, tg, dftitg, itg);
    }
  }
}
int main() {
  int n = read();
  int m = read() + 1;
  int p = 1;
  while (p < m) p <<= 1;
  int siz = p << 1;
  std::vector<int> F(siz);
  for (int i = 0; i < n; ++i) {
    int x = read();
    if (x < m) F[x] = 1;
  }
  std::vector<int> G(siz), TG(siz), ITG(siz);
  solve(p, F, G, TG, ITG, false);
  for (int i = 1; i < m; ++i) printf("%d\n", G[i]);
  return 0;
}