peterverebics/CodeNet_Python_118 huggingface dataset:
import sys

import math
def gcd(a,b):
	if a == 0:
		return b
	return gcd(b%a,a)

def main():
	n,x,t = map(int,input().split())
	print((math.ceil(n/x))*t)
if __name__ == "__main__":
	main()
n, x, t = map(int, input().split())
print(int((n + x - 1) // x) * t)
n, x, t = map(int, input().split())
if n%x:
    print((n//x + 1)*t)
else:
    print((n//x)*t)
input1 = input()
input1 = input1.split()
N, X, T = int(input1[0]), int(input1[1]), int(input1[2])
t = 0
while(N>0):
    N = N - X
    t += T
print(t)
def inp():
    return input()
def iinp():
    return int(input())
def inps():
    return input().split()
def miinps():
    return map(int,input().split())
def linps():
    return list(input().split())
def lmiinps():
    return list(map(int,input().split()))
def lmiinpsf(n):
    return [list(map(int,input().split()))for _ in range(n)]

n,x,t = miinps()

ans = (n + (x - 1)) // x

ans *= t

print(ans)
import sys
import math
from collections import defaultdict, deque
from copy import deepcopy
    
input = sys.stdin.readline
def RD(): return input().rstrip()
def F(): return float(input().rstrip())
def I(): return int(input().rstrip())
def MI(): return map(int, input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float,input().split()))
def Init(H, W, num): return [[num for i in range(W)] for j in range(H)]
    
    
def main():
    N, X, T = MI()
    if N % X == 0:
        print((N//X)*T)
    else:
        print(((N//X)+1)*T)
if __name__ == "__main__":
    main()
import fractions

n, x, t = map(int, input().split())

kaiten = int(n / x)
if int(n / x) != n / x:
    kaiten += 1
print(kaiten * t)
N, X, T = map(int, input().split())

w = N // X
if N % X == 0:
    print(w * T)
else:
    print((w + 1) * T)
import math
N,X,T=map(int,input().split())
a = math.ceil(N/X)
print(a*T)
a,b,c = map(int,input().split())
print((((a-1)//b)+1)*c)
import sys

def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

N,X,T = LI()

a = N // X
b = N % X

if b == 0:
    print(a*T)
else:
    print((a+1)*T)
N,X,T = map(int,input().split())

print(-(-N//X)*T)
N, X, T = map(int, input().split())
time = (N+X-1)//X
print(T * time)
n, x, t = map(int, input().split())

print((n + x - 1) // x * t)
N, X, T = map(int, input().split())
if N % X == 0:
    ans = N / X * T
else:
    ans = (N // X + 1) * T
print(int(ans))
N,X,T = map(int,input().split())
if N % X == 0:
  print(int(T*N/X))
else:
  print(T*(N//X+1))
n,x,t=list(map(int, input().split()))

sore=9
if n%x==0:
    sore=t*int(n/x)
else:
    sore=t*int(n/x)+t

print(sore)
n, x, t = map(int, input().split())
print(-(-n // x) * t)
import sys

if sys.subversion[0] == "PyPy":
    import io, atexit

    sys.stdout = io.BytesIO()
    atexit.register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

    sys.stdin = io.BytesIO(sys.stdin.read())
    input = lambda: sys.stdin.readline().rstrip()
RS = raw_input
RA = lambda x=int: map(x, RS().split())
RN = lambda x=int: x(RS())


def solve():
    print((n // x + int((n % x)!=0)) * t)
    return




n, x, t = RA()
solve()
n,x,t = map(int,input().split())
iter=n//x

if n%x!=0:
  print((iter+1)*t)
elif n%x==0:
  print(iter*t)
n,x,t=map(int,input().split())
if n%x == 0:
    print((n//x)*t)
else:
    print((n//x)*t+t)
N, X, T = map(int, input().split())
if N%X == 0:
  ans = (N//X)*T
else:
  ans = (N//X+1)*T
print(ans)
import math
N, X, T = map(int, input().split())
kaisuu = math.ceil(N/X)
print(T*kaisuu)
n, x, t = map(int, input().split())
ans = t*(n//x)
if n % x != 0:
    ans += t

print(ans)
N,X,T=map(int,input().split())
print(-(-N//X)*T)
# -*- coding: utf-8 -*-
#
import math
import sys
import itertools
import numpy as np


n,x,t = map(int, input().split())

if n%x>0:
    print((n//x+1)*t)
else:
    print(n//x*t)
n, m, t = input().split()
z = ((int(n)+int(m))-1)//int(m)
ans = z * int(t) 
print(ans)
n,x,t=map(int,input().split())
ans=int(n/x+0.99)
print(ans*t)
def main():
    n, x, t = map(int, input().split())
    print(-(-n // x) * t)


if __name__ == '__main__':
    main()
import math


n, x, t = map(int, input().split())
print(math.ceil(n / x) * t)
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, X, T = map(int, readline().split())

    ans = (N + X - 1) // X * T
    print(ans)

    return


if __name__ == '__main__':
    main()
N, X, T=map(int,input().split())
if N%X!=0:
    print((N//X+1)*T)
else:
    print(N//X*T)
N, X, T = (int(x) for x in input().split() )

a = int(N/X)

if N % X != 0:
    t = (a + 1)* T
else:
    t = a * T

print(t)
import math

N, X, T = map(int, input().split())

t = math.ceil(N / X)

print(t * T)
# coding: utf-8
# Your code here!
# 幅優先探索（行きがけ）
import collections
import sys
import copy
import re
import math
import itertools


def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())


def main():
    N, X, T = LI()

    time = math.ceil(N/X)
    ans = T*time

    print(ans)
 

if __name__ == '__main__':
    main()
n,x,t=map(int,input().split())

time = n//x
if n%x != 0: time += 1
print(time*t)
#!/usr/bin/python3
 
cmdvar_numlist=input()
cmdvar_numlist_splited=cmdvar_numlist.split()

N,X,T=list(map(int,cmdvar_numlist_splited))

i=0

while N >0:
    N = N - X
    i+=1

ans=T * i
print(ans)
import math
N,T,u = map(int,input().split())
print((math.ceil(N/T))*u)
n, c, t = map(int, input().split())

print(t * (n // c + bool(n % c)))
n, x, t = map(int, input().split(' '))

ans = 0
if n % x == 0:
  ans = n/x * t
else:
  ans = ((n//x)+1)*t

print(int(ans))
N, X, T = map(int, input().split())
count = 0
result = 0

if N < X:
  print(T)
else:
  if N % X == 0:
    count = N / X
    result = count * T
    print(int(result))
  else:
    count = (N // X) + 1
    result = count * T
    print(int(result))
N,X,T = map(int,input().split())
res = N*T//X
div = res//T
mod = res%T
if mod == 0:
    print (res)
else :
    print ((div+1)*T)
n, x, t = map(int ,input().split())
print(int(((n + x -1) / x )) * t)
n,x,t=map(int,input().split())
ans=0;
while(n>0):
	ans+=t;
	n-=x;
print(ans)
n, x, t = map(int, input().split())

if n % x == 0:
    print((n // x) * t)
else:
    print((n // x) * t + t)
n,x,t = map(int,input().split())
add = n % x != 0
ans = n // x * t
if(add):
    ans += t
print(ans)
N, X, T = list(map(int, input().split()))

if N % X == 0:
    print(N // X * T)
else:
    print((N // X + 1) * T)
import math
n, x, t = map(int, input().split())
N = math.ceil(n/x)
print(t*N)
N, X, T = map(int, input().split())

if N % X == 0:
  print(N // X * T)
else:
  print((N // X + 1) * T)
a,b,c=map(int,input().split())
x = 0
y = 0
for i in range(a):
    x = x + c
    y = y + b
    if a <= y:
        print(x)
        break
n,x,t=map(int,input().split())
a=n//x

if x*a!=n:
  a=a+1

print(a*t)
import math
n,x,t = map(int,input().split(' '))
nn = math.ceil(n/x)
print(nn * t)
import math
n,m,t = map(int,input().split())
if n%m == 0:
  print(int(n/m)*t)
else:
  print(math.ceil(n/m)*t)
N, X, T = map(int,input().split())

if N % X != 0:
    print((N // X + 1)*T)
else:
    print((N // X)*T)
N, X, T = map(int, input().split())

ans = 0
while N > 0:
  ans += T
  N -= X

print(ans)
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=tf-8
#

"""
"""

from collections import defaultdict
import bisect

import sys
input = sys.stdin.readline

def solve(n,x,t):
    print (((n-1)//x+1) * t)

            

def main():
    n,x,t = map(int,input().split())
    solve(n,x,t)


if __name__ == "__main__":
    main()
n,x,t = map(int,input().split())
if n%x == 0:
  s=n//x
else:
  s=n//x+1
l=s*t
print(l)
import sys
import math
input = sys.stdin.readline

n,x,t=map(int,input().split())
val = math.ceil(n/x)
ans = val*t
print(ans)
from math import ceil

n, x, t = map(int, input().split())
res = ceil(n/x) * t
print(res)
(n, x, t) = tuple([int(x) for x in input().split(" ")])
summ = 0
time = 0
while summ < n:
    summ += x
    time += t
print(time)
N, X, T = map(int, input().split())
if N % X == 0:
    print(T*(N//X))
else:
    print(T*(N//X+1))
import math

N,X,T = [int(x) for x in input().split()]
print(math.ceil(N/X)*T)
n,x,t=map(int,input().split())
print((n+x-1)//x*t)
import math

n, x, t = map(int, input().split())

#t分でx個のたこ焼き

print(math.ceil(n / x) * t)
from math import ceil
N, X, T = map(int, input().split())
print(ceil(N/X)*T)
N,X,T=map(int,input().split())
if N%X==0:
  print((N//X)*T)
else:
  print((N//X+1)*T)
n,x,t=map(int,input().split())
kaisuu=n//x
if n%x!=0:
    kaisuu+=1
ans=kaisuu*t
print(ans)
N, X, T = map(int, input().split())

n_count = ((N - 1)// X) + 1
print(n_count * T)
N, X, T = map(int, input().split())

count = N // X
if N % X != 0:
    count += 1

print(count * T)
def solve():
  N, X, T = map(int, input().split())
  ans = (0--N//X)*T
  return ans
print(solve())
import math

n,x,t = (int(x) for x in input().split())

print(math.ceil(n/x)*t)
from math import ceil
n, x, t = map(int, input().split())
k = ceil(n / x)
print(k * t)
import math

n,x,t = map(int,input().split())
print(math.ceil(n/x)*t)
N, X, T = map(int,input().split())

add = 0
if N % X > 0:
  add = 1

ans = int(N//X + add)*T
print(ans)
n, x, t = map(int, input().split())
print(-(-n//x)*t)
from math import ceil
 
N,X,T = map(int,input().split())
 
print(ceil(N/X)*T)
n, x, t = map(int, input().split())

if n % x != 0:
    print(n // x * t + t)
else:
    print(n // x * t)
n, x, t = map(int, input().split())

if n % x !=0:
    a = ((n // x)+1) * t 
else:
    a=(n//x)*t
print(a)
n, x, t = map(int, input().split())
cnt = n // x
if n % x > 0:
    cnt += 1
print(int(cnt*t))
from sys import stdin,stdout
# n=int(stdin.readline())
n,x,t=list(map(int,stdin.readline().split()))
q=n//x+int((n%x)!=0)
print(t*q)
N, X, T = map(int, input().split())
times = (N + X - 1) // X
print(times * T)
n,x,t = list(map(int,input().split()))

for i in range(2000):
    if i * x >= n:
        ans = i
        break

print(ans*t)
n,x,t=map(int,input().split())
if n%x==0:
  print(n//x*t)
else:
  print((n//x+1)*t)
import math
from sys import stdin

n, x, t  = map(int, stdin.readline().rstrip().split())
print(int(math.ceil(n/x)*t))
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations

def main():
    N, X, T = map(int, input().split())

    if N % X == 0:
        print((N // X) * T)
    else:
        print((N // X + 1) * T)

if __name__ == '__main__':
    main()
n = input().split()
n = [int(i) for i in n]
time = 0
while n[0] > 0:
  n[0] = n[0] - n[1]
  time += n[2]

print(time)
import math

n, x, t = map(int, input().split())
print(t * math.ceil(n/x))
n, x, t = map(int, input().split())
res = ((n+x-1) // x) * t
print(res)
import math

n, x, t = map(int, input().split())
print(math.ceil(n/x)*t)
k,x,t=map(int,input().split())

if x>=k:
    print(t)
else:
    if k%x==0:
        
        print((k//x)*t)
    else:
        print(((k//x)+1)*t)
n,x,t = map(int,input().split())
if n>x:
    print(-(-n//x)*t)
else:
    print(t)
n, x, t = map(int, input().split())
print((n//x)*t if n%x==0 else (n//x)*t+t)
N,X,T=map(int,input().split())

if N%X==0:
  print(N//X*T)
else:
  print((N//X+1)*T)
n,x,t = list(map(int,input().split()))

ans = (n // x) * t


if n % x != 0:
    ans += t

print(ans)
n,x,t = map(int,input().split())

nn = n//x
amari = n%x

if amari == 0:
    print(nn * t)
else:
    print(nn * t + t)
import math
n,x,t=map(int, input().split())
print(math.ceil(n/x)*t)
import math
import re
#import sympy

n,x,t=map(int,input().split())
if n%x==0:
    print((int(n/x))*t)
    exit()
print((int(n/x)+1)*t)
n,x,t = map(int,input().split())

cnt = 0
while n > 0:
    n = n - x
    cnt += 1

print(cnt*t)
n,x,t=map(int, raw_input().split())
if n%x==0:
	print (n/x)*t
else:
	print (n/x)*t+t
N, X, T = map(int,input().split())
print(-(-N // X) * T)
from math import ceil
n, x, t = map(int, input().split())
print(t*ceil(n/x))
def main():
    n, x, t = list(map(int, input().split()))
    k = n // x
    if n % x != 0:
        k += 1
    print(k*t)

if __name__ == "__main__":
    main()
# import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")

N, X, T = map(int, input().split())

val = (N + X - 1) // X
print(val * T)
import math
N,X,T = map(int,input().split())
l = math.ceil(N/X)
print(l*T)
L=list(map(int,input().split()))
N,X,T=L[0],L[1],L[2]
if N%X==0:
    Y=(N//X)*T
else:
    Y = (1+ N // X) * T
print(Y)
N, X, T = list(map(int, input().split())) 
times=(N+X-1)//X

ans=times*T

print(ans)
N, X, T = map(int, input().split())

print((N // X + bool(N%X)) * T)
from math import ceil
n, x, t = map(int, input().split())
print(ceil(n/x)*t)
import math

N, X, T = map(int, input().split())
print((math.ceil(N/X)) * T)
n,x,t=map(int,input().split())
y=n//x
if(n%x!=0):
    ans=(y+1)*t
else:
    ans=y*t
print(ans)
N, X, T = map(int, input().split())
result = N//X
if N%X == 0:
    pass
else:
    result += 1
print(result*T)
n,x,t = map(int,input().split())

a = n//x
mod = n%x

if mod==0:
  ans = a*t
else:
  ans = (a+1)*t

print(ans)
import math
N,X,T = map(int,input().split())
NX = math.ceil(N/X)

print(NX*T)
import math
N, X, T = map(int, input().split())
print(math.ceil(N / X) * T)
import math

n, x, t = map(int, input().split())

ans = math.ceil(n / x) * t

print(ans)
n,x,t=map(int,open(0).read().split())
print(-(-n//x)*t)
n,x,t=map(int,input().split())
p=n//x
if n/x>n//x:
  p+=1
print(p*t)
import math
n,x,t = map(int,input().split())
point = math.ceil(n/x)
print(point*t)
N,X,T = map(int,input().split())
k = N/X
t = N//X
if k > t:
  print((t+1)*T)
else:
  print(t*T)
N, X, T = map(int, input().split())

print((N + X - 1) // X * T)
N, X, T = map(int, input().split())

print(-(-N//X)*T)
N, X, T = map(int, input().split())
if N % X == 0:
    print(N // X * T)
else:
    print((N // X + 1) * T)
n, x, t = map(int, input().split())
times = (n + x - 1) // x
ans = times * t
print(ans)
n, x, t = map(int, input().split())
answer = 0
while n > 0:
    n -= x
    answer += t
print(answer)
n,x,t = map(int,input().split())

c=1
while True:
  if x*c >= n:
    break
  else:
    c = c+1
print(c*t)
N, X, T = map(int, input().split())

print(T * ((N + X - 1) // X))
n,x,t = map(int, input().split())
 
if n <= x:
  print(t)
elif n % x == 0:
  print(n//x*t)
else:
  print((n//x+1)*t)
n ,x,t = map(int,input().split())
time  =0
while n>0:
    n-=x
    time+=t
print(time)
n,x,t = input().split()
n=int(n)
x=int(x)
t=int(t)

if(n%x==0):
    print((n // x)*t)
else:
    print(((n // x )+ 1)*t)
N, X, T = map(int, input().split())

print( -(-N//X) * T )
N, X, T = (int(x) for x in input().split())
if(N % X == 0):
    print((N // X) * T)
else:
    print(((N // X) + 1) * T)
#####
# B #
#####

N,X,T = map(int,input().split())

if N % X == 0:
    print(N // X * T)
else:
    print((N // X + 1) * T )
n, x, t = map(int, input().split())

print(((n - 1) // x + 1) * t)
n, x, t = map(int, input().split())

total_num = 0
total_time = 0

while(True):
    total_num += x
    total_time += t
    if n <= total_num:
        break

print(total_time)
N, X, T = map(int, input().split())

ANS = -(-N // X) * T
print(ANS)
n, x, t = map(int, input().split())
ans = t * ((n+x-1) // x)
print(ans)
n, x, t = map(int, input().split())

print(t * ((n+x-1)//x))
n, x, t = map(int, input().split())

if n%x == 0:
  ans = n//x
  print(t*ans)
else:
  ans = n//x
  print(t*(ans+1))
N, X,T = map(int, input().split())
if (N/X)-int(N/X)==0:
    a=N/X
    print(int(a*T))
else:
    a=int(N/X)+1
    print(int(a*T))
import bisect, collections, copy, heapq, itertools, math, string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())

N, X, T = MI()
a = math.ceil(N / X)
print(a * T)
import math
N,X,T = map(int, input().split())
ans = 0
while N>0:
    N-=X
    ans += T
print(ans)
n, x, t = map(int, input().split())


num = 0
for i in range(n):
    if n > x:
        n -= x
        num += 1

num += 1
print(t * num)
n,x,t=map(int,input().split())
import math
print(t*(math.ceil(n/x)))
import math
n,x,t=list(map(int,input().split()))
print(math.ceil(n/x)*t)
n,x,t=map(int,input().split());print((-(-n//x))*t)
# -*- coding: utf-8 -*-

# スペース区切りの整数の入力
n, x, t = map(int, input().split())

# print(n, x, t)

count = n // x
if n % x != 0 :
  count += 1

print(count*t)
N,X,T = map(int, input().split())
ans = 0
while(N>0):
  N-=X
  ans +=T 
print(ans)
n,x,t = list(map(int,input().split()))
print(t*((n-1)//x + 1))
from math import ceil
a,b,c= map(int,input().split())
ans= int(ceil(a/b)*c)
print(ans)
n,x,t = map(int, input().split())
if n%x == 0:
    print((n//x)*t)
else:
    print(((n//x)+1)*t)
import math
n,x,t=map(int,input().split())
print(t*math.ceil(n/x))
input_str = input().split()
amount_to_make = int(input_str[0])
lot_size = int(input_str[1])
time_to_make_one_lot = int(input_str[2])

proceeded_time = 0
made_amount = 0
while made_amount < amount_to_make:
    made_amount += lot_size
    proceeded_time += time_to_make_one_lot

print(proceeded_time)
N, X, T = map(int, input().split())
if N % X == 0:
    times = N // X
elif N % X != 0:
    times = N // X + 1
else:
    pass
ans = T * times
print("{0}".format(ans))
#!/usr/bin/env python3

import sys
import pprint
from math import ceil

sys.setrecursionlimit(10 ** 6)

class Logger:
	def __init__(self, debug):
		self.debug = debug
	def print(self, *args):
		if self.debug:
			pprint.pprint(args)


def main():
	log = Logger(1)
	n, x, t = map(int, sys.stdin.readline().split())
	print(t * ceil(n / x))
	


main()
from math import ceil

N,X,T = map(int, open(0).read().split())
print(ceil(N/X)*T)
n,x,t=map(int,input().split())
ans=n//x+1
if n%x==0:
    ans-=1
print(ans*t)
n,x,t = map(int,input().split())
print(-(-n//x)*t)
import math

def takoyaki(n, x, t)-> int :
  itr = math.ceil(n / x)
  return itr * t

if __name__ == "__main__":
  input = list(map(int, input().split()))
  print(takoyaki(input[0], input[1], input[2]))
n,x,t=map(int,input().split())
b=int(n/x)
if n%x >0:
    b+=1
print(b*t)
N,X,T = map(int,input().split())
if N%X == 0:
    print((N//X)*T)
else:
    print(((N//X)+1)*T)
X,Y,T = list(map(int,input().split()))
A = 1
if X % Y == 0:
  A = 0

print(((X//Y)+A)*T)
import math
a,b,c=[int(i) for i in input().split()]
d=math.ceil(a/b)
print(c*d)
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy


def main():
    n,x,t = map(int, input().split())
    if n%x == 0:
        print((n//x)*t)
    else:
        print(((n//x)+1)*t)
            
    
if __name__ == '__main__':
	main()
from math import ceil
N, X , T = map(int, input().split())
time=ceil(N/X)
print(T*time)
N,X,T = list(map(int, input().split()))
n = 0
cnt = 0
while n < N:
    cnt += T
    n += X
print(cnt)
import math
N,X,T = map(int, input().split())
A = math.ceil(N/X)
print(A*T)
n, x, t = map(int,input().split())
print((n+x-1)//x*t)
n, x, t = map(int, input().split())
print(abs(-n // x) * t)
N,X,T = map(int,input().split())
if N%X==0:
  print(N//X*T)
if N%X!=0:
  print((N//X+1)*T)
import math

a = list(map(int,input().split()))
print((math.ceil(a[0]/a[1]))*a[2])
n, x, t = map(int, input().split())
i = 0
while True:
    i += 1
    if i*x >= n :
        break
print(i*t)
N, X, T = map(int, input().split())

if N % X == 0:
  print(int(N / X) * T)
else :
  print((int(N / X) + 1) * T)
# cook your dish here
n,x,t=map(int,input().split())

if n/x==n//x:
    print(n*t//x)
    
else:
    print(((n//x)+1)*t)
N,X,T = map(int, input().split())

nf = float(N/X)
ni = int(N/X)
d = nf - ni 

if d == 0:
    ans = ni * T
else:
    ans = (ni + 1) * T

print(ans)
import math
N, X, T = map(int, input().split())

ans = math.ceil(N / X) * T
print(ans)
n, x, t = map(int, input().split())

if n%x == 0:
  a = n//x
  
else:
  a = n//x + 1
  
print(a*t)
N, X, T = map(int, input().split())

A = N // X
B = N % X

if B == 0:
    print(A * T)
else:
    print((A+1)*T)
import math
N,X,T=map(int,input().split())
k=N/X
print((math.ceil(k))*T)
n, x, t = map(int, input().split())
if n % x == 0:
    print((n // x) * t)
else:
    print((n // x + 1) * t)
from math import ceil
n,x,t = [int(x) for x in input().split()]
print(ceil(n/x)*t)
N, X, T = map(int, input().split())

if N <= X:
  print(T)
else:
  if (N % X) == 0:
    print((N // X) * T)
  else:
    print((N // X + 1) * T)
n,x,t=map(int,input().split())
import math
print((math.ceil(n/x))*t)
N, X, T = map(int,input().split())
i = 0
while X * i < N: i += 1
print(T * i)
import math
import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
from numba import jit
import collections
import bisect
from collections import deque
from copy import copy, deepcopy
import time
 
def main():
    N,X,T = map(int,input().split())
    print(math.ceil(N/X) * T)

if __name__ == '__main__':
    main()
import math
n,x,t=map(int,input().split())
y=math.ceil(n/x)
print(y*t)
n,x,t = map(int,input().split())
if n%x==0:
  print(int(n*t/x))
else:
  print((int(n/x)+1)*t)
N, X, T = (list(map(int, input('').split(' '))))
print(-(-N//X)*T)
import math
n,x,t=map(int,input().split())
temp=int(math.ceil(n/x))
print(temp*t)
N, X, T = map(int,input().split())

A = N % X

if ( A ) == 0:
    print(( N // X ) * T )
elif ( N % X ) != 0:
    print(( N // X + 1 ) * T )
n,x,t = map(int, input().split())

ans = 0 
if n % x == 0:
    ans = (n//x)*t 
else:
    ans = (n//x)*t + t

print(ans)
n,x,t=map(int,input().split())
if n%x!=0:
    num=n//x+1
    print(num*t)
else:
    print(n//x*t)
n,x,t = map(int, input().split())
y = n//x
z = n%x
if z != 0:
    print((y+1)*t)
else:
    print(y*t)
import math
i = list(map(int, input().split()))

N = i[0]
X = i[1]
T = i[2]

A = N / X
A = math.ceil(A)
A = A*T

print(A)
import sys

def main(lines):
  line=lines

if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)
n, x, t = map(int, input().split())
a = n/x
if n<x:
  print(0)
if n % x == 0:
  print(a*t)
else:
  print((int(a) + 1)*t)
a, b, c = map(int, input().split())

if a%b == 0:
    d = a / b
else:
    d = int(a / b) + 1
    
print("{}".format(d * c))
n, x, t = map(int, input().split())
print((n + 1) // x * t)
import math
N,X,T=list(map(int,input().split()))
print(N,X,T)
print(math.ceil(N/X)*T)
n, x, t = map(int, input().split())
print(n//x*t) if t % x == 0 else print((n//x+1)*t)
a, b, c = map(int, input().split())
if b>c:
  print(b)
else:
  print(a*c)
import math
N, X, T = map(int, input().split())
 
print(math.ceil((N/X))+T)
import math
N,X,T=map(int,input().split(' '))

ans=math.ceil(X/N)*T
print(ans)
N,X,T =map(int, input().split()) 
print(T*(N//X+1))
from math import ceil
N,X,T=map(int,input().split())

if X>=N:
    print(1)
else:
    print(T*ceil(N/X))
n, x, t = map(int, input().split())
times = (n + x - 1) / x
ans = times * t
print(ans)
n, x, t = map(int, input().split())

if n % t == 0:
  ans = (n // x) * t
else:
  ans = (n // x + 1) * t

print(ans)
n, x, t = list(map(int, input().split()))

print(n//x*t)
n,x,t = map(int,input().split())
if n % x == 0:
  print(n / x * t)
else:
  print(n / x * t + 1)