import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class Euler558 {
    static final int kMinE = -180;
    static final int kMaxE = 90;
    static final long kM = 100000000000000000L;

    static BigDecimal cbrtDec(BigDecimal x, MathContext mc) {
        if (x.compareTo(BigDecimal.ZERO) == 0)
            return BigDecimal.ZERO;

        double approx = Math.pow(x.doubleValue(), 1.0 / 3.0);
        BigDecimal r = new BigDecimal(approx, mc);

        BigDecimal two = new BigDecimal(2);
        BigDecimal three = new BigDecimal(3);

        for (int i = 0; i < 30; i++) {
            BigDecimal num = two.multiply(r, mc).add(x.divide(r.multiply(r, mc), mc), mc);
            r = num.divide(three, mc);
        }
        return r;
    }

    static class RootTable {
        long[] u1;
        long[] u2;
        long[] u3;
    }

    static RootTable buildRootTable() {
        RootTable table = new RootTable();
        int len = kMaxE - kMinE + 1;
        table.u1 = new long[len];
        table.u2 = new long[len];
        table.u3 = new long[len];

        MathContext mc = new MathContext(100, RoundingMode.HALF_UP);
        BigDecimal bd29 = new BigDecimal(29);
        BigDecimal bd93 = new BigDecimal(93);
        BigDecimal bd3 = new BigDecimal(3);
        BigDecimal bd2 = new BigDecimal(2);
        BigDecimal bd1 = new BigDecimal(1);
        BigDecimal bdkM = new BigDecimal(kM);

        BigDecimal sqrt93 = bd93.sqrt(mc);
        BigDecimal p = bd29.subtract(bd3.multiply(sqrt93, mc), mc).divide(bd2, mc);
        BigDecimal q = bd29.subtract(p, mc);
        BigDecimal r = bd1.add(cbrtDec(p, mc), mc).add(cbrtDec(q, mc), mc).divide(bd3, mc);

        BigDecimal z = BigDecimal.ONE;
        for (int i = 0; i < -kMinE; i++) {
            z = z.divide(r, mc);
        }

        for (int i = 0; i < len; i++) {
            BigDecimal x = z;
            long y1 = x.longValue();
            table.u1[i] = y1;

            x = bdkM.multiply(x.subtract(new BigDecimal(y1), mc), mc);
            long y2 = x.longValue();
            table.u2[i] = y2;

            x = bdkM.multiply(x.subtract(new BigDecimal(y2), mc), mc);
            long y3 = x.longValue();
            table.u3[i] = y3;

            z = z.multiply(r, mc);
        }
        return table;
    }

    static long solveCalc(int limit) {
        RootTable table = buildRootTable();
        int len = kMaxE - kMinE + 1;
        int i0 = -kMinE;
        long sm = 0;

        for (int j = 1; j <= limit; j++) {
            long n = (long) j * j;

            if (n == 1) {
                sm++;
                continue;
            }

            while (i0 < len && table.u1[i0] < n) {
                i0++;
            }

            int i = i0 - 1;
            long rep = 1;

            long n1 = n - table.u1[i] - 1;
            long n2 = kM - table.u2[i] - 1;
            long n3 = kM - table.u3[i];

            while (true) {
                i -= 3;
                while (i >= 0) {
                    if (table.u1[i] != n1) {
                        if (table.u1[i] < n1)
                            break;
                    } else if (table.u2[i] != n2) {
                        if (table.u2[i] < n2)
                            break;
                    } else if (table.u3[i] <= n3) {
                        break;
                    }
                    i--;
                }

                rep++;
                n1 -= table.u1[i];
                n2 -= table.u2[i];
                n3 -= table.u3[i];

                if (n3 < 0) {
                    n3 += kM;
                    n2--;
                }
                if (n2 < 0) {
                    n2 += kM;
                    n1--;
                }

                if (n1 == 0 && n2 == 0 && n3 < 1000) {
                    sm += rep;
                    break;
                }
            }
        }
        return sm;
    }

    public static String solve() {
        return Long.toString(solveCalc(5000000));
    }

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