import java.util.ArrayList;
import java.util.HashMap;

public class Euler784 {

    static int[] buildSpf(int n) {
        int[] spf = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            spf[i] = i;
        }
        for (int i = 2; i * i <= n; i++) {
            if (spf[i] == i) {
                for (int j = i * i; j <= n; j += i) {
                    if (spf[j] == j) {
                        spf[j] = i;
                    }
                }
            }
        }
        return spf;
    }

    static class Factor {
        int p, c;

        Factor(int p, int c) {
            this.p = p;
            this.c = c;
        }
    }

    static ArrayList<Factor> factorizeSmall(int x, int[] spf) {
        ArrayList<Factor> factors = new ArrayList<>();
        while (x > 1) {
            int p = spf[x];
            int c = 0;
            while (x % p == 0) {
                x /= p;
                c++;
            }
            factors.add(new Factor(p, c));
        }
        return factors;
    }

    static ArrayList<Factor> mergeFactorizations(ArrayList<Factor> a, ArrayList<Factor> b) {
        HashMap<Integer, Integer> merged = new HashMap<>();
        for (Factor f : a) {
            merged.put(f.p, merged.getOrDefault(f.p, 0) + f.c);
        }
        for (Factor f : b) {
            merged.put(f.p, merged.getOrDefault(f.p, 0) + f.c);
        }
        ArrayList<Factor> res = new ArrayList<>();
        for (HashMap.Entry<Integer, Integer> entry : merged.entrySet()) {
            res.add(new Factor(entry.getKey(), entry.getValue()));
        }
        return res;
    }

    static long solveFast(int n) {
        int[] spf = buildSpf(n + 1);
        long ans = 0;

        for (int r = 2; r < n; r++) {
            int m = Math.min(r - 1, n - r);
            if (m <= 0)
                continue;

            ArrayList<Factor> fa = factorizeSmall(r - 1, spf);
            ArrayList<Factor> fb = factorizeSmall(r + 1, spf);
            ArrayList<Factor> factors = mergeFactorizations(fa, fb);

            long sqMinus1 = (long) r * r - 1L;
            ans += dfs(0, 1L, factors, m, r, sqMinus1);
        }

        return ans;
    }

    static long dfs(int idx, long cur, ArrayList<Factor> factors, int m, long r, long sqMinus1) {
        if (idx == factors.size()) {
            if (cur == 0 || cur > m)
                return 0;
            long p = r + cur;
            long q = r + sqMinus1 / cur;
            return p + q;
        }

        Factor f = factors.get(idx);
        long val = cur;
        long sum = 0;

        for (int e = 0; e <= f.c; e++) {
            if (val > m)
                break;
            sum += dfs(idx + 1, val, factors, m, r, sqMinus1);
            if (e == f.c || val > m / f.p)
                break;
            val *= f.p;
        }

        return sum;
    }

    public static String solve() {
        return Long.toString(solveFast(2000000));
    }

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