import java.util.*;

public class Euler926 {

    static final long kMod = 1000000007L;

    static long powMod(long base, long exp) {
        long res = 1;
        while (exp > 0) {
            if ((exp & 1) != 0)
                res = (res * base) % kMod;
            base = (base * base) % kMod;
            exp >>= 1;
        }
        return res;
    }

    static long invMod(long x) {
        return powMod(x, kMod - 2);
    }

    static List<Integer> primesUpTo(int n) {
        boolean[] isComp = new boolean[n + 1];
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; i++) {
            if (!isComp[i]) {
                primes.add(i);
                if ((long) i * i <= n) {
                    for (int j = i * i; j <= n; j += i)
                        isComp[j] = true;
                }
            }
        }
        return primes;
    }

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

    static class Event implements Comparable<Event> {
        int k;
        long mul;

        Event(int k, long mul) {
            this.k = k;
            this.mul = mul;
        }

        public int compareTo(Event o) {
            return Integer.compare(this.k, o.k);
        }
    }

    static class Pair {
        int e, c;

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

    static long rOfFactorialOptimized(int n) {
        if (n < 2)
            return 0;

        List<Integer> primes = primesUpTo(n);
        Map<Integer, Integer> countByExp = new HashMap<>();
        int maxE = 0;
        for (int p : primes) {
            int e = vpFactorial(n, p);
            countByExp.put(e, countByExp.getOrDefault(e, 0) + 1);
            maxE = Math.max(maxE, e);
        }

        List<Pair> groups = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : countByExp.entrySet()) {
            groups.add(new Pair(entry.getKey(), entry.getValue()));
        }
        Collections.sort(groups, (a, b) -> Integer.compare(a.e, b.e));

        long d1 = 1;
        for (Pair p : groups) {
            d1 = (d1 * powMod(p.e + 1, p.c)) % kMod;
        }

        List<Event> events = new ArrayList<>();
        for (Pair p : groups) {
            int e = p.e;
            int c = p.c;
            long prevTerm = e + 1;

            int l = 2;
            while (l <= e) {
                int q = e / l;
                int r = e / q;
                long term = q + 1;
                if (term != prevTerm) {
                    long ratio = (term * invMod(prevTerm)) % kMod;
                    events.add(new Event(l, powMod(ratio, c)));
                    prevTerm = term;
                }
                l = r + 1;
            }

            if (e + 1 <= maxE && prevTerm != 1) {
                long ratio = invMod(prevTerm);
                events.add(new Event(e + 1, powMod(ratio, c)));
            }
        }

        Collections.sort(events);

        long currD = d1;
        long answer = currD - 1;

        int idx = 0;
        for (int k = 2; k <= maxE; ++k) {
            while (idx < events.size() && events.get(idx).k == k) {
                currD = (currD * events.get(idx).mul) % kMod;
                idx++;
            }
            answer = (answer + currD - 1 + kMod) % kMod;
        }

        return answer;
    }

    public static String solve() {
        return Long.toString(rOfFactorialOptimized(10000000));
    }

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