#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>  
#include <functional>
#define ll long long int
#define ld long double
#define pb push_back
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define mod 1000000007
#define MAX 100009
#define endl '\n'
#define mp make_pair
#define INF 1000000000
#define fast ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
#define ff first
#define ss second
#define ps(x,y) fixed<<setprecision(y)<<x
#define pii pair<long long int,long int>
#define mii map<long long int,long long int>
#define setbits(x) __builtin_popcountll(x)			//counts no of ones in binary representation
#define w(t) 	int t; cin>>t; while(t--)
 
using namespace __gnu_pbds;
using namespace std;

typedef tree<long long int, null_type, less<long long int>, rb_tree_tag,  
            tree_order_statistics_node_update>  
		ordered_set;
//         https://www.geeksforgeeks.org/order_of_key-in-c&&find_by_order/

///////////////////////////////////BFS AND DFS FROM HACKEREARTH///////////////////////

ll par[MAX];
//ll size[MAX];

ll parent(ll x){
	if(x==par[x])
		return x;
	
	ll y = parent(par[x]);		//gives ultimate parent
	par[x]=y;					//path compression
	return y;
}

void union1(ll a,ll b){
	ll x=parent(a);
	ll y=parent(b);
	if(x==y)
		return;
	par[x]=y;
	//size[y]+=size[x];
	//size[x]=0;
}

void init(){
    for(ll i=0;i<MAX;i++){
        par[i]=i;
        //size[i]=1;
    }
}

//////////////////////////////////////////////// DFS //////////////////////////////////////////////////////////////////
/*
 bool visited[MAX];
 //long long int parent[MAX];   
void dfs(vector<long long int>adj[],long long int i)
{
    visited[i]=true;
    for(auto j:adj[i])
    {
        if(!visited[j])
        {
            dfs(adj,j);
        }
    }
}
 
 
*/

bool sortinrev(const pair<int,int> &a,  		//for vector of pairs
               const pair<int,int> &b) 
{ 
       return (a.first < b.first); 
}

// Driver function to sort the vector elements 
// by second element of pairs 
bool sortbysec(const pair<int,int> &a, 
              const pair<int,int> &b) 
{ 
    return (a.second < b.second); 
} 

//strtok() used for tokenizing string - gives 1st token of string - takes (char *) and deliminator as input

int stringToDecimal(string s){
	int ans=0;
	int base=1;
	for(int i=s.length()-1;i>=0;i--){
		ans = ans + (s[i] - '0')*base;
		base = base*2;
	}
	return ans;
}

void sort1(vector<string> &s, int n) 				//sort string by its length
{ 
    for (int i=1 ;i<n; i++) 
    { 
        string temp = s[i]; 
  
        // Insert s[j] at its correct position 
        int j = i - 1; 
        while (j >= 0 && temp.length() < s[j].length()) 
        { 
            s[j+1] = s[j]; 
            j--; 
        } 
        s[j+1] = temp; 
    } 
} 

bool isprime(ll n){			//to check whteher no is prime or not
	if (n <= 1) 
        return false; 
    if (n <= 3) 
        return true; 
  
    // This is checked so that we can skip 
    // middle five numbers in below loop 
    if (n % 2 == 0 || n % 3 == 0) 
        return false; 
  
    for (int i = 5; i * i <= n; i = i + 6) 
        if (n % i == 0 || n % (i + 2) == 0) 
            return false; 
  
    return true; 
}


void SieveOfEratosthenes(int n) 			//best way to find primes O(nlog(logn))
{ 
	int cnt=0;
    // 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 (int 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 (int i=p*p; i<=n; i += p) 
                prime[i] = false; 
        } 
    } 
  	for(int i=2;i<=n;i++){
		//if(x==n)	break;
		if(prime[i]){
			cnt++;
		//	x++;
		}
	}
	cout<<cnt;
} 

ll modularExponentiation(ll x,ll n,ll M)
{
    if(n==0)
        return 1;
    else if(n%2 == 0)        //n is even
        return modularExponentiation((x*x)%M,n/2,M);
    else                             //n is odd
        return (x*modularExponentiation((x*x)%M,(n-1)/2,M))%M;
}

//ll d, x, y;
void extendedEuclid(ll A, ll B) {
    /*if(B == 0) {
        d = A;
        x = 1;
        y = 0;
    }
    else {
        extendedEuclid(B, A%B);
        int temp = x;
        x = y;
        y = temp - (A/B)*y;
    }	*/
}

ll modInverse(ll A, ll M)
{
    extendedEuclid(A,M);
   // return (x%M+M)%M;    //x may be negative
}

//string to int done by stringstream class geek object, stoi/atoi(C style function- works only for C-style strings (character array and string literal)), 
//

bool mycomp(string a, string b){				//for alphabetical sorting of strings ------ use with sort function
	//returns 1 if string a is alphabetically 
	//less than string b
	//quite similar to strcmp operation
	return a<b;
}


int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
 //   w(t){
    	ll a,b,n;
    	cin>>a>>b>>n;
    	ll x;
    	if(n<b){
    		ll ans=a*n;
    		ans/=b;
    		cout<<ans;
		}
		else{
			ll ans=a*(b-1);
			ans/=b;
			cout<<ans;
		}
//	}
}








Measured memory_bytes: 3644