import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Euler608 {
    static final long kMod = 1000000007L;
    static final int kSmallLimit = 1000000;

    static int[] smallPrefixTau = new int[kSmallLimit];
    static Map<Long, Long> largePrefixTauCache = new HashMap<>();

    static void buildSmallPrefixTau() {
        for (int d = 1; d < kSmallLimit; d++) {
            for (int m = d; m < kSmallLimit; m += d) {
                smallPrefixTau[m]++;
            }
        }
        for (int i = 1; i < kSmallLimit; i++) {
            long v = smallPrefixTau[i] + smallPrefixTau[i - 1];
            smallPrefixTau[i] = (int) (v % kMod);
        }
    }

    static long prefixTau(long n) {
        if (n < kSmallLimit) {
            return smallPrefixTau[(int) n];
        }
        Long cached = largePrefixTauCache.get(n);
        if (cached != null)
            return cached;

        long sumVal = 0;
        long x = 1;
        while (x * x <= n) {
            sumVal += n / x;
            x++;
        }

        long xMinus1 = x - 1;
        long val = 2 * sumVal - xMinus1 * xMinus1;
        long out = val % kMod;
        if (out < 0)
            out += kMod;
        largePrefixTauCache.put(n, out);
        return out;
    }

    static List<Integer> makePrimes(int n) {
        byte[] mark = new byte[n + 1];
        List<Integer> primes = new ArrayList<>();
        for (int p = 2; p <= n; p++) {
            if (mark[p] == 0) {
                primes.add(p);
                for (int q = p; q <= n; q += p) {
                    mark[q] = 1;
                }
            }
        }
        return primes;
    }

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

    static long modPow(long base, long exp) {
        long result = 1;
        base %= kMod;
        if (base < 0)
            base += kMod;
        while (exp > 0) {
            if ((exp & 1) == 1)
                result = (result * base) % kMod;
            base = (base * base) % kMod;
            exp >>= 1;
        }
        return result;
    }

    static long tri(long x) {
        return x * (x + 1) / 2;
    }

    static long ans = 0;
    static long N = 1000000000000L;
    static List<Integer> primes;
    static long[] ds;

    static void dfs(long acc, int startIdx, long d, int sign) {
        long term = (d * prefixTau(N / acc)) % kMod;
        if (sign > 0) {
            ans = (ans + term) % kMod;
        } else {
            ans = (ans - term + kMod) % kMod;
        }

        for (int j = startIdx; j < primes.size(); j++) {
            long p = primes.get(j);
            if (acc > N / p)
                break;
            dfs(acc * p, j + 1, (d * ds[j]) % kMod, -sign);
        }
    }

    public static String solve() {
        int factN = 200;
        buildSmallPrefixTau();

        primes = makePrimes(factN);
        ds = new long[primes.size()];

        long k = 1;
        for (int i = 0; i < primes.size(); i++) {
            int e = exponentInFactorial(primes.get(i), factN);
            long tE = tri(e) % kMod;
            long tEp1 = tri(e + 1) % kMod;
            ds[i] = (tE * modPow(tEp1, kMod - 2)) % kMod;
            k = (k * tEp1) % kMod;
        }

        ans = 0;
        dfs(1, 0, k, 1);

        return Long.toString(ans);
    }

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