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 std::min;
using std::reverse;
const int mod = 998244353, cmod = 499122176, imod = 86583718, g = 3;
int r[262144], a[262144], b[262144], c[262144], ans[262144];
int tf[262144], tf_inv[262144], tf_sqr[262144], tf_ln[262144], tf_exp[262144],
    tf_pow[262144], tf_div[262144], tf_mdl[262144], tf_cos[262144],
    tf_sin[262144], tf_asin0[262144], tf_asin1[262144], tf_atan0[262144],
    tf_atan1[262144];
struct pnum {
  static int W;
  int re, im;
  pnum(const int& r, const int& i) : re(r), im(i) {}
  void operator*=(const pnum& p) {
    int tmp0(1ll * re * p.re % mod + 1ll * im * p.im % mod * W % mod);
    int tmp1(1ll * re * p.im % mod + 1ll * im * p.re % mod);
    if (tmp0 >= mod) tmp0 -= mod;
    if (tmp1 >= mod) tmp1 -= mod;
    re = tmp0, im = tmp1;
  }
};
int pnum::W = 0;
pnum operator^(const pnum& x, int p) {
  pnum tmp(x), res(1, 0);
  while (p) {
    if (p & 1) res *= tmp;
    tmp *= tmp;
    p >>= 1;
  }
  return res;
}
int pow(int x, int p) {
  int res(1);
  while (p) {
    if (p & 1) res = 1ll * res * x % mod;
    x = 1ll * x * x % mod;
    p >>= 1;
  }
  return res;
}
int cipolla(int x) {
  int tmp0, tmp1;
  while (1) {
    tmp0 = rand() % mod;
    tmp1 = 1ll * tmp0 * tmp0 % mod - x;
    if (tmp1 < 0) tmp1 += mod;
    if (pow(tmp1, cmod) + 1 == mod) break;
  }
  pnum::W = tmp1;
  pnum res(tmp0, 1);
  res = res ^ (mod - cmod);
  return min(res.re, mod - res.re);
}
inline void swap(int& a, int& b) {
  int tmp(a);
  a = b, b = tmp;
}
void ntt(int* t, int lim) {
  for (int i(0); i < lim; ++i) {
    if (i < r[i]) swap(t[i], t[r[i]]);
  }
  for (int i(1), j(2); i < lim; i <<= 1, j <<= 1) {
    int wn(pow(g, (mod - 1) / j));
    for (int k(0); k < lim; k += j) {
      for (int l(k), w(1); l < k + i; ++l, w = 1ll * w * wn % mod) {
        int tmp(1ll * w * t[l + i] % mod);
        t[l + i] = t[l] - tmp;
        if (t[l + i] < 0) t[l + i] += mod;
        t[l] += tmp;
        if (t[l] >= mod) t[l] -= mod;
      }
    }
  }
}
void inv(int n, int* f, int* invf) {
  int clear(0);
  *invf = pow(*f, mod - 2);
  for (int i(2), j(4), mi(n << 1); i < mi; i <<= 1, j <<= 1) {
    for (int k(0); k < j; ++k) r[k] = (r[k >> 1] | ((k & 1) ? j : 0)) >> 1;
    for (int k(0); k < i; ++k) tf_inv[k] = f[k];
    ntt(tf_inv, j);
    ntt(invf, j);
    for (int k(0); k < j; ++k) {
      int tmp(2 - 1ll * tf_inv[k] * invf[k] % mod);
      if (tmp < 0) tmp += mod;
      invf[k] = 1ll * tmp * invf[k] % mod;
    }
    reverse(invf + 1, invf + j);
    ntt(invf, j);
    int inv(pow(j, mod - 2));
    for (int k(0); k < i; ++k) invf[k] = 1ll * invf[k] * inv % mod;
    for (int k(i); k < j; ++k) invf[k] = 0;
    clear = i;
  }
  for (int i(n); i < clear; ++i) invf[i] = 0;
  clear <<= 1;
  for (int i(0); i < clear; ++i) tf_inv[i] = 0;
}
void sqrt(int n, int* f, int* sqf) {
  int inv2(pow(2, mod - 2)), clear(0);
  *sqf = cipolla(*f);
  for (int i(2), j(4), mi(n << 1); i < mi; i <<= 1, j <<= 1) {
    inv(i, sqf, tf);
    for (int k(0); k < i; ++k) tf_sqr[k] = f[k];
    ntt(tf_sqr, j);
    ntt(tf, j);
    ntt(sqf, j);
    for (int k(0); k < j; ++k) {
      int tmp(1ll * tf[k] * tf_sqr[k] % mod + sqf[k]);
      if (tmp >= mod) tmp -= mod;
      sqf[k] = 1ll * tmp * inv2 % mod;
    }
    reverse(sqf + 1, sqf + j);
    ntt(sqf, j);
    int inv(pow(j, mod - 2));
    for (int k(0); k < i; ++k) sqf[k] = 1ll * sqf[k] * inv % mod, tf[k] = 0;
    for (int k(i); k < j; ++k) sqf[k] = 0, tf[k] = 0;
    clear = i;
  }
  for (int i(n); i < clear; ++i) sqf[i] = 0;
  clear <<= 1;
  for (int i(0); i < clear; ++i) tf_sqr[i] = 0;
}
void der(int n, int* f, int* df) {
  for (int i(1); i < n; ++i) df[i - 1] = 1ll * f[i] * i % mod;
}
void ite(int n, int* f, int* itf) {
  for (int i(1); i < n; ++i) itf[i] = 1ll * f[i - 1] * pow(i, mod - 2) % mod;
}
void ln(int n, int* f, int* lnf) {
  inv(n, f, tf);
  der(n, f, tf_ln);
  int len(1);
  while (len < n) len <<= 1;
  len <<= 1;
  ntt(tf, len);
  ntt(tf_ln, len);
  for (int i(0); i < len; ++i) tf_ln[i] = 1ll * tf[i] * tf_ln[i] % mod;
  reverse(tf_ln + 1, tf_ln + len);
  ntt(tf_ln, len);
  int inv(pow(len, mod - 2));
  for (int i(0); i < n; ++i) tf_ln[i] = 1ll * tf_ln[i] * inv % mod;
  ite(n, tf_ln, lnf);
  *lnf = 0;
  for (int i(0); i < len; ++i) tf[i] = tf_ln[i] = 0;
}
void exp(int n, int* f, int* expf) {
  int clear(0);
  *expf = 1;
  for (int i(2), j(4), mi(n << 1); i < mi; i <<= 1, j <<= 1) {
    ln(i, expf, tf_exp);
    for (int k(0); k < i; ++k) tf[k] = f[k];
    ntt(tf_exp, j);
    ntt(tf, j);
    ntt(expf, j);
    for (int k(0); k < j; ++k) {
      int tmp((1 + tf[k] - tf_exp[k]) % mod);
      if (tmp < 0) tmp += mod;
      expf[k] = 1ll * tmp * expf[k] % mod;
    }
    reverse(expf + 1, expf + j);
    ntt(expf, j);
    int inv(pow(j, mod - 2));
    for (int k(0); k < i; ++k) expf[k] = 1ll * expf[k] * inv % mod, tf[k] = 0;
    for (int k(i); k < j; ++k) expf[k] = 0, tf[k] = 0;
    clear = i, *tf_exp = 0;
  }
  for (int i(n); i < clear; ++i) expf[i] = 0;
  clear <<= 1;
  for (int i(0); i < clear; ++i) tf[i] = tf_exp[i] = 0;
}
void pow(int n, int* f, int* pf, int p) {
  int k(0);
  while (!f[k]) ++k;
  int tmp(n - k);
  for (int i(0); i < tmp; ++i) tf_pow[i] = f[i + k];
  ln(tmp, tf_pow, tf_pow);
  for (int i(0); i < tmp; ++i) tf_pow[i] = 1ll * tf_pow[i] * p % mod;
  exp(tmp, tf_pow, pf);
  for (int i(0); i < tmp; ++i) tf_pow[i] = 0;
  long long tk(1ll * k * p);
  if (tk < n) {
    tmp = pow(f[k], p);
    k = tk;
    for (int i(n - k - 1); i >= 0; --i) pf[i + k] = 1ll * tmp * pf[i] % mod;
    for (int i(0); i < k; ++i) pf[i] = 0;
  } else {
    for (int i(0); i < tmp; ++i) pf[i] = 0;
  }
}
void div(int n, int* f, int m, int* g, int* dif) {
  reverse(f, f + n + 1);
  reverse(g, g + m + 1);
  int tmp(n - m + 1), len(1);
  while (len < tmp) len <<= 1;
  len <<= 1;
  inv(tmp, g, tf_div);
  for (int i(0); i < tmp; ++i) tf[i] = f[i];
  ntt(tf, len);
  ntt(tf_div, len);
  for (int i(0); i < len; ++i)
    dif[i] = 1ll * tf[i] * tf_div[i] % mod, tf[i] = tf_div[i] = 0;
  reverse(dif + 1, dif + len);
  ntt(dif, len);
  int inv(pow(len, mod - 2));
  for (int i(0); i < tmp; ++i) dif[i] = 1ll * dif[i] * inv % mod;
  for (int i(tmp); i < len; ++i) dif[i] = 0;
  reverse(dif, dif + tmp);
  reverse(f, f + n + 1);
  reverse(g, g + m + 1);
}
void mdl(int n, int* f, int m, int* g, int* dif, int* mdf) {
  int tmp(min(m, n - m + 1)), len(1);
  for (int i(0); i < tmp; ++i) tf_mdl[i] = dif[i];
  for (int i(0); i < m; ++i) tf[i] = g[i];
  while (len < m) len <<= 1;
  len <<= 1;
  for (int i(0); i < len; ++i) r[i] = (r[i >> 1] | ((i & 1) ? len : 0)) >> 1;
  ntt(tf, len);
  ntt(tf_mdl, len);
  for (int i(0); i < len; ++i) tf_mdl[i] = 1ll * tf_mdl[i] * tf[i] % mod;
  ntt(tf_mdl, len);
  reverse(tf_mdl + 1, tf_mdl + len);
  int inv(pow(len, mod - 2));
  for (int i(0); i < len; ++i) tf_mdl[i] = 1ll * tf_mdl[i] * inv % mod;
  for (int i(0); i < m; ++i) {
    tmp = f[i] - tf_mdl[i];
    if (tmp < 0) tmp += mod;
    mdf[i] = tmp;
  }
  for (int i(0); i < len; ++i) tf[i] = tf_mdl[i] = 0;
}
void scs(int type, int n, int* f, int* ansf0, int* ansf1 = NULL) {
  int tmp(pow(2, mod - 2));
  for (int i(0); i < n; ++i) ansf0[i] = 1ll * imod * f[i] % mod;
  exp(n, ansf0, tf_cos);
  for (int i(0); i < n; ++i) ansf0[i] = mod - ansf0[i];
  exp(n, ansf0, tf_sin);
  if (type) {
    for (int i(0); i < n; ++i)
      ansf0[i] = 1ll * tmp * (tf_cos[i] + tf_sin[i]) % mod;
  } else {
    tmp = 1ll * tmp * (mod - imod) % mod;
    for (int i(0); i < n; ++i)
      ansf0[i] = 1ll * tmp * (tf_cos[i] - tf_sin[i] + mod) % mod;
  }
  if (ansf1 != NULL) {
    tmp = 1ll * tmp * (mod - imod) % mod;
    for (int i(0); i < n; ++i)
      ansf1[i] = 1ll * tmp * (tf_cos[i] - tf_sin[i] + mod) % mod;
  }
  for (int i(0); i < n; ++i) tf_sin[i] = tf_cos[i] = 0;
}
void asin(int n, int* f, int* asinf) {
  int len(1);
  for (int i(0); i < n; ++i) tf_asin0[i] = f[i];
  while (len < n) len <<= 1;
  len <<= 1;
  for (int i(0); i < len; ++i) r[i] = (r[i >> 1] | ((i & 1) ? len : 0)) >> 1;
  ntt(tf_asin0, len);
  for (int i(0); i < len; ++i)
    tf_asin0[i] = (1 + mod - 1ll * tf_asin0[i] * tf_asin0[i] % mod) % mod;
  reverse(tf_asin0 + 1, tf_asin0 + len);
  ntt(tf_asin0, len);
  int inv0(pow(len, mod - 2));
  for (int i(0); i < n; ++i) tf_asin0[i] = 1ll * tf_asin0[i] * inv0 % mod;
  for (int i(n); i < len; ++i) tf_asin0[i] = 0;
  sqrt(n, tf_asin0, asinf);
  inv(n, asinf, tf_asin1);
  der(n, f, tf_asin0);
  *(tf_asin0 + n - 1) = 0;
  ntt(tf_asin0, len);
  ntt(tf_asin1, len);
  for (int i(0); i < len; ++i)
    tf_asin1[i] = 1ll * tf_asin1[i] * tf_asin0[i] % mod;
  reverse(tf_asin1 + 1, tf_asin1 + len);
  ntt(tf_asin1, len);
  for (int i(0); i < n; ++i) tf_asin1[i] = 1ll * tf_asin1[i] * inv0 % mod;
  ite(n, tf_asin1, asinf);
  *asinf = 0;
  for (int i(0); i < len; ++i) tf_asin0[i] = tf_asin1[i] = 0;
}
void atan(int n, int* f, int* atanf) {
  int len(1);
  for (int i(0); i < n; ++i) tf_atan0[i] = f[i];
  while (len < n) len <<= 1;
  len <<= 1;
  for (int i(0); i < len; ++i) r[i] = (r[i >> 1] | ((i & 1) ? len : 0)) >> 1;
  ntt(tf_atan0, len);
  for (int i(0); i < len; ++i)
    tf_atan0[i] = (1ll * tf_atan0[i] * tf_atan0[i] + 1) % mod;
  reverse(tf_atan0 + 1, tf_atan0 + len);
  ntt(tf_atan0, len);
  int inv0(pow(len, mod - 2));
  for (int i(0); i < n; ++i) tf_atan0[i] = 1ll * tf_atan0[i] * inv0 % mod;
  for (int i(n); i < len; ++i) tf_atan0[i] = 0;
  inv(n, tf_atan0, tf_atan1);
  der(n, f, tf_atan0);
  *(tf_atan0 + n - 1) = 0;
  ntt(tf_atan0, len);
  ntt(tf_atan1, len);
  for (int i(0); i < len; ++i)
    tf_atan0[i] = 1ll * tf_atan0[i] * tf_atan1[i] % mod;
  reverse(tf_atan0 + 1, tf_atan0 + len);
  ntt(tf_atan0, len);
  for (int i(0); i < n; ++i) tf_atan0[i] = 1ll * tf_atan0[i] * inv0 % mod;
  ite(n, tf_atan0, atanf);
  for (int i(0); i < len; ++i) tf_atan0[i] = tf_atan1[i] = 0;
}
int main() {
  int n, k, len(1), inv0(pow(2, mod - 2));
  scanf("%d%d", &n, &k);
  a[0] = a[2] = 1, a[1] = 6;
  sqrt(k + 1, a, b);
  inv(k + 1, b, ans);
  b[0] += 1, b[1] += 1;
  for (int i(0); i <= k; ++i) b[i] = 1ll * b[i] * inv0 % mod;
  pow(k + 1, b, c, n + 1);
  while (len < k) len <<= 1;
  len <<= 1;
  for (int i(0); i < len; ++i) r[i] = (r[i >> 1] | ((i & 1) ? len : 0)) >> 1;
  ntt(ans, len);
  ntt(c, len);
  for (int i(0); i < len; ++i) ans[i] = 1ll * ans[i] * c[i] % mod;
  reverse(ans + 1, ans + len);
  ntt(ans, len);
  inv0 = pow(len, mod - 2);
  n = min(n, k);
  for (int i(1); i <= n; ++i) printf("%d ", 1ll * ans[i] * inv0 % mod);
  for (int i(n + 1); i <= k; ++i) printf("0 ");
  return 0;
}