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 long long MAX = 3e5 + 7;
const long long MOD = 998244353;
const long long org = 3;
const long long lev = (MOD + 1) / 3;
long long L, LIM;
struct poly {
  long long kunjinkao[MAX];
  long long &operator[](long long id) { return kunjinkao[id]; }
  void clear() { memset(kunjinkao, 0, sizeof(kunjinkao)); }
};
poly ans, g, a;
poly A, B, C;
long long R[MAX];
long long quick_pow(long long x, long long y) {
  long long ret = 1;
  while (y) {
    if (y & 1LL) ret = ret * x % MOD;
    y >>= 1LL;
    x = x * x % MOD;
  }
  return ret;
}
void NTT(poly &arr, long long typ) {
  for (long long i = 0; i < LIM; i++) {
    if (R[i] > i) {
      swap(arr[i], arr[R[i]]);
    }
  }
  for (long long mid = 1; mid < LIM; mid <<= 1) {
    long long W = quick_pow(typ == 1 ? org : lev, (MOD - 1) / (mid << 1));
    for (long long j = 0; j < LIM; j += (mid << 1)) {
      long long w = 1;
      for (long long i = 0; i < mid; i++) {
        long long x = arr[i + j], y = (arr[i + j + mid] * w) % MOD;
        arr[i + j] = (x + y) % MOD;
        arr[i + j + mid] = (x - y + MOD) % MOD;
        w = w * W % MOD;
      }
    }
  }
  if (typ == -1) {
    long long inv = quick_pow(LIM, MOD - 2);
    for (long long i = 0; i < LIM; i++) {
      arr[i] = arr[i] * inv % MOD;
    }
  }
}
void init(long long len) {
  L = 0;
  LIM = 1;
  while (LIM <= len) {
    L++;
    LIM <<= 1LL;
  }
  for (long long i = 0; i < LIM; i++) {
    R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
  }
}
void mul(poly &a, long long lena, poly &b, long long lenb, poly &kk) {
  init(lena + lenb);
  for (long long i = lena; i < LIM; i++) {
    a[i] = 0;
  }
  for (long long i = lenb; i < LIM; i++) {
    b[i] = 0;
  }
  NTT(a, 1);
  NTT(b, 1);
  for (long long i = 0; i < LIM; i++) {
    kk[i] = (a[i] * b[i]) % MOD;
  }
  NTT(kk, -1);
  for (long long i = lena + lenb - 1; i < LIM; i++) {
    kk[i] = 0;
  }
}
namespace INV {
poly G0, F;
}
void get_inv(poly &a, long long len, poly &kk) {
  if (len == 1) {
    kk[0] = quick_pow(a[0], MOD - 2);
    return;
  }
  INV::G0.clear();
  get_inv(a, (len + 1) >> 1LL, INV::G0);
  init(len + len);
  for (long long i = 0; i < len; i++) {
    INV::F[i] = a[i];
  }
  for (long long i = len; i < LIM; i++) {
    INV::F[i] = 0;
  }
  NTT(INV::F, 1);
  NTT(INV::G0, 1);
  for (long long i = 0; i < LIM; i++) {
    kk[i] = (INV::G0[i] * (2 - (INV::G0[i] * INV::F[i]) % MOD)) % MOD;
  }
  NTT(kk, -1);
  for (long long i = len; i < LIM; i++) {
    kk[i] = 0;
  }
}
namespace LN {
poly dev_A, inv_A, B;
}
void get_dev(poly &a, long long len, poly &kk) {
  for (long long i = 1; i < len; i++) {
    kk[i - 1] = a[i] * i % MOD;
  }
  kk[len - 1] = 0;
}
void get_idev(poly &a, long long len, poly &kk) {
  for (long long i = 1; i < len; i++) {
    kk[i] = a[i - 1] * quick_pow(i, MOD - 2) % MOD;
  }
  kk[0] = 0;
}
void get_ln(poly &a, long long len, poly &kk) {
  kk.clear();
  LN::dev_A.clear();
  get_dev(a, len, LN::dev_A);
  LN::inv_A.clear();
  get_inv(a, len, LN::inv_A);
  LN::B.clear();
  mul(LN::dev_A, len, LN::inv_A, len, LN::B);
  get_idev(LN::B, len, kk);
}
namespace EXP {
poly G0, lnG0, F;
}
void get_exp(poly &a, long long len, poly &kk) {
  if (len == 1) {
    kk[0] = 1;
    return;
  }
  EXP::G0.clear();
  get_exp(a, len + 1 >> 1, EXP::G0);
  get_ln(EXP::G0, len, EXP::lnG0);
  init(len + len);
  EXP::F.clear();
  for (long long i = 0; i < len; i++) {
    EXP::F[i] = a[i];
  }
  for (long long i = len; i < LIM; i++) {
    EXP::F[i] = 0;
  }
  NTT(EXP::G0, 1);
  NTT(EXP::lnG0, 1);
  NTT(EXP::F, 1);
  for (long long i = 0; i < LIM; i++) {
    kk[i] = EXP::G0[i] * ((1 - EXP::lnG0[i] + EXP::F[i] + MOD) % MOD) % MOD;
  }
  NTT(kk, -1);
  for (long long i = len; i < LIM; i++) {
    kk[i] = 0;
  }
  EXP::lnG0.clear();
}
namespace SQRT {
poly G, F, A, invG;
}
void get_sqrt(poly &a, long long len, poly &kk) {
  if (len == 1) {
    kk[0] = 1;
    return;
  }
  SQRT::G.clear();
  get_sqrt(a, len + 1 >> 1, SQRT::G);
  SQRT::invG.clear();
  get_inv(SQRT::G, len, SQRT::invG);
  SQRT::A.clear();
  init(len + len);
  for (long long i = 0; i < len; i++) {
    SQRT::A[i] = a[i];
  }
  for (long long i = len; i < LIM; i++) {
    SQRT::A[i] = 0;
  }
  NTT(SQRT::G, 1);
  NTT(SQRT::invG, 1);
  NTT(SQRT::A, 1);
  long long inv2 = quick_pow(2, MOD - 2);
  for (long long i = 0; i < LIM; i++) {
    kk[i] =
        ((SQRT::G[i] + SQRT::A[i] * SQRT::invG[i] % MOD) % MOD * inv2) % MOD;
  }
  NTT(kk, -1);
  for (long long i = len; i < LIM; i++) {
    kk[i] = 0;
  }
  SQRT::invG.clear();
}
signed main() {
  long long N, M;
  cin >> N >> M;
  A.clear();
  for (long long i = 1; i <= N; i++) {
    long long x;
    cin >> x;
    A[x] = -4;
  }
  A[0]++;
  B.clear();
  get_sqrt(A, M + 1, B);
  B[0]++;
  C.clear();
  get_inv(B, M + 1, C);
  for (long long i = 1; i <= M; i++) {
    cout << ((C[i] * 2LL) % MOD + MOD) % MOD << endl;
  }
}