import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.LongStream;

public class Euler681 {

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

    static class Pair {
        long p;
        int e;

        Pair(long p, int e) {
            this.p = p;
            this.e = e;
        }
    }

    static List<Pair> factorSquare(int m, int[] spf) {
        List<Pair> fac = new ArrayList<>();
        int x = m;
        while (x > 1) {
            int p = spf[x];
            int e = 0;
            do {
                x /= p;
                e++;
            } while (x % p == 0);
            fac.add(new Pair(p, 2 * e));
        }
        return fac;
    }

    static void buildDivs(int idx, long cur, List<Pair> fac, long[] out, int[] count) {
        if (idx == fac.size()) {
            out[count[0]++] = cur;
            return;
        }
        long p = fac.get(idx).p;
        int e = fac.get(idx).e;
        long mul = 1;
        for (int i = 0; i <= e; ++i) {
            buildDivs(idx + 1, cur * mul, fac, out, count);
            mul *= p;
        }
    }

    static long solveSingleM(int m, int[] spf) {
        long n2 = (long) m * m;
        List<Pair> fac = factorSquare(m, spf);

        int totalDivs = 1;
        for (Pair pair : fac)
            totalDivs *= (pair.e + 1);

        long[] divs = new long[totalDivs];
        int[] count = { 0 };
        buildDivs(0, 1L, fac, divs, count);
        Arrays.sort(divs);

        int L = totalDivs;
        long ans = 0;

        for (int i = 0; i < L; ++i) {
            long w = divs[i];
            for (int j = i; j < L; ++j) {
                long z = divs[j];
                if (w > n2 / z)
                    break;
                long wz = w * z;
                if (n2 % wz != 0)
                    continue;

                long rem = n2 / wz;
                if (z > rem / z)
                    break;

                for (int k = j; k < L; ++k) {
                    long y = divs[k];
                    if (y > rem / y)
                        break;
                    if (rem % y != 0)
                        continue;

                    long x = rem / y;
                    if (x < y)
                        continue;
                    if (x >= y + z + w)
                        continue;

                    long p = x + y + z + w;
                    if (p % 2 != 0)
                        continue;

                    ans += p;
                }
            }
        }
        return ans;
    }

    public static String solve() {
        int n = 1000000;
        int[] spf = buildSpf(n);

        long ans = LongStream.rangeClosed(1, n)
                .parallel()
                .map(m -> solveSingleM((int) m, spf))
                .sum();

        return Long.toString(ans);
    }

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