class Euler44 {

    private static class Options {
        int maxIndex = 5000;
        boolean runCheckpoints = true;
    }

    private static long pentagonal(long n) {
        return n * (3 * n - 1) / 2;
    }

    private static boolean isPentagonal(long x) {
        if (x <= 0) {
            return false;
        }
        double disc = 1.0 + 24.0 * x;
        double root = Math.sqrt(disc);
        double n = (1.0 + root) / 6.0;
        long k = Math.round(n);
        return pentagonal(k) == x;
    }

    private static long solve(int maxIndex) {
        long[] p = new long[maxIndex + 1];
        for (int i = 1; i <= maxIndex; ++i) {
            p[i] = pentagonal(i);
        }

        long best = Long.MAX_VALUE;

        for (int j = 2; j <= maxIndex; ++j) {
            for (int k = j - 1; k >= 1; --k) {
                long diff = p[j] - p[k];
                if (diff >= best) {
                    break;
                }
                long sum = p[j] + p[k];
                if (isPentagonal(diff) && isPentagonal(sum)) {
                    best = diff;
                }
            }
        }

        return best;
    }

    private static boolean runCheckpoints() {
        if (!isPentagonal(12) || !isPentagonal(35) || isPentagonal(36)) {
            System.err.println("Checkpoint failed for pentagonal predicate");
            return false;
        }
        if (!isPentagonal(40755)) {
            System.err.println("Checkpoint failed for known pentagonal value");
            return false;
        }
        return true;
    }

    private static boolean parseIntAfterPrefix(String arg, String prefix, Options options) {
        if (!arg.startsWith(prefix)) {
            return false;
        }
        String tail = arg.substring(prefix.length());
        if (tail.isEmpty()) {
            return false;
        }

        int parsed = 0;
        for (int i = 0; i < tail.length(); ++i) {
            char c = tail.charAt(i);
            if (c < '0' || c > '9') {
                return false;
            }
            parsed = parsed * 10 + (c - '0');
        }
        if (prefix.equals("--max-index=")) {
            options.maxIndex = parsed;
        }
        return true;
    }

    private static boolean parseArguments(String[] args, Options options) {
        for (String arg : args) {
            if (arg.equals("--skip-checkpoints")) {
                options.runCheckpoints = false;
                continue;
            }
            if (parseIntAfterPrefix(arg, "--max-index=", options)) {
                continue;
            }

            System.err.println("Unknown argument: " + arg);
            return false;
        }

        return options.maxIndex >= 10;
    }

    public static void main(String[] args) {
        Options options = new Options();
        if (!parseArguments(args, options)) {
            System.exit(1);
        }
        if (options.runCheckpoints && !runCheckpoints()) {
            System.exit(2);
        }

        System.out.println(solve(options.maxIndex));
    }
}