package main

import (
	"fmt"
	"math"
)

const MOD int64 = 1000000007

func add(a, b int64) int64 {
	return (a + b) % MOD
}

func sub(a, b int64) int64 {
	return (a%MOD - b%MOD + MOD) % MOD
}

func mul(a, b int64) int64 {
	return (a % MOD) * (b % MOD) % MOD
}

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = mul(res, base)
		}
		base = mul(base, base)
		exp /= 2
	}
	return res
}

func inv(n int64) int64 {
	return power(n, MOD-2)
}

func main() {
	var m int64
	if _, err := fmt.Scan(&m); err != nil {
		return
	}

	inv6 := inv(6)
	inv30 := inv(30)
	inv42 := inv(42)

	M := m % MOD
	A := mul(mul(M, M+1), M+2)
	B := add(mul(3, M), 4)
	C := sub(0, add(mul(3, M), 6))
	D := int64(2)

	eval6P := func(d int64) int64 {
		d = d % MOD
		d2 := mul(d, d)
		d3 := mul(d2, d)
		res := A
		res = add(res, mul(B, d))
		res = add(res, mul(C, d2))
		res = add(res, mul(D, d3))
		return res
	}

	ans := mul(eval6P(1), inv6)

	limitX := int64(math.Sqrt(float64(m)))

	for x := int64(1); x <= limitX; x++ {
		x2 := x * x
		ans = add(ans, mul(4, mul(eval6P(x2), inv6)))

		maxY := int64(math.Sqrt(float64(m - x2)))
		if maxY < 1 {
			continue
		}

		y := maxY % MOD
		y2 := mul(y, y)
		y3 := mul(y2, y)
		y4 := mul(y2, y2)

		T := mul(mul(y, y+1), add(mul(2, y), 1))

		S0 := y
		S2 := mul(T, inv6)

		term4 := sub(add(mul(3, y2), mul(3, y)), 1)
		S4 := mul(mul(T, term4), inv30)

		term6 := add(sub(add(mul(3, y4), mul(6, y3)), mul(3, y)), 1)
		S6 := mul(mul(T, term6), inv42)

		mx2 := x2 % MOD
		mx4 := mul(mx2, mx2)
		mx6 := mul(mx4, mx2)

		s0 := S0
		s1 := add(mul(mx2, S0), S2)
		s2 := add(add(mul(mx4, S0), mul(mul(2, mx2), S2)), S4)
		s3 := add(add(mul(mx6, S0), mul(mul(3, mx4), S2)), add(mul(mul(3, mx2), S4), S6))

		sum6P := A
		sum6P = mul(sum6P, s0)
		sum6P = add(sum6P, mul(B, s1))
		sum6P = add(sum6P, mul(C, s2))
		sum6P = add(sum6P, mul(D, s3))

		ans = add(ans, mul(4, mul(sum6P, inv6)))
	}

	fmt.Println(ans)
}