qyliang/CodeNanoFix huggingface dataset:
Buggy code:
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
N = int(input())
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors

ls = make_divisors(N)
count =0
for i in ls:
    if N/i -2> 0:
        count+= N/i -1 

print(int(count))

Fixed code:
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
N = int(input())
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors

ls = make_divisors(N)
count =0
for i in ls:
    if N/i -1 >= 1 and i < N/i-1:
        count+= N/i -1 
    

print(int(count))
Buggy code:
import math
N = int(input())

ans = 0
tmp = math.sqrt(1 + 4 * N)
if tmp * tmp == 4 * N + 1:
    tmp -= 1
mina = int((-1 + tmp) / 2) + 1

for a in range(1, mina):
    if (N - a) % a == 0:
        ans += (N - a) / a
print(int(ans))




Fixed code:
import math
N = int(input())

ans = 0
mina = int((-1 + math.sqrt(1 + 4 * N)) / 2)
if (mina * 2 + 1) * (mina * 2 + 1) != 1 + 4 * N:
    mina += 1

for a in range(1, mina):
    if (N - a) % a == 0:
        ans += int((N - a) / a)
print(ans)
Buggy code:
import math
N = int(input())
div = []
for i in range(1, int(math.sqrt(N))+1):
  if N%i==0:
    div.append(i)
    if i != N//i:
      div.append(N//i)
ans = 0
for i in range(len(div)):
  if div[i]-1>0 and N%(div[i]-1)!=0:
    ans += div[i]-1
print(ans)

Fixed code:
import math
N = int(input())
div = []
for i in range(1, int(math.sqrt(N))+1):
  if N%i==0:
    div.append(i)
    if i != N//i:
      div.append(N//i)
ans = 0
for i in range(len(div)):
  if div[i]-1 > 0 and N//(div[i]-1) == N%(div[i]-1):
    ans += div[i]-1
print(ans)
Buggy code:
# div2019D - DivRem Number
def divisors(n: int) -> set:
    # Compute divisors of a number.
    divs = set()
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            div.add(i)
            div.add(n // i)
    return divs


def main():
    N = int(input())
    divs = divisors(N)
    ans = 0
    for m in divs:
        if m == 1:
            continue
        m -= 1
        if N // m == N % m:
            ans += m
    print(ans)


if __name__ == "__main__":
    main()

Fixed code:
# div2019D - DivRem Number
def divisors(n: int) -> set:
    # Compute divisors of a number.
    divs = set()
    for i in range(1, int(n ** 0.5) + 1):
        if n % i == 0:
            divs.add(i)
            divs.add(n // i)
    return divs


def main():
    N = int(input())
    divs = divisors(N)
    ans = 0
    for m in divs:
        if m == 1:
            continue
        m -= 1
        if N // m == N % m:
            ans += m
    print(ans)


if __name__ == "__main__":
    main()
Buggy code:
n = int(input())
i = 1
ans = 0
while i * i <= n:
    m = n / i - 1
    if m != 1:
        1
    elif m == int(m) and n // m == n % m:
        ans += int(m)
    i += 1
print(ans)

Fixed code:
n = int(input())
i = 1
ans = 0
while i * i <= n:
    m = n / i - 1
    if m == 0:
        1
    elif m == int(m) and n // m == n % m:
        ans += int(m)
    i += 1
print(ans)
Buggy code:
n = int(input())
ans = 0
for i in range(1,int(n**(1/2))+1):
    s = i
    a = i
    if (n-a)%s==0:
        ans += (n-a)//s
print(ans)

Fixed code:
n = int(input())
ans = 0
for i in range(1,int(n**(1/2))+1):
    s = i
    a = i
    if (n-a)%s==0:
        if (n-a)//s > a:
            ans += (n-a)//s
print(ans)
Buggy code:
N = int(input())

if N > 2:
    ans = N - 1
else:
    ans = 0

print(ans)
x = 2
while x*x <= N:
    if N % x == 0:
        m = N // x - 1
        if N % m == x:
            print(m)
            ans += m
    x += 1
print(ans)


Fixed code:
N = int(input())

if N > 2:
    ans = N - 1
else:
    ans = 0

x = 2
while x*x <= N:
    if N % x == 0:
        m = N // x - 1
        if N % m == x:
            ans += m
    x += 1
print(ans)
Buggy code:
# coding: utf-8
import numpy as np
from functools import lru_cache
import time
import math

def main(): 
    if True:
        N = int(input())
        #H,W = list(map(int, input().split()))
        #A = np.asarray([str(input()) for i in range(H)])
    else:
        pass

    sN = int(math.sqrt(N))
    r = np.asarray([],dtype=int)
    count = 0
    for i in range(sN+1):
        #print(i)
        if N % (i+1) == 0 :
            r = np.append(r,i+1)
            if i+1 != N//(i+1):
                r = np.append(r,N//(i+1))
    r = np.sort(r)

    for i in range(r.size)[1:]:
        if (r[i] - r[i-1]) > 1:
            count += r[i]-1

    print(int(count))#,r)
if __name__ =='__main__':
    main()

Fixed code:
# coding: utf-8
import numpy as np
from functools import lru_cache
import time
import math

def main(): 
    if True:
        N = int(input())
        #H,W = list(map(int, input().split()))
        #A = np.asarray([str(input()) for i in range(H)])
    else:
        pass

    sN = int(math.sqrt(N))
    r = np.asarray([],dtype=int)
    count = 0
    for i in range(sN+1):
        #print(i)
        if N % (i+1) == 0 :
            r = np.append(r,i+1)
            if i+1 != N//(i+1):
                r = np.append(r,N//(i+1))
    r = np.sort(r)

    for i in range(r.size)[1:]:
        if N//(r[i]-1) == N%(r[i]-1):
            count += r[i]-1
        else:
            pass
            #print(r[i])

    print(int(count))#,r)
if __name__ =='__main__':
    main()
Buggy code:
#!/usr/bin/env python3
import sys


def solve(N: int):
    ret = 0
    i = 1
    used = set()
    while i * i <= N:
        tmp = N - i
        if tmp % i == 0:
            val = tmp // i
            if not val in used:
                ret += val
                used.add(val)
        if N % (i + 1):
            val2 = N // (i + 1) != i
            #if val2 != val:
            if not val2 in used:
                ret += val2
                used.add(val2)
        i += 1
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()


Fixed code:
#!/usr/bin/env python3
import sys


def solve(N: int):
    ret = 0
    i = 1
    used = set()
    while (i - 1) ** 2 <= N:
        #print(i)
        tmp = N - i
        if tmp % i == 0:
            val = tmp // i
            if val > 0 and N // val == N % val and not val in used:
                ret += val
                used.add(val)
        if N % (i + 1):
            val = N // (i + 1) != i
            if val > 0 and N // val == N % val and not val in used:
                ret += val
                used.add(val)
        i += 1
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    solve(N)

if __name__ == '__main__':
    main()
Buggy code:
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

n = int(input())

for i in range(1, 1000):
    if n%i == n//i:
        print(i, n%i)
    #if ((n-i)/i)%1 == 0:
        #print(i)

#print(make_divisors(n))

ans = 0
for i in make_divisors(n):
    if i > n ** 0.5:
        ans += i-1

print(ans)
print(1)

Fixed code:
#%%
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

n = int(input())


ans = 0
for i in make_divisors(n):
    if i >= n ** 0.5 + 1:
        ans += i-1

print(ans)
Buggy code:
n=int(input())
c=0
for i in range(1,int(n**0.5)+1):
    if n%i==0:
        c+=max(0,n//i-1)
print(c)

Fixed code:
n=int(input())
c=0
for i in range(1,int(n**0.5)+1):
    if n%i==0:
        if i<n//i-1 :
            c+=max(0,n//i-1)
print(c)
Buggy code:
N = int(input())
#import math
#sq_N = int(math.sqrt(N))
ans = 0
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors
N_divs = make_divisors(N)
for i in range(len(N_divs)//2,len(N_divs)):
        ans += N_divs[i]-1
#for i in range(sq_N):
#    if N//i == N%i:
#        ans += i
if N == 2:
    ans = 0
print(ans)



Fixed code:
N = int(input())
import math
sq_N = int(math.sqrt(N))
ans = 0
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors
N_divs = make_divisors(N)


for i in range(len(N_divs)): 
    k = N//N_divs[i] - 1
    if k != 0:
        if N//k == N%k:
            ans += k

print(ans)
Buggy code:
N = int(input())

def make_divisors(n):
  divisors = []
  for i in range(1, int(n ** 0.5) + 1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i:
        divisors.append(n // i)
  return divisors

div = make_divisors(N)
ans = 0
for d in div:
  if N // (d - 1) == N % (d - 1):
    ans += d - 1

print(ans)

Fixed code:
N = int(input())

def make_divisors(n):
  divisors = []
  for i in range(1, int(n ** 0.5) + 1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i:
        divisors.append(n // i)
  return divisors

div = make_divisors(N)
ans = 0
for d in div:
  if d != 1 and N // (d - 1) == N % (d - 1):
    ans += d - 1

print(ans)
Buggy code:
import math
N = int(input())
ans = 0
for m in range(1,math.ceil(N**(1/2))):
  if (N-m)%m == 0 and m < (N-m)%m:
    ans += int((N-m)/m)

if N == 1:
  ans = 0
if N == 2:
  ans = 0
if N == 3:
  ans = 2
if N == 6:
  ans = 5
print(ans)    

Fixed code:
import math
N = int(input())
ans = 0
for m in range(1,math.ceil(N**(1/2))):
  if (N-m)%m == 0 and m < (N-m)//m:
    ans += int((N-m)/m)

if N == 1:
  ans = 0
if N == 2:
  ans = 0
if N == 3:
  ans = 2
if N == 6:
  ans = 5
print(ans)
Buggy code:
import math
n = int(input())
cnt = 0

for i in range(1,int(math.sqrt(n)) + 1):
    if (n-i) % i == 0:
        cnt += (n-i) // i

print(cnt)

Fixed code:
import math
n = int(input())
cnt = 0

for i in range(1,int(math.sqrt(n)) + 1):
    if n % i == 0:
        if (n-i) // i > 0 and n // ((n-i) // i) == n % ((n-i) // i):
            cnt += (n-i) // i
print(cnt)
Buggy code:
import math

N = int(input())
n = int(math.sqrt(N))
count=0
for i in range(1,n+1:
    d = N - i
    if d%i==0:
        k = int(d/i)
        count+=k
print(count)

Fixed code:
import math

N = int(input())
n = int(math.sqrt(N))
count=0
for i in range(1,n+1):
    d = N - i
    if d%i==0 and i < (N // i) -1:
        k = d//i
        count+=k
print(count)
Buggy code:
n = int(input())
from math import gcd
r = n//2
cou = 0
for i in range(1,int(r**0.5)+1):
  if n%i==0:
    b = n//i-1 
    cou += b

    if i>2:
      c = i-1
      cou += c

print(cou)

Fixed code:
n = int(input())
from math import gcd
cou = 0
for i in range(1,int(n**0.5)+1):
  if n%i==0:
    b = n//i-1
    if b>=2 and n//b==n%b:
      cou += b
    
    if i>2:
      c = i-1
      if n//c==n%c:
        cou += c
print(cou)
Buggy code:
n = input()

result = 0

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

for i in make_divisors(n):
    x = n//c - 1
    if n%x == n//x:
        result+=x

print(result)


Fixed code:
n = int(input())

result = 0

def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

for i in make_divisors(n):
    x = n//i - 1
    if x!=0:
        if n%x == n//x:
            result+=x

print(result)
Buggy code:
N = int(input())

ans = 0
for i in range(1, int(N**0.5)+2):
    if (N-i)%i == 0:
        ans += (N-i)//i
print(ans)
    

Fixed code:
N = int(input())

ans = 0
for i in range(1, int((N+1)**0.5)):
    if (N-i)%i == 0:
        ans += (N-i)//i
print(ans)
Buggy code:
n=int(input())
ans=0
for i in range(1,int(n**.5)):
  if n%i==0:ans+=(n-i)//i
print(ans)

Fixed code:
n=int(input())
ans=0
for i in range(1,int(n**.5+(n**.5%1!=0))):
  j=(n-i)//i
  if n%j==n//j:
    ans+=j
print(ans)
Buggy code:
import math
n = int(input())
ans = 0
for i in range(1,math.floor(math.sqrt(n))):
    if n % i == 0:
        ans += (n//i)-1
print(ans)

Fixed code:
import math
n = int(input())
ans = 0
for i in range(1,math.floor(math.sqrt(n))+1):
    if n % i == 0:
        num = (n//i)-1
        if num > 0:
            if n // num == n % num:
                ans += num
print(ans)
Buggy code:
N = int(input())
k = int(1)
ans =  int(0)

while N>k**2 :
    if N%k==0:
        m = int(N//k-1)
        ans +=m
        k +=1

print(ans)


Fixed code:
N = int(input())
k = int(1)
ans =  int(0)

while N>k**2 :
    if N%k==0:
        m = int(N/k-1)
        if m>k:
            ans +=m
    k +=1

print(ans)
Buggy code:
n = int(input())
x = 0
for i in range(1,n+1):
  if (n-i)%i == 0:
    x += (n-i)//i
  if (n-i)/i<i:
    break
print(int(x))

Fixed code:
n = int(input())
x = 0
for i in range(1,n+1):
  if (n-i)//i<=i:
    break
  if (n-i)%i == 0:
    if (n-i)//i != i:
      x += (n-i)//i
print(int(x))
Buggy code:
N = int(input())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    return divisors


n = make_divisors(N)
answer = 0
for i in n:
    if i == 1:
        continue
    q, r = divmod(N, i - 1)
    if q == r:
        answer += i - 1
    else:
        break

print(answer)

Fixed code:
N = int(input())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors


n = make_divisors(N)
answer = 0
for i in n[::-1]:
    if i == 1:
        continue
    q, r = divmod(N, i - 1)
    if q == r:
        answer += i - 1
    else:
        break

print(answer)
Buggy code:
import math
n = int(input())
ans = 0
for i in range(1,math.ceil(math.sqrt(n))):
    if n % i == 0:
        div = (n - i) // i
        if div < i:
            ans += div
print(ans)


Fixed code:
import math
n = int(input())
ans = 0
for i in range(1,math.ceil(math.sqrt(n))):
    if n % i == 0:
        div = (n - i) // i
        if div > i:
            ans += div
print(ans)
Buggy code:
import math
N = int(input())
result = 0

root = math.ceil(math.sqrt(N))
for i in range(root):
    if N % (i + 1) == 0:
        result += N // (i + 1) - 1

print(result)

Fixed code:
import math
N = int(input())
result = 0

root = math.ceil(math.sqrt(N))
for i in range(root):
    if N % (i + 1) == 0 and (i + 1) + 1 < N // (i + 1):
        result += N // (i + 1) - 1

print(result)
Buggy code:
N = int(input())

ans = int()

for i in range(1, int((N + 1) ** 0.5) - 1):

    if N % i == 0:

        ans += int(N / i) - 1

print(ans)


Fixed code:
N = int(input())

ans = int()

for i in range(1, int(N ** 0.5) + 1):

    if N % i == 0 and i < int(N / i - 1):

        ans += int(N / i) - 1

print(ans)
Buggy code:
n = int(input())
n_1 = int(n ** (1/2)) + 1
s = 0

for i in range(1,n_1 + 1):
    if n % i == 0:
        s += (n // i) - 1

print(s)

Fixed code:
n = int(input())
n_1 = int(n ** (1/2))
s = 0
 
for i in range(1,n_1+10000):
    if n % i == 0:
        if i < n // i -1:
            s += (n // i) - 1

print(s)
Buggy code:
from math import sqrt
N = int(input())

ans = 0
for i in range(1, int(sqrt(N))+1):
    print(i)
    if N%i == 0 and i < N//i-1:
        ans += N//i-1

print(ans)

Fixed code:
from math import sqrt
N = int(input())

ans = 0
for i in range(1, int(sqrt(N))+1):
    # print(i)
    if N%i == 0 and i < N//i-1:
        ans += N//i-1

print(ans)
Buggy code:
N = int(input())
import math
ans = 0
for k in range(1, int(math.sqrt(N) + 1)):
    # print(k - 1, N // k - 1)
    if N % k == 0 and k ** 2 != N:
        ans += N // k - 1

print(ans - 1)


Fixed code:
N = int(input())
import math
ans = 0
for k in range(1, int(math.sqrt(N) + 1)):
    # print(k - 1, N // k - 1)
    m = N // k - 1
    if m != 0:
        if N % k == 0 and N // m == N % m:
            ans += m

print(ans)
Buggy code:
def make_divisor(n):
    divisor = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisor.append(i)
    divisor.append(n)
    return divisor

N = int(input())
a = make_divisor(N)

sum = 0
for i in a:
    sum += (N // i) - 1

print(sum)

Fixed code:
def make_divisor(n):
    divisor = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisor.append(i)
    divisor.append(n)
    return divisor

N = int(input())
a = make_divisor(N)

sum = 0
for i in a:
    if N // i - 1 > i:
        sum += (N // i) - 1

print(sum)
Buggy code:
N=int(input())
ans=0
for i in range(1,int(N**0.5)+1):
    if (N-i)%i==0:
        ans+=(N-i)//i
print(ans)

Fixed code:
N=int(input())
ans=0
if N==1:
    ans=0
else:
    for i in range(1,int(N**0.5)+1):
        if (N-i)%i==0:
            q=(N-i)//i
            if N%q==i:
                ans+=(N-i)//i
print(ans)
Buggy code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-


def main():
  n = int(input())
  total = 0

  if n <= 2:
    print(0)
    return

  for i in range(1, n):
    if i * (i + 1) >= n:
      break
    elif n % i != 0:
      continue
    else:
      total += n // i - 1

  print(total + n - 1)


if __name__ == '__main__':
  main()



Fixed code:
#!/usr/bin/env python
# -*- coding: utf-8 -*-


def main():
  n = int(input())
  total = 0

  if n <= 2:
    print(0)
    return

  for i in range(1, n):
    if i * (i + 1) >= n:
      break
    elif n % i != 0:
      continue
    else:
      total += n // i - 1

  print(total)


if __name__ == '__main__':
  main()
Buggy code:
N=int(input())
rN=int(N**(1/2))
ans=0
for i in range(1,rN+1):
  N-=1
  if N%i==0:
    ans+=N//i
print(ans)

Fixed code:
N=int(input())
rN=int(N**(1/2))
ans=0
for i in range(1,rN+1):
  N-=1
  if i>=N/i:
    break
  if N%i==0:
    ans+=N//i
print(ans)
Buggy code:
a,b,t = map(int,input().split())
print(str(((t+0.5) // a) * b))

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

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

T = T + 0.5

times = T // A

print(B*times)

Fixed code:
import sys
input = lambda: sys.stdin.readline().rstrip()

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

T = T + 0.5

times = T // A

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

S=T+0.5

C=S//A

print(C*B)

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

S=T+0.5

C=S//A

print(int(C*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,c= map(int,input().split())
aaa = (c + 0.5) // a
print(aaa * b)

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

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

t05 = t + 0.5
times = t05 // a

total = b * times


Fixed code:
abt = list(map(int,input().split()))

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

t05 = t + 0.5
times = t05 // a

total = b * times

print(str(int(total)))
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())
print(round(((T + 0.5) // 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())
s = (t+0.5) // a 
print(b*s)

Fixed code:
a, b, t=map(int, input().split())
s = (t+0.5) // a 
print(int(b*s))
Buggy code:
a, b, t = 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())

m=a//t

print(int(m*b))

Fixed code:
a,b,t=map(int,input().split())
     
m=t//a
     
print(int(m*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())
print(((T+0.5)//A)*B)


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

print(int(B * ((T+0.5) // A)))
Buggy code:
li = input().split()
A=int(li[0])
B=int(li[1])
T=int(li[2])
s=T*B/A
print(str(s))

Fixed code:
li = input().split()
A=int(li[0])
B=int(li[1])
T=int(li[2])
s=T//A*B
print(s)
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=(int(x) for x in input().split())
n=(t+0.5)//a
print(b*n)

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

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

i = int((T + 0.5) // A)

print(int(B * i))



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

i = int((T + 0.5) // A)

print(int(B * i))
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(b*((t+0.5)//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())

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

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 = B*(T // A)
print(ans)
Buggy code:
a, b, t = (int(i) for i in input().split())
print(b * t//a)

Fixed code:
a, b, t = (int(i) for i in 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())
print(int(B*((T+0.5)//A)))
Buggy code:
a,b,c=map(int,input(),split());print(c//a*b)

Fixed code:
a,b,c=map(int,input().split());print(c//a*b)
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())
t += 0.5
print(int(b * (t // a)))
Buggy code:
a,b,t=map(int,input().split())
print(int(b*(t+0.5)//a))

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

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


Fixed code:
#coding:utf-8
a,b,t =map(int,input().split())
x = t // a
print(b*x)
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)*5)


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

print((t//a)*5)

Fixed code:
a, b, t = map(int, input().split())
print(b*int(t//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())
print(int(((T+0.5)//A)*B))
Buggy code:
line = list(map(int,input().split()))
print(line)
a = (line[2] // line[0]) * line[1]
print(a)

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

c = int(t / a)

ans = a*c
print(ans)

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

c = t // a

ans = b*c
print(ans)