qyliang/CodeNanoFix huggingface dataset:
Buggy code:
def getlist():
	return list(map(int, input().split()))

A, B, T = getlist()
print(B * (int(A // (T + 0.5))))

Fixed code:
def getlist():
	return list(map(int, input().split()))

A, B, T = getlist()
print(B * (int((T + 0.5) // A)))
Buggy code:
A,B,T = map(int,input().split())
n = (T+0.5)//A
print(B*n)


Fixed code:
A,B,T = map(int,input().split())
n = (T+0.5)//A
print(int(B*n))
Buggy code:
A, B, T = map(int, input().split())
ans = ((T + 0.5) // A ) * B
print(ans)

Fixed code:
A, B, T = map(int, input().split())
ans = ((T + 0.5) // A ) * B
print(round(ans))
Buggy code:
A,B,T = map(int,input().split())
print(((0.5+T)//A)*B)

Fixed code:
A,B,T = map(int,input().split())
print(int((0.5+T)//A)*B)
Buggy code:
a, b, t = map(int, input().split())

x =(t+0.5)//a

print(b*x)

Fixed code:
a, b, t = map(int, input().split())

x =int((t+0.5)//a)*b

print(x)
Buggy code:
a,b,t = int(input().split())
s = int(t//a)
print(b*s)

Fixed code:
a,b,t = map(int, input().split())
s = int(t//a)
print(b*s)
Buggy code:

A,B,T = list(map(int, input().split()))

print(A//T*B)

Fixed code:
A,B,T = map(int,input().split())
print(int(T//A)*B)
Buggy code:
a,b,t = map(int,input().split())
print((t + 0.5)//a * b)

Fixed code:
a, b, t = map(int, input().split())
s = (t + 0.5) // a
print(int(s * b))
Buggy code:
import math
a,b,t=map(float,input().split())
c = math.floor(t/a)
print(c*b)

Fixed code:
import math
a,b,t=map(float,input().split())
c = round(math.floor(t/a))
print(c*round(b))
Buggy code:
A,B,T = map(int, input().split())
print(T/A*B)

Fixed code:
A, B, T = map(int, input().split())
print(B*(T//A))
Buggy code:
a, b, t = map(int, input().split())
bis = t // a
print(bis * t)

Fixed code:
a, b, t = map(int, input().split())

print(b * (t // a))
Buggy code:
A, B, T = input().split()
ans = int(T)/int(A)*int(B)
print(ans)


Fixed code:
A,B,T=map(int,input().split())
ans=T//A*B

print(ans)
Buggy code:
a,b,t = map(int,input().split())
sum = 0
sum = ((t + 0.5)//a )* b
print(sum)

Fixed code:
a,b,t = map(int,input().split())
sum = 0
sum = (int)((t + 0.5)//a )* b
print(sum)
Buggy code:
A, B, T = map(int, input().split())

print(int((T+0.5)/A * B))

Fixed code:
A, B, T = map(int, input().split())
print(int((T + 0.5) // A * B))
Buggy code:
a,b,t=map(int,input().split())
print((t/a)*b)


Fixed code:
a, b, t = map(int, input().split())

ans = t // a * b
print(ans)
Buggy code:
a, b ,c= list(map(int, input().split()))
print(int(a//c * b))


Fixed code:
a, b ,c= list(map(int, input().split()))
print(int(c//a * b))
Buggy code:
a,b,t=map(int,input().split())
print((t+0.5)//a*b)

Fixed code:
a,b,t=map(int,input().split())
x=((t+0.5)//a)
print(int(x*b))
Buggy code:
a,b,t = list(map(int, input().split()))
print(a * int((t + 0.5) / b))

Fixed code:
a,b,t=map(int,input().split())

print(int(((t+0.5)//a)*b))
Buggy code:
A , B , T = map(int , input()split())

count =  T // A * B

print(count)

Fixed code:
A , B , T = map(int , input().split())
 
count =  T // A * B
 
print(count)
Buggy code:
a,b,t = map(int,input().split())
ans = math.floor(t/a) * b
print(ans)

Fixed code:
import math

a,b,t = map(int,input().split())
ans = math.floor(t/a) * b
print(ans)
Buggy code:
a,b,t = map(int,input().split())
ans = ((t - t%a)/a)*b
print(ans)

Fixed code:
a,b,t = map(int,input().split())
ans = ((t - t%a)/a)*b
print(int(ans))
Buggy code:
A, B, T = map( int, input().split() )
print( (T + 0.5) // A * B )

Fixed code:
A,B,T=map(int,input().split())

print(int(B*((T+0.5)//A)))
Buggy code:
A,B,T=list(map(int,input().split()))


print((A//T)*B)

Fixed code:
A,B,T=map(int,input().split())

print(B*(T//A))
Buggy code:
import math

a, b, t = [int(x) for x in input().split()]
print(math.ceil((t + 0.5) % a) * b)


Fixed code:
import math

a, b, t = [int(x) for x in input().split()]
print(math.ceil((t + 0.5) // a) * b)
Buggy code:
a,b,t = map(int, input().split())
print(b*((t+0.5)//a)

Fixed code:
a, b, t = list(map(int, input().split()))
print(b * int((t + 0.5) // a))
Buggy code:
a,b,t = map(int,input().split())
T = t + 0.5

print(round(T/a)*b)

Fixed code:
a,b,t = map(int,input().split())
T = t + 0.5

print(round(T // a * b))
Buggy code:
a, b, t = map(int, input().split())
print((((t + 0.5) - ((t + 0.5) % a)) / a) * b)

Fixed code:
a, b, t = map(int, input().split())
print(int((((t + 0.5) - ((t + 0.5) % a)) / a) * b))
Buggy code:
A, B, T = map(int, input().split())

num = T + 0.5 // A

print(num * B)


Fixed code:
A, B, T = map(int, input().split())
 
num = (T + 0.5) // A
 
print(int(num * B))
Buggy code:
A, B, T = map(int, input().split())
ans = ((T + 0.5) // A) * B
print(ans)

Fixed code:
A,B,T=map(int,input().split(" "))

ans=((T+0.5)//A)*B
print(int(ans))
Buggy code:
a,b,t= map(int, input().split())
print(((t+0.5)//a)*b)

Fixed code:
a,b,t = input().split()
print(int((int(t) + 0.5) // int(a) * int(b)))
Buggy code:
from functools import reduce
A, B, T = map(int, input().split())

print((T + 0.5) // A * B)

Fixed code:
from functools import reduce
A, B, T = map(int, input().split())
print(int((T + 0.5) // A * B))
Buggy code:
a,b,t=map(int,input(),split())
print(((t+1/2)//a)*b)


Fixed code:
a,b,t=map(int,input().split())
print(((t+1//2)//a)*b)
Buggy code:
a,b,t = map(int,input().split())
x = (t + 0.5) // a
print(x*b)

Fixed code:
a,b,t = map(int,input().split())
x = int((t+0.5) // a)
print(x*b)
Buggy code:
A,B,T = map(int, input().split())

print(B * T//A)

Fixed code:
A,B,T = map(int,input().split())

print(T // A * B)
Buggy code:
a, b, t = map(int, input().split())
print(((t+0.5)//a) * b)


Fixed code:
a,b,t = map(int,input().split())

n = (t+0.5)//a

print(int(n*b))
Buggy code:
A,B,T = map(int,input().split())
n = int((T + 0.5)//A)
print(n*A)

Fixed code:
A,B,T = map(int,input().split())
T = T+0.5
print(int((T//A)*B))
Buggy code:
a,b,t = map(int,input().split())
print(round((t+0.5)/a)*b)

Fixed code:
a, b, t = map(int, input().split())
print(int((t+0.5) //a *b))
Buggy code:
a,b,t=map(int,input().split())

print((t+0.5)//a*5)


Fixed code:
a,b,t=map(int, input().split())

ans=(t+0.5)//a*b
print(int(ans))
Buggy code:
A, B, T = map(int, input().split(' '))

print(B * T // A)


Fixed code:
A,B,T= map(int,input().split())
print((T//A)*B)
Buggy code:
a,b,t=map(int,input().split())
print(int(t/a*b))

Fixed code:
a, b, t = map(int, input().split())

s = b * (t//a)

print(s)
Buggy code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,t=I()
time=0
cnt=1
while t+0.5 > time:
    ans +=b
    time+=a*cnt
    cnt+=1

print(ans)


Fixed code:
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,t=I()


print(t//a*b)
Buggy code:
a,b,t = map(int,input().split())
t = t+0.5
cnt = t//a

print(cnt*b)

Fixed code:
a,b,t = map(int,input().split())

print(int(b * ((t+0.5) // a)))
Buggy code:
a,b,t = map(int,input().split())
ans = b * t // a
print(ans)

Fixed code:
a, b, t = map(int,input().split())
ans = t // a * b
print(ans)
Buggy code:
A,B,T = input().split()
print(int((T//A)*B)

Fixed code:
A, B ,T = map(int, input().split())
print(B*(T//A))
Buggy code:
a, b, t = map(int, input().split())
num = t / a
print(num * b)

Fixed code:
a,b,t = map(int, input().split())
 
print((t//a)*b)
Buggy code:
a,b,t=map(int,input().split())

ans=((t+0.5)//a)*b
print(ans)

Fixed code:
a,b,t=map(int,input().split())

ans=int(((t+0.5)//a)*b)
print(ans)
Buggy code:
A,B,T=map(int, float(input()))
print((T+0.5)//A*B)

Fixed code:
A,B,T=(map(float, input().split())) 
print(int((T+0.5)//A*B))
Buggy code:
a, b, t = map(int, input().split())
n = (t + 0.5) // a
print(b * n)

Fixed code:
a, b, t = map(int, input().split())
n = (t + 0.5) // a
print(int(n * b))
Buggy code:
A, B, T = map(int, input().split())
print((T+0.5)//A * B)

Fixed code:
A, B, T = map(int,input().split())
print(int(B * ((T+0.5)//A)))
Buggy code:
A, B, T= map(int, input().split())

print(round(T/A)*B)

Fixed code:
A, B, T= map(int, input().split())

print(T//A*B)
Buggy code:
A, B, T =map(int, input().split())
print(B * ((T+0.5) //A))


Fixed code:
A, B, T = map(int,input().split())
print(int(((T+0.5)//A)*B))
Buggy code:
a = list(map(int,input().split()))
print(a[1]*a[2]//a[0])

Fixed code:
a = list(map(int,input().split()))
print(a[1]*(a[2]//a[0]))
Buggy code:
import math
a, b, t = map(int, input().split())
t += 0.5
cou = t // a
ans = cou * b
print(ans)

Fixed code:
from math import ceil
a, b, t = map(int, input().split())
t += 0.5
cou = t // a
ans = cou * b
print(ceil(ans))
Buggy code:
a, b, t, = map(int, input().split())
ans = ((t + 0.5) // a ) * b
print(ans)

Fixed code:
a, b, t, = map(int, input().split())
ans = ((t + 0.5) // a ) * b
print(int(ans))
Buggy code:
x = input()
x = x.split(" ")
a = x[0]
b = x[1]
c = x[2]
n = c // a 
print(n * b)

Fixed code:
x = input()
x = x.split(" ")
a = int(x[0])
b = int(x[1])
c = int(x[2])
n = c // a 
print(n * b)
Buggy code:
A,B,T=map(int,input().split())
n=int(T/B)
print(B*n)


Fixed code:
A,B,T = map(int,input().split())

print(T//A * B)
Buggy code:
a, b, t, = map(int, input().split())
ans = 0
t += 0.5

ans += (t / a) * b
print(ans)

Fixed code:
a, b, t, = map(int, input().split())
ans = 0
t += 0.5

ans = int((t // a) * b)
print(ans)
Buggy code:
a,b,t=map(int,input().split())
t+=0.5
print(t//a*b)

Fixed code:
a, b, t = map(int, input().split())
print(int((t+0.5) // a * b))
Buggy code:
a, b, t = map(int, input().split())
print(((t+0.5) // a)*b)

Fixed code:
a,b,t=map(int,input().split())
cnt=(t+0.5)//a
print(int(b*cnt))
Buggy code:
A, B, T = map(int, input().split())
T += 0.5
print(int(T/A*B)


Fixed code:
A, B, T = map(int, input().split())
T += 0.5
print(int(T//A*B))
Buggy code:
A, B, T = list(map(int, input().split()))
print(int((T/A)*B))

Fixed code:
A, B, T = map(int, input().split())

print((T // A)*B)
Buggy code:
a,b,t = map(int,input().split())
k = (t+0.5)//a
print(k*b)

Fixed code:
a, b, t = map(int, input().split())

print(int((t + 0.5) // a) * b)
Buggy code:
a, b, c = map(int ,input().split())
	print((a+0.5)//c * a)

Fixed code:
a, b, c = map(int ,input().split())
print(int((c+0.5)//a * b))
Buggy code:
a,b,t=map(int,input().split())
print((t/a)*b)

Fixed code:
a, b, t = map(int, input().split())
print(int(b * (t // a)))
Buggy code:
a,b,t = map(int, input().split())
sum = a//t
print(b*sum)

Fixed code:
a,b,t=map(int,input().split())

print(b*(t//a))
Buggy code:
a,b,t = map(int, input().split())
sum = a//t
print(b*ans)


Fixed code:
a,b,t = map(int,input().split())

ans = (t//a) * b

print(ans)
Buggy code:
a,b,t = map(int,input().split())
print((t+0.5)//a*b)


Fixed code:
a,b,t = map(int,input().split())
print(int((t+0.5)//a*b))
Buggy code:
A,B,T = map(int, input().split())
Ans = ((T+0.5)//A)*B
print(int(Ans)

Fixed code:
A,B,T = map(int, input().split())
Ans = ((T+0.5)//A)*B
print(int(Ans))
Buggy code:
A, B, T = map(int, input().split())
print(((T+0.5)//B)*a)

Fixed code:
A, B, T = map(int, input().split())
print(int(((T+0.5)//A)*B))
Buggy code:
A = list(map(int,input().split()))
print((A[2]-A[2]%A[0])/A[0]*A[1])

Fixed code:
A = list(map(int,input().split()))
print(int((A[2]-A[2]%A[0])/A[0]*A[1]))
Buggy code:
A, B, T = int(x) for x in input().split()

print((T//A)*B)

Fixed code:
A, B, T = (int(x) for x in input().split())
 
print((T//A)*B)
Buggy code:
A, B, T = list(map(int, input().split()))

print(str(B * ((T+0.5) // A) ))


Fixed code:
A, B, T = list(map(int, input().split()))

print(str(int(B * ((T+0.5) // A) )))
Buggy code:
A,B,T = map(input().split())
print(T//A*B)


Fixed code:
A,B,T = map(int,input().split())
print(T//A*B)
Buggy code:
a, b, t = [int(x) for x in input().split()]
sum = b*(t+0.5)//a
print(sum)

Fixed code:
a, b, t = [int(x) for x in input().split()]
sum = int(b*((t+0.5)//a))
print(sum)
Buggy code:
A,B,T=map(int,input().split())
time=(T+0.5)//A
S=B*time
print(S)

Fixed code:
A,B,T=map(int,input().split())
time=(T+0.5)//A
S=int(B*time)
print(S)
Buggy code:
A, B, T = map(int, input().split())
print(A*B*T)

Fixed code:
A,B,T = map(int,input().split())

print(T//A*B)
Buggy code:
a,b,t=map(int,input().split())

print(t//a*b

Fixed code:
a,b,t=map(int,input().split())

print((t//a)*b)
Buggy code:
a,b,t=map(int,input().split())
print((0.5+t)//a*b)

Fixed code:
a, b, t = map(int, input().split())
c = (t+0.5)//a
print(int(c*b))
Buggy code:
a, b, t = map(int, input().split())
print((t + 0.5) // a * b)

Fixed code:
a,b,t = map(int, input().split())
print(round((t + 0.5) // a * b))
Buggy code:
A,B,T = map(int, input().split())

print(B*(T/A))


Fixed code:
A,B,T=map(int,input().split())
a=T//A
print(B*a)
Buggy code:
a,b,t=map(int,input().split())
print(b*(a//t))

Fixed code:
a,b,t = map(int,input().split())
n = t // a
print(n*b)
Buggy code:
A,B,T=map(int,input().split())
print(B*(T+0.5)/A)

Fixed code:
A,B,T = map(int,input().split())

print(int(((T + 0.5) // A) * B))
Buggy code:
a,b,c=map(int,input().split())
print(b*(t/a))

Fixed code:
a,b,t = list(map(int, input().split()))
c = t // a
print(c*b)
Buggy code:
import sys
import math

i=list(map(int,input().split()))

a=i[0]
b=i[1]
t=i[2]

ans=t/a*b
print(int(ans))

Fixed code:
import sys
import math

i=list(map(int,input().split()))

a=i[0]
b=i[1]
t=i[2]

ans=math.floor(t/a)*b
print(ans)
Buggy code:
a, b, c = [int(i) for i in input().split()]

c = c + 0.5

d = c // a

print(b * d)

Fixed code:
a, b, c = [int(i) for i in input().split()]

c = c + 0.5

d = c // a

print(int(b * d))
Buggy code:
a = list(map(int, input().split())
print(a[1]//a[0]*(a[2]+0.5))

Fixed code:
a = list(map(int, input().split()))
print(a[2]//a[0] * a[1])
Buggy code:
A, B, T = map(int, input().split())

print(int(B* T//A))

Fixed code:
A, B, T = map(int, input().split())

print(int(B* (T//A)))
Buggy code:
a,b,t = map(int, input().split())
print(((t+0.5) // a)*b)

Fixed code:
a,b,t = map(int, input().split())
ans = ((t+0.5) // a)*b
print(int(ans))
Buggy code:
a, b, t = [int(i) for i in input().split()]
print(b * (c // a))

Fixed code:
a, b, t = [int(i) for i in input().split()]
print(b * (t // a))
Buggy code:
a,b,t=map(input().split())
ans=0
ans=int(((t+0.5)//a)*b)
print(ans)

Fixed code:
a,b,t=map(int,input().split())
ans=int(((t+0.5)//a)*b)
print(ans)
Buggy code:
A,B,T = map(int,input().split())

print(((T+0.5)//A)*B)


Fixed code:
A, B, T = map(int, input().split())

print(int((T+0.5)//A*B))
Buggy code:
a, b, t = map(int, input().split())
print((t+0.5)//a * b)

Fixed code:
a, b, t = list(map(int, input().split()))
print(int(((t + 0.5) // a) * b))
Buggy code:
A, B, T = map(int,input().split())
print(int(T / A * B))

Fixed code:
A,B,T = list(map(int, input().split()))

print(T//A * B)
Buggy code:
a, b, t=map(int.input().split())
print(b*(t//a))

Fixed code:
a,b,t = map(int,input().split())
c=t//a
print(b*c)
Buggy code:
a,b,c=map(int, input().split())
print(a*(b/c))

Fixed code:
a,b,c=map(int, input().split())
print(b*(c//a))
Buggy code:
A,B,T = map(int,input().split())
A = int(A)
B = int(B)
T = int(T)

t = T + 0.5
k = t // A
bisket = k * B

print(bisket)

Fixed code:
A,B,T = input().split()
A = int(A)
B = int(B)
T = int(T)

t = T + 0.5
bisket = t // A * B

print(int(bisket))
Buggy code:
import math

A,B,T = map(int,input().split())

freq = math.floor(((T+0.5)/A))

print(A*freq)

Fixed code:
import math

A,B,T = map(int,input().split())

freq = math.floor(((T+0.5)/A))
print(B*freq)
Buggy code:

a, b, t = map(int, input().split())
x = int(t+0.5) / a
print(x * b)


Fixed code:
a, b, t = map(int, input().split())
t = t + 0.5
x = t // a
y = x * b
print(int(y))
Buggy code:
A, B, T = map(int, input().split())
print(int(((T + 0.5)//A * A)))

Fixed code:
A, B, T = map(int, input().split())
print(int(((T + 0.5)//A * B)))
Buggy code:
A,B,T = map(int, print(input().split()))

print(T//A*B)


Fixed code:
A,B,T=map(int, input().split())
print(T//A*B)
Buggy code:
a,b,t=map(int,input().split())
aa=(t+0.5)//a
print(b*aa)

Fixed code:
a,b,t=map(int,input().split())
aa=int((t+0.5)//a)
print(b*aa)
Buggy code:
A, B, T = list(map(int, input().split()))
print((T/A)*B)

Fixed code:
A, B, T = list(map(int, input().split()))
print(T // A * B)
Buggy code:
a,b,t=map(int,input().split())
print(b*((t+0.5)//a))

Fixed code:
a,b,t = map(int, input().split())

ans = int((t + 0.5) // a * b)

print(ans)
Buggy code:
A,B,T = map(int,input().split())
print(T//A*3)

Fixed code:
A, B, T = map(int, input().split())

print(B*(T//A))
Buggy code:
A,B,T = map(int(input().split()))

print((T//A)*B)

Fixed code:
A,B,T=input().split()
A=int(A)
B=int(B)
T=int(T)
print(T//A*B)
Buggy code:
l = [int(i) for i in input().split()]
print((l[3] + 0.5) // l[0] * l[1])

Fixed code:
l = [int(i) for i in input().split()]
print(int((l[2] + 0.5) // l[0] * l[1]))
Buggy code:
A,B,T=map(int,input().split())
print((T+0.5)//A *B)

Fixed code:
A, B, T = map(int, input().split())

print(int(((T + 0.5) // A) * B))
Buggy code:
A,B,T=map(input(),split())
a=int(T/A+0.5)
print(a*B)

Fixed code:
A, B, T =map(int,input().split())
print( int((T+0.5)//A * B))
Buggy code:
A,B,T = map(int,input().split())
C = (T + 0.5) // A
D = C * B 
print(D)

Fixed code:
A,B,T = map(int,input().split())
C = (T + 0.5) // A
D = C * B 
print(str(int(D)))
Buggy code:
a,b,t = map(int,input().split())
print(((t+0.5)//a)*b)

Fixed code:
a,b,t = map(int,input().split())
ans = 0
t += 0.5
ans = t //a * b
print(int(ans))
Buggy code:
a, b, t = map(int, input().split(' '))
print((t+0.5)//a*b)


Fixed code:
a, b, t = map(int, input().split())
print(int((t+0.5)//a*b))
Buggy code:
a, b, t = map(int, input().split())
print((t+0.5)//a*b)

Fixed code:
a,b,t=map(int,input().split())
ans = (t+0.5)//a * b
print(int(ans))
Buggy code:
a, b, t = map(int, input().split(' '))
(t+0.5)//a*b


Fixed code:
a, b, t = map(int, input().split(' '))
print(int((t+0.5)//a*b))
Buggy code:
a,b,t = map(int,input().split())
ans = t//a*5
print(ans)


Fixed code:
a,b,t = map(int,input().split())
ans = t//a*b
print(ans)
Buggy code:
a,b,t = map(int,input().split())

ans = (t+0.5)//a*b

print(ans)

Fixed code:
a,b,t = map(int,input().split())

ans = (t+0.5)//a*b

print(int(ans))
Buggy code:
A,B,T=map(int,input().split())
print(((T+0.5)/A)*B)

Fixed code:
A,B,T=map(int,input().split())
cnt=(T+0.5)//A
print(int(B*cnt))
Buggy code:
a,b,t=map(int,input().split())
t//=a
print(a*t)

Fixed code:
a, b, t=map(int, input().split())
print((t//a)*b)
Buggy code:
A,B,T=map(int,input().split)
print((T/A)*B)

Fixed code:
A,B,T = map(int, input().split())

ans = T // A * B
print(ans)
Buggy code:
a, b, t = map(int, input().split())

print(a // t * b)

Fixed code:
a,b,t = list(map(int,input().split()))
print(t//a*b)
Buggy code:
a, b, t = map(int, input().split())
print（b * (t // a))

Fixed code:
a,b, t= map(int, input().split())

print(b * (t//a))
Buggy code:
i=list(map(int,input().split()))
a=i[2]+0.5
b=a//i[0]
print(b*i[1])

Fixed code:
i=list(map(int,input().split()))
a=i[2]+0.5
b=a//i[0]
c=b*i[1]
d=int(c)
print(d)
Buggy code:
a,b,t = map(int,input().split())

print((t+0.5)//a*b)

Fixed code:
a, b, t = map(int, input().split())
print(int((t+0.5)//a)*b)
Buggy code:
import math
a,b,t = map(int,input().split())
b*(t//a)

Fixed code:
import math
a,b,t = map(int,input().split())
print(b*(t//a))
Buggy code:
a,b,t = map(int, input().split())
print(int(t/a * b))

Fixed code:
a, b, t = map(int, input().split())

print(b*(t//a))
Buggy code:
a,b,t=[int(s)for s in input().split()]
print(b*t//a)

Fixed code:
a,b,t=[int(s)for s in input().split()]
print(b*(t//a))
Buggy code:
a,b,t = map(int(),input().split())
x = t // a
y = x * b
print(y)

Fixed code:
a,b,t = map(int,input().split())
x = t // a
y = x * b
print(y)
Buggy code:
a, b, t = map(int, input().split())

print((t+0.5)//a * b)

Fixed code:
a, b, t = map(int, input().split())

print(int((t+0.5)//a * b))
Buggy code:
x = input().split()¥a, b,t = int(x[0]),int(x[1]),int(x[2])
t += 0.5
num = t//a
sum = int(num * b)
print(num)

Fixed code:
x = input().split()
a, b,t = int(x[0]),int(x[1]),int(x[2])
t += 0.5
num = t//a
sum = int(num * b)
print(sum)
Buggy code:
a,b,t=map(int,input ().split())
r=b*(t/a)
print(r)


Fixed code:
a, b, t = map(int, input().split())

print(t//a*b)
Buggy code:
A ,B ,T = map(int, input().split()) 
print(T/A*B)

Fixed code:
A ,B ,T = map(int, input().split()) 
print((T//A)*B)
Buggy code:
a, b, t = map(int, input().split())
print(b*((t+0.5)//a))

Fixed code:
a, b, t = map(int, input().split())
t=t+0.5
print(int(t//a*b))
Buggy code:
# -*- coding: utf-8 -*-

a, b, c = map(int, input().split())
int(b * ((t+0.5)//a))

Fixed code:
# -*- coding: utf-8 -*-
a, b, t = map(int, input().split())
print(int(b * ((t+0.5)//a)))
Buggy code:
mport math 

a,b,c= input().split()
x,y,z=(int(a),int(b),int(c))
p = math.floor(z / x)
print(int(p * y))


Fixed code:
import math 

a,b,c= input().split()
x,y,z=(int(a),int(b),int(c))
p = math.floor(z / x)
print(int(p * y))
Buggy code:
a,b,t=map(int,input().split());print((t+0.5)//a*b)

Fixed code:
a,b,t=map(int,input().split())

print(int((t+0.5)//a*b))
Buggy code:
A,B,C = map(int, input().split())
print(round(C/A*B))

Fixed code:
A,B,C = map(int, input().split())
print(round(C//A*B))
Buggy code:
a, b, t = map(int,input().split())

time = (t+0.5) // a
print(b * time)

Fixed code:
a,b,t = map(int,input().split())
print(int((t+0.5)//a*b))
Buggy code:
a,b,t = map(int,input().split())
print((t+0.5)//a*b)

Fixed code:
a,b,t = map(int, input().split())

cnt = (t+0.5)//a

print(int(cnt*b))
Buggy code:
a, b, t = map(int,input().split())
 
time = t  // a

print(time)
print(b * time)

Fixed code:
a,b,t =map(int, input().split())

print((t//a)*b)
Buggy code:
a, b, t = map(int, input().split())

turn = t // a
count = a * turn

print(count)


Fixed code:
a, b, t = map(int, input().split())

turn = t // a
count = b * turn

print(count)
Buggy code:
a,b,t = map(int,input().split())
print(int(b/a*t+0.5))

Fixed code:
a,b,t = map(int, input().split())
print(int(((t + 0.5)//a)*b))
Buggy code:
A, B, T = map(int, input.split())

print((T+0.5) // A * B)

Fixed code:
A, B, T = map(int, input().split())

print(int((T+0.5) // A * B))
Buggy code:
a , b , t = map(int, input().split())
n = ((t + 0.5 / a) * b).int()
print(n)


Fixed code:
a, b, t = map(int, input().split())
print(int(((t + 0.5) // a) * b))
Buggy code:
A, B, T = map(int, input().split())

print((T+0.5)//A*B)

Fixed code:
A, B, T = map(int, input().split())
x = (T + 0.5) // A
print(int(B * x))
Buggy code:
a,b,c=map(int,input().split())
print(b*(t//a))

Fixed code:
a,b,c=map(int,input().split())
print(c//a*b)
Buggy code:
a,b,t=list(map(int,input().split()))
print(t*(b//a))


Fixed code:
a, b, t = list(map(int, input().split()))
print(t // a * b)
Buggy code:
A,B,T=map(int,input().split())

number = ((T+0.5)//A)*B

print(number)

Fixed code:
A,B,T=map(int,input().split())

number = round(((T+0.5)//A)*B)

print(number)
Buggy code:
import sys
a,b,t = list(map(int, input().split()))
print(b*(c//a))

Fixed code:
import sys
a,b,t = list(map(int, input().split()))
print(b*(t//a))
Buggy code:
a,b,t = map(int, input().split())
print(((t+0.5)//a)*b)

Fixed code:
a,b,t = map(int,input().split())
print(int(((t + 0.5 )  // a )* b))
Buggy code:
a,b,c = list(map(int,input().split()))
print(a*(c//b))


Fixed code:
a,b,c = list(map(int,input().split()))
print(b*(c//a))
Buggy code:
A,B,T=map(int,input().split())
print(int(((T+0.5)/A)*B))


Fixed code:
A, B, T = map(int, input().split())
ans = int((T + 0.5) // A * B)
print(ans)
Buggy code:
a,b,c = map(int,input().split())
c += 0.5
print(c//a*b)

Fixed code:
a,b,c = map(int,input().split())
c+=0.5
print(int(c//a*b))