peterverebics/CodeNet_Python_118 huggingface dataset:
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())
cnt = -((-n)//x)
print(t*cnt)
kk = list(map(int, input().split()))
a = kk[0] - (kk[0] % kk[1])
b = a / kk[1]

if (kk[0] % kk[1]) == 0:
  answer = b * kk[2]
else:
  answer = (b + 1) * kk[2]
print(int(answer))
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:
  a = N//X
else:
  a = N//X + 1
print(a*T)
#A
N, X, T=map(int, input().split())

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

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


if __name__ == '__main__':
    print(main())
N, X, T = map(int, input().split())
count = 1
check = X
if X > 1:
    while True:
        value = int(N / X)
        re = N % X
        if re == 0:
            count = value
            TotalTime = T * count
            break
        else:
            count += value
            TotalTime = T * count
            break
else:
    TotalTime = T * N

print(TotalTime)
x,n,t = map(int,input().split(" "))
cnt =0
while x > 0:
    x -= n
    cnt += 1
print(cnt * t)
n, x, t = input().split()
z = ((int(n)+int(x))-1)//int(x)
ans = z * int(t) 
print(ans)
N, X, T = map(int, input().split())

x = int(N / X)

x = x + 1 if N % X != 0 else x

ans = T * x

print(ans)
n, x, t = map(int, input().split())
print(t * ((n + x - 1) // x))
N, X, T = map(int,input().split())
ans = -(-N // X) * T
print(ans)
def inputlist(): return [int(j) for j in input().split()]
N,X,T =inputlist()
a = (N//X) + int(N % X != 0)
print(a*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())
if n%x==0:
	print((n//x)*t)
else:
	print((1+n//x)*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())

y = t * int(math.ceil(n/x))
print(y)
import math
n, x, t = map(int, input().split())
print(math.ceil(n/x)*t)
x, y, z = map(int, input().split())
print(int((x + y - 1) / y) * z)
tako = list(map(int, input().split()))
if tako[0] % tako[1] != 0:
  print(tako[0]//tako[1]*tako[2]+tako[2])
else:
  print(tako[0]//tako[1]*tako[2])
N,X,T=map(int,input().split())

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

#print(int_n, int_x, int_t)

if int_n % int_x == 0:
  print(int_n // int_x *int_t)
else:
  print(((int_n // int_x) + 1)*int_t)
n, x, t = map(int, input().split())
cnt = 0
time = 0
while True :
    if cnt >= n:
        break
    else:
        cnt += x
        time += t
print(time)
n, x, t = map(int, input().split())
ans = t * (n//x)
print(ans+t if n%x else ans)
def resolve():
	import math
	N, X, T = map(int, input().split())
	print(math.ceil(N/X)*T)
resolve()
N, X, T = map(int, input().split())

import math

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

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

print(time)
import math

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

count = math.ceil(n / x)

time = t * count

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

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

if N % X == 0:
    print(int(N / X) * T)
else:
    print(((N // X) + 1) * 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())
res = 0
count = 0
while count < N:
    res += T
    count += X
print(res)
import math

to_make, at_most, batch_time = map(int, input().split())

batches = math.ceil(to_make / at_most)
print(batch_time * batches)
N, X, T = map(int, input().split())
ans = (N + X - 1)//X*T
print(ans)
a,b,c=map(int, input().split())

print(((a+b-1)//b)*c)
i = input("").split(" ")
ii = [int(a) for a in i]
if ii[0]%ii[1] == 0:
  n = (ii[0]//ii[1])
else:
  n = (ii[0]//ii[1])+1
print(str(n*ii[2]))
import math
n,x,t = map(int,input().split())

num=0
while(num*x<n):
    num+=1

print(num*t)
V = input()
N,X,T = V.split()
N = int(N)
X = int(X)
T = int(T)
if(N%X==0):
  c = N/X
else:
  c = N//X + 1
  
A = int(c*T)
  
print(A)
import math
n, x, t = map(int, input().split())
print(math.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())
t = 0
while(N>0):
  t += 1
  N -= X

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

while(N>X):
    counter+=1
    N=N-X

counter+=1

print(counter*T)
N, X, T = map(int, input().split())
print(-(-N//X)*T)
import sys
input =sys.stdin.readline

N,X,T=(int(x) for x in input().rstrip('\n').split())
if N%X==0:
  print(T*(N//X))
else:
  print(T*(N//X)+T)
import math
N, X, T = input().strip().split(' ')
count = math.ceil(int(N)/int(X))
time = int(T) * count
print(time)
N,X,T = map(int,input().split())

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

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

print(math.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())

import math

print(t*math.ceil(n/x))
import math
N,X,T = list(map(int,input().split(" ")))
k = math.ceil(N/X)
print(k*T)
#!/usr/bin python3
# -*- coding: utf-8 -*-

n, x, t = map(int, input().split())
ret = (n + (x-1))//x
print(ret*t)
import math
N, X, T = map(int, input().split())
ans = int(math.ceil(N / X)) * T
print(ans)
input_list = input().rstrip().split(' ')

n = int(input_list[0])
x = int(input_list[1])
t = int(input_list[2])

times = int(n / x)
if n % x != 0:
    times += 1

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

if N % X == 0:
    times = N / X
else:
    times = N // X
    times += 1

ans = int(times * T)

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

print(math.ceil(n/x) * t)
n, x, t = input().split()
N = int(n)
X = int(x)
T = int(t)
if N % X == 0:
    c = N / X
else:
    c = int(N / X) + 1 
C = int(c)
print(C*T)
n,x,t= map(int,input().split()) #標準入力

if(n%x==0):
	num=n//x
else:
	num=n//x+1

print(num*t) #焼くセット数*時間を計算して出力(())
N,X,T = map(int,input().split())
if N % X ==0:
    a = int(N/X)
    print(a*T)
else:
    a = int(N/X)+1
    print(a*T)
n, x, t = map(int,input().split())
if (n%x == 0):
  y = n//x*t
  print(y)
else:
  y = n//x + 1
  y = y*t
  print(y)
n,x,t=map(int,input().split())
count=0
a=0
a=x
if(n<=x):
        print(t,end='\n')
        
elif(x==1):
        print((n)*t)
else:    
    while(x<n):
        count=count+1
        x=x+a    
    print((count+1)*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()))
if N%X == 0:
  print((N//X)*T)
else:
  print((N//X)*T+T)
# -*- coding: utf-8 -*-
N, X, T = map(int, input().split())

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

import math
print(math.ceil(N / X) * T)
def read_ints():
    return map(int, input().split(' '))


n, x, t = read_ints()
print(((n - 1) // x + 1) * t)
import math
[N, X, T] = input().split()

A = math.ceil(int(N)/int(X))

ans = A*int(T)
print(ans)
N, X, T = map(int,input().split())
counter = 0
rem = N
while rem > 0:
    rem -= X
    counter += 1
print(counter*T)
## coding: UTF-8
import math

N, X, T = map(int,input().split())
ans = math.ceil(N/X) * T
print(ans)
import math
n,x,t = list(map(int, input().split()))
print(math.ceil(n/x)*t)
def cooking_takoyaki(target_num, cook_per, need_time):
    div, mod =divmod(target_num, cook_per)
    if mod == 0:
        return div * need_time
    return div * need_time + need_time

if __name__=='__main__':
    a, b, c = map(int, input().split())
    print(cooking_takoyaki(a, b, c))
# 2020/08/22
# AtCoder Beginner Contest 176 - A
import math

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

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

# Output
print(ans)
n,x,t = map(int, input().split())
print(t * (n // x + 1) if n % x != 0 else t * (n // x))
import math
n,x,t = map(int,input().split())
ans = t*math.ceil(n/x)
print(ans)
# A - Takoyaki
N,X,T = map(int,input().split())
ans = T*((N-1)//X+1)
print(ans)
N, X, T = map(int, input().split())
print((N + X - 1) // X * T)
N,X,T=map(int,input().split())
if N//X!=N/X:
    print((N//X+1)*T)
else:
    print((N//X)*T)
import math
n, x, t = map(int, input().split())
for _ in range(1<<30):
  continue
print(math.ceil(n / x) * t)
N, X, T = map(int, input().split())
ans = - (- N // X) * T
print(ans)
n, x, t = map(int, input().split())

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

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

print(ans)
n,x,t = map(int,input().split())
for i in range(1,10**9):
    if n <= x*i:
        print(i*t)
        quit()
import math
n,x,t = map(int,input().split())
c = math.ceil(n/x)
print(t*c)
import math
n,x,t=map(int, input().split(" "))
print(math.ceil(n / x) * t)
import math

N, X, T = [int(i) for i in input().split()]
 
print(math.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)
import math
a, b, c = map(int,input().split())
d = math.ceil(a / b)
print(d * c)
import math

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

res = math.ceil(1. * n / x) * t

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

if n % x == 0:
  total = n // x * t 
else:
  total = (n// x + 1) * t
print(total)
n, x, t = map(int, input().split())
if n % x == 0:
    print((n//x)*t)
else:
    print((n//x+1)*t)
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline().rstrip()

def main():
    N, X, T = map(int, input().split())
    c = 0
    t = 0
    while c < N:
        c += X
        t += T

    print(t)

if __name__ == '__main__':
    main()
import sys
sys.setrecursionlimit(10**9)

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


if __name__ == "__main__":
    main()
n,x,t=[int(i) for i in input().split()]
k=n//x
if n%x:
    print((k+1)*t)
else:
    print(k*t)
def ceil(a, b):
	return -(-a//b)

n,x,t = map(int,input().split())
print(ceil(n, x)*t)
n, x, t = map(int, input().split())
m = n//x
if n%x==0:
  print(m*t)
else:
  print(m*t+t)
n, x, y = list(map(int, input().split()))
if n % x == 0:
    print((n // x) * y)
else:
    print((n // x + 1) * y)
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

    N,X,T = LI()
    ans = math.ceil(N/X)*T
    print(ans)
if __name__ == '__main__':
    main()
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N, X, T = MAP()
print(0--N//X*T)
n,x,t=map(int, input().split())

a=(n+x-1)//x
ans=a*t

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

a = ceil(N / X)

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

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

out = int(math.ceil(n/x)) * t if x != 0 else 0
print(out)
import math

N, X, T = map(int, input().split())
print(math.ceil(N/X) * T)
import math
n, x, t = map(int, input().split())
print(t * math.ceil(n / x))
N, X, T = list(map(int, input().split()))
ans = N // X
if N % X != 0:
  ans += 1
ans = ans * T
print(ans)
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())
s1=int(N/X)
s2=N%X
if s2>0:
  print((s1+1)*T)
else:
  print(s1*T)
a,b,c=map(int,input().split())
d=0
if a%b!=0:
  d=1
print((d+a//b)*c)
n,x,t=map(int,input().split())

if n%x==0:
    print(t*(n//x))
else:
    print(t*(n//x+1))
n, x, t = [int(x) for x in input().split()]
print( (n // x) * t + (n % x > 0) * t )
import collections as cc
import sys
import bisect as bi
I=lambda:list(map(int,input().split()))
n,x,t=I()
print((n+x-1)//x*t)
n, x, t = map(int, input().split())
total = int(n / x) * t
total += t if (n % x) > 0 else 0
print(total)
a = list(map(int,input().split()))

b = a[0] // a[1]
c = a[0] % a[1]
if c != 0:
    c = 1
ans = (b + c) * a[2]
print(str(ans))
import math

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

t = int(math.ceil(N/X))

print('{}'.format(t*T))
n, x, t = map(int,input().split())
cnt=0
while True:
    n=n-x
    cnt+=t
    if n<=0:
        break
print(cnt)
n,x,t = map(int, input().split())
times = 0

times = t
while n - x > 0:
  n -= x
  times += t

print(times)
N, X, T = map(int, input().split())
count = 1
check = X
if X > 1:
    while True:
        value = int(N / X)
        re = N % X
        if re == 0:
            count = value
            TotalTime = T * count
            break
        else:
            count += value
            TotalTime = T * count
            break
else:
    TotalTime = T * N
print(TotalTime)
n, x, t = map(int, input().split())

if n % x != 0:
    print((n // x + 1) * t)
else:
    print(n // x * t)
import math

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

ans = math.ceil(n / x) * t
print(ans)
N, X, T = map(int, input().split())
if N%X ==0:
    ans = (N // X ) *T
else:
    ans = (N // X +1) *T
print(ans)
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())
if n%x==0:
  print((n//x)*t)
else:
  print(((n//x)+1)*t)
N, X, T = map(int, input().split())

print(T * (N//X if N % X == 0 else N//X+1))
nks=input("").split(" ")
n=int(nks[0])
k=int(nks[1])
s=int(nks[2])
a=(n//k)
if(n%k!=0):
    a+=1
print(a*s)
N, X, T = map(int, input().split())

steps = (N + X - 1) // X
print(steps*T)
N,X,T = map(int,input().split())
if N%X == 0 : 
    W = (N//X)*T
else:
    W = ((N//X)+1)*T
print(W)
# [] = list(map(int, input().split()))

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

if N % X == 0:
    cnt = N // X
else:
    cnt = N // X +1
print(T*cnt)
N,X,T = [int(hoge) for hoge in input().split()]
print(T*((N-1)//X+1))
import math

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())
a=n%x
b=int(n/x)
if a==0:
  c=b
else:
  c=b+1
d=c*t
print(d)
N,X,T = map(int,input().split())
if N % X == 0:
 k = N // X
else:
 k = N // X + 1
ans = k * T
print (ans)
import math
n,x,t = map(int,input().split())
print(math.ceil(n/x)*t)
import math
N, X, T = map(int, input().split())
 
if N % X == 0:
  print(int(N / X * T))
else:
  print((math.floor(N/X) + 1) * T)
import sys
readline=sys.stdin.readline

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

print(((X + N - 1)// X) * T)
n,x,t = map(int, input().split())
ans = 0
tmp = 0
while True:
    tmp +=x
    ans +=t
    if tmp  >=n:
        break
print(ans)
# -*- coding: utf-8 -*-
import math
N,X,T = [int(i) for i in input().split()]
print(T* (math.ceil(N*1.0/X)))
N, X, T = map(int, input().split())
ans = int(N / X) * T
if not N % X == 0:
    ans += T
print(ans)
import math

N,X,T=map(int,input().split())
if (N/X==0):
    print (T)
else:
    print (math.ceil(N/X)*T)
N,X,T = map(int, input().split())

ans = int(N / X) * T
ans += T if N % X != 0 else 0

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(math.ceil(N / X) * T)
N, X, T = map(int, input().split())
print(((N-1)//X + 1)*T)
# -*- coding: utf-8 -*-

if __name__ == '__main__':
    l = list(map(int, input().split()))
    N = int(l[0])
    X = int(l[1])
    T = int(l[2])
    
    if N%X == 0:
        print((N//X) * T)
    else:
        print((N//X + 1) * T)
param=list(map(int,input().split()))

ama=param[0]%param[1]
war=(param[0]-ama)/param[1]

if ama==0:
    tim=war*param[2]
else:
    tim=(war+1)*param[2]

print(int(tim))
import math

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

times = math.ceil(n/x)

print(times*t)
n,x,t=map(int,input().split())
c=0
while c<n:
    c+=x

print(c//x*t)
N, X, T = map(int, input().split())
print(int((N+X-1)/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,k=map(int,input().split())
a=n//x
if(n%x!=0):
  a+=1
print(a*k)
n,x,t = map(int,input().split())
 
ans = int(n/x)*t
 
if(n%x != 0):
  ans += t
  
print(ans)
n,x,t=[int(x)for x in input().split()]
print(t*len(range(0,n,x)))
n,x,t = map(int,input().split())

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


if __name__ == '__main__':
    main()
def resolve():
    n, x, t = list(map(int, input().split()))
    cnt = int(n / x)
    if n % x == 0:
        print(cnt * t)
    else:
        print(cnt * t + t)

resolve()
N,X,T = map(int,input().split())
syo = N//X
amari = N%X
if amari != 0:
    syo += 1
print(syo*T)
n, x, t = map(int, input().split())
if n % x == 0:
    ans = n//x
else :
    ans = n//x + 1
 
ans *= t
print(ans)
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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

print((N + X - 1) // X * T)
N,X,T = map(int,input().split())
if N%X==0:
  print(N//X*T)
else:
  print((N//X+1)*T)
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n,x,t = inpl()
print((n+x-1)//x*t)
n,x,t=map(int, input().split())
print(((n-1)//x+1)*t)
n,x,t=map(int,input().split())
u=t
v=x
while(x<n):
  x+=v
  t+=u
print(t)
def ceildiv(n, x):
  ret = n // x
  if n % x != 0:
    ret += 1
  return ret

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

print (t * ceildiv(n, x))
n,x,t=map(int,input().split())
s=n//x * t
if n%x!=0:
  s+=t
print(s)
import math
n, x, t = input().split()
answer = math.ceil(int(n) / int(x)) * int(t)
print(answer)
import math
N,X,T = map(int, (input().split(" ")))
t = math.ceil(N/X) * T
print(t)
N,X,T = map(int, input().split())

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

meta = [int(s) for s in input().split(' ')]

print(math.ceil(meta[0] / meta[1]) * meta[2])
val = input().split(" ")
n,x,t = [int(i) for i in val]

if n%x ==0:
    time = (n//x)*t
elif n%x != 0:
    time = (n//x+1)*t

print(time)
a, b, c =map(int,input().split())

d = a / b

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

x = math.ceil(N / X)
print(x * T)
import math
n, x, t = list(map(int, input().split()))
print (math.ceil(n / x) * t)
import math
n, x, t = list(map(int, input().split()))
ans = t * (math.ceil(n/x))
print(ans)
a,b,c=map(int,input().split())
d=a//b
e=a/b
if d==e:
    print(d*c)
else:
    print((d+1)*c)
n,x,t = map(int,input().split())
a = (n-1)//x + 1
print(a*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())
a=1
if n%x==0:
  a=0
print(t*(n//x+a))
n,x,t=map(int, input().split())
print(t*((n-1)//x+1))
n,x,t = input().split(" ")

s = 0
time = 0
while int(n) > s:
  s += int(x)
  time += int(t)
print(time)
N,X,T = list(map(int,input().split()))
print(((N-1)//X+1)*T)
N, X, T = map(int, input().split())
print(T*((N+X-1)//X))
n,x,t = map(int,input().split())
print (-(-n//x)*t)
n, x, t = map(int, input().split())

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


if __name__ == '__main__':
    main()
N, X, T = map(int,input().split())

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

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

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

print(T*cnt)
n,x,t = map(int,input().split())

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

ans = t
tako = x
while True:
    if tako >= n:
        print(ans)
        exit()
    else:
        tako += x
        ans += t
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
# INF =  float("inf")
INF = 10**18
import bisect
import statistics
mod = 10**9+7
# mod = 998244353

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

print(math.ceil(N/X)*T)
N,X,T =map(int,input().split())
A = -(-N//X)
B = A*T
print(B)
# coding:utf-8
n, x, t = map(int, input().split())
count = n // x
if n % x != 0:
    count += 1
print(t * count)
n, x, t = map(int, input().split())
print(t * (n // x + 1 * (n % x != 0)))
import math
n, x, t = map(int, input().split())

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

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

n, x, t = [int(x) for x in inp().split()]
print(ceil(n/x)*t)
want, max, time = map(int, input().split())
if want % max == 0:
  required = int(want / max)
else:
  required = int(want / max + 1)
print(required * time)
n,x,t=map(int,input().split())
a=(n+x-1)//x
print(a*t)
import sys

sys.setrecursionlimit(10**6)
input = sys.stdin.readline
#read = sys.stdin.buffer.read

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


if __name__ == "__main__":
    main()
n, x, t = map(int, input().split())
q, mod = divmod(n, x)
print(q * t if mod == 0 else (q + 1) * t)
import math
n,x,t=list(map(int,input().split()))
k=math.ceil(n/x)
print(k*t)
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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