import java.util.ArrayList;

public class Euler785 {

    static int classIndexFromG(int g) {
        switch (g) {
            case 1:
                return 0;
            case 4:
                return 1;
            case 16:
                return 2;
            case 19:
                return 3;
            case 64:
                return 4;
            case 76:
                return 5;
            case 304:
                return 6;
            case 1216:
                return 7;
            default:
                return -1;
        }
    }

    static int trailingZerosMod16(int xMod16) {
        xMod16 &= 15;
        if (xMod16 == 0)
            return 4;
        int c = 0;
        while ((xMod16 & 1) == 0) {
            xMod16 >>= 1;
            c++;
        }
        return c;
    }

    @SuppressWarnings("unchecked")
    static ArrayList<Integer>[][] buildResidueTable() {
        ArrayList<Integer>[][] table = new ArrayList[8][304];
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 304; j++) {
                table[i][j] = new ArrayList<>();
            }
        }

        for (int vm = 0; vm < 304; ++vm) {
            for (int um = 0; um < 304; ++um) {
                int m16 = (5 * um - 3 * vm) & 15;
                int n16 = (3 * um - 5 * vm) & 15;

                int tz = Math.min(trailingZerosMod16(m16), trailingZerosMod16(n16));
                tz = Math.min(tz, 3);
                int g2 = (tz == 0 ? 1 : (tz == 1 ? 4 : (tz == 2 ? 16 : 64)));

                int m19 = (5 * um - 3 * vm) % 19;
                if (m19 < 0)
                    m19 += 19;
                boolean e19 = (m19 == 0);
                int g = g2 * (e19 ? 19 : 1);

                int idx = classIndexFromG(g);
                table[idx][vm].add(um);
            }
        }
        return table;
    }

    static final ArrayList<Integer>[][] residueTable = buildResidueTable();

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

    static long accumulateStride(long N, int[] vmax, int tid, int step) {
        int[] G = { 1, 4, 16, 19, 64, 76, 304, 1216 };
        double lo = 5.0 / 3.0;
        double hi = (103.0 - 4.0 * Math.sqrt(19.0)) / 45.0;

        long ans = 0; // The total answer fits in a 64 bit integer for N=10^9

        for (int ci = 0; ci < 8; ++ci) {
            int g = G[ci];
            for (int v = tid + 1; v <= vmax[ci]; v += step) {
                long umin = (long) Math.floor(lo * v) + 1;
                long umax = (long) Math.floor(hi * v);
                if (umin > umax)
                    continue;

                ArrayList<Integer> residues = residueTable[ci][v % 304];
                for (int r : residues) {
                    long first = umin;
                    int delta = (r - (int) (first % 304) + 304) % 304;
                    first += delta;

                    for (long u = first; u <= umax; u += 304) {
                        if (gcd(u, v) != 1)
                            continue;

                        long uu = u;
                        long vv = v;

                        long z0 = 32L * uu * uu - 176L * uu * vv + 240L * vv * vv;
                        if (z0 > N * (long) g)
                            continue;

                        long x0 = 15L * uu * uu - 34L * uu * vv + 15L * vv * vv;
                        long y0 = 105L * uu * uu - 446L * uu * vv + 473L * vv * vv;

                        long x = x0 / g;
                        long y = y0 / g;
                        long z = z0 / g;

                        ans += x + y + z;
                    }
                }
            }
        }

        return ans;
    }

    static long solveFast(long N) {
        int[] G = { 1, 4, 16, 19, 64, 76, 304, 1216 };
        double hi = (103.0 - 4.0 * Math.sqrt(19.0)) / 45.0;
        double cmin = 32.0 * hi * hi - 176.0 * hi + 240.0;

        int[] vmax = new int[8];
        for (int i = 0; i < 8; ++i) {
            double lim = Math.sqrt((N * (double) G[i]) / cmin);
            vmax[i] = (int) Math.floor(lim) + 3;
        }

        int threadCount = Runtime.getRuntime().availableProcessors();
        if (threadCount > 16)
            threadCount = 16;
        if (threadCount <= 1 || N < 1000000) {
            return accumulateStride(N, vmax, 0, 1);
        }

        Thread[] threads = new Thread[threadCount];
        long[] partials = new long[threadCount];

        for (int t = 0; t < threadCount; t++) {
            final int tid = t;
            final int step = threadCount;
            threads[t] = new Thread(() -> {
                partials[tid] = accumulateStride(N, vmax, tid, step);
            });
            threads[t].start();
        }

        long ans = 0;
        for (int t = 0; t < threadCount; t++) {
            try {
                threads[t].join();
                ans += partials[t];
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return ans;
    }

    public static String solve() {
        return Long.toString(solveFast(1000000000L));
    }

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