import java.util.stream.IntStream;

public class Euler977 {
    static final long MOD = 1_000_000_007;

    static long modpow(long a, long e) {
        long r = 1 % MOD;
        a %= MOD;
        while (e > 0) {
            if ((e & 1) != 0)
                r = (r * a) % MOD;
            a = (a * a) % MOD;
            e >>= 1;
        }
        return r;
    }

    static int[] powAll;
    static int[] powOffset;

    static void buildPowers(int n) {
        int maxBase = n + 1;
        powOffset = new int[maxBase + 1];
        int[] powLen = new int[maxBase + 1];

        long totalLen = 0;
        for (int b = 2; b <= maxBase; b++) {
            int maxExp = (n - 1) / (b - 1) + 1;
            powLen[b] = maxExp + 1;
            powOffset[b] = (int) totalLen;
            totalLen += powLen[b];
        }

        powAll = new int[(int) totalLen];
        for (int b = 2; b <= maxBase; b++) {
            int off = powOffset[b];
            int len = powLen[b];
            powAll[off] = 1;
            for (int e = 1; e < len; e++) {
                long prev = powAll[off + e - 1];
                powAll[off + e] = (int) ((prev * b) % MOD);
            }
        }
    }

    static int powBase(int base, int exp) {
        if (exp == 0 || base == 1)
            return 1;
        return powAll[powOffset[base] + exp];
    }

    static long bruteCount(int n) {
        int[] a = new int[n + 1];
        return dfs(1, a, n);
    }

    static long dfs(int idx, int[] a, int n) {
        if (idx > n) {
            for (int k = 1; k < n; k++) {
                if (a[k + 1] != a[a[k]])
                    return 0;
            }
            return 1;
        }
        long cnt = 0;
        for (int v = 1; v <= n; v++) {
            a[idx] = v;
            cnt += dfs(idx + 1, a, n);
        }
        return cnt;
    }

    static long solveSlow(int n) {
        long total = 0;
        for (int t = 0; t < n; t++) {
            int N = n - t;
            for (int l = 1; l <= N; l++) {
                int q = N / l;
                int r = N % l;
                long P = (modpow(q, l - r) * modpow(q + 1, r)) % MOD;
                if (t == 0) {
                    total = (total + P) % MOD;
                } else {
                    long multiplier = (r == 0) ? (q - 1) : q;
                    total = (total + multiplier * P) % MOD;
                }
            }
        }
        return total;
    }

    static long computeBRange(int n, int lStart, int lEnd) {
        long sum = 0;
        int n1 = n - 1;
        for (int l = lStart; l < lEnd; l++) {
            int maxQ = n1 / l;
            for (int q = 1; q <= maxQ; q++) {
                int n0 = q * l;
                int n1Limit = (q + 1) * l - 1;
                if (n1Limit > n1)
                    n1Limit = n1;
                int R = n1Limit - n0;

                long powqL = powBase(q, l);
                long term0 = ((q - 1) * powqL) % MOD;
                long sumBlock = term0;

                if (R >= 1) {
                    long powqL1 = powBase(q, l + 1);
                    long powqL1minusR = powBase(q, l + 1 - R);
                    long powq1R1 = powBase(q + 1, R + 1);
                    long sumR = (powqL1minusR * powq1R1 - powqL1 * (q + 1)) % MOD;
                    if (sumR < 0)
                        sumR += MOD;
                    sumBlock = (sumBlock + sumR) % MOD;
                }

                sum = (sum + sumBlock) % MOD;
            }
        }
        return sum;
    }

    static long solveFast(int n) {
        if (n <= 0)
            return 0;

        long sumA = 0;
        for (int l = 1; l <= n; l++) {
            int q = n / l;
            int r = n % l;
            long P = ((long) powBase(q, l - r) * powBase(q + 1, r)) % MOD;
            sumA = (sumA + P) % MOD;
        }

        if (n == 1)
            return sumA;

        long sumB = IntStream.range(0, 16)
                .parallel()
                .mapToLong(t -> {
                    int L = 1 + (n - 1) * t / 16;
                    int R = 1 + (n - 1) * (t + 1) / 16;
                    return computeBRange(n, L, R);
                })
                .reduce(0, (a, b) -> (a + b) % MOD);

        return (sumA + sumB) % MOD;
    }

    public static String solve() {
        int N = 1000000;
        buildPowers(N);
        return Long.toString(solveFast(N));
    }

    public static void main(String[] args) {
        if (bruteCount(7) != 174) {
            System.out.println("Validation failed");
            return;
        }
        if (solveSlow(100) != 305741269) {
            System.out.println("Validation failed");
            return;
        }
        buildPowers(7);
        if (solveFast(7) != 174) {
            System.out.println("Validation failed");
            return;
        }

        System.out.println(solve());
    }
}