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

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

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

kei = A*C

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

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

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

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

Solution (Python):


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


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

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

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

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

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

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

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

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

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

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

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

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

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

num = b // a

print(min(num, 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()))
myans1=int(b/a)
if(myans1>c):
	print(c)
else:
	print(myans1)

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

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

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

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

Solution (Python):

def input2():
	return map(int,input().split())

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

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

n = min(c, b // a)

print(n)

Solution (Python):
def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    a, b, c = Input()
    print(min(b//a, c))


main()

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

if '__main__' == __name__:
    resolve()

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

can_listen = b // a

if can_listen < c:
    print(can_listen)
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())

count = b // a

if count > c:
    count = c

print(count)

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

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

num = int(B / A)

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

Solution (Python):
A,B,K = map(int,input().split())
print((B//A,K)[B//A >= K])

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

Solution (Python):
def atc_120a(input_value: str) -> int:
    A, B, C = map(int, input_value.split(" "))
    return min(C, B // A)

input_value = input()
print(atc_120a(input_value))

Solution (Python):

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


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

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:
    answer = C
else:
    answer = B // A

print(answer)

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

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

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

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

Solution (Python):

A, B, C = map(int, input().split())
if (1<=A&A<=100)&(1<=B&B<=100)&(1<=C&C<=100):
    C_price=A*C
    if B<C_price:
        B_count=int(B/A)
    elif B>=C_price:
        B_count=C
    print(B_count)

Solution (Python):
a, b, c = (int(n) for n in 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(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())
count=0
while B>0:
   if A>B:
      break
   B=B-A
   count+=1
   if count>=C:
      break
print(count)

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)
elif A * C >= B:
    print(B // A)

Solution (Python):
price, poket_money, max_music = map(int, input().split())

music_times = -1
for i in range(0, poket_money + 1, price):
    music_times += 1
    if max_music == music_times:
        break

print(music_times)

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

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






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

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

Solution (Python):
'''
問題：
    高橋くんは、自動販売機でジュースを買ったときの音が好きです。
    その音は 1回 A円で聞くことができます。

    高橋くんは B円持っていますが、
    お気に入りの音を C回聞くと満足するため、
    B円で最大 C回まで聞けるだけ聞きます。
    高橋くんはお気に入りの音を何回聞くことになるでしょうか。
'''

'''
制約：
    入力は全て整数である。
    1 ≤ A, B, C ≤ 100
'''


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


result = 0
if a * c < b:
    result = c
else:
    result = int(b / a)

print(result)

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

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):
per_price, takahashi_all_money, count_satisfied_sound = map(int, input().split())

need_money_of_satisfied = count_satisfied_sound * per_price

if takahashi_all_money >= need_money_of_satisfied:
    print(count_satisfied_sound)
elif takahashi_all_money < need_money_of_satisfied:
    print(takahashi_all_money // per_price)

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

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

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

Solution (Python):

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

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

a = B // A

if C > a:
    print(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:
    print(0)
elif 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):
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(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())
print(min(B // A, C))

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    A, B, C = LI()

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

if __name__ == '__main__':
    resolve()

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

    d = b // a

    print(min(c, d))


if __name__ == "__main__":
    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([b//a,c][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(c if b-a*c>=0 else b//a)

Solution (Python):
value, money, max_count = map(int, input().split())

ans = min(money // value, max_count)
print(ans)

Solution (Python):
value, money, max_count = map(int, input().split())

ans = min(money // value, max_count)
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(c,b//a))

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

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

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

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

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

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

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    A, B, C = map(int, readline().split())

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

    return


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

a=list(map(int,input().split()))
print(min(math.floor(a[1]/a[0]),a[2]))

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(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):
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())
count = min(c, b//a)
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(min(b//a, c))

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re












import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
a,b,c = readInts()
print(min(c, b//a))

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

ans=0
while b>=a and ans<c:

    b=b-a
    ans+=1

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 >= C:
    print(C)

elif 1 <= B / A < C:
    print(B //A)

else:
    print(0)

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

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

if B>=A*C:
    print(C)
elif B<A*C:
    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):
def main():
    a, b, c = map(int, input().split())
    cnt = 0
    current = a
    while current <= b:
        if cnt == c:
            break
        cnt += 1
        current += a
    print(cnt)


if __name__ == "__main__":
    main()

Solution (Python):
a, b, c = map(int, input().split())
ans = 0
for i in range(1, c+1):
  if a*i <= b:
    ans += 1
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())
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(b//a, c))

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

Solution (Python):
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    a, b, c = nm()
    print(min(c, b // a))


if __name__ == '__main__':
    main()

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

while a <= b:
    b -= a
    cnt += 1

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

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

max_sound = B // A

if C > max_sound:
    print(max_sound)
else:
    print(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 = list(map(int, input().split()))
n = b % a
if a * c <= b:
  print(c)
else:
  print(int((b - n) / a))

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

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

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

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

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

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

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

Solution (Python):
A, B, C = input().strip().split()
A, B, C = [int(A), int(B), int(C)]

if B/A < 1:
    print(0)
elif B/A > C:
    print(C)
else:
    print(int(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(C,B//A))

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

Solution (Python):















































def calculation(lines):
    
    
    A, B, C = list(map(int, lines[0].split()))
    
    
    
    

    result = (B // A)
    if result > C:
        result = C

    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['2 11 4']
        lines_export = [4]
    if pattern == 2:
        lines_input = ['3 9 5']
        lines_export = [3]
    if pattern == 3:
        lines_input = ['100 1 10']
        lines_export = [0]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



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

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

Solution (Python):

import sys
input = sys.stdin.readline  
A,B,C = map(int, input().split())
hear =B //A
ans =min(hear,C)
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(b//a if b//a <= c else c)

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

print(min(count, C))

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

if b - (a * c) >= 0:
    print(c)

elif b - (a * c) < 0:
    print(b // a)

elif a > b :
    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());
print(min(C, B // A))

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

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

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

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

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

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

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

Solution (Python):
import sys
A,B,C = map(int,input().split())
if not ( 1 <= A <= 100 and 1 <= B <= 100 and 1 <= C <= 100 ): sys.exit()

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

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

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

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 ( A*C <= B )  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())

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

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

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

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

sound_count = b//a

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

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

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

Solution (Python):
n = list(map(int, input().split()))
def ans(a, b, c):
    if a > b:
        return 0
    else:
        if int(b/a) < c:
            return int(b/a)
        else:
            return c
print(ans(n[0], n[1], n[2]))

Solution (Python):
n = list(map(int, input().split()))
def ans(a, b, c):
    if a > b:
        return 0
    else:
        if int(b/a) < c:
            return int(b/a)
        else:
            return c
print(ans(n[0], n[1], n[2]))

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())
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(x) for x in 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):
import sys
rm = lambda: map(int, sys.stdin.buffer.readline().split())
a, b, c = rm()
print(min(c, b//a))

Solution (Python):
import sys
rm = lambda: map(int, sys.stdin.buffer.readline().split())
a, b, c = rm()
print(min(c, b//a))

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b, c = rm()
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())
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())
count = int(b / a)

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

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

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

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

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

b = B // A

if b >= C:
    print(C)

else:
    print(b)

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

count = 0
A_org = A
A = 0
for i in range(1000):
    if count < C:
        if A + A_org <= B:
            A += A_org
            count += 1
        else:
            break
    else:
        break
    
print(count)

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

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

Solution (Python):
def resolve():
    inp = input()
    li = list(map(lambda x: int(x), inp.split(" ")))
    num = li[1]//li[0]
    print(min(num, li[2]))
    
resolve()

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

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