import java.util.HashMap;

public class Euler884 {

    static long floorCuberoot(long x) {
        long k = (long) Math.cbrt(x);
        while (cube(k + 1) <= x && cube(k + 1) > 0)
            ++k;
        while (cube(k) > x || cube(k) < 0)
            --k;
        return k;
    }

    static long cube(long k) {
        return k * k * k; // Assumes it won't overflow for the values we need
    }

    static class Solver {
        long[] A;
        HashMap<Long, Long> memo = new HashMap<>(30000);

        long solveRec(long x, long readyK) {
            if (x <= 1)
                return 0;
            Long cached = memo.get(x);
            if (cached != null)
                return cached;

            long k = floorCuberoot(x - 1);
            long c = cube(k);
            long t = x - c;

            long ans = A[(int) k] + t + solveRec(t, readyK);
            memo.put(x, ans);
            return ans;
        }

        long SFast(long N) {
            if (N <= 1)
                return 0;

            long K = floorCuberoot(N - 1);
            A = new long[(int) K + 1];

            memo.put(0L, 0L);
            memo.put(1L, 0L);

            for (long k = 1; k < K; ++k) {
                long delta = 3 * k * k + 3 * k + 1;
                long sdelta = solveRec(delta, k);
                A[(int) (k + 1)] = A[(int) k] + delta + sdelta;
                memo.put(cube(k + 1), A[(int) (k + 1)]);
            }

            return solveRec(N, K);
        }
    }

    public static String solve() {
        Solver solver = new Solver();
        return Long.toString(solver.SFast(100000000000000000L));
    }

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