#include <bits/stdc++.h>

#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T>
T gcd(T a, T b) { return ((a % b == 0) ? b : gcd(b, a % b)); }
template <typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 998244353;

namespace Problem {
using namespace std;
template <long long Mod = MOD>
class Modint {
 public:
  long long v;

  Modint(const Modint &x) { v = x.v; }
  explicit Modint(int x) {
    if (x < 0 or Mod <= x) x %= Mod;
    if (x < 0) x += Mod;
    v = x;
  }
  explicit Modint(long long x) {
    if (x < 0 or Mod <= x) x %= Mod;
    if (x < 0) x += Mod;
    v = x;
  }
  explicit Modint(unsigned x) {
    if (Mod <= x) x %= Mod;
    v = x;
  }
  explicit Modint(unsigned long long x) {
    if (Mod <= x) x %= Mod;
    v = x;
  }
  template <typename T>
  explicit Modint(T x) {
    if (x < 0 or Mod <= x) x %= Mod;
    v = x;
  }
  Modint() : v(0) {}
  long long get() const { return v; }
  Modint mpow(Modint &n) const { return mpow(n.v); }
  Modint mpow(long long n) const {
    long long i = 1, p = v;
    Modint ret(1);
    while (i <= n) {
      if (i & n) ret *= p;
      i = (i << 1);
      p = (p * p) % Mod;
    }
    return ret;
  }
  Modint operator-() const { return (v ? Modint(Mod - v) : Modint(0)); }
  explicit operator int() const { return v; }
  explicit operator long long() const { return v; }
  Modint &operator+=(const Modint &a) {
    v = (v + a.v);
    if (v >= Mod) v -= Mod;
    return *this;
  }
  Modint &operator-=(const Modint &a) {
    v = (v - a.v);
    if (v < 0) v += Mod;
    return *this;
  }
  Modint &operator*=(const Modint &a) {
    v = (v * a.v) % Mod;
    return *this;
  }
  Modint &operator/=(const Modint &a) {
    v = (v * a.mpow(Mod - 2).v) % Mod;
    return *this;
  }
  template <class T>
  Modint &operator+=(const T &a) {
    v = (v + Modint(a).v);
    if (v >= Mod) v -= Mod;
    return *this;
  }
  template <class T>
  Modint &operator-=(const T &a) {
    v = (v - Modint(a).v);
    if (v < 0) v += Mod;
    return *this;
  }
  template <class T>
  Modint &operator*=(const T &a) {
    v = (v * Modint(a).v) % Mod;
    return *this;
  }
  template <class T>
  Modint &operator/=(const T &a) {
    v = (v * Modint(a).mpow(Mod - 2).v) % Mod;
    return *this;
  }
  friend Modint operator+(const Modint &a, const Modint &b) {
    return Modint(a) += b;
  }
  friend Modint operator-(const Modint &a, const Modint &b) {
    return Modint(a) -= b;
  }
  friend Modint operator*(const Modint &a, const Modint &b) {
    return Modint(a) *= b;
  }
  friend Modint operator/(const Modint &a, const Modint &b) {
    return Modint(a) /= b;
  }
  template <class T, class U>
  friend Modint operator+(const T &a, const U &b) {
    return Modint(a) += Modint(b);
  }
  template <class T, class U>
  friend Modint operator-(const T &a, const U &b) {
    return Modint(a) -= Modint(b);
  }
  template <class T, class U>
  friend Modint operator*(const T &a, const U &b) {
    return Modint(a) *= Modint(b);
  }
  template <class T, class U>
  friend Modint operator/(const T &a, const U &b) {
    return Modint(a) /= Modint(b);
  }
};

template <long long M>
ostream &operator<<(ostream &os, const Modint<M> m) {
  return os << m.v;
}

template <long long Mod = MOD>
class Factorial {
 private:
  int n;

 public:
  vector<long long> fac, inv;

 public:
  Factorial(long long n) : n(n), fac(n + 1), inv(n + 1) {
    fac[0] = 1;
    for (int i = 0; i < n; ++i) fac[i + 1] = fac[i] * (i + 1) % Mod;
    inv[n] = modpow(fac[n], Mod - 2);
    for (int i = n - 1; i >= 0; --i) inv[i] = inv[i + 1] * (i + 1) % Mod;
  };
  long long modpow(long long a, long long n, long long mod = Mod) {
    long long i = 1, ret = 1, p = a;
    while (i <= n) {
      if (i & n) {
        ret = (ret * p) % mod;
      }
      i = (i << 1);
      p = (p * p) % mod;
    }
    return ret;
  }
  long long comb(int a, int b) {
    return (fac[a] * inv[b] % Mod) * inv[a - b] % Mod;
  }
};
class Solver2 {
 public:
  LL n, k;
  Factorial<> fac;
  vector<Modint<>> ans;
  vector<vector<Modint<>>> dp;
  Solver2(LL n, LL k) : n(n), k(k), fac(4444), ans(2 * k + 1), dp(k + 1, vector<Modint<>>(n + 1)){};

  void solve() {
    DBG(n, k)
    /*for (int i = 2; i <= k + 1; ++i) {
      int j = 1;
      for (; j * 2 <= i; ++j) {
        DBG(i, j, ans[i])
        if (j * 2 == i) {
          ans[i] += fac.comb(n + k - j - 2, k - j - 1);
        } else {
          ans[i] += fac.comb(n + k - j - 2, k - j - 1);
        }
      }
      for (; j <= k; ++j) {
        DBG(i, j, ans[i], '*')
        ans[i] += fac.comb(n + k - j - 1, k - j);
      }
    }*/
    dp[0][0] = Modint<>(1);
    vector<Modint<>> sum(n + 1, Modint<>(1));
    for (int i = 1; i <= k; ++i) {
      for (int j = n; j >= 1; --j) {
        dp[i][j] += dp[i - 1][j] + sum[j - 1] * 2;
      }
      dp[i][0] = dp[i - 1][0];
      for (int j = 1; j <= n; ++j) {
        sum[j] = sum[j - 1] + dp[i][j];
      }
    }
    for (int i = 2; i <= k + 1; ++i) {
      if (i % 2 == 0) {
        for (int j = 0; j <= n; ++j) {
          DBG(i / 2, j, n - j + k - i, n - j, ans[i])
          DBG(dp[(i - 1) / 2][j])
          if (k - i + 1 > 0)
            ans[i] += dp[(i - 1) / 2][j] * fac.comb(n - j + k - i, n - j);
          if (k - i + 1 == 0 && j == n)
            ans[i] += dp[(i - 1) / 2][j];
          if (k - i + 1 == 0 && j == n - 1)
            ans[i] += dp[(i - 1) / 2][j];
          if (k - i + 1 > 0 && n - j - 1 >= 0) ans[i] += dp[(i - 1) / 2][j] * fac.comb(n - j + k - i - 1, n - j - 1);
        }
      } else {
        for (int j = 0; j <= n; ++j) {
          DBG(i / 2, j, n - j + k - i, n - j, ans[i])
          DBG(dp[i / 2][j])
          if (k - i + 1 > 0) ans[i] += dp[i / 2][j] * fac.comb(n - j + k - i, n - j);
          if (k - i + 1 == 0 && j == n) ans[i] += dp[i / 2][j];
        }
      }
    }
    //output
    for (int i = k + 2; i <= 2 * k; ++i) {
      ans[i] = ans[2 * k + 2 - i];
    }
    for (int i = 2; i <= 2 * k; ++i) {
      cout << ans[i] << endl;
    }
  }
};
}  // namespace Problem

int main() {
  std::cin.tie(0);
  std::ios_base::sync_with_stdio(false);
  // std::cout << std::fixed << std::setprecision(12);
  long long n = 0, k;
  std::cin >> k >> n;

  Problem::Solver2 sol(n, k);
  sol.solve();
  return 0;
}


Measured memory_bytes: 31744