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

Solution (Python):
from sys import stdin
N,A,B = [int(x) for x in stdin.readline().rstrip().split()]
print(min(A*N,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(T*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())
if A * N >= B:
  print(B)
else:print(A * N)

Solution (Python):

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

Solution (Python):

n, a, b = [int(s) for s in input().split()]
print(min(a * n, b))

Solution (Python):
import sys
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(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(n * a) if n * a <= b 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(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())
print(min(n*a,b))

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

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

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

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

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

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

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

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

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

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(s) for s in 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):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n,a,b=INTM()
    print(min(n*a,b))
if __name__ == '__main__':
    do()

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

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

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

aa080()

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n, a, b = list(map(int, input().rstrip('\n').split()))
    print(min(n * a, b))


if __name__ == '__main__':
    slove()

Solution (Python):
import sys

input = sys.stdin.readline


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

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

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
p2 = b
print(min(p1, 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([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())

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

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

plan_A = A * N
plan_B = B

if plan_A < plan_B:
    print(str(plan_A))
else:
    print(str(plan_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(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 = 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(a * n, b))

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

Solution (Python):
x=list(input().split())
x1=int(x[0])
x2=int(x[1])
x3=int(x[2])
plan1=x1*x2
plan2=x3

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

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(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())
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 =[int(x) for x in 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(A*N,B))

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

plan1 = A*N
plan2 = B

if plan1 > plan2:
    print(plan2)
else:
    print(plan1)

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

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

X = A * N
if X < B :
    print(X)
    
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())
cost = N * A
print(min(cost, 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(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 sys
import math
from fractions import gcd





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

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

big_prime = 1000000007

"""


 =  sys.stdin.readline().rstrip()
 =  list(sys.stdin.readline().rstrip())


 =  int(sys.stdin.readline())
 =  map(int, sys.stdin.readline().split())
 =  list(map(int, sys.stdin.readline().split()))
 =  [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""


N, A, B =  map(int, sys.stdin.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())
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(c) if a*b > c else print(a*b)

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

print(min(A*N,B))

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

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


if __name__ == "__main__":
    main()

Solution (Python):
S = input().split()
N, A, B = int(S[0]), int(S[1]), int(S[2])
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())
d=a*b
if d>c:
  print(c)
else:
  print(d)

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

Solution (Python):


def main():


   N,A,B = map(int,input().split())
   print(A*N) if A*N <= B else print(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(min(b,a*n))

Solution (Python):
n, a, b = map(int, input().split())
if 1 <= n <= 20 and 1 <= a <= 100 and 1 <= b <= 2000:
    print(min(a * n, b))
else:
    print('hoge!')

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

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

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

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


if __name__ == "__main__":
    resolve()

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

Solution (Python):
import sys
import  math
from statistics import *
from collections import *
from operator import itemgetter
"""
from fractions import gcd
def lcm(x, y):
    return (x * y) // gcd(x, y)
"""
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

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

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

Solution (Python):
if __name__ == '__main__':
  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(b, a * n))

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

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

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

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 = list(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(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(A * N, 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) = (int(tok) for tok 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):
def main():
    N, A, B = map(int, input().split())
    return min(N*A, B)

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

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

Solution (Python):
n, a, b = 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(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())
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(B, A*N))

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

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


if __name__ == "__main__":
    test()

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

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

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

else:
    min=b

print(min)

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

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

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

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

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

Solution (Python):


N, A, B = 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()[:3])
p1=n*a

print(min(p1,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 = list(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())

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 = [int(x) for x in input().split()]

plan_1 = A*N
plan_2 = B

ans=min(plan_1,plan_2)
print(ans)

Solution (Python):

import sys
INF = float("inf")


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


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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import math






def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
 
def main():
    N,A,B = inputMap()
    
    ans = min(B, N*A)
    print(ans)
            	
if __name__ == "__main__":
	main()

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

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

Solution (Python):



import sys

input = sys.stdin.readline

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

main()

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

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

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

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

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

A = n*a

if A >= b:
    print(b)
else:
    print(A)

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, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

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

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

Solution (Python):
N, A, B = [int(nab) for nab 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())
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(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())

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 smaller(x, y):
	if x < y:
		return x
	return y

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

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

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

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

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

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

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

plan1 = A * N
plan2 = B

print(min(plan1, plan2))

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 = list(map(int,input().split()))
b = a[0]*a[1]
c = a[2]

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

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

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

Solution (Python):

import sys


def solve(N: int, A: int, B: int):
    if N * A <= B:
        print(N*A)
    else:
        print(B)

    return


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


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())
ans= min(N*A,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(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(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):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

N, A, B = nl()

print(min(A*N, B))

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

Solution (Python):

import sys


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



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

sum1 = N*A

if sum1 >= B:
    print(B)
else:
    print(sum1)

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