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

public class Euler425 {

    static boolean[] sievePrimes(int n) {
        boolean[] isPrime = new boolean[n + 1];
        if (n >= 2) {
            Arrays.fill(isPrime, 2, n + 1, true);
        }
        for (int p = 2; p * p <= n; p++) {
            if (isPrime[p]) {
                for (int q = p * p; q <= n; q += p) {
                    isPrime[q] = false;
                }
            }
        }
        return isPrime;
    }

    static class Node implements Comparable<Node> {
        int cost;
        int p;

        Node(int cost, int p) {
            this.cost = cost;
            this.p = p;
        }

        @Override
        public int compareTo(Node o) {
            if (this.cost != o.cost) {
                return Integer.compare(this.cost, o.cost);
            }
            return Integer.compare(this.p, o.p);
        }
    }

    static String solveS(int limit) {
        boolean[] isPrime = sievePrimes(limit);
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= limit; i++) {
            if (isPrime[i])
                primes.add(i);
        }

        List<Integer> pow10 = new ArrayList<>();
        pow10.add(1);
        while (pow10.get(pow10.size() - 1) <= limit / 10) {
            pow10.add(pow10.get(pow10.size() - 1) * 10);
        }

        int[] best = new int[limit + 1];
        Arrays.fill(best, Integer.MAX_VALUE);
        if (limit < 2 || !isPrime[2])
            return "0";

        PriorityQueue<Node> pq = new PriorityQueue<>();
        best[2] = 2;
        pq.add(new Node(2, 2));

        while (!pq.isEmpty()) {
            Node node = pq.poll();
            int cost = node.cost;
            int p = node.p;
            if (cost != best[p])
                continue;

            int len = 1;
            while (len < pow10.size() && p >= pow10.get(len)) {
                len++;
            }

            for (int pos = 0; pos < len; pos++) {
                int place = pow10.get(pos);
                int oldDigit = (p / place) % 10;
                for (int d = 0; d <= 9; d++) {
                    if (d == oldDigit)
                        continue;
                    if (pos == len - 1 && d == 0)
                        continue;
                    int v = p + (d - oldDigit) * place;

                    if (v >= 2 && v <= limit && isPrime[v]) {
                        int cand = Math.max(cost, v);
                        if (cand < best[v]) {
                            best[v] = cand;
                            pq.add(new Node(cand, v));
                        }
                    }
                }
            }

            if (len > 1) {
                int v = p % pow10.get(len - 1);
                if (v >= 2 && v <= limit && isPrime[v]) {
                    int cand = Math.max(cost, v);
                    if (cand < best[v]) {
                        best[v] = cand;
                        pq.add(new Node(cand, v));
                    }
                }
            }

            if (len < pow10.size()) {
                int base = pow10.get(len);
                for (int d = 1; d <= 9; d++) {
                    long vl = (long) d * base + p;
                    if (vl <= limit) {
                        int v = (int) vl;
                        if (v >= 2 && isPrime[v]) {
                            int cand = Math.max(cost, v);
                            if (cand < best[v]) {
                                best[v] = cand;
                                pq.add(new Node(cand, v));
                            }
                        }
                    }
                }
            }
        }

        long ans = 0;
        for (int p : primes) {
            if (best[p] > p) {
                ans += p;
            }
        }
        return Long.toString(ans);
    }

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