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):
a, b, c =(int(i) for i in 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(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 = [int(x) for x in input().split()]
if n*a > b:
  print(str(b))
elif n*a < b:
  print(str(n*a))
else:
  print(str(b))

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

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

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

Solution (Python):
human_num, train_value, taxi_num = tuple(int(i) for i in input().split(" "))
print(min(train_value * human_num, taxi_num))

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

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(i) for i in input().split()]
print(min(n*a,b))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
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([N*A,B]))

Solution (Python):
info = input().split(" ")
N = int(info[0])
A = int(info[1])
B = int(info[2])

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

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

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

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

Solution (Python):
x,y,z = map(int,input().split())
a = x * y
print(min([a,z]))

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

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())
a=[N*A,B]
print(min(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 a*n>b:
    print(b)
else:
    print(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):
def solve(string):
    n, a, b = map(int, string.split())
    return str(min(n * a, b))


if __name__ == '__main__':
    print(solve(input()))

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


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

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

if a[0]*a[1]<a[2]:
  print(a[0]*a[1])
else:
  print(a[2])

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 = list(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):
import sys
input = sys.stdin.readline

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

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

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

Solution (Python):
n,a,b = map(int,input().split())
def money(n,a,b):
  result = a * n
  if result >= b:
    return b
  else:
    return result

print(money(n,a,b))

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

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

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

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


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


if __name__ == "__main__":
	if sys.platform =='ios':
		sys.stdin=open('inputFile.txt')
		
	ret = main()
	if ret is not None:
		print(ret)

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

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

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

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

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

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

print str(min_value)

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()];print(C if A*B>C else A*B)

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

train = n * a
taxi = b

print(min(train, taxi))

Solution (Python):
import sys

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

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

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

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())
 
if n*a <= b:
  print(a*n)
else:
  print(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 = [int(i) for i in 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())
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())
train = N * A
if (train < B):
    print(train)
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):
nab = input().split()

n = int(nab[0])
a = int(nab[1])
b = int(nab[2])

print(min(a*n, b))

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

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

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

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

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

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

if (n * a > b):
    ans = b
else:
    ans = n * a

print(ans)

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

print(min(N * A, B))

Solution (Python):
from collections import Counter
from collections import deque
from functools import reduce
from operator import mul
from pprint import pprint
import bisect
import copy
import fractions
import itertools
import math
import queue
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers): return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): return reduce(LCM, numbers)
def LCM(m, n): return (m * n // fractions.gcd(m, n))
def COMBINATION(n, r):
    if n < 0 or r < 0 or n < r:
        return 0
    r = min(n-r, r)
    if r == 0:
        return 1
    o = reduce(mul, range(n, n - r, -1))
    u = reduce(mul, range(1, r + 1))
    return o // u
class UnionFind():

    def __init__(self, n):
        self.n = n
        self.node = [i for i in range(n)]
        self.size = [1 for _ in range(n)]

    def same(self, x, y):
        return bool(self.root(x) == self.root(y))

    def root(self, x):
        if self.node[x] == x:
            return x
        else:
            self.node[x] = self.root(self.node[x])  
            return self.node[x]

    def unite(self, x, y):
        x, y = self.root(x), self.root(y)
        if x == y:
            return  
        if self.size[x] < self.size[y]:
            x, y = y, x
        self.node[y] = x
        self.size[x] += self.size[y]

    def return_size(self, x):
        return self.size[self.root(x)]


n, a, b = MI()
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):
str = input()
n, a, b = str.split(' ')

n = int(n)
a = int(a)
b = int(b)

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

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

Solution (Python):
N, A, B = list(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()))


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

if __name__ == "__main__":
    solve()

Solution (Python):
def find_min_expense(N, A, B):
    return min(N * A, B)	      

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

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

Solution (Python):
N,A,B = list(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().rstrip().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):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline 

n,a,b = [int(i) for i in 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())
print(min(A * N, B))

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

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

Solution (Python):
l = list(map(int, input().split()))

if l[0] * l[1] > l[2]:
  print(l[2])
else:
  print(l[0] * l[1])

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

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

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

Solution (Python):
s = input().split(" ")
train = int(s[0]) * int(s[1])
taxi = int(s[2])
if train < taxi:
  print(train)
else:
  print(taxi)

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

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

Solution (Python):
args = input().split()
n = int(args[0])
a = int(args[1])
b = int(args[2])

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

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

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

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

if a * b < c:
    print(a * b)
else:
    print(c)

Solution (Python):
'''
N=int(input())
A=int(input())
B=int(input())
'''
s=input().split(" ")
N=int(s[0])
A=int(s[1])
B=int(s[2])
if N*A>=B:
    print(B)
else:
    print(N*A)

Solution (Python):
N = input().split(" ")


if (int(N[0]) * int(N[1])) > int(N[2]):
    print(int(N[2]))
else:
    print(int(N[0])*int(N[1]))

Solution (Python):
input_data=input()
input_data=input_data.split()
a=int(input_data[0])
b=int(input_data[1])
c=int(input_data[2])

if a*b<c:
    output=a*b
    
else :
    output=c

print(output)

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



IA = lambda: [int(x) for x in input().split()]

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

Solution (Python):
inp = input().split(' ')
in0 = int(inp[0])
in1 = int(inp[1])
in2 = int(inp[2])
print(min(in0*in1, in2))

Solution (Python):
aaa = input().split()

train_fee = int(aaa[0]) * int(aaa[1])
taxi_fee = int(aaa[2])

print(min([train_fee,taxi_fee]))

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

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

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

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

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

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

Solution (Python):


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

Solution (Python):
a,b,c=map(int,input().split())
if c < a*b:
  print(c)
else:
  print(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):
list = [int(i) for i in input().split()]
if list[0]*list[1] <= list[2]:
    print(list[0]*list[1])
else:
    print(list[2])

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

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

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

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

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

Solution (Python):
import sys
import numpy as np
MOD = 3
INF = 1000000000


def input():
    return sys.stdin.readline().rstrip()


def main():
    n, a, b = [int(e) for e in input().split()]

    print(min(a * n, b))


main()

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

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

Solution (Python):

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

a_total = n * a

c_min = 0

if a_total > b :
  c_min = b
else :
  c_min = a_total
  
print(c_min)

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

train = n * a

print(min(train,b))

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

print(min(N*A, B))

Solution (Python):
import sys, itertools, collections
sys.setrecursionlimit(10000)

read_ints = lambda: list(map(int, input().split()))
read_int  = lambda: int(input())

INF = 10 ** 10

n, a, b = read_ints()
ans = min(a * n, b)
print(ans)

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

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

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

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

Solution (Python):
a, b, c = [int(i) for i in input().split()]
if a * b > c:
  print(c)
else:
  print(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 = (int(i) for i 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):
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())
ans = [A * N, B]
print(min(ans))

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

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

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

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

Solution (Python):

def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(input())
def S(): return list(input())
n,a,b=IL()
print(min(a*n,b))

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

Solution (Python):

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

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

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

if n*a < b: print(n*a)
else: print(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):
from sys import stdin
N,A,B = [int(x) for x in stdin.readline().rstrip().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):
x,y,z = map(int, input().split())
D = x * y
T=z
if  D < T :
      print(D)
else : print(T)

Solution (Python):


import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

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

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

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

if n * a > b:
    ans = b
else:
    ans = n*a

print(ans)

Solution (Python):
nums = list(map(int, input().split()))

if nums[0]*nums[1] > nums[2]:
    print(nums[2])
    
elif nums[0]* nums[1] <= nums[2]: 
    print(nums[0] * nums[1])

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

ans = 1000000000000

for x in range(N+1):
    sum = (N - x) * A + x * B / N
    if sum < ans and sum.is_integer():
        ans = sum

print(int(ans))

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())

N,A,B=LI()

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

train = int(str[0]) * int(str[1])
taxi = int(str[2])

if (train <= taxi):
	print(train)
else:
	print(taxi)

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

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

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

Solution (Python):
n, a, b = (int(_) for _ in input().split())
remainder = 0
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())
train = N * A
taxi = B
if(train <= taxi):
  print(train)
else:
  print(taxi)

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

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

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

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

train=a*n
bus=b

print(min(train,bus))

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

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

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

Solution (Python):
s=input().split(" ")

tr = int(s[0])*int(s[1])
tx = int(s[2])

if tr<tx:
  print(tr)
else:
  print(tx)

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

def solve(N, A, B):
    ans = min([N*A, B])
    print(ans)


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

if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np
from collections import defaultdict
from itertools import combinations


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

print(min(N*A, B))

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

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

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

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

Solution (Python):
N,A,B =(int(x) for x in input().split())
An = N*A
if(An < B):
    print(An)
else:
    print(B)

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

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

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

Solution (Python):
def main():
    N, A, B = [int(n) for n in input().split()]
    print(min(A * N, B))
main()

Solution (Python):

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

Solution (Python):
import sys

n,a,b = input().split(' ')


n = int(n)
a = int(a)
b = int(b)

train = n * a
bus = b

if(train < bus):
  print(train)
else:
  print(bus)

Solution (Python):

NAB= list(map(int, input().split()))

train = NAB[0]*NAB[1]
taxi = NAB[2]

if train > taxi:
    print(taxi)
else:
    print(train)

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