import java.util.*;
import java.math.*;

public class Euler245 {
    static boolean[] isPrimeSmall;
    static int[] primes;

    public static String solve() {
        long LIMIT = 200_000_000_000L;
        int kMax = (int) Math.sqrt((double) LIMIT);
        sieve(kMax);

        long[] rem = new long[kMax + 1];
        int[][] factors = new int[kMax + 1][];
        int[][] exponents = new int[kMax + 1][];
        int[] fcount = new int[kMax + 1];

        List<int[]> tempF = new ArrayList<>();
        List<int[]> tempE = new ArrayList<>();
        for (int k = 2; k <= kMax; k++) {
            rem[k] = (long) k * k - k + 1;
            tempF.add(new int[0]);
            tempE.add(new int[0]);
        }

        for (int p : primes) {
            if (p > kMax)
                break;
            if (p == 2)
                continue;
            if (p == 3) {
                for (int k = 2; k <= kMax; k += 3) {
                    if (rem[k] % 3 != 0)
                        continue;
                    int e = 0;
                    while (rem[k] % 3 == 0) {
                        rem[k] /= 3;
                        e++;
                    }
                    addFactor(k, 3, e, factors, exponents, fcount);
                }
                continue;
            }
            if (p % 3 != 1)
                continue;
            long root = tonelliShanks(p - 3, p);
            long inv2 = (p + 1) / 2;
            long r1 = ((1 + root) % p * inv2) % p;
            long r2 = ((1 + p - root) % p * inv2) % p;
            for (long r : new long[] { r1, r2 }) {
                long kk = r < 2 ? r + ((2 - r + p - 1) / p) * p : r;
                while (kk <= kMax) {
                    int ki = (int) kk;
                    if (rem[ki] % p == 0) {
                        int e = 0;
                        while (rem[ki] % p == 0) {
                            rem[ki] /= p;
                            e++;
                        }
                        addFactor(ki, p, e, factors, exponents, fcount);
                    }
                    kk += p;
                }
            }
        }
        for (int k = 2; k <= kMax; k++) {
            if (rem[k] > 1)
                addFactor(k, (int) rem[k], 1, factors, exponents, fcount);
        }

        Set<Long> results = new HashSet<>();
        for (int k = 2; k <= kMax; k++) {
            long K = (long) k * k - k + 1;
            List<Long> divs = getDivisors(k, factors, exponents, fcount);
            for (long a : divs) {
                long b = K / a;
                if (a > b)
                    continue;
                long pp = k + a, qq = k + b;
                if (pp == qq)
                    continue;
                if (pp > LIMIT / qq)
                    continue;
                if (isPrime(pp) && isPrime(qq))
                    results.add(pp * qq);
            }
        }

        int kRoot = (int) Math.cbrt((double) LIMIT);
        for (int k = 2; k < kRoot; k++) {
            int idx = Arrays.binarySearch(primes, k + 1);
            if (idx < 0)
                idx = -idx - 1;
            dfsMulti(k, idx, 1, 1, 1, 0, LIMIT, results);
        }

        long sum = 0;
        for (long v : results)
            sum += v;
        return String.valueOf(sum);
    }

    static void dfsMulti(int k, int idx, long m, long A, int lastP, int depth, long LIMIT, Set<Long> results) {
        long denom = k * A - ((long) (k - 1)) * m;
        if (denom <= 0)
            return;
        long numer = k * A + 1;
        if (numer % denom == 0) {
            long p = numer / denom;
            if (p > lastP && m <= LIMIT / p && depth >= 2 && isPrime(p))
                results.add(m * p);
        }
        for (int i = idx; i < primes.length; i++) {
            long q = primes[i];
            if (q <= k)
                continue;
            if (m > LIMIT / q / q)
                break;
            dfsMulti(k, i + 1, m * q, A * (q - 1), (int) q, depth + 1, LIMIT, results);
        }
    }

    static int[][] factorsBuf;
    static int[][] exponentsBuf;

    static void addFactor(int k, int p, int e, int[][] factors, int[][] exponents, int[] fcount) {
        int c = fcount[k]++;
        if (factors[k] == null || c >= factors[k].length) {
            int nl = Math.max(4, c + 1);
            factors[k] = Arrays.copyOf(factors[k] == null ? new int[0] : factors[k], nl);
            exponents[k] = Arrays.copyOf(exponents[k] == null ? new int[0] : exponents[k], nl);
        }
        factors[k][c] = p;
        exponents[k][c] = e;
    }

    static List<Long> getDivisors(int k, int[][] factors, int[][] exponents, int[] fcount) {
        List<Long> divs = new ArrayList<>();
        divs.add(1L);
        for (int i = 0; i < fcount[k]; i++) {
            int p = factors[k][i], e = exponents[k][i];
            int sz = divs.size();
            long mult = 1;
            for (int j = 0; j < e; j++) {
                mult *= p;
                for (int m = 0; m < sz; m++)
                    divs.add(divs.get(m) * mult);
            }
        }
        return divs;
    }

    static void sieve(int n) {
        isPrimeSmall = new boolean[n + 1];
        Arrays.fill(isPrimeSmall, true);
        isPrimeSmall[0] = isPrimeSmall[1] = false;
        for (int i = 2; (long) i * i <= n; i++)
            if (isPrimeSmall[i])
                for (int j = i * i; j <= n; j += i)
                    isPrimeSmall[j] = false;
        List<Integer> pl = new ArrayList<>();
        for (int i = 2; i <= n; i++)
            if (isPrimeSmall[i])
                pl.add(i);
        primes = pl.stream().mapToInt(Integer::intValue).toArray();
    }

    static boolean isPrime(long n) {
        if (n < 2)
            return false;
        if (n < isPrimeSmall.length)
            return isPrimeSmall[(int) n];
        return millerRabin(n);
    }

    static boolean millerRabin(long n) {
        if (n < 2)
            return false;
        for (long p : new long[] { 2, 3, 5, 7, 11, 13 }) {
            if (n % p == 0)
                return n == p;
        }
        long d = n - 1;
        int s = 0;
        while (d % 2 == 0) {
            d /= 2;
            s++;
        }
        for (long a : new long[] { 2, 3, 5, 7, 11, 13 }) {
            if (a % n == 0)
                continue;
            long x = modPow(a, d, n);
            if (x == 1 || x == n - 1)
                continue;
            boolean witness = true;
            for (int i = 0; i < s - 1; i++) {
                x = mulMod(x, x, n);
                if (x == n - 1) {
                    witness = false;
                    break;
                }
            }
            if (witness)
                return false;
        }
        return true;
    }

    static long mulMod(long a, long b, long m) {
        return BigInteger.valueOf(a).multiply(BigInteger.valueOf(b)).mod(BigInteger.valueOf(m)).longValue();
    }

    static long modPow(long base, long exp, long mod) {
        return BigInteger.valueOf(base).modPow(BigInteger.valueOf(exp), BigInteger.valueOf(mod)).longValue();
    }

    static long tonelliShanks(long n, long p) {
        if (n == 0)
            return 0;
        if (p == 2)
            return 1;
        if (p % 4 == 3)
            return modPow(n, (p + 1) / 4, p);
        long q = p - 1;
        int s = 0;
        while (q % 2 == 0) {
            q /= 2;
            s++;
        }
        long z = 2;
        while (modPow(z, (p - 1) / 2, p) != p - 1)
            z++;
        long c = modPow(z, q, p), x = modPow(n, (q + 1) / 2, p), t = modPow(n, q, p);
        int m = s;
        while (t != 1) {
            int i = 1;
            long t2i = mulMod(t, t, p);
            while (t2i != 1) {
                t2i = mulMod(t2i, t2i, p);
                i++;
            }
            long b = modPow(c, 1L << (m - i - 1), p);
            x = mulMod(x, b, p);
            long b2 = mulMod(b, b, p);
            t = mulMod(t, b2, p);
            c = b2;
            m = i;
        }
        return x;
    }

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