PolandBall is standing in a row with Many Other Balls. More precisely, there are exactly n Balls. Balls are proud of their home land — and they want to prove that it's strong.

The Balls decided to start with selecting exactly m groups of Balls, each consisting either of single Ball or two neighboring Balls. Each Ball can join no more than one group.

The Balls really want to impress their Enemies. They kindly asked you to calculate number of such divisions for all m where 1 ≤ m ≤ k. Output all these values modulo 998244353, the Enemies will be impressed anyway.

Input

There are exactly two numbers n and k (1 ≤ n ≤ 109, 1 ≤ k < 215), denoting the number of Balls and the maximim number of groups, respectively.

Output

You should output a sequence of k values. The i-th of them should represent the sought number of divisions into exactly i groups, according to PolandBall's rules.

Examples

Input

3 3


Output

5 5 1 

Input

1 1


Output

1 

Input

5 10


Output

9 25 25 9 1 0 0 0 0 0 

Note

In the first sample case we can divide Balls into groups as follows: 

{1}, {2}, {3}, {12}, {23}.

{12}{3}, {1}{23}, {1}{2}, {1}{3}, {2}{3}.

{1}{2}{3}.

Therefore, output is: 5 5 1.
#include <bits/stdc++.h>
using namespace std;
namespace Polynomial_NTT {
using LL = long long;
constexpr int g = 3, P = 998244353;
constexpr int MXLEN = 1 << 16;
constexpr long long inv2 = (P + 1) >> 1;
class poly_t : public vector<int> {
 public:
  poly_t() {}
  poly_t(initializer_list<int> list) {
    for (const int &val : list) push_back(val);
  }
  poly_t(const poly_t &A, int size) { *this = A, resize(size); }
};
inline int modAdd(int u, int v) { return (((u += v) >= P) && (u -= P)), u; }
int getInv(int u) {
  return u == 1 ? 1 : static_cast<LL>(P - P / u) * getInv(P % u) % P;
}
int Pow(int u, int v) {
  int ans = 1;
  for (; v; v >>= 1, u = static_cast<LL>(u) * u % P)
    if (v & 1) ans = static_cast<LL>(u) * ans % P;
  return ans;
}
enum DFT_FLAG_t { NORMAL = 1, INVERSE = -1 };
void DFT(poly_t &A, int n, DFT_FLAG_t flag = NORMAL) {
  static int prevLen, rev[MXLEN + 1];
  if (prevLen != n) {
    prevLen = n;
    for (int i = 0; i < n; i++)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) * (n >> 1));
  }
  if (static_cast<int>(A.size()) != n) A.resize(n);
  for (int i = 0; i < n; i++)
    if (i < rev[i]) swap(A[i], A[rev[i]]);
  for (int i = 1; i < n; i <<= 1) {
    LL wn = Pow(g, P - 1 + flag * (P - 1) / (i << 1));
    for (int j = 0; j < n; j += i << 1)
      for (int k = 0, w = 1; k < i; k++, w = wn * w % P) {
        int x0 = A[j + k], x1 = static_cast<LL>(w) * A[i + j + k] % P;
        A[j + k] = modAdd(x0, x1);
        A[i + j + k] = modAdd(x0, P - x1);
      }
  }
  if (flag == INVERSE) {
    LL tmp = getInv(n);
    for (int &val : A) val = tmp * val % P;
  }
}
poly_t multiply(poly_t &A, poly_t &B) {
  static poly_t C;
  int X = 1, n = A.size(), m = B.size();
  for (; X < n + m - 1; X <<= 1)
    ;
  C.resize(X);
  DFT(A, X, NORMAL), DFT(B, X, NORMAL);
  for (int i = 0; i < X; i++) C[i] = static_cast<LL>(A[i]) * B[i] % P;
  DFT(C, X, INVERSE), C.resize(n + m - 1);
  return C;
}
poly_t getInverse(const poly_t &A, int n) {
  if (n == 1) return {getInv(A[0])};
  poly_t B = getInverse(A, (n + 1) >> 1);
  poly_t T = poly_t(A, n);
  int X = 1;
  for (int mxlen = (n << 1) - 1; X < mxlen; X <<= 1)
    ;
  DFT(B, X, NORMAL), DFT(T, X, NORMAL);
  for (int i = 0; i < X; i++)
    B[i] = (2LL * B[i] + static_cast<LL>(P - T[i]) * B[i] % P * B[i]) % P;
  DFT(B, X, INVERSE), B.resize(n);
  return B;
}
poly_t getDerivative(const poly_t &A) {
  int n = A.size();
  poly_t ans;
  ans.resize(n - 1);
  for (int i = 1; i < n; i++) ans[i - 1] = static_cast<LL>(i) * A[i] % P;
  return ans;
}
poly_t getIntegral(const poly_t &A, int n) {
  static int prevLen = 1, inv[MXLEN + 1] = {0, 1};
  if (n > prevLen) {
    for (int i = prevLen + 1; i <= n; i++)
      inv[i] = static_cast<LL>(P - P / i) * inv[P % i] % P;
    prevLen = n;
  }
  poly_t ans;
  ans.resize(n);
  for (int i = 1; i < n; i++) ans[i] = static_cast<LL>(A[i - 1]) * inv[i] % P;
  return ans;
}
poly_t getLogarithm(const poly_t &A, int n) {
  poly_t F = A;
  poly_t dF = getDerivative(F);
  F = getInverse(F, n);
  int X = 1;
  for (int mxlen = (n << 1) - 1; X < mxlen; X <<= 1)
    ;
  DFT(F, X, NORMAL), DFT(dF, X, NORMAL);
  for (int i = 0; i < X; i++) F[i] = static_cast<LL>(F[i]) * dF[i] % P;
  DFT(F, X, INVERSE);
  return getIntegral(F, n);
}
poly_t getExponential(const poly_t &A, int n) {
  if (n == 1) return {1};
  poly_t F = getExponential(A, (n + 1) >> 1);
  poly_t B = poly_t(A, n);
  F.resize(n);
  poly_t lnF = getLogarithm(F, n);
  for (int i = 0; i < n; i++) B[i] = modAdd(B[i], P - lnF[i]);
  int X = 1;
  for (int mxlen = (n << 1) - 1; X < mxlen; X <<= 1)
    ;
  DFT(F, X, NORMAL), DFT(B, X, NORMAL);
  for (int i = 0; i < X; i++) B[i] = F[i] * (1LL + B[i]) % P;
  DFT(B, X, INVERSE), B.resize(n);
  return B;
}
poly_t getSqrt(const poly_t &A, int n) {
  if (n == 1) return {1};
  poly_t F = getSqrt(A, (n + 1) >> 1);
  poly_t B = poly_t(A, n);
  F.resize(n);
  poly_t invF = getInverse(F, n);
  int X = 1;
  for (int mxlen = (n << 1) - 1; X < mxlen; X <<= 1)
    ;
  DFT(B, X, NORMAL), DFT(invF, X, NORMAL);
  for (int i = 0; i < X; i++) B[i] = static_cast<LL>(B[i]) * invF[i] % P;
  DFT(B, X, INVERSE), B.resize(n);
  for (int i = 0; i < n; i++) B[i] = modAdd(B[i], F[i]) * inv2 % P;
  return B;
}
}  // namespace Polynomial_NTT
using LL = long long;
const int mod = 998244353;
const LL inv2 = (mod + 1) >> 1;
int main() {
  ios::sync_with_stdio(false);
  cout.tie(nullptr);
  int n, k;
  cin >> n >> k;
  int mxlen = min(n, k) + 1;
  Polynomial_NTT::poly_t delta = {1, 6, 1};
  delta = Polynomial_NTT::getSqrt(delta, mxlen);
  Polynomial_NTT::poly_t A = delta;
  A[0]++, A[1]++;
  for (int &val : A) val = val * inv2 % mod;
  A = Polynomial_NTT::getLogarithm(A, mxlen);
  for (int &val : A) val = val * static_cast<LL>(n + 1) % mod;
  A = Polynomial_NTT::getExponential(A, mxlen);
  delta = Polynomial_NTT::getInverse(delta, mxlen);
  Polynomial_NTT::poly_t ans = Polynomial_NTT::multiply(A, delta);
  for (int i = 1; i <= k; i++) cout << (i <= n ? ans[i] : 0) << ' ';
  return 0;
}
