import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

public class Euler338 {

    static final long MOD = 100000000L;

    static long iroot3(long n) {
        long approx = (long) Math.cbrt((double) n);
        while ((approx + 1) * (approx + 1) * (approx + 1) <= n && (approx + 1) > 0)
            approx++;
        while (approx * approx * approx > n)
            approx--;
        return approx;
    }

    static long divisorSummatory(long n, Map<Long, Long> cache) {
        if (n <= 0)
            return 0;
        if (cache.containsKey(n))
            return cache.get(n);

        long res = 0;
        long k = 1;
        while (k <= n) {
            long q = n / k;
            long r = n / q;
            res += q * (r - k + 1);
            k = r + 1;
        }

        cache.put(n, res);
        return res;
    }

    static java.math.BigInteger sumFloorProducts(long n) {
        if (n < 2)
            return java.math.BigInteger.ZERO;
        java.math.BigInteger sum = java.math.BigInteger.ZERO;
        long i = 2;
        while (i <= n) {
            long a = n / i;
            long b = n / (i - 1);

            long next_a = n / a + 1;
            long next_b = n / b + 2;
            long nxt = Math.min(next_a, next_b);
            if (nxt > n + 1)
                nxt = n + 1;

            long cnt = nxt - i;
            sum = sum.add(java.math.BigInteger.valueOf(cnt).multiply(java.math.BigInteger.valueOf(a))
                    .multiply(java.math.BigInteger.valueOf(b)));
            i = nxt;
        }
        return sum;
    }

    static java.math.BigInteger sumDoubleFloor(long n, long limit) {
        int threads = Runtime.getRuntime().availableProcessors();
        if (limit < threads)
            threads = (int) limit;

        ExecutorService executor = Executors.newFixedThreadPool(threads);
        List<Future<java.math.BigInteger>> futures = new ArrayList<>();

        for (int t = 0; t < threads; t++) {
            final long start = 1 + (limit * t) / threads;
            final long end = (limit * (t + 1)) / threads;

            futures.add(executor.submit(() -> {
                java.math.BigInteger local = java.math.BigInteger.ZERO;
                for (long a = start; a <= end; a++) {
                    for (long b = 1; b <= limit; b++) {
                        local = local.add(java.math.BigInteger.valueOf(n / (a * b)));
                    }
                }
                return local;
            }));
        }

        java.math.BigInteger total = java.math.BigInteger.ZERO;
        for (Future<java.math.BigInteger> f : futures) {
            try {
                total = total.add(f.get());
            } catch (Exception e) {
            }
        }
        executor.shutdown();
        return total;
    }

    static java.math.BigInteger tripleCount(long n) {
        long L = iroot3(n);
        Map<Long, Long> cache = new HashMap<>();

        java.math.BigInteger sum_a = java.math.BigInteger.ZERO;
        long a = 1;
        while (a <= L) {
            long q = n / a;
            long r = n / q;
            if (r > L)
                r = L;
            long cnt = r - a + 1;
            sum_a = sum_a.add(java.math.BigInteger.valueOf(cnt)
                    .multiply(java.math.BigInteger.valueOf(divisorSummatory(q, cache))));
            a = r + 1;
        }

        java.math.BigInteger sum_ab = sumDoubleFloor(n, L);
        java.math.BigInteger l3 = java.math.BigInteger.valueOf(L).multiply(java.math.BigInteger.valueOf(L))
                .multiply(java.math.BigInteger.valueOf(L));

        return sum_a.multiply(java.math.BigInteger.valueOf(3))
                .subtract(sum_ab.multiply(java.math.BigInteger.valueOf(3)))
                .add(l3);
    }

    static java.math.BigInteger computeG(long n) {
        if (n < 2)
            return java.math.BigInteger.ZERO;
        Map<Long, Long> cache = new HashMap<>();

        java.math.BigInteger sProd = sumFloorProducts(n);
        long dN = divisorSummatory(n, cache);
        java.math.BigInteger tN = tripleCount(n);

        return sProd.subtract(tN).add(java.math.BigInteger.valueOf(dN));
    }

    public static String solve() {
        long N = 1000000000000L;
        java.math.BigInteger ans = computeG(N).remainder(java.math.BigInteger.valueOf(MOD));
        long val = ans.longValue();
        if (val < 0)
            val += MOD;
        return String.valueOf(val);
    }

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