import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class Euler596 {
    static final long MOD = 1000000007L;
    static final long INV2 = 500000004L;

    static long modAdd(long a, long b) {
        a += b;
        if (a >= MOD)
            a -= MOD;
        return a;
    }

    static long modSub(long a, long b) {
        return (a >= b) ? (a - b) : (a + MOD - b);
    }

    static long isqrt(long x) {
        long r = (long) Math.sqrt((double) x);
        while (r > 0 && r * r > x)
            r--;
        while ((r + 1) * (r + 1) <= x && (r + 1) * (r + 1) > 0)
            r++;
        return r;
    }

    static class SWorkerPart1 extends RecursiveTask<Long> {
        long start, end, N;

        SWorkerPart1(long s, long e, long n) {
            start = s;
            end = e;
            N = n;
        }

        protected Long compute() {
            long ans = 0;
            for (long i = start; i < end; i++) {
                ans = (ans + (i % MOD) * ((N / i) % MOD)) % MOD;
            }
            return ans;
        }
    }

    static class SWorkerPart2 extends RecursiveTask<Long> {
        long start, end, M, N;

        SWorkerPart2(long s, long e, long m, long n) {
            start = s;
            end = e;
            M = m;
            N = n;
        }

        protected Long compute() {
            long ans = 0;
            for (long q = start; q < end; q++) {
                long l = N / (q + 1) + 1;
                long r = N / q;
                if (r <= M)
                    continue;
                if (l <= M)
                    l = M + 1;
                if (l > r)
                    continue;

                long cnt = (r - l + 1) % MOD;
                long lr = (l % MOD + r % MOD) % MOD;
                long sVal = (((lr * cnt) % MOD) * INV2) % MOD;
                ans = (ans + (q % MOD) * sVal) % MOD;
            }
            return ans;
        }
    }

    static long SMod(long N) {
        if (N == 0)
            return 0;
        long M = isqrt(N);

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

        long ans = 0;

        List<SWorkerPart1> tasks1 = new ArrayList<>();
        long chunk1 = (M + threads - 1) / threads;
        for (int t = 0; t < threads; t++) {
            long s = 1 + t * chunk1;
            long e = Math.min(M + 1, 1 + (t + 1) * chunk1);
            if (s < e)
                tasks1.add(new SWorkerPart1(s, e, N));
        }

        long qmax = N / (M + 1);
        List<SWorkerPart2> tasks2 = new ArrayList<>();
        long chunk2 = (qmax + threads - 1) / threads;
        for (int t = 0; t < threads; t++) {
            long s = 1 + t * chunk2;
            long e = Math.min(qmax + 1, 1 + (t + 1) * chunk2);
            if (s < e)
                tasks2.add(new SWorkerPart2(s, e, M, N));
        }

        if (tasks1.size() + tasks2.size() > 2) {
            for (int i = 1; i < tasks1.size(); i++)
                tasks1.get(i).fork();
            for (int i = 1; i < tasks2.size(); i++)
                tasks2.get(i).fork();

            if (!tasks1.isEmpty())
                ans = modAdd(ans, tasks1.get(0).compute());
            if (!tasks2.isEmpty())
                ans = modAdd(ans, tasks2.get(0).compute());

            for (int i = 1; i < tasks1.size(); i++)
                ans = modAdd(ans, tasks1.get(i).join());
            for (int i = 1; i < tasks2.size(); i++)
                ans = modAdd(ans, tasks2.get(i).join());
        } else {
            for (SWorkerPart1 task : tasks1)
                ans = modAdd(ans, task.compute());
            for (SWorkerPart2 task : tasks2)
                ans = modAdd(ans, task.compute());
        }

        return ans;
    }

    static long TMod(long r) {
        long N = r * r;
        long sN = SMod(N);
        long sN4 = SMod(N / 4);

        long term = modSub(sN, (4 * sN4) % MOD);
        long t = modAdd(1, (8 * term) % MOD);
        return t;
    }

    public static String solve() {
        return Long.toString(TMod(100000000L));
    }

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