import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class Euler447 {
    static final long MOD = 1000000007;

    static long safeMod(long val) {
        val %= MOD;
        if (val < 0)
            val += MOD;
        return val;
    }

    static class Sieve {
        byte[] mu;

        Sieve(int n) {
            mu = new byte[n + 1];
            boolean[] isPrime = new boolean[n + 1];
            for (int i = 2; i <= n; i++)
                isPrime[i] = true;

            List<Integer> primes = new ArrayList<>(n / 10);

            mu[1] = 1;
            for (int i = 2; i <= n; i++) {
                if (isPrime[i]) {
                    primes.add(i);
                    mu[i] = -1;
                }
                for (int p : primes) {
                    if ((long) i * p > n)
                        break;
                    isPrime[i * p] = false;
                    if (i % p == 0) {
                        mu[i * p] = 0;
                        break;
                    }
                    mu[i * p] = (byte) -mu[i];
                }
            }
        }
    }

    static long calcT(long x) {
        long totalSum = 0;
        long l = 1;
        while (l <= x) {
            long q = x / l;
            long r = x / q;

            long count = r - l + 1;
            long sumLR = l + r;

            long sumSeq = safeMod((count % (2 * MOD)) * (sumLR % (2 * MOD)) % (2 * MOD) / 2);

            long term = safeMod(sumSeq * (q % MOD));
            totalSum = safeMod(totalSum + term);

            l = r + 1;
        }
        return totalSum;
    }

    public static String solve() {
        long N = 100000000000000L;
        int limit = (int) Math.sqrt(N);

        Sieve sieve = new Sieve(limit);

        int threads = Math.max(1, Runtime.getRuntime().availableProcessors());

        long sN = IntStream.range(0, threads).parallel().mapToLong(threadId -> {
            long localSum = 0;
            for (int d = threadId + 1; d <= limit; d += threads) {
                if (sieve.mu[d] == 0)
                    continue;

                long inner = calcT(N / ((long) d * d));
                long term = safeMod((d % MOD) * inner);

                if (sieve.mu[d] == 1) {
                    localSum = safeMod(localSum + term);
                } else {
                    localSum = safeMod(localSum - term);
                }
            }
            return localSum;
        }).reduce(0, (a, b) -> safeMod(a + b));

        long nSumMod = safeMod((N % (2 * MOD)) * ((N + 1) % (2 * MOD)) % (2 * MOD) / 2);
        long result = safeMod(sN - nSumMod);

        return Long.toString(result);
    }

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