public class Euler914 {

    static long isqrt(long x) {
        long r = (long) Math.sqrt((double) x);
        while ((r + 1) * (r + 1) <= x) {
            ++r;
        }
        while (r * r > x) {
            --r;
        }
        return r;
    }

    static long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static long bestForN(long R, long n) {
        long C = 2 * R;
        long nn = n * n;
        if (nn >= C) {
            return 0;
        }

        long t = C - 1 - nn;
        long m = isqrt(t);
        if (m <= n) {
            return 0;
        }

        if (((m ^ n) & 1L) == 0L) {
            --m;
        }

        while (m > n && gcd(m, n) != 1) {
            m -= 2;
        }

        if (m <= n) {
            return 0;
        }

        return n * (m - n);
    }

    static long fastF(long R) {
        long C = 2 * R;
        double sqrt2 = Math.sqrt(2.0);
        double denom = 4.0 + 2.0 * sqrt2;
        double Cld = (double) (C - 1);

        long n0 = Math.round(Math.sqrt(Cld / denom));
        if (n0 == 0) {
            n0 = 1;
        }

        long best = 0;
        int kWindow = 4096;
        for (int d = -kWindow; d <= kWindow; ++d) {
            long ni = n0 + d;
            if (ni <= 0) {
                continue;
            }
            long cand = bestForN(R, ni);
            if (cand > best) {
                best = cand;
            }
        }

        double n0ld = (double) n0;
        double nmaxld = Math.sqrt(Cld / 2.0);

        double left = n0ld;
        double right = n0ld;

        double ubN0 = n0ld <= 0 || Cld - n0ld * n0ld <= 0 ? 0.0 : n0ld * (Math.sqrt(Cld - n0ld * n0ld) - n0ld);

        if (ubN0 > (double) best) {
            double lo = 0.0;
            double hi = n0ld;
            for (int it = 0; it < 140; ++it) {
                double mid = (lo + hi) * 0.5;
                double ubMid = mid <= 0 || Cld - mid * mid <= 0 ? 0.0 : mid * (Math.sqrt(Cld - mid * mid) - mid);
                if (ubMid > (double) best) {
                    hi = mid;
                } else {
                    lo = mid;
                }
            }
            left = hi;

            lo = n0ld;
            hi = nmaxld;
            for (int it = 0; it < 140; ++it) {
                double mid = (lo + hi) * 0.5;
                double ubMid = mid <= 0 || Cld - mid * mid <= 0 ? 0.0 : mid * (Math.sqrt(Cld - mid * mid) - mid);
                if (ubMid > (double) best) {
                    lo = mid;
                } else {
                    hi = mid;
                }
            }
            right = lo;
        }

        long L = 1;
        if (left > 16.0) {
            L = (long) Math.floor(left) - 16;
        }

        long nMax = isqrt((C - 1) / 2);
        long Rn = (long) Math.ceil(right) + 16;
        if (Rn > nMax) {
            Rn = nMax;
        }

        for (long n = L; n <= Rn; ++n) {
            long nn = n * n;
            if (nn >= C) {
                break;
            }
            long mmax = isqrt(C - 1 - nn);
            if (mmax <= n) {
                continue;
            }
            long ub = n * (mmax - n);
            if (ub <= best) {
                continue;
            }

            long cand = bestForN(R, n);
            if (cand > best) {
                best = cand;
            }
        }

        return best;
    }

    public static String solve() {
        return Long.toString(fastF(1000000000000000000L));
    }

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