import java.util.ArrayList;

public class Euler851 {

    static final long kMod = 1000000007L;

    static long modAdd(long a, long b) {
        a += b;
        if (a >= kMod)
            a -= kMod;
        return a;
    }

    static long modSub(long a, long b) {
        a -= b;
        if (a < 0)
            a += kMod;
        return a;
    }

    static long modMul(long a, long b) {
        long aMod = (a % kMod + kMod) % kMod;
        long bMod = (b % kMod + kMod) % kMod;
        return (aMod * bMod) % kMod;
    }

    static long modPow(long a, long e) {
        long r = 1 % kMod;
        a %= kMod;
        if (a < 0)
            a += kMod;
        while (e > 0) {
            if ((e & 1) == 1)
                r = modMul(r, a);
            a = modMul(a, a);
            e >>= 1;
        }
        return r;
    }

    static long modInv(long a) {
        return modPow(a, kMod - 2);
    }

    static ArrayList<Integer> sievePrimes(int n) {
        boolean[] isPrime = new boolean[n + 1];
        java.util.Arrays.fill(isPrime, true);
        if (n >= 0)
            isPrime[0] = false;
        if (n >= 1)
            isPrime[1] = false;
        for (int i = 2; i * i <= n; ++i) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        ArrayList<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; ++i) {
            if (isPrime[i])
                primes.add(i);
        }
        return primes;
    }

    static int vpFactorial(int n, int p) {
        int e = 0;
        while (n > 0) {
            n /= p;
            e += n;
        }
        return e;
    }

    static long factorialMod(int n) {
        long r = 1;
        for (int i = 2; i <= n; ++i) {
            r = modMul(r, i);
        }
        return r;
    }

    static long geomSum(long base, long e) {
        base %= kMod;
        if (base < 0)
            base += kMod;
        if (e < 0)
            return 0;
        if (base == 1)
            return (e + 1) % kMod;
        long num = modSub(modPow(base, e + 1), 1);
        long den = modSub(base, 1);
        return modMul(num, modInv(den));
    }

    static class Pair {
        int p, e;

        Pair(int p, int e) {
            this.p = p;
            this.e = e;
        }
    }

    static long sigmaKFactorial(ArrayList<Pair> pe, int k) {
        long res = 1;
        for (Pair pair : pe) {
            long base = modPow(pair.p, k);
            long s = geomSum(base, pair.e);
            res = modMul(res, s);
        }
        return res;
    }

    static class Mat2 {
        long a00, a01, a10, a11;

        Mat2() {
        }

        Mat2(long a00, long a01, long a10, long a11) {
            this.a00 = a00;
            this.a01 = a01;
            this.a10 = a10;
            this.a11 = a11;
        }
    }

    static Mat2 matMul(Mat2 A, Mat2 B) {
        Mat2 C = new Mat2();
        C.a00 = (modMul(A.a00, B.a00) + modMul(A.a01, B.a10)) % kMod;
        C.a01 = (modMul(A.a00, B.a01) + modMul(A.a01, B.a11)) % kMod;
        C.a10 = (modMul(A.a10, B.a00) + modMul(A.a11, B.a10)) % kMod;
        C.a11 = (modMul(A.a10, B.a01) + modMul(A.a11, B.a11)) % kMod;
        return C;
    }

    static Mat2 matPow(Mat2 base, long e) {
        Mat2 r = new Mat2(1, 0, 0, 1);
        while (e > 0) {
            if ((e & 1) == 1)
                r = matMul(r, base);
            base = matMul(base, base);
            e >>= 1;
        }
        return r;
    }

    static long tauPrimePower(long tauP, int p, int e) {
        if (e == 0)
            return 1;
        if (e == 1)
            return tauP;
        long p11 = modPow(p, 11);
        Mat2 M = new Mat2(tauP, modSub(0, p11), 1, 0);
        Mat2 P = matPow(M, e - 1);
        return (modMul(P.a00, tauP) + modMul(P.a01, 1)) % kMod;
    }

    static long[] computeSigma1Upto(int N) {
        long[] sig = new long[N + 1];
        for (int d = 1; d <= N; ++d) {
            for (int m = d; m <= N; m += d) {
                sig[m] += d;
            }
        }
        for (int i = 0; i <= N; ++i)
            sig[i] %= kMod;
        return sig;
    }

    static long[] computeTauUpto(int N, long[] sigma1) {
        long[] tau = new long[N + 1];
        tau[0] = 0;
        tau[1] = 1;
        long neg24 = modSub(0, 24);
        for (int n = 2; n <= N; ++n) {
            long s = 0;
            for (int k = 1; k < n; ++k) {
                s = (s + sigma1[k] * tau[n - k]) % kMod;
            }
            long inv = modInv(n - 1);
            tau[n] = modMul(modMul(neg24, s), inv);
        }
        return tau;
    }

    static long computeTauFactorialSerial(ArrayList<Pair> pe, long[] tauSmall) {
        long prod = 1;
        for (Pair pair : pe) {
            int p = pair.p;
            int e = pair.e;
            long tauP = tauSmall[p];
            long t = tauPrimePower(tauP, p, e);
            prod = modMul(prod, t);
        }
        return prod;
    }

    static long norm(long x) {
        x %= kMod;
        if (x < 0)
            x += kMod;
        return x;
    }

    public static String solve() {
        int N = 10000;
        ArrayList<Integer> primes = sievePrimes(N);
        ArrayList<Pair> pe = new ArrayList<>();
        for (int p : primes) {
            pe.add(new Pair(p, vpFactorial(N, p)));
        }

        long nMod = factorialMod(N);
        long[] nPow = new long[6];
        nPow[0] = 1;
        for (int i = 1; i <= 5; ++i)
            nPow[i] = modMul(nPow[i - 1], nMod);

        long[] sig = new long[12];
        int[] ks = { 1, 3, 5, 7, 9, 11 };
        for (int k : ks) {
            sig[k] = sigmaKFactorial(pe, k);
        }

        long[] sigma1Small = computeSigma1Upto(N);
        long[] tauSmall = computeTauUpto(N, sigma1Small);

        long tauFact = computeTauFactorialSerial(pe, tauSmall);

        long c2 = modMul(norm(-24), sig[1]);
        long c4 = modMul(240, sig[3]);
        long c6 = modMul(norm(-504), sig[5]);
        long c8 = modMul(480, sig[7]);
        long c10 = modMul(norm(-264), sig[9]);
        long factor12 = modMul(65520, modInv(691));
        long c12 = modMul(factor12, sig[11]);

        long inv2 = modInv(2);
        long inv5 = modInv(5);
        long inv7 = modInv(7);
        long inv24185 = modInv(24185);

        long a1 = c2;

        long a2 = modAdd(c4, modMul(12, modMul(nPow[1], c2)));

        long a3 = c6;
        a3 = modAdd(a3, modMul(9, modMul(nPow[1], c4)));
        a3 = modAdd(a3, modMul(72, modMul(nPow[2], c2)));

        long a4 = c8;
        a4 = modAdd(a4, modMul(8, modMul(nPow[1], c6)));
        a4 = modAdd(a4, modMul(modMul(216, inv5), modMul(nPow[2], c4)));
        a4 = modAdd(a4, modMul(288, modMul(nPow[3], c2)));

        long a5 = c10;
        a5 = modAdd(a5, modMul(modMul(15, inv2), modMul(nPow[1], c8)));
        a5 = modAdd(a5, modMul(modMul(240, inv7), modMul(nPow[2], c6)));
        a5 = modAdd(a5, modMul(144, modMul(nPow[3], c4)));
        a5 = modAdd(a5, modMul(864, modMul(nPow[4], c2)));

        long a6 = c12;
        a6 = modAdd(a6, modMul(modMul(norm(-4608), inv24185), tauFact));
        a6 = modAdd(a6, modMul(modMul(36, inv5), modMul(nPow[1], c10)));
        a6 = modAdd(a6, modMul(30, modMul(nPow[2], c8)));
        a6 = modAdd(a6, modMul(modMul(720, inv7), modMul(nPow[3], c6)));
        a6 = modAdd(a6, modMul(modMul(2592, inv7), modMul(nPow[4], c4)));
        a6 = modAdd(a6, modMul(modMul(10368, inv5), modMul(nPow[5], c2)));

        long S = 0;
        S = modAdd(S, modMul(norm(-6), a1));
        S = modAdd(S, modMul(15, a2));
        S = modAdd(S, modMul(norm(-20), a3));
        S = modAdd(S, modMul(15, a4));
        S = modAdd(S, modMul(norm(-6), a5));
        S = modAdd(S, a6);

        long inv2985984 = modInv(2985984);
        long ans = modMul(S, inv2985984);

        return Long.toString(ans);
    }

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