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

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

plan1 = a * n
plan2 = b

print(min(plan1, plan2))

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def I():
    
     return int(sys.stdin.readline().rstrip())
def LI():
    
     return list(map(int,sys.stdin.readline().rstrip().split()))
def S():
    
     return sys.stdin.readline().rstrip()
def LS():
    
     return list(sys.stdin.readline().rstrip().split())

N,A,B=LI()
x=N*A
y=B

if x <= y:
    print(x)
else:
    print(y)

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def I():
    
    return int(sys.stdin.readline().rstrip())
def LI():
    
    return list(map(int,sys.stdin.readline().rstrip().split()))
def S():
    
    return sys.stdin.readline().rstrip()
def LS():
    
    return list(sys.stdin.readline().rstrip().split())

N, A, B = LI()

x = A*N
y = B

if x <= y:
    print(x)
else:
    print(y)

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

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

import sys
sys.setrecursionlimit(10**6)

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

prices = [A * N, B]

print(min(prices))

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

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

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):
lst = input().split()
print(min([int(lst[0]) * int(lst[1]), int(lst[2])]))

Solution (Python):

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



plan_A = A * N
plan_B = B

print(min(plan_A, plan_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,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())

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

Solution (Python):

S_list = list(map(int,input().split()))
N,A,B = S_list
if N * A > B:
    result = B
else:
    result = N * A
print(result)

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

plan1 = a * t
plan2 = b

print(min(plan1, 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 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, T, B = map(int,input().split())

print(min(N * T, B))

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

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

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

park_price = []
park_price.append(N * A)
park_price.append(B)

answer = min(park_price)
print(answer)

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

plan = [n * a, b]
print(min(plan))

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):
'''
問題：
    駐車場があり、以下の二種類のプランのどちらかを選んで駐車できます。
    プラン 1 : T時間駐車した場合、A×T 円が駐車料金となる。
    プラン 2 : 駐車した時間に関わらず B 円が駐車料金となる。
    N時間駐車するとき、駐車料金は最小でいくらになるか求めてください。
'''

'''
制約：
    1 ≦ N ≦ 20
    1 ≦ A ≦ 100
    1 ≦ B ≦ 2000
    入力は全て整数
'''


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

result = [n * a, b] 

print(min(result))

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 atc_080a(NAB: str) -> int:
    N, A, B = map(int, NAB.split(" "))
    return min(N * A, B)

NAB = input()
print(atc_080a(NAB))

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

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

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

plan1 = N * A
plan2 = B

min_plice = min(plan1,plan2)
print(min_plice)

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):
time, normal_cost, unlimited_cost = map(int, input().split())
if normal_cost * time < unlimited_cost:
    total_cost = normal_cost * time
else:
    total_cost = unlimited_cost
print(total_cost)

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

Solution (Python):


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

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

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

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

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

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

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

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

Solution (Python):


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


plan1 = a * b
plan2 = c

resalt=[plan1,plan2]

print(min(resalt))

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 (1 <= N & N <= 20) & (1 <= A & A <= 100) & (1 <= B & B <= 2000):
    p1 = A * N
    p2 = B
    print(min(p1, p2))

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

Solution (Python):
parking_time, time_price, anytime_price = map(int, input().split())

min_price_plan = min(parking_time * time_price, anytime_price)

print(min_price_plan)

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

print(min(plan_A, plan_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):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    N, A, B = map(int, readline().split())

    print(min(N * A, B))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
hours, price_per_h, fixed_charge = map(int, input().split())

plan_a = hours * price_per_h

if plan_a >= fixed_charge:
    print(fixed_charge)
elif plan_a < fixed_charge:
    print(plan_a)

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

p1 = A * N
p2 = B
a = [p1, p2]
print(min(a))

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

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

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

print(min(a * n, b))

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

price = [a * n] + [b]
print(min(price))

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

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

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

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

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

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

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

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

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

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

print(min(A,b))

Solution (Python):
import sys
import numpy as np
import math  
from collections import deque
from collections import defaultdict
from copy import deepcopy
from itertools import accumulate 
def input(): return sys.stdin.readline().rstrip()
from functools import lru_cache 

def main():
    N = list(map(int,input().split()))
    A1 = N[0] * N[1]
    ans = N[2]
    if A1 < ans:
        print(A1)
    else: print(ans)
    return 0

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(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 = (int(T) for T in input().split())
print(min(A*N,B))

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

ans = N * A if N * A < B else B

print(ans)

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())
a = n*a
print(min(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 = (int(x) for x 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):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush

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

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

Solution (Python):
n,a,b=map(int, input().split())
if n*a >b:
    print(b)
elif 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, raw_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):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N, A, B = LI()

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

if __name__ == '__main__':
    resolve()

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

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

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 accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, A, B = map(int, readline().split())

    print(min(A * N, B))

    return


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

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

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


price1=A*N
price2=B

if price1>=price2:
    print(int(price2))
else:
    print(int(price1))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

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


if __name__ == "__main__":
    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(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(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 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):
def resolve():
    n, a, b = map(int, input().split())

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

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

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 bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
n, a, b = M()
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())
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 = map(int,input().split())
plan1 = n*a
if plan1 <= b:
    print(plan1)
else:
    print(b)

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

print(min(a * n, b))

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

print(min(a*b,c))

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


x = N*A

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

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

N,A,B = list(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):
p = list(map(int, input().split()))
n = p[0]
a = p[1]
b = p[2]

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

Solution (Python):










import sys

def input(): return sys.stdin.readline().rstrip()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


N, A, B = iInM()

ans = min(A * N, B)

print(ans)

Solution (Python):
n,a,b=[int(i) for i in 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())
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(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):
import sys
N,A,B = map(int,input().split())

if not (1 <= N <= 20 and 1 <= A <= 100 and 1 <= B <= 2000):
    sys.exit()

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(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):
I = input().split()
N, A, B = [int(i) for i in I]

print(min(N * A, B))

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

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

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

Z=N*A

if Z>B:
	print(B)
else:
	print(Z)

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

x1 = N * A

if (x1 <= B):
    print(x1)

elif(x1 > B):
    print(B)

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

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 = input().split()

N = int(N)

A = int(A)

B = int(B)

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

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

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

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

p1 = n*a
p2 = b

print(min(p1,p2))

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

ans = min(B, N_jikan * A)

print(ans)

Solution (Python):
def actual(n, a, b):
    return min(n * a, b)

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

Solution (Python):
def method_name(n, a, b):    
    plan1 = a * n
    plan2 = b
    return plan1, plan2

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


main()

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
y = b
if x <= y:
    print(x)
else :
    print(y)

Solution (Python):
import sys

input = sys.stdin.readline


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

    ans = min(A * N, B)

    print(ans)


if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
t, a, b = list(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):
import math

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