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

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

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

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

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

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

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

answer = 0

if B//A < C:
  answer = B//A
else:
  answer = C

print(answer)

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

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

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

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

for i,j in enumerate(n):
  n[i] = int(j)
  
if n[1] / n[0] >= n[2]:
  print(n[2])
else:
  print(int(n[1] / n[0]))

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

for i,j in enumerate(n):
  n[i] = int(j)
  
if n[1] / n[0] >= n[2]:
  print(n[2])
else:
  print(int(n[1] / n[0]))

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

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

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

Solution (Python):
import math

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

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

n1 = int(b / a)
if c  > n1:
    print(n1)
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 = [int(x) for x in input().split()]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

if arr[1] < arr[0]*arr[2]:
  print(int(arr[1]/arr[0]))
else:
  print(arr[2])

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


if __name__ == "__main__":
    main()

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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
fee, money, times = map(int,input().split())

if money/fee >= times:
   print(times)

else:
   print(int(money/fee))

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

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

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

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

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

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

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

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys


args = str(input()).split(" ")

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

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

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

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

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

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

Solution (Python):
class Solution:
  def solve(self, A, B, C):
    count = 0
    while True:
      B -= A
      if B < 0: break
      count += 1
      if count == C: return C
    return count

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

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

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

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

Solution (Python):
line = input().split(' ')
price = int(line[0])
equity = int(line[1])
max = int(line[2])

def getTimes(price, equity, max):
    real = int(equity / price)
    return min(real, max)

def min(a, b):
    if a <= b:
        return a
    else:
        return b

res = getTimes(price, equity, max)
print(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 = map(int, input().split())
 
if A>B:
  print(0)
elif 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 = map(int, input().split())

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

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

x = abc[1]//abc[0]

if x > abc[2]:
    print(abc[2])
else:
    print(x)

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

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

Solution (Python):
def compute():
  from sys import stdin
  A, B, C = list(map(int, stdin.readline().split()))
  
  print(min(B//A, C))

if __name__ == "__main__":
  compute()

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

main()

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

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

required = a * c
limit = b

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

Solution (Python):

"""
Created on Mon Mar  4 22:42:24 2019

@author: yuta
"""

A,B,C = list(map(int,input().split()))
def main(a,b,c):
    d = int(b/a)
    if d >= c:
        e = c
    else:
        e = d
    print(e)
main(A,B,C)

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

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

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

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

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

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

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

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

A,B,C = [int(i) for i in readline().split(' ')]
if A*C <= B:
  print(C)
elif A > B:
  print(0)
else:
  print(B // A)

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

if __name__=='__main__':
  main()

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

if(a > b):
	print("0")
elif(b / a >= c):
	print(int(c))
elif(b / a < c):
	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())
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(min([B//A, C]))

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

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

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

Solution (Python):
import 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())
if a*c<b:
    print(c)
else:
    print(b//a)

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

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

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

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

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

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

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

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)


def main():
    a,b,c = LI()

    return min(c,b//a)



print(main())

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

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

def func(S):
	A, B, C = map(int, S.split())
	return B // A if B // A < C else C

def main():
	
	
	
	print(func(input()))
	return

if __name__ == '__main__':
	main()

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

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


"""
a, b, k = map(int, input().split())
for i in range(1,max(a, b)+1):
    if a % i == 0 and b % i == 0:
        k -= 1
        if k == 0:
             print(i)
"""

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

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

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





taka = 0
while (taka != C and B >= A):
    B-=A
    taka+=1
print(taka)

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

a, b, c = map(int, sys.stdin.readline().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())
if(b//a>=c):
	print(c)
else:
	print(b//a)

Solution (Python):



A,B,C = [int(x) for x in input().split()]
if A*C <= B:
    answer = C
else:
    answer = B//A

print(answer)

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

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

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

Solution (Python):
a,b,nmax=map(int,raw_input().split())

op=0

while b>=a:
    op+=1
    b=b-a
    if op==nmax:
        break

print op

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

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

print(Cmax)

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):
print(*[min(a[1]//a[0],a[2]) for a in [list(map(int,input().split()))]])

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

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

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

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

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

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

Solution (Python):
import math
data = input().split()

result = (int(data[1]) // int(data[0])) 

if result <= int(data[2]):
        if result >= 1:
            print(math.floor(result))
        elif result < 1:
            print("0")
elif result > int(data[2]):
    print(data[2])

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

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

result = min(C, B // A)

print(result)

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

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

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

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

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

tmp = int(B / A)

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

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

x=b//a
x=int(x)

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

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

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


A,B,C=spaceinput()

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

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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline

def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, B, C] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print min(B/A, C)

if __name__ == '__main__':
    main()

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

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

Solution (Python):


price, money, satis = map(int, input().split())


if price * satis <= money:
	output = satis

else:
	output = money // price

print(output)

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

flag = 0
while B>0 and B>=A:
	B = B - A
	flag+=1
	if flag==C:
		print(C)
		exit()
print(flag)

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

Solution (Python):




def FavoriteSound(oneTimePay,haveMoney,satisfiedCount):
	if oneTimePay*satisfiedCount <= haveMoney:
		return satisfiedCount
	else:
		possibleCount = haveMoney // oneTimePay
		return possibleCount


if __name__ == '__main__':
	A,B,C = map(int,input().strip().split(' '))
	solution = FavoriteSound(A,B,C)
	print("{}".format(solution))

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

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

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

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

Solution (Python):



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

print("{}".format(int(min(b / a, c))))

Solution (Python):
import sys
import io
import math

datalist = input().split()

data_a = int(datalist[0])
data_b = int(datalist[1])
data_c = int(datalist[2])

data_ans = int(data_b / data_a)

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

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

dat = list[1] / list[0]
if (dat >= list[2]):
  print(list[2])
else:
  print(int(dat))

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

if A > B:
    print(0)

elif B < A * C:
    print(B // A)

else:
    print(C)

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

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

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

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

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

d = int(b / a)

if d > c:
    print(c)

else:
    print(d)

Solution (Python):
if __name__ == "__main__":
    s = input()
    yen = s.split()
    for i in range(len(yen)):
        yen[i] = int(yen[i])
    times_A = yen[1] / yen[0]
    if(times_A < yen[2]):
        print(int(times_A))
    else:
        print(yen[2])

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

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

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

Solution (Python):
from sys import stdin






n = stdin.readline().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])


out = int(b / a)

if out > c:
    out = c

print(out)

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

Solution (Python):
a, b, k = [int(x) for x in input().strip().split(" ")]
print(min(b // a, k))

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

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

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

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

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

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

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

Solution (Python):
import sys

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

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

Solution (Python):
from sys import stdin

input = [int(i) for i in stdin.readline().rstrip().split(' ')]

if (input[0] * input[2]) <= input[1]:
  print(input[2])
else:
  print(input[1] // input[0])

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

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

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

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

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

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

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

if A[2] <=A[1]/A[0]:
	print(A[2])
else:
	print('%d'%(A[1]/A[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 = 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):
import math
a, b, c = [int(x) for x in input().split()]
if a*c <= b:
    print(math.floor(c))
else:
    print(math.floor(b/a))

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

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

else:
    print(int(b/a))

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

Solution (Python):
S = input().split()
A, B, C = int(S[0]), int(S[1]), int(S[2])
print(C if A*C <= B else 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(" "))
i = 0

while i < c:
  if b < a:
    break
  else:
    b -= a
    i += 1

print(i)

Solution (Python):

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

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

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

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

Solution (Python):
import sys

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

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

print(O)

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

Solution (Python):

import sys



def solve(lines):
    A,B,C = map(int, lines.pop(0).split(' '))
    res = B // A
    if res > C:
        print(C)
    else:
        print(res)




lines = [x.strip() for x in sys.stdin.readlines()]




solve(lines)

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

Solution (Python):
A,B,C= input().split()
A=eval(A)
B=eval(B)
C=eval(C)
if B//A>=C :
    print(C)
elif 0<B/A<C:
    print(B//A)

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

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

print(div)

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

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

Solution (Python):
cost, amount, satisfaction = list(map(int, input().split()))

total_yen = cost * satisfaction


if total_yen <= amount:
    print(satisfaction)
else:
    print(amount // cost)

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

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

if A*C < B:
    print(C)

elif A*C == B:
    print(C)

elif A*C > B:
    print(B//A)