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

public class Euler357 {
    static boolean[] sievePrimes(int n) {
        boolean[] isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);
        if (n >= 0)
            isPrime[0] = false;
        if (n >= 1)
            isPrime[1] = false;
        for (int i = 4; i <= n; i += 2)
            isPrime[i] = false;
        for (int p = 3; (long) p * p <= n; p += 2) {
            if (!isPrime[p])
                continue;
            for (long j = (long) p * p; j <= n; j += 2L * p) {
                isPrime[(int) j] = false;
            }
        }
        return isPrime;
    }

    static int[] buildSpfOdd(int limit) {
        int[] spf = new int[limit / 2 + 1];
        int root = (int) Math.sqrt(limit);
        for (int p = 3; p <= root; p += 2) {
            if (spf[p / 2] != 0)
                continue;
            long step = 2L * p;
            long start = (long) p * p;
            for (long j = start; j <= limit; j += step) {
                if (spf[(int) (j / 2)] == 0)
                    spf[(int) (j / 2)] = p;
            }
        }
        return spf;
    }

    static boolean checkN(int n, boolean[] isPrime, int[] spfOdd) {
        if (n == 1)
            return true;
        if ((n & 1) != 0)
            return false;
        if ((n & 3) == 0)
            return false;

        int m = n / 2;
        List<Integer> factors = new ArrayList<>();
        factors.add(2);
        while (m > 1) {
            int p = spfOdd[m / 2];
            if (p == 0)
                p = m;
            factors.add(p);
            m /= p;
            if (m % p == 0)
                return false;
        }

        List<Long> divisors = new ArrayList<>();
        divisors.add(1L);
        for (int p : factors) {
            int size = divisors.size();
            for (int i = 0; i < size; i++) {
                divisors.add(divisors.get(i) * p);
            }
        }

        for (long d : divisors) {
            long q = (long) n / d;
            if (d > q)
                continue;
            if (!isPrime[(int) (d + q)])
                return false;
        }
        return true;
    }

    public static String solve() {
        int limit = 100000000;
        int maxPrime = limit + 1;
        boolean[] isPrime = sievePrimes(maxPrime);

        List<Integer> primes = new ArrayList<>();
        if (maxPrime >= 2 && isPrime[2])
            primes.add(2);
        for (int i = 3; i <= maxPrime; i += 2) {
            if (isPrime[i])
                primes.add(i);
        }

        int half = limit / 2;
        int[] spfOdd = buildSpfOdd(half);

        int threads = Runtime.getRuntime().availableProcessors();
        if (threads <= 0)
            threads = 1;
        if (threads > primes.size())
            threads = primes.size();

        ExecutorService executor = Executors.newFixedThreadPool(threads);
        List<Future<Long>> futures = new ArrayList<>();

        int chunk = (primes.size() + threads - 1) / threads;
        for (int t = 0; t < threads; t++) {
            final int start = t * chunk;
            final int end = Math.min(primes.size(), start + chunk);
            futures.add(executor.submit(() -> {
                long local = 0;
                for (int i = start; i < end; i++) {
                    int n = primes.get(i) - 1;
                    if (n > limit)
                        continue;
                    if (checkN(n, isPrime, spfOdd)) {
                        local += n;
                    }
                }
                return local;
            }));
        }

        long total = 0;
        try {
            for (Future<Long> f : futures) {
                total += f.get();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        executor.shutdown();

        return String.valueOf(total);
    }

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