#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rrep(i, a, b) for (int i = (int)(a); i > (int)(b); i--)
#define ll long long
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define PQ priority_queue<int, vector<int>, greater<int>>
#define PQ_g priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>>
#define chmin(a, b) a = min(a, b)
#define chmax(a, b) a = max(a, b)
const int d4[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
const int d8[8][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};
void Yes(bool b) {cout << (b ? "Yes" : "No") << endl;}

ll const MOD = 998244353LL;
ll const inv20 = 149736653LL;
ll const inv2 = 499122177LL;

ll int_sqrt(ll n) {
    ll l = 0LL, r = 1LL << 30;
    while (r - l > 1LL) {
        ll m = (l + r) >> 1;
        if (n < m * m) r = m;
        else l = m;
    }
    return l;
}

ll sub_calc(ll n) {
    ll sqrt_n = int_sqrt(n);
    ll m = sqrt_n - 1LL;
    ll ret = inv20 * m;
    ret %= MOD;
    ret *= m + 1LL;
    ret %= MOD;
    ret *= (((8LL * (m * m % MOD) + 27LL * m + 23LL) % MOD) * m + 2LL) % MOD;
    ret %= MOD;

    n %= MOD;
    ll sqrt_n_2 = sqrt_n * sqrt_n % MOD;
    
    ret += (((sqrt_n * inv2) % MOD) * (n - sqrt_n_2 + 1LL) % MOD) * (n + sqrt_n_2) % MOD;

    ret %= MOD;
    ret += MOD;
    ret %= MOD;

    return ret;
}

ll pow_mod(ll a, ll b) {
    ll ret = 1LL;
    while (b) {
        if (b & 1LL) {
            ret *= a;
            ret %= MOD;
        }
        a *= a;
        a %= MOD;
        b >>= 1;
    }
    return ret;
}

ll inv(ll a) {
    return pow_mod(a, MOD - 2LL);
}

int main() {
    vector<ll> after3pow;
    map<ll, vector<int>> num_to_pow;
    after3pow.push_back(1LL);
    vector<ll> cnt_pow(59 + 1, 1LL);
    cnt_pow[0] = 0LL;
    cnt_pow[1] = 0LL;
    cnt_pow[2] = 0LL;

    ll pow_cnt_lim[60] = {1LL << 60, 1LL << 60, 1LL << 60, 1000000, 31622, 3981, 1000, 372, 177, 100, 63, 43, 31, 24, 19, 15, 13, 11, 10, 8, 7, 7, 6, 6, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};

    for (ll j = 2LL; j <= 1000000LL; j++) {
        ll num = 1LL;
        rep(i, 1, 59 + 1) {
            if (j > pow_cnt_lim[i]) break;
            num *= j;
            if (i >= 3) num_to_pow[num].push_back(i);
        }
    }
    

    for (auto &p: num_to_pow) {
        after3pow.push_back(p.first);
    }
    after3pow.push_back(1LL << 60);
    after3pow.push_back(1LL << 60);


    ll n; cin >> n;
    ll ans = 0LL;
    ll multiplier = 1LL;

    rep(i, 0, after3pow.size() - 1) {
        if (after3pow[i] > n) break;
        if (after3pow[i] > 1LL) {
            for (auto &pw: num_to_pow[after3pow[i]]) {
                multiplier *= inv(cnt_pow[pw]);
                multiplier %= MOD;
                cnt_pow[pw]++;
                multiplier *= cnt_pow[pw];
                multiplier %= MOD;
            }
        }
        
        ans += multiplier * (sub_calc(min(n, after3pow[i + 1] - 1LL)) - sub_calc(after3pow[i] - 1LL)) % MOD;
        ans %= MOD;
    }
    

    ans %= MOD;
    ans += MOD;
    ans %= MOD;

    cout << ans << endl;
}