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>
const int N = 1 << 19;
const int S = N * sizeof(long long);
inline int read() {
  register char c = getchar(), d = 0;
  while (c > '9' || c < '0') d = c, c = getchar();
  register int r = 0;
  while (c <= '9' && c >= '0') r = (r << 1) + (r << 3) + c - '0', c = getchar();
  return d == '-' ? -r : r;
}
inline void wtx(long long x) {
  if (x / 10) wtx(x / 10);
  putchar(x % 10 + '0');
}
inline void wtln(long long x) {
  if (x < 0) putchar('-'), x = -x;
  wtx(x), putchar('\n');
}
inline void wtsp(long long x) {
  if (x < 0) putchar('-'), x = -x;
  wtx(x), putchar(' ');
}
const int M = 998244353, G = 3;
inline long long mod(long long x, long long m = M) { return (x % m + m) % m; }
inline long long inc(long long x, long long y) {
  return x + y >= M ? x + y - M : x + y;
}
inline long long dec(long long x, long long y) {
  return x - y >= 0 ? x - y : x - y + M;
}
inline long long pow(long long x, long long t) {
  x = mod(x, M), t = mod(t, M - 1);
  long long r = 1;
  while (t) {
    if (t & 1) r = r * x % M;
    x = x * x % M, t >>= 1;
  }
  return r;
}
inline void swap(long long& x, long long& y) {
  if (x ^ y) x ^= y ^= x ^= y;
}
int swp[N], cur;
inline void Init(int t) {
  cur = t;
  for (int i = 0; i < (1 << t); ++i)
    swp[i] = (swp[i >> 1] >> 1) | ((i & 1) << (t - 1));
}
inline void Swap(int t, long long* buf) {
  if (cur ^ t) Init(t);
  for (int i = 0; i < (1 << t); ++i)
    if (i > swp[i]) swap(buf[i], buf[swp[i]]);
}
long long L, R, omg, dlt, I;
inline void Trns(int t, long long* buf, int sgn = 1) {
  Swap(t, buf);
  for (int l = 1, n = 2, m = 1; l <= t; ++l, n <<= 1, m <<= 1) {
    dlt = pow(G, sgn * (M - 1) / n);
    for (int p = 0; p < (1 << t); p += n) {
      omg = 1;
      for (int i = 0; i < m; ++i) {
        L = buf[p + i], R = omg * buf[p + i + m] % M;
        buf[p + i] = inc(L, R), buf[p + i + m] = dec(L, R);
        omg = omg * dlt % M;
      }
    }
  }
  if (sgn == -1) {
    I = pow((1 << t), -1);
    for (int i = 0; i < (1 << t); ++i) buf[i] = buf[i] * I % M;
  }
}
long long f[N], g[N], h[N];
long long T1[N];
inline void PInv(int n, long long* src, long long* dst) {
  memset(T1, 0, S);
  memset(dst, 0, S);
  int tt = 0;
  while ((1 << tt) <= n) ++tt;
  dst[0] = pow(src[0], -1);
  for (int t = 0; t <= tt; ++t) {
    for (int i = 0; i < (1 << t); ++i) T1[i] = src[i];
    Trns(t + 1, dst), Trns(t + 1, T1);
    for (int i = 0; i < (1 << t) * 2; ++i)
      dst[i] = mod(dst[i] * (2 - dst[i] * T1[i] % M));
    Trns(t + 1, dst, -1);
    for (int i = 0; i < (1 << t); ++i) dst[i + (1 << t)] = 0;
  }
  for (int i = n + 1; i < (1 << tt); ++i) dst[i] = 0;
}
long long T4[N], T5[N];
inline void Sqrt(int n, long long* src, long long* dst) {
  memset(T4, 0, S);
  memset(T5, 0, S);
  int tt = 0;
  while ((1 << tt) <= n) ++tt;
  dst[0] = 1;
  for (int t = 0; t <= tt; ++t) {
    PInv((1 << t) - 1, dst, T4);
    for (int i = 0; i < (1 << t); ++i) T5[i] = src[i];
    ++t, Trns(t, T4), Trns(t, T5);
    for (int i = 0; i < (1 << t); ++i) T4[i] = T5[i] * T4[i] % M;
    Trns(t, T4, -1), --t;
    I = pow(2, -1);
    for (int i = 0; i < (1 << t); ++i) dst[i] = (dst[i] + T4[i]) * I % M;
  }
  for (int i = n + 1; i < (1 << tt); ++i) dst[i] = 0;
}
int n, m, t;
int main() {
  n = read(), m = read(), f[0] = 1;
  for (int i = 1; i <= n; ++i) f[read()] = M - 4;
  Sqrt(m, f, g), g[0] = mod(g[0] + 1);
  PInv(m, g, h);
  for (int i = 1; i <= m; ++i) wtln(mod(h[i] * 2));
}