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):
def main():

    """ convenient functions
    
    
    
    
    
    """

    """convenient decorator
    
    
        
        
        
        
        
        
        
        
        
        
    """
    
    
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product 
    
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  
        b, e = 2, 0  
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict 
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
    from copy import deepcopy, copy 
    import operator
    from operator import itemgetter
    
    
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd 
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    
    
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) 
    def modinv(a, p = MOD):
        
        
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        
        
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    
        
        
    
        
        
        
        
        
    
        
        
        
        
    
        
        
    """

    
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    
    
    
    
    
    
    
    """

    if __name__ != '__main__':
        
        sys.stdin = open('sample.txt')

    
    

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

    """memo: how to use defaultdict of list
    
    Dic = defaultdict(list)
    
    Dic[x].append(y)
    
    for k, v in Dic.items():
    """

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

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

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

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

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

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

print(ans)

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


main()

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

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

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

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

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

num=B//A

print(min(num,C))

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

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

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

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

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

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

Solution (Python):


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

ans = B // A

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

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

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

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

Solution (Python):
def smaller(x, y):
	if x < y: return x
	return y

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

Solution (Python):
S = input()
S = S.split()
howMuch = int(S[0])
Ihave = int(S[1])
sutis = int(S[2])
 
if (Ihave // howMuch) < sutis:
    print(Ihave // howMuch)
else:
    print(sutis)

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

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

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

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

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

Solution (Python):
price, wallet, m = map(int, input().split())
if wallet // price >= m:
  print(m)
else:
  print(wallet // price)

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

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

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

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

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

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())
ans = 0
while B >= A:
  ans += 1
  B -= A
  if ans == C:
    break
print(ans)

Solution (Python):
n1, n2, n3 = [int(i) for i in input().split()]

r1 = n2 // n1

if r1 >= n3:
    r1 = n3

print(r1)

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

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

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

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

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

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

a = x[0]
b = x[1]
c = x[2]

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

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

n=B//A

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

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

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

answer=B//A

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

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

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

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

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

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

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

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

if(enable_num < C):
    print(enable_num)
else:
    print(C)

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

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

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

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

Solution (Python):





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

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

Solution (Python):
a,b,c = map(int, input().split())
if b/a > c:
    cnt = c
else:
    cnt = int(b/a)
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):
def abc():
    price, wallet, want = map(int, input().rstrip().split())
    quantity = int(wallet / price)
    print(min(quantity, want))


abc()

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

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

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

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

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):
import sys
cost, money, satisfy = [int(x) for x in sys.stdin.readline().rstrip().split()]
print(min(satisfy, money // cost))

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

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

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

Solution (Python):
num = [int(i) for i in input().split()]
count = 0

for i in range(num[2]):
    if num[1] // num[0] != 0:
        count += 1
        num[1] -= num[0]
print(count)

Solution (Python):


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

possible = int(B / A)

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

Solution (Python):
A,B,C = (int(i) for i in 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(C if A * C < B else B // A )

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

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

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

max_num = B // A

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

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

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

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

print(ans)

Solution (Python):



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

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

Solution (Python):
import math
inp = input().split(" ")
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])

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

Solution (Python):



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

Solution (Python):

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

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

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

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

else:
    print(B//A)

Solution (Python):
import math

a = [int(i) for i in input().split(" ")]
if a[2] * a[0] <= a[1]:
  print(a[2])
else:
  b = math.floor(a[1] / a[0])
  print(b)

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

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

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

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

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

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

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

Solution (Python):
a, b, c = [ int(v) for v in 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())

n = b//a

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

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

s=b//a

if s>=c:
    print(c)

else:
    print(s)

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

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

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

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

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

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

Solution (Python):
nums = input().split()

A = int(nums[0]) 
B = int(nums[1]) 
C = int(nums[2]) 

cnt = 0
while True:
    
    
    if B < A:
        break

    
    if cnt >= C:
        break

    
    if B > 0:
        B = B - A 
        cnt+=1
    else:
        break

print(cnt)

Solution (Python):
import math
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().strip().split())

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

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

mon_lim = int(b/a)
if mon_lim < c:
    print(mon_lim)
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 sys
import itertools
from collections import deque
from operator import itemgetter

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

Solution (Python):


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

if math.floor(B/A)>C:
    print(C)
else:
    print(math.floor(B/A))

Solution (Python):
data = list(map(int,input().split()))
a = data[0]
b = data[1]
c = data[2]
del data
print(int((b-b%a)/a-((b-b%a)/a > c)*((b-b%a)/a-c)))

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

cnt = 0
while (cnt < c) and (b - a >= 0):
        b -= a
        cnt += 1

print(cnt)

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

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

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

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

cnt = 0
money = b
while money >= a:
    if cnt == c:
        break
    
    money -= a
    cnt += 1

print(cnt)

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

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

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

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

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

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

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

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

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

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

Solution (Python):

lst_1 = input().split()

A = int(lst_1[0])
B = int(lst_1[1])
C = int(lst_1[2])

ans = 0

while 1:

    if (A > B) or (C == 0):
        break
    B -= A
    ans += 1
    C -= 1

print(ans)

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

A = int(A)
B = int(B)
C = int(C)

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

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)



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


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


if __name__ == '__main__':
    main()

Solution (Python):
A, B, C = [int(e) for e in input().split(" ")]





p, _ = divmod(B, A)
if p > C:
    print(C)
else:
    print(p)

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

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

if b/a > c :
  print(c)

else:
  print(math.floor(b/a))

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

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

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

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

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

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

Solution (Python):
import sys
rr = lambda: sys.stdin.readline().strip()
ri = lambda: int(rr())
rs = lambda: [int(_) for _ in rr().split()]

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

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 = [int(abc) for abc in input().split()]
n = B // A
if n > C:
  print(C)
else:
  print(n)

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

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

ans = min(C, B // A)

print(ans)

Solution (Python):

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

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

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

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

X = B//A
if X > C:
    ans = C
else:
    ans = X

print(ans)

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

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

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

K = B // A

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

Solution (Python):
from sys import stdin
aa,bb,cc = stdin.readline().split()
a,b,c = int(aa), int(bb), int(cc)

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

Solution (Python):
import sys


def input():
    return sys.stdin.readline()[:-1]







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

import math
print(min(math.floor(B/A), C))

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

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