import java.util.*;

public class Euler292 {
    static class Direction implements Comparable<Direction> {
        int length;
        int dx;
        int dy;
        double angle;

        Direction(int length, int dx, int dy, double angle) {
            this.length = length;
            this.dx = dx;
            this.dy = dy;
            this.angle = angle;
        }

        @Override
        public int compareTo(Direction b) {
            if (this.angle != b.angle) {
                return Double.compare(this.angle, b.angle);
            }
            if (this.dx != b.dx) {
                return Integer.compare(this.dx, b.dx);
            }
            return Integer.compare(this.dy, b.dy);
        }
    }

    static int gcd2(int x, int y) {
        x = Math.abs(x);
        y = Math.abs(y);
        if (y == 0)
            return x;
        if (x == 0)
            return y;
        while (y != 0) {
            int r = x % y;
            x = y;
            y = r;
        }
        return x;
    }

    static List<Direction> initVectors(int n) {
        List<Direction> vectors = new ArrayList<>();
        for (int y = -n; y <= n; ++y) {
            for (int x = -n; x <= n; ++x) {
                int t = x * x + y * y;
                int t2 = (int) Math.round(Math.sqrt(t));
                if (gcd2(x, y) != 1 || t2 * t2 != t) {
                    continue;
                }
                double ang = Math.atan2(y, x);
                if (ang < 0.0) {
                    ang += 6.2831853071795862;
                }
                vectors.add(new Direction(t2, x, y, ang));
            }
        }
        Collections.sort(vectors);
        return vectors;
    }

    static void addTransitions(Map<Integer, Long> src, int dx, int dy, int nrl, int n, Map<Integer, Long> dst) {
        int base = n + 1;
        int nrl2 = nrl * nrl;

        for (Map.Entry<Integer, Long> entry : src.entrySet()) {
            int packed = entry.getKey();
            long count = entry.getValue();

            int cy = packed % base;
            int cx = packed / base - n;
            int nx = cx + dx;
            int ny = cy + dy;
            int np = nx * nx + ny * ny;

            if (ny >= 0 && np <= nrl2) {
                int key = (nx + n) * base + ny;
                dst.put(key, dst.getOrDefault(key, 0L) + count);
            }
        }
    }

    static long countPolygons(int n) {
        if (n < 3)
            return 0;

        List<Direction> vectors = initVectors((n - 1) / 2);

        List<Map<Integer, Long>> arr = new ArrayList<>();
        for (int i = 0; i <= n; ++i) {
            arr.add(new HashMap<>());
        }

        int originKey = n * (n + 1);
        arr.get(n).put(originKey, 1L);

        for (Direction v : vectors) {
            for (int i = v.length; i <= n; ++i) {
                Map<Integer, Long> src = arr.get(i);
                if (src.isEmpty())
                    continue;

                for (int g = 1; g <= i / v.length; ++g) {
                    int nrl = i - v.length * g;
                    addTransitions(src, v.dx * g, v.dy * g, nrl, n, arr.get(nrl));
                }
            }
        }

        long diagonal = 0;
        for (Direction v : vectors) {
            diagonal += n / (2 * v.length);
        }
        diagonal /= 2;

        long answer = -diagonal - 1;
        for (int i = 0; i <= n; ++i) {
            if (arr.get(i).containsKey(originKey)) {
                answer += arr.get(i).get(originKey);
            }
        }

        return answer;
    }

    public static String solve() {
        return String.valueOf(countPolygons(120));
    }

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