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

public class Euler433 {

    static long floorDiv(long a, long b) {
        return (a >= 0) ? (a / b) : -(((-a) + b - 1) / b);
    }

    static class FloorPair {
        long sum1;
        long sum2;
    }

    static FloorPair floorSumPair(long p, long q, long m, long s1, long s2) {
        FloorPair result = new FloorPair();
        long sign = 1;

        while (true) {
            long t = floorDiv(m, q);
            m -= t * q;
            result.sum1 += sign * t * s1;
            result.sum2 += sign * t * s2;

            t = floorDiv(p, q);
            p -= t * q;
            result.sum1 += sign * t * s1 * (s1 + 1) / 2;
            result.sum2 += sign * t * s2 * (s2 + 1) / 2;

            if (p == 0)
                return result;

            t = floorDiv(p * s1 + m, q);
            result.sum1 += sign * s1 * t;
            s1 = t;

            t = floorDiv(p * s2 + m, q);
            result.sum2 += sign * s2 * t;
            s2 = t;

            long tempP = p;
            p = q;
            q = tempP;

            m = -m - 1;
            sign = -sign;
        }
    }

    static long calcSmart(int val) {
        int maxXY = (int) Math.sqrt(val);
        long result1 = 0;
        long result2 = 0;

        for (int x = 2; x <= maxXY; x++) {
            long vOverX = val / x;
            for (int y = 1; y < x; y++) {
                int split = val / (x + y);
                result1 += (long) split * (split - 1) / 2;

                long s1 = vOverX - split;
                long s2 = (split <= maxXY) ? (maxXY - split) : 0;

                FloorPair block = floorSumPair(-x, y, val - (long) split * x, s1, s2);
                result1 += block.sum1;

                if (split <= maxXY) {
                    result2 += (long) split * (split - 1) / 2;
                    result2 += block.sum2;
                } else {
                    result2 += (long) maxXY * (maxXY - 1) / 2;
                }
            }
        }
        return 2 * result1 - result2;
    }

    static class MobiusData {
        byte[] mu;
        int[] prefix;
    }

    static MobiusData buildMobius(int limit) {
        MobiusData data = new MobiusData();
        data.mu = new byte[limit + 1];
        data.prefix = new int[limit + 1];
        int[] lp = new int[limit + 1];
        List<Integer> primes = new ArrayList<>();

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

        for (int i = 1; i <= limit; i++) {
            data.prefix[i] = data.prefix[i - 1] + data.mu[i];
        }

        return data;
    }

    static long baseTerm(int n) {
        long m = n / 2;
        if ((n & 1) == 0) {
            return (3 * m - 2) * m;
        }
        return 3 * m * m + m;
    }

    static class IntervalTask {
        int q;
        int muSum;

        IntervalTask(int q, int muSum) {
            this.q = q;
            this.muSum = muSum;
        }
    }

    static long computeS(int n) {
        int limit = n / 5;
        MobiusData data = buildMobius(limit);

        List<IntervalTask> tasks = new ArrayList<>();

        int l = 1;
        while (l <= limit) {
            int q = n / l;
            int r = Math.min(limit, n / q);
            int muSum = data.prefix[r] - data.prefix[l - 1];
            if (muSum != 0 && q > 1) {
                tasks.add(new IntervalTask(q, muSum));
            }
            l = r + 1;
        }

        long result = baseTerm(n);

        long parallelSum = tasks.parallelStream().mapToLong(task -> {
            return 2L * task.muSum * calcSmart(task.q);
        }).sum();

        result += parallelSum;

        return 2 * result + (long) n * (n + 1) / 2;
    }

    public static String solve() {
        return Long.toString(computeS(5000000));
    }

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