public class Euler775 {
    static final long MOD = 1000000007L;
    static final long INV2 = (MOD + 1) / 2;

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

    static long icbrt(long n) {
        if (n == 0)
            return 0;
        long x = (long) Math.cbrt((double) n);
        while ((x + 1) * (x + 1) * (x + 1) <= n)
            x++;
        while (x * x * x > n && x > 0)
            x--;
        return x;
    }

    static long p2Prefix(long r) {
        if (r == 0)
            return 0;
        long s = isqrt(r);
        if (s * s < r)
            s++;
        long k = s - 1;

        long base = (8L * k * k * k + 3L * k * k + k) / 3L;
        long consumed = k * k;
        long rem = r - consumed;

        long len1 = (rem < (s - 1)) ? rem : (s - 1);
        long len2 = rem - len1;

        long add1 = len1 * (4L * s - 2L);
        long add2 = len2 * (4L * s);

        return base + add1 + add2;
    }

    static long modMul(long a, long b) {
        return (a * b) % MOD;
    }

    static long modSumRange(long l, long r) {
        if (l > r)
            return 0;
        long len = (r - l + 1) % MOD;
        long ends = ((l % MOD) + (r % MOD)) % MOD;
        return modMul(modMul(len, ends), INV2);
    }

    static long addPhase(long acc, long L, long R, long capN, long base, long rBase) {
        if (L > capN)
            return acc;
        long left = L;
        long right = (R < capN) ? R : capN;
        if (left > right)
            return acc;

        long lenU = right - left + 1;
        long len = lenU % MOD;
        long sumN = modSumRange(left, right);

        long rr = right - rBase;
        long ll = left - rBase;
        long sumPU = p2Prefix(rr) - p2Prefix((ll == 0) ? 0 : (ll - 1));
        long sumP = sumPU % MOD;

        long cur = modMul(6, sumN);
        cur = (cur - modMul(len, base % MOD) + MOD) % MOD;
        cur = (cur - sumP + MOD) % MOD;

        acc += cur;
        if (acc >= MOD)
            acc -= MOD;
        return acc;
    }

    static long GMod(long N) {
        long ans = 0;
        long mMax = icbrt(N);

        for (long m = 1; m <= mMax; m++) {
            long m2 = m * m;
            long mp1 = m + 1;

            long v0 = m * m2;
            long v1 = m2 * mp1;
            long v2 = m * mp1 * mp1;
            long v3 = mp1 * mp1 * mp1;

            long s0 = 6 * m2;
            long s1 = 2 * (m2 + 2 * m * mp1);
            long s2 = 2 * (2 * m * mp1 + mp1 * mp1);

            ans = addPhase(ans, v0, v1, N, s0, v0);
            ans = addPhase(ans, v1 + 1, v2, N, s1, v1);
            ans = addPhase(ans, v2 + 1, v3 - 1, N, s2, v2);
        }

        return ans;
    }

    public static String solve() {
        return Long.toString(GMod(10000000000000000L));
    }

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