#include<bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define pb push_back
#define all(a) begin(a),end(a)
#define allr(a) rbegin(a),rend(a)
#define ff first
#define ss second
template<class T> bool chmax(T& a,T b){return a<b?a=b,1:0;}
template<class T> bool chmin(T& a,T b){return a>b?a=b,1:0;}
using ll =long long;
using pii =pair<int,int>;
using pll=pair<long long,long long>;
using vi=vector<int>;
using vll=vector<ll>;
inline bool ingrid(int a,int b,int h,int w){
    return 0<=a&&a<h&&0<=b&&b<w;
}

const int INFI = numeric_limits<int>::max() / 2; const long long INFL = numeric_limits<long long>::max() / 2;
constexpr pii dx4[4] = {pii{-1, 0}, pii{0, -1},pii{1, 0}, pii{0, 1} };
#define endl '\n'
struct nCk{
    vector<long long> fact, fact_inv, inv;
    int m=998244353;
    nCk(int _n){
        init(_n);
    }
    nCk(int _n,int _m){
        m=_m;
        init(_n);
        
    }
    //計算量O(n)
    void init(int SIZE){
        fact.resize(SIZE + 5);
        fact_inv.resize(SIZE + 5);
        inv.resize(SIZE + 5);
        fact[0] = fact[1] = 1;
        fact_inv[0] = fact_inv[1] = 1;
        inv[1] = 1;
        for (int i = 2; i < SIZE + 5; i++) {
            fact[i] = fact[i - 1] * i % m;
            inv[i] = m - inv[m % i] * (m / i) % m;
            fact_inv[i] = fact_inv[i - 1] * inv[i] % m;
        }
    }
    //計算量O(1)
    long long C(int n,int k){
        assert(!(n<k));
        assert(!(n<0||k<0));
        assert(n<fact.size());
        return fact[n]*(fact_inv[k]*fact_inv[n-k]%m)%m;
    }
    long long H(int n,int r){
        assert(n>=0&&r>=0);
        return r == 0 ? 1 : C(n + r - 1, r);
    }
    long long P(int n,int r){
        assert(r>=0&&r>=n);
        assert(n<fact.size());
        return (fact[n]*fact_inv[n-r])%m;
    }
};
#include<atcoder/all>
using mint9=atcoder::modint998244353;
int n;
void solve(){
    if(n&1){
        cout<<0<<endl;
        return;
    }
    n/=2;
    nCk comb(n);
    using pm=pair<mint9,mint9>;
    vector dp(n+1,vector<pm>(n+1));
    dp[0][0]={1,0};
    //dp[i][j]:=(をi,)をj使った時の(場合の数、f(S)の総和)
    rep(i,0,n+1){
        rep(j,0,n+1){
            if(i-j<0)continue;
            if(i!=n){
                // (を追加
                dp[i+1][j].ff+=dp[i][j].ff;
                dp[i+1][j].ss+=dp[i][j].ss;
            }
            if(j!=n&&i>=j+1){
                // )を追加
                dp[i][j+1].ff+=dp[i][j].ff;
                dp[i][j+1].ss+=dp[i][j].ss+(dp[i][j].ff*(i-(j+1)));
            }
        }
    }
    cout<<dp[n][n].ss.val()<<endl;
}

int main(){
    cin>>n;
    solve();
    return 0;
}
/*
普通に二次元dp?
直線を超えないように気を付ける
*/