import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Euler625 {
    static final int MOD = 998244353;
    static final int INV2 = (MOD + 1) / 2;

    static int triMod(long l, long r) {
        long cnt = r - l + 1;
        long a = (l + r) % MOD;
        long b = cnt % MOD;
        return (int) ((a * b % MOD) * INV2 % MOD);
    }

    static class PhiPrefix {
        int limit;
        int[] pref;

        PhiPrefix(int limit, int[] pref) {
            this.limit = limit;
            this.pref = pref;
        }
    }

    static PhiPrefix buildPhiPrefix(int limit) {
        int[] phi = new int[limit + 1];
        List<Integer> primes = new ArrayList<>();
        byte[] isComp = new byte[limit + 1];

        if (limit >= 1)
            phi[1] = 1;

        for (int i = 2; i <= limit; i++) {
            if (isComp[i] == 0) {
                primes.add(i);
                phi[i] = i - 1;
            }
            for (int p : primes) {
                long v = (long) p * i;
                if (v > limit)
                    break;
                isComp[(int) v] = 1;
                if (i % p == 0) {
                    phi[(int) v] = phi[i] * p;
                    break;
                }
                phi[(int) v] = phi[i] * (p - 1);
            }
        }

        int[] pref = new int[limit + 1];
        for (int i = 1; i <= limit; i++) {
            pref[i] = (pref[i - 1] + phi[i]) % MOD;
        }
        return new PhiPrefix(limit, pref);
    }

    static int sumPhi(long n, PhiPrefix pre, Map<Long, Integer> memo) {
        if (n <= pre.limit)
            return pre.pref[(int) n];
        if (memo.containsKey(n))
            return memo.get(n);

        long res = (n % MOD) * ((n + 1) % MOD) % MOD;
        res = (res * INV2) % MOD;

        for (long l = 2; l <= n;) {
            long q = n / l;
            long r = n / q;
            long cnt = (r - l + 1) % MOD;
            long sub = (cnt * sumPhi(q, pre, memo)) % MOD;
            res = (res - sub + MOD) % MOD;
            l = r + 1;
        }

        int finalRes = (int) res;
        memo.put(n, finalRes);
        return finalRes;
    }

    static int G(long N, PhiPrefix pre, Map<Long, Integer> memo) {
        sumPhi(N, pre, memo);
        long ans = 0;
        for (long l = 1; l <= N;) {
            long q = N / l;
            long r = N / q;
            long sumD = triMod(l, r);
            long sphi = sumPhi(q, pre, memo);
            ans = (ans + sumD * sphi) % MOD;
            l = r + 1;
        }
        return (int) ans;
    }

    public static String solve() {
        int LIMIT = 5000000;
        PhiPrefix pre = buildPhiPrefix(LIMIT);
        Map<Long, Integer> memo = new HashMap<>();

        long ans = G(100000000000L, pre, memo);
        return Long.toString(ans);
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}