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

#define int long long  

constexpr int mod = 998244353;

int qpow(int a, int b) {
    int ret = 1;
    for (; b; b /= 2, a = a * a % mod) {
        if (b % 2) {
            ret = ret * a % mod;
        }
    }
    return ret;
}

int inv(int a) {
    return qpow(a, mod - 2);
}
vector<int> minp, primes;
void sieve(int n) {
    minp.assign(n + 1, 0);
    primes.clear();    
    for (int i = 2; i <= n; i++) {
        if (minp[i] == 0) {
            minp[i] = i;
            primes.push_back(i);
        }
        for (auto p : primes) {
            if (i * p > n) {
                break;
            }
            minp[i * p] = p;
            if (p == minp[i]) {
                break;
            }    
        }
    }  
}

struct Min25 {
    int n;
    int sqrtn;

    vector<int> v;
    vector<int> f;

    int sum(int x) {
        x %= mod;
        return ((x + 1) * x % mod * inv(2) % mod - 1 + mod) % mod;
    }

    int calc(int x) {
        return x % mod;
    }   

    int get(int x) {
        if (x <= sqrtn) {
            return f[v.size() - x];
        } else {
            return f[n / x - 1]; 
        }
    }
    void init() {
        // 提前筛出sqrn以内质数
        for (int l = 1, r; l <= n; l = r + 1) {
            v.push_back(n / l);
            r = n / (n / l);
        }
        f.resize(v.size());
        for (int i = 0; i < v.size(); i++) {
            f[i] = sum(v[i]);
        }
        int ps = 0;
        for (auto p : primes) {
            for (int i = 0; i < v.size(); i++) {
                if (p * p > v[i]) {
                    break;
                }
                f[i] = (f[i] - calc(p) * (get(v[i] / p) - ps + mod) % mod + mod) % mod;
            }
            ps = (ps + calc(p)) % mod;
        }
    }

    int solve(int x) {
        // if (x <= 1) {
        //     return x;
        // }
        n = x;
        sqrtn = sqrt(n + 0.5);
        init();
        return get(n);
    }
};

struct Min26 {
    int n;
    int sqrtn;

    vector<int> v;
    vector<int> f;

    int sum(int x) {
        x %= mod;
        return (x * (x + 1) % mod * (2 * x + 1) % mod * inv(6) % mod - 1 + mod) % mod;
    }

    int calc(int x) {
        x %= mod;
        return x * x % mod;
    }   

    int get(int x) {
        if (x <= sqrtn) {
            return f[v.size() - x];
        } else {
            return f[n / x - 1]; 
        }
    }
    void init() {
        // 提前筛出sqrn以内质数
        for (int l = 1, r; l <= n; l = r + 1) {
            v.push_back(n / l);
            r = n / (n / l);
        }
        f.resize(v.size());
        for (int i = 0; i < v.size(); i++) {
            f[i] = sum(v[i]);
        }
        int ps = 0;
        for (auto p : primes) {
            for (int i = 0; i < v.size(); i++) {
                if (p * p > v[i]) {
                    break;
                }
                f[i] = (f[i] - calc(p) * (get(v[i] / p) - ps + mod) % mod + mod) % mod;
            }
            ps = (ps + calc(p)) % mod;
        }
    }

    int solve(int x) {
        // if (x <= 1) {
        //     return x;
        // }
        n = x;
        sqrtn = sqrt(n + 0.5);
        init();
        return get(n);
    }
};

signed main() {  
    ios::sync_with_stdio(false);
    cin.tie(nullptr);  

    int n;
    cin >> n;

    sieve(sqrt(n + 0.5));

    int x = ((n + 2) % mod) * ((n - 1) % mod) % mod * inv(2) % mod;
    int y = (n % mod) * ((n + 1) % mod) % mod * ((2 * n + 1) % mod) % mod * inv(6) % mod;
    int sum = (x * x % mod - y + 1 + mod) * inv(2) % mod; 

    Min25 a;
    Min26 b;

    a.solve(n), b.solve(n);

    int s1 = (a.get(n) - a.get(n / 2) + mod) % mod;
    int s2 = (b.get(n) - b.get(n / 2) + mod) % mod;

    sum -= (s1 * (x - s1 + mod) % mod + (s1 * s1 % mod - s2 + mod) * inv(2) % mod) % mod;
    sum = (sum + mod) % mod;
    cout << sum << "\n";

    return 0;
}