#define GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define make_unique(a) sort(all(a)); a.resize(unique(all(a)) - a.begin())
#define fs first
#define sc second
#define th third
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define vec vector
#define vsum(x) accumulate(x.begin(), x.end(), 0LL)
#define ins insert
#define rsz(x) resize(x)
#define sz(x) (int)(x.size())
#define ext extract
#define prq priority_queue
#define un_map unordered_map
#define un_multimap unordered_multimap
#define un_set unordered_set
#define un_multiset unordered_multiset
#define GET_MACRO(_1, _2, _3, _4, NAME, ...) NAME
#define FORN_1(end) for (auto iter_for_forn = 0; iter_for_forn < end; ++iter_for_forn)
#define FORN_2(iter, end) for (auto iter = 0; iter < end; ++iter)
#define FORN_3(iter, begin, end) for (auto iter = begin; iter < end; ++iter)
#define FORN_4(iter, begin, end, move) for (auto iter = begin; iter < end; iter+=move)
#define RFORN_1(begin) for (auto iter_for_rforn = (begin); iter_for_rforn >= 0; --iter_for_rforn)
#define RFORN_2(iter, end) for (auto iter = end-1; iter >= 0; --iter)
#define RFORN_3(iter, begin, end) for (auto iter = end-1; iter >= begin; --iter)
#define RFORN_4(iter, begin, end, move) for (auto iter = end-1; iter >= begin; iter-=move)
#define forn(...) GET_MACRO(__VA_ARGS__, FORN_4,FORN_3, FORN_2, FORN_1)(__VA_ARGS__)
#define rforn(...) GET_MACRO(__VA_ARGS__, RFORN_4,RFORN_3, RFORN_2, RFORN_1)(__VA_ARGS__)
#define each(el, arr) for (auto &el : arr)
#ifdef LOCAL
#define dbg(...) [](auto...zxc){ ((cout << zxc << ' '), ...) << endl;}(#__VA_ARGS__, ":", __VA_ARGS__)
#define dbgv(v) if(static_cast<string>(#v)!="_")cout<< #v <<" :"; cout << "[ "; for(auto &zxc: v) {cout << zxc << " ,"; }cout <<"]"<< endl;
#define dbgvv(v) {cout<< #v <<" :\n";int cnt = 0;for(auto &_: v) {cout << #v << "[" << cnt++ << "]: ";dbgv(_);}cout << endl;}
#define dbgm(v) cout<< #v <<" :"; for(auto &zxc: v) {cout << '\n' << zxc.fs << ": " << zxc.sc; }cout << endl;
#else
#define dbg(...)
#define dbgv(v)
#define dbgvv(v)
#define dbgm(v)
#endif
template<class T1, class T2, class T3>
struct triple {T1 first;T2 second;T3 third;triple() = default;
triple(const T1 &f, const T2 &s, const T3 &t) : first(f), second(s), third(t) {}
bool operator==(const triple &other) const {return tie(first, second, third) == tie(other.first, other.second, other.third);}
bool operator!=(const triple &other) const { return !(*this == other); }
bool operator<(const triple &other) const {return tie(first, second, third) < tie(other.first, other.second, other.third);}
bool operator<=(const triple &other) const { return !(*this > other); }
bool operator>(const triple &other) const {return tie(first, second, third) > tie(other.first, other.second, other.third);}
bool operator>=(const triple &other) const { return !(*this < other); }};
using vb = vector<bool>;using vvb = vector<vb>;using vvvb = vector<vvb>;
using vc = vector<char>;using vvc = vector<vc>;using vvvc = vector<vvc>;
using vi = vector<int>;using vvi = vector<vi>;using vvvi = vector<vvi>;using vvvvi = vector<vvvi>;using vvvvvi = vector<vvvvi>;
using ll = long long;using vl = vector<ll>;using vvl = vector<vl>;using vvvl = vector<vvl>;using vvvvl = vector<vvvl>;using vvvvvl = vector<vvvvl>;
using ld = long double;using vd = vector<ld>;using vvd = vector<vd>;using vvvd = vector<vvd>;
using pi = pair<int, int>;using vpi = vector<pi>;using vvpi = vector<vpi>;using vvvpi = vector<vvpi>;
using ti = triple<int, int, int>;using vti = vector<ti>;using vvti = vector<vti>;using vvvti = vector<vvti>;
using pl = pair<ll, ll>;using vpl = vector<pl>;using vvpl = vector<vpl>;using vvvpl = vector<vvpl>;
using tl = triple<ll, ll, ll>;using vtl = vector<tl>;using vvtl = vector<vtl>;using vvvtl = vector<vvtl>;
using pd = pair<ld, ld>;using vpd = vector<pd>;
using td = triple<ld, ld, ld>;using vtd = vector<td>;
using ull = unsigned long long;
using cld = complex<ld>;using cd = complex<double>;
template<class T1> istream &operator>>(istream &in, vector<T1> &a) { for (T1 &i: a) in >> i; return in;}
template<class T1, class T2> istream &operator>>(istream &in, vector<pair<T1, T2>> &a) { for (auto &[i1, i2]: a) in >> i1 >> i2; return in; }
template<class T1, class T2> istream &operator>>(istream &in, pair<T1, T2> &a) { in >> a.first >> a.second; return in; }
template<class T1, class T2, class T3> istream &operator>>(istream &in, vector<triple<T1, T2, T3>> &a) { for (auto &[i1, i2, i3]: a) in >> i1 >> i2 >> i3; return in; }
template<class T1, class T2, class T3> istream &operator>>(istream &in, triple<T1, T2, T3> &a) { in >> a.first >> a.second >> a.third; return in;}
template<class T1> ostream &operator<<(ostream &out, vector<T1> &a) { for (T1 &i: a) out << i << ' '; return out; }
template<class T1, class T2> ostream &operator<<(ostream &out, vector<pair<T1, T2>> &a) { for (auto &[i1, i2]: a) out << i1 << ' ' << i2 << '\n'; return out; }
template<class T1, class T2> ostream &operator<<(ostream &out, const pair<T1, T2> &a) { out << a.first << ' ' << a.second; return out; }
template<class T1, class T2, class T3> ostream &operator<<(ostream &out, vector<triple<T1, T2, T3>> &a) { for (auto &[i1, i2, i3]: a) out << i1 << ' ' << i2 << ' ' << i3 << '\n'; return out; }
template<class T1, class T2, class T3> ostream &operator<<(ostream &out, const triple<T1, T2, T3> &a) { out << a.first << ' ' << a.second << ' ' << a.third; return out; }
int BitSize(int64_t number) { int BitSizeAns = 1; while (number > 1) number >>= 1, BitSizeAns++; return BitSizeAns;}
int64_t Bit(int64_t number, int PosInNumber) { return (number >> PosInNumber) & 1; }
template <class T> T gcd(T a, T b) { while (b) a = a % b, swap(a, b); return a; }
template <class T> T gcd(vector<T> a) { T g = a[0]; each(el, a) g = gcd(g,el); return g; }
template <class T> T gcd(initializer_list<T> a) { T g = *a.begin(); each(el, a) g = gcd(g,el); return g; }
template <class T> T lcm(T a, T b){ return a / gcd(a,b) * b; }
template <class T> T lcm(vector<T> a) { T g = a[0]; each(el, a) g = lcm(g,el); return g; }
template <class T> T lcm(initializer_list<T> a) { T g = *a.begin(); each(el, a) g = lcm(g,el); return g; }
template<class T> bool ckmin(T &a, const T &b) { return b < a && (a = b); }
template<class T> bool ckmax(T &a, const T &b) { return b > a && (a = b); }
void coutans(bool ans) { ans ? cout << "YES" << '\n' : cout << "NO" << '\n'; }

const ll mod = 998244353;
int64_t poww(int64_t val, int64_t d, int64_t modd = mod) {int64_t ans = 1, mn = val;while (d) { if (d & 1) ans = mn * ans % modd; mn = mn * mn % modd, d >>= 1;}return ans;}


// Факториалы
vi f_fact(const int n) {
    vi fact(n, 1);
    forn(i,1,n) fact[i] = 1ll * fact[i-1] * i % mod;
    return fact;
}

// Обратные
vi f_inv(const int n){
    vi inv = f_fact(n);
    int ifact = poww(inv.back(), mod-2);
    rforn(i,2,n){
        inv[i] = 1ll * inv[i - 1] * ifact % mod;
        ifact = 1ll * ifact * i % mod;
    }
    return inv;
}

// Первообразый корень от простого
int primitive_root(int p){
    int phi = p-1, n = phi;
    vi fact;
    for (int i=2; i*i<=n; ++i)
        if (n % i == 0){ 
            fact.pb(i);
            while(n%i == 0) n/=i;
        }
    if(n!=1) fact.pb(n);
    forn(res,2,p+1){
        bool ok = 1;
        each(d, fact){
            ok &= (poww(res, phi/d) != 1);
            if(!ok) break;
        }
        if(ok) return res;
    }
    return -1;
}

// NTT
void NTT(vi &a){
    // need n = 2^d
    int n = sz(a);
    int d = __lg(n);
    int pr = primitive_root(mod);
    vi rev(n, 0);
    forn(j,n) rev[j] = (rev[j >> 1] >> 1) + ((j & 1) << (d-1));
    vi root(n, 1);
    for(int k = 1;k<n;k*=2){
        int p = poww(pr, (mod - 1) / (2 * k), mod);
        forn(i,1,k){
            root[k + i] = root[(k + i) >> 1];
            if(i&1) root[k+i] = (1ll * root[k+i] *p) % mod;
        }
    }
    forn(i,n) if (i < rev[i]) swap(a[i],a[rev[i]]);
    for (int k=1; k<n; k<<=1) {
        forn(i,0,n,2*k){
            forn(j,k){
                int tmp = 1ll * a[i+j+k] * root[k+j] % mod;
                a[i+j+k] = (a[i+j] - tmp + mod) % mod;
                a[i+j] = (a[i+j] + tmp) % mod;
            }
        }
    }
}

// Обратное NTT
void inv_NTT(vi &a){
    NTT(a);
    reverse(1+all(a));
    int inv_n = poww(sz(a), mod-2);
    forn(i,sz(a)) a[i] = (1ll * a[i] * inv_n) % mod;
}

// Сумма рядов
vi sum(const vi &a, const vi &b){
    vi c(max(sz(a), sz(b)));
    forn(i,sz(c)){
        if(i>=sz(a)) c[i] = b[i];
        else if(i>=sz(b)) c[i] = a[i];
        else c[i] = (a[i]+b[i])%mod;
    }
    return c;
}

// Разность рядов
vi diff(const vi &a, const vi &b){
    vi c(max(sz(a), sz(b)), 0);
    forn(i,sz(c)){
        if(i>=sz(a)) c[i] = (mod - b[i]) % mod;
        else if(i>=sz(b)) c[i] = a[i];
        else c[i] = (a[i] - b[i] + mod) % mod;
    }
    return c;
}

// Умножение рядов
vi mul(vi a, vi b){
    int n = sz(a), m = sz(b);
    int N = 1 << (__lg(n+m-2)+1);
    a.resize(N), b.resize(N);
    NTT(a), NTT(b);
    vi c(N);
    forn(i,N) c[i] = (1ll * a[i] * b[i]) % mod;
    inv_NTT(c);
    return c;
}
vi mul(vi a, vi b, int n){
    a.resize(n), b.resize(n);
    vi c = mul(a,b);
    c.resize(n);
    return c;
}

// Обратный ряд
vi inv(vi &a, int n){
    assert(a[0]!=0);
    vi A(1,a[0]);
    vi B(1,poww(a[0], 7-2,7));
    vi two {2};
    int bit = 1;
    while(sz(B) < n){
        int len = 1 << bit;
        forn(i, min(sz(a), sz(B)), min(len, sz(a))) A.pb(a[i]);
        B = mul(B, diff(two, mul(A, B, len)), min(n, len));
        bit++;
    }
    return B;
}

// Прозводная ряда
vi deriv(vi &a){
    vi da(sz(a) - 1);
    forn (i,1, sz(a)) da[i - 1] = (1ll * i * a[i]) % mod;
    return da;
}

// Интеграл от ряда
vi integ(vi &a){
    vi b(sz(a)+1);
    vi invs = f_inv(sz(b));
    forn(i,1,sz(a)+1) b[i] = 1ll * a[i-1] * invs[i] % mod;
    return b;
}

// Логарифм ряда
vi log(vi a, int n){
    assert(a[0]==1);
    a.resize(min(sz(a), n));
    if (n == 0) return a;
    a = mul(deriv(a), inv(a, n - 1), n - 1);
    return integ(a);
}

// Экспонента ряда
vi exp(vi A, int n){
    assert(A[0]==0);
    vi a(1);
    vi b(1,1);
    int bit = 1;
    while(sz(b) < n){
        int len = 1 << bit;
        vi ln_b = log(b,min(n,len));
        forn(i, sz(b), min(len, sz(A))) a.pb(A[i]);
        ln_b = diff(a,ln_b);
        (++ln_b[0])%= mod;
        b = mul(b, ln_b, min(len,n));
        bit++;
    }
    assert(b[0]==1);
    return b;
}   

// Ряд в степени (можно рациональной)
vi power(vi A, const int deg, const int n) {
    assert(A[0]==1);
    A = log(A, n);
    each(a,A) a = 1ll * a * deg % mod;
    A = exp(A, n);
    assert(A[0]==1);
    return A;
}

// ОПФ -> ЭПФ
vi EGF(vi ogf) {
    int ifact = 1, n = sz(ogf);
    forn(i,2,n) ifact = 1ll * ifact * i % mod;
    ifact = poww(ifact, mod-2);
    rforn(i,2,n){
        ogf[i] = 1ll * ogf[i] * ifact % mod;
        ifact = 1ll * ifact * i % mod;
    }
    return ogf;
}

// ЭПФ -> ОПФ
vi OGF(vi egf) {
    int fact = 1, n = sz(egf);
    forn(i,2,n){
        fact = 1ll * fact * i % mod;
        egf[i] = 1ll * egf[i] * fact % mod;
    }
    return egf;
}

void solve() {
    ll n; cin >> n; n++;
    vi G(n); 
    forn(i,n){
        int y = 1ll * i * (i-1) / 2 % (mod-1);
        G[i] = poww(2, y);
    }
    G = EGF(G);
    vi C = log(G,n);
    C[0] = 1;
    forn(i,n) C[i] = 1ll * C[i] * i % mod;
    vi CC = mul(C,C,n);
    vi ans = mul(G,CC,n);
    ans = OGF(ans);
    forn(i,n) ans[i] = 1ll * ans[i] * poww(2,mod-2) %mod;
    cout << ans[n-1] << '\n';
}
 
signed main() {
    ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t = 1;
    // cin >> t;
    while (t--) solve();
}