v, a, t = map(int, input().split())
u = v - a * t
print(u)

import java.util.*;
public class Main {
    static int countMatches(List<String> grid1, List<String> grid2) {
        int count = 0;
        int m = grid1.size();
        int n = grid1.get(0).length();
        int[][] g1 = new int[m][n];
        int[][] g2 = new int[m][n];
        int[][] orMap = new int[m][n];
        for(int i=0; i<m; i++){
            char[] str1 = grid1.get(i).toCharArray();
            char[] str2 = grid2.get(i).toCharArray();
            for(int j=0; j<n; j++){
                g1[i][j] = str1[j] - '0';
                g2[i][j] = str2[j] - '0';
            }
        }
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                orMap[i][j] = g1[i][j] | g2[i][j];
            }
        }
        for(int i=0; i<m; i++){
            for(int j=0; j<n; j++){
                if(orMap[i][j] == 1 && dfs(g1, g2, orMap, i, j)) count++;
            }
        }
        return count;
    }

    private static boolean dfs(int[][] g1, int[][] g2, int[][] orMap, int i, int j) {
        int m = orMap.length;
        int n = orMap[0].length;
        orMap[i][j] = 0;
        boolean up = true, down = true, left = true, right = true;
        if(i > 0 && orMap[i-1][j] == 1) up = dfs(g1, g2, orMap, i-1, j);
        if(i < m - 1 && orMap[i+1][j] == 1) down = dfs(g1, g2, orMap, i+1, j);
        if(j > 0 && orMap[i][j-1] == 1) left = dfs(g1, g2, orMap, i, j-1);
        if(j < n - 1 && orMap[i][j+1] == 1) right = dfs(g1, g2, orMap, i, j+1);

        return g1[i][j] == 1 && g2[i][j] == 1 && up && down && left && right;
    }

import math

def closestColor(pixels):
    pure_colors = {
        "Black": (0, 0, 0),
        "White": (255, 255, 255),
        "Red": (255, 0, 0),
        "Green": (0, 255, 0),
        "Blue": (0, 0, 255)
    }

    def distance(c1, c2):
        return sum((a - b) ** 2 for a, b in zip(c1, c2))

    results = []
    
    for pixel in pixels:
        rgb = (int(pixel[i:i+8], 2) for i in (0, 8, 16))
        closest = min(pure_colors.items(), key=lambda x: distance(rgb, x[1]))

        min_dist = distance(rgb, closest[1])
        ties = [name for name, color in pure_colors.items() if distance(rgb, color) == min_dist]

        results.append("Ambiguous" if len(ties) > 1 else ties[0])

    return results

Strictly follows plagiarism🌚