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(c)
else:
    count = 0
    while a <= b:
        b -= a
        count += 1
    print(count)

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

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

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

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

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

d = b // a

if d <= c:
  print(d)
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())
x=b//a
print(min(x,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())
z=min(b//a,c)
print(z)

Solution (Python):
xyz=input().split()
x=int(xyz[0])
y=int(xyz[1])
z=int(xyz[2])
k=y//x
if k>z:
    print(z)
else:
    print(k)

Solution (Python):
li=[int(i) for i in input().split()]
a=li[0]
b=li[1]
c=li[2]
d=b//a
if(d>c):
    print(c)
else:
    print(d)

Solution (Python):

from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string
import math
import time
from fractions import gcd



def I(): return int(input())


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


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['Yes', 'No']
MOD = 10**9+7
inf = float('inf')
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)


show_flg = False



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

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


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
print(min(C, B // A))

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

ans=b//a

print(min(ans,c))

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

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

for idx, ret in enumerate([B - A * cnt for cnt in range(C + 1)]):
    if ret < 0:
        print(idx - 1)
        break
else:
    print(idx)

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

Solution (Python):
import math

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

    max_listen = math.floor(b/a)

    print(min(c, max_listen))

    pass


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
input = sys.stdin.readline
def print_ans(A, B, C):
    """Test Case
    >>> print_ans(2, 11, 4)
    4
    >>> print_ans(3, 9, 5)
    3
    >>> print_ans(100, 1, 10)
    0
    """
    print(min(C, B // A))


if __name__ == '__main__':
    A, B, C = map(int, input().rstrip().split())
    print_ans(A, B, C)

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

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

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

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

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

Solution (Python):

import math
import datetime




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

if A*C <= B :
  print (C)
else :
  print (math.floor(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 = (int(x) for x in input().split())
if (a*c < b):
    print(c)
else:
    print (int(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 = list(map(int, input().split()))
can_buy = B // A
if can_buy > C:
    print(C)
else:
    print(can_buy)

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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


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(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((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(' '))
print(min(int(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())


B_A = (B//A)

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

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

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

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

b = B
ans = 0
while ans < C:
    b -= A
    if b < 0:
        break
    ans += 1
print(ans)

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

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

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

count = int(data[1]/data[0])

if count > data[2]:
    print(data[2])
else:
    print(count)

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

Solution (Python):

import sys










def main():
    a, b, c = [int(x) for x in sys.stdin.readline().split()]
    if b >= a * c:
        ans = c
    else:
        ans = b // a
    print(ans)


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

ans = min(C, 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())

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

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

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

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


if __name__ == '__main__':
    main()

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

import math

if B  >= A * C:
    print(C)
else:
    print(math.floor(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())

ret = min(c, b//a)

print(ret)

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):

a, b, c = [int(s) for s in input().split()]
print(c if a * c <= b else b // a)

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

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

k = b//a

if c <= k:
	k = c
	
print(k)

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

bt = b // a

print(min(c, bt))

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

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

Solution (Python):
from sys import stdin

a,b,c = [int(x) for x in stdin.readline().rstrip().split()]

kai = b//a

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

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

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

print(ans)

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

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

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

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

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

number = B // A

if number > C:
    number = C

print(number)

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

kai = b//a

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

Solution (Python):
a,b,c=map(int,input().split());print([b//a,c][a*c<b])

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

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

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

N = B // A

if C <= N:
    print(int(C))
else:
    print(int(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 = [int(x) for x in 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())

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:
    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(int(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())
    count = 0
    while B - A >= 0 and count < C:
        B -= A
        count += 1
    print(count)


if __name__ == "__main__":
    main()

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

Solution (Python):
import math

def main():
    A,B,C =  map(int, input().split())
    max_kai = math.floor(B/A)
    if max_kai > C:
        print(C)
    else:
        print(max_kai)


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

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

Solution (Python):

def main():
    A, B, C = map(int, input().split())
    flg = A <= B
    print(min(B // A, C) if flg else 0)


if __name__ == "__main__":
    main()

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

Solution (Python):
a,b,c = list(map(int,input().strip().split()))
can = int(b/a)
ans = [can,c]
print(min(ans))

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

Solution (Python):
A,B,C = map(int,input().split())
t=B//A 
if t>C:
    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())
d=0
while (d+1)<=c and (b-a)>=0:
  b=b-a
  d=d+1
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_list=list(map(int,input().split()))
A=a_list[0]
B=a_list[1]
C=a_list[2]
if B//A <= C:
    answer=B//A
else:
    answer=C
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())
if a*c <= b:
  print(c)
else:
  print(int(b/a))

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c = list(map(int, input().rstrip('\n').split()))
    print(min(b // a, c))


if __name__ == '__main__':
    slove()

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

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

Solution (Python):
from sys import stdin

A,B,C = map(int,stdin.readline().strip().split())

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

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

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

Solution (Python):
A,B,C = map(int,input().split())
money = B
utility = 0
if A > B:
    print(utility)
else:
    while (utility < C) and (money-A >= 0):
        utility += 1
        money -= A
    print(utility)

Solution (Python):
def func():
    str = input()
    x, y, z = str.split()
    x = int(x)
    y = int(y)
    z = int(z)
    print(int(min((y/x), z)))


if __name__ == "__main__":
    func()

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

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

Solution (Python):
INPUT = list(map(int,input().split()))
A=INPUT[0]
B=INPUT[1]
C=INPUT[2]
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 = map(int, input().split())
ans = b//a
if ans >= c:
    ans = c
print(ans)

Solution (Python):
a, b, c = (int(x) for x in 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(b//a)
else:
  print(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())
s=b//a
print(c if c<=s else s)

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

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

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

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

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

count = 0
while 1:
    if B < A:
        break
    if C > 0:
        B -= A
        count += 1
        C -= 1
    else:
        break

print(count)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c = list(map(int, input().rstrip('\n').split()))
    print(min(b // a, c))


if __name__ == '__main__':
    slove()

Solution (Python):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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

Solution (Python):


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

print min((b/a), c)

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

Solution (Python):
a,b,c=[int(s) for s in 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())
n=b
m=0
while m<c and n>=a:
    n+=(-1)*a
    m+=1
    
print(m)

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(" "))
ans = None

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

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

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

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

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

if B >= A*C:
  print(C)
else:
  for i in range(1,C+1):
    if B < A*i:
      break
  print(i-1)

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

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):
def main(A, B, C):
    return min(B//A,C)

args = input().split()

print(main(int(args[0]), int(args[1]), int(args[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(c,b//a))

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

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

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

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

if __name__ == "__main__":
    resolve()

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 = b // a

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

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

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

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

else:
    print(int(s[1]/s[0]))

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

ans = min(c, max(0, b // a))

print(ans)

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

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

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

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

if a > b:
    res = 0
else:
    if a*c <= b:
        res = c
    else:
        res = b // a

print(res)

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

Solution (Python):
A,B,C = [int(x) for x in 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 = min(B // A, C)
print(ans)

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

if b-c*a>=0:
    print(c)
if b-c*a < 0:
    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):
l= list(map(int,input().split()))
a=l[0]
b=l[1]
c=l[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=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):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
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(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 = [int(i) for i 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())
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(n)
else:
    print(c)

Solution (Python):
if __name__ == '__main__':
    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(C,B//A))

Solution (Python):

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

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

counter=0
while counter<C and B-A*counter>=A:
  counter+=1
  
print(counter)

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


if __name__ == "__main__":
    main()

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


if __name__ == "__main__":
    main()

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


if __name__ == "__main__":
    main()

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

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

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

q = B // A

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

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

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

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

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

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

Solution (Python):
def MAP(): return list(map(int,input().split()))

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

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

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

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

def main():
    A,B,C = map(int, input().split())
    n = 0
    while B >= A and n < C:
        B -= A
        n += 1
    print(n)

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

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

Solution (Python):
import math
x = input().split()
A = int(x[0])
B = int(x[1])
C = int(x[2])
if (math.floor(B/A) >= C):
  print(C)
else:
  print(math.floor(B/A))