#include "bits/stdc++.h"
using namespace std;
typedef long long li;


template <long long mod>
struct modint {
    long long x;

    modint<mod>(): x(0LL) {}
    modint<mod>(const long long _data) {
        if (_data < 0) {
            x = (_data % mod + mod) % mod;
        } else if (_data >= mod) {
            x = _data % mod;
        } else {
            x = _data;
        }
    }

    bool operator==(const modint<mod>& op) const {
        return x == op.x;
    }

    bool operator!=(const modint<mod>& op) const {
        return !((*this) == op);
    }

    modint<mod> operator-() const {
        if (x == 0) {
            return modint(0);
        }
        return modint(mod - x);
    }

    modint<mod> operator+(const modint<mod>& op) const {
        const long long newdata = x + op.x;
        if (newdata >= mod) {
            return modint<mod>(newdata - mod);
        } else {
            return modint<mod>(newdata);
        }
    }

    modint<mod>& operator+=(const modint<mod>& op) {
        x = (*this + op).x;
        return *this;
    }

    modint<mod> operator-(const modint<mod>& op) const {
        return *this + (-op);
    }

    modint<mod>& operator-=(const modint<mod>& op) {
        x = (*this - op).x;
        return *this;
    }

    modint<mod> operator*(const modint<mod>& op) const {
        return modint<mod>(x * op.x % mod);
    }

    modint<mod>& operator*=(const modint<mod>& op) {
        x = (*this * op).x;
        return *this;
    }

    modint<mod> pow(const long long n) const {
        if (n == 0) {
            return modint<mod>(1);
        }
        modint<mod> sq = pow(n / 2);
        if (n & 1) {
            return (*this) * sq * sq;
        } else {
            return sq * sq;
        }
    }

    modint<mod> inverse() const {
        return pow(mod - 2);
    }

    modint<mod> operator/(const modint<mod>& op) const {
        return (*this) * op.inverse();
    }

    modint<mod>& operator/=(const modint<mod>& op) {
        x = (*this / op).x;
        return *this;
    }

    friend modint<mod> operator/(const long long dividend, const modint<mod>& divisor) {
        return modint<mod>(dividend) / divisor;
    }

    static modint<mod> factorial(const long long n) {
        static std::vector<modint<mod>> cache(1, 1);

        if (cache.size() <= n) {
            auto next_index = cache.size();
            modint<mod> x = cache.back();
            cache.resize(n + 1);
            for (int i = next_index; i <= n; ++i) {
                x *= i;
                cache[i] = x;
            }
        }
        while (cache.size() <= n) {
            modint<mod> next = cache.back() * cache.size();
            cache.push_back(next);
        }
        return cache[n];
    }

    static modint<mod> invfact(const long long n) {
        static std::vector<modint<mod>> cache(1, 1);

        if (cache.size() <= n) {
            auto next_index = cache.size();
            modint<mod> x = cache.back();
            cache.resize(n + 1);
            for (int i = next_index; i <= n; ++i) {
                x /= i;
                cache[i] = x;
            }
        }
        while (cache.size() <= n) {
            modint<mod> next = cache.back() * cache.size();
            cache.push_back(next);
        }
        return cache[n];
    }

    static modint<mod> combination(const long long n, const long long k) {
        if (k < 0 || n < k) {
            return modint<mod>(0);
        }

        if (n < 1e6) {
            return factorial(n) * invfact(k) * invfact(n - k);
        }

        modint<mod> ret = invfact(k);
        for (int i = 1; i <= k; ++i) {
            ret = ret * modint<mod>(n - i + 1);
        }
        return ret;
    }
};

typedef modint<998244353> mint;

mint f(li k, li n, li c) {
    mint x = 0;
    for (int i = 0; i <= c; ++i) {
        mint xi = 1;
        xi *= mint(2).pow(i);
        xi *= mint::combination(c, i);
        li balls = n - i;
        li slices = i + k - 2 * c - 1;
        xi *= mint::combination(balls + slices, slices);
        x += xi;
    }
    return x;
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    li k, n;
    cin >> k >> n;

    for (int i = 2; i <= 2 * k; ++i) {
        if (i % 2 == 1) {
            li c = (min(i - 1LL, k) - max(1LL, i - k) + 1) / 2;
            cout << f(k, n, c).x << '\n';
        } else {
            li c = (min(i - 1LL, k) - max(1LL, i - k)) / 2;
//            cerr << f(k - 1, n, c).x << " " << f(k - 1, n - 1, c).x << endl;
            cout << (f(k - 1, n, c) + f(k - 1, n - 1, c)).x << '\n';
        }
    }

    return 0;
}

Measured memory_bytes: 384