993 992 991
 100 1 10
 960 935 994
 99 8 99
 60 16 1
 759 10 258
 24 19 9
 196 169 144
 1000 999 1
 945 812 917
 1000 100 10
 500 300 300
 888 777 1000
 2 1 4
 24 12 12
 767 2 514
 2 1 2
 1000 1 1
 5 2 1
 70 32 1
 765 123 899
 17 7 10
 5 4 10
 888 777 888
 66 38 4
 1000 999 1000
 9 3 300
 244 87 4
 765 123 45
 1000 1 1000
 305 203 421
 100 10 1
 64 12 8
 894 1 999
 2 1 1
 18 14 10
 6 2 4
 888 777 1
 27 26 1
 2 1 3
 5 1 5
 7 3 200
 561 31 917
 17 10 7
 93 74 831

1
 990
 27
 1127
 3
 19325
 3
 24
 1
 151
 90
 200
 143
 4
 12
 196605
 2
 999
 2
 2
 4693
 15
 3
 127
 3
 2
 600
 8
 235
 999000
 212
 9
 35
 892107
 1
 3
 8
 1
 1
 3
 20
 267
 15678
 5
 214


import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

public class codeforcesDP {
    static int MOD = 1000000007;
    static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {

        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int temp = (c*a+b-1)/b;
        temp = (temp*a-a*c)/a;
        System.out.println(temp);

    }


    static int binarySearch(int[] arr, int x){
        int low = 0;
        int high = arr.length-1;
        int mid;
        while(low < high){
            mid = (low + high)/2;
            if(arr[mid] == x)
                return mid;
            if(arr[mid] < x){
                low = mid + 1;
            }
            else {
                high = mid-1;
            }
        }
        if(arr[low] > x)
            return low-1;
        return low;
    }

    static int binarySearch(long[] arr, long x){
        int low = 0;
        int high = arr.length-1;
        int mid;
        while(low < high){
            mid = (low + high)/2;
            if(arr[mid] == x)
                return mid;
            if(arr[mid] < x){
                low = mid + 1;
            }
            else {
                high = mid-1;
            }
        }
        if(arr[low] > x)
            return low-1;
        return low;
    }

    static int binarySearchUB(int[] arr,int x){
        int low = 0;
        int high = arr.length-1;
        int mid;
        int ans = 0;
        int upper = 0;
        while(low <= high){
            mid = (low + high)/2;
            if(arr[mid] == x){
                low = mid + 1;
                ans = mid;
            }
            else if(arr[mid] < x){
                low = mid+1;
                upper = low;
            }
            else {
                high = mid - 1;
            }
        }
        if(arr[ans] == x)
            return ans;
        return upper;
    }

    static int binarySearchLB(int[] arr,int x){
        int low = 0;
        int high = arr.length-1;
        int mid;
        int ans = 0;
        int lower = 0;
        while(low <= high){
            mid = (low + high)/2;
            if(arr[mid] == x){
                ans = mid;
                high = mid - 1;
            }
            else if(arr[mid] < x){
                low = mid + 1;
            }
            else {
                high = mid - 1;
                lower = high;
            }
        }
        if(arr[ans] == x)
            return ans;
        return lower;
    }





    static int[] prefixSum(int[] arr){
        int[] ans = new int[arr.length];
        ans[0] = arr[0];
        for(int  i = 1;i<arr.length;i++){
            ans[i] = ans[i-1] + arr[i];
        }
        return ans;
    }

    static long[] prefixSumLong(long[] arr){
        long[] ans = new long[arr.length];
        ans[0] = arr[0];
        for(int  i = 1;i<arr.length;i++){
            ans[i] = ans[i-1] + arr[i];
        }
        return ans;
    }
    static int kadane(int[] arr){

        int max = Integer.MIN_VALUE;
        int tempMax = 0;

        for(int i = 0;i<arr.length;i++){
            if(tempMax + arr[i] < arr[i]){
                tempMax = arr[i];
            }
            else {
                tempMax += arr[i];
            }
            if(tempMax > max){
                max = tempMax;
            }
        }
        return max;
    }




    static void printArr(long[] arr){
        for(long i : arr)
            System.out.print(i + " ");
        System.out.println();
    }

    static void printDP(int[][] dp){
        for(int i=0;i<dp.length;i++){
            for(int j = 0;j<dp[0].length;j++){
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }

    }

    static int helpMe(int index, char[] ch, int length, int[][] dp){

        char c = 'Q';
        if(length == 1)
            c = 'A';
        if(length == 3)
            return 1;
        if(index == ch.length)
            return 0;
        if(dp[index][length] != -1)
            return dp[index][length];
        int considering = 0;
        if(c == ch[index])
            considering = helpMe(index+1,ch,length+1,dp);
        int notConsidering = helpMe(index+1,ch,length,dp);
        dp[index][length] = considering+notConsidering;
        return considering+notConsidering;
    }

    static int[] takeInputInt(int n){
        int[] input = new int[n];
        for(int i=0;i<n;i++){
            input[i] = sc.nextInt();
        }
        return input;
    }
    static long[] takeInputLong(int n){
        long[] input = new long[n];
        for(int i=0;i<n;i++){
            input[i] = sc.nextLong();
        }
        return input;
    }

}
