class Euler50 {
    private static class Options {
        int limit = 1000000;
        boolean runCheckpoints = 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');
        }
        options.limit = 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, "--limit=", options)) {
                continue;
            }
            System.err.println("Unknown argument: " + arg);
            return false;
        }
        return options.limit >= 3;
    }

    private static boolean[] sieve(int limit) {
        boolean[] isPrime = new boolean[limit + 1];
        for (int i = 2; i <= limit; i++) {
            isPrime[i] = true;
        }
        isPrime[0] = false;
        isPrime[1] = false;

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

        return isPrime;
    }

    private static int solve(int limit) {
        boolean[] isPrime = sieve(limit - 1);

        int[] primes = new int[limit];
        int primeCount = 0;
        for (int n = 2; n < limit; n++) {
            if (isPrime[n]) {
                primes[primeCount++] = n;
            }
        }

        long[] prefix = new long[primeCount + 1];
        for (int i = 0; i < primeCount; i++) {
            prefix[i + 1] = prefix[i] + primes[i];
        }

        int bestPrime = 0;
        int bestLen = 0;

        for (int i = 0; i < primeCount; i++) {
            for (int j = i + bestLen + 1; j <= primeCount; j++) {
                long sum = prefix[j] - prefix[i];
                if (sum >= limit) {
                    break;
                }
                if (sum < isPrime.length && isPrime[(int)sum]) {
                    bestLen = j - i;
                    bestPrime = (int)sum;
                }
            }
        }

        return bestPrime;
    }

    private static boolean runCheckpoints() {
        if (solve(100) != 41) {
            System.err.println("Checkpoint failed for limit=100");
            return false;
        }
        if (solve(1000) != 953) {
            System.err.println("Checkpoint failed for limit=1000");
            return false;
        }
        return true;
    }

    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.limit));
    }
}