#include<bits/stdc++.h>

using namespace std;

using ll = int64_t;

const ll MOD = 998244353;

int minv(int a, int m) {
	a %= m; //assert(a);
	return a == 1 ? 1 : int(m - int64_t(minv(m, a)) * m / a);
}

template<unsigned M_> struct modnum {
	static constexpr unsigned M = M_;
	using ll = int64_t; using ull = uint64_t; unsigned x;
	modnum& norm(unsigned a) { x = a < M ? a : a - M; return *this; }
	constexpr modnum(ll a = 0U) : x(unsigned((a %= ll(M)) < 0 ? a + ll(M) : a)) {}
	explicit operator int() const { return x; }
	modnum& operator+=(const modnum& a) { return norm(x + a.x); }
	modnum& operator-=(const modnum& a) { return norm(x - a.x + M); }
	modnum& operator*=(const modnum& a) { x = unsigned(ull(x) * a.x % M); return *this; }
	modnum& operator/=(const modnum& a) { return (*this *= a.inv()); }
	modnum operator+(const modnum& a) const { return (modnum(*this) += a); }
	modnum operator-(const modnum& a) const { return (modnum(*this) -= a); }
	modnum operator*(const modnum& a) const { return (modnum(*this) *= a); }
	modnum operator/(const modnum& a) const { return (modnum(*this) /= a); }
	template<typename T> friend modnum operator+(T a, const modnum& b) { return (modnum(a) += b); }
	template<typename T> friend modnum operator-(T a, const modnum& b) { return (modnum(a) -= b); }
	template<typename T> friend modnum operator*(T a, const modnum& b) { return (modnum(a) *= b); }
	template<typename T> friend modnum operator/(T a, const modnum& b) { return (modnum(a) /= b); }
	modnum operator+() const { return *this; }
	modnum operator-() const { return modnum() - *this; }
	modnum pow(ll e) const {
		if (e < 0) return inv().pow(-e);
		modnum b = x, xe = 1U;
		for (; e; e >>= 1) { if (e & 1) xe *= b; b *= b; }
		return xe;
	}
	modnum inv() const { return minv(x, M); }
	friend modnum inv(const modnum& a) { return a.inv(); }
	explicit operator bool() const { return x; }
	friend bool operator==(const modnum& a, const modnum& b) { return a.x == b.x; }
	friend bool operator!=(const modnum& a, const modnum& b) { return a.x != b.x; }
	friend ostream &operator<<(ostream& os, const modnum& a) { return os << a.x; }
	friend istream &operator>>(istream& in, modnum& n) { ll v_; in >> v_; n = modnum(v_); return in; }
};

using num = modnum<998244353>;


int minv_2(int a) {
    static const int m = MOD;
    
	return a <= 1 ? a : m - int64_t(minv_2(m % a)) * (m / a) % m;
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n; cin>>n;

    if(n <= 2){
        cout<<"1\n";
        return 0;
    }
    vector<ll> inv(n+1);
    /*
        5, MOD
        MOD, 5

    */
   inv[1] = 1;
    for (int x = 2; x <= n; ++x) {
        inv[x] = -(MOD/x * inv[MOD % x])%MOD;
        inv[x] += MOD;
        inv[x] %= MOD;
        //cout<<x<<" "<<inv[x]<<" "<<minv(x, MOD)<<" "<<minv_2(x)<<"\n";
    }
    num fact = 1; // (n-1)!
    for(int i =1; i <= n - 2; i++)
        fact *= i;
    
    num ans = fact*(n-1);

    num big = n-2;
    ans = ans + big*fact;
    for(int i = 3; i < n; i++){
        int x = i + i - 1;
        big = big *inv[(n-(i-1))];
        big = big * (n-(x-1)) * (n - (x-2));
        fact = fact * inv[(n-(i-1))];
        ans = ans + big*fact;        
    }
    cout<<ans<<"\n";

    return 0;
}