#include <bits/stdc++.h>
using namespace std;

// ref: https://judge.yosupo.jp/submission/102040

template<int M> struct MINT {
    long long v;
    static MINT<M> w;
    MINT<M>() : v(0) {}
    MINT<M>(const long long v) : v(v) { normalize(); }
    void normalize() { v %= M; if (v < 0) v += M; }

    friend istream& operator >> (istream& in, MINT<M>& a) { in >> a.v; a.normalize(); return in; }
    friend ostream& operator << (ostream& out, const MINT<M>& a) { return out << a.v; }
    friend MINT<M> pow(MINT<M> a, long long b) {
        MINT<M> res = 1;
        for (; b; b >>= 1, a *= a) if (b & 1) res *= a;
        return res;
    }

    MINT<M> power(long long b) const { return pow(*this, b); }
    MINT<M> mul_inv() const { return power(M - 2); }

    MINT<M>& operator += (const MINT<M>& t) { if ((v += t.v) >= M) v -= M; return *this; }
    MINT<M>& operator -= (const MINT<M>& t) { if ((v -= t.v) < 0) v += M; return *this; }
    MINT<M>& operator *= (const MINT<M>& t) { v *= t.v; normalize(); return *this; }
    MINT<M>& operator /= (const MINT<M>& t) { *this *= t.mul_inv(); normalize(); return *this; }

    MINT<M> operator + (const MINT<M>& t) const { return MINT<M>(*this) += t; }
    MINT<M> operator - (const MINT<M>& t) const { return MINT<M>(*this) -= t; }
    MINT<M> operator * (const MINT<M>& t) const { return MINT<M>(*this) *= t; }
    MINT<M> operator / (const MINT<M>& t) const { return MINT<M>(*this) /= t; }
    MINT<M> operator - () const { return -v; }

    bool operator == (const MINT<M>& t) const { return v == t.v; }
    bool operator != (const MINT<M>& t) const { return v != t.v; }

    operator int32_t() const { return v; }
    operator int64_t() const { return v; }
};

template<int M>
void NTT(vector<MINT<M>>& a, bool inv_fft = false) {
    int n = a.size(); vector<MINT<M>> root(n / 2);
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n / 2;
        while (j >= bit) j -= bit, bit >>= 1;
        if (i < (j += bit)) swap(a[i], a[j]);
    }
    auto ang = MINT<M>::w.power((M - 1) / n); if (inv_fft) ang = ang.mul_inv();
    root[0] = 1; for (int i = 1; i < n / 2; i++) root[i] = root[i - 1] * ang;
    for (int i = 2; i <= n; i <<= 1) {
        int step = n / i;
        for (int j = 0; j < n; j += i) {
            for (int k = 0; k < i / 2; k++) {
                auto u = a[j + k], v = a[j + k + i / 2] * root[k * step];
                a[j + k] = u + v; a[j + k + i / 2] = u - v;
            }
        }
    }
    auto inv = MINT<M>(n).mul_inv();
    if (inv_fft) for (int i = 0; i < n; i++) a[i] = a[i] * inv;
}

template<typename T>
struct Poly {
    vector<T> a;
    Poly() : a() {}
    Poly(T a0) : a(1, a0) { normalize(); }
    Poly(const vector<T>& a) : a(a) { normalize(); }
    void normalize() { while (!a.empty() && a.back() == T(0)) a.pop_back(); }

    int size() const { return a.size(); }
    int deg() const { return size() - 1; }
    void push_back(const T& x) { a.push_back(x); }
    T get(int idx) const { return 0 <= idx && idx < size() ? a[idx] : T(0); }
    T& operator [] (int idx) { return a[idx]; }

    Poly reversed() const { auto b = a; reverse(b.begin(), b.end()); return b; }
    Poly trim(int sz) const { return vector<T>(a.begin(), a.begin() + min(sz, size())); }
    Poly inv(int n) const {
        Poly q(T(1) / a[0]);
        for (int i = 1; i < n; i <<= 1) {
            Poly p = Poly(2) - q * trim(i * 2);
            q = (p * q).trim(i * 2);
        }
        return q.trim(n);
    }

    Poly operator *= (const T& x) { for (auto& i : a) i *= x; normalize(); return *this; }
    Poly operator /= (const T& x) { return *this *= T(1) / x; }

    Poly operator += (const Poly& t) {
        a.resize(max(size(), t.size()));
        for (int i = 0; i < t.size(); i++) a[i] += t.a[i];
        normalize(); return *this;
    }
    Poly operator -= (const Poly& t) {
        a.resize(max(size(), t.size()));
        for (int i = 0; i < t.size(); i++) a[i] -= t.a[i];
        normalize(); return *this;
    }
    Poly operator *= (const Poly& t) {
        auto b = t.a;
        int n = 2; while (n < a.size() + b.size()) n <<= 1;
        a.resize(n); b.resize(n); NTT(a); NTT(b);
        for (int i = 0; i < n; i++) a[i] *= b[i];
        NTT(a, true); normalize(); return *this;
    }
    Poly operator /= (const Poly& t) {
        if (deg() < t.deg()) return *this = Poly();
        int sz = deg() - t.deg() + 1;
        Poly ra = reversed().trim(sz), rb = t.reversed().trim(sz).inv(sz);
        *this = (ra * rb).trim(sz);
        for (int i = sz - size(); i; i--) a.push_back(T(0));
        reverse(a.begin(), a.end()); normalize();
        return *this;
    }
    Poly operator %= (const Poly& t) {
        if (deg() < t.deg()) return *this;
        Poly tmp = *this; tmp /= t; tmp *= t;
        *this -= tmp; normalize();
        return *this;
    }

    Poly operator + (const Poly& t) const { return Poly(*this) += t; }
    Poly operator - (const Poly& t) const { return Poly(*this) -= t; }
    Poly operator * (const Poly& t) const { return Poly(*this) *= t; }
    Poly operator / (const Poly& t) const { return Poly(*this) /= t; }
    Poly operator % (const Poly& t) const { return Poly(*this) %= t; }
    Poly operator * (const T x) const { return Poly(*this) *= x; }
    Poly operator / (const T x) const { return Poly(*this) /= x; }

    T eval(T x) const {
        T res = 0;
        for (int i = deg(); i >= 0; i--) res = res * x + a[i];
        return res;
    }
    Poly derivative() const {
        vector<T> res;
        for (int i = 1; i < size(); i++) res.push_back(T(i) * a[i]);
        return res;
    }
    Poly integral() const {
        vector<T> res{ T(0) };
        for (int i = 0; i < size(); i++) res.push_back(a[i] / T(i + 1));
        return res;
    }
    Poly ln(int n) const {
        assert(size() > 0 && a[0] == T(1));
        return (derivative() * inv(n)).integral().trim(n);
    }
    Poly exp(int n) const {
        if (size() == 0) return Poly(1);
        assert(size() > 0 && a[0] == T(0));
        Poly res(1);
        for (int i = 1; i < n; i <<= 1) {
            auto t = Poly(1) + trim(i * 2) - res.ln(i * 2);
            res = (res * t).trim(i * 2);
        }
        return res.trim(n);
    }
    Poly pow(long long n, int k) const {
        // compute f(x)^n mod x^k
        Poly acc(1), t = *this;
        t = t.trim(k);
        for (; n; n >>= 1) {
            if (n & 1) acc = (acc * t).trim(k);
            t = (t * t).trim(k);
        }
        return acc;
    }
};

using ModInt = MINT<998244353>;
template<> ModInt ModInt::w = ModInt(3);

using T = ModInt;

// solution references
// https://openworks.wooster.edu/cgi/viewcontent.cgi?article=7688&context=independentstudy
// https://codeforces.com/blog/entry/117906

vector<ModInt> factorial, inv_factorial;

int n;

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n;

    if (n == 1) {
        cout << "1\n";
        return 0;
    }

    factorial.resize(n + 1);
    inv_factorial.resize(n + 1);
    factorial[0] = 1;

    for (int i = 1; i <= n; i++) {
        factorial[i] = factorial[i - 1] * ModInt(i);
    }
    inv_factorial[n] = factorial[n].mul_inv();
    for (int i = n - 1; i >= 0; i--) {
        inv_factorial[i] = inv_factorial[i + 1] * ModInt(i + 1);
    }

    Poly<ModInt> exp_my;
    exp_my.a.resize(n + 1);

    for (int i = 0; i <= n; i++) {
        if (i & 1) {
            exp_my[i] = -inv_factorial[i];
        } else {
            exp_my[i] = inv_factorial[i];
        }
    }

    Poly<ModInt> poly1;
    poly1.a.resize(n + 1);

    for (int i = 0; i <= n; i++) {
        poly1[i] = inv_factorial[i];
        poly1[i] *= ModInt(i).power(n - n / 2);
        poly1[i] *= ModInt(i + 1).power(n / 2);
    }

    Poly<ModInt> poly2;
    poly2.a.resize(n + 1);

    for (int i = 0; i <= n; i++) {
        poly2[i] = inv_factorial[i];
        poly2[i] *= ModInt(i).power(n - (n + 1) / 2);
        poly2[i] *= ModInt(i + 1).power((n + 1) / 2);
    }

    poly1 *= exp_my;
    poly2 *= exp_my;
    poly1.a.resize(n + 1);
    poly2.a.resize(n + 1);

    poly1 *= poly2;

    for (int i = 0; i < 2 * n - 1; i++) {
        cout << poly1[2 * n - 1 - i] << " ";
    }
    cout << "\n";

    return 0;
}