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

public class Euler279 {
    static long gcd(long a, long b) {
        while (b != 0) {
            long t = a % b;
            a = b;
            b = t;
        }
        return a;
    }

    static long gcd3(long a, long b, long c) {
        return gcd(a, gcd(b, c));
    }

    static long count90Range(long limit, long mStart, long mEnd, long mStep) {
        long out = 0;
        for (long m = mStart; m <= mEnd; m += mStep) {
            for (long n = 1; n < m; ++n) {
                if (((m - n) & 1L) == 0 || gcd(m, n) != 1L) {
                    continue;
                }
                long primitivePerimeter = 2L * m * (m + n);
                out += limit / primitivePerimeter;
            }
        }
        return out;
    }

    static long count120Range(long limit, long mStart, long mEnd, long mStep) {
        long out = 0;
        for (long m = mStart; m <= mEnd; m += mStep) {
            for (long n = 1; n < m; ++n) {
                if (gcd(m, n) != 1L) {
                    continue;
                }
                long mm = m * m;
                long nn = n * n;
                long a = mm - nn;
                long b = 2L * m * n + nn;
                long c = mm + m * n + nn;
                if (gcd3(a, b, c) != 1L) {
                    continue;
                }
                long primitivePerimeter = a + b + c;
                out += limit / primitivePerimeter;
            }
        }
        return out;
    }

    static long count60NonEqRange(long limit, long mStart, long mEnd, long mStep) {
        long out = 0;
        for (long m = mStart; m <= mEnd; m += mStep) {
            long mm = m * m;
            long nMax = (m - 1) / 2;
            for (long n = 1; n <= nMax; ++n) {
                if (gcd(m, n) != 1L) {
                    continue;
                }
                long nn = n * n;
                long a = mm - nn;
                long c = mm - m * n + nn;

                long ba = 2L * m * n - nn;
                if (gcd3(a, ba, c) == 1L) {
                    long primitivePerimeter = a + ba + c;
                    out += limit / primitivePerimeter;
                }

                long bb = mm - 2L * m * n;
                if (bb > 0 && gcd3(a, bb, c) == 1L) {
                    long primitivePerimeter = a + bb + c;
                    out += limit / primitivePerimeter;
                }
            }
        }
        return out;
    }

    static long maxM90(long limit) {
        long m = 2;
        while (2L * m * (m + 1) <= limit) {
            ++m;
        }
        return m - 1;
    }

    static long maxM120(long limit) {
        long m = 2;
        while (2L * m * m + 3L * m + 1 <= limit) {
            ++m;
        }
        return m - 1;
    }

    static long maxM60(long limit) {
        long m = 2;
        while (true) {
            // Need BigInteger or __int128 equivalent to avoid overflow, but m is around
            // 10000 for limit=1e8
            // which fits fine in 64-bit int. Let's do it safely.
            long mm = m * m;
            long minPerimeterA = 2L * mm + m - 1;
            long minPerimeterB = 3L * m * ((m + 1) / 2);
            if (minPerimeterA > limit && minPerimeterB > limit) {
                break;
            }
            ++m;
        }
        return m - 1;
    }

    public static String solve() {
        long limit = 100_000_000L;
        long mMax90 = maxM90(limit);
        long mMax120 = maxM120(limit);
        long mMax60 = maxM60(limit);

        long with60 = limit / 3;
        long with90 = 0;
        long with120 = 0;

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

        if (threads <= 1) {
            with90 += count90Range(limit, 2, mMax90, 1);
            with120 += count120Range(limit, 2, mMax120, 1);
            with60 += count60NonEqRange(limit, 2, mMax60, 1);
        } else {
            ExecutorService executor = Executors.newFixedThreadPool(threads);
            List<Future<long[]>> futures = new ArrayList<>();

            for (int t = 0; t < threads; ++t) {
                final long mStart = 2 + t;
                final long mStep = threads;

                futures.add(executor.submit(() -> {
                    long c90 = count90Range(limit, mStart, mMax90, mStep);
                    long c120 = count120Range(limit, mStart, mMax120, mStep);
                    long c60 = count60NonEqRange(limit, mStart, mMax60, mStep);
                    return new long[] { c90, c120, c60 };
                }));
            }

            for (Future<long[]> f : futures) {
                try {
                    long[] res = f.get();
                    with90 += res[0];
                    with120 += res[1];
                    with60 += res[2];
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            executor.shutdown();
        }

        long total = with60 + with90 + with120;
        return String.valueOf(total);
    }

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