Theatre Square in the capital city of Berland has a rectangular shape with the size *n* × *m* meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size *a* × *a*.

What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Theatre Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square.
The input contains three positive integer numbers in the first line: *n*,  *m* and *a* (1 ≤  *n*, *m*, *a* ≤ 10<sup class="upper-index">9</sup>).
6 6 4
4
1 1 1
1
2 1 1
2
1 2 1
2
2 2 1
4
2 1 2
1
1 1 3
1
2 3 4
1
1000000000 1000000000 1
1000000000000000000
12 13 4
12
222 332 5
3015
1000 1000 10
10000
1001 1000 10
10100
100 10001 1000000000
1
1000000000 1000000000 1000000000
1
1000000000 1000000000 999999999
4
1000000000 1000000000 192
27126743055556
1000000000 987654321 1
987654321000000000
456784567 1000000000 51
175618850864484
39916800 134217728 40320
3295710
from collections import deque
import heapq
from math import gcd, lcm
import os
import sys
LOCAL = True
try:
    open(f"{os.path.realpath(os.path.dirname(__file__))}/../generator.py")
except:
    LOCAL = False

# MOD = 10 ** 9 + 7
MOD = 998244353

INF = 10 ** 100
def sqrt(n):
    if n < 0:
        return -1
    a = 0
    b = n
    while a != b:
        mid = (a + b) // 2
        if mid * mid < n:
            a = mid + 1
        else:
            b = mid
    if a * a != n:
        return -1
    return a
def inv(n):
    return pow(n % MOD, MOD - 2, MOD)
fib_mem = [0, 1]
def fib(n, cache=True):
    if not cache:
        a, b = 0, 1
        for _ in range(n):
            a, b = b % MOD, (a + b) % MOD
        return a
    else:
        while len(fib_mem) < n + 1:
            fib_mem.append((fib_mem[-1] + fib_mem[-2]) % MOD)
        return fib_mem[n]
fac_mem = [1]
def fac(n, cache=True):
    if not cache:
        r = 1
        for i in range(1, n + 1):
            r = (r * i) % MOD
        return r
    else:
        while len(fac_mem) < n + 1:
            fac_mem.append(fac_mem[-1] * len(fac_mem) % MOD)
        return fac_mem[n]
def perm(n, k, cache=True):
    return fac(n, cache=cache) * inv(fac(k, cache=cache)) % MOD
def comb(n, k, cache=True):
    return fac(n, cache=cache) * inv(fac(k, cache=cache) * fac(n - k, cache=cache)) % MOD
def comb_row(n):
    yield 1
    r = 1
    for k in range(1, n + 1):
        r = r * (n + 1 - k) * inv(k) % MOD
        yield r
def prod(l):
    r = 1
    for i in l:
        r *= i
    return r
def is_prime(n):
    if n <= 3:
        return n >= 2
    if n % 2 == 0:
        return False
    if n % 3 == 0:
        return False
    d = 5
    while d * d <= n:
        if n % d == 0:
            return False
        d += (9 - d % 6) >> 1
    return True
def factor(n):
    p = []
    while n % 2 == 0:
        p.append(2)
        n >>= 1
    while n % 3 == 0:
        p.append(3)
        n //= 3
    d = 5
    while d * d <= n:
        while n % d == 0:
            n //= d
            p.append(d)
        d += (9 - d % 6) // 2
    if n > 1:
        p.append(n)
    return p
def count(l):
    r = {}
    for i in l:
        r[i] = r.get(i, 0) + 1
    return r
def first_such(pred, a=0, b=None):
    if b == None:
        b = max(1, a)
        while not pred(b):
            b *= 2
    while a < b:
        mid = (a + b) // 2
        if pred(mid):
            b = mid
        else:
            a = mid + 1
    if a > b:
        return None
    return a
def last_such(pred, a=0, b=None):
    if b == None:
        b = max(1, a)
        while not pred(b):
            b *= 2
    while a < b:
        mid = (a + b + 1) // 2
        if pred(mid):
            b = mid - 1
        else:
            a = mid
    if a > b:
        return None
    return a
def halt_and_catch_fire():
    [*range(10 ** 18)]
def ints():
    return [int(j) for j in input().split()]
def chars():
    return list(input())
def deb(*l, **kwargs):
    if LOCAL:
        print("\033[2m", end="")
        print(*l, **kwargs)
        print("\033[0m", end="")
def ans(*l, **kwargs):
    if LOCAL:
        print("\033[32m", end="")
    if l and type(l[0]) == bool:
        print(["NO", "YES"][l[0]], **kwargs)
    else:
        print(*l, **kwargs)
    if LOCAL:
        print("\033[0m", end="")

#####

n, m, a = ints()

deb(((m - 1) // a + 1) * ((n - 1) // a + 1))