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

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

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

Solution (Python):
A, B, C = map(int, input().split())
syo = B // A 
if syo > C:
    clc = syo - (syo - C)

else :
    clc = syo 

print(clc)

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

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

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

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

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

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

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

Solution (Python):
A,B,C=map(int,input().split())
k=0
X=0
while X<=B:
  k+=1
  X=k*A
if k-1<C:
  print(k-1)
if k-1>=C:
  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(B // A)
elif B // A > C:
    print(C)
else:
    print(B // A)

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

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

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

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

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

k=x//a

print(min(k,c))

Solution (Python):
cost, money, max = map(int, input().split())
print(max if (money // cost) > max else money // cost)

Solution (Python):

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

else:
	print(B // A);

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

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

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

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

Solution (Python):
cost, money, satisfy = map(int, input().split(' '))
if (money / cost) >= satisfy:
    print(satisfy)
else:
    print(money // cost)

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

Solution (Python):
import math


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

ans = min(C, math.floor(B / A))

print(ans)

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

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

if m_max < c:
  print(m_max)
else:
  print(c)

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

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

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

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

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

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

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

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

    if B >= A * C:
        answer = C
    else:
        answer = B // A

    print(answer)

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

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

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

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

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

import sys


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



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=(int(x) for x in input().split())
count=0
for i in range(0,C):
    if(B>=A):
        count+=1
        B-=A
print(count)

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

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

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

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

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

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

Solution (Python):


def main():
    a, b, c = map(int, input().split())
    d = int(b / a)

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

if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):


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

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

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

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

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

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

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

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

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

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

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

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

result = 0
if A > B:
    print(result)
    exit(0)

while result * A <= B :
    if (result + 1) * A > B:
        break
    result +=1

print(result)

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

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

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

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

main()

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

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

Solution (Python):


def solve():
    A, B ,C = list(map(int, input().split()))

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

if __name__ == "__main__":
    solve()

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 = [int(i) for i in input().split()]
print(min(c, b//a))

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

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

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

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

intInput = [int(i) for i in input]

result = 0


if(intInput[0]*intInput[2] <= intInput[1]):
	print(intInput[2])

elif(intInput[0]>intInput[1]):
	print(0)

else:
	for i in range(intInput[2]):
		result = result + intInput[0]
		if(intInput[1] - result < intInput[0]):
			print(i+1)
			break

Solution (Python):

import sys
try:
    from math import gcd
except Exception:
    from fractions import gcd


def solve(A: int, B: int, C: int):
    return 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))  
    result = solve(A, B, C)
    print(result)

if __name__ == '__main__':
    main()

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

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

count = math.floor(B / A)

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

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().rstrip().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):
from sys import stdin
import math

A,B,C = [int(x) for x in stdin.readline().rstrip().split()]

if B < A:
  print('0')
elif A*C <= B:
  print(C)
else:
  print(math.floor(B/A))

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

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

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

Solution (Python):

def main():
   ARR = raw_input()
   ABC = list(map(int, ARR.split()))
   A = ABC[0]
   B = ABC[1]
   C = ABC[2]
   ans = 0
   while B >= A:
      B = B - A
      ans += 1
      if ans == C:
         break;
   print(ans)
main()

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

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

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

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())
cost = B
ans = 0

for _ in range(C):
    if cost - A >= 0:
        cost -= A
        ans +=1
    else:
        break

print(ans)

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

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

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

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

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

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

ans = min(B // A, C)

print(ans)

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

Solution (Python):
i,j,k = map(int, input().split())

if (j >= i * k):
    print(k)
else:
    print(int(j/i))

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

c = 0
while B >= A:
    B = B - A
    if c == C:
        break
    c += 1

print(c)

Solution (Python):
inpt=input()
ABC=inpt.split()
A=int(ABC[0])
B=int(ABC[1])
C=int(ABC[2])
if A*C<=B:
    ans=C
else:
    ans=B//A
print(ans)

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

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

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

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

Solution (Python):
import functools

import os

INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


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


def inlf():
    return list(map(float, input().split()))


def inls():
    return input().split()


def debug(fn):
    if not os.getenv('LOCAL'):
        return fn

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print('DEBUG: {}({}) -> '.format(
            fn.__name__,
            ', '.join(
                list(map(str, args)) +
                ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
            )
        ), end='')
        ret = fn(*args, **kwargs)
        print(ret)
        return ret

    return wrapper


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

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

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

Solution (Python):


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

Solution (Python):
from sys import stdin
A,B,C = map(int,stdin.readline().rstrip().split())
if B/A > C:
    print(C)
else:
    print(int(B/A))

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

a = int(in1[0])
b = int(in1[1])
c = int(in1[2])

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

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):
input = input().split()

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):


import numpy as np










[A, B, C] = list(map(int,input().split()))
ans = min(C, 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())
cnt = 0

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

print(cnt)

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

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

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

Solution (Python):



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

print '{}'.format(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 = list(map(int, input().split()))



ans = B // A



if ans > C:
    ans = C

print(ans)

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


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

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

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

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

count = B // A

if C < count:
	count = C
	
print(count)

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

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

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

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

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

Solution (Python):
import math

i = list(map(int, input().split()))
A = i[0]
B = i[1]
C = i[2]

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

if(A * C > B):
  if(B >= A):
    print(math.floor(B / A))
  else:
    print(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, raw_input().split())
if b >= c*a:
    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 B/A > C:
    print(C)
else :
    print(B//A)

Solution (Python):
i = list(map(int,input().split()))
a = i[1]//i[0]
c = i[2]
if a<c:
	print(a)
else:
	print(c)

Solution (Python):
a, b, c = [int(s) for s in input().split(' ')]

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
A,B,C=map(int,input().split())
cnt=0
for i in range(C):
    B-=A
    if B>=0:
        cnt+=1
    else:
        break
print(cnt)

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

Solution (Python):
a,b,c=map(int, raw_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):
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, math

stdout_write = sys.stdout.write

for line in sys.stdin:
  a, b, c = (int(i) for i in line.strip().split())
  ans = min(int(math.floor(b / a)), c)
  stdout_write('{}\n'.format(ans))

Solution (Python):
import sys

stdout_write = sys.stdout.write

for line in sys.stdin:
  a, b, c = (int(i) for i in line.strip().split())
  cnt = 0
  if (a * c) <= b:
    cnt = c
    break

  for _ in range(c):
    if (b - a) < 0:
      break
    b -= a
    cnt += 1

stdout_write('{}\n'.format(cnt))

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

Solution (Python):
list = raw_input().split()

A = int(list[0])

B = int(list[1])

C = int(list[2])

if B // A < C:
    print B // A

else:
    print C

Solution (Python):


import re

x = input()
x = re.split(" ",x)

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

if(int(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):
import math

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

if B - A*C < 0:
    print(math.floor(B/A))
else:
    print(C)

Solution (Python):


def main():
    A, B, C = [int(x) for x in input().split()]
    if B // A > C:
        print(C)
    else:
        print(B//A)

if __name__ == "__main__":
    main()

Solution (Python):
import math

A, B, C = map(int, input().split())
if B - A * C < 0:
    print(math.floor(B/ A))
else:
    print(C)

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

cut = B // A
if cut >= C:
    ans = C
else:
    ans = cut
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):
import math
a, b, c = map(int, input().split())
D = b / a
if a > b:
    print(0)
elif D == c:
    print(c)
elif D > c:
    if c > D:
        print(math.floor(D))
    else:
        print(c)
else:
    print(math.floor(D))

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

Solution (Python):

import sys
import math


def solve(A: int, B: int, C: int):
    use = math.floor(B/A)
    print(min(C,use))
    return



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


def main():
    a, b, c = map(int, input().split())
    ans = solve(a, b, c)
    print(ans)


main()

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

if num > c:
	print(c)

else:
	print(num)

Solution (Python):
def smaller(x, y):
	if x < y: return x
	else: return y
A, B, C = map(int, raw_input().split())
print smaller(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=int(b/a)
if x<=c:
  print(x)
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(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(" "))

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

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

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

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

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

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

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

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

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

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

num = B // A

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

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

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

Solution (Python):
a,b,c=(int(x) for x in input().split())

answer=min(int(b/a),c)

print(answer)

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

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

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

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

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

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

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

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

Solution (Python):


"""
Created on Fri Apr  5 22:44:01 2019

@author: lab
"""

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

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