import java.util.*;
import java.util.concurrent.*;

public class Euler263 {
    static int isqrt(long n) {
        if (n < 0)
            return 0;
        return (int) Math.sqrt(n);
    }

    static List<Integer> sievePrimes(int limit) {
        if (limit < 2)
            return new ArrayList<>();
        boolean[] isPrime = new boolean[limit + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        for (int p = 2; p <= isqrt(limit); ++p) {
            if (isPrime[p]) {
                for (int i = p * p; i <= limit; i += p) {
                    isPrime[i] = false;
                }
            }
        }
        List<Integer> primes = new ArrayList<>();
        for (int p = 2; p <= limit; ++p) {
            if (isPrime[p])
                primes.add(p);
        }
        return primes;
    }

    static class Factor {
        long prime;
        int exp;

        Factor(long p, int e) {
            prime = p;
            exp = e;
        }
    }

    static List<Factor> factorize(long n, List<Integer> primes) {
        List<Factor> factors = new ArrayList<>();
        long m = n;
        for (int p : primes) {
            if ((long) p * p > m)
                break;
            if (m % p == 0) {
                int exp = 0;
                while (m % p == 0) {
                    m /= p;
                    exp++;
                }
                factors.add(new Factor(p, exp));
            }
        }
        if (m > 1) {
            factors.add(new Factor(m, 1));
        }
        return factors;
    }

    static long sigmaPrimePower(long p, int exp) {
        long s = 1;
        long power = 1;
        for (int i = 0; i < exp; ++i) {
            power *= p;
            s += power;
        }
        return s;
    }

    static boolean isPractical(long n, List<Integer> basePrimes) {
        if (n == 1)
            return true;
        if (n % 2 != 0)
            return false;
        List<Factor> factors = factorize(n, basePrimes);
        if (factors.isEmpty() || factors.get(0).prime != 2)
            return false;
        long sigmaPrefix = sigmaPrimePower(factors.get(0).prime, factors.get(0).exp);
        for (int i = 1; i < factors.size(); ++i) {
            long p = factors.get(i).prime;
            int exp = factors.get(i).exp;
            if (p > sigmaPrefix + 1)
                return false;
            sigmaPrefix *= sigmaPrimePower(p, exp);
        }
        return true;
    }

    static boolean isEngineersParadiseCandidate(long n, List<Integer> basePrimes) {
        if (n < 9)
            return false;
        int[] offsets = { -8, -4, 0, 4, 8 };
        for (int offset : offsets) {
            if (!isPractical(n + offset, basePrimes))
                return false;
        }
        return true;
    }

    static List<Long> sieveSegment(long low, long high, List<Integer> basePrimes) {
        if (high < 2 || low > high)
            return new ArrayList<>();
        long oddLow = Math.max(3, low | 1);
        if (oddLow > high)
            return new ArrayList<>();
        int oddCount = (int) ((high - oddLow) / 2 + 1);
        byte[] isPrime = new byte[oddCount];
        Arrays.fill(isPrime, (byte) 1);

        for (int p : basePrimes) {
            if (p == 2)
                continue;
            if ((long) p * p > high)
                break;
            long start = oddLow;
            long rem = start % p;
            if (rem != 0)
                start += (p - rem);
            if (start < (long) p * p)
                start = (long) p * p;
            if (start % 2 == 0)
                start += p;

            for (long m = start; m <= high; m += 2L * p) {
                int idx = (int) ((m - oddLow) / 2);
                isPrime[idx] = 0;
            }
        }

        List<Long> primes = new ArrayList<>();
        for (int i = 0; i < oddCount; ++i) {
            if (isPrime[i] == 1) {
                primes.add(oddLow + 2L * i);
            }
        }
        return primes;
    }

    public static String solve() {
        long limit = 2000000000L;
        int targetCount = 4;
        long segmentSpan = 8000000L;

        int threads = Math.max(1, Runtime.getRuntime().availableProcessors());
        long primeLimit = limit + 9;
        int root = isqrt(primeLimit) + 1;
        List<Integer> basePrimes = sievePrimes(root);

        List<Long> paradises = new CopyOnWriteArrayList<>();
        List<Long> window = new ArrayList<>();

        java.util.function.Consumer<Long> processPrime = (p) -> {
            window.add(p);
            if (window.size() > 4) {
                window.remove(0);
            }
            if (window.size() != 4)
                return;
            if (window.get(1) - window.get(0) != 6 ||
                    window.get(2) - window.get(1) != 6 ||
                    window.get(3) - window.get(2) != 6) {
                return;
            }

            long n = window.get(0) + 9;
            if (n > limit)
                return;
            if (isEngineersParadiseCandidate(n, basePrimes)) {
                paradises.add(n);
            }
        };

        processPrime.accept(2L);
        long segmentLow = 3;

        ExecutorService executor = Executors.newFixedThreadPool(threads);

        while (segmentLow <= primeLimit && paradises.size() < targetCount) {
            List<long[]> batchRanges = new ArrayList<>();
            for (int t = 0; t < threads; ++t) {
                if (segmentLow > primeLimit)
                    break;
                long high = Math.min(primeLimit, segmentLow + segmentSpan - 1);
                batchRanges.add(new long[] { segmentLow, high });
                segmentLow = high + 1;
            }

            if (batchRanges.size() == 1) {
                List<Long> primes = sieveSegment(batchRanges.get(0)[0], batchRanges.get(0)[1], basePrimes);
                for (long p : primes) {
                    processPrime.accept(p);
                    if (paradises.size() >= targetCount)
                        break;
                }
            } else {
                List<Future<List<Long>>> futures = new ArrayList<>();
                for (long[] range : batchRanges) {
                    futures.add(executor.submit(() -> sieveSegment(range[0], range[1], basePrimes)));
                }

                for (Future<List<Long>> future : futures) {
                    try {
                        List<Long> primes = future.get();
                        for (long p : primes) {
                            processPrime.accept(p);
                            if (paradises.size() >= targetCount)
                                break;
                        }
                    } catch (Exception e) {
                    }
                    if (paradises.size() >= targetCount)
                        break;
                }
            }
        }
        executor.shutdown();

        long sum = 0;
        for (long p : paradises)
            sum += p;
        return String.valueOf(sum);
    }

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