class Euler26 {

    private static class Options {
        int limit = 1000;
        boolean runCheckpoints = true;
    }

    private static boolean parseIntAfterPrefix(String arg, String prefix, Options options) {
        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');
        }

        options.limit = parsed;
        return true;
    }

    private static boolean parseArguments(String[] args, Options options) {
        for (String arg : args) {
            if (arg.equals("--skip-checkpoints")) {
                options.runCheckpoints = false;
                continue;
            }
            if (parseIntAfterPrefix(arg, "--limit=", options)) {
                continue;
            }

            System.err.println("Unknown argument: " + arg);
            return false;
        }

        return options.limit > 2;
    }

    private static int recurringCycleLength(int denominator) {
        int[] firstSeen = new int[denominator];
        for (int i = 0; i < denominator; i++) {
            firstSeen[i] = -1;
        }

        int remainder = 1 % denominator;
        int position = 0;

        while (remainder != 0 && firstSeen[remainder] == -1) {
            firstSeen[remainder] = position;
            remainder = (remainder * 10) % denominator;
            position++;
        }

        if (remainder == 0) {
            return 0;
        }
        return position - firstSeen[remainder];
    }

    private static int solve(int limit) {
        int bestD = 2;
        int bestLen = 0;

        for (int d = 2; d < limit; d++) {
            int cycle = recurringCycleLength(d);
            if (cycle > bestLen) {
                bestLen = cycle;
                bestD = d;
            }
        }

        return bestD;
    }

    private static boolean runCheckpoints() {
        if (recurringCycleLength(7) != 6) {
            System.err.println("Checkpoint failed for denominator=7");
            return false;
        }
        if (solve(10) != 7) {
            System.err.println("Checkpoint failed for limit=10");
            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.limit));
    }
}