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 int maxn = 1600005;
const int modc = 998244353;
long long ksm(long long x, long long n) {
  n %= modc - 1;
  if (n < 0) n += modc - 1;
  long long res = 1;
  while (n) {
    if (n & 1) (res *= x) %= modc;
    (x *= x) %= modc;
    n /= 2;
  }
  return res;
}
long long p[maxn], nn;
void fft(long long *a, long long *out, int step, int n) {
  if (n == 1) {
    out[0] = a[0];
    return;
  }
  int mid = n / 2;
  fft(a, out, step * 2, mid);
  fft(a + step, out + mid, step * 2, mid);
  long long t1, t2;
  for (int i = 0; i < mid; i++) {
    t1 = out[i];
    (t2 = out[i + mid] * p[nn / n * i]) %= modc;
    (out[i] = t1 + t2) %= modc;
    (out[i + mid] = t1 - t2) %= modc;
  }
}
long long aa[maxn], bb[maxn], out1[maxn], out2[maxn];
void cheng(int n, long long *a, long long *b, long long *ans) {
  for (int i = 0; i < n; i++) aa[i] = a[i], bb[i] = b[i];
  for (int i = n; i < (n << 1); i++) aa[i] = bb[i] = 0;
  n <<= 1;
  nn = n;
  p[0] = 1;
  p[1] = ksm(3, (modc - 1) / n);
  for (int i = 2; i < n; i++) (p[i] = p[i - 1] * p[1]) %= modc;
  fft(aa, out1, 1, n);
  fft(bb, out2, 1, n);
  for (int i = 0; i < n; i++) (out1[i] *= out2[i]) %= modc;
  p[0] = 1;
  p[1] = ksm(3, -(modc - 1) / n);
  for (int i = 2; i < n; i++) (p[i] = p[i - 1] * p[1]) %= modc;
  fft(out1, ans, 1, n);
  long long p = ksm(n, modc - 2);
  for (int i = 0; i < n; i++) (ans[i] *= p) %= modc;
}
long long t[maxn];
void inv(int tn, long long *a, long long *b) {
  b[0] = ksm(a[0], modc - 2);
  for (int i = 2; i <= tn; i <<= 1) {
    cheng(i / 2, a, b, t);
    for (int j = 0; j < i; j++) t[j] *= -1;
    t[0] += 2;
    cheng(i, b, t, b);
  }
}
long long a[maxn], b[maxn], c[maxn], d[maxn], tt[maxn], ans[maxn];
int main() {
  int m, n;
  scanf("%d%d", &m, &n);
  n++;
  for (int i = 1; i <= m; i++) {
    int t;
    scanf("%d", &t);
    if (t >= n) continue;
    c[t]++;
  }
  int tn = 1;
  while (tn < n) tn *= 2;
  ans[0] = 1;
  for (int i = 2; i <= tn; i *= 2) {
    cheng(i, ans, c, a);
    cheng(i, a, ans, b);
    for (int j = 0; j < i; j++) (b[j] -= ans[j]) %= modc, (a[j] *= 2) %= modc;
    a[0]--;
    b[0]++;
    inv(i, a, d);
    cheng(i, d, b, tt);
    for (int j = 0; j < i; j++) (ans[j] -= tt[j]) %= modc;
  }
  for (int i = 1; i < n; i++) {
    if (ans[i] < 0) ans[i] += modc;
    printf("%lld\n", ans[i]);
  }
  return 0;
}