import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Euler256 {
    static boolean isTatamiTileable(int a, int b) {
        if (a > b) {
            int temp = a;
            a = b;
            b = temp;
        }
        if (((long) a * b) % 2 != 0)
            return false;
        long groups = (b + a / 2) / a;
        long dist = Math.abs(a * groups - b);
        return !(dist > groups + 1);
    }

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

        for (int i = 2; (long) i * i <= n; ++i) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; ++i) {
            if (isPrime[i])
                primes.add(i);
        }
        return primes;
    }

    static class Factor {
        int p, e;

        Factor(int p, int e) {
            this.p = p;
            this.e = e;
        }
    }

    static int countTatamiFreeRooms(int s, List<Integer> primes) {
        List<Factor> factors = new ArrayList<>();
        int x = s;
        for (int p : primes) {
            if ((long) p * p > x)
                break;
            if (x % p != 0)
                continue;
            int e = 0;
            while (x % p == 0) {
                x /= p;
                e++;
            }
            factors.add(new Factor(p, e));
        }
        if (x > 1) {
            factors.add(new Factor(x, 1));
        }

        int root = (int) Math.sqrt(s);
        int[] count = new int[] { 0 };

        dfs(0, 1, factors, root, s, count);
        return count[0];
    }

    static void dfs(int idx, long current, List<Factor> factors, int root, int s, int[] count) {
        if (idx == factors.size()) {
            if (current <= root) {
                int a = (int) current;
                int b = s / a;
                if (!isTatamiTileable(a, b)) {
                    count[0]++;
                }
            }
            return;
        }

        Factor f = factors.get(idx);
        long val = current;
        for (int i = 0; i <= f.e; ++i) {
            if (val > root)
                break;
            dfs(idx + 1, val, factors, root, s, count);
            val *= f.p;
        }
    }

    public static String solve() {
        int target = 200;
        int step = 55440;
        int initialLimit = 2000000;
        int start = Math.max(step, ((initialLimit + step - 1) / step) * step);
        int fastCap = 2000000000;

        List<Integer> primes = buildPrimesSimple((int) Math.sqrt(fastCap) + 1);

        int threads = Math.max(1, Runtime.getRuntime().availableProcessors());
        ExecutorService executor = Executors.newFixedThreadPool(threads);
        AtomicInteger nextS = new AtomicInteger(start);
        AtomicInteger best = new AtomicInteger(Integer.MAX_VALUE);

        List<Future<?>> futures = new ArrayList<>();

        for (int t = 0; t < threads; ++t) {
            futures.add(executor.submit(() -> {
                while (true) {
                    int s = nextS.getAndAdd(step);
                    if (s > fastCap)
                        break;
                    if (s >= best.get())
                        continue;
                    if (s % 2 != 0)
                        continue;

                    if (countTatamiFreeRooms(s, primes) == target) {
                        int current = best.get();
                        while (s < current && !best.compareAndSet(current, s)) {
                            current = best.get();
                        }
                    }
                }
            }));
        }

        for (Future<?> f : futures) {
            try {
                f.get();
            } catch (Exception e) {
            }
        }
        executor.shutdown();

        if (best.get() != Integer.MAX_VALUE) {
            return String.valueOf(best.get());
        }
        return "-1";
    }

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