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

public class Euler388 {
    private static final long n = 10000000000L;
    private static int sieveLimit;
    private static int[] prefix;
    private static Map<Long, Long> cache = new HashMap<>();

    public static String solve() {
        sieveLimit = (int) Math.max(1000000L, (long) Math.pow(n, 2.0 / 3.0) + 1000);

        int[] lp = new int[sieveLimit + 1];
        int[] mu = new int[sieveLimit + 1];
        List<Integer> primes = new ArrayList<>();
        mu[1] = 1;

        for (int i = 2; i <= sieveLimit; ++i) {
            if (lp[i] == 0) {
                lp[i] = i;
                primes.add(i);
                mu[i] = -1;
            }
            for (int p : primes) {
                long x = (long) i * p;
                if (x > sieveLimit)
                    break;
                lp[(int) x] = p;
                if (p == lp[i]) {
                    mu[(int) x] = 0;
                    break;
                }
                mu[(int) x] = -mu[i];
            }
        }

        prefix = new int[sieveLimit + 1];
        long current = 0;
        for (int i = 1; i <= sieveLimit; ++i) {
            current += mu[i];
            prefix[i] = (int) current;
        }

        BigInteger answer = BigInteger.ZERO;
        long l = 1;
        while (l <= n) {
            long q = n / l;
            long r = n / q;
            long muBlock = M(r) - M(l - 1);

            BigInteger bq = BigInteger.valueOf(q + 1);
            BigInteger f = bq.multiply(bq).multiply(bq).subtract(BigInteger.ONE);
            answer = answer.add(f.multiply(BigInteger.valueOf(muBlock)));

            l = r + 1;
        }

        String s = answer.toString();
        if (s.length() <= 18)
            return s;
        return s.substring(0, 9) + s.substring(s.length() - 9);
    }

    private static long M(long x) {
        if (x <= sieveLimit)
            return prefix[(int) x];
        Long cached = cache.get(x);
        if (cached != null)
            return cached;

        long ans = 1;
        long l = 2;
        while (l <= x) {
            long q = x / l;
            long r = x / q;
            ans -= (r - l + 1) * M(q);
            l = r + 1;
        }

        cache.put(x, ans);
        return ans;
    }

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