#pragma region Include/Defines
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <limits.h>
#include <vector>
#include <stdlib.h>
#include <algorithm>
#include <memory.h>
#include <string.h>
#include <math.h>
#include <string>
#include <algorithm>
#include <functional>
#include <cassert>
#include <map>
#include <set>
#include <iostream>
#include <queue>
#include <time.h>

using namespace std;
typedef long long lli;
typedef vector<int> vi;
typedef vector<lli> vli;
typedef pair<int, int> pii;
typedef pair<lli, lli> pll;
typedef vector<pii> vpii;
typedef vector <pll> vpll;
typedef long double ld;
#define all(a) std::begin(a), std::end(a)

const int INF = 0x3f3f3f3f;
const lli LINF = 0x3f3f3f3f3f3f3f3f;

template<typename T, typename T2> inline void _max(T &a, T2 b) { a = max((T)a, (T)b); }
template<typename T, typename T2> inline void _min(T &a, T2 b) { a = min((T)a, (T)b); }

#ifdef _DEBUG
#define epr(...) fprintf(stderr,__VA_ARGS__)
#else
#define epr(...) 
#endif
#pragma endregion

#pragma region Modular Arithmetic
int MOD = 998244353;
int add(int x) { return x; }
template<typename... T> int add(int a, T... b) { a += add(b...); return a >= MOD ? a - MOD : a; }
template<typename... T> int _add(int &a, T... b) { return a = add(a, b...); }
inline int sub(const int a, const int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline int _sub(int &a, const int b) { return a = sub(a, b); }
inline int neg(const int a) { return MOD - a; }
int mul(int a) { return a; };
template<typename... T> int mul(int a, T... b) { return 1ll * a * mul(b...) % MOD; }
template<typename... T> int _mul(int &a, T... b) { return a = 1ll * a * mul(b...) % MOD; }
int binPow(int b, lli p) {
	int r = 1;
	while (p) {
		if (p & 1) r = mul(r, b);
		b = mul(b, b);
		p >>= 1;
	}
	return r;
}
int gcdex(int a, int b, int &x, int &y) {
	if (!b) return x = 1, y = 0, a;
	int px, py, res = gcdex(b, a % b, px, py);
	return x = py, y = px - a / b * py, res;
}
int inv(const int a) { // a and MOD must be coprime
	int x, y;
	int g = gcdex(a, MOD, x, y);
	assert(g == 1);
	x = (x % MOD + MOD) % MOD;
	return x;
}
inline int dvd(const int a, const int b) { // b and MOD must be coprime
	int rev = inv(b);
	return mul(a, inv(b));
} // b != 0
inline void _dvd(int &a, const int b) { a = dvd(a, b); } // b and MOD must be coprime
inline int convert(int x) {
	int tx = x % MOD + MOD;
	return tx >= MOD ? tx - MOD : tx;
};
#pragma endregion

const int MAX = 1e4 + 100;

int k, n;

int f[MAX], rf[MAX];

int C(int n, int k) {
	if (k < 0 || k > n) return 0;
	return mul(f[n], mul(rf[k], rf[n - k]));
}

void clear() {
}

void read() {
}

void solve() {
	for (int tk = 2; tk <= 2 * k; tk++) {
		int NG = 0;
		for (int i = 1; i <= tk; i++) 
			if(i <= k && tk - i <= k && i <= tk - i) NG++;
		int res = 0;
		for (int i = 0; i <= n / 2; i++) {
			int mc = mul(C(NG, i), C(n + k - 1 - 2 * i, k - 1));
			if (i & 1) mc = neg(mc);
			res = add(res, mc);
		}
		printf("%d\n", res);
	}
}

void precalc() {
	f[0] = 1;
	for (int i = 1; i < MAX; i++) f[i] = mul(f[i - 1], i);
	for (int i = 0; i < MAX; i++) rf[i] = inv(f[i]);
}

int main() {
	precalc();
#ifdef _LOCAL_VAN
	freopen("in.txt", "r", stdin);
#endif
	while (scanf("%d%d", &k, &n) == 2) {
		clear();
		read();
		solve();
#ifndef _LOCAL_VAN
		return 0;
#endif
	}
	return 0;
}

Measured memory_bytes: 384