#include<bits/stdc++.h>
    #define ll long long
    #define INF 1e9 + 7
    #define fast_io ios_base::sync_with_stdio(false)
    #define cine cin.tie(NULL)
    #define in(x) cin>>x
    #define op(x) cout<<x<<"\n"
    #define pb(x) push_back(x);
    using namespace std;
    ll power(ll x,ll y)
    {
        ll temp;
        if( y == 0)
            return 1;
        temp = power(x, y/2);
        if (y%2 == 0)
            return temp*temp;
        else
            return x*temp*temp;
    }
    void removeDups(ll arr[], ll n)
    {
        // Hash map which will store the
        // elements which has appeared previously.
        unordered_map<ll, bool> mp;
        vector<ll>v;
        for (ll i = 0; i < n; ++i) {

            // Print the element if it is
            // there in the hash map
            if (mp.find(arr[i]) == mp.end()) {
                v.pb(arr[i]);
            }

            // Insert the element in the hash map
            mp[arr[i]] = true;
        }
        cout<<n-v.size()<<"\n";
    }
    bool isPowerOfTwo (int x)
    {
        /* First x in the below expression is for the case when x is 0 */
        return x && (!(x&(x-1)));
    }
    void SieveOfEratosthenes(ll n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        bool prime[n+1];
        memset(prime, true, sizeof(prime));

        for (ll p=2; p*p<=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if (prime[p] == true)
            {
                // Update all multiples of p greater than or
                // equal to the square of it
                // numbers which are multiple of p and are
                // less than p^2 are already been marked.
                for (ll i=p*p; i<=n; i += p)
                    prime[i] = false;
            }
        }

        // Print all prime numbers
        for (ll p=2; p<=n; p++)
           if (prime[p])
              cout << p << " ";
    }
    bool isPrime(ll n)
    {
        if (n <= 1)
            return false;
        for (ll i = 2; i < n; i++)
            if (n % i == 0)
                return false;

        return true;
    }
    int maximumXOR(int arr[] , int n , int k)
    {
        // Compute XOR value of first subarray of size k
        int current_xor = 0 ;
        for (int i = 0 ; i < k ; i++)
            current_xor  = current_xor ^ arr[i];

        // Traverse rest of the array
        int max_xor = current_xor;
        for (int i = k ; i < n; i++)
        {
            // First remove previous subarray's first
            // element
            current_xor = current_xor ^ arr[i-k];

            // add new element
            current_xor = current_xor ^ arr[i];

            // Update maximum xor value
            max_xor = max(max_xor, current_xor);
        }

        return max_xor;
    }
    ll countDivisibles(ll A, ll B, ll M)
    {
        // Add 1 explicitly as A is divisible by M
        if (A % M == 0)
            return (B / M) - (A / M) + 1;

        // A is not divisible by M
        return (B / M) - (A / M);
    }
    string LCSubStr(string X, string Y)
    {
      // Find length of both the strings.
      int m = X.length();
      int n = Y.length();

      // Variable to store length of longest
      // common substring.
      int result = 0;

      // Variable to store ending point of
      // longest common substring in X.
      int end;

      // Matrix to store result of two
      // consecutive rows at a time.
      int len[2][n];

      // Variable to represent which row of
      // matrix is current row.
      int currRow = 0;

      // For a particular value of i and j,
      // len[currRow][j] stores length of longest
      // common substring in string X[0..i] and Y[0..j].
      for (int i = 0; i <= m; i++) {
          for (int j = 0; j <= n; j++) {
              if (i == 0 || j == 0) {
                  len[currRow][j] = 0;
              }
              else if (X[i - 1] == Y[j - 1]) {
                  len[currRow][j] = len[1 - currRow][j - 1] + 1;
                  if (len[currRow][j] > result) {
                      result = len[currRow][j];
                      end = i - 1;
                  }
              }
              else {
                  len[currRow][j] = 0;
              }
          }

          // Make current row as previous row and
          // previous row as new current row.
          currRow = 1 - currRow;
      }

      // If there is no common substring, print -1.
      if (result == 0) {
          return "-1";
      }

      // Longest common substring is from index
      // end - result + 1 to index end in X.
      return X.substr(end - result + 1, result);
    }
    int main()
    {
       //fast_io;
       //cine;
       //code
       ll n,a,b;
       cin>>n>>a>>b;
       cout<<min(n*a,b);
    }


Measured memory_bytes: 256