import java.util.ArrayList;

public class Euler634 {
    static long isqrt(long x) {
        if (x < 0)
            return 0;
        long r = (long) Math.sqrt(x);
        while ((r + 1) > 0 && (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 p6(long a) {
        if (a >= 1450)
            return Long.MAX_VALUE;
        long t = a * a;
        t *= t;
        t *= a * a;
        return t;
    }

    static long iroot6(long x) {
        if (x <= 0)
            return 0;
        long r = (long) Math.pow(x, 1.0 / 6.0);
        while (p6(r + 1) <= x)
            r++;
        while (p6(r) > x)
            r--;
        return r;
    }

    static ArrayList<Integer> primes_upto(int n) {
        ArrayList<Integer> primes = new ArrayList<>();
        if (n < 2)
            return primes;
        boolean[] is_comp = new boolean[n + 1];
        for (int i = 2; i <= n; ++i) {
            if (!is_comp[i]) {
                primes.add(i);
                if ((long) i * i <= n) {
                    for (int j = i * i; j <= n; j += i)
                        is_comp[j] = true;
                }
            }
        }
        return primes;
    }

    static int[] mobius_upto(int n) {
        int[] mu = new int[n + 1];
        int[] lp = new int[n + 1];
        ArrayList<Integer> primes = new ArrayList<>();
        if (n >= 1)
            mu[1] = 1;
        for (int i = 2; i <= n; ++i) {
            if (lp[i] == 0) {
                lp[i] = i;
                primes.add(i);
                mu[i] = -1;
            }
            for (int p : primes) {
                if (p > lp[i] || (long) i * p > n)
                    break;
                lp[i * p] = p;
                if (p == lp[i]) {
                    mu[i * p] = 0;
                    break;
                }
                mu[i * p] = -mu[i];
            }
        }
        return mu;
    }

    static long count_cubefree_upto(long n) {
        int D = (int) icbrt(n);
        int[] mu = mobius_upto(D);
        long s = 0;
        for (int d = 1; d <= D; ++d) {
            if (mu[d] == 0)
                continue;
            long d3 = (long) d * d * d;
            s += (long) mu[d] * (n / d3);
        }
        return s;
    }

    public static String solve() {
        long N = 9000000000000000000L;
        int vmax = (int) icbrt(N);
        boolean[] sqfree = new boolean[vmax + 1];
        for (int i = 1; i <= vmax; i++)
            sqfree[i] = true;

        int P = (int) isqrt(vmax);
        ArrayList<Integer> pr = primes_upto(P);
        for (int p : pr) {
            long p2 = (long) p * p;
            for (long m = p2; m <= vmax; m += p2) {
                sqfree[(int) m] = false;
            }
        }

        long powerful = 0;
        long squarefree_count = 0;
        for (int b = 1; b <= vmax; ++b) {
            if (!sqfree[b])
                continue;
            squarefree_count++;
            long b3 = (long) b * b * b;
            long q = N / b3;
            powerful += isqrt(q);
        }

        long sqrtN = isqrt(N);
        long cubefree_count = count_cubefree_upto(sqrtN);

        int r6 = (int) iroot6(N);
        long prime6 = primes_upto(r6).size();

        long ans = powerful - squarefree_count - cubefree_count - prime6 + 1;
        return Long.toString(ans);
    }

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