qyliang/CodeNanoFix huggingface dataset:
Buggy code:
A, B, C = map(int(),input().split())
print(min(B//A,C))

Fixed code:
A, B, C = (map(int, input().split()))
print(min(B // A, C))
Buggy code:
a,b,c=map(int,input().split())
if a*c <= b:
  print(c)
else:
  print(b/a)

Fixed code:
a,b,c=map(int,input().split())
print(c if c*a < b else b//a)
Buggy code:
a,b,c=map(int,input().split())
ans=min(b/a,c)
print(ans)

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


print(min(c, b//a))
Buggy code:
a, b, c = map(int, input().split())
print(a,b,c)
if(b/a>=c):
    print(c)
else:
    print(b//a)


Fixed code:
a,b,c = map(int,input().split())
m = b // a
if m >= c:
    print(c)
else:
    print(m)
Buggy code:
"""
author : halo2halo
date : 16, Jan, 2020
"""

import sys
import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A, B,C = map(int, readline().split())
print(max(B//A,C))


Fixed code:
"""
author : halo2halo
date : 16, Jan, 2020
"""

import sys
import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A, B,C = map(int, readline().split())
print(min(B//A,C))
Buggy code:
A,B,C = [int(v) for v in input().split()]
print(min(A//B,C))

Fixed code:
A,B,C = [int(v) for v in input().split()]
print(min(B//A,C))
Buggy code:
a,b,c=map(int,input().split(' '))
if c<b//a:
    print(b//a)
else:
    print(c)


Fixed code:
a,b,c=map(int,input().split(' '))
if b//a<c:
    print(b//a)
else:
    print(c)
Buggy code:
a,b,c = map(int,input().split())
if a//b >= c:
  print(c)
else:
  print(a//b)

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

if a*c>=b:
    print(b//a)
else:
    print(c)
Buggy code:
def main():
    A,B,C = input().split()
    if int(B)//int(A)>int(C):
        print(C)
    else:
        print(int(B)/int(A))

if __name__ == "__main__":
    main()


Fixed code:
def main():
    A,B,C = input().split()
    if int(B)//int(A)>int(C):
        print(C)
    else:
        print(int(B)//int(A))

if __name__ == "__main__":
    main()
Buggy code:
A,B,C = map(int, input().split())
print(min(A//B, C))

Fixed code:
A,B,C = map(int, input().split())
print(min(B//A, C))
Buggy code:
a,b,c = map(int,input().split())
if b//a>=c:
  print(b//a)
else:
  print(b//a)

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

if b >= a * c:
	print(c)
else:
	print(b // a)
Buggy code:
a,b,c = map(int,input().split())
print( min(b//a,c)

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



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

if a*c<=b:
  print(c)
  
else:
  print(b//a)

Fixed code:
a,b,c=map(int,input().split())
if a*c<=b:
  print(c)
else:
  print(b//a)
Buggy code:
a, b, c = map(int, input().split())
print(min(a // b, c))

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

if B >= A*C:
    print(A*C)
else:
    print(B//A)

Fixed code:
A,B,C = map(int,input().split())
if B//A >= C: print(C) 
else: print(B//A)
Buggy code:
A,B,C = [int(_) for _ in input().split]
n = min(B//A,C)
print(n)

Fixed code:
A,B,C = [int(_) for _ in input().split()]
n = min(B//A,C)
print(n)
Buggy code:
a, b, c=map(int, input().split())
if a * c <= b:
  print(c)
else:
  print(floor(b / a))

Fixed code:
a,b,c = map(int, input().split())
if a*c<=b: print(c)
else: print(b//a)
Buggy code:
A,B,C = map(int,input().split())
if B >= A*C:
    print(C)
else:
    print(B//C)

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

if B>= A*C:
    print(C)
else:
    print(B//A)
Buggy code:
a,b,c=map(int,input().split())

d=a//b

if d>=c:
  print(c)
else:
  print(d)

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

d=b//a

if d>=c:
  print(c)
else:
  print(d)
Buggy code:

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

if (b//a) <= c:
    print(c)
else:
    print(b//a)


Fixed code:
a,b,c=map(int,input().split())
if b//a<c:
    print(b//a)
else:
    print(c)
Buggy code:
import sys

l = []
for line in sys.stdin:
  l.append([int(i) for i in line.split()])

a, b, c = l
if b >= a * c:
  print(c)
else:
  print(b//a)
         

Fixed code:
import sys
 
l = []
for line in sys.stdin:
  l.append([int(i) for i in line.split()])
 
a, b, c = l[0]
if b >= a * c:
  print(c)
else:
  print(b//a)
Buggy code:
A, B, C = map(int, input().split())

if C <= B / A:
    print(C)
else:
    print(B / A)


Fixed code:
A,B,C = map(int,input().split())
if C*A <= B:
    print(C)
else :
    print(B//A)
Buggy code:
A, B, C = map(int, input().split())

print(min(B / A, C))


Fixed code:
A, B, C = map(int, input().split())
mx = B // A
print(min(mx, C))
Buggy code:
a,b,c = map(int, input().split())
ans = b//a
if ans >= c:
    ans = c

Fixed code:
a,b,c = map(int, input().split())
ans = b//a
if ans >= c:
    ans = c
print(ans)
Buggy code:
a. b, c = map(int, input().split())
z = b // a
if z >= c:
  print(c)
else:
  print(z)

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

if b // a > c:
    print(c)
else:
    print(b // a)
Buggy code:
a, b , c = map(int, input().split(' '))
if a*c < b:
    print(c)
else:
    printn(int(b//a))

Fixed code:
a, b , c = map(int, input().split(' '))
if a*c < b:
    print(c)
else:
    print(int(b//a))
Buggy code:
a, b, c = [int(i) for i in input().split()]

if a%b > c:
    print(c)
else:
    print(a%b)


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

if b//a > c:
    print(c)
else:
    print(b//a)
Buggy code:
A, B, C = map(int, input().split())

if A*C < B:
    print(C)

if A*C = B:
    print(C)

if A*C > B:
    print(B//A)

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

if A*C < B:
    print(C)

elif A*C == B:
    print(C)

elif A*C > B:
    print(B//A)
Buggy code:
A, B, C = [int(i) for i in input().split()]
print(min(B // A, C)

Fixed code:
A, B, C = [int(i) for i in input().split()]
print(min(B // A, C))
Buggy code:
x, y, z = map(int, input().split())
if y // x >= z:
    print("z")
else:
    print(y//x)


Fixed code:
x, y, z = map(int, input().split())
if y // x >= z:
    print(z)
else:
    print(y//x)
Buggy code:

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

Fixed code:

a,b,c=map(int,input().split())
print(min(b//a,c))
Buggy code:
a,b,c=map(int,input().split())
print(c if b/a<=c else b/a)

Fixed code:
a,b,c = map(int,input().split())
print(b//a if b//a <= c else c)
Buggy code:
A, B, C = map(int, input().split())

coin_sound_cnt = A//B
if coin_sound_cnt > C:
  print(C)
else:
  print(coin_sound_cnt)


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

coin_sound_cnt = B//A
if coin_sound_cnt > C:
  print(C)
else:
  print(coin_sound_cnt)
Buggy code:
A, B, C = map(int, input().split())
if (B / A < C):
    print(B / A)
else:
    print(C)


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

if B//A<C:
  print(int(B//A))
else:
  print(C)
Buggy code:
a,b,c = map(int, input().split())
print (min(b/a,c))

Fixed code:
a,b,c = map(int,input().split())
print(min(c,b //a))
Buggy code:
a,b,c = map(int,input().split())
if b*c <= a:
    print(c)
else:
    print(b//a)


Fixed code:
a,b,c = map(int,input().split())
if a*c <= b:
    print(c)
else:
    print(b//a)
Buggy code:
A, B, C = list(map(int, input().split()))
if A // B > C:
    print(C)
else:
    print(A // B)


Fixed code:
A, B, C = list(map(int, input().split()))
can_buy = B // A
if can_buy > C:
    print(C)
else:
    print(can_buy)
Buggy code:
a,b,c = list(map(int,input().split()))
print(min(b/a,c))

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

Fixed code:
A,B,C = map(int, input().split())
print(min(B//A, C))
Buggy code:
a,b, c = map(int, input().split())
if b/a > c:
  print(c)
else:
  print(b/a)
  

Fixed code:
a,b,c = map(int,input().split())
if b//a >= c:print(c)
else:print(b//a)
Buggy code:
A,B,C=(int() for x in input().split())
print(min(C,A//B))

Fixed code:
A,B,C=(int(x) for x in input().split())
print(min(C,B//A))
Buggy code:
a, b, c = map(int, input().split())

print(min(-(-b//a), c))

Fixed code:
a, b, c = map(int, input().split())
print(int(min(b // a, c)))
Buggy code:
a,b,c = map(int,input().split())
if a // b > c:
  print(c)
else:
  print(a // b)
  
  

Fixed code:
a,b,c = map(int,input().split())
if b // a > c:
  print(c)
else:
  print(b // a)
Buggy code:
a, b, c = map(int, input().split())
s = b // a
g = a * c
if a > g:
    print(c)
else:
    print(s)

Fixed code:
a, b, c = map(int, input().split())
s = b // a
g = a * c
if b > g:
    print(c)
else:
    print(s)
Buggy code:
a,b,c = map(int,input().split())
print(min((b//a),c)

Fixed code:

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

Fixed code:
a, b, c = map(int, input().split())
print(min(b//a, c))
Buggy code:
A, B, C = map(int, input().split())
print(B//A if B//C <= C else C)


Fixed code:
A, B, C = map(int, input().split())
print(B//A if B//A <= C else C)
Buggy code:
A,B,C=map(int,input().split())
if A*C<=B:
  print(C)
else:
  print(B/A)

Fixed code:
A,B,C=map(int,input().split())
if A*C<=B:
  print(C)
else:
  print(B//A)
Buggy code:
a,b,c=map(int,input().split())
print(min(b//a, c)

Fixed code:
a,b,c = map(int, input().split())
d = b // a
print(min(d,c))
Buggy code:
a,b,c = [int(x) for x in input().split()]
print(min(a//b, c))

Fixed code:
a,b,c = [int(x) for x in input().split()]
print(min(b//a, c))
Buggy code:
A,B,C=map(int,input().split())


min(int(B/A),C)

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

if b%a <= c :
    print(b//a)
else:
    print(c)

Fixed code:
a,b,c=map(int,input().split())
if b//a <= c:
	print(b//a)
else:
	print(c)
Buggy code:
A,B,C = map(int, input().split())
s = B//A
if C<=s:
	print(C)
else
	print(s)

Fixed code:
A,B,C = map(int, input().split())
s = B//A
if C<=s:
	print(C)
else:
	print(s)
Buggy code:
A, B, C = map(int, input().split())
B // A = D
if D >=C:
  print(C)
else:
  print(D)

Fixed code:
A, B, C = map(int, input().split())
D = B // A 
if D >=C:
  print(C)
else:
  print(D)
Buggy code:
a,b,c = map(int,input(),split())
if a*c < b:
  print(c)
else:
  print(b//a)

Fixed code:
a,b,c= map(int,input().split())
if a*c<b :print(c)
else:print(b//a)
Buggy code:
A, B, C = [int(i) for i in input().split()]
ans = max(B // A, C)
print(ans)

Fixed code:
A, B, C = [int(i) for i in input().split()]
ans = min(B // A, C)
print(ans)
Buggy code:
a,b,c= map(int,input().split())
if a*c>b :print(c)
else:print(b//a)

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

if b > a * c:
    print(c)
else:
    print(b//a)
Buggy code:
a,b,c=map(int,input().split())

answer = b//a

if answer<c:
  print(answer)
  else:
    print(c)

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

if b//a <= c:
  print(b//a)
  
else:
  print(c)
Buggy code:
A, B, C = map(int, input().split())
if (A*C) >= B:
  print(C)
else:
  print(B//A)

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

if B // A >= C:
	print(C)
else:
	print(B // A)
Buggy code:
a,b,c = map(int,input().split())
if(a/b >=c):
    print(c)
else:
    print(int(a/b))


Fixed code:
a,b,c=map(int,input().split())
if b//a>c:
  print(c)
else:
  print(b//a)
Buggy code:
A, B, C = map(int,input().split())
if C >= A // B:
  print(A // B)
else:
  print(C)

Fixed code:
A, B, C = map(int,input().split())
if C >= B // A:
    print(B // A)
else:
    print(C)
Buggy code:
price, wallet, m = map(int, input().split())
if wallet // price >= m:
  print(price*m)
else:
  print(wallet // price)

Fixed code:
price, wallet, m = map(int, input().split())
if wallet // price >= m:
  print(m)
else:
  print(wallet // price)
Buggy code:
a,b,c=map(int,input().split())
print(min(c,a//b))


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

print(min(b//a, c))
Buggy code:
A, B, C = map(int, input().split())

if A/B >= C:
  print(C)
else:
  print(A/B)


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

if B/A >= C:
  print(C)
else:
  print(B//A)
Buggy code:
a,b,c=map(int,input().split())
print(min(b//1,c))


Fixed code:
a,b,c=map(int,input().split())
print(min((b//a),c) )
Buggy code:
a,b,c=map(int, input.split())
max=a*c
if b >= max:
    print(c)
else:
    print(b//a)


Fixed code:
a,b,c=map(int, input().split())
if b >= a*c:
    print(c)
else:
    print(b//a)
Buggy code:
a, b, c = map(int, input().split())
res = b // a
if res > c:
  res = c
print(c)

Fixed code:
a, b, c = map(int, input().split())
res = b // a
if res > c:
  res = c
print(res)
Buggy code:
A, B, C = map(int, input().split())
if B / A > C:
  print(B / A)
else:
  print(C)

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

if(B // A >= C):
    print(C);
else:
    print(B // A)
Buggy code:
A,B,C=map(int,input().split())


B_A = B//A

if B_A <= C:
    print(C)
else:
    print(B_A)

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


B_A = (B//A)

if B_A <= C:
    print(B_A)
else:
    print(C)
Buggy code:
A,B,C = map(int,input().split())
print(int(min(C,A/B)))

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

count = a // b

if count < c:
  print(count)
else:
  print(c)

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

count = b // a

if count < c:
  print(count)
else:
  print(c)
Buggy code:
a, b, c = map(int, input().split());

if b / a >= c:
    print(c);
else:
    print(b/a);


Fixed code:
a,b,c = map(int,input().split())
if b/a >= c:
 print(c)
else:
 print(b//a)
Buggy code:
import sys
stdin = sys.stdin

def li(): return map(int, stdin.readline().split())

A, B, C = tuple(li())
times = B // A
print(min(A, C))


Fixed code:
import sys
stdin = sys.stdin

def li(): return map(int, stdin.readline().split())

A, B, C = tuple(li())
times = B // A
print(min(times, C))
Buggy code:
a,b,c=map(int,input().split())
if a//b >= c:
    A=c
else:
    A=a//b

Fixed code:
a,b,c=map(int,input().split())
if b//a >= c:
    A=c
else:
    A=b//a
print(A)
Buggy code:
A, B, C = map(int, input().split)
print(min(C, B//A)

Fixed code:
A, B, C = list(map(int, input().split()))
print(min(C, B // A))
Buggy code:
a,b,c = map(int,input().split())
print(min(-(-b//a),c))

Fixed code:
a,b,c = map(int, input().split())
print(min(int(b//a), c))
Buggy code:
A, B, C = list(map(int, input().split()))
if B // A >= C:
    print(C)
else:
    print(A//B)


Fixed code:
A,B,C=map(int,input().split())
if B//A>=C:
    print(C)
else:
    print(B//A)
Buggy code:
A,B,C = map(int, input().split())
if B//A > C
    print(C)
else:
    print(B//A)

Fixed code:
A,B,C = map(int, input().split())
if B//A > C:
    print(C)
else:
    print(B//A)
Buggy code:
A,B,C = map(int, input().split())
print(B//A)

Fixed code:
A,B,C = map(int,input().split())
print(min(B//A, C))
Buggy code:
a,b,c= map(int, input().split())
x=0
if b>a*c:
  x=c
else:
  x=b//c
print(x)

Fixed code:
a,b,c=map(int,input().split())
if b>=a*c:
    print(c)
else:
    print(b//a)
Buggy code:
a,b,c=map(int, input().split())
print(min(c,a//b))

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

print(min(b//a, c))
Buggy code:
A,B,C=map(int,input().split())
if B//A<=C:
    print(A//B)
else:
    print(C)

Fixed code:
A,B,C=map(int,input().split())
if B//A<=C:
    print(B//A)
else:
    print(C)
Buggy code:
A,B,C=map(int,input().split())
d=B//A
if d<C:
  print(d)
  else:
    print(C)

Fixed code:
A,B,C=map(int,input().split())
d=B//A
if d<C:
  print(d)
else:
  print(C)
Buggy code:
a,b,c = map(int,input.split())
print (min(b//a,c))

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

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

R = B // A

print(min(R, C))
Buggy code:
A, B, C = map(int, input().split())
print(B // A)

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

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

print(min(b // a, c))
Buggy code:
a,b,c = map(int,input().split(" "))
if b / a >= c:
  print(c)
else:
  print(b / a)

Fixed code:
a,b,c = map(int,input().split(" "))
if b // a >= c:
  print(c)
else:
  print(b // a)
Buggy code:
a,b,c = map(int,input().split())

print(min(c,a//b))

Fixed code:
a,b,c = map(int,input().split())
 
print(min(c,b//a))
Buggy code:
a,b,c = map(int,input().split())
print(c if a*c < b else b//c)

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

print(min(B/A, C))

Fixed code:

A, B, C = map(int, input().split())
print(min(B//A, C))
Buggy code:
A = list(map(int, input().split()))
a = A[1]//A[0]
if a >= A[2]:
    print(a)
else:
    print(A[2])

Fixed code:
A = list(map(int, input().split()))
a = A[1]//A[0]
if a <= A[2]:
    print(a)
else:
    print(A[2])
Buggy code:
a,b,c = map(int, input().split(' ')) 
if(b / a < c):
	print(b / a)
else:
	print(c)

Fixed code:
a,b,c = map(int, input().split()) 
if(b / a <= c):
	print(int(b // a))
else:
	print(c)
Buggy code:
a,b,c = map(int, input().split()) 
if(b / a < c):
	print(b / a)
else:
	print(c)

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

if b//a <= c:
  ans = b//a
else:
  ans = c
  
print(ans)
Buggy code:
A, B, C = map(int,input().split())
X =A//B
if X >= C:
    print(C)
else:
    print(X)

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

if B//A >= C:
    print(C)
else:
    print(B//A)
Buggy code:
A, B, C = map(int,input().split())
C = B//A
print(C)

Fixed code:
A, B, C = map(int, input().split())
print (min(B//A, C))
Buggy code:
A, B, C = map(int, input().split())
money_time = A * C
if money_time <= B:
  print(A)
else:
  print(B // A)

Fixed code:
A,B,C = map(int,input().split())
if (A*C) <= B:
    print(C)
else:
    print(B//A)
Buggy code:
A, B, C = map(int, input().split())

if B > A * C:
  print(A * C)
else:
  print(A)

Fixed code:
A, B, C = map(int, input().split())
 
if B > A * C:
  print(C)
else:
  print(B // A)
Buggy code:
a,b,c=map(int,input().split())
if a*c<=b:
  print(c)
else:
  print(c//a)

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

if(b//a<c):
    print(b//a)
else:
    print(c)
Buggy code:
a,b,c = map(int,input().split())
print(min(a//b, c))

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

print(min(b//a,c))
Buggy code:
A, B, C = map(int, input().split())
print(C if B // A > C else C)

Fixed code:
A, B, C = map(int, input().split())
if B // A > C:
    print(C)
else:
    print(B // A)
Buggy code:
a,b,c = int(input().split())
if b//a <= c:
    print(b//a)
else:
    print(c)

Fixed code:
a,b,c = map(int,input().split())
if b//a <= c:
    print(b//a)
else:
    print(c)
Buggy code:
a, b, c = map(int, input().split())
print(min(c, b//a)

Fixed code:
a, b, c = map(int, input().split())
print(min(c,b//a))
Buggy code:
a,b,c = map(int, input().split())
print(c) if a*c=<b else print(b//a)

Fixed code:
a,b,c = map(int, input().split())
print(c) if a*c<=b else print(b//a)
Buggy code:
a, b, c=map(int, input().split())
if b/a > c:
    print(c)
else:
    print(b/a)


Fixed code:
a, b, c=map(int, input().split())
if b/a > c:
    print(c)
else:
    print(b//a)
Buggy code:
A, B, C = map(int,input().split())

if (A * C) <= B:
    answer = C
else:
    answer = B % A
print(answer)

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

if (A * C) <= B:
    answer = C
else:
    answer = B // A
print(answer)
Buggy code:
A, B, C = map(int, input.split())
print(min(B//A, C))

Fixed code:
A, B, C = map(int,input().split(" "))
print(min(B//A,C))
Buggy code:
A, B, C = map(int, input().split())
print(min(-(-B//A), C)

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

print(b//a)

Fixed code:
a,b,c = map(int,input().split())
print(min(b // a,c))
Buggy code:
from sys import stdin

input = [int(i) for i in stdin.readline().rstrip().split(' ')]

if (input[0] * input[2]) <= input[1]:
  print(input[2])
else:
  print(input[1] / input[0])

Fixed code:
from sys import stdin

input = [int(i) for i in stdin.readline().rstrip().split(' ')]

if (input[0] * input[2]) <= input[1]:
  print(input[2])
else:
  print(input[1] // input[0])
Buggy code:
A, B, C = map(int, input().split())
ans = int(B / A)
if ans > 0:
    print(ans)
else:
    print(0)

Fixed code:
A,B,C = map(int, input().split())
ans = B // A
if ans >= C:
    print(C)
else:
    print(ans)
Buggy code:
A,B,C=map(int,input().split())
if B/A>=C:
    print(C)
else:
    print(B/A)

Fixed code:
A,B,C=map(int,input().split())
if B//A >= C:
    print(C)
else:
    print(B//A)
Buggy code:
A,B,C=map(int, input().split())
D=B//A
if D<=C:
    print(C)
else:
    print(D)

Fixed code:
A,B,C=map(int, input().split())
D=B//A
if D<=C:
    print(D)
else:
    print(C)
Buggy code:
a, b, c = map(int, input().split())
print(b//a)

Fixed code:

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

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

print(a//b) if a//b<c else print(c)

Fixed code:
a,b,c = map(int,input().split())
print(b//a if b//a < c else c)
Buggy code:
a,b,c = map(int,input().split())
print(b//a)

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

num = B // A

if num >= C:
    num == C

print(num)


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

num = B // A

if num >= C:
    print(C)
else:
    print(num)
Buggy code:
a, b, c = map(int, input().split())

if a * c <= b:
    print(a * c)
else:
    print(b // a)

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

if a*c <= b:
    print(c)
else:
    print(b//a)
Buggy code:
a,b,c=map(int,input().split());print(min(b,c)//a)

Fixed code:
a, b, c = map(int, input().split())
print(min(c, b//a))
Buggy code:
a,b,c=map(int,input().split())
x=int(b/a)
if(x=<c):
  print(x)
else:
  print(c)


Fixed code:
a, b, c=map(int, input().split())
if (b//a)<=c:
  print(b//a)
else:
  print(c)
Buggy code:
a,b,c = map(int,input().split())

if a*c < b:
  print(int(c))
if a*c > b:
  print(int(b/a))
else:
  print(0)
  

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

if b >= a * c:
    print(c)
else:
    print(b // a)
Buggy code:
import math
A,B,C=map(int,input().split())
can=math.floor(B/A)
print(can)
if can>=C:
  print(C)
else:
  print(can)

Fixed code:
import math
A,B,C=map(int,input().split())
can=math.floor(B/A)
if can>=C:
  print(C)
else:
  print(can)
Buggy code:
A,B,C = (int(i) for in input().split())
sho=B//A

if sho >= C :
    print(C)
else:
    print(sho)

Fixed code:
A,B,C = (int(i) for i in input().split())
sho=B//A

if sho >= C :
    print(C)
else:
    print(sho)
Buggy code:
A,B,C=map(int,input().split())
if A//B<C:
    print(A//B)
else :
    print(C)    


Fixed code:
A,B,C=map(int,input().split())
if B//A<C:
    print(B//A)
else :
    print(C)
Buggy code:
def main():
    a, b, c = map(int, input().split())

    if a * b >= c:
        print(c)
    else:
        print(b // a)

if __name__ == "__main__":
    main()


Fixed code:
def main():
    a, b, c = map(int, input().split())

    if b // a >= c:
        print(c)
    else:
        print(b // a)
    
if __name__ == "__main__":
    main()
Buggy code:
A,B,C=map(int,input().split())
print(min(int(B/A),C)

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


Fixed code:
a,b,c = map(int,input().split())
print(min(c, b//a))
Buggy code:
a,b,c=map(int,input().split())
total=b/a
if(total>=c):
    print(c)
else:
    print(total)

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

if b // a >= c:
    print(c)
else:
    print(b // a)