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

"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(a, b, c):
    return min(int(b/a), c)


do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(int, line.split())) for line in lines]
    a, b, c = parsed_lines[0]
    return a, b, c


if not do_submit:
    a, b, c = input_parse("""
    2 11 4
    """)
    print(sol(a, b, c))
else:
    a, b, c = list(map(int, input().split()))
    print(sol(a, b, 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())
ab = int(b / a)
if ab < c:
    print(ab)
else:
    print(c)

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

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)
elif a > b:
    print(0)
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):
int_list = input().strip().split()

fee_per_sound = int(int_list[0])
takahasi_money = int(int_list[1])
satisfaction_number = int(int_list[2])

if takahasi_money >= fee_per_sound*satisfaction_number:
    print(satisfaction_number)
else:
    print(takahasi_money//fee_per_sound)

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 = list(map(int, input().split()))
max_i = B//A
print(min(max_i, C))

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

Solution (Python):
import sys


def main():
    lines = sys.stdin.readlines()[0].split(' ')
    one_try = int(lines[0])
    money = int(lines[1])
    count = int(lines[2])
    n = 0
    while(True):
        if money >= one_try:
            money = money - one_try
            n = n + 1
        else:
            break
        if n == count:
            break
    print(n)


if __name__ == '__main__':
    main()

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

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

a=int(a)
b=int(b)
c=int(c)

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

print(int(res))

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

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

count = B / A;

print(C if count > C else int(count));

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

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

Solution (Python):
import math


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

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

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

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

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

a=0

for i in range(C):
    if A>B:
        break
    B=B-A
    a+=1
    if B<=0:
        break
print(a)

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

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

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

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

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

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

C_max = B//A

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

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

Solution (Python):
import sys

l = raw_input().split()
a = int(l[0])
b = int(l[1])
c = int(l[2])

ret = int(b/a)
if ret >= c:
    ret =c

print(ret)

Solution (Python):
a,b,c=input().split()
result=0
for i in range(1,int(c)+1):
    if int(b) >= int(a)*i:
        result+=1
    else : break
print(result)

Solution (Python):



import sys
import math





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



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

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

count = B // A

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

Solution (Python):
import math

val = input().split(" ")
once = int(val[0])
money = int(val[1])
num = int(val[2])

count = money / once

if count >= num:
  print(num)
else:
  print(math.floor(count))

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

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

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

Solution (Python):
tmp = [int(i) for i in raw_input().split()]
A = tmp[0]
B = tmp[1]
C = tmp[2]
tmp = 0
for i in range(C):
    if B >=A:
        B = B -A
        tmp += 1
print(tmp)

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

data = sys.stdin.readline()
a, b, c = data.split(" ")
d = int(int(b) / int(a))
if d >= int(c):
  print(c)

else:
  print(d)

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

a = int(a)
b = int(b)
c = int(c)

Ans = min(b//a,c)

print(Ans)

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

Solution (Python):
a,b,c=(int(x) for x in input().split())
count=0
while True:
    if c<=count or b<a:
        break

    if a<=b:
        b-=a
        count+=1
print(count)

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

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

Solution (Python):
def main():
  A, B, C = map(int, input().split(" "))
  count = B // A
  print(min(count, C))
  
if __name__ == '__main__':
  main()

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

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

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

Solution (Python):
import math

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

dst = None
if A*C <= B:
    dst = C
else:
    dst = math.floor(B/A)

print(dst)

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

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

Solution (Python):
info =  [int(i) for i in input().split()]
a = info[0]
b = info[1]
c = info[2]

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

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

"""def main():
    a, b, k = list(map(int, input().split()))
    lst = []
    for i in range(1, 101):
        if a % i == 0 and b % i == 0:
            lst.append(i)
    print(sorted(lst, reverse=True)[k-1])"""

main()

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

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

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

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

num = b // a

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

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

Solution (Python):
from sys import stdin


def a(input_string):
    favorite_sound_fee ,my_money, count = [int(x) for x in input_string.split()]
    hear_count = 0
    while(hear_count < count and my_money >= favorite_sound_fee):
        my_money -= favorite_sound_fee
        hear_count += 1
    return hear_count


def main():
    input_line = stdin.readline().rstrip()
    answer = a(input_line)
    print(answer)


if __name__ == '__main__':
    main()

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

ans = 0

if (b < a):
    ans = 0
elif (b / a < c):
    ans = int(b / a)
else:
    ans = c

print(ans)

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

count = 0

while (b >= a) and (c > count):
    b = b - a
    count += 1
print(count)

Solution (Python):


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

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

Solution (Python):
"""
    音　１回　A円
    高橋君所持金　B円
    満足する回数　C円　
    出力：お気に入りの音を何回聴けるか？
        B円での何回聴けるかを問いている。
"""

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())
m = b
ans = 0
for i in range(c):
    if b-a*(i+1) < 0:
        break
    ans += 1

print(ans)

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

Solution (Python):
A, B, C = [int(s) for s in input().split(" ")]
for i in range(C):
  B -= A
  if B<0:
    i -= 1
    break
print(i+1)

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

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

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

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

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

ans = int(N[1]/N[0])
print(min(ans,N[2]))

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

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

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

count = 0

while True:
    if count == c:
        break
    if a * (1 + count) <= b:
        count += 1
    else:
        break

print(count)

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

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

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

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

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

Solution (Python):

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

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

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

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

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

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

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

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

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

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

amount = int(b / a)

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

Solution (Python):
a,b,c=list(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):
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from functools import lru_cache, reduce
from math import ceil, floor

import heapq
import itertools
import operator


inf = float('inf')


def get_int():
    return int(input())


def get_str():
    return input().strip()


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


def get_char_list():
    return list(input().strip())



A, B, C = 0, 0, 0


def set_inputs():
    global A, B, C
    A, B, C = get_list_of_int()


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

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

n = int(b/a)

print(n) if n < c else print(c)

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

Solution (Python):


import sys

def parse_input(lines_as_string = None):


    lines = []
    if lines_as_string is None:
        lines.append(input())
    else:
        lines = [e for e in lines_as_string.split("\n")][1:-1]
 
    tokens = lines[0].split(" ")
    a = int(tokens[0])
    b = int(tokens[1])
    c = int(tokens[2])

    return (a, b, c)


def solve(a, b, c):

    tmp = b
    count = 0
    while True:
        tmp = tmp - a
        if tmp >= 0:
            count += 1
        else:
            break

        if count >= c:
            break

    return count

def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

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

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):
in_str = input()
input_list = list(map(int,in_str.split()))
per = input_list[0]
money = input_list[1]
target = input_list[2]
time = int(money/per)
ans = 0
if(time>=target):
  ans = target
else:
  ans = time
print(ans)

Solution (Python):

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

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

Solution (Python):
drinkPay, money, satisfied = map(int, input().split())

canHear = int(money / drinkPay)
if canHear < satisfied:
    print(canHear)
else :
    print(satisfied)

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

ans = 0
count = 0
maxCount = int(inData[2])
many = int(inData[1])
nedan = int(inData[0])

for i in range(0, maxCount):
    if nedan <= many:
        if count < maxCount:
            ans += 1
            many -= nedan
        else:
            break
    else:
        break

print(ans)

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

Solution (Python):
abc = [int(s) for s in input().split(' ')]
result = 0

if abc[1] / abc[0] > abc[2]:
  result = abc[2]
else:
  result = int(abc[1] / abc[0])
print(result)

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

Solution (Python):

import sys
sys.setrecursionlimit(10000)

input = sys.stdin.readline

def debug(*args): print("DEBUG:\t", *args, file=sys.stderr)

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

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

Solution (Python):


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

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

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

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

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

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

print(ANS)

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

Solution (Python):
a,b,c = map(int,input().split())
count = 0
while count * a <= b:
    count += 1
print(min(count-1,c))

Solution (Python):
juice, money, Manzoku = map(int, input().split())
toManzoku = min(int(money / juice), Manzoku)
print(toManzoku)

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

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

n = b/a

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

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

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

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

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

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

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

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

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


count = 0
if A > B:
    print('0')
    exit()
    
while A <= B:
    B = B - A
    count += 1
    if count == C:
        print(count)
        exit()
print(count)

Solution (Python):
A, B, C = [int(x) for x in input().split()]
if B//A < C:
  print(B//A)
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 = list(map(int, input().split()))
n = int(B // A)

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

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

    while(b >= a):
        if (counter >= c):
            break
        counter += 1
        b = b - a

    print(counter)


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

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

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

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

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

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

Solution (Python):
def favorite_sound(A,B,C):
    if A*C <= B:
        return C
    else:
        return int(B / A)

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

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

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

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

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

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
for i in range(0, c, 1):
  if a <= b:
    ans += 1
    b -= a
print(ans)

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

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

Solution (Python):


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



ans = B // A



if ans > C:
    ans = C

print(ans)

Solution (Python):


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

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

print(d)

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

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

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

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

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

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

R = B // A

print(min(R, C))

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

Solution (Python):
import math

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

Solution (Python):

from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


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



"""
s = S()
n = len(s)
while len(s)>1:
    i = 0
    f = True
    while s[i] == s[i+1]:
        if i+1 == len(s)-1:
            f = False
            break
        i += 1
    if not f:break
    s.pop(i)
    s.pop(i)
print(n-len(s))
"""

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

main()

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

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

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

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

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

Solution (Python):
""" AtCoder """

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

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

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

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

x = b // a

if x <= c:
	print(x)

else:
	print(c)

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

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

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

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

else:
	print(b//a)

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

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

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

Solution (Python):
x = [int(i) for i in input().split()]
s = x[1]/x[0]
print(int(min(s,x[2])))

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

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

Solution (Python):
n = list(map(int, input().split())) 
kaisu=n[1]//n[0]

if kaisu<n[2]:
  print(kaisu)
else:
  print(n[2])

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

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

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

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

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

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

Solution (Python):


import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
from datetime import date

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

A,B,C=MAP()

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

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

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

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

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

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

answer = 0

if B < A or C == 0:
	print(0)
elif A == 0:
	print(C)
elif C < (B // A):
	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):
nums=list(map(int,input().split(" ")))
p=int(nums[1]/nums[0])
if p>nums[2]:
    print(nums[2])
else:
    print(p)

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

Solution (Python):
N = list(map(int,input().split()))
A = N[0]
B = N[1]
C = N[2]

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

Solution (Python):


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

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

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

Solution (Python):

def solve():
    A, B, C = map(int, input().split())
    ans = B // A
    if ans > C:
        ans = C
    print(ans)


if __name__ == '__main__':
    solve()

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

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

print(r)

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

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

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

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

Solution (Python):
import math

a, b, c = map(int, input().split())
mx = math.floor(b / a)

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

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

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

q = inp[1] // inp[0]
print(min(q,inp[2]))

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

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

Solution (Python):
s = input().split()
n = int(s[1]) // int(s[0])

if n >= int(s[2]):
  print(s[2])
else:
  print(n)

Solution (Python):


A, B, C = (int(i) for i 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(a > b):
  print(0)
elif(a*c <= b):
  print(c)
elif(a*c > b):
  print(b//a)

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