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


def solve(N: int, A: int, B: int):
    if A * N < B:
        print(A*N)
    else:
        print(B)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(N, A, B)

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):

import sys


def solve(N: int, A: int, B: int):
    print(min(N*A, B))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(N, A, B)

if __name__ == '__main__':
    main()

Solution (Python):

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

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

d = n * a
t = b

print(min(d, t))

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

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

Solution (Python):


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

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

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


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

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

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

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

print(min(A * N, B))

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

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().rstrip()
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
import heapq
INF = float("inf")
sys.setrecursionlimit(10**7)

dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def mi(): return map(int, input().split())
def ii(): return int(input())


N, A, B = mi()

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

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

print(min(n*a, b))

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

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

print(min(N * A, B))

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

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

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

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

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

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

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



def read_h(typ=int):
    return list(map(typ, input().split()))


def read_v(n, m=1, typ=int):
    return [read_h() if m > 1 else typ(input()) for _ in range(n)]


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


if __name__ == '__main__':
    main()

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

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

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

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

print(min(N * A, B))

Solution (Python):
import math
import string
import itertools
import fractions
import heapq
import collections
import re
import array
import bisect
import sys
import random
import time
inf = 10**9


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

    print(min(n*a, b))


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
import sys

fin = sys.stdin.readline

n, a, b = map(int, fin().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().strip().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):

import sys
from operator import itemgetter

from fractions import gcd

from math import ceil, floor

from copy import deepcopy

from itertools import accumulate






from collections import Counter
import math
from functools import reduce
sys.setrecursionlimit(200000)

input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(x): print("debug: ", x, file=sys.stderr)








def solve(N: int, A: int, B: int):
    if N * A >= B:
        print(B)
    else:
        print(N*A)
    return


def iterate_tokens():
    for line in sys.stdin:
        for word in line.split():
            yield word


def main():
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(N, A, B)


if __name__ == '__main__':
    main()

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

train = A*N
taxi = B

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

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
 
    n, a, b = [int(i) for i in 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())

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

x=min(a*n,b)

print(x)

Solution (Python):

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

print(min(a*n, b))

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

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

print( min(n*a,b) )

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

Solution (Python):
def li():
    return list(map(int, input().split()))


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

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

Solution (Python):
N, A, B = [int(n) for n in 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())

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

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

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

import sys


def solve(N: int, A: int, B: int):
    print(min(A*N,B))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(N, A, B)

if __name__ == '__main__':
    main()

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

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

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

print(min(n * a, b))

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

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

Solution (Python):
def solve(N, A):
    pass

def main():
    N, A, B =[int(x) for x in input().split()]

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

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


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N,A,B=MAP()

print(min(N*A, B))

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

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

Solution (Python):
n, a, b = map(int,input().split())
print(min(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):
from collections import deque
from itertools import accumulate
import sys
sys.setrecursionlimit(10**6)

mo=10**9+7

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

ans=min(n*a,b)

print(ans)

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


main()

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

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

d = n*a
t = b
print(min(d,t))

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

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

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

print(min(N * A, B))

Solution (Python):

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

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

print(min(N* A,B))

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

print(min(n*a, b))

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

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

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


main()

Solution (Python):
import sys

stdin = sys.stdin

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

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

Solution (Python):
import numpy as np
import copy


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

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

Solution (Python):

import time
import re
import math
import fractions

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

start=time.time()
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(b, n*a))

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import random
input = sys.stdin.readline






















def main():

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

	a = N*A
	b=B
	

	

	print(min(a,b))




if __name__ == "__main__":
	main()

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

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

print(min(A * N, B))

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

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

Solution (Python):










import sys
import os
from io import IOBase, BytesIO


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


BUFSIZE = 8192


class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill():
            pass
        return super(FastIO, self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill()
            self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.getvalue())
            self.truncate(0), self.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        py2 = round(0.5)
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2 == 1:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            self.write = lambda s: self.buffer.write(s.encode("ascii"))
            self.read = lambda: self.buffer.read().decode("ascii")
            self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)


def get_array(): return list(map(int, sys.stdin.readline().split()))


def get_ints(): return map(int, sys.stdin.readline().split())


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


if __name__ == "__main__":
    main()

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

Solution (Python):
def cmb(n, r, mod):
    if ( r<0 or r>n ):
        return 0
    r = min(r, n-r)
    return g1[n] * g2[r] * g2[n-r] % mod

mod = 10**9+7 
N = 10**4
g1 = [1, 1] 
g2 = [1, 1] 
inverse = [0, 1] 

for i in range( 2, N + 1 ):
    g1.append( ( g1[-1] * i ) % mod )
    inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
    g2.append( (g2[-1] * inverse[-1]) % mod )


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

ans = min(b,n*a)

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

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

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

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

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

Solution (Python):

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

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

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

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

Solution (Python):
def getlist():
	return list(map(int, input().split()))

N, A, B = getlist()

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

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

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

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


if __name__ == '__main__':
    main()

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

S = A*N
T = B

if S >= T:
    print(T)
else:
    print(S)

Solution (Python):
import sys

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

print(min(N * A, B))

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

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

print(min(a*n,b))

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

print(min(A*N, B))

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

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

print(min(n*a,b))

Solution (Python):
def main():

    """ convenient functions
    
    
    
    
    
    """

    """convenient decorator
    
    
        
        
        
        
        
        
        
        
        
        
    """
    
    
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product 
    
    from math import factorial, ceil, floor
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  
        b, e = 2, 0  
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict 
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
    from copy import deepcopy, copy 
    import operator
    from operator import itemgetter
    
    
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd 
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    
    
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) 
    def modinv(a, p = MOD):
        
        
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        
        
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    
        
        
    
        
        
        
        
        
    
        
        
        
        
    
        
        
    """

    
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    
    
    
    
    
    
    
    """

    if __name__ != '__main__':
        
        sys.stdin = open('sample.txt')

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

    """memo: how to use defaultdict of list
    
    Dic = defaultdict(list)
    
    Dic[x].append(y)
    
    for k, v in Dic.items():
    """

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

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

print(min(a*n,b))

Solution (Python):
import collections

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


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


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, A, B):
    return min(A*N, B)


def main():
    N, A, B = read_int_n()
    print(slv(N, A, B))


if __name__ == '__main__':
    main()

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

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

Solution (Python):
def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]






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

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

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(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().strip().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 input(): return sys.stdin.readline()[:-1]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def MATINT(h): return [list(map(int, input().split())) for _ in range(h)]
def MATSTR(h): return [input() for _ in range(h)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
inf = float('inf')
mod = 10 ** 9 + 7

def main():
    N, A, B = MAP()
    if A*N > B:
        print(B)
    else:
        print(A*N)


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

fin = sys.stdin.readline
N, A, B = [int(elem) for elem in fin().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(b,a*n))