Problem:
 Score : 100 points    Problem Statement N of us are going on a trip, by train or taxi.  The train will cost each of us A yen (the currency of Japan).  The taxi will cost us a total of B yen.  How much is our minimum total travel expense?      Constraints  All values in input are integers.  1 \leq N \leq 20  1 \leq A \leq 50  1 \leq B \leq 50         Input Input is given from Standard Input in the following format:  N  A  B       Output Print an integer representing the minimum total travel expense.        Sample Input 1 4 2 9      Sample Output 1 8  The train will cost us 4 \times 2 = 8 yen, and the taxi will cost us 9 yen, so the minimum total travel expense is 8 yen.       Sample Input 2 4 2 7      Sample Output 2 7       Sample Input 3 4 2 8      Sample Output 3 8

Solution (Python):

import sys
sys.setrecursionlimit(300000)


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

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

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

Solution (Python):
import bisect
from operator import itemgetter
import math
import copy
import collections
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N,A,B = IL()

print(min(N*A,B))

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


if __name__ == "__main__":
    main()

Solution (Python):
def getN():
    return int(input())
def getNM():
    return map(int, input().split())
def getList():
    return list(map(int, input().split()))
n, a, b = getList()
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(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):

import sys


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

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


ans = min(n * a, b)


print(ans)

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):
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations

from itertools import accumulate
from bisect import bisect_left, bisect_right





def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
 
def i_inpl(): return int(input())
def l_inpl(): return list(map(int, input().split()))
def line_inpl(x): return [i_inpl() for _ in range(x)]

INF = int(1e18)
MOD = int(1e9)+7 



N, A, B = l_inpl()

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

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

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

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):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n,a,b = na()

print(min(n*a,b))

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

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

mi = lambda: map(int, input().split())

N, A, B = mi()

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

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

Solution (Python):
a,b,c = list(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):
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(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(a*n,b))

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

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

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())
ans=min(b,a*n)
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):
import sys
def input():
    return sys.stdin.readline()[:-1]

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

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

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

print(min(N*A,B))

Solution (Python):
from bisect import bisect_left, bisect_right; from collections import Counter, defaultdict, deque, OrderedDict; from copy import deepcopy; from fractions import gcd; from functools import lru_cache, reduce; from math import ceil, floor; from sys import stdin, setrecursionlimit
import heapq as hq; import itertools as its; import operator as op



inf = float('inf')
input = stdin.readline


def main():
    n, a, b = get_li()
    print(min(n * a, b))
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


def get_li():
    return [int(i) for i in input().split()]


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def gets(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input().strip()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().strip().split(sep=sep))]
        for _ in range(n)
    )))


if __name__ == '__main__':
    setrecursionlimit(4100000)
    main()

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

Solution (Python):











import sys
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N,A,B = MI()
    print(min(N*A, B))
if __name__ == '__main__':
    main()

Solution (Python):


import sys

class ATOrT:
    def solve(self):
        n, a, b = [int(_) for _ in input().split()]
        print(min(b, n * a))

solver = ATOrT()
input = sys.stdin.readline

solver.solve()

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

Solution (Python):

a, b, c = map(int, input().split())
print(min(c, 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 prob_a():
    n, a, b = [int(a) for a in input().split()]
    print(str(int(min(n * a, b) + 0.1)))


prob_a()

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

Solution (Python):
n, a, b = (int(_) for _ in input().split())

train=a*n
taxi=b

print(min(train,taxi))

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

ans1 = A * N
ans2 = B
print(min(ans1,ans2))

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

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

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):
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    N, A, B = i2nn()
    n = min(A * N, B)
    print(n)

main()

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

Solution (Python):


import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop

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

if __name__ == '__main__':
    main()

Solution (Python):
import bisect
import heapq
import itertools
import math
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7




N, A, B = list(map(int, sys.stdin.readline().split()))
print(min(A*N, B))

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

Solution (Python):
import sys
sys.setrecursionlimit(100000000)
input=lambda : sys.stdin.readline().rstrip()

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

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

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

Solution (Python):
import math
import fractions
import copy
import numpy as np
def j(q):
    if q==1: print("Yes")
    elif q == 0:print("No")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def printrow(a):
    for i in a:
        print(i)
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
x,y,a, = ips()
print(min(x*y,a))

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

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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
Max = sys.maxsize
def l(): 
	return list(map(int,input().split()))
def m(): 
	return map(int,input().split())
def onem(): 
	return int(input())
def s(x): 
	a = []
	aa = x[0]
	su = 1
	for i in range(len(x)-1):
		if aa == x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a
def jo(x): 
	return " ".join(map(str,x))
def max2(x): 
	return max(map(max,x))

n,a,b = m()

print(min(n*a,b))

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

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

n, a, b = na()

print(min(a*n, b))

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

print(min(N*A,B))

Solution (Python):

import sys
INF = float("inf")


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

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

sys.setrecursionlimit(1000000)
mod = 1000000007


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


def B():
    n = I()

    return


def C():
    n = I()

    return


def D():
    n = I()

    return


def E():
    n = I()

    return


def F():
    n = I()

    return



if __name__ == "__main__":
    A()

Solution (Python):

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

print(min(a*b,c))

Solution (Python):
from collections import defaultdict,deque
import numpy as np
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(input())
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

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

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