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, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)

N, A, B = rl()

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

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

c = n * a 

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

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

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
print(min(train,taxi))

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

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

Solution (Python):

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

Solution (Python):
x = list(map(int, input().split()))
n = x[0]
a = x[1]
b = x[2]

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

Solution (Python):
from collections import Counter


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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N, A, B = LI()

    print(min(A * N, B))

if __name__ == '__main__':
    resolve()

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

densya = N * A

if densya <= B:
    print(densya)

else:
    print(B)

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

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

    
if '__main__' == __name__:
    resolve()

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

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

a=N*A

print(min(a,B))

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations

from heapq import heapify,heappop,heappush


from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

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

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

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

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

if __name__ == '__main__':
    main()

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())
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(x) for x in input().split())
print(min(A*N,B))

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

Solution (Python):
from sys import stdin
N, A, B = input().split()
train = int(N) * int(A)
taxi = int(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())
t = N*A
if t > B:
  print(B)
else:
  print(t)

Solution (Python):

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

Solution (Python):
n,a,b = [int(a) for a in input().split()]
if a*n<b or 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):
import numpy as np

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

print(min(costs))

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

elif a*n<b:
    print(a*n)

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

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

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

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

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

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

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

Solution (Python):
arr = input().split()
n,train,taxi = int(arr[0]), int(arr[1]), int(arr[2])

print(min(n*train, taxi))

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

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

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

Solution (Python):

url = "https://atcoder.jp//contests/abc133/tasks/abc133_a"

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

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

    return


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
N,A,B=map(int,input().split())
a=N*A
if a>=B:
    print(B)
else:
    print(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):
import sys
a=sys.stdin.readline()
res = [int(x) for x in a.split() if x.isdigit()] 
N,A,B= [res[i] for i in (0,1,2)]
if 1<=N<=20 and 1<=A<=50 and 1<=B<=50:
    x=N*A
    if x>B:
        print(B)
    else:
        print(x)

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

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

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

print(min(z, x*y))

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

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

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

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 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 LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    n, a, b = LI()
    print(min(a*n, b))

main()

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

print(min(N*A,B))

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

train_cost = N * A
taxi_cost = B

print(min(train_cost, taxi_cost))

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

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

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):
import sys
sys.setrecursionlimit(10**6)



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







ans = min(a*n, b)

print(ans)

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

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

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

Solution (Python):
N,A,B = map(int,input().split())
bus = N*A
print(bus if B >= bus else 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]
def main():

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

    print(min(N*A,B))
if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = lambda: sys.stdin.readline().rstrip()


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


if __name__ == '__main__':
    solve()

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

print(min(N*A, B))

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

train = inp[0] * inp[1]

if train < inp[2]:
    print(train)
else:
    print(inp[2])

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

ans = n*a

print(min(ans,b))

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

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

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

train = N*A
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(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):
def inp():return map(int,input().split())

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

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

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

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

Solution (Python):

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

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

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin, setrecursionlimit


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


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

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

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

Solution (Python):
import sys


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

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

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

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")











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

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

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

Solution (Python):
import math
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(N*A, B))

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

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

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

Solution (Python):
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush
from fractions import gcd
from math import ceil, floor, sqrt
from copy import deepcopy

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

if __name__ == "__main__":
    main()

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

if cost_train >= cost_bus:
  print(cost_bus)
else:
  print(cost_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().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):



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

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

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

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

c = []

c.append(n*a)
c.append(b)

print(min(c))

Solution (Python):


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

Solution (Python):
l = list(map(int, input().split()))
n=l[0]
a=l[1]
b = l[2]

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

import sys
input = sys.stdin.readline
N,A,B = (int(x) for x in input().split())
train =A *N
taxi =B
print(min(train,taxi))

Solution (Python):

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

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

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

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

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

print(min(a*b, c))

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

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

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

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

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


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

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

Solution (Python):
def tort(n, a, b):

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

Solution (Python):
import sys

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

    A = N * A

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

    return


if __name__ == "__main__":
    main()
    sys.exit(0)

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

Solution (Python):
def i():
	return int(input())
def i2():
	return map(int,input().split())
def s():
	return str(input())
def l():
	return list(input())
def intl():
	return list(int(k) for k in input().split())

n,a,b=i2()
value=min(n*a,b)
print(value)

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):
import itertools
import math
import fractions
import functools
import copy

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

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

Solution (Python):

"""
Created on Tue May 12 14:07:41 2020

@author: shinba
"""


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

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

Solution (Python):
import sys
import math
import bisect

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

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


def lcm(a, b):
    return a * b // gcd (a, b)





N,A,B  =  inputIL()

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

a = A * N
ans = min(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
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N, A, B = M()
print(min(N*A, B))

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