import java.util.ArrayList;
import java.util.List;

public class Euler705 {
    static final long kMod = 1000000007L;

    static class DigitInfo {
        int count = 0;
        int[] divisors = new int[4];
        boolean[] has = new boolean[10];
    }

    static DigitInfo[] buildDigitInfo() {
        DigitInfo[] info = new DigitInfo[10];
        for (int d = 1; d <= 9; ++d) {
            DigitInfo di = new DigitInfo();
            for (int x = 1; x <= d; ++x) {
                if (d % x == 0) {
                    di.divisors[di.count] = x;
                    di.has[x] = true;
                    di.count++;
                }
            }
            info[d] = di;
        }
        return info;
    }

    public static String solve() {
        int N = 100000000;
        DigitInfo[] info = buildDigitInfo();

        long[] state = new long[12];
        // state[0] = total_sequences
        // state[1] = total_inversions
        // state[2..11] = value_occurrence_sum[0..9]
        state[0] = 1;

        byte[] composite = new byte[N];
        int root = (int) Math.sqrt(N) + 1;

        for (int p = 3; p <= root; p += 2) {
            if (composite[p] != 0)
                continue;
            if ((long) p * p >= N)
                break;
            int step = 2 * p;
            for (int x = p * p; x < N; x += step) {
                composite[x] = 1;
            }
        }

        processDigit(2, info, state);

        int[] buf = new int[10];
        for (int p = 3; p < N; p += 2) {
            if (composite[p] != 0)
                continue;
            int x = p;
            int len = 0;
            while (x > 0) {
                buf[len++] = x % 10;
                x /= 10;
            }
            for (int i = len - 1; i >= 0; --i) {
                processDigit(buf[i], info, state);
            }
        }

        return Long.toString(state[1]);
    }

    static void processDigit(int digit, DigitInfo[] info, long[] state) {
        if (digit == 0) {
            return;
        }

        DigitInfo di = info[digit];
        int s = di.count;

        long[] gt = new long[10];
        long running = 0;
        for (int t = 9; t >= 1; --t) {
            gt[t] = running;
            running += state[2 + t];
            if (running >= kMod) {
                running -= kMod;
            }
        }

        long cross = 0;
        for (int i = 0; i < s; ++i) {
            int v = di.divisors[i];
            cross += gt[v];
            if (cross >= kMod) {
                cross -= kMod;
            }
        }

        state[1] = (state[1] * s % kMod + cross) % kMod;

        long[] nextOccurrence = new long[10];
        for (int t = 1; t <= 9; ++t) {
            long v = state[2 + t] * s % kMod;
            if (di.has[t]) {
                v += state[0];
                if (v >= kMod) {
                    v -= kMod;
                }
            }
            nextOccurrence[t] = v;
        }

        System.arraycopy(nextOccurrence, 1, state, 3, 9);
        state[0] = state[0] * s % kMod;
    }

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