#include <bits/stdc++.h>
namespace fei_standard_library {
const int maxn = 1 << 21, mod = 998244353;
class poly {
 private:
  std::vector<int> data;

 public:
  poly(std::size_t len = std::size_t(0)) { data = std::vector<int>(len); }
  poly(const std::vector<int> &b) { data = b; }
  poly(const std::vector<int> &b, int len) {
    data = b;
    data.resize(len);
  }
  poly(const poly &b, int len) {
    data = b.data;
    data.resize(len);
  }
  poly(const int &h) { data.push_back(h); }
  void resize(std::size_t len, int val = 0) { data.resize(len, val); }
  std::size_t size(void) const { return data.size(); }
  void clear(void) { data.clear(); }
  int &operator[](std::size_t b) { return data[b]; }
  const int &operator[](std::size_t b) const { return data[b]; }
  poly operator*(const poly &h) const;
  poly operator*=(const poly &h);
  poly operator*(const int &h) const;
  poly operator*=(const int &h);
  poly operator+(const poly &h) const;
  poly operator+=(const poly &h);
  poly operator-(const poly &h) const;
  poly operator-=(const poly &h);
  poly operator<<(const std::size_t &b) const;
  poly operator<<=(const std::size_t &b);
  poly operator>>(const std::size_t &b) const;
  poly operator>>=(const std::size_t &b);
  poly operator/(const int &h) const;
  poly operator/=(const int &h);
  poly inv(void) const;
  poly inv(const int &h) const;
  friend poly sqrt(const poly &h);
};
int qpow(int a, int b) {
  int res = 1;
  while (b) {
    if (b & 1) res = (long long)res * a % mod;
    a = (long long)a * a % mod, b >>= 1;
  }
  return res;
}
int rev[maxn];
void dft(std::vector<int> &f, int n, int b) {
  static int w[maxn];
  for (int i = 0; i < n; ++i)
    if (i < rev[i]) std::swap(f[i], f[rev[i]]);
  for (int i = 2; i <= n; i <<= 1) {
    w[0] = 1, w[1] = qpow(3, (mod - 1) / i);
    if (b == -1) w[1] = qpow(w[1], mod - 2);
    for (int j = 2; j < i / 2; ++j) w[j] = (long long)w[j - 1] * w[1] % mod;
    for (int j = 0; j < n; j += i)
      for (int k = 0; k < i / 2; ++k) {
        int p = f[j + k], q = (long long)f[j + i / 2 + k] * w[k] % mod;
        f[j + k] = (p + q) % mod, f[j + i / 2 + k] = (p - q + mod) % mod;
      }
  }
}
poly poly::operator*(const poly &h) const {
  int N = 1;
  while (N < (int)(size() + h.size() - 1)) N <<= 1;
  std::vector<int> f(this->data), g(h.data);
  f.resize(N), g.resize(N);
  for (int i = 0; i < N; ++i)
    rev[i] = (rev[i >> 1] >> 1) | (i & 1 ? N >> 1 : 0);
  dft(f, N, 1), dft(g, N, 1);
  for (int i = 0; i < N; ++i) f[i] = (long long)f[i] * g[i] % mod;
  dft(f, N, -1), f.resize(size() + h.size() - 1);
  for (int i = 0, inv = qpow(N, mod - 2); i < (int)f.size(); ++i)
    f[i] = (long long)f[i] * inv % mod;
  return f;
}
poly poly::operator*=(const poly &h) { return *this = *this * h; }
poly poly::operator*(const int &h) const {
  std::vector<int> f(size());
  for (int i = 0; i < (int)f.size(); ++i) f[i] = (long long)f[i] * h % mod;
  return f;
}
poly poly::operator*=(const int &h) {
  for (int i = 0; i < (int)size(); ++i) data[i] = (long long)data[i] * h % mod;
  return *this;
}
poly poly::operator+(const poly &h) const {
  std::vector<int> f(this->data);
  if (f.size() < h.size()) f.resize(h.size());
  for (int i = 0; i < (int)h.size(); ++i) f[i] = (f[i] + h[i]) % mod;
  return f;
}
poly poly::operator+=(const poly &h) {
  std::vector<int> &f = this->data;
  if (f.size() < h.size()) f.resize(h.size());
  for (int i = 0; i < (int)h.size(); ++i) f[i] = (f[i] + h[i]) % mod;
  return f;
}
poly poly::operator-(const poly &h) const {
  std::vector<int> f(this->data);
  if (f.size() < h.size()) f.resize(h.size());
  for (int i = 0; i < (int)h.size(); ++i) f[i] = (f[i] - h[i] + mod) % mod;
  return f;
}
poly poly::operator-=(const poly &h) {
  std::vector<int> &f = this->data;
  if (f.size() < h.size()) f.resize(h.size());
  for (int i = 0; i < (int)h.size(); ++i) f[i] = (f[i] - h[i] + mod) % mod;
  return f;
}
poly poly::operator<<(const std::size_t &b) const {
  std::vector<int> f(size() + b);
  for (int i = 0; i < (int)size(); ++i) f[i + b] = data[i];
  return f;
}
poly poly::operator<<=(const std::size_t &b) { return *this = (*this) << b; }
poly poly::operator>>(const std::size_t &b) const {
  std::vector<int> f(size() - b);
  for (int i = 0; i < (int)f.size(); ++i) f[i] = data[i + b];
  return f;
}
poly poly::operator>>=(const std::size_t &b) { return *this = (*this) >> b; }
poly poly::operator/(const int &h) const {
  std::vector<int> f(this->data);
  int inv = qpow(h, mod - 2);
  for (int i = 0; i < (int)f.size(); ++i) f[i] = (long long)f[i] * inv % mod;
  return f;
}
poly poly::operator/=(const int &h) {
  int inv = qpow(h, mod - 2);
  for (int i = 0; i < (int)data.size(); ++i)
    data[i] = (long long)data[i] * inv % mod;
  return *this;
}
poly poly::inv(void) const {
  int N = 1;
  while (N < (int)(size() + size() - 1)) N <<= 1;
  std::vector<int> f(N), g(N), d(this->data);
  d.resize(N), f[0] = qpow(d[0], mod - 2);
  for (int w = 2; w < N; w <<= 1) {
    for (int i = 0; i < w; ++i) g[i] = d[i];
    for (int i = 0; i < w * 2; ++i)
      rev[i] = (rev[i >> 1] >> 1) | (i & 1 ? w : 0);
    dft(f, w << 1, 1), dft(g, w << 1, 1);
    for (int i = 0; i < w * 2; ++i)
      f[i] = (long long)f[i] * (2 - (long long)f[i] * g[i] % mod) % mod;
    dft(f, w << 1, -1);
    for (int i = 0, inv = qpow(w << 1, mod - 2); i < w; ++i)
      f[i] = (long long)f[i] * inv % mod;
    for (int i = w; i < w * 2; ++i) f[i] = 0;
  }
  f.resize(size());
  for (int i = 0; i < (int)f.size(); ++i) f[i] = (f[i] + mod) % mod;
  return f;
}
poly poly::inv(const int &h) const { return poly(*this, h).inv(); }
int modsqrt(int h) { return 1; }
poly sqrt(const poly &h) {
  int N = 1;
  while (N < (int)(h.size() + h.size() - 1)) N <<= 1;
  poly f(N), g(N), d(h);
  d.resize(N), f[0] = modsqrt(d[0]);
  for (int w = 2; w < N; w <<= 1) {
    g.resize(w);
    for (int i = 0; i < w; ++i) g[i] = d[i];
    f = (f + f.inv(w) * g) / 2;
    f.resize(w);
  }
  f.resize(h.size());
  return f;
}
}  // namespace fei_standard_library
int n, k;
struct Pair {
  fei_standard_library::poly f[3];
  Pair operator*(const Pair &b) const {
    Pair res;
    res.f[0] = f[0] * b.f[0] + ((f[1] * b.f[1]) << 1);
    res.f[1] = f[0] * b.f[1] + ((f[1] * b.f[2]) << 1);
    res.f[2] = f[1] * b.f[1] + ((f[2] * b.f[2]) << 1);
    for (int i = 0; i < 3; ++i)
      if ((int)res.f[i].size() > (k + 1)) res.f[i].resize(k + 1);
    return res;
  }
} ret, ans;
int main() {
  scanf("%d%d", &n, &k), --n;
  ret.f[0] = std::vector<int>{1, 1}, ret.f[1] = 1, ret.f[2] = 0, ans = ret;
  while (n) {
    if (n & 1) ans = ans * ret;
    ret = ret * ret, n >>= 1;
  }
  ans.f[0].resize(k + 1);
  for (int i = 1; i <= k; ++i) printf("%d ", ans.f[0][i]);
  return 0;
}
