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
import sys
from math import *
import builtins
import string
import bisect
import os
from io import BytesIO, IOBase

alphabets = list(string.ascii_lowercase)
ALPHABETS = list(string.ascii_uppercase)

# # For getting input from input.txt file
# sys.stdin = open('input.txt', 'r')
#
# # Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')

# input = sys.stdin.readline

# Fast Input Output

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self, **kwargs):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")


# endregion


def print(x, end='\n'):
    sys.stdout.write(str(x) + end)


# IO helpers
def get_int():
    return int(input())


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


def get_char_list():
    s = input()
    return list(s[:len(s)])


def get_tuple_ints():
    return tuple(map(int, input().split()))


def print_iterable_ns(p):
    print("".join(map(str, p)))


def print_iterable_s(p):
    print(" ".join(map(str, p)))


def y_or_n(a):
    if a == 0:
        print("NO")
    else:
        print("YES")


def floorSearch(arr, low, high, x):
    if low > high:
        return -1
    if x >= arr[high]:
        return high
    mid = int((low + high) / 2)
    if arr[mid] == x:
        return mid
    if mid > 0 and arr[mid - 1] <= x < arr[mid]:
        return mid - 1
    if x < arr[mid]:
        return floorSearch(arr, low, mid - 1, x)
    return floorSearch(arr, mid + 1, high, x)


def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    mid = 0
    while low <= high:
        mid = (high + low) // 2
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid
    return -1


def isPrime(n):
    if n <= 1:
        return False

    for i in range(2, int(sqrt(n)) + 1):
        if n % i == 0:
            return False

    return True


def mex(ls, size):
    f = [0] * size
    for i in range(len(ls)):
        f[ls[i]] = 1

    ans = 0
    for i in range(size):
        if f[i] == 0:
            ans = 1
            return i

    if ans == 0:
        return size + 1


def SieveOfEratosthenes(n):
    prime = [True for i in range(n + 1)]
    p = 2
    res = []
    while p * p <= n:
        if prime[p]:
            res.append(p)
            for i in range(p * p, n + 1, p):
                prime[i] = False
        p += 1
    return res


def main():
    l1 = get_list_ints()
    ans = (l1[0]*l1[1])/(l1[2]*l1[2])
    if ans%1 == 0:
        print(int(ans))
    else:
        print(int(ans)+2)
    pass


if __name__ == '__main__':
    main()
