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

public class Euler501 {

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

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

    private static long iroot7(long n) {
        if (n == 0)
            return 0;
        long x = (long) Math.pow(n, 1.0 / 7.0);
        while (Math.pow(x + 1, 7) <= n)
            x++;
        while (x > 0 && Math.pow(x, 7) > n)
            x--;
        return x;
    }

    private static List<Integer> primeSieve(long n) {
        if (n < 2)
            return new ArrayList<>();
        int m = (int) (n + 1);
        boolean[] isPrime = new boolean[m];
        for (int i = 2; i < m; i++)
            isPrime[i] = true;
        long r = isqrt(n);
        for (int p = 2; p <= r; p++) {
            if (isPrime[p]) {
                for (int q = p * p; q < m; q += p) {
                    isPrime[q] = false;
                }
            }
        }
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i < m; i++) {
            if (isPrime[i])
                primes.add(i);
        }
        return primes;
    }

    static class PiTables {
        long n, v;
        long[] smalls, larges;

        PiTables(long n, long v, long[] smalls, long[] larges) {
            this.n = n;
            this.v = v;
            this.smalls = smalls;
            this.larges = larges;
        }
    }

    private static PiTables tabulatePis(long n, List<Integer> primes) {
        long v = isqrt(n);
        long[] smalls = new long[(int) (v + 1)];
        long[] larges = new long[(int) (v + 1)];

        for (int i = 1; i <= v; i++) {
            smalls[i] = i - 1;
            larges[i] = n / i - 1;
        }

        for (int pInt : primes) {
            long p = pInt;
            if (p > v)
                break;
            long pCnt = smalls[(int) p - 1];
            long q = p * p;
            if (q > n)
                break;
            long end = Math.min(v, n / q);

            for (int i = 1; i <= end; i++) {
                long d = i * p;
                if (d <= v) {
                    larges[i] -= larges[(int) d] - pCnt;
                } else {
                    larges[i] -= smalls[(int) (n / d)] - pCnt;
                }
            }

            for (int i = (int) v; i >= q; i--) {
                smalls[i] -= smalls[(int) (i / p)] - pCnt;
            }
        }
        return new PiTables(n, v, smalls, larges);
    }

    public static void main(String[] args) {
        long n = 1000000000000L;
        long v = isqrt(n);
        List<Integer> primes = primeSieve(v);
        PiTables pi = tabulatePis(n, primes);

        long ans = 0;
        long cbrtN = icbrt(n);
        long piCbrtN = pi.smalls[(int) cbrtN];

        for (int piIdx = 0; piIdx < piCbrtN; piIdx++) {
            long p = primes.get(piIdx);
            if (p * p * p >= n)
                break;
            long m = n / p;
            long qLim = pi.smalls[(int) isqrt(m)];

            for (int pjIdx = piIdx + 1; pjIdx < qLim; pjIdx++) {
                long q = primes.get(pjIdx);
                long r = m / q;
                long piR;
                if (r <= pi.v) {
                    piR = pi.smalls[(int) r];
                } else {
                    piR = pi.larges[(int) (p * q)];
                }
                ans += piR - pi.smalls[(int) q];
            }
        }

        for (int piIdx = 0; piIdx < piCbrtN; piIdx++) {
            long p = primes.get(piIdx);
            long p3 = p * p * p;
            long r = n / p3;
            if (r <= 1)
                break;
            if (r <= pi.v) {
                ans += pi.smalls[(int) r];
            } else {
                ans += pi.larges[(int) p3];
            }
        }

        long root4 = isqrt(isqrt(n));
        ans -= pi.smalls[(int) root4];
        ans += pi.smalls[(int) iroot7(n)];

        System.out.println(ans);
    }
}