import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;

public class Euler641 {

    static long isqrt_floor(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 iroot6_floor(BigInteger n) {
        double nd = n.doubleValue();
        long r = (long) Math.pow(nd, 1.0 / 6.0);
        while (BigInteger.valueOf(r + 1).pow(6).compareTo(n) <= 0)
            r++;
        while (BigInteger.valueOf(r).pow(6).compareTo(n) > 0)
            r--;
        return r;
    }

    static class Mobius {
        int N;
        int[] mu;
        long[] pref_mu;
        long[] pref_sqfree;

        Mobius(int n) {
            this.N = n;
            mu = new int[n + 1];
            pref_mu = new long[n + 1];
            pref_sqfree = new long[n + 1];

            ArrayList<Integer> primes = new ArrayList<>();
            int[] lp = new int[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];
                }
            }
            for (int i = 1; i <= n; ++i) {
                pref_mu[i] = pref_mu[i - 1] + mu[i];
                pref_sqfree[i] = pref_sqfree[i - 1] + (mu[i] != 0 ? 1 : 0);
            }
        }
    }

    static class MertensMemo {
        Mobius mb;
        HashMap<Long, Long> memo;

        MertensMemo(Mobius m) {
            this.mb = m;
            this.memo = new HashMap<>();
        }

        long M(long n) {
            if (n <= mb.N)
                return mb.pref_mu[(int) n];
            Long val = memo.get(n);
            if (val != null)
                return val;
            long res = 1;
            long l = 2;
            while (l <= n) {
                long q = n / l;
                long r = n / q;
                res -= (r - l + 1) * M(q);
                l = r + 1;
            }
            memo.put(n, res);
            return res;
        }
    }

    static long squarefree_count(long n, Mobius mb, MertensMemo mm) {
        if (n <= mb.N)
            return mb.pref_sqfree[(int) n];
        long r = isqrt_floor(n);
        long s = 0;
        for (long d = 1; d <= r; ++d) {
            s += (long) mb.mu[(int) d] * (n / (d * d));
        }
        return s;
    }

    static long squarefree_even_count(long n, Mobius mb, MertensMemo mm) {
        long Q = squarefree_count(n, mb, mm);
        long M = mm.M(n);
        return (Q + M) / 2;
    }

    static long f(BigInteger N) {
        int LIM = 1000000;
        Mobius mb = new Mobius(LIM);
        MertensMemo mm = new MertensMemo(mb);

        long amax = iroot6_floor(N);
        long ans = 0;
        for (long a = 1; a <= amax; ++a) {
            BigInteger a6 = BigInteger.valueOf(a).pow(6);
            BigInteger t = N.divide(a6);

            // taking sqrt of t using biginteger logic
            BigInteger t_sqrt = t.sqrt();
            long s = t_sqrt.longValue();

            long bmax = isqrt_floor(s);
            ans += squarefree_even_count(bmax, mb, mm);
        }
        return ans;
    }

    public static String solve() {
        BigInteger N = BigInteger.TEN.pow(36);
        long ans = f(N);
        return Long.toString(ans);
    }

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