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

public class Euler896 {

    static boolean augment(int u, long[] edges, int[] matchRight, boolean[] seen) {
        long mask = edges[u];
        while (mask != 0) {
            long lsb = mask & -mask;
            int v = Long.numberOfTrailingZeros(lsb);
            mask &= (mask - 1);
            if (seen[v])
                continue;
            seen[v] = true;
            if (matchRight[v] == -1 || augment(matchRight[v], edges, matchRight, seen)) {
                matchRight[v] = u;
                return true;
            }
        }
        return false;
    }

    static boolean hasPerfectMatching(long[] masks, int n) {
        Integer[] order = new Integer[n];
        for (int i = 0; i < n; i++)
            order[i] = i;
        Arrays.sort(order, Comparator.comparingInt(a -> Long.bitCount(masks[a])));

        long[] edges = new long[n];
        for (int i = 0; i < n; ++i) {
            edges[i] = masks[order[i]];
            if (edges[i] == 0)
                return false;
        }

        int[] matchRight = new int[n];
        Arrays.fill(matchRight, -1);
        for (int u = 0; u < n; ++u) {
            boolean[] seen = new boolean[n];
            if (!augment(u, edges, matchRight, seen)) {
                return false;
            }
        }
        return true;
    }

    static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static long lcmUpto(int n) {
        long l = 1;
        for (int i = 1; i <= n; ++i) {
            l = (l * i) / gcd(l, i);
        }
        return l;
    }

    static List<Integer> primePowersUpto(int n) {
        List<Integer> factors = new ArrayList<>();
        boolean[] isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);
        if (n >= 0)
            isPrime[0] = false;
        if (n >= 1)
            isPrime[1] = false;

        for (int p = 2; p * p <= n; ++p) {
            if (!isPrime[p])
                continue;
            for (int q = p * p; q <= n; q += p) {
                isPrime[q] = false;
            }
        }

        for (int p = 2; p <= n; ++p) {
            if (!isPrime[p])
                continue;
            int pp = 1;
            while (pp <= n / p)
                pp *= p;
            factors.add(pp);
        }
        return factors;
    }

    static long[][][] buildMaskCache(int n) {
        long[][][] cache = new long[n + 1][n + 1][];
        for (int i = 1; i <= n; ++i) {
            for (int d = 1; d <= i; ++d) {
                if (i % d != 0)
                    continue;
                cache[i][d] = new long[d];
                for (int r = 0; r < d; ++r) {
                    long mask = 0;
                    for (int o = 0; o < n; ++o) {
                        if ((r + o) % d == 0) {
                            mask |= (1L << o);
                        }
                    }
                    cache[i][d][r] = mask;
                }
            }
        }
        return cache;
    }

    static boolean relaxedFeasible(int n, long modulus, long residue, long[][][] cache) {
        long[] masks = new long[n];
        for (int i = 1; i <= n; ++i) {
            int d = (int) gcd(modulus, i);
            int r = (int) (residue % d);
            masks[i - 1] = cache[i][d][r];
        }
        return hasPerfectMatching(masks, n);
    }

    static List<Long> periodStarts(int n) {
        List<Integer> factors = primePowersUpto(n);
        long[][][] cache = buildMaskCache(n);

        List<Long> residues = new ArrayList<>();
        residues.add(0L);
        long modulus = 1;

        for (int factor : factors) {
            long nextModulus = modulus * factor;
            List<Long> next = new ArrayList<>();
            for (long c : residues) {
                for (int k = 0; k < factor; ++k) {
                    long candidate = c + k * modulus;
                    if (relaxedFeasible(n, nextModulus, candidate, cache)) {
                        next.add(candidate);
                    }
                }
            }
            residues = next;
            modulus = nextModulus;
        }

        long L = lcmUpto(n);
        List<Long> starts = new ArrayList<>();
        for (long r : residues) {
            starts.add(r == 0 ? L : r);
        }
        Collections.sort(starts);

        List<Long> uniqueStarts = new ArrayList<>();
        for (long start : starts) {
            if (uniqueStarts.isEmpty() || !uniqueStarts.get(uniqueStarts.size() - 1).equals(start)) {
                uniqueStarts.add(start);
            }
        }
        return uniqueStarts;
    }

    static long nthDivisibleRangeStart(int n, long nth) {
        long L = lcmUpto(n);
        List<Long> starts = periodStarts(n);

        long per = starts.size();
        long block = (nth - 1) / per;
        int idx = (int) ((nth - 1) % per);
        return block * L + starts.get(idx);
    }

    public static String solve() {
        return Long.toString(nthDivisibleRangeStart(36, 36));
    }

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