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;
inline char nc() {
  static char buf[100000], *p1 = buf, *p2 = buf;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
inline void read(int &x) {
  char c = nc(), b = 1;
  for (; !(c >= '0' && c <= '9'); c = nc())
    if (c == '-') b = -1;
  for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
    ;
  x *= b;
}
const int P = 998244353;
const int G = 3;
const int N = 100005 << 2;
inline int Pow(long long a, int b) {
  long long ret = 1;
  for (; b; b >>= 1, a = a * a % P)
    if (b & 1) ret = ret * a % P;
  return (int)ret;
}
inline int Inv(int a) { return Pow(a, P - 2); }
inline int Root(int a) {
  if (a == 1) return 1;
}
int R[N];
inline void FFT(int *a, int n, int r) {
  for (int i = 0; i < n; i++)
    if (i < R[i]) swap(a[i], a[R[i]]);
  for (int i = 1; i < n; i <<= 1) {
    int wn = Pow(G, (P - 1) / (i << 1));
    if (r == -1) wn = Pow(wn, P - 2);
    for (int j = 0; j < n; j += (i << 1)) {
      int w = 1;
      for (int k = 0; k < i; k++, w = (long long)w * wn % P) {
        long long x = a[j + k], y = (long long)w * a[j + i + k] % P;
        a[j + k] = (x + y) % P;
        a[j + i + k] = (x + P - y) % P;
      }
    }
  }
  if (r == -1)
    for (int i = 0, inv = Pow(n, P - 2); i < n; i++)
      a[i] = (long long)a[i] * inv % P;
}
inline void GetInv(int *a, int *b, int n) {
  static int tmp[N];
  if (n == 1) return void(b[0] = Inv(a[0]));
  GetInv(a, b, n >> 1);
  for (int i = 0; i < n; i++) tmp[i] = a[i], tmp[n + i] = 0;
  int L = 0;
  while (!(n >> L & 1)) L++;
  for (int i = 1; i < (n << 1); i++) R[i] = (R[i >> 1] >> 1) | ((i & 1) << L);
  FFT(tmp, n << 1, 1);
  FFT(b, n << 1, 1);
  for (int i = 0; i < (n << 1); i++)
    tmp[i] = (long long)b[i] * (2 + P - (long long)tmp[i] * b[i] % P) % P;
  FFT(tmp, n << 1, -1);
  for (int i = 0; i < n; i++) b[i] = tmp[i], b[n + i] = 0;
}
const int INV2 = (P + 1) / 2;
inline void GetRoot(int *a, int *b, int n) {
  static int tmp[N], invb[N];
  if (n == 1) return void(b[0] = Root(a[0]));
  GetRoot(a, b, n >> 1);
  memset(invb, 0, sizeof(int) * n);
  GetInv(b, invb, n);
  int L = 0;
  while (!(n >> L & 1)) L++;
  for (int i = 1; i < (n << 1); i++) R[i] = (R[i >> 1] >> 1) | ((i & 1) << L);
  for (int i = 0; i < n; i++) tmp[i] = a[i], tmp[n + i] = 0;
  FFT(tmp, n << 1, 1);
  FFT(b, n << 1, 1);
  FFT(invb, n << 1, 1);
  for (int i = 0; i < (n << 1); i++)
    tmp[i] = (long long)((long long)b[i] * b[i] + tmp[i]) % P * invb[i] % P *
             INV2 % P;
  FFT(tmp, n << 1, -1);
  for (int i = 0; i < n; i++) b[i] = tmp[i], b[n + i] = 0;
}
int n, m;
int a[N], b[N];
int main() {
  int c;
  read(m);
  read(n);
  for (int i = 1; i <= m; i++) read(c), a[c] = P - 4;
  a[0] = 1;
  for (m = 1; m <= n; m <<= 1)
    ;
  GetRoot(a, b, m);
  b[0] = (b[0] + 1) % P;
  memset(a, 0, sizeof(int) * m);
  GetInv(b, a, m);
  for (int i = 1; i <= n; i++) printf("%d\n", (long long)a[i] * 2 % P);
  return 0;
}