#include <bits/stdc++.h>
 
#define rep(...) overload_rep(__VA_ARGS__, rep_1, rep_0) (__VA_ARGS__)
#define rep_0(i, end) for (int i = 0; i < (end); ++i)
#define rep_1(i, fr, ba) for (int i = (fr); i <= (ba); ++i)
#define overload_rep(arg_0, arg_1, arg_2, name, ...) name
#define all(box) box.begin(), box.end()
 
template <class T, class U> inline bool chmax(T& lhs, const U& rhs) { if (lhs < rhs) { lhs = rhs; return 1; } return 0; }
template <class T, class U> inline bool chmin(T& lhs, const U& rhs) { if (lhs > rhs) { lhs = rhs; return 1; } return 0; }

template <int MODULUS = 1000000007>
struct modulo_int {
private:

  long long value;
  constexpr void normalize() {
    value %= MODULUS;
    if (value < 0) value += MODULUS;
  }

public:

  constexpr modulo_int(const long long& value_ = 0) : value(value_) { normalize(); }
  constexpr modulo_int operator - () const { return modulo_int(MODULUS - value); }
  constexpr modulo_int operator ~ () const { return modulo_int(*this) << (MODULUS - 2); }
  constexpr const long long& operator () () const { return value; }

  constexpr modulo_int operator + (const modulo_int& rhs) const { return modulo_int(*this) += rhs; }
  constexpr modulo_int& operator += (const modulo_int& rhs) {
    if ((value += rhs.value) >= MODULUS) value -= MODULUS;
    return (*this);
  }

  constexpr modulo_int operator - (const modulo_int& rhs) const { return modulo_int(*this) -= rhs; }
  constexpr modulo_int& operator -= (const modulo_int& rhs) {
    if ((value += MODULUS - rhs.value) >= MODULUS) value -= MODULUS;
    return (*this);
  }

  constexpr modulo_int operator * (const modulo_int& rhs) const { return modulo_int(*this) *= rhs; }
  constexpr modulo_int& operator *= (const modulo_int& rhs) {
    (value *= rhs.value) %= MODULUS;
    return (*this);
  }

  constexpr modulo_int operator / (const modulo_int& rhs) const { return modulo_int(*this) /= rhs; }
  constexpr modulo_int& operator /= (const modulo_int& rhs) {
    return (*this) *= ~rhs;
  }

  constexpr modulo_int operator << (const long long& shift) const {
    modulo_int result(1), mult(*this);
    for (long long t = shift; t > 0; t >>= 1) {
      if (t & 1) result *= mult;
      mult *= mult;
    }
    return result;
  }

  friend std::istream& operator >> (std::istream& stream, modulo_int& lhs) {
    stream >> lhs.value;
    lhs.normalize();
    return stream;
  }

  friend std::ostream& operator << (std::ostream& stream, const modulo_int& rhs) {
    return stream << rhs.value;
  }

};

constexpr int mod = 998244353;
constexpr int size = 16384;
using modint = modulo_int<mod>;

template <size_t N>
struct modarray {
  modint data[N + 1];
};

template <size_t N>
constexpr modarray<N> calc_fact() {
  modarray<N> res;
  res.data[0] = 1;
  for (int i = 1; i <= N; ++i) {
    res.data[i] = res.data[i - 1] * i;
  }
  return res;
}

constexpr auto fact = calc_fact<size>();

template <size_t N>
constexpr modarray<N> calc_fact_inv() {
  modarray<N> res;
  res.data[N] = ~fact.data[N];
  for (int i = N; i > 0; --i) {
    res.data[i - 1] = res.data[i] * i;
  }
  return res;
} 

constexpr auto ifact = calc_fact_inv<size>();

// nCr
modint comb(const int& N, const int& R) {
  if (N < 0 || N < R || R < 0) return modint();
  return fact.data[N] * ifact.data[N - R] * ifact.data[R];
}

// x_0 + x_1 + ... x_N-1 = S
modint calc(const int& N, const int& S) {
  return comb(S + N - 1, S);
}

int main() {

  int N, K;
  std::cin >> K >> N;

  rep (S, 2, 2 * K) {
    int num = (S - 1) / 2 - std::max(S - K, 1) + 1;
    modint ans;
    if (S % 2 == 0) {
      rep (i, 0, num) {
        ans += comb(num, i) * (modint(2) << i) * calc(K - 2 * num + i - 1, N - i);
        ans += comb(num, i) * (modint(2) << i) * calc(K - 2 * num + i - 1, N - i - 1);
      }
    } else {
      rep (i, 0, num) {
        ans += comb(num, i) * (modint(2) << i) * calc(K - 2 * num + i, N - i);
      }
    }
    std::cout << ans << '\n';
  }

}


Measured memory_bytes: 256