peterverebics/CodeNet_Python_118 huggingface dataset:
#入力受け取り N=個数 X=焼ける数 T=時間
N,X,T = map(int, input().split())

#回数定義
count = 0

#NがXで割り切れなければ+1
if N % X == 0:
    count = N / X
else:
    count = N // X + 1

#回数×時間
ans = count * T
print(ans)
n,x,t=map(int,input().split())
print((n//x)*t if n%t == 0 else ((n//x)*t+t))
n, x, t = map(int, input().split())
print((n//x + 1)*t)
x = list(map(lambda i: int(i), input().split(' ')))
all = x[0]
available = x[1]
time = x[2]

result = (all/available) * time
if all%available != 0:
    result += time 

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

print( t * ( n//x + 1 ) )
a,b,c=list(map(int,input().split()))
d=a//b
print(int(d*c))
N, X, T = map(int, input().split())

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

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

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

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

if N % X == 0:
    print(T*N/X)
else:
    print(T*(int(N/X)+1))
n,x,t=map(int,input().split())
print((n//x+1)*t)
N,X,T=input().split()
n=int(N)
x=int(X)
t=int(T)
s=int(t*(((n-(n%x))/x)+1))
print(s)
n, x, t = map(int, input().split())
if n%x == 0:
    print(n//x * t)
else:
    print((n//x + 1)+t)
list = list(map(int,input().split( )))
if list[0] % list[1] == 0:
  time = list[2]*list[0]/list[1]
else :
  time = list[2]*(list[0]/list[1]+1)
print (time)
NXT= [int(i) for i in input().split(' ')]
i=NXT[0]
count=0
while i>=0: 
    i -= NXT[1];count +=1
print(int(NXT[2]*count))
n,x,t = map(int,input().split())
if n % x == 0:
  print(n / x * t)
else:
  print(n / x * t + t)
nums = input().split()


s = int(nums[0])/int(nums[1])
v = int(nums[0])/int(nums[1])

if v != 0:
    s = int(s)+1

time = s*int(nums[2])
print(time)
N,T,X = map(int,input().split())
if N % X == 0:
  print(T*N//X)
else:
  print(T*(N//X+1))
def main():
    N, X, T = map(int, input().split())
    print(T * (N//X+1))


if __name__ == "__main__":
    main()
N=20; X=12; T=6
import math
T_total = ( math.ceil( N / X )*T + T )

print (T_total)
n,x,t=map(int,input().split())
s=n//x * t
if n%x!=0:
  s+=1
print(s)
n, x, t = map(int, input().split())
print(((n//x)+1)*t)
N, X, T = map(int,input().split())
int((N/X)*T)
N,X,T=map(int,input().split())
for i in range(0,1000):
    if X*i>=N:
        print(T*i)
        break
N, X, T = map(int, input().split())

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

ans = n / x
ans = round(ans)
ans = ans * t
if ans == 0:
    ans = t
print(ans)
N, X, T = map(int, input().split())
time = (N // X + 1) * T
print(time)
n,x,t = map(int,input().split())
if n%x == 0:
    c = n/x
else:
    b = n/x
    c = b//1
a = c*t
print(a)
N, X, T = [int(s) for s in input().split(" ")]

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

ans = n / x
ans = round(ans)
ans = ans * t
if ans == 0:
    ans = t
if n == 0:
    ans = 0
print(ans)
n, x, t = map(int, input().split())
a = n/x
if n % x == 0:
  print(a*t)
else:
  print((int(a) + 1)*t)
import math
n,x,t = map(int,input().split())
print(math.ceil(n//x)*t)
N,X,T = map(int, input().split())  # 3個の数字の入力を受け取る


m=(N//X) 
m1=m*T


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

count=2
item=0
time=0

while True:
  if n > item:
    item=x*count
    time=t*count
  
  if n <= item:
    break
  
  count+=1

print(time)
N=20; X=12; T=6
import math
T_total = ( math.ceil( N / X )*T )

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

a=N//X
b=a*T
c=b+T

print(c)
def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T
N,X,T = 100,20,30
result = calculate(N,X,T)
print(result)
n,x,t = map(int,input().split())

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

print(((n // x) + 1)*t)
import sys
input = sys.stdin.readline
read = lambda: list(map(int, input().strip().split()))
n, x, t = read()
print(n//x * t)
N, X, T = map(int, input().split())
print((N//X+1)*T)
n, x, t = input().split()
n = int(n)
x = int(x)
t = int(t)

if n % x == 0:
  print((n//x)*t)
else:
  print(int((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 = [int(i) for i in input().split()]
print(n // x * t)
NXT = list(map(int,input().split()))
NXT.sort()
T = NXT[0]
X = NXT[1]
N = NXT[2]
ans=0
a = N // X
if(N%X==0):
    ans=T*a
else:
    ans = T*(a+1)
print(ans)
n,x,t = map(int,input().split())
print(round(n/x+0.5)*t)
N, X,T= map(int, input().split())
while(X<N):
    X=X*2
    T=T*2
print(T)
def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T
N,X,T = 100,20,30
result = calculate(100,20,30)
print(result)
N,K,T=map(int,input().split())
if N%K==0:
  print((N%K)*T)
else:
  print(((N//K)+1)*T)
if __name__ == "__main__":
    n, x, t = map(int, input().split())

    ans = t * (n + x - 1) / x
    ans = int(ans)
    print(ans)
import math
n,x,t = map(float,input().split())
if n%x == 0:
    c = n/x
else:
    c = math.ceil(n/x)
a = c*t
print(a)
n,x,t = map(int,input().split())
print((n*t)//x + 1)
n, x, t = map(int, input().split())
answer = (n//x)*t
print(answer)
n, x, t = map(int, input().split())
yash = n / x

pattu = yash * t
print(int(pattu))
list = list(map(int,input().split()))
if list[0] % list[1] == 0:
  time = list[2]*list[0]/list[1]
else :
  time = list[2]*(list[0]/list[1]+1)
print (time)
N, X, T = map(int, input().split())

a = N // X
min_T = T*(a+1)

print(min_T)
n,x,t=map(int,input().split())
for i in range(1,t):
  if x*i>=n:
    print(i*t)
    break
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())
print(t*(n+(x-1)//t))
n,x,t = [int(i) for i in input().split()]
print((int(n/x)+1)*t)
N, X, T = map(int,input().split())

if N <= X:
  print(T)
else:
  if N % X == 0:
    A = N / X * T
    print(A)
  else:
    B = (N / X + 1) * T
    print(B)
N, X, T = map(int, input().split())
print(int(-(-N/X)*T))
l = list(map(int,input().split()))
a=l[0]
b=l[1]
c=l[2]
d=b//c
if(b==1):
    print(a*c)
else:
    x=abs(a-b)
    if(x>c):
        print(c+c)
    else:
        print(c+x)
n, x, t = map(int, input().split())

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

print(c//t)
n,x,t=map(int,input().split())
if(n<=x):
    print(t)    
else:
    if(x<t):
        print((n*t)//x)
    else:
        while(n>x):
            x*=2
            t*=2
        print(t)
N, X, T = map(int, input().split() )

a = N // X
a = (a+1) * T

print(a)
[n, x, t] = map(int, input().split())

ans = (n // x) * t

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

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

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

if n <= x:
  print(x)
elif 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)//x)*t)
n,x,t=map(int, input().split())
print(n//x*t+1)
N,X,T=map(int,input().split())
a=N//X
b=N%X
c=a*T+T
print(c)
N, X, T = map(int, input().split())
print(((N//X)+1)+T)
N, X, T = map(int, input().split(' '))

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

if N%T == 0:
    print(N//X*T)
else:
    print(N//X*T+T)
s = input()
max = 0
count = 0
for i in range(3):
    if s[i]=="R":
        count+=1
    else:
        if max < count:
            max = count
        count = 0
if max < count:
    max = count
print(max)
n,x,t = map(int,input().split())

if n % x == 0:
  print((n // x) * t + t)
else:
  print((n // x) * t)
import sys
input = sys.stdin.readline

def takoyaki(n,x,t):
  acc = 0
  for i in range(1000):
    if i % t == 0:
      acc += x
      if x >= n:
        return i
  return 0  
if __name__ == "__main__":
  n,x,t = map(int,input().split())
  print(takoyaki)
N,X,T=map(int, input().split())
a=N//X+1
if N%X==0:
    print(a*T-1)
else:
    print(a*T)
import math
n,x,t = map(int,input().split())
if n%x == 0:
    c = n/x
else:
    b = n/x
    c = math.ceil(b)
a = c*t
print(a)
n,x,t=map(int,input().split())
print(-n/x*-t)
N, X, T = map(int, input().split())
time = ((N // X) + 1) * T
print(time)
n, x, t = map(int,input().split())
res = 0

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

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

if n/x == n//x:
    print(n/x*t)
else:
    print((n//x+1)*t)
import sys
import copy
from collections import deque
import collections
import itertools
stdin = sys.stdin

mod = 10**9+7

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

n, x, t = na()

if n%x==0:
    print(t*(n/x))
else:
    print(int(t*(n//x) + t))
N,T,X = map(int,input().split())
print(T*(N/X + 1))
n,x,t=map(int,input().split())
if x>n and n==x:
  print(t)
elif x==1:
  print(n*t)
else:
  print(2*t*(n//x))
NXT= [int(i) for i in input().split(' ')]
T=int(NXT[0]/NXT[1])+1
print(int(T*NXT[2]))
x,t,n=list(map(int, input().split())) 
for i in range(10000000):
  if x*t*i>=n:
    print(i*t)
    exit()
N, X, T = map(int,input().split())
a = N / X
if a == int(a):
  print(int(a * T))
else:
  print(int((a + 1) * T))
x,n,t= map(int, input().split())
a=x//n+1
print(str(a*t))
n, x, t = map(int, input().split())
if n % t == 0:
	print((n // x) * t)
else:
	print(((n // x) + 1) * t)
n, x, t = map(int, input().split())
if n<=x:
    print(int(t))
else:
    print(int((n//x)+1)*t)
n,x,t = map(int,input().split())
x = n/x
if x%1 == 0:
    print(int(x)*t)
else:
    print((int(n/x)+1)*t)
N,X,T= map(int,input().split())
print((N//X)*T+T)
n,x,t=map(int,input().split())
if n%x==0:
  s=n/x
  print(s*t)
else:
  s=n//x
  print((s+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())
a= N/X
b = int(a)
if a-b > 0:
  a = b+1
res = b*T
print(res)
N,X,T = map(int,input().split())
print((N // X + 1)*T)
a,b,c=list(map(int,input().split()))

print(int((a//b)*c))
N, X, T = map(int, input().split())
a = N / X
print(a * T)
line = input().split()
n = int(line[0])
x = int(line[1])
t = int(line[2])
print(-(n//x)*t)
N ,X, T = map(int,input().split())

a = N // X + 1
total = a *T
print(total)
N, X, T = map(int, input().split())
count = 1
check = X
if X > 1:
    while True:
        X = N - X
        if X > check:
            count += 1
            continue
        else:
            count += 1
            TotalTime = T * count
            break
else:
    TotalTime = T * N
print(TotalTime)
n, x, t = map(int, input().split())
if n % x == 0:
    c = n / x
else:
    b = n / x
    c = b // 1
a = int(c * t)
print(a)
import sys
input = sys.stdin.readline

def takoyaki(n,x,t):
  acc = 0
  for i in range(1000):
    if i % t == 0:
      acc += x
      if x >= n:
        return i
  return 0  
if __name__ == "__main__":
  n,x,t = input().split()
  print(takoyaki)
N, X, T = map(int, input().split())

ans = N//X
if N%T != 0:
    ans+=1

print(ans*T)
N,X,T=map(int,input().split())
for i in range(1,N):
    if X*i>=N:
        print(T*i)
        break
n, x, t = map(int, input().split())
print((n // x + 1) * t)
# math.ceil(N / X) * T分
import math
N, X, T = [int(i) for i in input().split()]
print(math.ceil(N/X * T))
Tako_lists = input().split()
N = int(Tako_lists[0])
X = int(Tako_lists[1])
T = int(Tako_lists[2])

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

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

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

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

print(ans)
def main():
    n, x, t = map(int, input().split())
    print(int(n / x + 0.5) * t)

if __name__ == '__main__':
    main()
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 = [int(i) for i in input().split()]
print((N+X-1)//T)
N,X,T = map(int, input().split())

ans = N / X * T

print(ans)
N,X,T = map(int,input().split())
import math
k = math.floor(N/X)
print(T*(k+1))
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:
	print(N // X * T)
else:
	print((N // X + 1) * T)
N,X,T = map(int,input().split())
print((N % X ) * (T + 1))
n, x, t = [int(x) for x in input().split()]

c = n / x + 1
print(c * t)
n, x, t = input().split()
N = int(n)
X = int(x)
T = int(t)
Tn = int((N * T) / X)
print(Tn)
N, X, T = map(int, input().split())
time = (N+X)//X
print(T * time)
n,x,t=map(int,input().split())
l=int(n/x)
if l>n/x:p=l+1
else:p=l
print(p*t)
n,x,t = map(int,input().split())
if n==x:
    print(0)
else:
    tmp = n/x
    print(round(tmp)*t)
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n,x,t = list(map(int, input().split()))
ans = t * (n//x + int(n&x!=0))
print(ans)
[n,x,t]=list(map(int,input().split()))
kaisu=n//x+1
if n%x!=0:
    kaisu+=1
ans=kaisu*t
print(ans)
input1 = input()
input1 = input1.split()
N, X, T = int(input1[0]), int(input1[1]), int(input1[2])
result = int((N*T)/X)
print(result)
n,x,t=map(int,input().split())
c=0
while c<n:
    c+=t

print(c//t)
import math
N,X,T=map(int,input().split(' '))
 
ans=math.ceil(N/X)
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 % t != 0:
	print(((n // x) + 1) * t)
else:
	print(int((n / x) * t))
n,x,t=map(int,input().split())
print((n/x+1)*t)
oc, cap, time = map(int, input().split())
cnt = 0
while oc>0:
    oc -= cap
    cnt += time

print(time)
n, x, t = list(map(int, input().split()))
print(((n//x)+1)*t)
N, X, T = map(int,input().split())
ans = N//X + 1
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())

if N%X==0:
  print(T*N/X)
else:
  print(T*(N//X+1))
n, x, t = [int(i) for i in input().split()]
if n < x:
    print(x)
else:
    if n % x == 0:
        print((n // x) * t)
    else:
        print(((n // x) + 1) * t)
n,x,t = map(int, input().split())
cnt = (n//x) + 1
time = t * cnt
print(time)
N,X,T=map(int,input().split())
if N//X<N/X<N//X+1:
  print((N//X+1)*T) 
else:
  print(N/X*T)
N, X, T = map(int,input().split())
n = 0
total = 0

if N % X == 0:
    n = N / X
    total = n * T
else:
    n = N // X + 1
    total = n * T

print(total)
n,x,t=map(int,input().split())
k=n//x
print((t+1)*k)
X,K,D=map(int,input().split())
X=abs(X)
if X>=K*D:
  print(X-K*D)
else:
  y=X//D
  z=K-y
  if z%2==0:
    print(K-y*D)
  else:
    print(K-(y+1)*D)
n,x,t=map(int,input().split())

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

print(N/X*T)
n,x,t = map(int,input().split())
print((n % x + 1) * t)
A,B,C=map(int, input().split())
i,j=divmod(A,B)
if j == 0:
  j=0
ttt=(i+j)*C
print(ttt)
N, X, T = map(int, input().split())

Y = int(N / X)
ans = Y * T

print(ans)
(n, x, t) =  map(int, input().split(' '))
r = round(n/x)
print(t*r)
import math
n,x,t=map(int,input().split())
r=math.ceil(n//x)*t
print(r)
X,T,N = map(int,input().split())
print(-(-N//X)*T)
N,T,X = 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((n//x + 1) * t)
else:
  print(n/x * t)
N,X,T = map(int, input().split())
if N % X == 0:
    print((N/X)*T)
else:
    print(((N-N%X)/X+1)*T)
N, X,T= map(int, input().split())
result=(N*T)/X
print(int(result))
n,x,t = map(int,input().split())
if n%x == 0:
  print(n/x)
else:
  print((n/x) + 1)
# cook your dish here
n,x,t=list(map(int,input().split()))
rate=int(x/t)
if(rate==0 or rate==1):
    answer=n*t
    print(int(answer))
else:
    answer=n/rate
    print(int(answer))
N,X,T=map(int,input().split())
print((int(N/X)+1)*T)
n, x, t = map(int, input().split())
time_lapse = (int(n / x) + 1) * t
print(time_lapse)
N,X,T = map(int,input().split())
print((N//X)*T if N%T == 0 else (N//X + 1)*T )
s = input().split()
N = int(s[0])
X = int(s[1])
T = int(s[2])
if N%X == 0:
  print((N//X)*T)
else:
  print((N/X+1)*T)
n, x, t = map(int, input().split())
answer = (n // x) * t
if answer % n != 0:
    answer += t

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

    r = round(N / X )
    print(r * T)


if __name__ == "__main__":
    main()
n,x,t = map(int, input().split())
print((n+x-1)/x * t)
array = list(map(int, input().split()))
if array[0] < array[1]:
    print(array[2])
elif array[0] & array[1] > 0:
    print((array[0] // array[1] + 1) * array[2])
else:
    print((array[0] // array[1]) * array[2])
a,b,c=map(int,input().split())
d=a//b+1
print(d*c)
N,T,X = 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())
print((N + X - 1) / X * T)
n,x,t=map(int,input().split())
print (round(n/x)*t)
N,S,T=map(int,input().split())
if S<N:
    a=N%S
    if a==0:
        print((N/S)*T)
    else:
        print(((N//S)+1)*T)
else:
    print(round(T))
N, X, T = map(int, input().split(' '))

if N%T == 0:
  print(int(N/X*T))
else:
  print(int((N//X+1)*T))
n, x, t = [int(i) for i in input().split()]
if n < t:
    print(x)
else:
    if n == t:
        print((n // x) * t)
    else:
        print(((n // x) + 1) * t)
n, x, t = input().split()
n = int(n)
x = int(x)
t = int(t)

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

print(((n-1)+1)//x*t)
import math
n,x,t = map(float,input().split())
c = n/x
b = math.ceil(c)
a = t*b
print(a)
n, x, t = map(int, input().split())
a = 0

print(n, x, t)

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

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

if X==1:
  ans = N*T  
else:
  while i<=N :
    i = i+X
    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())

if((N - X ) <= X):
    print(T + T)
if((N - X) > X):
    print(T*T)
N, X, T = map(int, input().split())
if X > 1:
   print(X)
else:
    TotalTime = T * N
    print(TotalTime)
n = list(input())
m=0
for i in range(1, len(n)):
    m+=i
if m%9==0:
    print("Yes")
else:
    print("No")
def readInt():
    return list(map(int, input().split()))

n,x,t = readInt()
ans = (n // x * t) 
print(ans)
A,B,C=input().split()
A=int(A)
B=int(B)
C=int(C)
D=C/A
D=int(D)
print((D+1)*B)
n,x,t = map(int,input().split())
if n%x==0:
    print(n/x*t)
elif n<x:
    print(t)
else:
    print((int(n//x)+1)*t)
n,x,t = map(int, input().split())
print((n//x + 1)*t)
List=list(map(int,input().split()))
if List[0]<=List[1]:
    print(List[2])
else:
    if List[1]!=1:
        print(((List[0]//List[1])+1)*List[2])
    else :
        print(((List[0]//List[1]))*List[2])
[n,x,t]=list(map(int,input().split()))
kaisu=n//x+1
ans=kaisu*t
print(ans)
n,x,t = [int(x) for x in input().split()]
print((n*t)//x)
n,x,t=map(int,input().split())

q=n//x

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

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

print(ans)
import sys
input = sys.stdin.readline

def takoyaki(n,x,t):
  acc = 0
  for i in range(1000):
    if i % t == 0:
      acc += x
      if x >= n:
        return i
  return 0  
if __name__ == "__main__":
  n,x,t = map(int,input().split())
  print(takoyaki(n,x,t))
N, X, T = map(int,input().split())
if N % X == 0:
  print( T*N // X )
else:
  print( N*T // X + N )
N, X, T = map(int, input().split())

t = round(N / X)

print(t * T)
N,X,T=list(map(int,input().split()))
time = (N // X + 1) * T
print(time)
N, X, T = list(map(int, input().split()))
ans = N // X
if N & X != 0:
  ans += 1
ans = ans * T
print(ans)
import math
n, x, t = list(map(int, input().split()))
z = n / x
if z == n//x:
  k = int(z)+1
  print(k * t)
else:
  print(int(z) * t)
n,x,t = map(int,input().split())

print((int(n/x)+1)*t)
N,X,T= map(int,input().split())
if N%T==0:
    print((N//X)*T)
else:
    print(((N//X)+1)*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())
print(N/X * T)
n,x,t=map(int,input().split())
import math
print((math.floor(n/x)+1)*t)
n,x,t = map(int, input().split())
ans = 0
ans += -(-n//x)
print(ans)
s = str(input())
d = s.split()
n = int(d[0])
x = int(d[1])
t = int(d[2])
n += x - (n%x)
dum = int(n / x)
ans = dum * t
print(ans)
N,X,T = map(int, input().split())

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

N = int(lst[0])
X = int(lst[1])
T = int(lst[2])

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

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

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

if N <= X:
    print(T)
else:
    a = N // X
    b = a * T
    c = b + int((N / X ) - a +T)
    print(c)
def main():
    inp = [int(i) for i in input().split()]
    for i in inp:
        if i < 1 or i > 1000:
            raise ValueError
    N = inp[0]
    X = inp[1]
    T = inp[2]
    if N % X == 0:
        result = (N/X)*T
    else:
        result = int((N/X)+1)*T
    print(result)


if __name__ == '__main__':
    main()
a,b,c=(int(x) for x in input().split())
 
y=(a//b+1)*c
 
z=a/b*c

if a/b != 0:
  print(y)
else:
  print(z)
N, X, T = map(int, input().split())

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

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

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

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

print((int(N / X) + 1) * T)
N,X,T = map(int,input().split())
S = X//N
A = X%N
if A == 0:
    print(S*T)
else:
    s = S+1
    print(s*T)
a,b,c=map(int,input().split())
if a%b==0:
    time=a/b
else:
    time=a//b+1
answer=c*time
print(answer)
n, x, t = list(map(int, input().split()))

def tako(n, x, t):
    time = 0
    while n > 0:
        n -= x
        time += t
    return time