#include <bits/extc++.h>
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

// To use most b i ts rather than jus t the lowest ones :
struct chash { // large odd number for C
    const uint64_t C = ll(4e18 * acos(0)) | 71;

    ll operator()(ll x) const { return __builtin_bswap64(x*C); }
};

__gnu_pbds::gp_hash_table<ll,ll,chash> rdp({},{},{},{},{1<<25});

const ll mod = 998244353;
const int N = 20210926;
const int DPC = 31625;

vector<int> lp(N+1);
vector<ll> pr;

int TN;
int LB = 0;
vector<ll> dp(DPC);

void prep(){
    for (int i=2; i <= N; ++i) {
        if (lp[i] == 0) {
            lp[i] = i;
            pr.push_back(i);
        }
        for (int j = 0; i * pr[j] <= N; ++j) {
            lp[i * pr[j]] = pr[j];
            if (pr[j] == lp[i]) {
                break;
            }
        }
    }

    while(pr[LB] < DPC)
        LB++;

    dp[1] = 1;

    for(int i = 2; i < DPC; i++){
        for(int j = 1; j * j <= i; j++){
            if(i % j)
                continue;

            dp[i] += dp[i / j];

            if(j * j != i)
                dp[i] += dp[j];

            dp[i] %= mod;
        }
    }

    for(int i = 1; i < DPC; i++)
        dp[i] = (dp[i] + dp[i - 1]) % mod;
}

ll rec(ll n){
    if(TN / n < DPC)
        return dp[TN / n];

    if(rdp.find(n) != rdp.end())
        return rdp[n];

    ll ans = 0;

    for(ll v = 2; v * n < DPC; v++)
        ans += rec(v * n);

    for(int i = LB; i < pr.size(); i++){
        if(pr[i] * n > TN)
            break;

        ans += rec(pr[i] * n);
    }

    ans %= mod;

    rdp[n] = ans;
    
    return ans;
}

int main(){
    cin >> TN;

    prep();

	cout << rec(1) << "\n";
}