import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;

public class Euler874 {

    static ArrayList<Integer> firstPrimes(int count) {
        if (count <= 0)
            return new ArrayList<>();
        int limit;
        if (count < 6) {
            limit = 15;
        } else {
            double n = count;
            limit = (int) (n * (Math.log(n) + Math.log(Math.log(n)))) + 32;
        }

        while (true) {
            boolean[] isPrime = new boolean[limit + 1];
            Arrays.fill(isPrime, true);
            isPrime[0] = false;
            isPrime[1] = false;

            for (int i = 2; (long) i * i <= limit; ++i) {
                if (!isPrime[i])
                    continue;
                for (int j = i * i; j <= limit; j += i)
                    isPrime[j] = false;
            }

            ArrayList<Integer> primes = new ArrayList<>(count);
            for (int x = 2; x <= limit && primes.size() < count; ++x) {
                if (isPrime[x])
                    primes.add(x);
            }
            if (primes.size() >= count)
                return primes;
            limit *= 2;
        }
    }

    static class State implements Comparable<State> {
        long dist;
        int u;

        State(long dist, int u) {
            this.dist = dist;
            this.u = u;
        }

        @Override
        public int compareTo(State o) {
            return Long.compare(this.dist, o.dist);
        }
    }

    static long maximalScoreFast(int k, long n, ArrayList<Integer> primes) {
        int top = primes.get(k - 1);
        int[] loss = new int[k];
        for (int d = 1; d < k; ++d) {
            loss[d] = top - primes.get(k - 1 - d);
        }

        int residue = (int) ((k - (n % k)) % k);

        long INF = Long.MAX_VALUE / 4;
        long[] dist = new long[k];
        Arrays.fill(dist, INF);
        PriorityQueue<State> pq = new PriorityQueue<>();

        dist[0] = 0;
        pq.add(new State(0, 0));

        while (!pq.isEmpty()) {
            State st = pq.poll();
            long du = st.dist;
            int u = st.u;

            if (du != dist[u])
                continue;

            for (int d = 1; d < k; ++d) {
                int v = u + d;
                if (v >= k)
                    v -= k;
                long nd = du + loss[d];
                if (nd < dist[v]) {
                    dist[v] = nd;
                    pq.add(new State(nd, v));
                }
            }
        }

        return n * top - dist[residue];
    }

    public static String solve() {
        int k = 7000;
        ArrayList<Integer> primes = firstPrimes(k + 1);
        long n = primes.get(k);
        return Long.toString(maximalScoreFast(k, n, primes));
    }

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