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

public class Euler379 {

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

    static long icbrt(long x) {
        if (x < 0)
            return 0;
        long r = (long) Math.cbrt(x);
        while ((r + 1) * (r + 1) * (r + 1) <= x)
            r++;
        while (r * r * r > x)
            r--;
        return r;
    }

    static long sqSumFloor(long n, long x1, long x2) {
        if (x1 > x2)
            return 0;

        long x = x2;
        long s = 0;
        long beta = n / (x + 1);
        long epsilon = n % (x + 1);
        long delta = (n / x) - beta;
        long gamma = beta - x * delta;

        while (x >= x1) {
            epsilon += gamma;
            if (epsilon >= x) {
                delta += 1;
                gamma -= x;
                epsilon -= x;
                if (epsilon >= x) {
                    delta += 1;
                    gamma -= x;
                    epsilon -= x;
                    if (epsilon >= x) {
                        break;
                    }
                }
            } else if (epsilon < 0) {
                delta -= 1;
                gamma += x;
                epsilon += x;
            }

            gamma += 2 * delta;
            beta += delta;
            s += beta;
            x -= 1;
        }

        if (x < x1)
            return s;

        epsilon = n % (x + 1);
        delta = (n / x) - beta;
        gamma = beta - x * delta;

        while (x >= x1) {
            epsilon += gamma;
            long delta2 = epsilon / x;
            delta += delta2;
            epsilon -= x * delta2;
            gamma += 2 * delta - x * delta2;
            beta += delta;
            s += beta;
            x -= 1;
        }

        while (x >= x1) {
            s += n / x;
            x -= 1;
        }

        return s;
    }

    static long summatoryD3(long n) {
        long cbrtN = icbrt(n);
        long acc = 0;

        for (long z = 1; z <= cbrtN; z++) {
            long nz = n / z;
            long sqrtNz = isqrt(nz);
            acc += 2 * sqSumFloor(nz, z + 1, sqrtNz) - sqrtNz * sqrtNz + nz / z;
        }

        acc *= 3;
        acc += cbrtN * cbrtN * cbrtN;
        return acc;
    }

    static int[] mobiusSieve(int n) {
        int[] mu = new int[n + 1];
        int[] lp = new int[n + 1];
        int[] primes = new int[n / 2 + 10];
        int primeCount = 0;

        if (n >= 1)
            mu[1] = 1;
        for (int i = 2; i <= n; i++) {
            if (lp[i] == 0) {
                lp[i] = i;
                primes[primeCount++] = i;
                mu[i] = -1;
            }
            for (int j = 0; j < primeCount; j++) {
                int p = primes[j];
                long v = (long) i * p;
                if (v > n)
                    break;
                lp[(int) v] = p;
                if (i % p == 0) {
                    mu[(int) v] = 0;
                    break;
                }
                mu[(int) v] = -mu[i];
            }
        }
        return mu;
    }

    static String solve() {
        long n = 1000000000000L;
        long I = icbrt(n);
        int D = (int) isqrt(n / I);

        long res = 0;
        int[] mu = mobiusSieve(D);
        long[] mertensSmall = new long[D + 1];

        for (int d = 1; d <= D; d++) {
            int mud = mu[d];
            if (mud != 0) {
                long div = (long) d * d;
                res += mud * summatoryD3(n / div);
            }
            mertensSmall[d] = mertensSmall[d - 1] + mud;
        }

        if (I >= 2) {
            long[] smallDiff = new long[(int) I];
            for (int i = 1; i < I; i++) {
                smallDiff[i] = summatoryD3(i);
            }

            res -= mertensSmall[D] * smallDiff[(int) I - 1];

            for (int i = (int) I - 1; i >= 2; i--) {
                smallDiff[i] -= smallDiff[i - 1];
            }

            long[] mertensBig = new long[(int) I];
            for (int i = (int) I - 1; i >= 1; i--) {
                long v = isqrt(n / i);
                long vSqrt = isqrt(v);

                long m = 1 - v + vSqrt * mertensSmall[(int) vSqrt];
                for (long d = 2; d <= vSqrt; d++) {
                    long q = v / d;
                    if (q <= D) {
                        m -= mertensSmall[(int) q];
                    } else {
                        int idx = (int) (i * d * d);
                        m -= mertensBig[idx];
                    }
                    m -= (mertensSmall[(int) d] - mertensSmall[(int) d - 1]) * q;
                }

                mertensBig[i] = m;
                res += smallDiff[i] * m;
            }
        }

        res += n;
        long ans = res / 2;
        return Long.toString(ans);
    }

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