public class Euler556 {
    static long floorSqrt(long x) {
        if (x <= 0)
            return 0;
        long r = (long) Math.sqrt(x);
        while ((r + 1) * (r + 1) <= x && r + 1 > 0)
            r++;
        while (r * r > x)
            r--;
        return r;
    }

    static long countGaussianPoints(long x) {
        if (x < 0)
            return 0;
        long r = floorSqrt(x);
        long b = r;
        long b2 = b * b;
        long a2 = 0;
        long sum = 0;
        for (long a = 0; a <= r; a++) {
            while (a2 + b2 > x) {
                b--;
                b2 -= 2 * b + 1;
            }
            sum += b;
            a2 += 2 * a + 1;
        }
        return 1 + 4 * sum;
    }

    static int[] buildSpf(int limit) {
        int[] spf = new int[limit + 1];
        int maxPrimes = Math.max(10, (int) (limit / Math.log(limit) * 1.2));
        int[] primes = new int[maxPrimes];
        int numPrimes = 0;

        for (int i = 2; i <= limit; i++) {
            if (spf[i] == 0) {
                spf[i] = i;
                if (numPrimes < primes.length) {
                    primes[numPrimes++] = i;
                } else {
                    int[] newPrimes = new int[primes.length * 2];
                    System.arraycopy(primes, 0, newPrimes, 0, numPrimes);
                    primes = newPrimes;
                    primes[numPrimes++] = i;
                }
            }
            for (int j = 0; j < numPrimes; j++) {
                int p = primes[j];
                if (p > spf[i] || (long) i * p > limit)
                    break;
                spf[i * p] = p;
            }
        }
        return spf;
    }

    static int localG(int p, int exp) {
        if (p == 2) {
            if (exp == 1)
                return -1;
            return 0;
        }
        if (p % 4 == 1) {
            if (exp == 1)
                return -2;
            if (exp == 2)
                return 1;
            return 0;
        }
        if (exp == 2)
            return -1;
        return 0;
    }

    static long computeF(long n) {
        int limit = (int) floorSqrt(n);
        int[] spf = buildSpf(limit);

        long[] g = new long[limit + 1];
        g[1] = 1;
        for (int m = 2; m <= limit; m++) {
            int p = spf[m];
            int t = m;
            int exp = 0;
            while (t > 1 && spf[t] == p) {
                t /= p;
                exp++;
            }
            long local = localG(p, exp);
            if (local == 0 || g[t] == 0) {
                g[m] = 0;
            } else {
                g[m] = local * g[t];
            }
        }

        long[] prefix = new long[limit + 1];
        for (int i = 1; i <= limit; i++) {
            prefix[i] = prefix[i - 1] + g[i];
        }

        java.math.BigInteger total = java.math.BigInteger.ZERO;
        long m = 1;
        while (m <= limit) {
            long k = n / (m * m);
            long maxM = floorSqrt(n / k);

            long sumG = prefix[(int) maxM] - prefix[(int) (m - 1)];
            long aVal = countGaussianPoints(k);

            java.math.BigInteger term = java.math.BigInteger.valueOf(sumG)
                    .multiply(java.math.BigInteger.valueOf(aVal - 1));
            total = total.add(term);

            m = maxM + 1;
        }

        return total.divide(java.math.BigInteger.valueOf(4)).longValue();
    }

    public static String solve() {
        return Long.toString(computeF(100000000000000L));
    }

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