import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Euler548 {
    static final long kLimit = 10000000000000000L; // 1e16

    static long gcdU64(long a, long b) {
        while (b != 0) {
            long t = a % b;
            a = b;
            b = t;
        }
        return a;
    }

    static long mulModU64(long a, long b, long mod) {
        long res = 0;
        a %= mod;
        while (b > 0) {
            if ((b & 1) != 0) {
                res = (res + a) % mod;
            }
            a = (a << 1) % mod;
            b >>= 1;
        }
        return res;
    }

    static long powModU64(long a, long d, long mod) {
        long r = 1;
        while (d > 0) {
            if ((d & 1) != 0)
                r = mulModU64(r, a, mod);
            a = mulModU64(a, a, mod);
            d >>= 1;
        }
        return r;
    }

    static boolean isPrimeU64(long n) {
        if (n < 2)
            return false;
        long[] smallPrimes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 };
        for (long p : smallPrimes) {
            if (n == p)
                return true;
            if (n % p == 0)
                return false;
        }

        long d = n - 1;
        long s = 0;
        while ((d & 1) == 0) {
            d >>= 1;
            s++;
        }

        long[] bases = { 2L, 325L, 9375L, 28178L, 450775L, 9780504L, 1795265022L };
        for (long a : bases) {
            if (a % n == 0)
                continue;
            long x = powModU64(a, d, n);
            if (x == 1 || x == n - 1)
                continue;
            boolean possiblePrime = false;
            for (long i = 1; i < s; i++) {
                x = mulModU64(x, x, n);
                if (x == n - 1) {
                    possiblePrime = true;
                    break;
                }
            }
            if (!possiblePrime)
                return false;
        }
        return true;
    }

    static long rngState = 0x123456789abcdef0L;

    static long splitmix64() {
        rngState += 0x9e3779b97f4a7c15L;
        long z = rngState;
        z = (z ^ (z >>> 30)) * 0xbf58476d1ce4e5b9L;
        z = (z ^ (z >>> 27)) * 0x94d049bb133111ebL;
        return z ^ (z >>> 31);
    }

    static long randU64(long lo, long hi) {
        long r = splitmix64();
        if (hi > lo) {
            return lo + Long.remainderUnsigned(r, hi - lo + 1);
        }
        return lo;
    }

    static long pollardRho(long n) {
        if ((n & 1) == 0)
            return 2;
        if (n % 3 == 0)
            return 3;

        while (true) {
            long c = randU64(1, n - 1);
            long x = randU64(0, n - 1);
            long y = x;
            long d = 1;

            while (d == 1) {
                x = (mulModU64(x, x, n) + c) % n;
                y = (mulModU64(y, y, n) + c) % n;
                y = (mulModU64(y, y, n) + c) % n;
                long diff = (x > y) ? (x - y) : (y - x);
                d = gcdU64(diff, n);
            }
            if (d != n)
                return d;
        }
    }

    static void factorRec(long n, List<Long> out) {
        if (n == 1)
            return;
        if (isPrimeU64(n)) {
            out.add(n);
            return;
        }
        long d = pollardRho(n);
        factorRec(d, out);
        factorRec(n / d, out);
    }

    static List<Integer> exponentPattern(long n) {
        if (n == 1)
            return Collections.emptyList();
        List<Long> fac = new ArrayList<>();
        factorRec(n, fac);
        Collections.sort(fac);
        List<Integer> exps = new ArrayList<>();
        for (int i = 0; i < fac.size();) {
            int j = i;
            while (j < fac.size() && fac.get(j).equals(fac.get(i)))
                j++;
            exps.add(j - i);
            i = j;
        }
        exps.sort(Collections.reverseOrder());
        return exps;
    }

    static java.math.BigInteger binomU128(int n, int k) {
        if (k < 0 || k > n)
            return java.math.BigInteger.ZERO;
        k = Math.min(k, n - k);
        java.math.BigInteger r = java.math.BigInteger.ONE;
        for (int i = 1; i <= k; i++) {
            r = r.multiply(java.math.BigInteger.valueOf(n - k + i))
                    .divide(java.math.BigInteger.valueOf(i));
        }
        return r;
    }

    static long gFromPattern(List<Integer> exps, long limit) {
        if (exps.isEmpty())
            return 1;
        int omega = 0;
        for (int e : exps)
            omega += e;

        java.math.BigInteger[][] C = new java.math.BigInteger[omega + 1][omega + 1];
        C[0][0] = java.math.BigInteger.ONE;
        for (int n = 1; n <= omega; n++) {
            C[n][0] = java.math.BigInteger.ONE;
            C[n][n] = java.math.BigInteger.ONE;
            for (int k = 1; k < n; k++) {
                C[n][k] = C[n - 1][k - 1].add(C[n - 1][k]);
            }
        }

        java.math.BigInteger[] total = new java.math.BigInteger[omega + 1];
        java.math.BigInteger limitBi = java.math.BigInteger.valueOf(limit);

        for (int k = 1; k <= omega; k++) {
            java.math.BigInteger prod = java.math.BigInteger.ONE;
            for (int a : exps) {
                prod = prod.multiply(binomU128(a + k - 1, k - 1));
            }
            total[k] = prod;
        }

        java.math.BigInteger g = java.math.BigInteger.ZERO;
        for (int k = 1; k <= omega; k++) {
            java.math.BigInteger fk = java.math.BigInteger.ZERO;
            for (int i = 1; i <= k; i++) {
                java.math.BigInteger term = C[k][i].multiply(total[i]);
                if (((k - i) & 1) != 0) {
                    fk = fk.subtract(term);
                } else {
                    fk = fk.add(term);
                }
            }
            g = g.add(fk);
            if (g.compareTo(limitBi) > 0)
                return limit + 1;
        }
        return g.longValueExact();
    }

    static class Enumerator {
        long[] primes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71 };
        Map<Long, List<Integer>> patternCache = new HashMap<>();
        Set<Long> solutions = new HashSet<>();
        List<Integer> cur = new ArrayList<>();

        List<Integer> cachedPattern(long n) {
            if (patternCache.containsKey(n))
                return patternCache.get(n);
            List<Integer> p = exponentPattern(n);
            patternCache.put(n, p);
            return p;
        }

        void dfs(int lastExp, java.math.BigInteger minN) {
            long g = gFromPattern(cur, kLimit);
            if (g > kLimit)
                return;

            if (java.math.BigInteger.valueOf(g).compareTo(minN) >= 0) {
                List<Integer> pat = cachedPattern(g);
                if (pat.equals(cur))
                    solutions.add(g);
            }

            int idx = cur.size();
            if (idx >= primes.length)
                return;
            long p = primes[idx];

            java.math.BigInteger pow = java.math.BigInteger.ONE;
            java.math.BigInteger limitBi = java.math.BigInteger.valueOf(kLimit);
            for (int e = 1; e <= lastExp; e++) {
                pow = pow.multiply(java.math.BigInteger.valueOf(p));
                java.math.BigInteger nextMin = minN.multiply(pow);
                if (nextMin.compareTo(limitBi) > 0)
                    break;
                cur.add(e);
                dfs(e, nextMin);
                cur.remove(cur.size() - 1);
            }
        }

        List<Long> run() {
            cur.clear();
            dfs(53, java.math.BigInteger.ONE);
            List<Long> sorted = new ArrayList<>(solutions);
            Collections.sort(sorted);
            return sorted;
        }
    }

    public static String solve() {
        Enumerator en = new Enumerator();
        List<Long> sols = en.run();
        java.math.BigInteger sum = java.math.BigInteger.ZERO;
        for (long x : sols) {
            sum = sum.add(java.math.BigInteger.valueOf(x));
        }
        return sum.toString();
    }

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