import java.util.ArrayList;
import java.util.List;

public class Euler234 {
    static List<Integer> primesUpTo(int n) {
        byte[] isComposite = new byte[n + 1];
        List<Integer> primes = new ArrayList<>();

        for (int i = 2; i <= n; ++i) {
            if (isComposite[i] == 0) {
                primes.add(i);
            }
            for (int p : primes) {
                long v = (long) i * p;
                if (v > n)
                    break;
                isComposite[(int) v] = 1;
                if (i % p == 0)
                    break;
            }
        }
        return primes;
    }

    static long sumMultiplesInRange(long d, long left, long right) {
        if (left > right)
            return 0;

        long first = ((left + d - 1) / d) * d;
        long last = (right / d) * d;

        if (first > last)
            return 0;

        long count = (last - first) / d + 1;

        // Use BigInteger arithmetic to avoid overflow or cast carefully to avoid sign
        // extension issues?
        // Since limits are up to 10^12, first+last is 2*10^12, and count can be large.
        // Product is < 10^18, so long is safe for intermediate values in this problem.
        long sum = first + last;

        // Account for odd parity to divide by 2 safely
        if (sum % 2 == 0) {
            return (sum / 2) * count;
        } else {
            return sum * (count / 2);
        }
    }

    public static String solve() {
        long limit = 999966663333L;
        int sqrtLimit = (int) Math.sqrt(limit) + 10;
        List<Integer> primes = primesUpTo(sqrtLimit + 100);

        int candidate = sqrtLimit + 101;
        while (true) {
            boolean isPrime = true;
            for (int p : primes) {
                if ((long) p * p > candidate)
                    break;
                if (candidate % p == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                primes.add(candidate);
                break;
            }
            candidate++;
        }

        long total = 0;
        for (int i = 0; i < primes.size() - 1; ++i) {
            long p = primes.get(i);
            long q = primes.get(i + 1);

            long p2 = p * p;
            if (p2 > limit)
                break;

            long q2 = q * q;
            long left = p2 + 1;
            long right = Math.min(limit, q2 - 1);

            if (left > right)
                continue;

            long sumP = sumMultiplesInRange(p, left, right);
            long sumQ = sumMultiplesInRange(q, left, right);
            long sumPQ = sumMultiplesInRange(p * q, left, right);

            total += sumP + sumQ - 2 * sumPQ;
        }

        return String.valueOf(total);
    }

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