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

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

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

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

t = int(A) * int(N)
d = int(B)
print(min(t,d))

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

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

Solution (Python):
x, y, z = input().split()

n = int(x)
a = int(y)
b = int(z)

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

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

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

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

print(min(A*N, B))

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

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

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

Solution (Python):



NAB = input().split(' ')
N = int(NAB[0])
A = int(NAB[1])
B = int(NAB[2])

print(min(B, A * N))

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

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

Solution (Python):

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

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

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

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

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

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

print(solve())

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

Solution (Python):
import numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    [N, A, B] = string_to_int(inputs[0])

    train = N * A
    taxi = B

    return min(train, taxi)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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

print(ans)

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

input = sys.stdin.readline

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

print(min(A * N , B))

Solution (Python):
N, A, B = map(int, raw_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())
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())
pa = n * a
print(min(pa, 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 = map(int, input().split())

den = N * A
tax = B

print(min(den, tax))

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)







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

solve()

Solution (Python):
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    N, A, B = InputToInt()
    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(n*a if n*a < b else b)


if __name__ == "__main__":
    main()

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

Solution (Python):
def swap(a,b):
    return (b,a)

def gcd(a,b):
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):

"""
AtCoder A
"""

import sys, math, random
import numpy as np








inf = 10**20
eps = 1.0 / 10**10
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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LLS(): return [list(sys.stdin.readline().rstrip()) for _ in sys.stdin.readlines()]
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 = list(map(int,input().split()))
    if N*A>B:
        print(B)
    else:
        print(A*N)
    
    
if __name__ == "__main__":
    main()

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

ans = min(N*A, B)

print(ans)

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

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):
import sys
from fractions import gcd
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

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




if __name__ == "__main__":
    main()

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

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

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

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

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

print( min(N*A, B) )

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

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

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

Solution (Python):
N,A,B=map(int,input().split())
print(min(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 numpy as np
import math
n, a, b = (int(i) for i in 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):


from itertools import combinations
import math
import datetime
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(A * N, B))

Solution (Python):
n1, n2, n3 = [int(i) for i in input().split()]

r1 = n3

if (n1 * n2) < n3:
    r1 = n1 * n2

print(r1)

Solution (Python):
from sys import stdin

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

input = lambda: stdin.readline()
main()

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

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())
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 = (int(_) for _ in input().split())  
print(min(N*a, b))

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

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

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

Solution (Python):
N, S, K = list(map(int, input().split()))
print(min([N*S, K]))

Solution (Python):
from sys import stdin

N, A, B = [int(x) for x in stdin.readline().rstrip().split()]
print(min(A * N, B))

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

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

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

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect
import heapq


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

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

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""


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

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

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

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

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

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

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N, A, B] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print min(A * N,  B)

if __name__ == '__main__':
    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(a*n, b))

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

print(min(A*N, B))

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

print(min(n*a, b))

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

print(min(n*a, b))

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

print(min(int(x[0])*int(x[1]), int(x[2])))

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

Solution (Python):
import sys
sys.setrecursionlimit(1000000)
 
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(x) for x in input().split())
print(min(B, A*N))

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

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

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

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

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

Solution (Python):
from sys import stdin
import math
import fractions
from collections import deque
from collections import Counter
import itertools

INF = 10 ** 10

N, A, B = [int(x) for x in stdin.readline().rstrip().split()]

ans1 = A*N
ans2 = B

print(min(ans1, ans2))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

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




main()

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

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

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

print(min(A * N, B))

Solution (Python):


n,a,b = (int(x) for x in input().split())
x = min(n*a, b)
print(x)

Solution (Python):




def solve():
    N, A, B = list(map(int, input().split()))
    return min(N * A, B)


def main():
    print(solve())


if __name__ == "__main__":
    main()

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

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

Solution (Python):
N, A, B = map(int, input().split())
print(min(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
input = sys.stdin.readline
sys.setrecursionlimit(1000000)


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

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

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

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



import sys

def rl(proc=None):
    if proc is not None:
        return proc(sys.stdin.readline())
    else:
        return sys.stdin.readline().rstrip()

def srl(proc=None):
    if proc is not None:
        return list(map(proc, rl().split()))
    else:
        return rl().split()

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

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




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

t = n  * a

if t >= b:
    print(b)
    exit()
print(t)

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


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


X = N * A

print(min(X, B))

Solution (Python):
import sys

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

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(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 numpy as np

a = input().split(" ")
N = int(a[0])
A = int(a[1])
B = int(a[2])

print(min(A*N,B))

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

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

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

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

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

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

Solution (Python):
import sys

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

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


main()

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

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

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

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

print(min(A*N,B))

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

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

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

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

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

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

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

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

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

Solution (Python):
n, a, b = [int(elem) for elem in 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(' '))
tr = n*a
tax = b
print(min(tr,tax))

Solution (Python):
import math, string, itertools, fractions, heapq, collections, re,  array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
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 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 _pf(s): return print(s, flush=True)

N, A , B = LI()

print(min(N*A, B))

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

print(min(N*A, B))

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


print(min(n * m,b))

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

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

Solution (Python):

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

print(min([N*A,B]))

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

def rli():
    return list(map(int, input().split()))

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
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())
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())

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, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy,copy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

if  __name__=='__main__':
    main()

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


def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  N, A, B = readInts()
  if A * N < B:
    print(A * N)
  else:
    print(B)

if __name__ == "__main__":
  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())
print(min(n * a, b))