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

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

Solution (Python):
import sys


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


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

Solution (Python):
class Solver:

    def __init__(self):
        pass

    def solve(self, a, b, c):
        n1 = b // a
        return min(n1, c)

if __name__ == '__main__':

    solver = Solver()

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

    n = solver.solve(a, b, c)
    print(n)

Solution (Python):



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

Solution (Python):
import sys
from operator import itemgetter
import collections


def r(a, b, c):
    cnt = b // a
    if c <= cnt:
        return c
    else:
        return cnt


def main():
    input = sys.stdin.readline
    a, b, c = list(map(int, input().split()))

    print(r(a, b, c))


if __name__ == '__main__':
    main()

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

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

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

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


cnt = 0
amari = 0

cnt = int(B / A)

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

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

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

def li(): return map(int, stdin.readline().split())

A, B, C = tuple(li())
times = B // A
print(min(times, C))

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

n = b//a

if n>=c:
    print(c)

if n<c:
    print(n)

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

Solution (Python):
x = input().split(' ')

y = int(x[1]) / int(x[0])

if int(x[2]) < y:
    print(x[2])
else:
    print(int(y))

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

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

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

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

Solution (Python):
l = input().split(" ")
a = int(l[0])
b= int(l[1])
c= int(l[2])
if(b//a<=c):
    print(b//a)
else:
    print(c)

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

result = b / a
result = int(min(result, c))
print(result)

Solution (Python):
a, b, c = (int(i) for i in 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):
import sys
input = sys.stdin.readline

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


main()

Solution (Python):
Aa,Bb,Cc=input().split()
A=int(Aa)
B=int(Bb)
C=int(Cc)
count=0
while A<=B and C>0:
    B=B-A
    C=C-1
    count=count+1
print(count)

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

x = b // a

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

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

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

Solution (Python):
if __name__ == '__main__':
    f = lambda: map(int, input().split())
    A, B, C = f()
    if B // A > C:
        print(C)
    else:
        print(B//A)

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


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

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


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

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

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

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

Solution (Python):


def _main():
    text = input()
    A, B, C = [int(i) for i in text.split(' ')]

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

Solution (Python):

import math

def main():
    line_input = input()
    line_split = line_input.split()
    A = int(line_split[0])
    B = int(line_split[1])
    C = int(line_split[2])
    max_num = math.floor(B / A)
    if max_num > C:
        print(C)
    else:
        print(max_num)
if __name__ == "__main__":
    main()

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

Solution (Python):
a, b, c = [int(_) for _ in input().split(' ')]
print(min(c, b // a))

Solution (Python):
from sys import stdin
a, b, c = [int(x) for x in stdin.readline().rstrip().split()]
if (b//a) > c:
    print(c)
else:
    print(b//a)

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())
cnt = 0

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

print(cnt)

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

Solution (Python):
A,B,C = map(int,input().split())
ans = 0
while B >= A:
    ans += 1
    B = B-A
print(min(ans,C))

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

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

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

if __name__ == '__main__':
	main()

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

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

ans = 0
for i in range(C):
    if A*(C-i)<=B:
        ans = C-i
        break

print(ans)

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

Solution (Python):
import sys






"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        
        
        
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x // y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)

    def gcd(self, x, y):
        if y == 0:
            return x
        else:
            return self.gcd(y, x % y)


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()
    id = Idea()

    """この下から書いてね"""
    a, b, c = ip.IL()
    d = b // a
    print(min(c, d))



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):
import sys
 
l = []
for line in sys.stdin:
  l.append([int(i) for i in line.split()])
 
a, b, c = l[0]
if b >= a * c:
  print(c)
else:
  print(b//a)

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

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

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

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

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

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

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

Solution (Python):
a, b, c = map(int, input().split())
ans=0
while ans<c:
  if b-a>=0:  
    ans+=1
    b-=a
  else:
    break
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 = [int(x) for x in input().split(" ")]

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


if cnt > c:
    ans = c
else:
    ans = cnt


print(ans)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin

abc = [int(i) for i in stdin.readline().rstrip().split(" ")]

print(min(abc[1]//abc[0],abc[2]))

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

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

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

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

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

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

MaxSound = int(B/A)

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

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

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

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

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

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

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

if num[0]*num[2] <= num[1]:
    print(num[2])
    exit()
else:
    print(int(num[1]/num[0]))

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



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

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

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

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

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

print(o)

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

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

for i in range(c, -1, -1):
    if(a*i <= b):
        print(i)
        exit()

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

Solution (Python):

"""
Created on Sun Mar  3 20:59:27 2019

@author: doppe
"""
A, B, C = map(int, input().split())

num = int (B / A)

if (num > C):
    num = C

print(num)

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

if L[0] * L[2] <= L[1]:
    print(L[2])
elif L[0] * L[2] > L[1]:
    print(L[1]//L[0])

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

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

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

Solution (Python):
A, B, C = map(int,input().split())
count = 0
while True:
  if B - A < 0 or count == C:
    break
  else:
    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(' '))
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 = [int(s) for s in input().split(' ')]
print(min(B//A, C))

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

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

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

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

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

Solution (Python):


"""
Created on 2019/3/3
Solved on 2019/3/3
@author: shinjisu
"""






def getInt(): return int(input())


def getIntList(): return [int(x) for x in input().split()]


def zeros(n): return [0]*n


def getIntLines(n): return [int(input()) for i in range(n)]


def getIntMat(n):
    mat = []
    for i in range(n):
        mat.append(getIntList())
    return mat


def zeros2(n, m): return [zeros(m)]*n


ALPHABET = [chr(i+ord('a')) for i in range(26)]
DIGIT = [chr(i+ord('0')) for i in range(10)]
N1097 = 10**9 + 7
INF = 10**12


def dmp(x, cmt=''):
    global debug
    if debug:
        if cmt != '':
            print(cmt, ':  ', end='')
        print(x)
    return x


def prob_A():
    A, B, C = getIntList()
    dmp((A, B, C))
    count = min(B // A, C)
    return count


debug = False  
ans = prob_A()
print(ans)




def prob_B():
    N = getInt()
    A = getIntList()
    dmp((N, A))
    return 123


def prob_C():
    N = getInt()
    A = getIntList()
    dmp((N, A))
    return 123


def prob_D():
    N = getInt()
    A = getIntList()
    dmp((N, A))
    return 123

Solution (Python):
cost, wallet , target = map(int, input().split())

t = wallet //cost

if t > target:
    print(target)

else:
    print(t)

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

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

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

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

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

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

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

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

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

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

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

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

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

print(min(cnt, c))

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

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


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

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





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

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

Solution (Python):
[like, money, max_like] = list(map(int, input().split(' ')))

num = money // like
if max_like <= num:
    print(max_like)
else:
    print(num)

Solution (Python):
import sys

def main(inp):
    a,b,c=map(int,next(inp).split())
    return min(int(b/a),c)
  
print(main(sys.stdin))

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

Solution (Python):
a, b, c = [int(elem) for elem in input().split()]
res = int(b/a)
if c <= res:
    print(c)
else:
    print(res)

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

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

if X > int(C):
    print(C)
else:
    print(X)

Solution (Python):


from sys import stdin

input = stdin.readline

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

Solution (Python):

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

Solution (Python):
import collections
import itertools
import numpy as np
import sys
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

A,B,C = IL()

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

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

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

Solution (Python):

"""
Created on Sun Mar  3 19:52:08 2019

@author: Yamazaki Kenichi
"""

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

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

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

x = b//a

if x <= c:
    print(x)
else:
    print(c)

Solution (Python):
a=list(map(int,input().split()))
A=a[0]
B=a[1]
C=a[2]
if B>=A*C:
  answer=C
else:
  answer=B//A
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())
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 = [int(i) for i in input().split()]

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

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

ans = b/a

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

Solution (Python):
A, B, C = [int(s) for s in input().split(" ")]
print(C if B >= A*C else B // A)

Solution (Python):

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

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

Solution (Python):

import copy
import numpy as np
import random
import copy


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

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

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

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

Solution (Python):


def main():
    sp = [int(e) for e in input().split(" ")]
    a = sp[0]
    b = sp[1]
    c = sp[2]

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

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

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

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

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

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

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

print(times)

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

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

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

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

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

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

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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

d = b // a

print(min(c, d))

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

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

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

Solution (Python):

a, b, c = map(int, input().split())
x = (int) (b / a)
print("{}".format(min(x,c)))

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

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

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

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

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

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

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

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

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

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

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

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

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

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