#include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
void io() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
}

typedef long long ll;
typedef unsigned long long ull;

const int MAXN = 4e5 + 5;
const ll INF = 0x3f3f3f3f3f3f3f;
const ll MOD = 998244353;
const int inv2 = (MOD + 1) >> 1;
typedef vector<int> Poly;
int inc(int a, int b) { return (a += b) >= MOD ? a - MOD : a; }
int fpow(int a, int b) {
    int t = 1;
    while (b) {
        if (b & 1) {
            t = 1LL * t * a % MOD;
        }
        a = 1LL * a * a % MOD;
        b >>= 1;
    }
    return t;
}
int W[MAXN * 4], inv[MAXN * 4];
// 预处理原根，以及线性求逆元
void prework(int n) {
    for (int i = 1; i < n; i <<= 1) {
        for (int j = W[i] = 1, Wn = fpow(3, (MOD - 1) / i >> 1); j < i; j++) {
            W[i + j] = 1LL * W[i + j - 1] * Wn % MOD;
        }
    }
    inv[1] = 1;
    for (int i = 2; i <= n; i++) {
        inv[i] = 1LL * (MOD - MOD / i) * inv[MOD % i] % MOD;
    }
}
void fft(Poly &a, int n, int opt) {
    a.resize(n);
    static int rev[MAXN * 4];
    for (int i = 1; i < n; i++) {
        if ((rev[i] = rev[i >> 1] >> 1 | (i & 1 ? n >> 1 : 0)) > i) {
            swap(a[i], a[rev[i]]);
        }
    }
    for (int q = 1; q < n; q <<= 1) {
        for (int p = 0; p < n; p += q << 1) {
            for (int i = 0, t; i < q; i++) {
                t = 1LL * W[q + i] * a[p + q + i] % MOD;
                a[p + q + i] = inc(a[p + i], MOD - t);
                a[p + i] = inc(a[p + i], t);
            }
        }
    }
    if (opt) {
        return;
    }
    for (int i = 0, inv = fpow(n, MOD - 2); i < n; i++) {
        a[i] = 1LL * a[i] * inv % MOD;
    }
    reverse(a.begin() + 1, a.end());
}
Poly poly_inv(Poly A) {
    Poly B(1, fpow(A[0], MOD - 2)), C(2);
    for (int L = 1; L < A.size(); L <<= 1) {
        (C = A).resize(L * 2);
        fft(B, L * 4, 1), fft(C, L * 4, 1);
        for (int i = 0; i < L * 4; i++) {
            B[i] =
                (2 * B[i] - 1LL * B[i] * B[i] % MOD * C[i] % MOD + MOD) % MOD;
        }
        fft(B, L * 4, 0);
        B.resize(L * 2);
    }
    return B.resize(A.size()), B;
}
int getsz(int n) {
    int x = 1;
    while (x < n) {
        x <<= 1;
    }
    return x;
}
void fix(Poly &A) {
    int x = A.size();
    while (x > 1 && !A[x - 1]) {
        x--;
    }
    A.resize(x);
}
Poly operator+(Poly A, Poly B) {
    if (A.size() < B.size()) {
        swap(A, B);
    }
    for (int i = 0; i < B.size(); i++) {
        A[i] = inc(A[i], B[i]);
    }
    return fix(A), A;
}
Poly operator-(Poly A, Poly B) {
    A.resize(max(A.size(), B.size()));
    for (int i = 0; i < B.size(); i++) {
        A[i] = inc(A[i], MOD - B[i]);
    }
    return fix(A), A;
}
Poly operator*(int k, Poly A) {
    for (int i = 0; i < A.size(); i++) {
        A[i] = 1LL * k * A[i] % MOD;
    }
    return A;
}
Poly operator*(Poly A, Poly B) {
    int L = getsz(A.size() + B.size() - 1);
    fft(A, L, 1), fft(B, L, 1);
    for (int i = 0; i < L; i++) {
        A[i] = 1LL * A[i] * B[i] % MOD;
    }
    return fft(A, L, 0), fix(A), A;
}
// 需要有 A.size() >= B.size()
Poly operator/(Poly A, Poly B) {
    int n = A.size() - B.size() + 1;
    reverse(A.begin(), A.end());
    A.resize(n);
    reverse(B.begin(), B.end());
    B.resize(n);
    return A = A * poly_inv(B), A.resize(n), reverse(A.begin(), A.end()),
           fix(A), A;
}
Poly operator>>(Poly A, int k) {
    A.resize(A.size() + 1);
    for (int i = A.size() - 1; i > 0; i--) {
        A[i] = A[i - 1];
    }
    A[0] = 0;
    return A;
}
Poly operator%(Poly A, Poly B) {
    if (A.size() < B.size()) {
        return A;
    }
    return A - A / B * B;
}
Poly poly_deri(Poly A) {
    for (int i = 0; i < A.size() - 1; i++) {
        A[i] = 1LL * (i + 1) * A[i + 1] % MOD;
    }
    return A.resize(A.size() - 1), A;
}
Poly poly_int(Poly A) {
    for (int i = A.size() - 1; i; i--) {
        A[i] = 1LL * A[i - 1] * inv[i] % MOD;
    }
    return A[0] = 0, A;
}
Poly poly_sqrt(Poly A) {
    Poly B(1, 1), iB, C(2);
    for (int L = 1; L < A.size(); L <<= 1) {
        (C = A).resize(L * 2);
        B.resize(L * 2);
        iB = poly_inv(B);
        fft(B, L * 4, 1), fft(iB, L * 4, 1), fft(C, L * 4, 1);
        for (int i = 0; i < L * 4; i++) {
            B[i] = (1LL * B[i] * B[i] + C[i]) % MOD * iB[i] % MOD * inv2 % MOD;
        }
        fft(B, L * 4, 0);
        B.resize(L * 2);
    }
    return B.resize(A.size()), B;
}
Poly poly_ln(Poly A) {
    Poly B = poly_deri(A) * poly_inv(A);
    return B.resize(A.size()), poly_int(B);
}
Poly poly_exp(Poly A) {
    Poly B(1, 1), C;
    for (int L = 1; L < A.size(); L <<= 1) {
        B.resize(L * 2);
        C = A + Poly(1, 1) - poly_ln(B), C.resize(L * 2);
        B = B * C;
    }
    return B.resize(A.size()), B;
}
Poly poly_pow(Poly A, int k) { return poly_exp(k * poly_ln(A)); }

pair<Poly, Poly> newton(int n, Poly B, Poly W) {
    Poly WW, BW, xeB, xeBW;
    Poly xeBW_B, xeBW_BWW;
    Poly xeBW_W, xeBW_WW, xeBW_WWW;
    Poly f0, g0, fB, fW, gB, gW;
    Poly x, y;
    Poly det_inv;
    for (int L = 1; L <= n; L <<= 1) {
        WW = W * W;
        BW = B * W;
        B.resize(2 * L);
        xeB = poly_exp(B) >> 1;
        fix(B);
        xeBW = poly_exp(BW) >> 1;
        xeBW_B = xeBW * B;
        xeBW_B.resize(2 * L);
        xeBW_BWW = xeBW_B * WW;
        xeBW_BWW.resize(2 * L);
        xeBW_W = xeBW * W;
        xeBW_W.resize(2 * L);
        xeBW_WW = xeBW_W * W;
        xeBW_WW.resize(2 * L);
        xeBW_WWW = xeBW_WW * W;
        xeBW_WWW.resize(2 * L);
        f0 = B - BW - xeB + xeBW_WW;
        g0 = W - WW - xeB + xeBW;
        fB = xeBW_WWW - W - xeB;
        fB[0] = (fB[0] + 1) % MOD;
        fW = xeBW_BWW + 2 * xeBW_W - B;
        gB = xeBW_W - xeB;
        gW = xeBW_B - 2 * W;
        gW[0] = (gW[0] + 1) % MOD;

        x = B * fB + W * fW - f0;
        x.resize(2 * L);
        y = B * gB + W * gW - g0;
        y.resize(2 * L);

        det_inv = fB * gW - fW * gB;
        det_inv.resize(2 * L);
        det_inv = poly_inv(det_inv);

        B = x * gW - y * fW;
        B.resize(2 * L);
        B = B * det_inv;
        B.resize(2 * L);
        W = y * fB - x * gB;
        W.resize(2 * L);
        W = W * det_inv;
        W.resize(2 * L);
    }
    return {B, W};
}

int main() {
    io();
    prework(getsz(MAXN) * 2);
    int n;
    cin >> n;
    auto [B, W] = newton(n, {0}, {0});
    int fac_n = 1;
    for (int i = 1; i <= n; i++) {
        fac_n = (ll)fac_n * i % MOD;
    }

    cout << (ll)(B[n] + W[n]) * fac_n % MOD;
}