ZhenlongDai/ACPR huggingface dataset:
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = [int(i) for i in input().split()]
print(int(N%X*T))

Failing test case input:
47 3 9

Expected output:
144


Actual output:
18


Fixed submission (verdict: Accepted):
import math

N,X,T = [int(i) for i in input().split()]
print(math.ceil(N / X) * T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
N, X, T = (int(x) for x in input().split())
t = (N / X)*T
print(math.ceil(t))

Failing test case input:
26 11 -1

Expected output:
-3


Actual output:
-2


Fixed submission (verdict: Accepted):
import math
N, X, T = (int(x) for x in input().split())
t = math.ceil(N / X)
print(t*T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())
print(-(-N/X)*T)

Failing test case input:
57 1 6

Expected output:
342


Actual output:
342.0


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
print(int(-(-N

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n,x,t=map(int,input().split())
print(math.ceil((n+1)/x)*t)

Failing test case input:
1001 1 0100

Expected output:
100100


Actual output:
100200


Fixed submission (verdict: Accepted):
import math
n,x,t=map(int,input().split())
print(t*math.ceil(n/x))

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
from math import floor
N, X, T = map(int, input().split())
print(floor(N/X)*T)

Failing test case input:
36 11 -1

Expected output:
-4


Actual output:
-3


Fixed submission (verdict: Accepted):
from math import ceil
N, X, T = map(int, input().split())
print(ceil(N/X)*T)

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):

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

ans = N / X * T

print(ans)

Failing test case input:
25 1 -1

Expected output:
-25


Actual output:
-25.0


Fixed submission (verdict: Accepted):

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

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

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())
if n % x == 0:
  print(n / x * t)
else:
  print(n / x * t + t)

Failing test case input:
149 10 1

Expected output:
15


Actual output:
15.9


Fixed submission (verdict: Accepted):
n,x,t = map(int,input().split())
if n % x == 0:
  print(n 
else:
  print(n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a = input().split()
b = int(a[0])
c = 0

while b >= 0:
  b -= int(a[1])
  c += int(a[2])
  
print(c)
  

Failing test case input:
77 1 -1

Expected output:
-77


Actual output:
-78


Fixed submission (verdict: Accepted):
a = input().split()
b = int(a[0])
c = 0

while b > 0:
  b -= int(a[1])
  c += int(a[2])
  
print(c)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())

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


Failing test case input:
87 5 6

Expected output:
108


Actual output:
104.39999999999999


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())

if N % X:
	print((N 
else:
	print(N
Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
from math import ceil
def resolve():
  N, X, T = map(int, input().split(" "))

  if N > X:
    print(ceil(N/X)*T)

if __name__ == "__main__":
  resolve()


Failing test case input:
4 5 11

Expected output:
11


Actual output:

Fixed submission (verdict: Accepted):
from math import ceil
def resolve():
  N, X, T = map(int, input().split(" "))

  if N > X:
    print(ceil(N/X)*T)
  else:
    print(T)
if __name__ == "__main__":
  resolve()

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

new_t = t * math.ceil(20/12)
print(new_t)

Failing test case input:
3 13 5

Expected output:
5


Actual output:
10


Fixed submission (verdict: Accepted):
import math

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

new_t = t * math.ceil(n/x)
print(new_t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

import math
N, X, T = [int(i) for i in input().split()]
print(math.ceil(N/X * T))

Failing test case input:
5 8 17

Expected output:
17


Actual output:
11


Fixed submission (verdict: Accepted):

import math
N, X, T = [int(i) for i in input().split()]
print(math.ceil(N/X) * T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
x,t,n=list(map(int, input().split())) 
for i in range(10000000):
  if x*t*i>=n:
    print(i*t)
    exit()
    

Failing test case input:
37 17 11

Expected output:
33


Actual output:
17


Fixed submission (verdict: Accepted):
n,x,t=list(map(int, input().split())) 
for i in range(10000000):
  if x*i>=n:
    print(i*t)
    exit()

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())

for i in range(200):
  if (i+1) * X >= N:
    print((i+1)*T)
    break

Failing test case input:
1000 1 1100

Expected output:
1100000


Actual output:

Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
 
for i in range(2000):
  if (i+1) * X >= N:
    print((i+1)*T)
    break

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())
print((N + X - 1) / X * T)


Failing test case input:
37 17 6

Expected output:
18


Actual output:
18.705882352941178


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
print((N + X - 1)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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 
print(c*T)


Failing test case input:
47 1 -1

Expected output:
-47


Actual output:
-47.0


Fixed submission (verdict: Accepted):
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)
Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
from math import ceil
N,X,T=map(int,input().split())

if X>=N:
    print(1)
else:
    print(T*ceil(N/X))



Failing test case input:
2 2 30

Expected output:
30


Actual output:
1


Fixed submission (verdict: Accepted):
from math import ceil
N,X,T=map(int,input().split())
print(T*ceil(N/X))

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):

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

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

print(ans)

Failing test case input:
1001 1 1000

Expected output:
1001000


Actual output:
1002000


Fixed submission (verdict: Accepted):

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

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

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
if n%x==0:
  print(n*t/x)
else:
  print( (int(n/x)+1)*t )

Failing test case input:
25 1 -1

Expected output:
-25


Actual output:
-25.0


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())
if n%x==0:
  print((n
else:
  print( ((n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int, input().split())

ans = n / x
ans = round(ans)
ans = ans * t
if ans == 0:
    ans = t
print(ans)

Failing test case input:
36 11 -1

Expected output:
-4


Actual output:
-3


Fixed submission (verdict: Accepted):
import math
n,x,t = map(int, input().split())

ans = n / x
ans = math.ceil(ans)
ans = ans * t
if ans == 0:
    ans = t
if n == 0:
    ans = 0
print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
if n % x == 0:
  print(n/x*t)
else:
  print((int(n/x)+1)*t)

Failing test case input:
1001 1 1000

Expected output:
1001000


Actual output:
1001000.0


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

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
oc, cap, time = map(int, input().split())
cnt = 0
while oc>0:
    oc -= cap
    cnt += time

print(time)


Failing test case input:
1010 2 0100

Expected output:
50500


Actual output:
100


Fixed submission (verdict: Accepted):
oc, cap, time = map(int, input().split())
cnt = 0
while oc>0:
    oc -= cap
    cnt += time

print(cnt)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = list(map(int, input().strip().split()))

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

print(ans)

Failing test case input:
33 1 -1

Expected output:
-33


Actual output:
-34


Fixed submission (verdict: Accepted):
N, X, T = list(map(int, input().strip().split()))

ans = (-(-N

print(ans)

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
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) 

Failing test case input:
41 1 6

Expected output:
246


Actual output:
252


Fixed submission (verdict: Accepted):
s = str(input())
d = s.split()
n = int(d[0])
x = int(d[1])
t = int(d[2])
if n % x != 0:
    n += x - (n%x)
dum = int(n 
ans = dum * t
print(ans)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T=map(int, input().split())
if N%X==0:
  print(N/X*T)
else:
  print((int(N/X)+1)*T)

Failing test case input:
1011 1 0100

Expected output:
101100


Actual output:
101100.0


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

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B,C=map(int, input().split())
i,j=divmod(A,B)
if j == 0:
  j=0
ttt=(i+j)*C
print(ttt)

Failing test case input:
20 22 6

Expected output:
6


Actual output:
120


Fixed submission (verdict: Accepted):
A,B,C=map(int, input().split())
i,j=divmod(A,B)
if j == 0:
  j=0
else:
  j=1
ttt=(i+j)*C
print(ttt)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = (int(x) for x in input().split())

mod = n%x
M = int(mod)
time = (n-M)/x
Time = int(time+1)
print(Time*t)

Failing test case input:
1000 2 0100

Expected output:
50000


Actual output:
50100


Fixed submission (verdict: Accepted):
n,x,t = (int(x) for x in input().split())

mod = n%x
M = int(mod)
time = (n-M)/x
Time = int(time+1)
if M == 0:
  Time = int(time)
print(Time*t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
total, max, time=map(int, input().split())

print (time*(int(total/max)+1))


Failing test case input:
35 1 -2

Expected output:
-70


Actual output:
-72


Fixed submission (verdict: Accepted):
total, max, time=map(int, input().split())

print (time*int(total/max) if total%max==0 else time*(int(total/max)+1))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
N,X,T=map(int,input().split(' '))

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

Failing test case input:
72 1 6

Expected output:
432


Actual output:
6


Fixed submission (verdict: Accepted):
import math
N,X,T=map(int,input().split(' '))
 
ans=math.ceil(N/X)*T
print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
x=input().split()

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


if n%t==0: print(k*(n/t))
else: print(k*(n/t + 1))






Failing test case input:
26 2 -2

Expected output:
-26


Actual output:
-26.0


Fixed submission (verdict: Accepted):
x=input().split()

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


if n%t==0: print(k*int(n/t))
else: print(k*int(n/t + 1))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
total, max, time=map(int, input().split())

print (time*((total/max)+1))


Failing test case input:
1001 2 0100

Expected output:
50100


Actual output:
50150.0


Fixed submission (verdict: Accepted):
total, max, time=map(int, input().split())

print (time*int(total/max) if total%max==0 else time*(int(total/max)+1))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
if n%x==0:
  print(n*t/x)
else:
  print(((int(n/x)+1)*t))

Failing test case input:
1000 2 0100

Expected output:
50000


Actual output:
50000.0


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())
if n%x==0:
  print((n
else:
  print( ((n
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T=input().split()
n=int(N)
x=int(X)
t=int(T)
s=int(t*(((n-(n%x))/x)+1))
print(s)

Failing test case input:
1000 1 0101

Expected output:
101000


Actual output:
101101


Fixed submission (verdict: Accepted):
N,X,T=input().split()
n=int(N)
x=int(X)
t=int(T)
if n%x==0:
  s=int(t*(n/x))
  print(s)
else:
  s=int(t*(((n-(n%x))/x)+1))
  print(s)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
from math import *
N,X,T=map(int,input().split())
M=N/X
if(M.is_integer()):
    print(T*M)
else:
    print(T*(floor(M)+1))

Failing test case input:
68 1 -1

Expected output:
-68


Actual output:
-68.0


Fixed submission (verdict: Accepted):
from math import *
N,X,T=map(int,input().split())
M=N/X
if(M.is_integer()):
    print(int(T*M))
else:
    print(T*(floor(M)+1))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n=input().split()
a=int(n[0])/int(n[1])
b=math.floor(a)
print(b)
if int(n[0])%int(n[1])!=0:
  b=b+1
print(b*int(n[2]))  

Failing test case input:
65 19 1

Expected output:
4


Actual output:
3
4


Fixed submission (verdict: Accepted):


import math
n=input().split()
a=int(n[0])/int(n[1])
b=math.floor(a)
if int(n[0])%int(n[1])!=0:
  b=b+1
print(b*int(n[2]))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int,input().split())
import math
print(math.ceil(N / X) * 6)

Failing test case input:
4 5 11

Expected output:
11


Actual output:
6


Fixed submission (verdict: Accepted):
N,X,T = map(int,input().split())
import math
print(math.ceil(N / X) * T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n,x,t = map(float,input().split())
if n%x == 0:
    c = n/x
else:
    b = n/x
    c = math.ceil(b)
a = c*t
print(a)

Failing test case input:
20 12 6

Expected output:
12

Actual output:
12.0


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
if x == 1:
    print(n*t)
else:
    k = int(n/x) + 1
    print(t*k)

Failing test case input:
2 2 23

Expected output:
23


Actual output:
46


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

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
N, X, T = map(int, input().split())
print((N % X) * T)

Failing test case input:
33 1 -1

Expected output:
-33


Actual output:
0


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
print(((N-1)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
N,X,T=list(map(int,input().split()))
print(N,X,T)
print(math.ceil(N/X)*T)

Failing test case input:
47 3 9

Expected output:
144


Actual output:
47 3 9
144


Fixed submission (verdict: Accepted):
import math
N,X,T=list(map(int,input().split()))
print(math.ceil(N/X)*T)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())
print(int(-(-N/X)*T))


Failing test case input:
37 3 8

Expected output:
104


Actual output:
98


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
print(int(-(-N

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

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

print(ans)

Failing test case input:
1111 2 1100

Expected output:
611600


Actual output:
610500


Fixed submission (verdict: Accepted):
import math

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

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

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = input().split()
n = int(n)
x = int(x)
t = int(t)

print(int(n*t/x))


Failing test case input:
26 4 1

Expected output:
7


Actual output:
6


Fixed submission (verdict: Accepted):
n, x, t = input().split()
n = int(n)
x = int(x)
t = int(t)
if n % x == 0:
  print((n
else:
  print((n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n, x, t = map(int, input().split())
print(math.ceil(x/n)*t)

Failing test case input:
26 2 -1

Expected output:
-13


Actual output:
-1


Fixed submission (verdict: Accepted):
import math
n, x, t = map(int, input().split())
print(math.ceil(n/x)*t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
print((n+x-1)/x*t)

Failing test case input:
26 2 -2

Expected output:
-26


Actual output:
-27.0


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())
print((n+x-1)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int, input().split())
print(round(n/x)*t)

Failing test case input:
32 5 6

Expected output:
42


Actual output:
36


Fixed submission (verdict: Accepted):
n,x,t=map(int, input().split())
print(-(-n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())

a = N / X

min_time = (int(a) + 1) * T

print(min_time)


Failing test case input:
72 1 6

Expected output:
432


Actual output:
438


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())

a = N / X

import math

min_time = math.ceil(a) * T

print(min_time)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int,input().split())
l=int(n/x)
if l>n/x:p=l+1
else:p=l
print(p*t)

Failing test case input:
4 5 11

Expected output:
11


Actual output:
0


Fixed submission (verdict: Accepted):
n,x,t=map(int,input().split())
l=int(n
if n%x>0:p=l+1
else:p=l
print(p*t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
47 4 -1

Expected output:
-12


Actual output:
-11


Fixed submission (verdict: Accepted):
N,X,T=map(int,input().split())
a= N/X
b = int(a)
if a-b > 0:
  b = b+1
res = b*T
print(res)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = input().split()

n = int(N)
x = int(X)
t = int(T)

y = int(n / x)

print((y+1)*t)

Failing test case input:
68 1 -1

Expected output:
-68


Actual output:
-69


Fixed submission (verdict: Accepted):
N,X,T = input().split()

n = int(N)
x = int(X)
t = int(T)

y = int(n / x)
if(y == n/x):
    print(y*t)
else:
    print((y+1)*t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
N,X,T = map(int,input().split())
print(math.floor(N/X)*T)

Failing test case input:
72 5 11

Expected output:
165


Actual output:
154


Fixed submission (verdict: Accepted):
import math
N,X,T = map(int,input().split())
print(math.ceil(N/X)*T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int,input().split())
print(-n/x*-t)

Failing test case input:
1001 2 0100

Expected output:
50100


Actual output:
50050.0


Fixed submission (verdict: Accepted):
n,x,t=map(int,input().split())
print(-n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
string = input("Enter your input: ")

print(string)

string = string.split()


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

if(n%x == 0):
    res = int(n/x) * t
    print(res)
else:
    res = (int(n/x) + 1) * t
    print(res)

Failing test case input:
20 22 6

Expected output:
6


Actual output:
Enter your input: 20 22 6
6


Fixed submission (verdict: Accepted):
string = input()
string = string.split()
n = int(string[0])
x = int(string[1])
t = int(string[2])

if(n%x == 0):
    res = int(n/x) * t
    print(res)
else:
    res = (int(n/x) + 1) * t
    print(res)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = list(map(int, input().split()))

n = n
print(n*t)

Failing test case input:
20 22 6

Expected output:
6


Actual output:
120


Fixed submission (verdict: Accepted):
import math
n, x, t = list(map(int, input().split()))

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

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
if n % x == 0:
    c = n / x
else:
    b = n / x
    c = b 
a = int(c * t)
print(a)

Failing test case input:
37 22 6

Expected output:
12


Actual output:
10


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

ret = math.floor(n/x) * t

print(ret)


Failing test case input:
37 3 8

Expected output:
104


Actual output:
96


Fixed submission (verdict: Accepted):
import math

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

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

print(ret)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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))

Failing test case input:
47 3 9

Expected output:
144


Actual output:
150


Fixed submission (verdict: Accepted):
x = list(map(lambda i: int(i), input().split(' ')))
all = x[0]
available = x[1]
time = x[2]

result = int(all/available) * time

if all%available != 0:
    result += time 

print(int(result))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

print(math.ceil(n/x)*t)



Failing test case input:
47 3 9

Expected output:
144


Actual output:
144.0


Fixed submission (verdict: Accepted):
import math
 
n,x,t=map(float,input().split())
 
print(int(math.ceil(n/x)*t))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
26 4 1

Expected output:
7


Actual output:
3


Fixed submission (verdict: Accepted):
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)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int, input().split())

answer = 0

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

print(int(answer))

Failing test case input:
20 12 5

Expected output:
10


Actual output:
13


Fixed submission (verdict: Accepted):
N,X,T = map(int, input().split())

answer = 0

if N%X == 0:
    S = int(N/X)
    answer = S*T
else:
    S = int(N / X)
    answer = (S+1) * T

print(int(answer))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T= map(int, input().split())
if N%X==0:
  print((N/X)*T)
else:
  print(((N/X)+1)*T)

Failing test case input:
26 2 -1

Expected output:
-13


Actual output:
-13.0


Fixed submission (verdict: Accepted):
N,X,T= map(int, input().split())
if N%X==0:
  print((N
else:
  print(((N

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
lst = input().split()

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

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

print(ans)

Failing test case input:
68 1 -1

Expected output:
-68


Actual output:
-69


Fixed submission (verdict: Accepted):
lst = input().split()

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

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

print(ans)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())

from math import ceil
time = ceil(t/n) * x
print(time)

Failing test case input:
1001 2 0100

Expected output:
50100


Actual output:
2


Fixed submission (verdict: Accepted):
n,x,t = map(int,input().split())

from math import ceil
time = ceil(n/x) * t
print(time)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
77 1 -1

Expected output:
-77


Actual output:
-77.0


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
37 5 8

Expected output:
64


Actual output:
56


Fixed submission (verdict: Accepted):
import math
n,x,t = map(int, input().split())

ans = n / x
ans = math.ceil(ans)
ans = ans * t
if ans == 0:
    ans = t
if n == 0:
    ans = 0
print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())

ans = int(n/x)*t

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


Failing test case input:
1001 1 1000

Expected output:
1001000


Actual output:

Fixed submission (verdict: Accepted):
n,x,t = map(int,input().split())
 
ans = int(n/x)*t
 
if(n%x != 0):
  ans += t
  
print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())
if n % x == 0:
  print(n / x * t)
else:
  print(n / x * t + 1)


Failing test case input:
56 2 6

Expected output:
168


Actual output:
168.0


Fixed submission (verdict: Accepted):
n,x,t = map(int,input().split())
if n % x == 0:
  print(n 
else:
  print(n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
date=input().split(" ")
N=int(date[0])
X=int(date[1])
T=int(date[2])
if N%X==0:
    print(N/X*T)
else:
    print((int(N/X)+1)*T)

Failing test case input:
77 1 -1

Expected output:
-77


Actual output:
-77.0


Fixed submission (verdict: Accepted):
date=input().split(" ")
N=int(date[0])
X=int(date[1])
T=int(date[2])
if N%X==0:
    print(int(N/X)*T)
else:
    print((int(N/X)+1)*T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
N, X, T = map(int, input().split())

count = N/X
print(count)
count = math.ceil(count)
print(count * T)


Failing test case input:
47 3 9

Expected output:
144


Actual output:
15.666666666666666
144


Fixed submission (verdict: Accepted):
import math
N, X, T = map(int, input().split())

count = N/X

count = math.ceil(count)
print(count * T)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
def main():
    N, X, T = map(int, input().split())
    
    print(round(N / X) * T)

if __name__ == "__main__":
    main()

Failing test case input:
65 9 1

Expected output:
8


Actual output:
7


Fixed submission (verdict: Accepted):
def main():
    N, X, T = map(int, input().split())
    
    if N % X == 0:
        print(int((N / X) * T))
    else:
        print((int((N 

if __name__ == "__main__":
    main()

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())

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

print(ans)


Failing test case input:
26 4 1

Expected output:
7


Actual output:
27


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())

ans = (N 
if N % X != 0:
    ans += T

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int,input().split())
print(T*(N/X+1))

Failing test case input:
26 4 1

Expected output:
7


Actual output:
7.5


Fixed submission (verdict: Accepted):
import math
N,X,T = map(int,input().split())
print(T*math.ceil(N/X))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):


import sys 

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

for i in range(N):
    if N<=X*(i+1):
        time = T*(i+1)
        print(time)
        sys.exit
    

Failing test case input:
26 3 -1

Expected output:
-9


Actual output:
-9
-10
-11
-12
-13
-14
-15
-16
-17
-18
-19
-20
-21
-22
-23
-24
-25
-26


Fixed submission (verdict: Accepted):


import sys 

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

for i in range(N):
    if X*i<N and N<=X*(i+1):
        time = T*(i+1)
        print(time)
        sys.exit

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

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)

Failing test case input:
26 4 -1

Expected output:
-7


Actual output:
-3


Fixed submission (verdict: Accepted):
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)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n,x,t = map(int,input().split())
if n%x == 0:
    c = n/x
else:
    b = float(n)/x
    c = int(math.ceil(b))
a = c*t
print(a)

Failing test case input:
1000 1 1000

Expected output:
1000000

Actual output:
1000000.0


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)


Failing test case input:
15 5 7

Expected output:
21


Actual output:
28


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
i=0
ans=0

if X==1:
  ans= N*T
else:
  if N<=X:
    ans = T
  else:
    while i<N :
      i = i+X
      ans = ans+T 
print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())
if n%x == 0:
  print(n/x)
else:
  print((n/x) + 1)

Failing test case input:
26 3 -2

Expected output:
-18


Actual output:
9.666666666666666


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

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

print(math.ceil(n/x)*t)

Failing test case input:
20 12 6

Expected output:
12

Actual output:
12.0


Fixed submission (verdict: Accepted):
import math
 
n,x,t=map(float,input().split())
 
print(int(math.ceil(n/x)*t))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T=input().split()
print((int(N)/int(X) + int(N)%int(X))*int(T))

Failing test case input:
21 6 7

Expected output:
28


Actual output:
45.5


Fixed submission (verdict: Accepted):
N,X,T = input().split()
M = 1 if int(N)%int(X) else 0
H = int(N)/int(X)
print((int(H) + M)*int(T))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X,T= map(int, input().split())
while(X<N):
    X=X*2
    T=T*2
print(T)

Failing test case input:
87 5 6

Expected output:
108


Actual output:
192


Fixed submission (verdict: Accepted):
N, X,T= map(int, input().split())
sum=0
while(N>0):
    N-=X
    sum+=1
print(T*sum)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
nt = (n + x - 1) / x 
print(int(nt * t))

Failing test case input:
1100 2 0100

Expected output:
55000


Actual output:
55050


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())
nt = (n + x - 1) / x 
ans = int(nt) * t
print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())
print(round(n/x+0.5)*t)

Failing test case input:
1001 1 0100

Expected output:
100100


Actual output:
100200


Fixed submission (verdict: Accepted):
n,x,t = map(int,input().split())
print((n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int, input().split())
times, mod = divmod(N,X)
if mod == 0:
  print(times * T)
else:
  print(times * T + 1)

Failing test case input:
36 11 -1

Expected output:
-4


Actual output:
-2


Fixed submission (verdict: Accepted):
N,X,T = map(int, input().split())
times, mod = divmod(N,X)
if mod == 0:
  print(times * T)
else:
  print(times * T + T)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
print((n / x) * t)

Failing test case input:
47 3 9

Expected output:
144


Actual output:
141.0


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())
print(int((n+x-1)/x) * t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int,input().split())
print (round(n/x)*t)

Failing test case input:
37 3 8

Expected output:
104


Actual output:
96


Fixed submission (verdict: Accepted):
import math
n,x,t=map(int,input().split())
print(math.ceil(n/x)*t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int,input().split())
print((int(N/X)+1)*T)

Failing test case input:
49 1 -1

Expected output:
-49


Actual output:
-50


Fixed submission (verdict: Accepted):
N,X,T = map(int,input().split())
import math
print(math.ceil(N/X)*T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int, input().split())
print((n+x-1)/x * t)

Failing test case input:
47 1 -1

Expected output:
-47


Actual output:
-47.0


Fixed submission (verdict: Accepted):
n,x,t = map(int, input().split())
print((n+x-1)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
param=input().split()

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

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

print(int(tim))

Failing test case input:
59 4 -1

Expected output:
-15


Actual output:
3
14.0
-15


Fixed submission (verdict: Accepted):
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))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int,input().split())
m=t
a=x
while(x<=n):
  x+=a
  t+=m
print(t)

Failing test case input:
47 1 -1

Expected output:
-47


Actual output:
-48


Fixed submission (verdict: Accepted):
n,x,t=map(int,input().split())
m=t
a=x
while(x<n):
  x+=a
  t+=m
print(t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

line = input()

strL = line.split()
N = int(strL[0])
X = int(strL[1])
T = int(strL[2])

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

print(ans)

Failing test case input:
36 11 -1

Expected output:
-4


Actual output:
-3


Fixed submission (verdict: Accepted):
import math

line = input()

strL = line.split()
N = int(strL[0])
X = int(strL[1])
T = int(strL[2])

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

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
print((n + x - 1) / x * t)

Failing test case input:
20 12 5

Expected output:
10


Actual output:
12.916666666666668


Fixed submission (verdict: Accepted):
import math
n, x, t = map(int, input().split())
print(math.ceil(n / x) * t)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
want, max, time = map(int, input().split())
required = int(want / max + 1)
print(required * time)

Failing test case input:
57 1 6

Expected output:
342


Actual output:
348


Fixed submission (verdict: Accepted):
want, max, time = map(int, input().split())
if want % max == 0:
  required = int(want / max)
else:
  required = int(want / max + 1)
print(required * time)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int,input().split())
print(round((n/x)*t))

Failing test case input:
87 5 6

Expected output:
108


Actual output:
104


Fixed submission (verdict: Accepted):
n,x,t=map(int,input().split())
print(-n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
if __name__ == "__main__":
    n, x, t = map(int, input().split())

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

Failing test case input:
20 12 5

Expected output:
10


Actual output:
12


Fixed submission (verdict: Accepted):
if __name__ == "__main__":
    n, x, t = map(int, input().split())

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

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
N,X,T=list(map(int, input().split()))
a=0
t=0
while a<=N:
    a+=X
    t+=T
print(t)

Failing test case input:
15 5 7

Expected output:
21


Actual output:
28


Fixed submission (verdict: Accepted):
N,X,T=list(map(int, input().split()))
a=0
t=0
while a<N:
    a+=X
    t+=T
print(t)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong 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

Failing test case input:
20 22 6

Expected output:
6


Actual output:

Fixed submission (verdict: Accepted):
n, x, t = list(map(int, input().split()))

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

print(tako(n, x, t))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
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)

Failing test case input:
1011 1 0100

Expected output:
101100


Actual output:
101100.0


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())

num = n

print(num*t)


Failing test case input:
6 5 18

Expected output:
36


Actual output:
108


Fixed submission (verdict: Accepted):
import math
n,x,t = map(int,input().split())

num = math.ceil(n/x)

print(num*t)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t = map(int,input().split())
if n % x == 0:
    c = n / x
else:
    b = n / x
    c = b 
a = c * t
print(a)

Failing test case input:
6 5 11

Expected output:
22


Actual output:
13.2


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())
if n/ x == 0 :
    time_lapse = (int(n / x)) * t
    print(time_lapse)
else:
    time_lapse = (int(n / x) + 1) * t
    print(time_lapse)

Failing test case input:
1011 1 0100

Expected output:
101100


Actual output:
101200


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

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):

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)

Failing test case input:
20 5 6

Expected output:
24


Actual output:
30


Fixed submission (verdict: Accepted):
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(int(time))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
input1 = input()
input1 = input1.split()
N, X, T = int(input1[0]), int(input1[1]), int(input1[2])
result = int((N*T)/X)
print(result)

Failing test case input:
20 12 5

Expected output:
10


Actual output:
8


Fixed submission (verdict: Accepted):
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)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math as mt
a,b,c=map(int,input().split())
y=b/a
y1=mt.ceil(y)
y2=int(y1)
y3=int(y2*c)
print(y3)

Failing test case input:
77 1 -2

Expected output:
-154


Actual output:
-2


Fixed submission (verdict: Accepted):
import math as mt
a,b,c=map(int,input().split())
y=a/b
y1=mt.ceil(y)
y2=int(y1)
y3=int(y2*c)
print(y3)

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
import math
N, X, T = map(int, input().split())
 
print(math.ceil((N/X))+T)

Failing test case input:
72 5 6

Expected output:
90


Actual output:
21


Fixed submission (verdict: Accepted):
import math
N, X, T = map(int, input().split())
 
print(math.ceil((N/X))*T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c = map(int,input().split())
if a%b ==0:
  time = a%b * c
else:
  time = (a%b + 1) *c
print(time)


Failing test case input:
56 1 6

Expected output:
336


Actual output:
0


Fixed submission (verdict: Accepted):
a,b,c = map(int,input().split())
if a%b ==0:
  time = (a
else:
  time = (a
print(time)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())

ans = 0

while True:
  if (n - x) <= 0:
    break
  
  if (n - x) > 0:
    ans += t
    n -= x

Failing test case input:
56 2 6

Expected output:
168


Actual output:

Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())

ans = t

while True:
  if (n - x) <= 0:
    break
  
  if (n - x) > 0:
    ans += t
    n -= x

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
N,X,T = map(int,input().split())
print(T*(math.floor(N/X)+1))

Failing test case input:
56 2 5

Expected output:
140


Actual output:
145


Fixed submission (verdict: Accepted):
import math
N,X,T = map(int,input().split())
print(T*math.ceil(N/X))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
s = input().split()

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

print(((N/X)+1)*T)

Failing test case input:
56 3 6

Expected output:
114


Actual output:
118.0


Fixed submission (verdict: Accepted):
s = input().split()
N = int(s[0])
X = int(s[1])
T = int(s[2])
if N%X == 0:
  print((N
else:
  print((N

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
A,B,C=input().split()
A=int(A)
B=int(B)
C=int(C)
D=C/A
D=int(D)
print((D+1)*B)

Failing test case input:
21 6 7

Expected output:
28


Actual output:
6


Fixed submission (verdict: Accepted):
A,B,C=input().split()
A=int(A)
B=int(B)
C=int(C)
D=A/B
D=int(D)
if A%B==0:
  print((D)*C)
else:
  print((D+1)*C)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math
n,x,t = map(int,input().split())
if n%x == 0:
    c = n/x
else:
    b = float(n)/float(x)
    c = math.ceil(b)
a = c*t
print(a)

Failing test case input:
1000 1 0101

Expected output:
101000


Actual output:
101000.0


Fixed submission (verdict: Accepted):
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 = int(c * t)
print(a)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n,x,t=map(int,input().split())

count=2
item=0
time=0

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

print(time)

Failing test case input:
4 4 26

Expected output:
26


Actual output:
52


Fixed submission (verdict: Accepted):
n,x,t=map(int,input().split())

count=2
item=0
time=0

while True:
  if n <= item:
    break

  if n<=x:
    time=t
    break

  if n > item:
    item=x*count
    time=t*count
    count=count+1

print(time)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int, input().split())
import math
number_of_times = math.ceil(N/X)
total_time = T * number_of_times
print(number_of_times)


Failing test case input:
1100 3 0100

Expected output:
36700


Actual output:
367


Fixed submission (verdict: Accepted):
N, X, T = map(int, input().split())
import math
number_of_times = math.ceil(N/X)
total_time = T * number_of_times
print(total_time)
Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())

ans = 0

while True:
  if (n - x) <= 0:
    break
  
  if (n - x) > 0:
    ans += t
    n -= x

print(ans)


Failing test case input:
47 3 2

Expected output:
32


Actual output:
30


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())

ans = t

while True:
  if (n - x) <= 0:
    break
  
  if (n - x) > 0:
    ans += t
    n -= x

print(ans)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int, input().split())
ans = 0
while True:
    N -= X
    ans += T
    if N < 0: break
print(ans) 

Failing test case input:
1001 1 0101

Expected output:
101101


Actual output:
101202


Fixed submission (verdict: Accepted):
N,X,T = map(int, input().split())
ans = 0
while True:
    N -= X
    ans += T
    if N <= 0: break
print(ans)

Problem: p02576
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
N, X, T = map(int,input().split())
a = N / X
if a == int(a):
  print(int(a * T))
else:
  print(int((a + 1) * T))

Failing test case input:
56 5 7

Expected output:
84


Actual output:
85


Fixed submission (verdict: Accepted):
N, X, T = map(int,input().split())
a = N / X
if a == int(a):
  print(int(a * T))
else:
  print(int((int(a) + 1) * T))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n, x, t = map(int, input().split())

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

Failing test case input:
47 3 8

Expected output:
128


Actual output:
133.33333333333331


Fixed submission (verdict: Accepted):
n, x, t = map(int, input().split())

if n % x == 0:
  print(n 
else:
  print((n

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import math

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

print(math.ceil(N / X))

Failing test case input:
45 2 -1

Expected output:
-23


Actual output:
23


Fixed submission (verdict: Accepted):
import math

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

print(math.ceil(N / X) * T)

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N,X,T = map(int,input().split())
import math
k = math.floor(N/X)
print(T*(k+1))


Failing test case input:
1010 2 0100

Expected output:
50500


Actual output:
50600


Fixed submission (verdict: Accepted):
N,X,T = map(int,input().split())
import math
k = math.floor(N/X)
if N%X == 0:
  print(T*k)
else:
  print(T*(k+1))

Problem: p02576
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
N, X, T = map(int,input().split())

ans = 0
while(N >= X):
    if N >= X:
        ans += T
        N = N - X
    else:
        ans += T
        break
    
    
print(ans)

Failing test case input:
149 10 1

Expected output:
15


Actual output:
14


Fixed submission (verdict: Accepted):
N, X, T = map(int,input().split())

ans = 0
while(N >= 0):
    if N == 0:
        break
    if N >= X:
        ans += T
        N = N - X
    else:
        ans += T
        break
    
print(ans)