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

public class Euler445 {
    static final int MOD = 1000000007;

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

    static class TermProductTracker {
        long productNonZero = 1;
        int zeroTerms = 0;
        Map<Integer, Integer> inverseCache = new HashMap<>();

        void add(int value) {
            if (value == 0) {
                zeroTerms++;
                return;
            }
            productNonZero = (productNonZero * value) % MOD;
        }

        void remove(int value) {
            if (value == 0) {
                zeroTerms--;
                return;
            }
            int inv = inverseCache.getOrDefault(value, 0);
            if (inv == 0) {
                inv = (int) modPow(value, MOD - 2);
                inverseCache.put(value, inv);
            }
            productNonZero = (productNonZero * inv) % MOD;
        }

        int value() {
            return zeroTerms > 0 ? 0 : (int) productNonZero;
        }
    }

    public static String solve() {
        int n = 10000000;
        int[] spf = new int[n + 1];
        List<Integer> primes = new ArrayList<>(n / 10);

        for (int i = 2; i <= n; ++i) {
            if (spf[i] == 0) {
                spf[i] = i;
                primes.add(i);
            }
            for (int p : primes) {
                long v = (long) i * p;
                if (v > n || p > spf[i]) {
                    break;
                }
                spf[(int) v] = p;
            }
        }

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

        int[] exponent = new int[n + 1];
        int[] powerMod = new int[n + 1];
        for (int i = 0; i <= n; i++)
            powerMod[i] = 1;

        TermProductTracker tracker = new TermProductTracker();

        long binomMod = 1;
        long answer = 0;
        int half = n / 2;

        for (int k = 1; k <= half; ++k) {
            int x = n - k + 1;
            while (x > 1) {
                int p = spf[x];
                int cnt = 0;
                while (x % p == 0) {
                    x /= p;
                    cnt++;
                }
                int delta = cnt;
                int oldExp = exponent[p];
                long pPow = powerMod[p];

                if (oldExp > 0) {
                    tracker.remove((int) ((pPow + 1) % MOD));
                }

                for (int i = 0; i < delta; ++i) {
                    pPow = (pPow * p) % MOD;
                }

                exponent[p] = oldExp + delta;
                powerMod[p] = (int) pPow;

                if (exponent[p] > 0) {
                    tracker.add((int) ((pPow + 1) % MOD));
                }
            }

            x = k;
            while (x > 1) {
                int p = spf[x];
                int cnt = 0;
                while (x % p == 0) {
                    x /= p;
                    cnt++;
                }

                int delta = -cnt;
                int oldExp = exponent[p];
                long pPow = powerMod[p];

                if (oldExp > 0) {
                    tracker.remove((int) ((pPow + 1) % MOD));
                }

                long invP = inv[p];
                for (int i = 0; i < -delta; ++i) {
                    pPow = (pPow * invP) % MOD;
                }

                exponent[p] = oldExp + delta;
                powerMod[p] = (int) pPow;

                if (exponent[p] > 0) {
                    tracker.add((int) ((pPow + 1) % MOD));
                }
            }

            binomMod = (binomMod * (n - k + 1)) % MOD;
            binomMod = (binomMod * inv[k]) % MOD;

            long qMod = tracker.value();
            long rMod = (qMod + MOD - binomMod) % MOD;
            long weight = (k == n - k) ? 1 : 2;
            answer = (answer + weight * rMod) % MOD;
        }

        return Long.toString(answer);
    }

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