public class Euler883 {

    static long isqrtU64(long x) {
        long y = (long) Math.sqrt(x);
        while (new java.math.BigInteger(String.valueOf(y + 1)).pow(2)
                .compareTo(new java.math.BigInteger(String.valueOf(x))) <= 0) {
            ++y;
        }
        while (new java.math.BigInteger(String.valueOf(y)).pow(2)
                .compareTo(new java.math.BigInteger(String.valueOf(x))) > 0) {
            --y;
        }
        return y;
    }

    static long floorDiv2(long a) {
        if (a >= 0)
            return a >> 1;
        return -(((-a) + 1) >> 1);
    }

    static long ceilDiv2(long a) {
        if (a >= 0)
            return (a + 1) >> 1;
        return -((-a) >> 1);
    }

    static long modPos(long a, long m) {
        long r = a % m;
        if (r < 0)
            r += m;
        return r;
    }

    static class CountResult {
        long all;
        long eq;

        CountResult(long all, long eq) {
            this.all = all;
            this.eq = eq;
        }
    }

    static CountResult countBoth(long M) {
        long fourM = 4L * M;
        long umax = isqrtU64(fourM / 3L);

        long all = 0;
        long eq = 0;

        for (long u = 0; u <= umax; ++u) {
            long D = fourM - 3L * u * u;
            long s = isqrtU64(D);

            long uu = u;
            long ss = s;
            long vmin = ceilDiv2(-uu - ss);
            long vmax = floorDiv2(-uu + ss);

            long len = 0;
            if (vmax >= vmin)
                len = vmax - vmin + 1;

            long cong = 0;
            if (len > 0) {
                int r = (int) (u % 3L);
                long first = vmin + modPos(r - vmin, 3);
                if (first <= vmax) {
                    cong = (vmax - first) / 3 + 1;
                }
            }

            if (u == 0) {
                all += len;
                eq += cong;
            } else {
                all += 2L * len;
                eq += 2L * cong;
            }
        }
        return new CountResult(all, eq);
    }

    static class SieveResult {
        int[] spf;
        byte[] mu;

        SieveResult(int[] spf, byte[] mu) {
            this.spf = spf;
            this.mu = mu;
        }
    }

    static SieveResult linearSieveSpfMu(int nmax) {
        int[] spf = new int[nmax + 1];
        byte[] mu = new byte[nmax + 1];
        int[] primes = new int[nmax / 10 + 1000];
        int numPrimes = 0;

        spf[1] = 1;
        mu[1] = 1;

        for (int i = 2; i <= nmax; ++i) {
            if (spf[i] == 0) {
                spf[i] = i;
                if (numPrimes == primes.length) {
                    int[] newPrimes = new int[primes.length * 2];
                    System.arraycopy(primes, 0, newPrimes, 0, primes.length);
                    primes = newPrimes;
                }
                primes[numPrimes++] = i;
                mu[i] = -1;
            }
            for (int j = 0; j < numPrimes; ++j) {
                int p = primes[j];
                long v = 1L * p * i;
                if (v > nmax)
                    break;
                spf[(int) v] = p;
                if (i % p == 0) {
                    mu[(int) v] = 0;
                    break;
                }
                mu[(int) v] = (byte) -mu[i];
            }
        }
        return new SieveResult(spf, mu);
    }

    static int computeFSingle(int n, int[] spf) {
        int x = n;
        int e3 = 0;
        while (x % 3 == 0) {
            x /= 3;
            ++e3;
        }

        long tauH2 = 1;
        long prod1 = 1;
        int chi = 1;

        while (x > 1) {
            int p = spf[x];
            int e = 0;
            while (x % p == 0) {
                x /= p;
                ++e;
            }
            long factor = 2L * e + 1;
            tauH2 *= factor;

            int pm3 = p % 3;
            if (pm3 == 1) {
                prod1 *= factor;
            } else if (pm3 == 2) {
                if ((e & 1) == 1)
                    chi = -chi;
            }
        }

        long res;
        if (e3 > 0) {
            res = tauH2 * (2L * e3 - 1);
        } else {
            res = (tauH2 + 1L * chi * prod1) / 2L;
        }
        return (int) res;
    }

    static long solveR2(long R2) {
        long N = R2 * R2;
        int nmax = (int) (3 * R2);

        SieveResult sieve = linearSieveSpfMu(nmax);
        int[] spf = sieve.spf;
        byte[] mu = sieve.mu;

        int[] f = new int[nmax + 1];
        for (int n = 1; n <= nmax; ++n) {
            f[n] = computeFSingle(n, spf);
        }

        int[] h = new int[nmax + 1];
        for (int k = 1; k <= nmax; ++k) {
            byte muk = mu[k];
            if (muk == 0)
                continue;
            for (int d = 1, m = k; m <= nmax; ++d, m += k) {
                h[m] += muk * f[d];
            }
        }

        long[] FBase = new long[(int) (R2 + 1)];
        long[] FEq = new long[(int) (R2 + 1)];

        // Single threaded for simplicity in translation unless speed is strictly
        // required.
        // 2,000,000 shouldn't be too slow in Java.
        for (int t = 1; t <= R2; ++t) {
            long denom = (long) t * t;
            long M = N / denom;
            CountResult cr = countBoth(M);
            FBase[t] = cr.all - 1L;
            FEq[t] = cr.eq - 1L;
        }

        long totalPoints = FBase[1];
        long E = totalPoints / 3L;

        java.math.BigInteger S = java.math.BigInteger.ZERO;
        for (int n = 1; n <= nmax; ++n) {
            int hn = h[n];
            if (hn == 0)
                continue;

            long Fn = 0;
            if (n % 3 != 0) {
                if (n <= R2)
                    Fn = FBase[n];
            } else {
                int t = n / 3;
                Fn = FEq[t];
            }
            S = S.add(java.math.BigInteger.valueOf(hn).multiply(java.math.BigInteger.valueOf(Fn)));
        }

        java.math.BigInteger T = S.subtract(java.math.BigInteger.valueOf(2 * E));
        return T.longValue();
    }

    public static String solve() {
        return Long.toString(solveR2(2000000L));
    }

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