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

public class Euler545 {
    static final long kDenTarget = 20010L;
    static final long kL = 308L;

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

    static boolean isPrimeU64(long x, List<Integer> primes) {
        if (x < 2)
            return false;
        for (int p : primes) {
            long pp = p;
            if (pp * pp > x)
                break;
            if (x % pp == 0)
                return x == pp;
        }
        return true;
    }

    static int modInv(int a, int mod) {
        int t = 0, newt = 1;
        int r = mod, newr = a;
        while (newr != 0) {
            int q = r / newr;
            int tmpT = t - q * newt;
            t = newt;
            newt = tmpT;
            int tmpR = r - q * newr;
            r = newr;
            newr = tmpR;
        }
        if (r != 1)
            return 0;
        if (t < 0)
            t += mod;
        return t;
    }

    static long bernoulliDenominatorEvenK(long k, List<Integer> primesSmall) {
        List<long[]> fac = new ArrayList<>();
        long x = k;
        for (int p : primesSmall) {
            long pp = p;
            if (pp * pp > x)
                break;
            if (x % pp == 0) {
                long e = 0;
                while (x % pp == 0) {
                    x /= pp;
                    e++;
                }
                fac.add(new long[] { pp, e });
            }
        }
        if (x > 1)
            fac.add(new long[] { x, 1 });

        List<Long> divs = new ArrayList<>();
        divs.add(1L);
        for (long[] pair : fac) {
            long p = pair[0];
            long e = pair[1];
            int cur = divs.size();
            long pe = 1;
            for (int i = 1; i <= e; i++) {
                pe *= p;
                for (int j = 0; j < cur; j++) {
                    divs.add(divs.get(j) * pe);
                }
            }
        }

        long den = 1;
        for (long d : divs) {
            long cand = d + 1;
            if (isPrimeU64(cand, primesSmall)) {
                den *= cand;
            }
        }
        return den;
    }

    static long bruteF10() {
        int lim = 200000;
        List<Integer> primes = sievePrimes((int) Math.sqrt(lim + 1) + 5);
        int found = 0;
        for (long m = 1; kL * m <= lim; m++) {
            long k = kL * m;
            long den = bernoulliDenominatorEvenK(k, primes);
            if (den == kDenTarget) {
                found++;
                if (found == 10)
                    return k;
            }
        }
        return 0;
    }

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

    static long kthMultiplierWithDen(int M, int kth) {
        long pmax = kL * M + 1L;
        int qmax = (int) Math.sqrt(pmax) + 2;
        List<Integer> primes = sievePrimes(qmax);

        boolean[] forbidden = new boolean[M + 1];

        int[] gs = { 2, 4, 14, 22, 28, 44, 154, 308 };
        for (int g : gs) {
            long maxpG = (long) g * M + 1L;
            long qlim = (long) Math.sqrt(maxpG) + 1L;

            boolean[] isPrimeU = new boolean[M + 1];
            Arrays.fill(isPrimeU, true);
            isPrimeU[0] = false;

            for (int q : primes) {
                if (q > qlim)
                    break;
                if (g % q == 0)
                    continue;

                int a = g % q;
                int inv = modInv(a, q);
                int u0 = (int) (((long) (q - 1) * inv) % q);

                long uStart = ((long) q * q - 1L + g - 1L) / g;
                long u = u0;
                if (u < uStart) {
                    u += ((uStart - u + q - 1L) / q) * q;
                }

                if (u <= M) {
                    int step = q;
                    for (int ui = (int) u; ui <= M; ui += step) {
                        isPrimeU[ui] = false;
                    }
                }
            }

            long div = kL / g;
            for (int u = 1; u <= M; u++) {
                if (!isPrimeU[u])
                    continue;
                long p = (long) g * u + 1L;
                if (p == 2 || p == 3 || p == 5 || p == 23 || p == 29)
                    continue;
                long r = u / gcd(u, div);
                if (r <= M) {
                    forbidden[(int) r] = true;
                }
            }
        }

        boolean[] invalid = new boolean[M + 1];
        for (int r = 2; r <= M; r++) {
            if (!forbidden[r])
                continue;
            for (int x = r; x <= M; x += r) {
                invalid[x] = true;
            }
        }

        int cnt = 0;
        for (int m = 1; m <= M; m++) {
            if (!invalid[m]) {
                cnt++;
                if (cnt == kth)
                    return m;
            }
        }
        return 0;
    }

    static long solveF1e5() {
        int kth = 100000;
        int M = 4000000;
        while (true) {
            long m = kthMultiplierWithDen(M, kth);
            if (m != 0)
                return kL * m;
            M *= 2;
        }
    }

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

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