#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
const int64 MOD = 998244353;

int64 addmod(int64 a, int64 b) {
    int64 s = a + b;
    if (s >= MOD) s -= MOD;
    return s;
}
int64 mulmod(int64 a, int64 b) {
    return (__int128)a * b % MOD;
}

// largest r with r^k <= n (k>=1)
int64 iroot_floor(int64 n, int k) {
    int64 lo = 0, hi = n + 1;
    while (lo + 1 < hi) {
        int64 mid = lo + (hi - lo) / 2;
        __int128 p = 1;
        bool ok = true;
        for (int t = 0; t < k; ++t) {
            p *= mid;
            if (p > n) { ok = false; break; }
        }
        if (ok) lo = mid;
        else hi = mid;
    }
    return lo;
}

// smallest p with p^k > L  (k>=2), return p^k if <= R else 0
int64 next_power_gt(int64 L, int64 R, int k) {
    int64 lo = 1, hi = R + 1;
    while (lo + 1 < hi) {
        int64 mid = lo + (hi - lo) / 2;
        __int128 p = 1;
        for (int t = 0; t < k; ++t) {
            p *= mid;
            if (p > (__int128)L) break;
        }
        if (p <= (__int128)L) lo = mid;
        else hi = mid;
    }
    __int128 pk = 1;
    for (int t = 0; t < k; ++t) pk *= hi;
    if (pk > (__int128)R) return 0;
    return (int64)pk;
}

int64 G_mod(int64 i) {
    int64 g = 1 % MOD;
    for (int k = 2; k <= 60; ++k) {
        int64 r = iroot_floor(i, k);
        if (r <= 1) break;
        g = mulmod(g, r % MOD);
    }
    return g;
}

int64 tri_mod(int64 n) {
    if (n <= 0) return 0;
    int64 a = n % MOD, b = (n + 1) % MOD;
    int64 s = mulmod(a, b);
    if (s & 1) s = mulmod(s, (MOD + 1) / 2);
    else s = mulmod(s / 2, 1);
    return s;
}

int64 sum_i_mod(int64 L, int64 R) {
    if (L > R) return 0;
    int64 x = tri_mod(R);
    int64 y = tri_mod(L - 1);
    return (x - y + MOD) % MOD;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int64 N;
    if (!(cin >> N)) return 0;

    int64 ans = 0;
    for (int64 m = 1; m * m <= N; ++m) {
        int64 L = m * m;
        int64 R = min(N, (m + 1) * (m + 1) - 1);

        vector<int64> cuts;
        for (int k = 3; k <= 60; ++k) {
            int64 x = next_power_gt(L, R, k);
            if (x) cuts.push_back(x);
        }
        sort(cuts.begin(), cuts.end());
        cuts.erase(unique(cuts.begin(), cuts.end()), cuts.end());

        int64 cur = L;
        for (int64 p : cuts) {
            if (cur <= p - 1) {
                int64 g = G_mod(cur);
                ans = addmod(ans, mulmod(g, sum_i_mod(cur, p - 1)));
            }
            cur = p;
        }
        if (cur <= R) {
            int64 g = G_mod(cur);
            ans = addmod(ans, mulmod(g, sum_i_mod(cur, R)));
        }
    }
    cout << ans << '\n';
    return 0;
}