#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <list>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <unordered_set>
#include <ctime>
#include <functional>
#include <ctime>
#include <limits>
#include <tuple>
#include <complex>
#include <numeric>
#include <future>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = acos(-1.0);

template<typename T>
T abs(T x) {
    return x > 0 ? x : -x;
}

template<typename T>
T sqr(T x) {
    return x * x;
}

template<typename T>
bool chmin(T &x, T y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}

template<typename T>
bool chmax(T &x, T y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}

template<typename U, typename V>
ostream &operator<<(ostream &s, const pair<U, V> &x) {
    s << "(" << x.fst << ", " << x.snd << ")";
    return s;
}

template<typename U>
ostream &operator<<(ostream &s, const vector<U> &x) {
    s << "[";
    bool was = false;
    for (auto it : x) {
        if (was) {
            s << ", ";
        }
        was = true;
        s << it;
    }
    s << "]";
    return s;
}

template<typename U>
ostream &operator<<(ostream &s, const set<U> &x) {
    s << "{";
    bool was = false;
    for (auto it : x) {
        if (was) {
            s << ", ";
        }
        was = true;
        s << it;
    }
    s << "}";
    return s;
}

template<int sz>
ostream operator<<(ostream &s, const bitset<sz> &x) {
    for (int i = 0; i < sz; i++) {
        s << x[i];
    }
    return s;
}


//--------------------------------------------------------------------------

const ll mod = 998244353;
const int maxn = 4005;
ll c[maxn][maxn];
int used[maxn];
int cu = 1;

int main() {

    srand(time(NULL));

#ifdef LOCAL
    freopen("a.in", "r", stdin);
    //freopen("a.in", "w", stdout);
#else
    //freopen("brackets.in", "r", stdin);
    //freopen("brackets.out", "w", stdout);
#endif

    for (int i = 0; i < maxn; i++) {
        c[i][0] = c[i][i] = 1;
        for (int j = 1; j < i; j++) {
            c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
            if (c[i][j] >= mod) {
                c[i][j] -= mod;
            }
        }
    }

    ll n, k;
    cin >> k >> n;

    for (int i = 2; i <= 2 * k; i++) {
        ll tw = 0;
        ll cnt = 0;

        bool has = false;

        cu++;
        for (int j = 1; j <= k; j++) {
            if (j + j == i) {
                has = true;
                continue;
            }

            if (used[j] == cu) {
                continue;
            }

            int x = i - j;
            if (1 <= x && x <= k && used[x] != cu) {
                used[x] = cu;
                tw++;
                cnt++;
            } else {
                cnt++;
            }
        }
//        cout << i << " " << cnt << " " << tw << " " << has << endl;

        auto foo = [&](int m) {
            ll ans = 0;
            ll p = 1;
            for (int j = 0; j <= tw; j++) {
                if (j) {
                    p = p * 2 % mod;
                }
                int types = cnt - tw + j;
                ll x = c[tw][j];
                if (types == 0) {
                    continue;
                }
                if (m + types - 1 - j < 0) {
                    continue;
                }
                ans += c[m + types - 1 - j][types - 1] * x % mod * p % mod;

            }
            ans %= mod;
            return ans;
        };

        if (!has) {
            cout << foo(n) << endl;
        } else {
            cout << (foo(n) + foo(n - 1)) % mod << endl;
        }
    }


    return 0;
}

Measured memory_bytes: 123904