import java.util.ArrayList;
import java.util.List;

public class Euler903 {
    static final int MOD = 1000000007;

    static int addmod(int a, int b) {
        a += b;
        if (a >= MOD)
            a -= MOD;
        return a;
    }

    static int submod(int a, int b) {
        a -= b;
        if (a < 0)
            a += MOD;
        return a;
    }

    static int mulmod(long a, long b) {
        return (int) ((a * b) % MOD);
    }

    static int 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 (int) r;
    }

    static int modInv(int a) {
        return modPow(a, MOD - 2);
    }

    static int[] computeInverses(int n) {
        int[] inv = new int[n + 1];
        if (n >= 1)
            inv[1] = 1;
        for (int i = 2; i <= n; i++) {
            inv[i] = (int) (MOD - (long) (MOD / i) * inv[MOD % i] % MOD);
        }
        return inv;
    }

    static class Harmonics {
        int[] H;
        int[] H2;
    }

    static Harmonics computeHarmonics(int n, int[] inv) {
        Harmonics out = new Harmonics();
        out.H = new int[n + 1];
        out.H2 = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            out.H[i] = addmod(out.H[i - 1], inv[i]);
            out.H2[i] = addmod(out.H2[i - 1], mulmod(inv[i], inv[i]));
        }
        return out;
    }

    static int[] computePhi(int n) {
        int[] phi = new int[n + 1];
        List<Integer> primes = new ArrayList<>();
        boolean[] isComp = new boolean[n + 1];

        phi[1] = 1;
        for (int i = 2; i <= n; i++) {
            if (!isComp[i]) {
                primes.add(i);
                phi[i] = i - 1;
            }
            for (int p : primes) {
                long v = 1L * p * i;
                if (v > n)
                    break;
                isComp[(int) v] = true;
                if (i % p == 0) {
                    phi[(int) v] = phi[i] * p;
                    break;
                } else {
                    phi[(int) v] = phi[i] * (p - 1);
                }
            }
        }
        return phi;
    }

    static int computeS(int n, int[] inv, int[] H, int[] H2, int[] phi) {
        int[] pref = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            int invI2 = mulmod(inv[i], inv[i]);
            int term = mulmod(phi[i], invI2);
            pref[i] = addmod(pref[i - 1], term);
        }

        long S = 0;
        for (int l = 1; l <= n;) {
            int q = n / l;
            int r = n / q;
            int sumF = submod(pref[r], pref[l - 1]);
            long h = H[q];
            long t = (h * h) % MOD;
            t = (t - H2[q]) % MOD;
            if (t < 0)
                t += MOD;
            S = (S + 1L * sumF * t) % MOD;
            l = r + 1;
        }
        return (int) S;
    }

    static int solveFast(int n) {
        if (n == 1)
            return 1;
        if (n == 2)
            return 5;

        int[] inv = computeInverses(n);
        Harmonics harm = computeHarmonics(n, inv);
        int[] phi = computePhi(n);
        int S = computeS(n, inv, harm.H, harm.H2, phi);

        int Hn = harm.H[n];
        int inv2 = inv[2];

        int invN = inv[n];
        int invNm1 = inv[n - 1];
        int invD = inv[n - 2];

        int pF = mulmod(Hn, invN);
        int pO = mulmod(submod(1, pF), invNm1);
        int pSW = mulmod(mulmod(mulmod(harm.H[n / 2], inv2), invN), invNm1);
        int pFF = mulmod(mulmod(addmod(submod(n % MOD, Hn), S), invN), invNm1);

        int K1 = mulmod(addmod(submod(submod(pF, pFF), pO), pSW), invD);

        int K0 = pFF;
        K0 = addmod(K0, mulmod(submod(pF, pFF), mulmod((n - 3) % MOD, invD)));
        K0 = addmod(K0, mulmod(submod(pO, pSW), mulmod((n - 1) % MOD, invD)));
        K0 = addmod(K0, inv2);
        K0 = submod(K0, pF);
        K0 = submod(K0, pO);
        K0 = addmod(K0, mulmod(addmod(pFF, pSW), inv2));

        int[] fact = new int[n + 1];
        fact[0] = 1;
        for (int i = 1; i <= n; i++)
            fact[i] = mulmod(fact[i - 1], i);

        int term1Const = mulmod(submod(n % MOD, Hn), inv2);
        int AConst = mulmod(submod(Hn, 1), invNm1);
        int C1 = submod(AConst, K0);

        int T = Math.max(1, Runtime.getRuntime().availableProcessors());
        if (n < 100000)
            T = 1;

        long[] partial = new long[T];
        Thread[] pool = new Thread[T];
        int block = (n + T - 1) / T;

        for (int t = 0; t < T; t++) {
            final int tIdx = t;
            final int L = t * block + 1;
            final int R = Math.min(n, (t + 1) * block);
            if (L > R)
                continue;

            pool[t] = new Thread(() -> {
                long sum = 0;
                for (int j = L; j <= R; j++) {
                    long m = j - 1;
                    long mm = m % MOD;
                    long tri = mm * ((mm + 1) % MOD) % MOD;
                    tri = (tri * inv2) % MOD;

                    long Ea = term1Const;
                    Ea = (Ea + mm * C1) % MOD;
                    Ea = (Ea - 1L * K1 * tri) % MOD;
                    if (Ea < 0)
                        Ea += MOD;

                    sum += Ea * fact[n - j] % MOD;
                    if (sum > (1L << 60))
                        sum %= MOD;
                }
                partial[tIdx] = sum % MOD;
            });
            pool[t].start();
        }

        try {
            for (int t = 0; t < T; t++) {
                if (pool[t] != null)
                    pool[t].join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long sum = 0;
        for (long v : partial)
            sum = (sum + v) % MOD;

        int ERank = addmod(1, (int) sum);
        long ans = 1L * fact[n] * fact[n] % MOD * ERank % MOD;
        return (int) ans;
    }

    public static String solve() {
        return Integer.toString(solveFast(1000000));
    }

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