Problem: 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.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmin(T &a, T b) {
  a = min(a, b);
}
template <typename T>
void chkmax(T &a, T b) {
  a = max(a, b);
}
inline int fread(void) {
  int ret = 0, op = 1;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') op = -1;
  for (; isdigit(ch); ch = getchar()) ret = (ret << 1) + (ret << 3) - '0' + ch;
  return ret * op;
}
const int MAXN = 5e6 + 10;
const int N = (1 << 16) + 1;
const int MAXM = +10;
const int mod = 998244353;
const int inv2 = ((mod + 1) >> 1);
const int gg = 3;
const int invg = 332748118;
int fpow(int base, int top) {
  int ret = 1;
  for (; top; top >>= 1) {
    if (top & 1) ret = 1ll * ret * base % mod;
    base = 1ll * base * base % mod;
  }
  return ret;
}
namespace Math {
inline bool check(int x) { return fpow(x, (mod - 1) / 2) == 1; }
inline int random(void) { return 1ll * rand() * rand() % mod; }
int w;
struct Maths {
  int a, b;
  Maths(int _a = 0, int _b = 0) : a(_a), b(_b) {}
  Maths operator+(const Maths you) {
    return Maths((a + you.a) % mod, (b + you.b) % mod);
  }
  Maths operator*(const Maths you) {
    Maths ret;
    ret.a = 1ll * a * you.a % mod + 1ll * b * you.b % mod * w % mod;
    ret.a %= mod;
    ret.b = (1ll * a * you.b % mod + 1ll * b * you.a % mod) % mod;
    return ret;
  }
};
Maths Mpow(Maths base, int top) {
  Maths ret = base;
  top--;
  for (; top; top >>= 1) {
    if (top & 1) ret = ret * base;
    base = base * base;
  }
  return ret;
}
inline int Cipolla(int n) {
  if (!check(n)) return -1;
  int rnd, ret;
  while (1) {
    rnd = random();
    w = 1ll * rnd * rnd % mod;
    w = (w - n + mod) % mod;
    if (!check(w)) break;
  }
  ret = Mpow(Maths(rnd, 1), (mod + 1) / 2).a;
  return min(ret, mod - ret);
}
}  // namespace Math
int n, m, rev[MAXN], mxN, lg2[MAXN], inv[MAXN], Gn[MAXN];
inline void process(int need) {
  for (mxN = 1; mxN < need; mxN <<= 1)
    ;
  lg2[1] = 0;
  for (int i = 2; i <= mxN; ++i) lg2[i] = lg2[i >> 1] + 1;
  for (int i = 0; i < mxN; ++i) {
    rev[i] = rev[i >> 1] >> 1;
    if (i & 1) rev[i] |= (mxN >> 1);
  }
  inv[1] = 1;
  for (int i = 2; i <= mxN; ++i)
    inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
  for (int len = 1; len < mxN; len <<= 1) {
    int sign = fpow(gg, (mod - 1) / (len << 1));
    Gn[len] = 1;
    for (int i = 1; i < len; ++i)
      Gn[len + i] = 1ll * Gn[len + i - 1] * sign % mod;
  }
}
unsigned long long tv[MAXN];
namespace Poly {
inline void NTT(vector<int> &F, int n, int tp) {
  if (tp == -1) reverse(F.begin() + 1, F.end());
  int tn = lg2[mxN / n];
  for (int i = 0; i < n; ++i) tv[i] = F[i];
  for (int i = 0; i < n; ++i)
    if ((rev[i] >> tn) < i) swap(tv[i], tv[rev[i] >> tn]);
  for (int len = 2; len <= n; len <<= 1) {
    for (int i = 0; i < n; i += len) {
      for (int j = i; j < i + len / 2; ++j) {
        int now = 1ll * Gn[(len >> 1) + j - i] * tv[j + len / 2] % mod;
        tv[j + len / 2] = tv[j] - now + mod;
        tv[j] = tv[j] + now;
      }
    }
  }
  for (int i = 0; i < n; ++i) F[i] = tv[i] % mod;
  if (tp == 1) return;
  int invn = fpow(n, mod - 2);
  for (int i = 0; i < n; ++i) F[i] = 1ll * F[i] * invn % mod;
}
vector<int> fix(vector<int> a, int n) {
  a.resize(n);
  return a;
}
vector<int> operator*(vector<int> a, vector<int> b) {
  if (a.empty() || b.empty()) return vector<int>();
  int used = a.size() + b.size() - 1;
  int lim = (1 << (lg2[used - 1] + 1));
  a.resize(lim);
  b.resize(lim);
  NTT(a, lim, 1);
  NTT(b, lim, 1);
  for (int i = 0; i < lim; ++i) a[i] = 1ll * a[i] * b[i] % mod;
  NTT(a, lim, -1);
  return fix(a, used);
}
vector<int> operator+(vector<int> a, vector<int> b) {
  int lim = max(a.size(), b.size());
  a.resize(lim);
  for (int i = 0; i < lim; ++i) {
    a[i] = a[i] + b[i];
    if (a[i] >= mod) a[i] -= mod;
  }
  return a;
}
vector<int> operator-(vector<int> a, vector<int> b) {
  int lim = max(a.size(), b.size());
  a.resize(lim);
  for (int i = 0; i < lim; ++i) {
    a[i] = a[i] - b[i];
    if (a[i] < 0) a[i] += mod;
  }
  return a;
}
vector<int> operator*(vector<int> a, int x) {
  int lim = a.size();
  for (int i = 0; i < lim; ++i) a[i] = 1ll * a[i] * x % mod;
  return a;
}
vector<int> Inv(vector<int> a) {
  int n = a.size();
  if (n == 1) {
    return vector<int>(1, fpow(a[0], mod - 2));
  }
  vector<int> b = Inv(fix(a, (n + 1) >> 1));
  return fix(b * 2 - a * b * b, n);
}
vector<int> Sqrt(vector<int> a) {
  int n = a.size();
  if (n == 1) {
    return vector<int>(1, Math::Cipolla(a[0]));
  }
  vector<int> b = fix(Sqrt(fix(a, (n + 1) >> 1)), n);
  return fix(((b + a * Inv(b))) * inv2, n);
}
vector<int> Deriv(vector<int> a) {
  int n = a.size();
  for (int i = 0; i < n - 1; ++i) {
    a[i] = 1ll * a[i + 1] * (i + 1) % mod;
  }
  a.pop_back();
  return a;
}
vector<int> Intgal(vector<int> a) {
  int n = a.size();
  a.push_back(0);
  for (int i = n; i >= 1; --i) {
    a[i] = 1ll * a[i - 1] * inv[i] % mod;
  }
  a[0] = 0;
  return a;
}
vector<int> Ln(vector<int> a) {
  int lim = a.size();
  a = fix(Intgal(Deriv(a) * Inv(a)), lim);
  return a;
}
vector<int> Exp(vector<int> a) {
  int n = a.size();
  if (n == 1) return vector<int>(1, 1);
  vector<int> b = fix(Exp(fix(a, (n + 1) >> 1)), n);
  return fix(b - b * (Ln(b) - a), n);
}
vector<int> operator/(vector<int> a, vector<int> b) {
  int n = a.size(), m = b.size();
  reverse(a.begin(), a.end()), reverse(b.begin(), b.end());
  a.resize(n - m + 1), b.resize(n - m + 1);
  a = fix(a * Inv(b), n - m + 1);
  reverse(a.begin(), a.end());
  return a;
}
vector<int> operator%(vector<int> a, vector<int> b) {
  int n = a.size(), m = b.size();
  a = a - (a / b) * b;
  return fix(a, m - 1);
}
vector<int> Shift(vector<int> a) {
  int n = a.size();
  a.push_back(0);
  for (int i = n; i >= 1; --i) a[i] = a[i - 1];
  a[0] = 0;
  a.pop_back();
  return a;
}
};  // namespace Poly
using namespace Poly;
const int MAXB = 150 + 10;
namespace Composit {
vector<int> A1[MAXB], A2[MAXB];
vector<int> compInv(vector<int> f) {
  int n = f.size();
  int siz = sqrt(n) + 1;
  int lim = 1;
  for (; lim < n; lim <<= 1)
    ;
  for (int i = 0; i < n - 1; ++i) f[i] = f[i + 1];
  f.pop_back();
  f = fix(Inv(f), lim);
  A1[0] = vector<int>(1, 1);
  A1[0].resize(lim);
  for (int i = 1; i <= siz; ++i) A1[i] = fix(A1[i - 1] * f, lim);
  A2[0] = vector<int>(1, 1);
  A2[0].resize(lim);
  for (int i = 1; i <= siz; ++i) A2[i] = fix(A2[i - 1] * A1[siz], lim);
  vector<int> ret;
  ret.resize(lim);
  for (int i = 0; i < siz; ++i) {
    for (int j = 0; j < siz && i * siz + j < n; ++j) {
      int tmp = 0;
      for (int k = 0; k <= i * siz + j - 1; ++k) {
        tmp += 1ll * A2[i][k] * A1[j][i * siz + j - 1 - k] % mod;
        tmp %= mod;
      }
      ret[i * siz + j] = 1ll * tmp * fpow(i * siz + j, mod - 2) % mod;
    }
  }
  return fix(ret, n);
}
}  // namespace Composit
int k;
inline void init(void) {
  process(N << 1);
  n = fread(), k = fread();
}
vector<int> F[3], G[3];
void solve(int len) {
  if (len == 1) {
    F[0][0] = F[0][1] = 1;
    F[1][0] = 1;
    return;
  }
  solve(len >> 1);
  G[0] = F[0], G[1] = F[1], G[2] = F[2];
  F[0] = fix(G[0] * G[0], k + 1) + Shift(fix(G[1] * G[1], k + 1));
  F[1] = fix(G[0] * G[1], k + 1) + Shift(fix(G[1] * G[2], k + 1));
  F[2] = fix(G[1] * G[1], k + 1) + Shift(fix(G[2] * G[2], k + 1));
  if (len & 1) {
    G[0] = F[0], G[1] = F[1], G[2] = F[2];
    F[0] = G[0] + Shift(G[0]) + Shift(G[1]);
    F[1] = G[0];
    F[2] = G[1];
  }
}
inline void work(void) {
  F[0].resize(k + 1);
  F[1].resize(k + 1);
  F[2].resize(k + 1);
  solve(n);
  for (int i = 1; i <= k; ++i) printf("%d ", F[0][i]);
}
int main() {
  init();
  work();
  return 0;
}