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

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(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(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())
ans = min(N*A, B) 

print (ans)

Solution (Python):
n,t,b = map(int,input().split())
if b > n*t:
 print(n*t)
elif b <= n*b:
  print(b)

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


abc()

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(a*n)
else:
    print(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):
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
MOD = 1000000007
def POW(x, y): return pow(x, y, MOD)
def INV(x, m=MOD): return pow(x, m - 2, m)
def DIV(x, y, m=MOD): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()

N,A,B=LI()

print(min(N*A,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())

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

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

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

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

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

Solution (Python):



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



if __name__ == '__main__':
    main()

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

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

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

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

print(min(a*t,b))

Solution (Python):
def smaller(x, y):
	if x < y: return x
	return y

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

Solution (Python):
T, A, B = map(int, input().split())
print(min(T * 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 = [int(i) for i in input().split()]
print(min(A * N, B))

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

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

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

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

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

plan1=x*a
plan2=b

if plan1<plan2:
    print(plan1)

elif plan1==plan2:
    print(plan1)

else:
    print(plan2)

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

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

Solution (Python):
import re
 
a = input()
 
a = re.split(" ",a)
 
b = int(a[0])*int(a[1])
c = int(a[2])
 
if(b < c):
    print(b)
else:
    print(c)

Solution (Python):
N, A, B = map(int, input().rstrip().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 B < A*N:
  print(B)
else:
  print(A*N)

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


main()

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

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

Solution (Python):

import sys
import math
input = sys.stdin.readline

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

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

Solution (Python):

import sys
from collections.abc import Iterable
from math import *
from itertools import *
from collections import *
from functools import *
from operator import *
try:
    from math import gcd
except Exception:
    from fractions import gcd


def solve(N: int, A: int, B: int):
    return min(A * N, B)


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    result = solve(N, A, B)
    if isinstance(result, Iterable):
        result = '\n'.join([str(v) for v in result])
    print(result)

if __name__ == '__main__':
    main()

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

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

p1 = l[0] * l[1]
p2 = l[2]

print(min(p1, p2))

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(N*A,B))

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

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

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    a, b, c = (int(_) for _ in input().split())  
    print(min(a*b,c))
    
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(a*n if a*n<b else 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())

tmp = int(N * A)
print(min(tmp, B))

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

tmp = int(N * A)
print(min(tmp, B))

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

m=n*a

print(min(m,b))

Solution (Python):
import sys


def input():
    return sys.stdin.readline()[:-1]








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

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

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())
K = N*A
if K<B:
  print(K)
elif B<K:
  print(B)
else:
  print(K)

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(n*a, b))

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

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, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    n,a,b = f()
    print(min(n*a, b))

solve()

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

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

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

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

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(n*a,b))

Solution (Python):

def read_input():
    n, a, b = map(int, input().split())
    return n, a, b


def submit():
    n, a, b = read_input()
    print(min(b, n*a))


if __name__ == '__main__':
    submit()

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

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

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

Solution (Python):


import sys
import math



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())
if A*N > B:
    print(B)
else:
    print(A*N)

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

p1 = n*a
p2 = b

print(min(p1,p2))

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

print(min([N*A,B]))

Solution (Python):



def quicksort(seq):
    if len(seq) < 1:
        return seq
    pivot = seq[0]
    left = []
    right = []
    for x in range(1, len(seq)):
        if seq[x] <= pivot:
            left.append(seq[x])
        else:
            right.append(seq[x])
    left = quicksort(left)
    right = quicksort(right)
    foo = [pivot]
    return (left + foo + right)




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 = list(map(int, input().split()))
print(a*n if a*n < 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())
pln1 = n * a
pln2 = b
print(min(pln1,pln2))

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

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

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

print(min(a*b,c))

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

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

print(b if b < n*a else n*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(A * N if A * N < 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())
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(c) for c in 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(B, A*N))

Solution (Python):
import functools

import os

INF = float('inf')


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


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


def inps():
    return input()


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


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


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


def inpm(line):
    return [inp() for _ in range(line)]


def inpfm(line):
    return [inpf() for _ in range(line)]


def inpsm(line):
    return [inps() for _ in range(line)]


def inlm(line):
    return [inl() for _ in range(line)]


def inlfm(line):
    return [inlf() for _ in range(line)]


def inlsm(line):
    return [inls() for _ in range(line)]


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

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

    return wrapper


n, a, b = inl()

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())
ans = min(A*N,B)
print(ans)

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(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(n*a,b))

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())



N, A, B = mi()
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):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    n, a, b = LI()
    print(min(n*a,b))
    return


def B():
    a = S()
    print(a.count("1"))
    return


def C():
    n = II()
    a = list(str(n))
    if not n % sum(a):
        print("Yes")
    else:
        print("No")
    return


def D():
    n = II()
    a = LI()
    ans = 0
    for a_ in a:
        while not a_ % 2:
            ans += 1
            a_ /= 2
    print(ans)
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

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

Solution (Python):
import re

a = input()

a = re.split(" ",a)

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

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

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


def A():
    n,a,b = LI()
    print(min(n*a,b))
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


def I_():
    return


def J():
    return


if __name__ == "__main__":
    A()

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(n*a if n*a < b else 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())
print(min(b,a*n))

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(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 = list(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())
if (N * A > B):
  print(B)
else:
  print(N * A)

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())
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 = [int(item) for item in 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):
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(N*A if N*A < B else B)

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

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

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

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

n1 = int(str[0]) * int(str[1])
n2 = int(str[2])
if n1 <= n2:
  print(n1)
else:
  print(n2)

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(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 = [int(n) for n in input().split()]
p = a * n
if a * n <= b:
    print(p)
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(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())
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 = list(map(int, input().split()))
print(min(A*N, B))

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

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

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

a_fee = a * n
b_fee = b

if a_fee < b_fee:
    print(a_fee)
else:
    print(b_fee)

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

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

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

Solution (Python):
def solve(string):
    n, a, b = map(int, string.split())
    return str(min(n * a, b))


if __name__ == '__main__':
    print(solve(input()))

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

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


def A():
    n,a,b = LI()
    print(min(n*a,b))
    return


def B():
    return


def C():
    n = I()
    f = LIR(n)
    po = [1]*11
    for i in range(n):
        k = 0
        p = 1
        for j in range(10):
            k += p*f[i][j]
            p *= 2
            po[j+1] = p
        f[i] = k
    p = LIR(n)
    ans = -float("inf")
    for i in range(1,1024):
        k = 0
        for j in range(n):
            c = i&f[j]
            s = 0
            for l in po:
                if c&l:s += 1
            k += p[j][s]
        ans = max(ans,k)
    print(ans)

def D():
    n,C = LI()
    T = [[0 for i in range(100002)] for j in range(C)]
    for i in range(n):
        s,t,c = LI()
        c -= 1
        T[c][s] += 1
        T[c][t+1] -= 1
    for c in range(C):
        for i in range(100000):
            T[c][i+1] += T[c][i]
    ans = 0
    for i in range(100000):
        k = 0
        for c in range(C):
            if T[c][i]:k += 1
        ans = max(ans, k)
    print(ans)

def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == "__main__":
    A()

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

print(n*a if a*n < 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(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())

a = N * A
b = B
if a >= b:
  print(b)
else:
  print(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())
ans=min(n*a,b)
print(ans)

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

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

Solution (Python):
NAB=list(map(int,input().split()))
m=NAB[0]*NAB[1]

if m>NAB[2]:
  print(NAB[2])
else:
  print(m)

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

Solution (Python):
N,A,B = map(int,input().split())
plan_A = A*N
plan_B = B
if(plan_A < plan_B):
    print(plan_A)
else:
    print(plan_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):

import copy
import numpy as np
import random

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


ans = min(b,a*n)

print(ans)

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

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

Solution (Python):



def main():
    n, a, b = map(int, input().split())
    if n * a > b:
        print(b)
    elif n * a <= b:
        print(n * a)


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

p1 = n * a
p2 = b

print(min(p1, p2))

Solution (Python):


import itertools
import collections
import bisect

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

if __name__ == '__main__':
    main()

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

Solution (Python):
def parking(N: int, A: int, B: int) -> int:
    return min(N * A, B)


if __name__ == "__main__":
    N, A, B = map(int, input().split())
    ans = parking(N, A, B)
    print(ans)

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

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(a*n,b))

Solution (Python):
import sys

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


if __name__ == '__main__':
    main()

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

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

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

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(a*n,b))

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

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


if __name__ == "__main__":
    main()

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