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

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

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

Solution (Python):
import sys

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

M = a[1] // a[0]

if M > a[2]:
  print(a[2])
else:
  print(M)

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

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

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

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

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

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

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

ans = b // a

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

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

Solution (Python):
A, B, C = map(int, input().rstrip().split(' '))
v = int(B / A)
if C < v:
    v = C

print(v)

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

Solution (Python):
p = input().split()
print(min(int(p[1]) // int(p[0]), int(p[2])))

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

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

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

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

print(X)

Solution (Python):
from sys import stdin
A, B, C = [int(x) for x in stdin.readline().rstrip().split()]
if C <= B//A:
  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(b//a if b//a<=c else c)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ans = min(C,B//A)

print(ans)

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

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

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

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

count = np.floor(B/A)

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

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

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

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

print(min(int(a[1]/a[0]),a[2]))

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

Solution (Python):


a, b, c = [int(i) for i in input().split()]

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

Solution (Python):
import numpy as np
from collections import defaultdict



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

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

Solution (Python):

import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

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

cnt = 0
for i in range(c):
    if b >= a:
        cnt += 1
        b -= a
    else:
        break
print(cnt)

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

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

Solution (Python):

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

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

Solution (Python):
import sys,collections,math;sys.setrecursionlimit(10**7)
def Is(): return [int(x) for x in sys.stdin.readline().split()]
def Ss(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

Solution (Python):
from sys import stdin

a, b, c = list(map(int, stdin.readline().rstrip().split()))

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

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

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

Solution (Python):
import sys

def main():
  input = sys.stdin.readline
  A, B, C = map(int, input().split())
  if B // A >= C:
    print(C)
  else:
    print(B // A)


if __name__ == '__main__':
  main()

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

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

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

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

n = B // A
out = min(n, C)
print(out)

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):
data = input().split()
a = int(data[0])
b = int(data[1])
c = int(data[2])

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

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

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

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

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

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

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

Solution (Python):
a=input()
a=a.split(' ')
a=[int(z) for z in a]

r=a[1]//a[0]
if r<a[2]:
  print(r)
else:
  print(a[2])

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

Solution (Python):

import re
import bisect
from datetime import datetime as dt
A, B, C = map(int, raw_input().split())

print min(B / A, C)

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

c_max = b//a
cnt = min(c_max,c)

print(cnt)

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

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

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

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

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

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

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

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

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 = map(int, raw_input().split())
if A*C <= B:
  print C
else:
  print B/A

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

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

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

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

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

Solution (Python):

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

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

Solution (Python):


















import math
import numpy as np
import copy
from collections import defaultdict, Counter
from itertools import product
from bisect import bisect_left, bisect_right
def inpl(): return list(map(int, input().split()))

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

x = b // a

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

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

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

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

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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

print(min(c,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
input = stdin.readline

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

print(d)

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

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

Solution (Python):

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

Solution (Python):

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


if __name__ == '__main__':
    solve()

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

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

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

Solution (Python):


import sys

a,b,c = map(int, sys.stdin.readline().rstrip().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(" "))
MAX = A * C
if B >= MAX:
    print(C)
else:
    print(B//A)

Solution (Python):
from sys import stdin

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

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

input = lambda: stdin.readline()
main()

Solution (Python):
import sys

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


ans = B // A


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

Solution (Python):


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

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

Solution (Python):

import sys
a,b,c=map(int,raw_input().split())
print(min(c,b/a))

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

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

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

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

print(solve())

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

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

Solution (Python):


import random
import bisect




def IT(): 
    return int(input())
def IL(): 
    return [int(_) for _ in input().split()]
def IS(): 
    return [_ for _ in input().split()]
def ILS(n): 
    return [int(input()) for _ in range(n)]
def SLS(n): 
    return [input() for _ in range(n)]
def ILSS(n): 
    return [[int(_) for _ in input().split()] for j in range(n)]


def bit_full_search(ss):
    n = len(ss)
    for i in range(1 << n):
        s = ""
        for j in range(n + 1):
            if ((1 & i >> j) == 1):
                s += ss[j]
        print(s)
def bit_full_search2(A):
    
    value = []
    for i in range(1 << len(A)):
        output = []

        for j in range(len(A)):
            if ((i >> j) & 1) == 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 matching_bisect(list1_val, list2_val, n):
    
    j = 0
    for i in range(len(list1_val)):
        j = bisect.bisect_left(list2_val, n - list1_val[i])
        if j < len(list2_val):
            if list1_val[i] + list2_val[j] == n:
                
                break
    return j

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

def main():

    a,b,c = IL()

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







main()

Solution (Python):
a, b, c = map(int, raw_input().strip().split())
q = b // a
ans = min(q, c)

print ans

Solution (Python):


import itertools
import collections
import bisect

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):



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


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

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

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

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

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

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

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

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

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


n = B//A

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

Solution (Python):
import math, string, itertools, fractions, heapq, collections, re,  array, bisect, sys, random, time, copy, functools


sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]


def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


A, B, C = LI()

result = B // A
print(min(result, 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())
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):
import sys
input = sys.stdin.readline
a,b,c = input().split()
a = int(a)
b = int(b)
c = int(c)
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())

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

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

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

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

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

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

max = (b // a)

print(max if max < c else 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(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())

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

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

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

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

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

Solution (Python):


import math
import numpy as np
import random
import copy
import statistics 
import bisect
import heapq

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

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


print(ans)

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

Solution (Python):
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy

def j(q):
    if q==1: print("YES")
    else:print("NO")
    exit(0)


def ct(x,y):
    if (x>y):print("GREATER")
    elif (x<y): print("LESS")
    else: print("EQUAL")

def ip():
    return int(input())




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










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

Solution (Python):


a, b, c = [int(x) for x in input().split()]
print(min(b // a, c))

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

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

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

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

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

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

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


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

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

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

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

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

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

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

Solution (Python):

def main():
    a = list(map(int, input().split()))
    ans = min(int(a[1]/a[0]), a[2])
    print(ans)


if __name__ == '__main__':
    main()

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

Solution (Python):


from collections import deque
import itertools as it
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18

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

print min(B / A, C)

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

Solution (Python):
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
INF = 10**18

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

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

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

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

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

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

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

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

Solution (Python):


if __name__ == '__main__':
    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 = [int(elem) for elem in input().split()]

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

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 = (int(z) for z in 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())
print(min(B//A,C))

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

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

Solution (Python):


import sys


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

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()


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

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

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

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