Language: Java

"""
    Satwik_Tiwari ;) .
    21st AUGUST , 2020  - FRIDAY
"""

#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function

from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase

from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned

#==============================================================================================
#fast I/O region
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):
        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")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

# inp = lambda: sys.stdin.readline().rstrip("\r\n")

#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
  def wrapped_func(*args, **kwargs):
    if stack: return f(*args, **kwargs)
    to = f(*args, **kwargs)
    while True:
      if type(to) is GeneratorType:
        stack.append(to)
        to = next(to)
        continue
      stack.pop()
      if not stack: break
      to = stack[-1].send(to)
    return to
  return wrapped_func
#### END ITERATE RECURSION ####

#===============================================================================================
#some shortcuts

mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  #as stdout.write always print sring.
def testcase(t):
    for p in range(t):
        solve()
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def google(p):
    print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
    res = 1     # Initialize result
    x = x % p  # Update x if it is more , than or equal to p
    if (x == 0) :
        return 0
    while (y > 0) :
        if ((y & 1) == 1) : # If y is odd, multiply, x with result
            res = (res * x) % p

        y = y >> 1      # y = y/2
        x = (x * x) % p
    return res
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True

#===============================================================================================
# code here ;))
@iterative
def dfs(v,visited,st,new):
    new.append(st)
    visited[st] = 1
    for i in v[st]:
        if(visited[i] == 0):
            ok = yield dfs(v,visited,i,new)
    yield True


def solve():
    n,x,t = sep()
    print(ceil(n/x)*t)






testcase(1)
# testcase(int(inp()))















Compiler output:
Main.java:1: error: class, interface, enum, or record expected
"""
^
Main.java:6: error: illegal character: '#'
#===============================================================================================
^
Main.java:7: error: illegal character: '#'
#importing some useful libraries.
^
Main.java:21: error: illegal character: '#'
from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
                                            ^
Main.java:22: error: illegal character: '#'
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
                                           ^
Main.java:25: error: illegal character: '#'
#If the element is already present in the list,
^
Main.java:26: error: illegal character: '#'
# the left most position where element has to be inserted is returned.
^
Main.java:29: error: illegal character: '#'
#If the element is already present in the list,
^
Main.java:30: error: illegal character: '#'
# the right most position where element has to be inserted is returned
^
Main.java:32: error: illegal character: '#'
#==============================================================================================
^
Main.java:33: error: illegal character: '#'
#fast I/O region
^
Main.java:37: error: '{' expected
class FastIO(IOBase):
            ^
Main.java:71: error: '{' expected
class IOWrapper(IOBase):
               ^
Main.java:82: error: illegal text block open delimiter sequence, missing line terminator
    """Prints the values to a stream, or to sys.stdout by default."""
       ^
Main.java:82: error: unclosed text block
    """Prints the values to a stream, or to sys.stdout by default."""
                                                                  ^
Main.java:95: error: class, interface, enum, or record expected
if sys.version_info[0] < 3:
                       ^
Main.java:100: error: illegal character: '#'
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
^
Main.java:102: error: illegal character: '#'
#===============================================================================================
^
Main.java:103: error: illegal character: '#'
### START ITERATE RECURSION ###
^
Main.java:103: error: illegal character: '#'
### START ITERATE RECURSION ###
 ^
Main.java:103: error: illegal character: '#'
### START ITERATE RECURSION ###
  ^
Main.java:103: error: illegal character: '#'
### START ITERATE RECURSION ###
                            ^
Main.java:103: error: illegal character: '#'
### START ITERATE RECURSION ###
                             ^
Main.java:103: error: illegal character: '#'
### START ITERATE RECURSION ###
                              ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
 ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
  ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
   ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
                           ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
                            ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
                             ^
Main.java:119: error: illegal character: '#'
#### END ITERATE RECURSION ####
                              ^
Main.java:121: error: illegal character: '#'
#===============================================================================================
^
Main.java:122: error: illegal character: '#'
#some shortcuts
^
Main.java:125: error: illegal character: '#'
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
                                                      ^
Main.java:126: error: illegal character: '#'
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
                                          ^
Main.java:131: error: illegal character: '#'
# def graph(vertex): return [[] for i in range(0,vertex+1)]
^
Main.java:133: error: illegal character: '#'
def nextline(): out("\n")  #as stdout.write always print sring.
                           ^
Main.java:141: error: unclosed character literal
    print('Case #'+str(p)+': ',end='')
          ^
Main.java:141: error: illegal character: '#'
    print('Case #'+str(p)+': ',end='')
                ^
Main.java:141: error: unclosed character literal
    print('Case #'+str(p)+': ',end='')
                 ^
Main.java:141: error: unclosed character literal
    print('Case #'+str(p)+': ',end='')
                          ^
Main.java:141: error: unclosed character literal
    print('Case #'+str(p)+': ',end='')
                             ^
Main.java:141: error: empty character literal
    print('Case #'+str(p)+': ',end='')
                                   ^
Main.java:144: error: illegal character: '#'
    res = 1     # Initialize result
                ^
Main.java:145: error: illegal character: '#'
    x = x % p  # Update x if it is more , than or equal to p
               ^
Main.java:149: error: illegal character: '#'
        if ((y & 1) == 1) : # If y is odd, multiply, x with result
                            ^
Main.java:152: error: illegal character: '#'
        y = y >> 1      # y = y/2
                        ^
Main.java:167: error: illegal character: '#'
#===============================================================================================
^
Main.java:168: error: illegal character: '#'
# code here ;))
^
Main.java:168: error: class, interface, enum, or record expected
# code here ;))
             ^
Main.java:189: error: illegal character: '#'
# testcase(int(inp()))
^
Main.java:170: error: unnamed classes are a preview feature and are disabled by default.
def dfs(v,visited,st,new):
^
  (use --enable-preview to enable unnamed classes)
Main.java:170: error: <identifier> expected
def dfs(v,visited,st,new):
                 ^
Main.java:170: error: <identifier> expected
def dfs(v,visited,st,new):
                    ^
Main.java:170: error: illegal start of type
def dfs(v,visited,st,new):
                     ^
Main.java:189: error: class, interface, enum, or record expected
# testcase(int(inp()))
           ^
57 errors