import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Euler526 {

    static final long L = 10000000000000000L;
    static final int K = 10000000;
    static final long MOD = 16L * 9L * 5L * 7L * 11L * 13L;
    static final long START = (L / MOD) * MOD;
    static final long[] D = { 1, 6, 1, 4, 315, 2, 1, 24, 1 };

    static long egcdInv(long a, long mod) {
        long t = 0, nt = 1;
        long r = mod, nr = a % mod;
        while (nr != 0) {
            long q = r / nr;
            long tt = t - q * nt;
            t = nt;
            nt = tt;
            long rr = r - q * nr;
            r = nr;
            nr = rr;
        }
        if (r != 1)
            return 0;
        if (t < 0)
            t += mod;
        return t;
    }

    static long crtTwo(long m1, long r1, long m2, long r2) {
        long inv = egcdInv(m1, m2);
        long delta = (r2 >= r1 % m2) ? (r2 - (r1 % m2)) : (r2 + m2 - (r1 % m2));
        // Use exact modulo for delta * inv
        long t = 0;
        long modDiv = m2;
        // BigInteger equivalent without objects, using modulo properties:
        long p_val = (delta % modDiv) * (inv % modDiv); // may exceed long if modDiv > 3e9, but m2 <= 13 here
        t = p_val % modDiv;
        return r1 + m1 * t;
    }

    static List<Long> buildResidues() {
        List<Long> rems = new ArrayList<>(Arrays.asList(1L, 7L));
        long prod = 16;

        for (int i = 0; i < rems.size(); i++)
            rems.set(i, crtTwo(prod, rems.get(i), 9, 5));
        prod *= 9;

        for (int i = 0; i < rems.size(); i++)
            rems.set(i, crtTwo(prod, rems.get(i), 5, 1));
        prod *= 5;

        for (int i = 0; i < rems.size(); i++)
            rems.set(i, crtTwo(prod, rems.get(i), 7, 3));
        prod *= 7;

        List<Long> nxt11 = new ArrayList<>();
        for (long r : rems) {
            nxt11.add(crtTwo(prod, r, 11, 1));
            nxt11.add(crtTwo(prod, r, 11, 2));
        }
        rems = nxt11;
        prod *= 11;

        List<Long> nxt13 = new ArrayList<>();
        for (long r : rems) {
            nxt13.add(crtTwo(prod, r, 13, 1));
            nxt13.add(crtTwo(prod, r, 13, 2));
            nxt13.add(crtTwo(prod, r, 13, 3));
            nxt13.add(crtTwo(prod, r, 13, 4));
        }
        rems = nxt13;

        Collections.sort(rems);
        return rems.stream().distinct().collect(Collectors.toList());
    }

    static class PrimeInv {
        int p;
        int inv;

        PrimeInv(int p, int inv) {
            this.p = p;
            this.inv = inv;
        }
    }

    static List<PrimeInv> buildPrimesAndInverses() {
        int LIM = 100000000;
        byte[] isPrime = new byte[LIM];
        Arrays.fill(isPrime, (byte) 1);
        isPrime[0] = isPrime[1] = 0;
        for (int i = 2; (long) i * i < LIM; i++) {
            if (isPrime[i] == 1) {
                for (int j = i * i; j < LIM; j += i)
                    isPrime[j] = 0;
            }
        }

        List<PrimeInv> pinv = new ArrayList<>(6000000);
        for (int p = 17; p < LIM; p++) {
            if (isPrime[p] == 1) {
                if (p == 2 || p == 3 || p == 5 || p == 7 || p == 11 || p == 13)
                    continue;
                long inv = egcdInv(MOD % p, p);
                pinv.add(new PrimeInv(p, (int) inv));
            }
        }
        return pinv;
    }

    public static void main(String[] args) {
        List<Long> rems = buildResidues();
        List<PrimeInv> pinv = buildPrimesAndInverses();

        long bestSum = rems.parallelStream().mapToLong(rem -> {
            byte[] flag = new byte[K];
            Arrays.fill(flag, (byte) 255);

            for (PrimeInv pi : pinv) {
                long p = pi.p;
                long inv = pi.inv;
                long base = ((START + rem) % p);
                base = (base * inv) % p;
                for (int i = 0; i < 9; i++) {
                    for (long k = base; k < K; k += p)
                        flag[(int) k] = 0;
                    base += inv;
                    if (base >= p)
                        base -= p;
                }
            }

            long localBest = 0;
            for (int i = 0; i < K; i++) {
                if (flag[i] != 0) {
                    long cand = START + rem - MOD * i;
                    long sum = 0;
                    for (int j = 0; j < 9; j++)
                        sum += (cand + j) / D[j];
                    if (sum > localBest)
                        localBest = sum;
                }
            }
            return localBest;
        }).max().orElse(0);

        System.out.println(bestSum);
    }
}