/*author ADITYA BANSAL
         MNNIT ALLAHABAD     */
#include<bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp> 
//using namespace boost::multiprecision; 
using namespace std;

#define watch(x) cerr<<(#x)<<"is"<<x<<nl;
#define ll long long
#define mod 1000000007
#define fast  ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define fi(a,b) for(ll i=a; i<b; i++)
#define fk(a,b) for(ll k=a; k<b; k++)
#define fri(a,b) for(ll i=a; i>b; i--)
#define fj(a,b) for(ll j=a; j<b; j++)
#define ffi(a,b) for(ll i=a;i*i<=b;i++)
#define mp make_pair
#define ff first 
#define all(v) (v).begin(),(v).end()
#define ss second
#define pb push_back
#define mem(v) memset((v),0,sizeof(v));
#define pll pair<ll,ll>
#define mll map<ll,ll>
#define sll set<ll>
#define vll vector<ll>
#define maxi(a,b,c) max(a,max(b,c))
#define mini(a,b,c) min(a,min(b,c))
#define md(a,b)  ((a%mod)*(b%mod)+mod)%mod 
#define ad(a,b)  (a%mod+b%mod+mod)%mod
#define pob pop_back
#define nl endl

ll const N=1000002;
ll prime[N]{0};
ll  tot[N + 5]; 
ll fact[N]{0};
ll invfact[N]{0};
vector<ll> primes;

/*----------------------<<MATRIX EXPONENTIATION>>--------------*/
const ll M=3;

void matrix_multi(ll A[M][M],ll B[M][M]){
    ll C[M][M];
    
    for(ll i=0;i<M;i++){
        
        for(ll j=0;j<M;j++){
            
            C[i][j]=0;
            for(ll k=0;k<M;k++){
                (C[i][j]+=(A[i][k])*(B[k][j]))%=(mod-1);
            }  }    }
            
             for(ll i=0;i<M;i++){
        
        for(ll j=0;j<M;j++){
            A[i][j]=C[i][j]%mod;
        }
             }
            
}
void powmat(ll B[M][M], ll A[M][M], ll n)
{
     while(n){
         if(n&1)
         matrix_multi(B,A);
         matrix_multi(A,A);
         n>>=1;
     }
}
/*-----------------------<<PRIMAITY>>-------------------------*/
bool isprime(ll n)
{                if(n<2) return (false);
	if(n==2)
	return(true);
	if(n%2==0)
	return(false);
	for(ll i=3;i*i<=n;i+=2)
	{
		if(n%i==0)
		return(false);
	}
	return(true);
}
/*-------------------<<EULER TOTIENT FUNC>>---------------------*/
                 /* < <  SINGLE ELEMENT   > >  */ 
ll phi(ll n){
   ll res=n;
   ffi(2,n){
  if(n%i==0){
    while(n%i==0)
    n/=i;
    res-=res/i;
}
}
if(n>1){
  res-=res/n;                 
} return res;
}

/*-------------------<<EULER TOTIENT FUNC>>---------------------*/

void computeTotient() 
{ 
    for (ll i = 1; i <= N; i++) 
        tot[i] = i;  
  
    for (ll p = 2; p <= N; p++) { 
        if (tot[p] == p) { 
            tot[p] = p - 1; 
            for (ll i = 2 * p; i <= N; i += p) { 
                tot[i] = (tot[i] / p) * (p - 1); 
            } 
        } 
    } 
} 
/*------------------------<<SEIVE>>-----------------------------*/
void seive(){ prime[1]=prime[0]=1;
    for(ll i=2;i*i<=N;i++)
    {
        if(!prime[i])
        {
            for(ll j=i*i;j<=N;j+=i)
            prime[j]=1;
        }
    }
  //  primes.pb(0);
    for(ll i=2;i<N;i++){
        
        if(!prime[i])
       primes.push_back(i); 
    }
  
}
/*--------------------<<BINARY EXPONENTIATION>>--------------------*/
ll power(ll a,ll n){
  ll res=1;
  while(n){
      if(n&1) res= md(res,a);
     n>>=1; 
     a= md(a,a);
  }
    return res;
}

/*--------------------<<BINARY SELF EXPONENTIATION>>--------------------*/
ll pows(ll a,ll n,ll m){
  ll res=1;
  while(n){
      if(n&1) res= ((res%m)*(a%m))%m;
     n>>=1; 
     a= ((a%m)*(a%m))%m;
  }
    return res;
}

/*--------------------- < <  FACTORIAL  >  >----------------------*/
void factorial(void){
 fact[0]=invfact[0]=1;
 fi(1,N){
      fact[i]=md(fact[i-1],i);
      invfact[i]=power(fact[i],mod-2);
 }
}

/*-------------------<<CODE STARTS HERE>>------------------------*/
                   
void solve(){ll a,b, k,n;
cin>>n>>a>>b;
          
    cout<<min(b,n*a)<<nl;      
          
               
}
signed main(){ fast
         // computeTotient();
       // seive();
        // factorial();
       
      //   ll  t; cin>>t; while(t--)
{ solve();}
    return 0;
}

Measured memory_bytes: 256