You are given integers N and K. Find the number of triples (a,b,c) of positive integers not greater than N such that a+b,b+c and c+a are all multiples of K.
The order of a,b,c does matter, and some of them can be the same.

-----Constraints-----
 - 1 \leq N,K \leq 2\times 10^5
 - N and K are integers.

-----Input-----
Input is given from Standard Input in the following format:
N K

-----Output-----
Print the number of triples (a,b,c) of positive integers not greater than N such that a+b,b+c and c+a are all multiples of K.

-----Sample Input-----
3 2

-----Sample Output-----
9

(1,1,1),(1,1,3),(1,3,1),(1,3,3),(2,2,2),(3,1,1),(3,1,3),(3,3,1) and (3,3,3) satisfy the condition.

Difficulty: EASY

Solutions:
(n, k) = map(int, input().split())
(cnt1, cnt2) = (0, 0)
if k % 2 == 1:
	for i in range(1, n + 1):
		if i % k == 0:
			cnt1 += 1
	print(cnt1 ** 3)
else:
	for i in range(1, n + 1):
		if i % k == k // 2:
			cnt2 += 1
	for i in range(1, n + 1):
		if i % k == 0:
			cnt1 += 1
	print(cnt1 ** 3 + cnt2 ** 3)


(N, K) = (int(T) for T in input().split())
Reminder = [0] * K
for NT in range(1, N + 1):
	Reminder[NT % K] += 1
Count = 0
for RA in range(0, K):
	RB = (K - RA) % K
	RC = (K - RA) % K
	if (RB + RC) % K == 0:
		Count += Reminder[RA] * Reminder[RB] * Reminder[RC]
print(Count)


(n, k) = list(map(int, input().split()))
ans = 0
if k % 2 != 0:
	ans = (n // k) ** 3
else:
	ans = (n // k) ** 3 + ((n + k // 2) // k) ** 3
print(ans)


(N, K) = map(int, input().split())
print((N // K) ** 3 if K % 2 == 1 else (N // K) ** 3 + ((N - K // 2) // K + 1) ** 3)


(n, k) = list(map(int, input().split()))
s = 0
if k % 2 == 1:
	s = (n // k) ** 3
else:
	s = (n // k) ** 3 + (n // (k // 2) - n // k) ** 3
print(s)


(n, k) = list(map(int, input().split()))
n_O = 0
n_E = 0
for i in range(1, n + 1):
	if 2 * i % k == 0:
		if 2 * i // k % 2 == 0:
			n_E += 1
		else:
			n_O += 1
print(n_E ** 3 + n_O ** 3)


import sys
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.141592653589793

def read_str():
	return sys.stdin.readline().strip()

def read_int():
	return int(sys.stdin.readline().strip())

def read_ints():
	return map(int, sys.stdin.readline().strip().split())

def read_ints2(x):
	return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())

def read_str_list():
	return list(sys.stdin.readline().strip().split())

def read_int_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def lcm(a: int, b: int) -> int:
	return a * b // math.gcd(a, b)

def Main():
	(n, k) = read_ints()
	if k % 2:
		print((n // k) ** 3)
	else:
		print((n // k) ** 3 + ((n + k // 2) // k) ** 3)

def __starting_point():
	Main()
__starting_point()


(N, K) = map(int, input().split())
if K % 2 == 0:
	ans = (N // K) ** 3 + ((N + K // 2) // K) ** 3
	print(ans)
else:
	print((N // K) ** 3)


import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

def I():
	return int(input())

def F():
	return float(input())

def SS():
	return input()

def LI():
	return [int(x) for x in input().split()]

def LI_():
	return [int(x) - 1 for x in input().split()]

def LF():
	return [float(x) for x in input().split()]

def LSS():
	return input().split()

def resolve():
	(N, K) = LI()
	num_0 = N // K
	if K % 2 == 0:
		num_K_half = N // K + (1 if N % K >= K // 2 else 0)
	else:
		num_K_half = 0
	ans = num_0 ** 3 + num_K_half ** 3
	print(ans)

def __starting_point():
	resolve()
__starting_point()


def readinput():
	(n, k) = list(map(int, input().split()))
	return (n, k)

def main(n, k):
	m = n // k
	count = m * m * m
	if k % 2 == 0:
		m = (n + k // 2) // k
		count += m * m * m
	return count

def __starting_point():
	(n, k) = readinput()
	ans = main(n, k)
	print(ans)
__starting_point()


(n, k) = map(int, input().split())
ans = 0
if k > 2 * n:
	print(ans)
else:
	r = k
	for i in range(1, k):
		if 2 * i % k == 0:
			r = i
	amari = set()
	for i in range(1, (n - r) // r + 1 + 1):
		if r * i % k in amari:
			continue
		else:
			amari.add(r * i % k)
			q = (n - r * i) // k + 1
			ans += q ** 3
	print(ans)


(n, k) = list(map(int, input().split()))
am_0 = []
am_k2 = []
if k % 2 == 0:
	for i in range(1, n + 1):
		if i % k == 0:
			am_0.append(i)
		elif i % k == k // 2:
			am_k2.append(i)
	print(len(am_0) ** 3 + len(am_k2) ** 3)
else:
	print(pow(n // k, 3))


(n, k) = list(map(int, input().split()))
ans = 0
for a in range(1, n + 1):
	ra = a % k
	rbc = k - ra
	if 2 * rbc % k == 0:
		ans += ((n - rbc) // k + 1) ** 2
print(ans)


(n, k) = map(int, input().split())
if k % 2 == 1:
	print((n // k) ** 3)
else:
	print(((n + k // 2) // k) ** 3 + (n // k) ** 3)


(a, b) = list(map(int, input().split()))
if b % 2 == 1:
	print((a // b) ** 3)
else:
	c = (a - b / 2) // b + 1
	print(int((a // b) ** 3 + c ** 3))


import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	(N, K) = list(map(int, readline().split()))
	ans = pow(N // K, 3)
	if K % 2 == 0 and N >= K // 2:
		ans += pow((N - K // 2) // K + 1, 3)
	print(ans)
	return

def __starting_point():
	main()
__starting_point()


from collections import Counter
import numpy as np
(N, K) = list(map(int, input().split(' ')))
mods = np.arange(1, N + 1) % K
counter = Counter(mods)
ans = 0
for a in list(counter.keys()):
	if (a + a) % K == 0:
		ans += counter[a] ** 3
print(ans)


(n, k) = [int(i) for i in input().split()]
if k % 2 == 1:
	print((n // k) ** 3)
else:
	print((n // k) ** 3 + (n // k + n % k // (k // 2)) ** 3)


(N, K) = map(int, input().split())
if K % 2 == 1:
	print((N // K) ** 3)
else:
	a = N // K
	t = K // 2
	b = (N - t) // K + 1
	print(a ** 3 + b ** 3)


import math
from math import gcd, pi, sqrt
INF = float('inf')
import sys
sys.setrecursionlimit(10 ** 6)
import itertools
from collections import Counter, deque

def i_input():
	return int(input())

def i_map():
	return list(map(int, input().split()))

def i_list():
	return list(i_map())

def i_row(N):
	return [i_input() for _ in range(N)]

def i_row_list(N):
	return [i_list() for _ in range(N)]

def s_input():
	return input()

def s_map():
	return input().split()

def s_list():
	return list(s_map())

def s_row(N):
	return [s_input for _ in range(N)]

def s_row_str(N):
	return [s_list() for _ in range(N)]

def s_row_list(N):
	return [list(s_input()) for _ in range(N)]

def main():
	(n, k) = i_map()
	R = [0] * k
	for i in range(1, n + 1):
		R[i % k] += 1
	ans = 0
	for a in range(k):
		b = (k - a) % k
		if 2 * b % k == 0:
			ans += R[a] * R[b] * R[b]
	print(ans)

def __starting_point():
	main()
__starting_point()


(N, K) = map(int, input().split())
res = (N // K) ** 3
if K % 2 == 0:
	res += ((N - K // 2) // K + 1) ** 3
print(res)


(n, k) = map(int, input().split())
if k % 2 == 1:
	ans = (n // k) ** 3
elif k <= 2 * n:
	a = n // (k // 2)
	b = a // 2
	ans = (a - b) ** 3 + b ** 3
else:
	ans = 0
print(ans)


(N, K) = map(int, input().split())
ans = 0
if K % 2 == 1:
	print((N // K) ** 3)
else:
	ans = (N // K) ** 3
	k = K // 2
	j = (N + k) // K
	print(j ** 3 + ans)


(n, k) = map(int, input().split())
candidOdd = 0
candidEven = 0
candidEven2 = 0
for i in range(1, n + 1):
	if k % 2 == 1:
		if i % k == 0:
			candidOdd += 1
	elif i % k == 0:
		candidEven += 1
	elif i % k == k / 2:
		candidEven2 += 1
print(candidOdd ** 3 + candidEven ** 3 + candidEven2 ** 3)


import sys

def input():
	return sys.stdin.readline().rstrip()

def main():
	(N, K) = list(map(int, input().split()))
	if K % 2 == 1:
		a = N // K
		print(a * a * a)
		return
	else:
		a = N // K
		count = a * a * a
		b = (N + K // 2) // K
		count += b * b * b
		print(count)

def __starting_point():
	main()
__starting_point()


(N, K) = map(int, input().split())
if K % 2 == 1:
	print((N // K) ** 3)
	return
k = K // 2
t = N // k - N // K
print(t ** 3 + (N // K) ** 3)


(n, k) = map(int, input().split())
if k % 2 == 1:
	ans = (n // k) ** 3
if k % 2 == 0:
	mk2 = n // (k // 2)
	mk = n // k
	ans = mk ** 3 + (mk2 - mk) ** 3
print(ans)


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	(n, k) = LI()
	if k % 2 == 0:
		return (n // (k // 2) - n // k) ** 3 + (n // k) ** 3
	return (n // k) ** 3
print(main())


(n, k) = list(map(int, input().split()))
count_0 = 0
count_half = 0
for i in range(1, n + 1):
	if i % k == k / 2:
		count_half += 1
	elif i % k == 0:
		count_0 += 1
print(count_half ** 3 + count_0 ** 3)


(n, k) = list(map(int, input().split()))
kcd = 0
kcd_half = 0
for i in range(1, n + 1):
	if k & 1 and i % k == 0:
		kcd += 1
	elif not k & 1:
		if i % k == 0:
			kcd += 1
		if i % k == k // 2:
			kcd_half += 1
print(kcd * kcd * kcd + kcd_half * kcd_half * kcd_half)


(N, K) = list(map(int, input().split()))
l = [0] * K
for i in range(1, N + 1):
	l[i % K] += 1
ans = 0
for ai in range(K):
	bi = (K - ai) % K
	ci = (K - ai) % K
	if (bi + ci) % K == 0:
		ans += l[ai] * l[bi] * l[ci]
print(ans)


(n, k) = map(int, input().split())
mod_0 = 0
mod_harf = 0
for i in range(1, n + 1):
	if i % k == 0:
		mod_0 += 1
	elif i % k == -i % k:
		mod_harf += 1
res = mod_0 ** 3 + mod_harf ** 3
print(res)


(N, K) = list(map(int, input().split()))
num = [0] * K
for i in range(1, N + 1):
	num[i % K] += 1
ans = 0
for a in range(K):
	b = (K - a) % K
	c = (K - a) % K
	if (b + c) % K != 0:
		continue
	ans += num[a] * num[b] * num[c]
print(ans)


(N, K) = map(int, input().split())
ans = 0
for r in range(K):
	n = (N + K - r) // K
	if r == 0:
		n -= 1
	if r * 2 % K == 0:
		ans += n ** 3
print(ans)


(N, K) = list(map(int, input().split()))
if K % 2 != 0:
	ans = (N // K) ** 3
else:
	k = N // K
	k_ = N // (K // 2)
	ans = k ** 3 + (k_ - k) ** 3
print(ans)


import itertools
ans = 0
(N, K) = [int(i) for i in input().split()]
x = 0
y = 0
for i in range(1, N + 1):
	if i % K == 0:
		x += 1
	if K % 2 == 0 and i % K == K // 2:
		y += 1
print(x ** 3 + y ** 3)


(n, k) = map(int, input().split())
if k == 1:
	print(n ** 3)
elif k == 2:
	m = n % 2
	o = n // 2
	print((o + m) ** 3 + o ** 3)
elif k % 2 == 1:
	x = n // k
	print(x ** 3)
else:
	x = n // k
	y = n // (k // 2)
	print(x ** 3 + (y - x) ** 3)


(n, k) = map(int, input().split())
if k % 2 == 1:
	x = 0
	for i in range(1, n + 1):
		if i % k == 0:
			x += 1
	print(x ** 3)
else:
	x = 0
	for i in range(1, n + 1):
		if i % k == 0:
			x += 1
	y = 0
	for i in range(1, n + 1):
		if i % k == k // 2:
			y += 1
	print(x ** 3 + y ** 3)


(n, k) = list(map(int, input().split()))
if k % 2 == 0:
	k //= 2
	a = n // k
	even = a // 2
	if a % 2 == 0:
		odd = even
	else:
		odd = even + 1
	ans = even ** 3 + odd ** 3
else:
	ans = (n // k) ** 3
print(ans)


(N, K) = list(map(int, input().split()))
modZeroCount = N // K
modHalfCount = 0
if K % 2 == 0:
	modHalf = K // 2
	if N % K < modHalf:
		modHalfCount = modZeroCount
	else:
		modHalfCount = modZeroCount + 1
answer = modZeroCount ** 3 + modHalfCount ** 3
print(answer)


def main():
	(n, k) = list(map(int, input().split()))
	if k % 2 == 1:
		c = n // k
		print(c ** 3)
		return
	if k % 2 == 0:
		c = (n - k // 2) // k + 1
		ans = c ** 3
		c = n // k
		print(ans + c ** 3)

def __starting_point():
	main()
__starting_point()


(n, k) = map(int, input().split())
am = [0] * k
for i in range(1, n + 1):
	res = i % k
	if (res + res) % k == 0:
		am[res] += 1
ans = 0
for i in am:
	ans += i ** 3
print(ans)


def main():
	(n, k) = list(map(int, input().split()))
	ans = 0
	if k % 2 == 0:
		kouho1 = []
		kouho2 = []
		for i in range(1, n + 1):
			if i % k == 0:
				kouho1.append(i)
			elif i % k == k / 2:
				kouho2.append(i)
		ans += len(kouho1) ** 3
		ans += len(kouho2) ** 3
	else:
		kouho = []
		for i in range(1, n + 1):
			if i % k == 0:
				kouho.append(i)
		ans += len(kouho) ** 3
	print(ans)
main()


(n, k) = map(int, input().split())
j = 0
m = 0
ans = 0
if k % 2 == 1:
	j = n // k
	ans = j * j * j
else:
	j = n // k
	m = (n - k // 2) // k + 1
	ans = m * m * m + j * j * j
print(ans)


(N, K) = map(int, input().split())
s = N // K
t = N % K
ans = s ** 3
if K % 2 == 0:
	u = K // 2
	if t < u:
		ans += s ** 3
	else:
		ans += (s + 1) ** 3
print(ans)


(n, k) = list(map(int, input().split()))
s = []
for i in range(1, n + 1):
	s.append(i % k)
from collections import Counter
dic = Counter(s)
ans = 0
for a in dic:
	if 2 * a % k == 0:
		ans = ans + dic[a] * dic[(k - a) % k] * dic[(k - a) % k]
print(ans)


def main():
	(N, K) = [int(n) for n in input().split(' ')]
	mul_K = int(N / K)
	if K % 2 == 1:
		print(mul_K ** 3)
		return 0
	mul_K_half = int(2 * N / K)
	mul_K_half_but_K = mul_K_half - mul_K
	print(mul_K ** 3 + mul_K_half_but_K ** 3)
	return 0
main()


import sys
input = sys.stdin.readline
(N, K) = list(map(int, input().split()))
if K % 2 == 0:
	A = list(range(K // 2, N + 1, K))
	B = list(range(K, N + 1, K))
else:
	A = list(range(K, N + 1, K))
	B = []
print(len(A) ** 3 + len(B) ** 3)


(N, K) = map(int, input().split())
if K % 2 == 1:
	c = N // K
	ans = c * (c - 1) * (c - 2) + 3 * c * (c - 1) + c
	print(ans)
else:
	K //= 2
	e = 0
	o = 0
	for i in range(1, N + 1):
		if i % K == 0:
			if i // K % 2 == 0:
				e += 1
			else:
				o += 1
	c = e
	ans = c * (c - 1) * (c - 2) + 3 * c * (c - 1) + c
	c = o
	ans += c * (c - 1) * (c - 2) + 3 * c * (c - 1) + c
	print(ans)


(n, k) = map(int, input().split())
rem0 = n // k
remhalf = n // k + 1 if n // k * k + k // 2 <= n else n // k
ans = rem0 ** 3 + (remhalf ** 3 if k % 2 == 0 else 0)
print(ans)


import sys

def solve(N: int, K: int):
	e = sum((i % K != 0 and i * 2 % K == 0 for i in range(1, N + 1)))
	z = sum((i % K == 0 for i in range(1, N + 1)))
	return pow(e, 3) + pow(z, 3)

def main():

	def iterate_tokens():
		for line in sys.stdin:
			for word in line.split():
				yield word
	tokens = iterate_tokens()
	N = int(next(tokens))
	K = int(next(tokens))
	print(solve(N, K))

def test():
	import doctest
	doctest.testmod()

def __starting_point():
	main()
__starting_point()


(N, K) = list(map(int, input().split()))
if K % 2 == 0:
	x = N // (K // 2)
	print((x - x // 2) ** 3 + (x // 2) ** 3)
else:
	print((N // K) ** 3)


import numpy as np
import sys
from collections import deque
from collections import defaultdict
import heapq
import collections
import itertools
import bisect
sys.setrecursionlimit(10 ** 6)

def zz():
	return list(map(int, sys.stdin.readline().split()))

def z():
	return int(sys.stdin.readline())

def S():
	return sys.stdin.readline()

def C(line):
	return [sys.stdin.readline() for _ in range(line)]

def nck(n, k, mod=10 ** 9 + 7):
	bunbo = bunshi = 1
	for i in range(k):
		bunshi = bunshi * (n - i) % mod
		bunbo = bunbo * (i + 1) % mod
	return bunshi * pow(bunbo, mod - 2, mod) % mod
(N, K) = zz()
ans = 0
modK = 0
if K % 2 == 0:
	mod0 = N // K
	ans += mod0 ** 3
	a = (N + K // 2) // K
	ans += a ** 3
else:
	mod0 = N // K
	ans = mod0 ** 3
print(ans)


(n, k) = list(map(int, input().split()))
num = [0] * k
for i in range(1, n + 1):
	num[i % k] += 1
ans = 0
for a in range(k):
	b = (k - a) % k
	c = (k - a) % k
	if (b + c) % k != 0:
		continue
	ans += num[a] * num[b] * num[c]
print(ans)


(n, k) = map(int, input().split())
a = 0
a2 = 0
for i in range(1, n + 1):
	if i % k == 0:
		a += 1
	elif 2 * i % k == 0:
		a2 += 1
print(a ** 3 + a2 ** 3)


def solve():
	(n, k) = list(map(int, input().split()))
	if k % 2 != 0:
		print((n // k) ** 3)
	else:
		print((n // k) ** 3 + ((n + k // 2) // k) ** 3)

def __starting_point():
	solve()
__starting_point()


def main():
	(n, k) = map(int, input().split())
	ans = 0
	baisuu = n // k
	ans += baisuu ** 3
	if k % 2 == 0:
		if baisuu * k + k // 2 <= n:
			hanbun = baisuu + 1
		else:
			hanbun = baisuu
		ans += hanbun ** 3
	print(ans)

def __starting_point():
	main()
__starting_point()


import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	(N, K) = list(map(int, readline().split()))
	R = [0] * K
	for i in range(1, N + 1):
		R[i % K] += 1
	ans = 0
	for a in range(K):
		b = c = (K - a) % K
		if (b + c) % K == 0:
			ans += R[a] * R[b] * R[c]
	print(ans)
	return

def __starting_point():
	main()
__starting_point()


(n, k) = list(map(int, input().split()))
n0 = n // k
ans = pow(n0, 3)
if k % 2 == 0:
	r = n % k
	ans += pow(n0 + int(n % k >= k // 2), 3)
print(ans)


(n, k) = map(int, input().split())
r = n // k
res = r ** 3
if k % 2 == 0:
	s = r
	if n % k >= k // 2:
		s += 1
	res += s ** 3
print(res)


import sys
input = sys.stdin.readline
(N, K) = map(int, input().split())
multip_K = [i for i in range(K, N + 1, K)]
le = len(multip_K)
ans_mod_0 = le ** 3
ans_mod_haf = 0
if K % 2 == 0:
	multip_haf = [i for i in range(1, N + 1) if i % K == K // 2]
	le_haf = len(multip_haf)
	ans_mod_haf = le_haf ** 3
ans = ans_mod_0 + ans_mod_haf
print(ans)


(n, k) = list(map(int, input().split()))
num = [0] * (k + 1)
for i in range(1, n + 1):
	num[i % k] += 1
ans = 0
for a in range(1, n + 1):
	mod = a % k
	temp_mod = (k - mod) % k
	if temp_mod * 2 % k != 0:
		continue
	ans += num[temp_mod] ** 2
print(ans)


a = list(map(int, input().split()))
b = a[0] // a[1]
if a[1] % 2 != 0:
	print(b ** 3)
elif a[0] % a[1] >= a[1] // 2:
	print(b ** 3 + (b + 1) ** 3)
else:
	print(2 * b ** 3)


(n, k) = map(int, input().split())
if k % 2 == 0:
	cnt1 = n // k
	cnt2 = n // k
	if n % k >= k // 2:
		cnt2 += 1
	print(cnt1 ** 3 + cnt2 ** 3)
else:
	print((n // k) ** 3)


import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	(N, K) = list(map(int, readline().split()))
	ans = 0
	step = K if K % 2 else K // 2
	for a in range(step, N + 1, step):
		l = a // K + 1
		r = (N + a) // K
		if r >= l:
			ans += (r - l + 1) ** 2
	print(ans)
	return

def __starting_point():
	main()
__starting_point()


(N, K) = list(map(int, input().split()))
ans = 0
if K % 2 == 0:
	d1 = N // (K // 2)
	d2 = N // K
	ans = d2 ** 3 + (d1 - d2) ** 3
else:
	d = N // K
	ans = d ** 3
print(ans)


(N, K) = map(int, input().split())
if K % 2 == 1:
	n = N // K
	print(n ** 3)
	return
n = N // (K // 2)
(n_odd, n_even) = ((n + 1) // 2, n // 2)
print(n_odd ** 3 + n_even ** 3)


def solve(N, K):
	div0 = N // K
	divh = (N + K // 2) // K if K % 2 == 0 else 0
	import math
	print(div0 ** 3 + divh ** 3)

def __starting_point():
	(N, K) = list(map(int, input().split()))
	solve(N, K)
__starting_point()


(n, k) = list(map(int, input().split()))
R = []
Ro = []
if k % 2 != 0:
	for i in range(1, n + 1):
		if i % k == 0:
			R.append(i)
	print(len(R) ** 3)
else:
	for i in range(1, n + 1):
		if i % k == 0:
			R.append(i)
		if i % k == k // 2:
			Ro.append(i)
	print(len(R) ** 3 + len(Ro) ** 3)


(n, k) = map(int, input().split())
res = 0
for i in range(1, n + 1):
	a = i % k
	b = -a % k
	c = -a % k
	if (b + c) % k == 0:
		res += (n + b) // k * ((n + c) // k)
print(res)