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

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

Solution (Python):
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from math import ceil, floor, sqrt, gcd
from copy import deepcopy

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


import math



from collections import deque
from collections import Counter




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

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

main()

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

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

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())
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):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():

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


if __name__ == '__main__':
    main()

Solution (Python):


input_data = list(map(int,input().split()))

d1 = input_data[0]
d2 = input_data[1]
d3 = input_data[2]

d4 = int(d2 / d1)
if d4 > d3:
    total = d3
else:
    total = d4

print(total)

Solution (Python):


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

if __name__=="__main__":
    main()

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

def main():
  A,B,C = [int(i) for i in input().strip().split()]
  return min(B//A,C)
  
if __name__ == "__main__":
  print(main())

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

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

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

if __name__ == '__main__':
    solve()

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

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

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

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

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

Solution (Python):

a, b, c = map(int, open(0).read().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())

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

def solve():
    input = sys.stdin.readline
    A, B, C = map(int, input().split())
    count = 0
    while count < C:
        if B >= A:
            count += 1
            B -= A
        else: break
    print(count)

    return 0

if __name__ == "__main__":
    solve()

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

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

    if b >= a * c:
        print(c)
    else:
        print(int(b/a))
    
if __name__ == '__main__':
    main()

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

tmp = b // a

print(min(tmp, c))

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

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

tmp =int(b/a)

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

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

Solution (Python):
import math
def ip():return int(input())
def inp():return map(int,input().split())
def inpstr():return map(str,input().split())
def linp():return list(map(int,input().split()))
def linpstr():return list(map(str,input().split()))

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

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

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

Solution (Python):

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

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)

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

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

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

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

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

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

Solution (Python):


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

ans = (b//a)

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

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

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,s,d=map(int,input().split())
print(min(s//a,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())
print(min(int(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():
  num = list(map(int,input().split()))
  if num[0]*num[2]<=num[1]:
    print( num[2] )
  else:
    print(int(num[1]/num[0]))

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

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 a * c <= b:
  ans = c
else:
  ans = b // a

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())
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 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):
import re
n = input()
m = re.search('(\d+)\s(\d+)\s(\d+)', n)
a = int(m.group(1))
b = int(m.group(2))
c = int(m.group(3))
i = b // a
if c <= i:
    print(c)
else:
    print(i)

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

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

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

Solution (Python):

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

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

Solution (Python):
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

a,b,c=L()
ans=0
if a*c<=b:
    ans=c
else:
    ans=b//a
print(ans)

Solution (Python):

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


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

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

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

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

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

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

cnt=0

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(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):
import bisect, collections, copy, heapq, itertools, math, numpy, string
import sys
from bisect import bisect_left, bisect_right, insort
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def MS(): return map(str, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())



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

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

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






















def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, c = mi()
    print(min(c, b // a))


if __name__ == "__main__":
    main()

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

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


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


if __name__ == "__main__":
    main()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = float('inf')


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






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


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





A,B,C = inputIL()

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

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

Solution (Python):
import sys
import math
import bisect

def main():
    a, b, c = map(int, input().split())
    ans = 0
    while ans < c and b >= a:
        b -= a
        ans += 1
    print(ans)

if __name__ == "__main__":
    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):

import sys


def solve(A: int, B: int, C: int):
    print(min(B // A, C))


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    solve(A, B, C)


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

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

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

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

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

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

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

if __name__ == '__main__':

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

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

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 statistics import median


from fractions import gcd
from itertools import combinations 
from collections import deque
from collections import defaultdict
import bisect










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

def readInts():
  return list(map(int,input().split()))

def main():
    a,b,c = readInts()
    print(c if a*c <= b else b//a)
if __name__ == '__main__':
  main()

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

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

Solution (Python):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right


from functools import reduce
from pprint import pprint

INF = float("inf")

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

a,b,c = myinput()

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

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

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

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

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

if __name__ == "__main__":
  resolve()

Solution (Python):
import sys

def solve():
    input = sys.stdin.readline
    A, B, C = map(int, input().split())
    print(min(C, B//A))

    return 0

if __name__ == "__main__":
    solve()

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

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

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

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

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

a, b, c = [int(x) for x in 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 a*c <= b else b//a)

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

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

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

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

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

nec = A*C
if(B>=nec):
    print(C)
else:
    i = C
    while all:
        if(A*i <= B):
            break
        else:
           i -= 1

    print(i)

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(c)
else:
    print(d)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

a,b,c = inpl()
print(min(c,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())
    print(min(B // A, C))


if __name__ == '__main__':
    main()

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

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

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

nec = A*C
if(B>=nec):
    print(C)
else:
    i = C
    while all:
        if(A*i <= B):
            break
        else:
           i -= 1

    print(i)

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
from operator import itemgetter
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


def readints():
    return list(map(int, input().split()))


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
a, b, c = map(int, input().split())
if a > b:
    print(0)
    exit()
if a*c <= b:
    print(c)
else:
    print(math.floor(b/a))

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

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

total = a * c

if b >= total:
    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())

kai = b//a

if kai>c:
  print(c)
elif kai<=c:
  print(kai)

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

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

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

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


if __name__ == '__main__':
    main()