import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Arrays;
import java.util.Collections;
import java.math.BigInteger;

public class Euler920 {

    static class PrimeNeed implements Comparable<PrimeNeed> {
        long prime;
        int need;

        PrimeNeed(long p, int n) {
            prime = p;
            need = n;
        }

        public int compareTo(PrimeNeed other) {
            if (this.prime != other.prime)
                return Long.compare(other.prime, this.prime);
            return Integer.compare(other.need, this.need);
        }
    }

    static long powCapped(long base, int exp, long cap) {
        long result = 1;
        for (int i = 0; i < exp; ++i) {
            if (result > cap / base)
                return cap + 1;
            result *= base;
        }
        return result;
    }

    static long mulPowCapped(long value, long base, int exp, long cap) {
        for (int i = 0; i < exp; ++i) {
            if (value > cap / base)
                return cap + 1;
            value *= base;
        }
        return value;
    }

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

    static class TauSolver {
        long limit;
        List<Integer> primes;
        Map<Long, List<PrimeNeed>> factorCache;
        Map<Long, Long> best;
        long bestValue;

        TauSolver(long limit) {
            this.limit = limit;
            this.primes = sievePrimes(300000);
            this.factorCache = new HashMap<>();
            this.best = new HashMap<>();
        }

        List<PrimeNeed> factorize(long x) {
            if (factorCache.containsKey(x))
                return factorCache.get(x);
            List<PrimeNeed> factors = new ArrayList<>();
            long value = x;
            for (int prime : primes) {
                if ((long) prime * prime > value)
                    break;
                if (value % prime == 0) {
                    int exponent = 0;
                    while (value % prime == 0) {
                        value /= prime;
                        exponent++;
                    }
                    factors.add(new PrimeNeed(prime, exponent));
                }
            }
            if (value > 1)
                factors.add(new PrimeNeed(value, 1));
            factorCache.put(x, factors);
            return factors;
        }

        List<Long> buildExtraPrimes(int count, List<PrimeNeed> mandatory) {
            java.util.Set<Long> blocked = new java.util.HashSet<>();
            for (PrimeNeed req : mandatory)
                blocked.add(req.prime);
            List<Long> extras = new ArrayList<>();
            for (int prime : primes) {
                long p = prime;
                if (!blocked.contains(p)) {
                    extras.add(p);
                    if (extras.size() == count)
                        break;
                }
            }
            return extras;
        }

        long minimalValueForVector(List<Integer> exponents, List<PrimeNeed> factors) {
            int r = exponents.size();
            int t = factors.size();
            if (t > r)
                return limit + 1;

            List<PrimeNeed> mandatory = new ArrayList<>(factors);
            Collections.sort(mandatory);

            for (PrimeNeed req : mandatory) {
                if (exponents.isEmpty() || exponents.get(0) < req.need)
                    return limit + 1;
            }

            List<Long> extras = buildExtraPrimes(r - t, mandatory);
            boolean[] used = new boolean[r];
            bestValue = limit + 1;

            dfsAssign(0, 1, r, t, mandatory, extras, exponents, used);
            return bestValue;
        }

        void dfsAssign(int idx, long current, int r, int t, List<PrimeNeed> mandatory, List<Long> extras,
                List<Integer> exponents, boolean[] used) {
            if (current >= bestValue)
                return;

            if (idx == t) {
                long value = current;
                int extraIdx = 0;
                for (int i = 0; i < r; ++i) {
                    if (used[i])
                        continue;
                    value = mulPowCapped(value, extras.get(extraIdx), exponents.get(i), limit);
                    if (value > limit || value >= bestValue)
                        return;
                    extraIdx++;
                }
                bestValue = Math.min(bestValue, value);
                return;
            }

            int previousExp = -1;
            for (int i = 0; i < r; ++i) {
                if (used[i])
                    continue;
                int exp = exponents.get(i);
                if (exp < mandatory.get(idx).need)
                    continue;
                if (exp == previousExp)
                    continue;
                previousExp = exp;

                long multiplied = mulPowCapped(current, mandatory.get(idx).prime, exp, limit);
                if (multiplied > limit || multiplied >= bestValue)
                    continue;

                used[i] = true;
                dfsAssign(idx + 1, multiplied, r, t, mandatory, extras, exponents, used);
                used[i] = false;
            }
        }

        void dfsVectors(int primeIdx, int maxExp, long currentValue, long tauValue, List<Integer> exponents) {
            List<PrimeNeed> factors = factorize(tauValue);
            long candidate = minimalValueForVector(exponents, factors);
            if (candidate <= limit) {
                if (!best.containsKey(tauValue) || candidate < best.get(tauValue)) {
                    best.put(tauValue, candidate);
                }
            }

            if (primeIdx >= primes.size())
                return;

            long prime = primes.get(primeIdx);
            long value = currentValue;
            for (int exp = 1; exp <= maxExp; ++exp) {
                if (value > limit / prime)
                    break;
                value *= prime;

                long newTau = tauValue * (exp + 1);

                exponents.add(exp);
                dfsVectors(primeIdx + 1, exp, value, newTau, exponents);
                exponents.remove(exponents.size() - 1);
            }
        }

        Map<Long, Long> computeMinimals() {
            best.clear();
            factorCache.clear();
            List<Integer> exponents = new ArrayList<>();
            dfsVectors(0, 64, 1, 1, exponents);
            return best;
        }
    }

    public static String solve() {
        long kLimit = 10000000000000000L;
        TauSolver solver = new TauSolver(kLimit);
        Map<Long, Long> minima = solver.computeMinimals();
        BigInteger total = BigInteger.ZERO;
        for (long v : minima.values()) {
            total = total.add(BigInteger.valueOf(v));
        }
        return total.toString();
    }

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