#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
using namespace std;

typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef long long ll;

template <typename _T>
inline void read(_T &f) {
    f = 0; _T fu = 1; char c = getchar();
    while (c < '0' || c > '9') { if (c == '-') { fu = -1; } c = getchar(); }
    while (c >= '0' && c <= '9') { f = (f << 3) + (f << 1) + (c & 15); c = getchar(); }
    f *= fu;
}

template <typename T>
void print(T x) {
    if (x < 0) putchar('-'), x = -x;
    if (x < 10) putchar(x + 48);
    else print(x / 10), putchar(x % 10 + 48);
}

template <typename T>
void print(T x, char t) {
    print(x); putchar(t);
}

const int md = 998244353;

inline int add(int x, int y) {
    if (x + y >= md) return x + y - md;
    return x + y;
}

inline void addx(int &x, int y) {
    x += y;
    if (x >= md) x -= md;
}

inline int sub(int x, int y) {
    if (x < y) return x - y + md;
    return x - y;
}

inline void subx(int &x, int y) {
    x -= y;
    if (x < 0) x += md;
}

inline int mul(int x, int y) { return 1ull * x * y % md; }

inline int fpow(int x, int y) {
    int ans = 1;
    while (y) {
        if (y & 1) ans = mul(ans, x);
        y >>= 1; x = mul(x, x);
    }
    return ans;
}

namespace Poly {
    vector <int> roots, rev;

    void getRevRoot(int base) {
        int n = 1 << base;
        if ((int)rev.size() == n) return;
        rev.resize(n);
        for (int i = 1; i < n; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (base - 1));
        if ((int)roots.size() >= n) return;
        int pren = max(1, (int)roots.size());
        roots.resize(n);
        for (int mid = pren; mid < n; mid <<= 1) {
            int wn = fpow(3, (md - 1) / (mid << 1));
            roots[mid] = 1;
            for (int i = 1; i < mid; i++) roots[i + mid] = mul(roots[i + mid - 1], wn);
        }
    }

    void ntt(vector <int> &a, int base) {
        int n = 1 << base;
        for (int i = 0; i < n; i++) {
            if (i < rev[i]) {
                swap(a[i], a[rev[i]]);
            }
        }
        for (int mid = 1; mid < n; mid <<= 1) {
            for (int i = 0; i < n; i += (mid << 1)) {
                for (int j = 0; j < mid; j++) {
                    int x = a[i + j], y = mul(a[i + j + mid], roots[mid + j]);
                    a[i + j] = add(x, y); a[i + j + mid] = sub(x, y);
                }
            }
        }
    }

    vector <int> operator * (vector <int> a, vector <int> b) {
        if ((int)a.size() <= 64 && (int)b.size() <= 64) {
            vector <int> ans(a.size() + b.size() - 1, 0);
            for (int i = 0; i < (int)a.size(); i++) {
                for (int j = 0; j < (int)b.size(); j++) {
                    ans[i + j] = add(ans[i + j], mul(a[i], b[j]));
                }
            }
            return ans;
        }
        int n = (int)a.size() + (int)b.size() - 1, base = 0;
        while ((1 << base) < n) ++base;
        a.resize(1 << base); b.resize(1 << base);
        getRevRoot(base); ntt(a, base); ntt(b, base);
        for (int i = 0; i < (1 << base); i++) a[i] = mul(a[i], b[i]);
        reverse(a.begin() + 1, a.end()); ntt(a, base); a.resize(n);
        int inv = fpow(1 << base, md - 2);
        for (int i = 0; i < n; i++) a[i] = mul(a[i], inv);
        return a;
    }

    vector <int> tmp;

    vector <int> pmul(vector <int> a, vector <int> b, int n, int ntted = 0) {
        int base = 0;
        while ((1 << base) < n) ++base;
        getRevRoot(base);
        a.resize(1 << base); ntt(a, base);
        if (!ntted) b.resize(1 << base), ntt(b, base), tmp = b;
        for (int i = 0; i < (1 << base); i++) a[i] = mul(a[i], tmp[i]);
        ntt(a, base); reverse(a.begin() + 1, a.end()); a.resize(n);
        int inv = fpow(1 << base, md - 2);
        for (int i = 0; i < n; i++) a[i] = mul(a[i], inv);
        return a;
    }

    vector <int> polyInv(vector <int> a, int n) {
        a.resize(n);
        if (n == 1) {
            vector <int> ans(1, fpow(a[0], md - 2));
            return ans;
        }
        vector <int> f0 = polyInv(a, (n + 1) >> 1), ans = f0;
        vector <int> now = pmul(a, f0, n, 0);
        for (int i = 0; i < (int)f0.size(); i++) now[i] = 0;
        now = pmul(now, vector <int> (0), n, 1); ans.resize(n);
        for (int i = (int)f0.size(); i < n; i++) ans[i] = sub(0, now[i]);
        return ans;
    }

    vector <int> polyInv(vector <int> a) {
        return polyInv(a, (int)a.size());
    }

    vector <int> operator + (vector <int> a, vector <int> b) {
        if (a.size() < b.size()) a.resize(b.size());
        for (int i = 0; i < (int)b.size(); i++) a[i] = add(a[i], b[i]);
        return a;
    }

    vector <int> operator - (vector <int> a, vector <int> b) {
        if (a.size() < b.size()) a.resize(b.size());
        for (int i = 0; i < (int)b.size(); i++) a[i] = sub(a[i], b[i]);
        return a;
    }

    vector <int> diff(vector <int> f) {
        int n = (int)f.size() - 1;
        for (int i = 0; i < n; i++) f[i] = mul(f[i + 1], i + 1);
        f.resize(n); return f;
    }

    vector <int> inte(vector <int> f) {
        int n = (int)f.size() + 1; f.resize(n);
        for (int i = n - 1; i >= 1; i--) f[i] = mul(f[i - 1], fpow(i, md - 2));
        f[0] = 0; return f;
    }

    vector <int> polyLn(vector <int> f) {
        int n = (int)f.size();
        f = inte(diff(f) * polyInv(f));
        f.resize(n); return f;
    }

    vector <int> polyExp(vector <int> f, int base) {
        int n = 1 << base; f.resize(n);
        if (n == 1) {
            vector <int> ans(1, 1);
            return ans;
        }
        vector <int> g0 = polyExp(f, base - 1), g(1, 1);
        g0.resize(n);
        g = g0 * (g - polyLn(g0) + f);
        return g;
    }

    vector <int> polyExp(vector <int> f) {
        int n = (int)f.size(), base = 0;
        while ((1 << base) < n) ++base;
        f = polyExp(f, base); f.resize(n);
        return f;
    }
}

using Poly::operator *;
using Poly::operator -;
using Poly::polyInv;
using Poly::polyExp;

const int N = 2e5 + 5;

vector <int> F, G;
int fac[N], invv[N];
int n;

int df[N], dfg[N];
int f[N], g[N], fg[N], ef[N], efg[N], gg[N], efg_gg[N];

void solve(int l, int r) {
    if (l == r) {
        if (!l) return;
        f[l] = add(fg[l], sub(ef[l - 1], efg_gg[l - 1]));
        g[l] = add(gg[l], sub(ef[l - 1], efg[l - 1]));
        df[l] = mul(f[l], l); dfg[l] = mul(fg[l], l);
        ef[l] = add(f[l], mul(ef[l], invv[l]));
        efg[l] = add(fg[l], mul(efg[l], invv[l]));
        efg_gg[l] = add(efg_gg[l], gg[l]);
        return;
    }
    int mid = (l + r) >> 1;
    solve(l, mid);
    auto upd = [&](int *f, int *g, int *res) {
        vector <int> f1(mid - l + 1), f2;
        for (int i = l; i <= mid; i++) f1[i - l] = f[i];
        if (l == 0) {
            f2.resize(mid - l + 1);
            for (int i = 0; i <= mid - l; i++) f2[i] = g[i];
        } else {
            f2.resize(r - l + 1);
            for (int i = 0; i <= r - l; i++) f2[i] = g[i];
        }
        // fprintf(stderr, "l = %d, mid = %d, r = %d\n", l, mid, r);
        f1 = f1 * f2; f1.resize(r - l + 1);
        for (int i = mid + 1; i <= r; i++) res[i] = add(res[i], f1[i - l]);
    };
    if (l == 0) {
        upd(f, g, fg);
        upd(g, g, gg);
        upd(df, ef, ef);
        upd(dfg, efg, efg);
        upd(gg, efg, efg_gg);
    } else {
        upd(f, g, fg); upd(g, f, fg);
        upd(g, g, gg); upd(g, g, gg);
        upd(df, ef, ef); upd(ef, df, ef);
        upd(dfg, efg, efg); upd(efg, dfg, efg);
        upd(gg, efg, efg_gg); upd(efg, gg, efg_gg);
    }
    solve(mid + 1, r);
}

int main() {
    read(n);
    for (int i = 1; i <= n; i++) invv[i] = fpow(i, md - 2);
    fac[0] = 1;
    for (int i = 1; i <= n; i++) fac[i] = mul(fac[i - 1], i);
    f[1] = 1; ef[0] = 1; efg[0] = 1;
    /*
    {
        F.resize(2); G.resize(2);
        F[1] = 1; G[1] = 0;
        for (int i = 2; i <= n; i++) {
            vector <int> a = polyInv(vector <int> {1} - G);
            vector <int> f = a * (polyExp(F) - polyExp(F * G) * G * G);
            vector <int> g = a * (polyExp(F) - polyExp(F * G));
            F.push_back(f[i - 1]); G.push_back(g[i - 1]);
            printf("%d : %d %d\n", i, mul(fac[i], F[i]), mul(fac[i], G[i]));
        }
        vector <int> EF = polyExp(F), EFG = polyExp(F * G), GG = G * G, EFGGG = EFG * GG;
        fprintf(stderr, "ef : ");
        for (int i = 0; i <= n; i++) fprintf(stderr, "%d ", EF[i]);
        fprintf(stderr, "\n");
        fprintf(stderr, "efg : ");
        for (int i = 0; i <= n; i++) fprintf(stderr, "%d ", EFG[i]);
        fprintf(stderr, "\n");
        fprintf(stderr, "gg : ");
        for (int i = 0; i <= n; i++) fprintf(stderr, "%d ", GG[i]);
        fprintf(stderr, "\n");
        fprintf(stderr, "efggg : ");
        for (int i = 0; i <= n; i++) fprintf(stderr, "%d ", EFGGG[i]);
        fprintf(stderr, "\n");
    }
    */
    solve(0, n);
    /*
    for (int i = 1; i <= n; i++) {
        fprintf(stderr, "f[%d] = %d, g[%d] = %d, ef[%d] = %d, efg[%d] = %d, gg[%d] = %d, efg_gg[%d] = %d\n", i, mul(fac[i], f[i]), i, mul(fac[i], g[i]), i, ef[i], i, efg[i], i, gg[i], i, efg_gg[i]);
    }
    */
    print(mul(fac[n], add(f[n], g[n])), '\n');
    return 0;
}