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
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

def main():
    n, a, b = input_nums()
    if n * a > b:
        print(b)
    else:
        print(n * a)

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

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

Solution (Python):
import sys

n, a, b = map(int, sys.stdin.readline().split())

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

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

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

Aans = A*N

if Aans > B:
    print(B)
else:
    print(Aans)

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

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

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

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

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

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

import sys


def solve(N: int, A: int, B: int):
    print(str(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(n*a, b))

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

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

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

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

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

Solution (Python):

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

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

Solution (Python):
n,a,b = map(int, input().split())
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 = [int(x) for x in input().split()]
an = a * n
print(an if an < b else b)

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

print(min(N*A,B))

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

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

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

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

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

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

print(ans)

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

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

print(min(n*a,b))

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

Solution (Python):

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


train = N * A
taxi = B
print(min(train, taxi))

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

print(ans)

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

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

print(min(a * n, b))

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

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

x = n * a
y = b
print(min(x,y))

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

tmp_1 = a*n

tmp_2 = b

if tmp_1 >= tmp_2:
    print(tmp_2)
else:
    print(tmp_1)

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

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

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

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

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

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

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

print(solve())

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

Solution (Python):


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

    print(min(train, taxi))

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

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

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

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

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

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

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

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


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

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

print(min(N*A,B))

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

Solution (Python):

import sys


def main():
    N,A,B = [int(s) for s in input().split()]
    print(B) if B <= A*N else print(A*N)

if __name__ == '__main__':
    main()

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

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

print(min(N * A, B))

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

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

Solution (Python):
import os, sys, re, math

(N, A, B) = [int(n) for n in input().split()]

print(min(N * A, B))

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

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

print(min(l))

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

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

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

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

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

Solution (Python):
from sys import stdin

n, a, b = (int(x) for x in stdin.readline().rstrip().split())
print(n*a if n*a <= b else b)

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

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

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

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

print(min(n*a, b))

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

print(min(n*a, b))

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

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

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

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

print(min(a*n,b))

Solution (Python):
N, A_train, B_taxi = map(int, input().split())
ans = min(B_taxi, N * A_train)
print(ans)

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

Solution (Python):





import sys

ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

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

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

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

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

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

print(min(N * A, B))

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

Solution (Python):



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

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

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

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

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

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

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

print(min(c))

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

Solution (Python):
number = input().split(" ")
N = int(number[0])
A = int(number[1])
B = int(number[2])
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())

MIN = min(N*A, B)

print(MIN)

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

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

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

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

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

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

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

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

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

train = n * a
tax = b

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

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

Solution (Python):






import math
import statistics
import numpy as np
import queue
import itertools

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

i = n*a

if i >= b:
    print(b)
elif i < b:
    print(i)

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())
a=n*a
if(a<=b):
  print(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 accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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

N, A, B = MAP()

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

Solution (Python):
import sys

n, a, b = map(int, sys.stdin.readline().split())

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

if __name__ == '__main__':
    ans = main()
    print(ans)

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

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

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

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

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

Solution (Python):


[n, a, b] = raw_input().split()

print min(int(n) * int(a), int(b))

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

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

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

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

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

print("{}".format(n*a if n*a<b else b))

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

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

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

train = N * A
taxy = B

print(min([train,taxy]))

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

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

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

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

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

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

train = N * A

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

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

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

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

Solution (Python):
n,a,b=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()]

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


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


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

n,a,b = get_nums_l()

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

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

Solution (Python):



import sys
input = sys.stdin.readline


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




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









print(solve(N, A, B))

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

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

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):
import sys
row = sys.stdin.readline
def read_ints(row):
    return list(map(int, row().split()))
  
X,A,B = read_ints(row)
print(min(X*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(a*n if a*n < 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())
if n*a>b:
    print (b)
elif n*a<b:
    print (n*a)
else:
    print (b)

Solution (Python):




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

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

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

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

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

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

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

Solution (Python):
from time import sleep
n, a, b = map(int, input().split())
sleep(1.98)
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())
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(n*a,b))

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

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

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

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

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

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

if N * A > B:
  r = B
else:
  r = N * A

print(int(r))

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

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

Solution (Python):
import sys

input = sys.stdin.readline


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



if __name__ == '__main__':
    Solution().main()

Solution (Python):
"""
author : halo2halo
date : 12, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

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

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

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

train = N * A
taxi = B

print(min(taxi, train))

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

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

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

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

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

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

Solution (Python):
n, a, b = [int(_) for _ 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,raw_input().split())
if N*A<=B:
  print N*A
else:
  print B

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


if __name__ == '__main__':
    main()

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

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

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