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-----
7 17 120

-----Sample Output-----
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.

Difficulty: introductory

Starter code:

Solutions:
n, a, b = (int(n) for n in input().split())
print(min(n * a, b))

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

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

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

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


# 数値の取得
N,A,B = map(int,input().split())

# 料金の最安値を出力
plan1 = A * N
plan2 = B
print(min(plan1,plan2))

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


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

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


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

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

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

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

print(min(N*A, B))

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

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

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

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

print(min(A * N, B))

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

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


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

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


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

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

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

N,A,B = list(map(int,input().split()))
price = [N * A, B]
print((min(price)))


def iroha():
    n,a,b=list(map(int, input().split()))
    print((b if b <= a*n else a*n))


def __starting_point():
    iroha()


__starting_point()

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

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


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

plan1 = a * t
plan2 = b

print(min(plan1, b))

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

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

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


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

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

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

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

# 080_a
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))

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

print(min(A*N, B))

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

print(min(N * A, B))

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

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

#
# abc080 a
#
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """7 17 120"""
        output = """119"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """5 20 100"""
        output = """100"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """6 18 100"""
        output = """100"""
        self.assertIO(input, output)


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


def __starting_point():
    # unittest.main()
    resolve()

__starting_point()

import bisect,collections,copy,heapq,itertools,math,string
import sys
def I():
    # 1 line 1 int
    return int(sys.stdin.readline().rstrip())
def LI():
    # 1 line n ints
    return list(map(int,sys.stdin.readline().rstrip().split()))
def S():
    # 1 line 1 string
    return sys.stdin.readline().rstrip()
def LS():
    # 1 line n strings
    return list(sys.stdin.readline().rstrip().split())

N, A, B = LI()

x = A*N
y = B

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



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

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

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

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

print(min(n*a,b))

lst = input().split()
print(min([int(lst[0]) * int(lst[1]), int(lst[2])]))

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

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


#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**6)

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

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


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

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

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

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

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

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

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

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

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

def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    t, a, b = Input()
    print(min(t*a, b))


main()


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

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




# 080a

def atc_080a(NAB: str) -> int:
    N, A, B = map(int, NAB.split(" "))
    return min(N * A, B)

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

# 080a

def atc_080a(NAB: str) -> int:
    N, A, B = list(map(int, NAB.split(" ")))
    return min(N * A, B)

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


parking_time, time_price, anytime_price = list(map(int, input().split()))

min_price_plan = min(parking_time * time_price, anytime_price)

print(min_price_plan)


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

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

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

print(min(a*n,b))

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

plan1 = a * n
plan2 = b

print(min(plan1, plan2))

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

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

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

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

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

# 標準入力から N, A, B の値を取得する
n, a, b = list(map(int, input().split()))

result = [n * a, b] # 結果出力用のリスト

print((min(result)))


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

# プラン 1: T時間駐車した場合、A × T円 が駐車料金となる。
# プラン 2: 駐車した時間に関わらず B円 が駐車料金となる。
# N時間駐車するとき、駐車料金は最小でいくらになるか求めてください。

plan_A = A * N
plan_B = B

print(min(plan_A, plan_B))

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

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

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

print(min(a * n, b))

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


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


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

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

print(min(N * A, B))

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

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

prices = [A * N, B]

print(min(prices))


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



plan_A = A * N
plan_B = B

print(min(plan_A, plan_B))

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

print(min(N*A, B))

# A - Parking
# N A B

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

# A * N < B ⇔ B

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


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

plan1 = N * A
plan2 = B

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


#080A
# 1.値を正しく取得
a, b, c = (int(x) for x in input().split())

# 2.正しく処理
plan1 = a * b
plan2 = c

resalt=[plan1,plan2]

print(min(resalt))

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

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

answer = min(park_price)
print(answer)


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

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


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

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)

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

print(min(N * T, B))

time, normal_cost, unlimited_cost = list(map(int, input().split()))
if normal_cost * time < unlimited_cost:
    total_cost = normal_cost * time
else:
    total_cost = unlimited_cost
print(total_cost)


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

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

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

# N時間駐車した時の最小料金を求める

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

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


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

print(min(A * N, B))

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

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

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

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

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

# A - Parking
# https://atcoder.jp/contests/abc080/tasks/abc080_a

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

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


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

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

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


#https://atcoder.jp/contests/abc080/tasks/abc080_a
S_list = list(map(int,input().split()))
N,A,B = S_list
if N * A > B:
    result = B
else:
    result = N * A
print(result)

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

print(min(n*a, b))

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

plan1 = N * A
plan2 = B

print(min(plan1,plan2))

import bisect,collections,copy,heapq,itertools,math,string
import sys
def I():
    #1 line 1 int
     return int(sys.stdin.readline().rstrip())
def LI():
    #1 line n int
     return list(map(int,sys.stdin.readline().rstrip().split()))
def S():
    #1 line 1 string
     return sys.stdin.readline().rstrip()
def LS():
    #1 line n strings
     return list(sys.stdin.readline().rstrip().split())

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

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