import java.util.*;

public class Euler563 {
    static void genSmoothRec(long[] primes, int idx, long cur, long limit, List<Long> out) {
        if (idx == primes.length) {
            out.add(cur);
            return;
        }
        long p = primes[idx];
        long v = cur;
        while (true) {
            genSmoothRec(primes, idx + 1, v, limit, out);
            if (v > limit / p)
                break;
            v *= p;
        }
    }

    static List<Long> genSmooth(long limit) {
        long[] primes = { 2, 3, 5, 7, 11, 13, 17, 19, 23 };
        List<Long> nums = new ArrayList<>(200000);
        genSmoothRec(primes, 0, 1, limit, nums);
        Set<Long> set = new HashSet<>(nums);
        List<Long> uniqueNums = new ArrayList<>(set);
        Collections.sort(uniqueNums);
        return uniqueNums;
    }

    static class MResult {
        long[] M;
        long maxFilled;
    }

    static int upperBound(List<Long> list, int from, long val) {
        int left = from;
        int right = list.size();
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (list.get(mid) > val) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }

    static MResult computeM(long sideLimit, int maxK) {
        List<Long> smooth = genSmooth(sideLimit);
        Map<Long, Integer> cnt = new HashMap<>(smooth.size() * 4);

        for (int i = 0; i < smooth.size(); i++) {
            long x = smooth.get(i);
            long ymax = (11 * x) / 10;
            int jEnd = upperBound(smooth, i, ymax);
            for (int j = i; j < jEnd; j++) {
                long y = smooth.get(j);
                long area = x * y;
                Integer currentCount = cnt.get(area);
                if (currentCount == null) {
                    cnt.put(area, 1);
                } else if (currentCount <= maxK) {
                    cnt.put(area, currentCount + 1);
                }
            }
        }

        long INF = Long.MAX_VALUE;
        long[] M = new long[maxK + 1];
        Arrays.fill(M, INF);

        for (Map.Entry<Long, Integer> entry : cnt.entrySet()) {
            long area = entry.getKey();
            int k = entry.getValue();
            if (k >= 2 && k <= maxK) {
                if (area < M[k]) {
                    M[k] = area;
                }
            }
        }

        long maxFilled = 0;
        for (int k = 2; k <= maxK; k++) {
            if (M[k] != INF && M[k] > maxFilled) {
                maxFilled = M[k];
            }
        }

        MResult res = new MResult();
        res.M = M;
        res.maxFilled = maxFilled;
        return res;
    }

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

    static long solveSumM(int maxK) {
        long sideLimit = 1000000;

        while (true) {
            MResult res = computeM(sideLimit, maxK);
            long INF = Long.MAX_VALUE;
            boolean allFound = true;

            for (int k = 2; k <= maxK; k++) {
                if (res.M[k] == INF) {
                    allFound = false;
                    break;
                }
            }

            if (!allFound) {
                sideLimit *= 10;
                continue;
            }

            long maxM = res.maxFilled;
            long s = isqrt(maxM);
            if (s * s < maxM)
                s++;

            long needed = (11 * s + 9) / 10;
            if (sideLimit < needed) {
                sideLimit = needed;
                continue;
            }

            long sum = 0;
            for (int k = 2; k <= maxK; k++) {
                sum += res.M[k];
            }
            return sum;
        }
    }

    public static String solve() {
        return Long.toString(solveSumM(100));
    }

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