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;
struct NTT {
  int mod, root, root_1, root_pw;
  NTT(int c, int g, int k) {
    root_pw = 1 << k;
    mod = c * root_pw + 1;
    root = pwr(g, c);
    root_1 = pwr(root, mod - 2);
  }
  void transform(vector<int> &a, bool invert) {
    int n = (int)a.size();
    assert((n & (n - 1)) == 0);
    assert(n <= root_pw);
    for (int i = 1, j = 0; i < n; ++i) {
      int bit = n >> 1;
      for (; j >= bit; bit >>= 1) j -= bit;
      j += bit;
      if (i < j) swap(a[i], a[j]);
    }
    for (int len = 2; len <= n; len <<= 1) {
      int wlen = invert ? root_1 : root;
      for (int i = len; i < root_pw; i <<= 1)
        wlen = int(wlen * 1ll * wlen % mod);
      for (int i = 0; i < n; i += len) {
        int w = 1;
        for (int j = 0; j < len / 2; ++j) {
          int u = a[i + j], v = int(a[i + j + len / 2] * 1ll * w % mod);
          a[i + j] = u + v < mod ? u + v : u + v - mod;
          a[i + j + len / 2] = u - v >= 0 ? u - v : u - v + mod;
          w = int(w * 1ll * wlen % mod);
        }
      }
    }
    if (invert) {
      int nrev = pwr(n, mod - 2);
      for (int i = 0; i < n; ++i) a[i] = int(a[i] * 1ll * nrev % mod);
    }
  }
  long long pwr(long long a, long long b) {
    long long ret = 1;
    while (b > 0) {
      if (b & 1) {
        ret = ret * a % mod;
      }
      b >>= 1;
      a = a * a % mod;
    }
    return ret;
  }
};
struct PolynomialUtility {
  NTT *ntt;
  PolynomialUtility(NTT *ntt) : ntt(ntt) {}
  vector<int> multiply(const vector<int> &A, const vector<int> &B, int terms) {
    if (terms == -1) {
      terms = A.size() + B.size();
    } else {
      terms = terms * 2;
    }
    int n = 1 << (int)ceil(log2(terms));
    assert(n <= ntt->root_pw);
    vector<int> FA(n);
    vector<int> FB(n);
    for (int i = 0; i < min(n / 2, (int)A.size()); ++i) {
      FA[i] = A[i];
    }
    for (int i = 0; i < min(n / 2, (int)B.size()); ++i) {
      FB[i] = B[i];
    }
    ntt->transform(FA, false);
    ntt->transform(FB, false);
    for (int i = 0; i < FA.size(); ++i) {
      FA[i] = (FA[i] * 1ll * FB[i]) % ntt->mod;
    }
    ntt->transform(FA, true);
    return FA;
  }
  vector<int> multiplyTransformed(const vector<int> &FA,
                                  const vector<int> &FB) {
    int n = FA.size();
    assert((n & (n - 1)) == 0);
    assert(n <= ntt->root_pw);
    vector<int> FR(n);
    for (int i = 0; i < FA.size(); ++i) {
      FR[i] = (FA[i] * 1ll * FB[i]) % ntt->mod;
    }
    ntt->transform(FR, true);
    return FR;
  }
  vector<int> pwr(const vector<int> &A, long long b, int terms = -1) {
    if (terms == -1) {
      terms = A.size() * b;
    }
    int n = 1 << (int)ceil(log2(terms));
    assert(n <= ntt->root_pw);
    vector<int> FA(A.begin(), A.end());
    FA.resize(n);
    ntt->transform(FA, false);
    for (int i = 0; i < FA.size(); ++i) {
      FA[i] = ntt->pwr(FA[i], b);
    }
    ntt->transform(FA, true);
    return FA;
  }
  vector<int> inverse(const vector<int> &F, int terms = -1) {
    if (terms == -1) {
      terms = F.size();
    }
    int n = 1 << (int)ceil(log2(terms));
    vector<int> curr(1, ntt->pwr(F[0], ntt->mod - 2));
    for (int m = 2; m <= n; m *= 2) {
      vector<int> B = pwr(curr, 2, m);
      B = multiply(B, F, m);
      curr.resize(m);
      for (int i = 0; i < m; ++i) {
        curr[i] = curr[i] * 2 - B[i];
        if (curr[i] < 0) {
          curr[i] += ntt->mod;
        }
      }
    }
    return curr;
  }
  vector<int> sqrt(const vector<int> &F, int s, int terms = -1) {
    assert((long long)s * s % ntt->mod == F[0]);
    if (terms == -1) {
      terms = F.size();
    }
    int n = 1 << (int)ceil(log2(terms));
    vector<int> curr(1, s);
    long long inverse_2 = ntt->pwr(2, ntt->mod - 2);
    for (int m = 2; m <= n; m *= 2) {
      vector<int> B = multiply(F, inverse(curr, m), m);
      curr.resize(m);
      for (int i = 0; i < m; ++i) {
        curr[i] = (curr[i] + B[i]) * inverse_2 % ntt->mod;
      }
    }
    return curr;
  }
  vector<int> getTransform(const vector<int> &A, bool invert) {
    int n = 1 << (int)ceil(log2(A.size()));
    vector<int> FA(A.begin(), A.end());
    FA.resize(n);
    ntt->transform(FA, invert);
    return FA;
  }
  void scale(vector<int> &A, int b) {
    for (int i = 0; i < A.size(); ++i) {
      A[i] = A[i] * 1ll * b % ntt->mod;
    }
  }
};
void testMul(PolynomialUtility polynomialUtility) {
  vector<int> A = {1, 8, 16, 0};
  vector<int> B = {1, 998244349, 998244349, 0};
  vector<int> C = polynomialUtility.multiply(A, B, 10);
  for (int i = 0; i < C.size(); ++i) {
    cout << C[i] << endl;
  }
}
void testInverse(PolynomialUtility polynomialUtility) {
  int n;
  cin >> n;
  vector<int> A(n);
  for (int i = 0; i < n; ++i) {
    cin >> A[i];
  }
  vector<int> C = polynomialUtility.inverse(A, 8);
  for (int i = 0; i < C.size(); ++i) {
    cout << C[i] << " ";
  }
}
const int SIZE = 100001;
int main() {
  NTT ntt(7 * 17, 3, 23);
  int mod = ntt.mod;
  PolynomialUtility polynomialUtility(&ntt);
  int n, m;
  scanf("%d %d", &n, &m);
  vector<int> c(SIZE);
  for (int i = 0; i < n; ++i) {
    int x;
    scanf("%d", &x);
    c[x] = 1;
  }
  polynomialUtility.scale(c, mod - 4);
  c[0] = 1;
  c = polynomialUtility.sqrt(c, 1, m + 1);
  c[0] = (c[0] + 1) % ntt.mod;
  c = polynomialUtility.inverse(c, m + 1);
  polynomialUtility.scale(c, 2);
  for (int i = 1; i <= m; ++i) {
    printf("%d\n", c[i]);
  }
}