public class Euler521 {

    static final long kMod = 1000000000L;

    static long triangularMinusOneMod(long n) {
        // n*(n+1)/2 - 1 modulo 10^9
        long nMod = n % kMod;
        long nPlus1Mod = (n + 1) % kMod;

        // However, n*(n+1) must be divided by 2 before modulo.
        // We can just use exact math since n <= 10^12, n*(n+1) <= 10^24
        // We'll use BigInteger style approach but since it's just one op,
        // we can do:
        long resMod;
        if (n % 2 == 0) {
            long temp1 = (n / 2) % kMod;
            long temp2 = (n + 1) % kMod;
            resMod = (temp1 * temp2) % kMod;
        } else {
            long temp1 = n % kMod;
            long temp2 = ((n + 1) / 2) % kMod;
            resMod = (temp1 * temp2) % kMod;
        }
        resMod = (resMod - 1 + kMod) % kMod;
        return resMod;
    }

    public static void main(String[] args) {
        long N = 1000000000000L;
        int v = (int) Math.sqrt(N);

        long[] cnt_small = new long[v + 1];
        long[] cnt_large = new long[v + 1];

        long[] sum_small = new long[v + 1];
        long[] sum_large = new long[v + 1];

        for (int i = 1; i <= v; i++) {
            cnt_small[i] = i - 1;
            sum_small[i] = triangularMinusOneMod(i);

            long q = N / i;
            cnt_large[i] = q - 1;
            sum_large[i] = triangularMinusOneMod(q);
        }

        long ret = 0;

        for (int p = 2; p <= v; p++) {
            if (cnt_small[p] == cnt_small[p - 1])
                continue;

            long p_cnt = cnt_small[p - 1];
            long p_sum = sum_small[p - 1];
            long p2 = (long) p * p;

            long count_at_Np;
            if (N / p <= v) {
                count_at_Np = cnt_small[(int) (N / p)];
            } else {
                count_at_Np = cnt_large[p];
            }

            ret = (ret + (p % kMod) * ((count_at_Np - p_cnt) % kMod)) % kMod;

            int end_large = (int) Math.min(v, N / p2);

            for (int i = 1; i <= end_large; i++) {
                long d = (N / i) / p;
                long c, s;
                if (d <= v) {
                    c = cnt_small[(int) d];
                    s = sum_small[(int) d];
                } else {
                    c = cnt_large[(int) (N / d)];
                    s = sum_large[(int) (N / d)];
                }

                cnt_large[i] -= (c - p_cnt);
                long terms = (s - p_sum) % kMod;
                if (terms < 0)
                    terms += kMod;

                sum_large[i] = (sum_large[i] - terms * (p % kMod)) % kMod;
                if (sum_large[i] < 0)
                    sum_large[i] += kMod;
            }

            for (int i = v; i >= p2; i--) {
                int d = i / p;
                long c = cnt_small[d];
                long s = sum_small[d];

                cnt_small[i] -= (c - p_cnt);
                long terms = (s - p_sum) % kMod;
                if (terms < 0)
                    terms += kMod;

                sum_small[i] = (sum_small[i] - terms * (p % kMod)) % kMod;
                if (sum_small[i] < 0)
                    sum_small[i] += kMod;
            }
        }

        long ans = (sum_large[1] + ret) % kMod;
        if (ans < 0)
            ans += kMod;

        System.out.printf("%09d\n", ans);
    }
}