#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>

using i64 = long long;

constexpr int P = 998244353;

int power(int a, int b) {
    int res = 1;
    for (; b; b /= 2, a = 1LL * a * a % P) {
        if (b % 2) {
            res = 1LL * res * a % P;
        }
    }
    return res;
}

std::vector<int> rev, roots {0, 1};

void dft(std::vector<int> &a) {
    int n = a.size();
    if (int(rev.size()) != n) {
        int k = __builtin_ctz(n) - 1;
        rev.resize(n);
        for (int i = 0; i < n; i++) {
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << k;
        }
    }
    for (int i = 0; i < n; i++) {
        if (rev[i] < i) {
            std::swap(a[i], a[rev[i]]);
        }
    }
    if (roots.size() < n) {
        int k = __builtin_ctz(roots.size());
        roots.resize(n);
        while ((1 << k) < n) {
            int e = power(31, 1 << (__builtin_ctz(P - 1) - k - 1));
            for (int i = 1 << (k - 1); i < (1 << k); i++) {
                roots[2 * i] = roots[i];
                roots[2 * i + 1] = 1LL * roots[i] * e % P;
            }
            k++;
        }
    }

    for (int k = 1; k < n; k *= 2) {
        for (int i = 0; i < n; i += 2 * k) {
            for (int j = 0; j < k; j++) {
                int u = a[i + j];
                int v = 1LL * a[i + j + k] * roots[k + j] % P;
                a[i + j] = (u + v) % P;
                a[i + j + k] = (u - v) % P;
            }
        }
    }
}

void idft(std::vector<int> &a) {
    int n = a.size();
    std::reverse(a.begin() + 1, a.end());
    dft(a);
    int inv = (1 - P) / n;
    for (int i = 0; i < n; i++) {
        a[i] = 1LL * a[i] * inv % P;
    }
}

std::vector<int> mul(std::vector<int> a, std::vector<int> b) {
    int n = 1, tot = a.size() + b.size() - 1;
    while (n < tot) {
        n *= 2;
    }
    if (tot < 128) {
        std::vector<int> c(a.size() + b.size() - 1);
        for (int i = 0; i < a.size(); i++) {
            for (int j = 0; j < b.size(); j++) {
                c[i + j] = (c[i + j] + 1LL * a[i] * b[j]) % P;
            }
        }
        return c;
    }
    a.resize(n);
    b.resize(n);
    dft(a);
    dft(b);
    for (int i = 0; i < n; i++) {
        a[i] = 1LL * a[i] * b[i] % P;
    }
    idft(a);
    a.resize(tot);
    return a;
}

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

    int n;
    std::cin >> n;

    std::vector<int> fac(n + 1), invfac(n + 1), inv(n + 1);
    fac[0] = 1;
    for (int i = 1; i <= n; i++) {
        fac[i] = 1LL * fac[i - 1] * i % P;
    }
    invfac[n] = power(fac[n], P - 2);
    for (int i = n; i; i--) {
        inv[i] = 1LL * invfac[i] * fac[i - 1] % P;
        invfac[i - 1] = 1LL * invfac[i] * i % P;
    }

    std::vector<int> f(n + 1), g(n + 1), seqg(n + 1), ef(n + 1), efg(n + 1), g2efg(n + 1), fg(n + 1), gefg(n + 1);
    // for (int i = 1; i <= n; i++) {
    //     for (int j = 0; j < i; j++) {
    //         f[i] = (f[i] + 1LL * (ef[j] - g2efg[j]) * seqg[i - j - 1]) % P;
    //     }

    //     for (int j = 0; j < i; j++) {
    //         g[i] = (g[i] + 1LL * (ef[j] - efg[j]) * seqg[i - j - 1]) % P;
    //     }

    //     for (int j = 0; j < i; j++) {
    //         ef[i] = (ef[i] + 1LL * ef[j] * f[i - j] % P * (i - j)) % P;
    //     }
    //     ef[i] = 1LL * ef[i] * inv[i] % P;

    //     for (int j = 0; j < i; j++) {
    //         fg[i] = (fg[i] + 1LL * f[j] * g[i - j]) % P;
    //     }

    //     for (int j = 0; j < i; j++) {
    //         efg[i] = (efg[i] + 1LL * efg[j] * fg[i - j] % P * (i - j)) % P;
    //     }
    //     efg[i] = 1LL * efg[i] * inv[i] % P;

    //     for (int j = 0; j < i; j++) {
    //         g2efg[i] = (g2efg[i] + 1LL * gefg[j] * g[i - j]) % P;
    //     }

    //     for (int j = 0; j < i; j++) {
    //         gefg[i] = (gefg[i] + 1LL * efg[j] * g[i - j]) % P;
    //     }

    //     for (int j = 0; j < i; j++) {
    //         seqg[i] = (seqg[i] + 1LL * seqg[j] * g[i - j]) % P;
    //     }
    // }

    seqg[0] = 1;
    ef[0] = 1;
    efg[0] = 1;
    auto work = [&](auto self, int l, int r) -> void {
        if (r - l == 1) {
            if (l > 0) {
                ef[l] = 1LL * ef[l] * inv[l] % P;
                efg[l] = 1LL * efg[l] * inv[l] % P;
            }
            return;
        }
        int m = (l + r + 1) / 2;
        // int m = r - 1;
        self(self, l, m);

        auto at = [](auto &f, int offset = 0) {
            return [&, offset](int i) { return i + offset < 0 ? 0 : f[i + offset]; };
        };

        auto add = [&](auto &dst, auto f, auto g) {
            if (l == 0) {
                std::vector<int> a(m), b(m);
                for (int i = 0; i < m; i++) {
                    a[i] = f(i);
                    b[i] = g(i);
                }
                std::vector<int> c = mul(a, b);
                for (int i = m; i < r; i++) {
                    if (i - 1 < c.size()) {
                        dst[i] = (dst[i] + c[i - 1]) % P;
                    }
                }
            } else {
                std::vector<int> a(m - l), b(r - l - 1);
                for (int i = 0; i < m - l; i++) {
                    a[i] = f(l + i);
                }
                for (int i = 0; i < r - l - 1; i++) {
                    b[i] = g(i);
                }
                std::vector<int> c = mul(a, b);
                for (int i = m; i < r; i++) {
                    if (i - l - 1 < c.size()) {
                        dst[i] = (dst[i] + c[i - l - 1]) % P;
                    }
                }
                for (int i = 0; i < m - l; i++) {
                    a[i] = g(l + i);
                }
                for (int i = 0; i < r - l - 1; i++) {
                    b[i] = f(i);
                }
                c = mul(a, b);
                for (int i = m; i < r; i++) {
                    if (i - l - 1 < c.size()) {
                        dst[i] = (dst[i] + c[i - l - 1]) % P;
                    }
                }
            }
        };
        add(f, [&](int i) { return (ef[i] - g2efg[i]) % P; }, at(seqg));
        add(g, [&](int i) { return (ef[i] - efg[i]) % P; }, at(seqg));
        add(ef, at(ef), [&](int i) { return 1LL * (i + 1) * f[i + 1] % P; });
        add(fg, at(f), at(g, 1));
        add(efg, at(efg), [&](int i) { return 1LL * (i + 1) * fg[i + 1] % P; });
        add(g2efg, at(gefg), at(g, 1));
        add(gefg, at(efg), at(g, 1));
        add(seqg, at(seqg), at(g, 1));
        self(self, m, r);
    };
    work(work, 0, n + 1);

    int ans = 1LL * (f[n] + g[n]) * fac[n] % P;
    ans = (ans + P) % P;
    std::cout << ans << "\n";

    return 0;
}