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):
N, A, B = map(int, input().split())
print(min(N*A, 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):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n,a,b=INTM()
    print(min(n*a,b))
if __name__ == '__main__':
    do()

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

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

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

Solution (Python):
def main():
    N, A, B = list(map(int, input().split()))
    if (N*A) > B:
        return B
    else:
        return N*A


if __name__ == '__main__':
    print(int(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().strip().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(b)
else:
    print(N*a)

Solution (Python):
from sys import stdin


a,b,c = [int(x) for x in stdin.readline().rstrip().split()]

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

Solution (Python):
input_list = list(map(int,input().split()))
n = input_list[0]
a = input_list[1]
b = input_list[2]
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())
ans=b
tr = n*a
if tr < b:
	ans=tr
print(ans)

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

train = N*A
taxi = B

print(min(train,taxi))

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

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

if __name__ == '__main__':
    main()

Solution (Python):
def examA():
    N, A, B = LI()
    ans = min(A*N,B)
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,inf
mod = 10**9 + 7
inf = float('inf')

if __name__ == '__main__':
    examA()

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

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

train = A * N
taxi = B

print(min(train, taxi))

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

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

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

Train = N * A
Taxi = B

if Train < Taxi:
    print(Train)
else :
    print(Taxi)

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

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

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):
p,q,r=map(int,input().split())
print(min(p*q,r))

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

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

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

print(min(N*A,B))

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


T = N*A

if B > T:
    print(T)
elif B <= T:
    print(B)

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

tr_sum = n * tr

print(min(tr_sum, tx))

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

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

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

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

train = n*a
taxi = b

print(min(train, taxi))

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

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

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())
	train = n*a
	taxi = b

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

if __name__ == "__main__":
	main()

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

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

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

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

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

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):
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(i) for i in input().split())

ans = 0
if A*N >= B:
  ans = B
else:
  ans = A*N

print(ans)

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__':
    main()

Solution (Python):
N,a,b=map(int,(input().split()))
d=N*a

if d>b:
	print(b)
else:
	print(d)

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)
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(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())
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, math, itertools, heapq, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0

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

Solution (Python):

import math
import datetime





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

l = []
l.append(n * a)
l.append(b)

print(min(l))

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

Solution (Python):
l=list(map(int,input().split()))
n=l[0]
a=l[1]
b=l[2]
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())

train = n * a

if train >= b:
    print(b)
else:
    print(train)

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

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

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

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

Solution (Python):


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

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

Solution (Python):


n, a, b = map(int, raw_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()) 
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(' '))


ans = (a * n) if (a * n) < b else b

print(ans)

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


TRAIN = N*A

TAXI = B

if TRAIN > TAXI:
    print(TAXI)
else:
    print(TRAIN)

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:
    B = A * N

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

train = n * a
taxi = b
print(min(train,taxi))

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

train = n * a
taxi = b
print(min(train,taxi))

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

train = n*a

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

Solution (Python):

import sys, math
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans=count=0


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

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

Solution (Python):
import sys
input = sys.stdin.readline
def print_ans(N, A, B):
    """Test Case
    >>> print_ans(4, 2, 9)
    8
    >>> print_ans(4, 2, 7)
    7
    >>> print_ans(4, 2, 8)
    8
    """
    print(min(N * A, B))

if __name__ == '__main__':
    N, A, B = map(int, input().rstrip().split())
    print_ans(N, A, B)

Solution (Python):

import sys










def main():
    n, a, b = [int(x) for x in sys.stdin.readline().split()]
    if n * a >= b:
        ans = b
    else:
        ans = n * a
    
    print(ans)


if __name__ == "__main__":
    main()

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

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

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

print(min(data[0]*data[1], data[2]))

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

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

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


if __name__ == '__main__':
    solve()

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

k = b

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    n,a,b=map(int,input().split())
    print(min(n*a,b))
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(n*a,b))

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

Solution (Python):

n, a, b = [int(s) for s 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())

if b > a*n:
    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):
import unittest


class TestA(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think(4, 2, 9), 8)

    def test_2(self):
        self.assertEqual(think(4, 2, 7), 7)

    def test_3(self):
        self.assertEqual(think(4, 2, 8), 8)


def solve():
    n, a, b = read_int(3)
    result = think(n, a, b)
    write(result)


def read():
    return read_int(3)


def read_int(n):
    return list(map(lambda x: int(x), read_line().split(' ')))[:n]


def read_float(n):
    return list(map(lambda x: float(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(n, a, b):
    return min(b, a * n)


def write(result):
    print(result)


if __name__ == '__main__':
    
    solve()

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

Solution (Python):



index = input().split()
n = int(index[0])
a = int(index[1])
b = int(index[2])

bus = n * a

if bus < b:
    print(bus)

else:
    print(b)

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

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

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

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
uber = B

rist = [train , uber]
print(min(rist))

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

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

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

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

if __name__ == "__main__":
    main()

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


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

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

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

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())
kake = N*A

print(min(kake,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 - T or T
https://atcoder.jp/contests/abc133/tasks/abc133_a

"""
import sys


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


if __name__ == '__main__':
    main(sys.argv[1:])

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

x = N*A
y = B

print(min([x,y]))

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

Solution (Python):
num = [int(e) for e in input().split()]

N = num[0]
a = num[1]
b = num[2]

train = a*N

if train>= b:
    print(b)
else:
    print(train)

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

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

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

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

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

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

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


if __name__ == '__main__':
    main()

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

train = n*a
taxi = b

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

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

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(n*a)
else:
  print(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())
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):
NAB = input().split()
N = int(NAB[0])
A = int(NAB[1])
B = int(NAB[2])
cost = 0
train = N * A
taxi = B
if train > taxi:
    cost = taxi
else:
    cost = train
print(cost)

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

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

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

print(min(N*A,B))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

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

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

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

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

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

print(min(N*A, B))

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

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

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

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

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

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

Solution (Python):
import sys

def input():
    return sys.stdin.readline()[:-1]

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

taxi = N * A
train = B

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

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

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

Solution (Python):
import sys
import fractions
from collections import Counter, deque, defaultdict
from math import factorial
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))

a,b,c = MAP()
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())

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