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;
namespace FastIO {
const int L = (1 << 20);
char buf[L], *S, *T;
inline char getchar() {
  if (S == T) {
    T = (S = buf) + fread(buf, 1, L, stdin);
    if (S == T) return EOF;
  }
  return *S++;
}
inline int read() {
  int s = 0, f = 1;
  char t = getchar();
  while ('0' > t || t > '9') {
    if (t == '-') f = -1;
    t = getchar();
  }
  while ('0' <= t && t <= '9') {
    s = (s << 1) + (s << 3) + t - '0';
    t = getchar();
  }
  return s * f;
}
}  // namespace FastIO
using FastIO::read;
const int N = 100005;
const int Mod = 998244353;
int rev[N * 8], Pow[N * 8], n, m;
int Inc(int x, int y) { return x + y >= Mod ? x + y - Mod : x + y; }
int Inc(int x, int y, int z) { return Inc(Inc(x, y), z); }
int Dec(int x, int y) { return x - y < 0 ? x - y + Mod : x - y; }
int Mul(int x, int y) { return (long long)x * y % Mod; }
int Mul(int x, int y, int z) { return Mul(Mul(x, y), z); }
void Output(int *A, int Max) {
  for (int i = 0; i < Max; i++) cout << A[i] << ' ';
  cout << '\n';
}
int Fpow(int a, int b) {
  int ans = 1;
  while (b) {
    if (b & 1) ans = Mul(ans, a);
    b >>= 1;
    a = Mul(a, a);
  }
  return ans;
}
int Bit(int Max) { return ceil(log2(Max)); }
void Make(int Max) {
  int c = Bit(Max);
  for (int i = 1; i < Max; i++)
    rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (c - 1));
}
int Hollow;
void NTT(int *val, int Max, int fla) {
  if (Hollow != Max) Make(Hollow = Max);
  for (int i = 0; i < Max; i++)
    if (rev[i] > i) swap(val[rev[i]], val[i]);
  for (int i = 1; i < Max; i <<= 1) {
    Pow[0] = 1;
    Pow[1] = Fpow(3, Mod - 1 + (Mod - 1) / (i << 1) * fla);
    for (int j = 2; j < i; j++) Pow[j] = Mul(Pow[j - 1], Pow[1]);
    for (int j = 0; j < Max; j += (i << 1))
      for (int k = 0; k < i; k++) {
        int x = val[j + k], y = Mul(val[i + j + k], Pow[k]);
        val[j + k] = Inc(x, y);
        val[i + j + k] = Dec(x, y);
      }
  }
  if (fla == -1) {
    int inv = Fpow(Max, Mod - 2);
    for (int i = 0; i < Max; i++) val[i] = Mul(val[i], inv);
  }
}
int tmp1[N * 8];
void Inverse(int *A, int *B, int lim) {
  B[0] = Fpow(A[0], Mod - 2);
  int len = 1;
  while (len <= lim) {
    len <<= 1;
    int Max = len << 1;
    for (int i = 0; i < len; i++) tmp1[i] = A[i];
    NTT(B, Max, 1);
    NTT(tmp1, Max, 1);
    for (int i = 0; i < Max; i++)
      B[i] = Dec(Mul(B[i], 2), Mul(tmp1[i], B[i], B[i])), tmp1[i] = 0;
    NTT(B, Max, -1);
    for (int i = len; i < Max; i++) B[i] = 0;
  }
  for (int i = lim + 1; i < len; i++) B[i] = 0;
}
int tmp2[N * 8], tmp3[N * 8], tmp4[N * 8], tmp5[N * 8];
void Solve(int *A, int *B, int lim) {
  B[0] = 1;
  int len = 1;
  while (len <= lim) {
    len <<= 1;
    int Max = len << 1;
    NTT(B, Max, 1);
    for (int i = 0; i < len; i++) tmp2[i] = A[i];
    NTT(tmp2, Max, 1);
    for (int i = 0; i < Max; i++) tmp3[i] = Mul(tmp2[i], B[i]);
    NTT(tmp3, Max, -1);
    for (int i = len; i < Max; i++) tmp3[i] = 0;
    NTT(tmp3, Max, 1);
    for (int i = 0; i < Max; i++) tmp4[i] = Mul(tmp3[i], B[i]);
    NTT(tmp3, Max, -1);
    NTT(tmp4, Max, -1);
    for (int i = len; i < Max; i++) tmp4[i] = 0;
    for (int i = 0; i < len; i++) tmp3[i] = Mul(tmp3[i], 2);
    tmp3[0] = Dec(tmp3[0], 1);
    tmp4[0] = Dec(tmp4[0], 1);
    Inverse(tmp3, tmp5, len - 1);
    NTT(tmp4, Max, 1);
    NTT(tmp5, Max, 1);
    for (int i = 0; i < Max; i++) {
      B[i] = Mul(tmp4[i], tmp5[i]);
      tmp2[i] = tmp3[i] = tmp4[i] = tmp5[i] = 0;
    }
    NTT(B, Max, -1);
    for (int i = len; i < Max; i++) B[i] = 0;
  }
  for (int i = lim + 1; i < len; i++) B[i] = 0;
}
int C[N * 8], T[N * 8];
int main() {
  n = read();
  m = read();
  for (int i = 1; i <= n; i++) C[read()]++;
  Solve(C, T, m);
  for (int i = 1; i <= m; i++) cout << T[i] << '\n';
  return 0;
}