Problem:
 Score : 100 points    Problem Statement Takahashi likes the sound when he buys a drink from a vending machine.  That sound can be heard by spending A yen (the currency of Japan) each time.  Takahashi has B yen. He will hear the sound as many times as he can with that money, but at most C times, as he would be satisfied at that time.  How many times will he hear the sound?      Constraints  All values in input are integers.  1 \leq A, B, C \leq 100         Input Input is given from Standard Input in the following format:  A  B  C       Output Print the number of times Takahashi will hear his favorite sound.        Sample Input 1 2 11 4      Sample Output 1 4  Since he has not less than 8 yen, he will hear the sound four times and be satisfied.       Sample Input 2 3 9 5      Sample Output 2 3  He may not be able to be satisfied.       Sample Input 3 100 1 10      Sample Output 3 0

Solution (Python):
A,B,C = map(int,input().split())
print(min(B//A,C))

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

Solution (Python):
A, B, C = map(int, input().split())

print(min([B//A, C]))

Solution (Python):
A,B,C = map(int,input().split())
if B // A <= C:
    print(B // A)
else:
    print(C)

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

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

Solution (Python):
A,B,C = map(int, input().split(" "))
c = B//A
if c>=C:
	print(C)
else:
  print(c)

Solution (Python):
A,B,C = map(int,(input().split()))
print(min(B//A,C))

Solution (Python):
A,B,C = map(int,input().split())

print(min(C,B//A))

Solution (Python):
a, b, c = map(int, input().split())
ans = min(b // a, c)
print(ans)

Solution (Python):
a, b, c = map(int, input().split())
if a > b:
    print(0)
elif a == b:
    print(1)
elif a < b:
    if b // a <= c:
         print( b // a)
    else:
         print(c)

Solution (Python):
A,B,C=map(int,input().split())

print(min(B//A,C))

Solution (Python):
A,B,C=map(int,input().split())
i=B//A
if i>C:
    print(C)
else:
    print(i)

Solution (Python):
import math
a, b, c = map(int, input().split())

print(min(c, math.floor(b/a)))

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

Solution (Python):
A,B,C = [int(i) for i in input().split()]
if A*C <= B:
    print(C)
else:
    print(B//A)

Solution (Python):
A,B,C=map(int,input().split())
print(min(B//A,C))

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

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

Solution (Python):
A,B,C=map(int,input().split())
if A*C<B:
  print(C)
else:
  print(B//A)

Solution (Python):
def main():
    a, b, c = map(int, input().split())
    Count = 0
    while True:
        b = b-a
        if Count == c or b < 0:
            break
        Count += 1
    print(Count)


if __name__ == "__main__":
    main()

Solution (Python):
a, b, c = map(int, input().split())
if b // a >= c:
    print(c)
else:
    print(b // a)

Solution (Python):
a, b, c = map(int, input().split())
d = 0
for i in range(1,c+1):
  if i*a <=b:
    d += 1
    continue
  else:
    break
print(d)

Solution (Python):
A,B,C = map(int,input().split())

print(min(C, B // A))

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

Solution (Python):
A, B, C = map(int, input().split())
print(min(B//A,C))

Solution (Python):

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

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

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

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

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

ans = min(b // a, c)


print(ans)

Solution (Python):

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

D=B//A

if C>D:
    print(D)
else:
    print(C)

Solution (Python):
def solve():
    A,B,C = map(int, input().split())
    print(min(C, B//A))

if __name__ == '__main__':
    solve()

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

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

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

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

Solution (Python):
a,b,c = map(int,input().split())
if b//a <= c:
  print(b//a)
else:
  print(c)

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

manzoku = c
saitei = b//a

print(min(manzoku, saitei))

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

Solution (Python):
a,b,c=map(int,input().split())
if b//a<c:
  print(b//a)
else:
  print(c)

Solution (Python):
a,b,c = map(int,input().split())
if c> b/a :
  print(int(b/a))
else:
  print(c)

Solution (Python):
A,B,C=map(int,input().split())
if B/A<0:
    print(0)
elif B/A>=C:
    print(C)
else:
    print(int(B/A))

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

Solution (Python):
A, B, C = map(int, input().split())
print(min(B//A, C))

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

Solution (Python):
A,B,C = [int(s) for s in input().split()]
 
print(C) if B//A >= C else print(B//A)

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

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

Solution (Python):
A, B, C = map(int, input().split())
print(min(B // A, C))

Solution (Python):
A,B,C=map(int,input().split())
print(min(B//A,C))

Solution (Python):
A, B, C = map(int, input().split())

print(min(B // A, C))

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

Solution (Python):
[A,B,C] = list(map(int,input().split()))
print(min(C,B//A))

Solution (Python):
a, b, c = map(int, input().split())
if b//a > c:
    print(c)
else:
    print(b//a)

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

Solution (Python):
a, b, c = map(int, input().split())
if a*c <= b:
    print(c)
else:
    print(b//a)

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

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

Solution (Python):
a,b,c=map(int,input().split())
ans=min(b//a,c)
print(ans)

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

Solution (Python):
A,B,C = map(int,input().split())

if B // A >= 1:
    if C <= B // A:
        print(C)
    elif B // A < C:
        print(B // A)
else:
    print(0)

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

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

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

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

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

Solution (Python):
a,b,c = map(int,input().split())
if a * c <= b:
    print(c)
else:
    print(b // a)

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

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

Solution (Python):
A,B,C = list(map(int,input().split()))

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

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

Solution (Python):
A,B,C=map(int,input().split())
if A*C<=B :
  print(C)
else :
  print(B//A)

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

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

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

Solution (Python):


A,B,C = [int(i) for i in input().rstrip().split()]

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

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

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

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

Solution (Python):
a,b,c = map(int,input().split())
if c*a < b:
    print(c)
else:
    print(b//a)

Solution (Python):
a, b, c = [int(_) for _ in input().split()]
print(min(b//a, c))

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

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

Solution (Python):
A, B, C = map(int, input().split())
if B >= A*C :
    print(C)
else :
    print(B//A)

Solution (Python):
A,B,C = map(int, input().split())
if B//A < C:
    print(B//A)
else:
    print(C)

Solution (Python):

A,B,C=map(int,input().split())
print(min(C,B//A))

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

Solution (Python):


[a, b, c] = [int(x) for x in input().split()]

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

Solution (Python):
a,b,c = map(int,input().split())
print(c if a*c<b else b//a)

Solution (Python):
A, B, C = map(int, input().split())
print(min(B // A, C))

Solution (Python):
a,b,c = map(int, input().split())
if b//a >= c:
  print(c)
if b//a < c:
  print(b//a)

Solution (Python):
a,b,c=map(int,input().split());print(min(b//a,c))

Solution (Python):
a,b,c=map(int,input().split())
if b//a <= c:
	print(b//a)
else:
	print(c)

Solution (Python):
s=list(map(int,input().split()))
a=s[1]//s[0]
if a<=s[2]:
  print(int(a))
else:
  print(s[2])

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

Solution (Python):
class Solution:
    def solve(self, A: int, B: int, C: int) -> str:

        return min(B // A, C)


if __name__ == '__main__':

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

    
    solution = Solution()
    print(solution.solve(A, B, C))

Solution (Python):
A,B,C = map(int,input().split())
print(min(C,B//A))

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

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

Solution (Python):


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

Solution (Python):
a,b,c = map(int,input().split())
ans = 0
if b // a >= c:
    ans = c
else:
    ans = b // a

print(ans)

Solution (Python):
A, B, C = map(int, input().split())

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

Solution (Python):
a,b,c = map(int, input().split(' ' ))
print(min(b//a, c))

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

Solution (Python):
A, B, C = map(int, input().split())

print(min(C, B // A))

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

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

Solution (Python):
def main():
    a, b, c = map(int, input().split())

    ans = b // a

    print(ans if ans < c else c)

if __name__ == '__main__':
    main()

Solution (Python):
a,b,c=map(int, input().split())
t=b//a
if c<t:
  print(c)
else:
  print(t)

Solution (Python):
A, B, C = map(int, input().split())
 
if B > A * C:
  print(C)
else:
  print(B // A)

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

cnt = b // a 

if cnt > c:
    print(c)
else:
    print(cnt)

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

Solution (Python):
A, B, C = map(int, input().split())

print(min(C, B//A))

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

Solution (Python):
a, b, c = map(int, input().split())
if a*c < b:
	print (c)
else:
	print (b//a)

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

Solution (Python):
a,b,c = map(int,input().split())
if a*c <= b:
    print(c)
else:
    print(b//a)

Solution (Python):
a,b,c = map(int, input().split())
if a*c<=b: print(c)
else: print(b//a)

Solution (Python):
a, b, c = map(int, input().split())
x = b // a
if x >= c:
    print(c)
else:
    print(x)

Solution (Python):
A, B, C = map(int, input().split())

if B//A < C:
    print(B//A)
    
elif B//A >= C:
    print(C)

Solution (Python):
a, b, c = map(int, input().split())
if a*c <= b:
    print(c)
else:
    print(b // a)

Solution (Python):
A, B, C = map(int, input().split())
print(min(C, (B//A)))

Solution (Python):
A,B,C=map(int,input().split())
print(B//A if B//A<C else C)

Solution (Python):
a,b,c = [int(x) for x in input().split()]

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

Solution (Python):
A,B,C = [int(i) for i in input().split()]
if B // A >= C:
    print(C)
else:
    print(B//A)

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

Solution (Python):
import math
A, B, C =map(int, input().split())
if B >= A * C:
  print(C)
else:
  print(math.floor(B/A))

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

Solution (Python):
a,b,c=map(int,input().split())
if b>=a*c:
    print(c)
elif b>=a:
    print(b//a)
else:
    print('0')

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

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

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

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

Solution (Python):


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

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

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

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

Solution (Python):
A, B, C = map(int, input().split())
if A * C <= B:
  print(C)
else:
  print(B // A)

Solution (Python):
A,B,C = map(int,input().split())

print(min(B//A,C))

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

Solution (Python):




def main():
    A, B, C = map(int, input().split())
    print(min(B // A, C))


if __name__ == "__main__":
    main()

Solution (Python):
A, B, C = map(int, input().split())

a = int(B/A)

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

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

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

Solution (Python):
A, B, C = list(map(int, input().split()))
if B // A >= C:
    print(C)
else:
    print(B//A)

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    A, B, C = map(int, input().split())
    print(min(C, B // A))

if __name__ == '__main__':
    main()

Solution (Python):
import math
def main(a,b,c):
    temp = math.floor(b/a)
    return temp if temp <= c else c

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

Solution (Python):
def main(A,B,C):
    if (B // A) > C:
        return C
    else:
        return (B // A)
        
A,B,C = map(int,input().split())
print(main(A,B,C))

Solution (Python):
A,B,C = map(int,input().split())

print(min(B//A,C))

Solution (Python):

a,b,c=map(int,input().split())
ans=int(b/a)
if ans>c:
    ans=c
print(ans)

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

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

Solution (Python):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())

sys.setrecursionlimit(10 ** 9)


def main():
    A, B, C = MAP()

    tmp = B
    for i in range(C):
        tmp -= A
        if tmp < 0:
            print(i)
            break
    else:
        print(C)


if __name__ == '__main__':
    main()

Solution (Python):
A,B,C=map(int,input().split())
ans=int(0)
pay=int(0)
for i in range(1,C+1):
  pay+=A
  if pay<=B:
    ans+=1
  else:
    break
print(ans)

Solution (Python):
A,B,C=map(int,input().split())
ans=B//A
if ans>C:
  print(C)
else:
  print(ans)

Solution (Python):
s = list(map(int, input().split()))

if s[1]//s[0] > s[2]:
    print(s[2])
else:
    print(s[1]//s[0])

Solution (Python):
a,b,c = map(int,input().split())
if b//a >= c:
  print(c)
else:
  print(b//a)

Solution (Python):
a,b,c = map(int,input().split())
if b//a >= c:
  print(c)
else:
  print(b//a)

Solution (Python):
a,b,c = map(int,input().split())
if b//a >= c:
  print(c)
else:
  print(b//a)

Solution (Python):
a,b,c = map(int,input().split())
if b//a >= c:
  print(c)
else:
  print(b//a)

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

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

Solution (Python):
A,B,C=map(int,input().split())

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

Solution (Python):
a,b,c=map(int,input().split())
if b//a>c:
    print (c)
else:
    print (b//a)

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

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

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
if int(b / a) > c:
	print(c)
else:
	print(int(b / a))

Solution (Python):
import math
A, B, C =map(int, input().split())
if B >= A * C:
  print(C)
else:
  print(math.floor(B/A))

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

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

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

Solution (Python):
import sys
 
stdin = sys.stdin

mod = 1000000007
inf = 1 << 60
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

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

Solution (Python):
import sys
import math
import itertools

a,b,c=list(map(int,input().split()))
count=math.floor(b/a)
if (count>=c):
	print(c)
	sys.exit()
print(count)

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

Solution (Python):
a, b, c = map(int, input().split())
print(c) if(int(b / a) > c) else print(int(b / a))

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

Solution (Python):
A, B, C = map(int, input().split())

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

Solution (Python):
a, b, c = (int(i) for i in input().split())
print(min(b//a, c))

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

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

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

Solution (Python):
a,b,c=map(int,input().split())
print((b//a if b//a<=c else c))

Solution (Python):
A,B,C=map(int,input().split())
if A*C<=B:
    print(C)
else:
    print(B//A)

Solution (Python):
A, B, C = map(int, raw_input().split())

sum = B/A
if sum > C:
    print C
else:
    print sum

Solution (Python):
A,B,C=map(int,raw_input().split())
if B/A>C:
    print C
else:
    print B/A

Solution (Python):
A, B, C = map(int, raw_input().split())

sum = B/A
if sum > C:
    print C
else:
    print sum

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

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

manzoku = c
saitei = b//a

print(min(manzoku, saitei))

Solution (Python):
A, B, C= map(int, input().split())
if A*C <= B:
  print(C)
elif A <= B:
  print(B//A)
else:
  print(0)

Solution (Python):
A, B, C = map(int, input().split())

ans = B // A

if ans > C:
    print(C)
else:
    print(ans)

Solution (Python):
def main():
    A, B, C = map(int, input().split(" "))
    print(min(B // A, C))


if __name__ == '__main__':
    main()

Solution (Python):
"""
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))

Solution (Python):
A, B, C = map(int, input().split())

if A * C <= B:
    print(C)

else:
    print(B // A)

Solution (Python):
a,b,c = map(int,input().split())
print(int(b/a) if int(b/a)<c else c)

Solution (Python):
a,b,c=map(int,input().split());print(min(c,b//a))

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

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

Solution (Python):
a,b,c = map(int,input().split())
can = b//a
 
if(c<can):
    print(c)
else:
    print(can)

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

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    a, b, c = map(int, input().split())
    print(min(b//a, c))
    
if __name__ == '__main__':
    main()

Solution (Python):
import sys

a, b, c = map(int, sys.stdin.readline().split())

def main():
    return min(b // a, c)

if __name__ == '__main__':
    ans = main()
    print(ans)

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

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

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

Solution (Python):
A,B,C = map(int,input().split())
if A*C <= B:
  r = C
else:
  r = B // A
 
print(r)

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

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

m = b//a

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

Solution (Python):
a, b, c = map(int, input().split())
if(b//a > c):
    print(c)
else:
    print(b//a)

Solution (Python):
A,B,C = map(int, input().split())

num = B//A
print(min(num,C))

Solution (Python):
a,b,c=map(int,input().split())
if c<=b/a:
    print(c)
else:
    print(b//a)

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

Solution (Python):
a, b, c = map(int, input().split())
print(b//a if b//a<=c else c)

Solution (Python):
a, b, c = map(int, input().split())
x = b//a
if x > c:
    x = c
print(x)

Solution (Python):
A, B, C = map(int, input().split())
print(int(min(C,B/A)))

Solution (Python):
A, B, C = list(map(int,input().split()))

maximum = A * C

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

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

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

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

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

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

Solution (Python):
a,b,c = map(int,input().split())
if a*c <= b:
    print(c)
else:
    print(b//a)

Solution (Python):
A, B, C = map(int, input().split())
ans = 0
for i in range(C):
    if A*(i+1) <= B:
        ans = ans+1
print(ans)

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

Solution (Python):
a, b, c = map(lambda x: int(x), input().split())
if a * c <= b:
  print(c)
else:
  print(int(b/a))

Solution (Python):
import math

a, b, c = list(map(int, input().split()))
cnt = math.floor(b / a)
if c <= cnt:
    print(c)
else:
    print(cnt)

Solution (Python):
A, B, C = map(int, input().split())
print(B//A if B//A < C else C)

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

Solution (Python):
A, B, C = map(int, input().split())

print(min(int(B/A), C))

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input():
    return sys.stdin.readline().rstrip()

def main():
    A,B,C=map(int,input().split())
    print(min(C,B//A))

if __name__ == '__main__':
    main()

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

Solution (Python):
a,b,c=map(int,input().split())
print(c if a*c <= b else b//a)

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

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

Solution (Python):
a,b,c=map(int,input().split())
d=b//a
print(min(c,d))

Solution (Python):
A,B,C = list(map(int,input().split(" ")))
if B / A >= C:
    print(C)
else:
    print(B // A)

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

Solution (Python):
a,b,c=map(int,input().split())
if b//a <= c:
    print(b//a)
else:
    print(c)

Solution (Python):
a,b,c=map(int,input().split())
if b//a>=c:
  print(c)
else:
  print(b//a)

Solution (Python):
A, B, C = map(int, input().split())
print(min(C, B//A))

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c=INTM()
    print(min(b//a,c))
if __name__ == '__main__':
    do()

Solution (Python):
a,b,c=map(int,input().split())
print(b//a if b//a <= c else c)

Solution (Python):
A, B, C = map(int, input().split())
print(min(B // A, C))

Solution (Python):
a,b,c=map(int,input().split());print(min(b//a,c))

Solution (Python):
A, B, C = map(int, input().split())
if B < C:
  print(0)
elif A * C < B:
  print(C)
else:
  print(B//A)

Solution (Python):
a, b, c = list(map(int, input().split()))
if b // a >= c:
    print(c)
else:
    print(b // a)

Solution (Python):
A,B,C=map(int, input().split())
print(B//A if B<A*C else C)

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

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

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

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

Solution (Python):
li=list(map(int,input().split()))

print(min(li[1]//li[0],li[2]))

Solution (Python):
A, B, C = map(int, input().split())
print(min(B // A, C))

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

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

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

Solution (Python):
A,B,C=map(int,input().split())
s=B//A
print(s if s<C else C)

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

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

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

Solution (Python):
a,b,c=map(int,input().split())
if b//a > c:
    print(c)
else:
    print(b//a)

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

Solution (Python):
a, b, c = list(map(int, input().split(' ')))
print(min(b//a, c))

Solution (Python):
A, B, C = map(int, input().split()) 
D = B // A
if D > C: 
    print(C)
else:
    print(D)

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

Solution (Python):
A,B,C=map(int,input().split())
print(min(B//A,C))

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

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

Solution (Python):
A,B,C = map(int, input().split())
s = B//A
if C<=s:
	print(C)
else:
	print(s)

Solution (Python):
A,B,C=map(int,input().split())
print(min(C,B//A))

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



A, B, C = list(map(int, sys.stdin.buffer.readline().split()))

ans = B//A
ans = int(min(ans, C))
print(ans)

Solution (Python):
a,b,c = map(int,input().split())
if a*c<=b:
    print(c)
else:
    print(b//a)

Solution (Python):
A, B, C = map(int, input().split())
if A*C < B:
    print(C)
else:
    print(B//A)

Solution (Python):
N = list(map(int,input().split()))
if(N[1]//N[0]<=N[2]):
	print(N[1]//N[0])
else:
	print(N[2])

Solution (Python):
a,b,c = map(int,input().split())
can = b//a

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

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

if b//a > c:
    ans = c
else:
    ans = b//a

print(ans)

Solution (Python):
a,b,c=map(int,input().split())
d=b//a
if(d>=c):
  print(c)
else:
  print(d)

Solution (Python):
a, b, c = map(int, input().split())
times = 0
while times < c and b >= a:
    b -= a
    times += 1
print(times)

Solution (Python):
def solve():
    A, B, C = map(int, input().split())

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


if __name__ == '__main__':
    solve()

Solution (Python):
A, B, C = map(int, input().split())

ans = B // A
print(min(ans, C))

Solution (Python):
a, b, c = map(int, input().split())
print(b // a if b//a <= c else c)

Solution (Python):
a,b,c = map(int,input().split())
if b//a<c:
    print(b//a)
else:
    print(c)

Solution (Python):
a,b,c=map(int,input().split())
e=int(b/a)
if(e>=c):
    print(c)
else:
    print(e)

Solution (Python):
A, B, C = map(int, input().split())
if B // A < C:
    print(B//A)
else:
    print(C)

Solution (Python):
import math

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

Solution (Python):
a,b,c=map(int,input().split())
if b<c*a:
  print(b//a)
else:
  print(c)

Solution (Python):
a,b,c=map(int,input().split())
if a>b:
  print(0)
elif a*c<b:
  print(c)
else:
  print(b//a)

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

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

Solution (Python):
A, B, C = map(int, input().split())

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

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

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

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

Solution (Python):

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

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

Solution (Python):
A, B, C = map( int, input().split() )
print( min( B // A, C ))

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

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

else:
    print(b//a)

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

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

Solution (Python):
A, B, C = list(map(int, input().split()))
if int(B / A) <= C :
	print(int(B / A))
else :
	print(C)

Solution (Python):
a,b,c = map(int,input().split())
num=b//a
if num>=c:
    print(c)
else:
    print(num)

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

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

Solution (Python):
a,b,c=map(int,input().split())
if b//a > c:
    print(c)
else:
    print(b//a)

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

if a*c <= b:
  print(c)
elif a*c > b:
  print(b//a)
else:
  print("0")

Solution (Python):
a,b,c = map(int, input().split())
count = b // a
ans = min(count, c)
print(ans)

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

Solution (Python):
a, b, c = [int(x) for x in input().split()]
times = b//a
if times > c:
    print(c)
else:
    print(times)

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

Solution (Python):
A,B,C = map(int, input().rstrip().split())

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

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

Solution (Python):
A,B,C=map(int,input().split())
print(min(C,B//A))

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

Solution (Python):
a, b, c = map(int, input().split())
m = b // a
if m >= c:
    print(c)
else:
    print(m)

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

Solution (Python):
a, b, c = map(int, input().split())
i = 0
while i < c and a <= b:
    b -= a
    i += 1
print(i)

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

Solution (Python):
a, b, c = [int(i) for i in input().split()]
print (min(int(b / a), c))

Solution (Python):
import os, sys, re, math

(A, B, C) = [int(n) for n in input().split()]

print (min(B // A, C))

Solution (Python):
A, B, C = [int(s) for s in input().split(' ')]
print(min(C, B // A))

Solution (Python):
a, b, c = list(map(int, input().split()))
print(min(b // a, c))

Solution (Python):
a, b, c = [int(x) for x in input().split()]
print(min(b//a, c))

Solution (Python):
a, b, c = map(int, input().split())
flag = True
count = 0
while flag:
  if c <= count or b - a < 0:
    break
  b -= a
  count += 1
print(count)

Solution (Python):
def p_a():
    a, b, c = map(int, input().split())
    print(min(b // a, c))
    
p_a()

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

Solution (Python):
a,b,c = map(int,input().split())
print(c) if c < b//a else print(b//a)

Solution (Python):
a, b, c = map(int, input().split())
if a*c <= b:
  print(c)
else:
  print(b//a)