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

public class Euler355 {

    static List<Integer> sievePrimes(int n) {
        List<Integer> primes = new ArrayList<>();
        if (n < 2)
            return primes;
        boolean[] isPrime = new boolean[n + 1];
        for (int i = 2; i <= n; i++)
            isPrime[i] = true;
        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        for (int i = 2; i <= n; i++) {
            if (isPrime[i])
                primes.add(i);
        }
        return primes;
    }

    static long maxPrimePowerLeqN(long n, int prime) {
        long value = prime;
        while (value <= n / prime) {
            value *= prime;
        }
        return value;
    }

    static long highestPowerWithLimit(int prime, long limit) {
        if (limit < prime)
            return 0;
        long value = prime;
        while (value <= limit / prime) {
            value *= prime;
        }
        return value;
    }

    static long hungarianMaxWeightBipartite(int leftSize, int rightSize, long[] weights) {
        if (leftSize == 0 || rightSize == 0)
            return 0;
        int n = leftSize;
        int m = rightSize;
        long inf = Long.MAX_VALUE / 4;

        long[] u = new long[n + 1];
        long[] v = new long[m + 1];
        int[] p = new int[m + 1];
        int[] way = new int[m + 1];

        for (int i = 1; i <= n; i++) {
            p[0] = i;
            int j0 = 0;
            long[] minv = new long[m + 1];
            for (int k = 0; k <= m; k++)
                minv[k] = inf;
            boolean[] used = new boolean[m + 1];

            do {
                used[j0] = true;
                int i0 = p[j0];
                long delta = inf;
                int j1 = 0;

                for (int j = 1; j <= m; j++) {
                    if (!used[j]) {
                        long cost = -weights[(i0 - 1) * m + (j - 1)];
                        long cur = cost - u[i0] - v[j];
                        if (cur < minv[j]) {
                            minv[j] = cur;
                            way[j] = j0;
                        }
                        if (minv[j] < delta) {
                            delta = minv[j];
                            j1 = j;
                        }
                    }
                }

                for (int j = 0; j <= m; j++) {
                    if (used[j]) {
                        u[p[j]] += delta;
                        v[j] -= delta;
                    } else {
                        minv[j] -= delta;
                    }
                }
                j0 = j1;
            } while (p[j0] != 0);

            do {
                int j1 = way[j0];
                p[j0] = p[j1];
                j0 = j1;
            } while (j0 != 0);
        }

        long minCost = 0;
        for (int j = 1; j <= m; j++) {
            if (p[j] != 0) {
                minCost += -weights[(p[j] - 1) * m + (j - 1)];
            }
        }
        return -minCost;
    }

    static long solveN(long n) {
        List<Integer> allPrimes = sievePrimes((int) n);
        List<Long> maxPrimePowers = new ArrayList<>();
        long baselineSum = 1;

        for (int p : allPrimes) {
            long power = maxPrimePowerLeqN(n, p);
            maxPrimePowers.add(power);
            baselineSum += power;
        }

        int split = (int) Math.sqrt((double) n);
        List<Integer> smallPrimes = new ArrayList<>();
        List<Long> smallPrimePowers = new ArrayList<>();
        List<Integer> largePrimes = new ArrayList<>();
        List<Long> largePrimePowers = new ArrayList<>();

        for (int i = 0; i < allPrimes.size(); i++) {
            int p = allPrimes.get(i);
            long power = maxPrimePowers.get(i);
            if (p <= split) {
                smallPrimes.add(p);
                smallPrimePowers.add(power);
            } else {
                largePrimes.add(p);
                largePrimePowers.add(power);
            }
        }

        int leftSize = smallPrimes.size();
        int largeSize = largePrimes.size();
        int rightSize = largeSize + leftSize;
        long[] weights = new long[leftSize * rightSize];

        for (int si = 0; si < leftSize; si++) {
            int p = smallPrimes.get(si);
            long pPower = smallPrimePowers.get(si);
            for (int li = 0; li < largeSize; li++) {
                int q = largePrimes.get(li);
                long qPower = largePrimePowers.get(li);

                if ((long) p * q > n)
                    break;

                long bestPFactor = highestPowerWithLimit(p, n / q);
                if (bestPFactor == 0)
                    continue;

                long pairValue = bestPFactor * q;
                if (pairValue <= pPower + qPower)
                    continue;

                long gain = pairValue - pPower - qPower;
                weights[si * rightSize + li] = Math.max(weights[si * rightSize + li], gain);
            }
        }

        long maxGain = hungarianMaxWeightBipartite(leftSize, rightSize, weights);
        return baselineSum + maxGain;
    }

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