#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
struct poly;
vector<int> rev, roots{0, 1}, Inv;
int ksm(int a, int b, int p) {
  int ans = 1;
  while (b) {
    if (b & 1) ans = 1ll * ans * a % p;
    b >>= 1, a = 1ll * a * a % p;
  }
  return ans;
}
void init(int k) {
  if (Inv.size() < k) {
    int j = Inv.size();
    Inv.resize(k + 1);
    for (int i = j; i <= k; ++i) Inv[i] = ksm(i, p - 2, p);
  }
  return;
}
void dft(vector<int> &a) {
  int n = a.size();
  if (rev.size() != n) {
    rev.resize(n);
    for (int i = 0; i < n; ++i)
      rev[i] = rev[i >> 1] >> 1 | ((i & 1) ? n >> 1 : 0);
  }
  for (int i = 0; i < n; ++i)
    if (rev[i] < i) swap(a[rev[i]], a[i]);
  if (roots.size() < n) {
    int k = roots.size();
    roots.resize(n);
    while (k < n) {
      int e = ksm(3, (p - 1) / (k << 1), p);
      for (int i = (k >> 1); i < k; ++i) {
        roots[i << 1] = roots[i];
        roots[i << 1 | 1] = 1ll * roots[i] * e % p;
      }
      k <<= 1;
    }
  }
  for (int i = 1; i < n; i <<= 1) {
    for (int j = 0; j < n; j += (i << 1)) {
      for (int k = 0; k < i; ++k) {
        int x = a[j | k], y = 1ll * a[i | j | k] * roots[i | k] % p;
        a[j | k] = ((x + y) > p ? ((x + y) - p) : x + y),
              a[i | j | k] = ((x - y + p) > p ? ((x - y + p) - p) : x - y + p);
      }
    }
  }
}
void idft(vector<int> &a) {
  dft(a);
  reverse(a.begin() + 1, a.end());
  int tmp = ksm(a.size(), p - 2, p);
  for (int i = 0; i < a.size(); ++i) a[i] = 1ll * a[i] * tmp % p;
}
void build(int l, int r, int t, const vector<int> &x, vector<poly> &tr);
void work(int l, int r, int t, poly x, vector<int> &ans,
          const vector<poly> &tr);
struct poly {
  vector<int> a;
  poly() {}
  poly(int x) {
    if (x) a = {x};
  }
  poly(const vector<int> &a0) : a(a0) {
    while (!a.empty() && !a.back()) a.pop_back();
  }
  int size() const { return a.size(); }
  int operator[](int id) const {
    if (id < 0 || id >= size()) return 0;
    return a[id];
  }
  poly modxk(int k) const {
    k = min(k, size());
    return poly(vector<int>(a.begin(), a.begin() + k));
  }
  poly divxk(int k) const {
    if (size() <= k) return poly();
    return poly(vector<int>(a.begin() + k, a.end()));
  }
  poly deriv() const {
    if (a.empty()) return poly();
    vector<int> res(size() - 1);
    for (int i = 0; i < size() - 1; ++i) res[i] = 1ll * a[i + 1] * (i + 1) % p;
    return poly(res);
  }
  poly integr() const {
    if (a.empty()) return poly();
    vector<int> res(size() + 1);
    init(size());
    for (int i = 0; i < size(); ++i) res[i + 1] = 1ll * a[i] * Inv[i + 1] % p;
    return poly(res);
  }
  friend poly operator*(poly a, poly b) {
    int len = 1, tot = a.size() + b.size() - 1;
    while (len < tot) len <<= 1;
    if (tot <= 128) {
      vector<int> c(len);
      for (int i = 0; i < a.size(); ++i)
        for (int j = 0; j < b.size(); ++j)
          c[i + j] = 1ll * (c[i + j] + 1ll * a[i] * b[j]) % p;
      return poly(c);
    }
    a.a.resize(len), b.a.resize(len);
    dft(a.a), dft(b.a);
    for (int i = 0; i < len; ++i) a.a[i] = 1ll * a[i] * b[i] % p;
    idft(a.a);
    return poly(a.a);
  }
  friend poly operator-(const poly a, const poly b) {
    vector<int> tmp(max(a.size(), b.size()));
    for (int i = 0; i < tmp.size(); ++i) {
      int x = a[i] - b[i];
      tmp[i] = ((x + p) > p ? ((x + p) - p) : x + p);
    }
    return poly(tmp);
  }
  friend poly operator+(const poly a, const poly b) {
    vector<int> tmp(max(a.size(), b.size()));
    for (int i = 0; i < tmp.size(); ++i) {
      int x = a[i] + b[i];
      tmp[i] = ((x) > p ? ((x)-p) : x);
    }
    return poly(tmp);
  }
  poly log(int len) { return (deriv() * inv(len)).integr().modxk(len); }
  poly exp(int len) {
    poly b(1);
    int k = 1;
    while (k < len) {
      k <<= 1;
      b = b * (1 - b.log(k) + modxk(k)).modxk(k);
    }
    return b.modxk(len);
  }
  poly inv(int len) const {
    poly b(ksm(a[0], p - 2, p));
    int k = 1;
    while (k < len) {
      k <<= 1;
      b = (b * (2 - modxk(k) * b)).modxk(k);
    }
    return b.modxk(len);
  }
};
struct matrix {
  poly a[2][2];
  poly *operator[](int x) { return a[x]; }
};
struct vec {
  poly a[2];
  poly &operator[](int x) { return a[x]; }
};
int n, K;
matrix mul(matrix a, matrix b) {
  matrix c;
  for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 2; ++j)
      for (int k = 0; k < 2; ++k)
        c[i][j] = (c[i][j] + (a[i][k] * b[k][j]).modxk(K));
  return c;
}
vec mul(vec a, matrix b) {
  vec c;
  for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 2; ++j) c[i] = (c[i] + (a[j] * b[i][j]).modxk(K));
  return c;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  cin >> n >> K;
  ++K;
  vec ans;
  ans.a[0] = vector<int>{1};
  matrix b;
  b[0][1] = poly{vector<int>{0, 1}};
  b[0][0] = poly{vector<int>{1, 1}};
  b[1][0] = poly{vector<int>{1}};
  while (n) {
    if (n & 1) ans = mul(ans, b);
    n >>= 1, b = mul(b, b);
  }
  ans.a[0] = ans.a[0].divxk(1);
  for (auto x : ans.a[0].a) cout << x << ' ';
  int st = ans.a[0].size();
  for (int i = st + 1; i < K; ++i) cout << 0 << ' ';
  cout << '\n';
  return 0;
}
