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

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


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


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


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():
	resolve()
__starting_point()


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)


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


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)


import sys
sys.setrecursionlimit(10 ** 6)
(n, a, b) = list(map(int, input().split()))
print(min(b, n * a))


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


def atc_080a(NAB: str) -> int:
	(N, A, B) = 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())
plan1 = a * n
plan2 = b
print(min(plan1, plan2))


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


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


(a, b, c) = (int(x) for x in input().split())
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())
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)


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


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


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