#include <bits/stdc++.h>

template <int m>
struct ModInt {
private:
    int raw_;
    using mint = ModInt;
    using i64 = int64_t;

public:
    ModInt() {
        raw_ = 0;
    }
    template <typename T>
    ModInt(const T &v) {
        raw_ = v % m;
    }
    int value() const {
        return (raw_ + m) % m;
    }
    mint &operator+=(const mint &rhs) {
        raw_ = (raw_ + rhs.raw_) % m;
        return *this;
    }
    mint &operator-=(const mint &rhs) {
        raw_ = (raw_ - rhs.raw_) % m;
        return *this;
    }
    mint &operator*=(const mint &rhs) {
        raw_ = (i64)raw_ * rhs.raw_ % m;
        return *this;
    }
    mint &operator/=(const mint &rhs) {
        return (*this) *= qpow(rhs, m - 2);
    }
    friend mint operator+(const mint &lhs, const mint &rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint &lhs, const mint &rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint &lhs, const mint &rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint &lhs, const mint &rhs) {
        return mint(lhs) /= rhs;
    }
    static constexpr int mod() {
        return m;
    }
    static mint qpow(mint a, i64 b) {
        mint res = 1;
        while (b) {
            if (b & 1) {
                res *= a;
            }
            a *= a, b >>= 1;
        }
        return res;
    }

};

using mint = ModInt<998244353>;
using namespace std;
using ll=long long;
vector<mint>fact,ifact;
void init(int n){
    fact.resize(n+4);
    ifact.resize(n+4);
    fact[0]=ifact[0]=1;
    for(int i=1;i<=n+3;i++){
        fact[i]=fact[i-1]*i;
        ifact[i]=1/fact[i];
    }
}
mint C(int n,int m){
    if(n<0||n-m<0||m<0)return 0;
    return fact[n]*ifact[n-m]*ifact[m];
}
mint C_inc(mint pre,int l,int r,int k){
    return 2*pre+C(k,l-1)-C(k,r);
}
void solve(){
    
    int n;
    cin>>n;
    init(n);
    vector<mint>p(n+3);
    mint f23=mint(2)/3;
    mint f13=mint(1)/3;
    for(int k=1;k<=n+1;k++){
        p[k]+=1-mint::qpow(f23,k)*2-k*mint::qpow(f13,k)*mint::qpow(2,k-1)+mint::qpow(f13,k)*(k+1);
        // cout<<p[k].value();
        if(k-1>=n)
        p[k]+=mint::qpow(f13,k);
        if(k>=n&&k>=2)
        p[k]+=mint::qpow(f13,k)*k;
        if(2*k>=n)
        p[k]+=mint::qpow(f23,k)-mint::qpow(f13,k);
    }
    int l=1,r=0;
    mint pre=0;
    for(int k=2;k<=n+1;k++){
        int cl=1,cr=min((3*k-1-n)/2,k-1);
        if(cl>cr)continue;
        while(r<cr){
            r++;
            pre+=C(k,r);
            
        }
        p[k]+=pre*mint::qpow(f13,k);
        pre=C_inc(pre,l,r,k);
    }
    l=1,r=0,pre=0;
    for(int k=3;k<=n+1;k++){
        int cl=1,cr=min((3*k-n)/2,k-2);
        if(cl>cr)continue;
        while(r<cr){
            r++;
            pre+=C(k-1,r);
        }
        p[k]+=pre*mint::qpow(f13,k)*k;
        pre=C_inc(pre,l,r,k-1);
    }
    p[n+2]=1-mint::qpow(f13,n+2);
    mint ans=0;
    for(int i=1;i<=n+2;i++){
        ans+=(p[i]-p[i-1])*i;
    }
    
    // for(int i=0;i<=n+2;i++){
    //     // assert(p[i]==()
    //     cout<<p[i].value()<<' ';
    // }
    // cout<<'\n';
    // cout<<(mint(8)/9).value();
    ans+=mint::qpow(f13,n+2)*(n+mint(7)/2);

    cout<<ans.value();
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    solve();
}