import java.util.ArrayList;

public class Euler632 {
    static final int MOD = 1000000007;

    static ArrayList<Integer> primes_upto(int n) {
        ArrayList<Integer> primes = new ArrayList<>();
        if (n < 2)
            return primes;
        byte[] is_comp = new byte[n / 2 + 1];
        primes.add(2);
        for (int i = 3; (long) i * i <= n; i += 2) {
            if (is_comp[i / 2] == 0) {
                for (int j = i * i; j <= n; j += i * 2) {
                    is_comp[j / 2] = 1;
                }
            }
        }
        for (int i = 3; i <= n; i += 2) {
            if (is_comp[i / 2] == 0) {
                primes.add(i);
            }
        }
        return primes;
    }

    static long isqrt_floor(long x) {
        if (x < 0)
            return 0;
        long r = (long) Math.sqrt(x);
        while ((r + 1) * (r + 1) <= x)
            r++;
        while (r * r > x)
            r--;
        return r;
    }

    static long[] compute_A(long N, byte[] omega, byte[] sqfree) {
        int limit = (int) isqrt_floor(N);
        long[] A = new long[10];
        int i = 1;
        while (i <= limit) {
            long q = N / ((long) i * i);
            int r = (int) isqrt_floor(N / q);
            if (r > limit)
                r = limit;
            while (r + 1 <= limit && N / ((long) (r + 1) * (r + 1)) == q)
                r++;
            while (r > limit || N / ((long) r * r) != q)
                r--;

            for (int d = i; d <= r; ++d) {
                if (sqfree[d] == 0)
                    continue;
                int w = omega[d];
                if (w < 10)
                    A[w] += q;
            }
            i = r + 1;
        }
        return A;
    }

    static long[] compute_C(long N, byte[] omega, byte[] sqfree) {
        long[][] binom = new long[10][10];
        for (int n = 0; n < 10; ++n) {
            binom[n][0] = binom[n][n] = 1;
            for (int k = 1; k < n; ++k) {
                binom[n][k] = binom[n - 1][k - 1] + binom[n - 1][k];
            }
        }

        long[] A = compute_A(N, omega, sqfree);
        long[] C = new long[10];
        for (int k = 0; k < 10; ++k) {
            long s = 0;
            for (int r = k; r < 10; ++r) {
                long term = A[r] * binom[r][k] * (((r - k) % 2 != 0) ? -1 : 1);
                s += term;
            }
            C[k] = s;
        }
        return C;
    }

    public static String solve() {
        int LIM = 100000000;
        ArrayList<Integer> primes = primes_upto(LIM);
        byte[] omega = new byte[LIM + 1];
        byte[] sqfree = new byte[LIM + 1];
        for (int i = 1; i <= LIM; i++)
            sqfree[i] = 1;
        sqfree[0] = 0;

        for (int p : primes) {
            for (int m = p; m <= LIM; m += p)
                omega[m]++;
            long p2 = (long) p * p;
            if (p2 <= LIM) {
                for (int m = (int) p2; m <= LIM; m += (int) p2) {
                    sqfree[m] = 0;
                }
            }
        }

        long N = 10000000000000000L;
        long[] C = compute_C(N, omega, sqfree);

        long ans = 1;
        for (long x : C) {
            if (x == 0)
                continue;
            ans = (ans * (x % MOD)) % MOD;
        }
        return Long.toString(ans);
    }

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