Problem:
 Score : 100 points    Problem Statement You are parking at a parking lot. You can choose from the following two fee plans:   Plan 1 : The fee will be A×T yen (the currency of Japan) when you park for T hours.  Plan 2 : The fee will be B yen, regardless of the duration.   Find the minimum fee when you park for N hours.      Constraints  1≤N≤20  1≤A≤100  1≤B≤2000  All input values are integers.         Input Input is given from Standard Input in the following format:  N  A  B       Output When the minimum fee is x yen, print the value of x .        Sample Input 1 7 17 120      Sample Output 1 119   If you choose Plan 1 , the fee will be 7×17=119 yen.  If you choose Plan 2 , the fee will be 120 yen.   Thus, the minimum fee is 119 yen.       Sample Input 2 5 20 100      Sample Output 2 100  The fee might be the same in the two plans.       Sample Input 3 6 18 100      Sample Output 3 100

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

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

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

Solution (Python):
n, a, b = [int(i) for i in input().split()]
print(min(n*a,b))

Solution (Python):
class Solution:
    def solve(self, N: int, A: int, B: int) -> str:

        return min(N*A, B)


if __name__ == '__main__':

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

    
    solution = Solution()
    print(solution.solve(N, A, B))

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

Solution (Python):

t,a,b=map(int,input().split())
print(min(a*t,b))

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

print(min((n*a),b))

Solution (Python):
N,A,B=map(int,input().split())
a=A*N
b=B
print(min(a,b))

Solution (Python):
time, planA, planB = map(int,input().split())

prise_A = time * planA
prise_B = planB

if prise_A >= prise_B:
    print(prise_B)
else:
    print(prise_A)

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

Solution (Python):


import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

N, A, B = na()

print(min(N * A, B))

Solution (Python):
n, a, b = map(int, input().split())
print(min([n*a, b]))

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

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

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

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

Solution (Python):
n, a, b = map(int, input().split())
l = [b, n * a]
print(min(l))

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

Solution (Python):

n,a,b=list(map(int,input().split()))
print(min((n*a),b))

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

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

s = a*n
print(min(s,b))

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

print(min(N*A,B))

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

Solution (Python):
from sys import stdin

n, a, b = [int(x) for x in stdin.readline().rstrip().split()]

print(min(n*a, b))

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

Solution (Python):
N,A,B=map(int,input().split(' '))
print(min(N*A,B))

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

print(min(A*N,B))

Solution (Python):


n, a, b = map(int,input().split())
print(min(a*n, b))

Solution (Python):


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


print( min(A*N, B) )

Solution (Python):
N, A, B = map(int, raw_input() .split())
if N * A < B:
    print N * A
elif N * A > B:
    print B
else:
    print B

Solution (Python):
n,a,b=map(int,raw_input().split())
if a*n <b:
  print a*n
else:
  print b

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

    print(min(n*a, b))

if __name__ == '__main__':
    main()

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

if T * A > B:
    print(B)
else :
    print(T * A)

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

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

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

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

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

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

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

Solution (Python):
def parking(n , a , b):

    return b if n * a > b else n * a

def main():
    n , a , b = map(int , input().split())
    print(parking(n , a , b))

if __name__ == '__main__':
    main()

Solution (Python):

n,a,b=map(int,input().split())
print(min(a*n,b))

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

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

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

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

print(min(n*a, b))

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

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

Solution (Python):

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
mod=10**9+7

def main():
    n,a,b=MI()
    print(min(n*a,b))


main()

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

Solution (Python):

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


print(min(a*n,b))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(min(n*a,b))

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

print(min(A*N, B))

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

p1 = a * n

if p1 < b:
  print(p1)
else:
  print(b)

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

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

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

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

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

Solution (Python):
def main():
    parking_hour, fee_par_hour, flat_fee = map(int, input().split())
    print(min(parking_hour * fee_par_hour, flat_fee))


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

print(min(a * n , b))

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

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

p1 = int(N) * int(A)
p2 = int(B)

if (p1 < p2):
	print(p1)
else:
	print(p2)

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

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

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

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

Solution (Python):
N,A,B=map(int,input().split());print(min(N*A,B))

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

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

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

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

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

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

Solution (Python):

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


print(min(A*N,B))

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

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

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

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

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

print(min(a * n , b))

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

if n*a < b:
    print(n*a)
else:
    print(b)

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

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

if(n * a < b):
    print(n * a)
else:
    print(b)

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

Solution (Python):
n,a,b = map(int,input().split())
x = a*n
if x<b:
    ans = x
else:
    ans = b
print(ans)

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

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

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

if n*a<=b:
  print(n*a)
else:
  print(b)

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

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

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

Solution (Python):




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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
from collections import deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,a,b = map(int,readline().split())

print(min(n*a,b))

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

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

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

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

Solution (Python):
"""
author : halo2halo
date : 29, Jan, 2020
"""

import sys
import itertools



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N, A, B = map(int, readline().split())
print(min(N*A,B))

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

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

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

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

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

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

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

print(min(a*n,b))

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

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

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

ans = min(A * N, B)

print(ans)

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

if n * a < b:
	print(n * a)
else:
	print(b)

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

Solution (Python):

 
import math
import itertools
import sys
import copy
 






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

print (min(A*N, B))

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

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

if N*A < B:
  print(N*A)
else:
  print(B)

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

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

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

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

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

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

print(min(n*a,b))

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

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

print(min(n*a, b))

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

print(min(N * A, B))

Solution (Python):
n,a,b = map(int,input().split())
pertime = n * a

if pertime < b:
	print(pertime)
else:
	print(b)

Solution (Python):
import sys
input = sys.stdin.readline
N,A,B = [int(i) for i in input().split()]
print(min(N * A , B))

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

if N*A >= B:
  r = B
else:
  r = N*A
print(int(r))

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

if b>n*a:
    print(n*a)
else:
    print(b)

Solution (Python):
num = input().split()
i = [int(s) for s in num]

if(i[0]*i[1] > i[2]):
    print(i[2])
else:
    print(i[0]*i[1])

Solution (Python):
x = [int(i) for i in input().split()]

N = x[0]
A = x[1]
B = x[2]

p1 = A * N
p2 = B

if p1 > p2:
  print(p2)

else:
  print(p1)

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

print(min(a*n, b))

Solution (Python):
import sys
input = sys.stdin.readline
N, A, B = map(int, input().split())
li = [A*N, B]
print(min(li))

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

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): 
    return a/gcd(a,b)*b

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

def main():
    n,a,b = map(int,input().split())
    print(min(n*a,b))
    return

if __name__=='__main__':
    main()

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

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

ans = min(n * a, b)

print(ans)

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

if n*a > b:
  print(b)
else:
  print(n*a)

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

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

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

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

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

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

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

print(min(b, N*a))

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
N, A, B = [int(x) for x in input().split()]
print(min(A * N, B))

Solution (Python):
n, a, b = map(lambda x: int(x), input().split())

if n*a < b:
  print(n*a)
else:
  print(b)

Solution (Python):

n,a,b = map(int,input().split())
print(min(n*a,b))

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

    price1 = A*N
    price2 = B

    print(min(price1,price2))

main()

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

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

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

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

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

print(min(a*n,b))

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

plan1 = a * n
plan2 = b

if (plan1 <= plan2):
   print(plan1)
else:
   print(plan2)

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

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

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

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

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

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

Solution (Python):
import sys

n, a, b = map(int, sys.stdin.readline().split())

def main():
    return min(a * n, b)

if __name__ == '__main__':
    ans = main()
    print(ans)

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

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

print(min(N * A, B))

Solution (Python):
n,a,b = map(int,input().split())
sum1 = a*n
print(min(sum1,b))

Solution (Python):
n, a, b = [int(x) for x in input().split()]
print(min(n*a, b))

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

Solution (Python):
import math

n, a, b = map(int, input().split())
print(min(b, a * n))

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

print(min(n*a, b))

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

Solution (Python):
import sys

n, a, b  = map(int, sys.stdin.readline().split())

print(min(a * n, b))

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

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

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

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

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

print(min(a*b,c))

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, A, B = MAP()
print(min(A*N, B))

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

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

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

Solution (Python):
n, a, b = map(int, input().split())
p1 = n*a
list = [p1, b]
print(min(list))

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

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

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

Solution (Python):
[print(min(n * a, b)) for n, a, b in [map(int, input().split())]]

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

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

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

if n * a >= b:
  ans = b
elif n * a < b:
  ans = n *a
  
print(ans)

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

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

if n*a <= b:
    ans = n*a
else:
    ans = b
print(ans)

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

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

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

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

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

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

print(min(N*A, B))

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

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

p1=a*n
p2=b

if p1>=p2:
  print(p2)
else:
  print(p1)

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

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

print(n * a if n * a < b else b)

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

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

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

Solution (Python):


[N, A, B] = [int(i) for i in input().split()]

plan_1 = A * N

plan_2 = B

print(min(plan_1, plan_2))

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

if A*N >= B:
  print(B)
else:
  print(A*N)

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

print(min(A * N, B))

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

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

print(min(n*a,b))

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

print(min(a*n, b))

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

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

print(min(N *A, B))

Solution (Python):


import sys
input = sys.stdin.readline

"""
H = int(input())
h = [int(ele) for ele in input().split()]
h = [0] + h
"""


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


def bfs(queue):
    global yet, graph
    if len(queue) == 0:
        return
    yet.remove(queue[-1])

    for i, adjacency in enumerate(graph[queue[-1]]):
        if adjacency == 1 and (i in yet) and (i not in queue):  
            queue.appendleft(i)
    else:
        queue.pop()
        bfs(queue)


def dfs(stack):
    global yet, graph
    yet.remove(stack[-1])

    for i, adjacency in enumerate(graph[stack[-1]]):
        if adjacency == 1 and i in yet:  
            stack.append(i)
            dfs(stack)
    else:
        stack.pop()


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
        if i != n // i:
            divisors.append(n//i)
    return divisors


class Node():

    def __init__(self):
        self.idx = None
        self.left = None
        self.right = None
        self.parent = None
        return

    def pre_order(self):
        global pre_order_str
        pre_order_str += str(self.idx) + " "
        if self.left:
            self.left.pre_order()

        if self.right:
            self.right.pre_order()

    def in_order(self):
        global in_order_str

        if self.left:
            self.left.in_order()

        in_order_str += str(self.idx) + " "

        if self.right:
            self.right.in_order()

    def post_order(self):
        global post_order_str
        if self.left:
            self.left.post_order()

        if self.right:
            self.right.post_order()

        post_order_str += str(self.idx) + " "


class HeapHelper():
    """HeapContrler.
    完全二分木を二分ヒープで表現した配列 A に対して、
    HeapHelper.parent(idx) とするとそのノードの親の添字を返す
    存在しない場合は Falseを返す

    Returns:
        [type] -- [description]
    """

    def __init__(self):
        return

    @staticmethod
    def parent(i):
        if i == 1:
            return False

        return int(i/2)

    @staticmethod
    def left(i):
        l_idx = 2*i
        if H < l_idx:
            return False

        return l_idx

    @staticmethod
    def right(i):
        r_idx = 2*i + 1
        if H < r_idx:
            return False

        return r_idx


if __name__ == "__main__":
    main()

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

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

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

print(min(n*a, b))

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

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

x=n*a
if x<b:
  print(x)
else:
  print(b)

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

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

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

Solution (Python):

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

n, a, b = map(int, input().split())
print(min(a*n, b))

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

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

print(min(A*N,B))

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

print(min(n*a,b))

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

Solution (Python):
import sys

stdin = sys.stdin
 
ni = lambda:int(ns())
nl = lambda:list(map(int,stdin.readline().split()))
ns = lambda:stdin.readline().rstrip()  

N, A, B = nl()
print(min(N * A, B))

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

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N,A,B = MI()
    print(min(B,N*A))
    
if __name__ == '__main__':
    main()

Solution (Python):
N, A, B = map(int, input().split())
parking_fee = min(A * N, B)

print(parking_fee)

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

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

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

N_A = (N*A)

if N_A <= B:
    print(N_A)
else:      
    print(B)

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

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

main()

Solution (Python):
from sys import stdin
n,a,b = [int(x) for x in stdin.readline().rstrip().split()]

print(min(n*a,b))

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

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

Solution (Python):
def examA():
    N, A, B = LI()
    ans = min(N*A,B)
    print(ans)


import sys,copy,bisect,itertools
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

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

print(min(a*n, b))

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

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

Solution (Python):

N,A,B = map(int, input().split())
print(min(A*N,B))

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

print(min(a * n, b))

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

if n*a <= b:
	print(n*a)
else:
	print(b)

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

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

Solution (Python):
n,a,b=map(int, input().split())
box = [n*a,b]
print(min(box))

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

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

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

print(min(N*A, B))

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

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

Solution (Python):

N, A, B = map(int, input().split())
plan1 = N * A
plan2 = B
if plan1 >= plan2:
    print(plan2)
else:
    print(plan1)

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










def main():
    a, t, b = (int(x) for x in read().split())
    if a * t >= b: print(b)
    else: print(a * t)


if __name__ == "__main__":
    
    main()

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

print(min(A*N,B))

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

print(min(n*a, b))

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

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

Solution (Python):
T, A, B=(int(x) for x in input().split())
print(min(A*T, B))