#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;

#define pb push_back
#define mp make_pair
#define rep(i,n) for(int i = 0; i < (n); i++)
#define repr(i,b,e) for(int i = (b); i <= (e); i++)

#define pr(x) do{cerr << (#x) << " = " << (x) << endl;}while(0)
#define pri(x,i) do{cerr << (#x) << "[" << i << "] = " << (x[i]) << endl;}while(0)

namespace std {
	template<class S, class T> pair<S, T> operator + (const pair<S, T> &a, const pair<S, T> &b) {return mp<S, T>(a.first + b.first, a.second + b.second);}
	template<class S, class T> pair<S, T> operator - (const pair<S, T> &a, const pair<S, T> &b) {return mp<S, T>(a.first - b.first, a.second - b.second);}
	template<class S, class T> pair<S, T>& operator += (pair<S, T> &a, const pair<S, T> &other) {return a = a + other;}
	template<class S, class T> pair<S, T>& operator -= (pair<S, T> &a, const pair<S, T> &other) {return a = a - other;}
	template<class S, class T> ostream& operator << (ostream& ost, pair<S, T> p) {ost << "(" << p.first << ", " << p.second << ")";return ost;}
	template<class T> ostream& print_iterable_container(ostream& ost, T& container) {
		for (auto&& iter = begin(container); iter != end(container); ++iter) ost << (iter == begin(container) ? " [ " : ", ") << (*iter);
		return ost << " ]";
	}
#	define APPLY_PRINT_ITERABLE_CONTAINER(container_type)\
	template<class T> ostream& operator << (ostream& ost, container_type<T>& container) {\
		return print_iterable_container(ost, container);\
	}
	APPLY_PRINT_ITERABLE_CONTAINER(vector);
	APPLY_PRINT_ITERABLE_CONTAINER(list);
	APPLY_PRINT_ITERABLE_CONTAINER(deque);
}

template<class T> inline bool CHMAX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool CHMIN(T &l,const T &r){return l>r?l=r,1:0;}

using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vpii = vector<pii>;
using vpll = vector<pll>;

using ld = long double;

template<class T> using VV = vector<vector<T> >;
template<class T> using maxPQ = priority_queue<T>;
template<class T> using minPQ = priority_queue<T, vector<T>, greater<T> >;
template<class T, class U> using uomap = unordered_map<T, U>;
template<class T> using uoset = unordered_set<T>;

const ll INF = 1001001001;
const ll INFll = (ll)INF * INF;
const ll MOD_FFT = 998244353;
const ld EPS = 1e-15;

int K, N;
VV<ll> C(4040, vll(4040));
vll two(4040);

void calcC() {
	rep(i, C.size()) rep(k, C[i].size()) {
		if (k == 0) C[i][k] = 1;
		else if (i < k) C[i][k] = 0;
		else C[i][k] = (C[i - 1][k - 1] + C[i - 1][k]) % MOD_FFT;
	}
	two[0] = 1;
	repr(i, 1, two.size() - 1) two[i] = two[i - 1] * 2 % MOD_FFT;
}

inline ll comb(ll n, ll r) {
	if (0 <= n && n < C.size() && 0 <= r && r < C[n].size()) return C[n][r];
	else return 0;
}

ll solve(int n, int s, int p) {
	ll ans = 0;
	repr(q, 0, p) {
		ll tasu = comb(p, q) * two[q] % MOD_FFT * comb(n + s - 1, n - q);
		ans = (ans + tasu) % MOD_FFT;
	}
	return ans;
}

int main() {
	cin >> K >> N;
	calcC();
	repr(k, 2, 2 * K) {
		int s = abs(k - 1 - K);
		int p = (k % 2 == 0 ? K - 1 - s : K - s) / 2;
		ll ans;
		if (k % 2 == 0) {
			ans = solve(N, s, p) + solve(N - 1, s, p);
		}
		else {
			ans = solve(N, s, p);
		}
		cout << ans % MOD_FFT << endl;
	}
	return 0;
}


Measured memory_bytes: 128000