public class Euler617 {
    static boolean powLeq(long a, int e, long lim) {
        long r = 1;
        for (int i = 0; i < e; i++) {
            if (lim / a < r)
                return false;
            r *= a;
        }
        return true;
    }

    static long floorRoot(long n, int e) {
        if (e <= 1)
            return n;
        long lo = 1;
        long hi = Math.min(n, 1000000000L) + 1;
        while (lo + 1 < hi) {
            long mid = lo + (hi - lo) / 2;
            if (powLeq(mid, e, n)) {
                lo = mid;
            } else {
                hi = mid;
            }
        }
        return lo;
    }

    static long maxAFor(long N, int p) {
        long lo = 1, hi = 1000000000L + 1;
        while (lo + 1 < hi) {
            long mid = lo + (hi - lo) / 2;
            long r = 1;
            boolean ok = true;
            for (int i = 0; i < p; i++) {
                if (N / mid < r) {
                    ok = false;
                    break;
                }
                r *= mid;
            }
            if (ok && r <= N - mid) {
                lo = mid;
            } else {
                hi = mid;
            }
        }
        return lo;
    }

    static long sumChain(long A, int e) {
        if (A < 2)
            return 0;
        long total = A - 1;
        int t = e;
        while (t <= 60) {
            long r = floorRoot(A, t);
            if (r < 2)
                break;
            total += (r - 1);
            if (t > 60 / e)
                break;
            t *= e;
        }
        return total;
    }

    static long computeD(long N) {
        long Nm2 = N - 2;
        int pMax = 1;
        long v = 2;
        while ((v << 1) > 0 && (v << 1) <= Nm2) {
            v <<= 1;
            pMax++;
        }

        long[] A = new long[pMax + 1];
        for (int p = 2; p <= pMax; p++) {
            A[p] = maxAFor(N, p);
        }

        long ans = 0;
        for (int p = 2; p <= pMax; p++) {
            ans += sumChain(A[p], p);
        }

        for (int e = 2; e <= pMax; e++) {
            int p = e * e;
            int L = 2;
            while (p <= pMax) {
                long amax = A[p];
                if (amax >= 2) {
                    ans += (long) (L - 1) * (amax - 1);
                }
                ans += sumChain(amax, e);
                if (p > pMax / e)
                    break;
                p *= e;
                L++;
            }
        }
        return ans;
    }

    public static String solve() {
        return Long.toString(computeD(1000000000000000000L));
    }

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