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

public class Euler446 {
    static final int MOD = 1000000007;

    static long modPow(long base, long exp, int mod) {
        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 int tonelliShanks(int n, int p) {
        if (p == 2)
            return n & 1;
        if (n == 0)
            return 0;
        if (modPow(n, (p - 1) / 2, p) != 1)
            return 0;
        if ((p & 3) == 3)
            return (int) modPow(n, (p + 1) / 4, p);

        int q = p - 1;
        int s = 0;
        while ((q & 1) == 0) {
            q >>= 1;
            s++;
        }

        int z = 2;
        while (modPow(z, (p - 1) / 2, p) != p - 1) {
            z++;
        }

        long m = s;
        long c = modPow(z, q, p);
        long t = modPow(n, q, p);
        long r = modPow(n, (q + 1) / 2, p);

        while (t != 1) {
            long tt = t;
            long i = 0;
            while (tt != 1 && i < m) {
                tt = (tt * tt) % p;
                i++;
            }

            long shift = m - i - 1;
            long b = modPow((int) c, 1L << shift, p);
            r = (r * b) % p;
            long b2 = (b * b) % p;
            t = (t * b2) % p;
            c = b2;
            m = i;
        }

        return (int) r;
    }

    static void applyPrimeToIndex(int p, int idx, long[] remaining, int[] qValue) {
        long value = remaining[idx];
        if (value % p != 0)
            return;
        long pPowerMod = 1;
        do {
            value /= p;
            pPowerMod = (pPowerMod * p) % MOD;
        } while (value % p == 0);
        remaining[idx] = value;
        int term = (int) ((1 + pPowerMod) % MOD);
        qValue[idx] = (int) (((long) qValue[idx] * term) % MOD);
    }

    public static String solve() {
        int nLimit = 10000000;
        int maxM = nLimit + 1;
        long[] remaining = new long[maxM + 1];
        int[] qValue = new int[maxM + 1];

        for (int m = 0; m <= maxM; m++) {
            remaining[m] = (long) m * m + 1;
            qValue[m] = 1;
        }

        int[] spf = new int[maxM + 1];
        List<Integer> primes = new ArrayList<>(maxM / 10);

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

        for (int p : primes) {
            if (p == 2) {
                for (int idx = 1; idx <= maxM; idx += 2) {
                    applyPrimeToIndex(2, idx, remaining, qValue);
                }
                continue;
            }
            if ((p & 3) != 1)
                continue;

            int root = tonelliShanks(p - 1, p);
            if (root == 0)
                continue;

            int root2 = (p - root) % p;

            for (int idx = root; idx <= maxM; idx += p) {
                applyPrimeToIndex(p, idx, remaining, qValue);
            }

            if (root2 != root) {
                for (int idx = root2; idx <= maxM; idx += p) {
                    applyPrimeToIndex(p, idx, remaining, qValue);
                }
            }
        }

        for (int m = 0; m <= maxM; m++) {
            long leftover = remaining[m];
            if (leftover > 1) {
                int term = (int) ((1 + (leftover % MOD)) % MOD);
                qValue[m] = (int) (((long) qValue[m] * term) % MOD);
            }
        }

        long inv9 = modPow(9, MOD - 2, MOD);
        long evenAdjust = (5 * inv9) % MOD;

        long answer = 0;
        for (int n = 1; n <= nLimit; n++) {
            int q1 = qValue[n - 1];
            int q2 = qValue[n + 1];
            long qTotal = ((long) q1 * q2) % MOD;
            if ((n & 1) == 0) {
                qTotal = (qTotal * evenAdjust) % MOD;
            }

            long nMod = n % MOD;
            long n2 = (nMod * nMod) % MOD;
            long n4Plus4 = (n2 * n2 + 4) % MOD;

            long rMod = (qTotal + MOD - n4Plus4) % MOD;
            answer = (answer + rMod) % MOD;
        }

        return Long.toString(answer);
    }

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