import java.util.*;

public class Euler51 {
    private static class Options {
        int familySize = 8;
        int sieveLimit = 2000000;
        boolean runCheckpoints = true;
    }

    private static boolean parseIntAfterPrefix(String arg, String prefix, int[] value) {
        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');
        }

        value[0] = parsed;
        return true;
    }

    private static boolean parseArguments(String[] args, Options options) {
        for (String arg : args) {
            if (arg.equals("--skip-checkpoints")) {
                options.runCheckpoints = false;
                continue;
            }
            int[] temp = new int[1];
            if (parseIntAfterPrefix(arg, "--family-size=", temp)) {
                options.familySize = temp[0];
                continue;
            }
            if (parseIntAfterPrefix(arg, "--sieve-limit=", temp)) {
                options.sieveLimit = temp[0];
                continue;
            }

            System.err.println("Unknown argument: " + arg);
            return false;
        }
        return options.familySize >= 2 && options.sieveLimit >= 100;
    }

    private static boolean[] sieve(int limit) {
        boolean[] prime = new boolean[limit + 1];
        Arrays.fill(prime, true);
        prime[0] = false;
        prime[1] = false;

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

        return prime;
    }

    private static boolean isPrimeTrial(long n) {
        if (n < 2) {
            return false;
        }
        if ((n % 2) == 0) {
            return n == 2;
        }
        for (long p = 3; p <= n / p; p += 2) {
            if ((n % p) == 0) {
                return false;
            }
        }
        return true;
    }

    private static boolean isPrimeFast(int n, boolean[] sieveTable) {
        if (n < sieveTable.length) {
            return sieveTable[n];
        }
        return isPrimeTrial(n);
    }

    private static int solve(int familySize, int sieveLimit) {
        boolean[] sieveTable = sieve(sieveLimit);

        for (int p = 11; p <= sieveLimit; ++p) {
            if (!sieveTable[p]) {
                continue;
            }

            String base = String.valueOf(p);

            for (char targetDigit = '0'; targetDigit <= '9'; ++targetDigit) {
                List<Integer> positions = new ArrayList<>();
                for (int i = 0; i < base.length(); ++i) {
                    if (base.charAt(i) == targetDigit) {
                        positions.add(i);
                    }
                }
                if (positions.isEmpty()) {
                    continue;
                }

                int subsets = 1 << positions.size();
                for (int mask = 1; mask < subsets; ++mask) {
                    int familyCount = 0;
                    int smallestFamilyPrime = Integer.MAX_VALUE;

                    for (char replacement = '0'; replacement <= '9'; ++replacement) {
                        char[] candidateArray = base.toCharArray();
                        for (int bit = 0; bit < positions.size(); ++bit) {
                            if (((mask >> bit) & 1) != 0) {
                                candidateArray[positions.get(bit)] = replacement;
                            }
                        }
                        String candidateStr = new String(candidateArray);

                        if (candidateStr.charAt(0) == '0') {
                            continue;
                        }

                        int value = Integer.parseInt(candidateStr);
                        if (isPrimeFast(value, sieveTable)) {
                            ++familyCount;
                            if (value < smallestFamilyPrime) {
                                smallestFamilyPrime = value;
                            }
                        }
                    }

                    if (familyCount >= familySize && smallestFamilyPrime == p) {
                        return p;
                    }
                }
            }
        }

        return 0;
    }

    private static boolean runCheckpoints() {
        if (solve(6, 100000) != 13) {
            System.err.println("Checkpoint failed for family size 6");
            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.familySize, options.sieveLimit));
    }
}