public class Euler603 {
    static final int MOD = 1000000007;

    static int addmod(int a, int b) {
        int s = a + b;
        if (s >= MOD)
            s -= MOD;
        return s;
    }

    static int mulmod(long a, long b) {
        return (int) ((a * b) % MOD);
    }

    static long[][] matIdentity() {
        long[][] m = new long[4][4];
        for (int i = 0; i < 4; i++)
            m[i][i] = 1;
        return m;
    }

    static long[][] matMul(long[][] x, long[][] y) {
        long[][] z = new long[4][4];
        for (int i = 0; i < 4; i++) {
            for (int k = 0; k < 4; k++) {
                if (x[i][k] == 0)
                    continue;
                for (int j = 0; j < 4; j++) {
                    z[i][j] = (z[i][j] + x[i][k] * y[k][j]) % MOD;
                }
            }
        }
        return z;
    }

    static long[] matVecMul(long[][] m, long[] v) {
        long[] r = new long[4];
        for (int i = 0; i < 4; i++) {
            long acc = 0;
            for (int k = 0; k < 4; k++) {
                acc += m[i][k] * v[k];
                acc %= MOD;
            }
            r[i] = acc;
        }
        return r;
    }

    static void feedDigit(long[][] m, int d) {
        for (int col = 0; col < 4; col++) {
            int f = (int) m[0][col];
            int s = (int) m[1][col];
            int t = (int) m[2][col];
            int one = (int) m[3][col];

            int dt = mulmod(d, t);
            int done = mulmod(d, one);
            int tenf = mulmod(10, f);

            int f2 = addmod(addmod(tenf, dt), done);
            int s2 = addmod(s, f2);
            int t2 = addmod(t, one);

            m[0][col] = f2;
            m[1][col] = s2;
            m[2][col] = t2;
            m[3][col] = one;
        }
    }

    static void feedNumber(long[][] m, int x) {
        if (x == 0) {
            feedDigit(m, 0);
            return;
        }
        int[] buf = new int[16];
        int len = 0;
        while (x > 0) {
            buf[len++] = x % 10;
            x /= 10;
        }
        for (int i = len - 1; i >= 0; i--) {
            feedDigit(m, buf[i]);
        }
    }

    static int upperBoundNthPrime(int n) {
        if (n < 6)
            return 15;
        double nd = (double) n;
        double bound = nd * (Math.log(nd) + Math.log(Math.log(nd)));
        return (int) Math.ceil(bound + 100.0);
    }

    static long[][] matrixForPPrimes(int n) {
        int limit = upperBoundNthPrime(n);
        byte[] comp = new byte[(limit >> 1) + 1];
        int r = (int) Math.sqrt(limit);
        for (int p = 3; p <= r; p += 2) {
            if (comp[p >> 1] == 1)
                continue;
            int step = p << 1;
            for (int x = p * p; x <= limit; x += step) {
                comp[x >> 1] = 1;
            }
        }

        long[][] m = matIdentity();
        int count = 1;
        feedNumber(m, 2);
        if (count == n)
            return m;

        for (int x = 3; x <= limit; x += 2) {
            if (comp[x >> 1] == 0) {
                count++;
                feedNumber(m, x);
                if (count == n)
                    return m;
            }
        }

        return m;
    }

    public static String solve() {
        int N = 1000000;
        long K = 1000000000000L;

        long[][] base = matrixForPPrimes(N);
        long[] state = { 0, 0, 0, 1 };

        long e = K;
        while (e > 0) {
            if ((e & 1) == 1)
                state = matVecMul(base, state);
            base = matMul(base, base);
            e >>= 1;
        }

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

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