import java.util.*;
import java.util.concurrent.*;

public class Euler223 {
    static class Factor {
        int p, e;

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

    static int[] buildSpf(int n) {
        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) p * i;
                if (v > n || p > spf[i])
                    break;
                spf[(int) v] = p;
            }
        }
        if (n >= 1)
            spf[1] = 1;
        return spf;
    }

    static void factorizeInt(int x, int[] spf, List<Factor> out) {
        out.clear();
        while (x > 1) {
            int p = spf[x];
            int e = 0;
            do {
                x /= p;
                e++;
            } while (x > 1 && spf[x] == p);
            out.add(new Factor(p, e));
        }
    }

    static void mergeFactors(List<Factor> a, List<Factor> b, List<Factor> out) {
        out.clear();
        int i = 0, j = 0;
        while (i < a.size() || j < b.size()) {
            if (j == b.size() || (i < a.size() && a.get(i).p < b.get(j).p)) {
                out.add(a.get(i++));
            } else if (i == a.size() || b.get(j).p < a.get(i).p) {
                out.add(b.get(j++));
            } else {
                out.add(new Factor(a.get(i).p, a.get(i).e + b.get(j).e));
                i++;
                j++;
            }
        }
    }

    public static String solve() {
        int perimeterLimit = 25000000;
        if (perimeterLimit < 3)
            return "0";

        int aMax = perimeterLimit / 3;
        long a1Count = (perimeterLimit - 1) / 2;
        int[] spf = buildSpf(aMax + 1);

        int threads = Math.max(1, Runtime.getRuntime().availableProcessors());
        threads = Math.min(threads, aMax);

        int chunk = 2048;
        List<int[]> tasks = new ArrayList<>();
        for (int start = 2; start <= aMax; start += chunk) {
            int end = Math.min(aMax, start + chunk - 1);
            tasks.add(new int[] { start, end });
        }

        ExecutorService executor = Executors.newFixedThreadPool(threads);
        List<Future<Long>> futures = new ArrayList<>();

        for (int[] task : tasks) {
            final int startA = task[0];
            final int endA = task[1];

            futures.add(executor.submit(() -> {
                long local = 0;
                List<Factor> leftFactors = new ArrayList<>(8);
                List<Factor> rightFactors = new ArrayList<>(8);
                List<Factor> mergedFactors = new ArrayList<>(16);
                long[] divisors = new long[256];

                for (int a = startA; a <= endA; ++a) {
                    long n = (long) a * a - 1;
                    if (n == 0)
                        continue;

                    long denom = perimeterLimit - a;
                    if (denom <= 0)
                        continue;

                    long vMin = (n + denom - 1) / denom;
                    double root = Math.sqrt(2.0 * a * a - 1.0);
                    long vMax = (long) Math.floor(root - a);
                    if (vMax <= 0)
                        continue;

                    while (true) {
                        long nextV = vMax + 1;
                        // Avoid overflow using BigInteger or checking sizes if necessary, but max a ~
                        // 8.3M, a^2 ~ 6e13. n is 6e13.
                        // (vMax+1)^2 + 2*a*(vMax+1)
                        // vMax won't exceed sqrt(n) ~ 8.3M
                        // (8.3M)^2 ~ 6.9e13, fits in signed long (9e18).
                        long test = nextV * nextV + 2L * a * nextV;
                        if (test <= n)
                            vMax++;
                        else
                            break;
                    }
                    while (true) {
                        long test = vMax * vMax + 2L * a * vMax;
                        if (test > n)
                            vMax--;
                        else
                            break;
                    }

                    if (vMax < vMin)
                        continue;

                    factorizeInt(a - 1, spf, leftFactors);
                    factorizeInt(a + 1, spf, rightFactors);
                    mergeFactors(leftFactors, rightFactors, mergedFactors);

                    divisors[0] = 1;
                    int divSize = 1;

                    for (Factor f : mergedFactors) {
                        int baseSize = divSize;
                        long mul = 1;
                        for (int e = 1; e <= f.e; ++e) {
                            mul *= f.p;
                            for (int i = 0; i < baseSize; ++i) {
                                long cand = divisors[i] * mul;
                                if (cand <= vMax) {
                                    if (divSize == divisors.length) {
                                        divisors = Arrays.copyOf(divisors, divisors.length * 2);
                                    }
                                    divisors[divSize++] = cand;
                                }
                            }
                        }
                    }

                    for (int i = 0; i < divSize; ++i) {
                        long v = divisors[i];
                        if (v < vMin)
                            continue;

                        long u = n / v;
                        if (((u - v) & 1) != 0)
                            continue;
                        if (u < v + 2L * a)
                            continue;
                        if (a + u > perimeterLimit)
                            continue;
                        local++;
                    }
                }
                return local;
            }));
        }

        long total = a1Count;
        for (Future<Long> f : futures) {
            try {
                total += f.get();
            } catch (Exception e) {
            }
        }
        executor.shutdown();

        return String.valueOf(total);
    }

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