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):

if __name__ == '__main__':
    x,y,z = map(int,input().split())
    print(min(y//x,z))

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

Solution (Python):

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

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

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

D = B//A

print(D if D <= C else 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())
d = b//a
if d >= c:
    print(c)
else:
    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())
if b//a < c:
  print(b//a)
else:
  print(c)

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 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())
d = b//a
print(min(d,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())

if a*c <= b:
    print(c)
else:
    print(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())
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 = map(int,input().split())
manzoku = a*c
genjitu = b // a

if manzoku > b:
    print(genjitu)
else:
    print(c)

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

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(C, B // A))

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

if ans >= C:
    ans = 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(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())
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):
str = input().split()
a = int(str[0])
b = int(str[1])
c = int(str[2])
 
if b // a > c:
	print(c)
else:
	print(b // a)

Solution (Python):
source = input().split()
A, B, C = int(source[0]), int(source[1]), int(source[2])
flag = True
index = 0
while B >= A and index <= C:
    B -= A
    index += 1
    if index == C:
        print(C)
        flag = False
        break
if flag:
    print(index)

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())

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

Solution (Python):
a,b,c = map(int,input().split())
print(int(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())
print(b//a if b//a<c else c)

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

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

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

Solution (Python):
import math
A, B, C = map(int, input().split())
print(min(math.floor(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())
result = 0
left_money=B
while left_money>=A and C>0:
  left_money-=A
  C-=1
  result +=1
else:
  print(result)

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

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):
a, b, c = map(int, input().split())
cnt = 0
while cnt < c and a <= b:
    b -= a
    cnt += 1
print(cnt)

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 = list(map(int, input().split()))
q = b // a
answer = c if q >= c else q
print(answer)

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

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

main()

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

Solution (Python):
A, B, C = map(int, input().split())
count = B // A
if count < C:
    print(count)
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())
if B >= A * C:
  print(C)
else:
  print(B//A)

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

answer=b//a

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

Solution (Python):

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

Solution (Python):
A,B,C = list(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 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 = list(map(int, input().split()))
m = B//A
if m >= C : 
    print(C)
else:
    print(m)

Solution (Python):
ABC = input().split()
A = int(ABC[0])
B = int(ABC[1])
C = int(ABC[2])
if 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 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())

ans=0
while True:
  if b<a or ans==c:
    break
  b-=a
  ans+=1
print(ans)

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(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())

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=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(C if B//A >= C else B//A)

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

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())
d=int(b/a)
if d>=c:
    print(c)
elif d<c:
    print(d)

Solution (Python):
cost, money, n = map(int, input().split())
cnt = money // cost
if cnt < n:
    print(cnt)
else:
    print(n)

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 (C if C <= B//A else 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 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())
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())
if 1 <= a <= 100 and 1 <= b <= 100 and 1 <= c <= 100:
    if c <= b // a:
        print(c)
    else:
        print(int(b // a))
else:
    print('hoge')

Solution (Python):
A,B,C= [int(i) for i in input().split()]
print(C if B//A >C 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())
print(min(b//a, c))

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

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

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 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())
print(c if b//a >= c else b//a)

Solution (Python):
a,b,c = map(int, input().split())
d = int(b / a)
if d > c:
    print(c)
else : 
    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(c,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())
print(int(min(b/a,c)))

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

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

Solution (Python):
A, B, C = map(int, input().split())
print('{0}'.format(B//A) if B//A < C else '{0}'.format(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().rstrip().split())
print( c if (int(a)*int(c) <=int(b) ) else int(int(b)/int(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())
n= B//A
print(min(n,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(c if c <= b//a 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())
if int(B/A) <C:
    print(int(B/A))
else:
    print(C)

Solution (Python):
list1 = [i for i in input().split()]

n1 = int(list1[0])
n2 = int(list1[1])
n3 = int(list1[2])

ans = int(n2//n1)

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

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

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 = list(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(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(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([B//A,C][B//A>C])

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

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

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

tmp=b//a

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

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())
D=B//A
if C<=D:
  print(C)
else:
  print(D)

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


if __name__ == "__main__":
    print(solve())

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=input().split()
a,b,c=int(a),int(b),int(c)

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

Solution (Python):
import math





inputa = input().split()


a = int(inputa[0])
b = int(inputa[1])
c = int(inputa[2])




ans = int(math.floor(float(b)/float(a)))

if ans > c:
    ans = c

print(ans)

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

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


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):
def test():
    a,b,c = map(int,input().split())

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


if __name__ == "__main__":
    test()

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 int(B/A)>C:
    print(C)
else :
    print(int(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())
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 a*c < b:
    print(c)
else:
    print(int(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())

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 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(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)
else:
  print(b // a)

Solution (Python):
ABC = list(map(int,input().split()))
count = 0
money = ABC[1]

for n in range(ABC[2]):
    if money >= ABC[0]:
        money = money - ABC[0]
        count = count + 1

print(count)

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())
 
Tmp = B//A
if Tmp > C:
  print(C)
else:
  print(Tmp)

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())
x=0
if b>=a*c:
  x=c
else:
  x=b//a
print(x)

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(int(B // A))

Solution (Python):
a,b,c = map(int, input().split())
 
if b//a >= c:
  print(c)
  
elif b//a < c:
  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())
print(min(B//A, C))

Solution (Python):

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

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

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())
print(min(c, 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 A*C < B:
    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 = (int(i) for i in input().split())  
if B//A <= C:
	print(B//A)
else:
	print(C)

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

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

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

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

Solution (Python):
"""


 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())


 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  


a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    A, B, C = map(int, sys.stdin.readline().split())
    cnt = 0
    while True:
        if B < A or cnt >= C:
            print(cnt)
            exit()
        B -= A
        cnt += 1

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())
if B//A <= C:
    print(int(B//A))
else:
    print(int(C))

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

Solution (Python):
N = input().split()
A = int(N[0])
B = int(N[1])
C = int(N[2])

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()))
if a*c <= b:
    print(c)
else:
    print(b//a)

Solution (Python):


A, B, C = map(int, input().rstrip().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() )

cnt = 0
  
while b >= a:
  b = b - a
  cnt += 1
  if cnt >= c:
    break
    
    
print  (cnt)

Solution (Python):



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







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

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

D = B // A

Ans = min(C, D)
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())
print(c) if b//a > c else print(b//a)

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

print(n if n<c else 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())
if B>=A*C:
	print(C)
else:
	print(B//A)

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

Solution (Python):
import math
A,B,C = map(int, input().split())
print(min(math.floor(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())

count = b // a

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

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

Solution (Python):

a, b, c = (int(_) for _ in input().split())
times = b // a
if times <= c:
    print(times)
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())
count = 0
while b >= a:
    b -= a
    count += 1
    if count == c:
        break
print(count)

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

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

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

Solution (Python):
import math

n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = n[2]

pn = math.floor(b / a)

print(int(min(pn,c)))

Solution (Python):
S = input()
 
S = list(map(int, S.split()))
 
A = S[0]
B = S[1]
C = S[2]
 
D = int(B/A)
        
if D > C:
  print(C)
else:
  print(D)

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())
print(min(c,math.floor(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(c if c < b//a else b//a)

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

Solution (Python):
x,y,z = map(int,input().split())
if y/x < z:
  print(int(y/x))
else:
  print(z)

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 = [int(i) for i in input().split()]

d = b//a

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

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

Solution (Python):
"""


 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())


 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  


a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    A,B,C = map(int, sys.stdin.readline().split())

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

Solution (Python):
str_in = input().split()
a = int(str_in[0])
b = int(str_in[1])
c = int(str_in[2])

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

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

res=min(c,b//a)

print(res)

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(b//a,c))

Solution (Python):
list = [int(i) for i in input().split(" ")]
a = list[0]
b = list[1]
c = list[2]

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

Solution (Python):
l = [int(i) for i in input().split()]

A = l[0]
B = l[1]
C = l[2]

D = B//A

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

Solution (Python):
from copy import *
from sys import *
import math
import queue
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)


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

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(m,n):
	x = max(m,n)
	y = min(m,n)
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	return y

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

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 math
a,b,c=map(int,input().split())
print(min(c,math.floor(b/a)))

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

Solution (Python):
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    A, B, C = i2nn()
    n = min(B // A, C)
    print(n)

main()

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 = list(map(int, input().split()))
ans = B // A
if ans > C:
    ans = C
print(ans)

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

count = b // a
if count < c:
    print(count)
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(c)
else:
    print(b//a)

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

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

Solution (Python):
price, money, satisfaction = map(int, input().split())

print(min(money // price, satisfaction))

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

Solution (Python):
a, b, c = map(int, input().split())
ans = b // a
if ans > c:
	print(c)
else:
	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())
ans = min(C, B // A)
print(ans)

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(b//a,c))

Solution (Python):
def resolve(input_: str):
    A, B, C = map(int, input_.split(' '))

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


if __name__ == "__main__":
    resolve(input())

Solution (Python):
A, B, C = list(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(B//A,C))

Solution (Python):



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


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

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

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

Solution (Python):
num = input().split()
if int(num[1])//int(num[0])>int(num[2]): print(int(num[2]))
else: print(int(num[1])//int(num[0]))

Solution (Python):
print(*[ x[2] if x[0]*x[2]<x[1]+1 else x[1]//x[0] for x in [[int(x) for x in input().split()]]])

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

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

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

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

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())

ans = 0
for i in range(c):
    if b < a:
        break
    ans += 1
    b -= a

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(C,B//A))

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

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

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

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())
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())
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=list(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()]
X = int(B/A)
if B / A >= C:
    print(C)
else:
    print(X)

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