import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Stack;

public class Solve {
    public static void main(String[] args) throws IOException {
        BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
        String expression = userInput.readLine();

        //System.out.println(evaluate(expression));

        solveExpression(expression);
    }

    static char openBracket = '(';
    static char closeBracket = ')';
    static String innerExpression = "";
    static String tempResult;
    static int startIndex = 0;
    static int endIndex = 0;

    private static void solveExpression(String expression) {
        if (expression.matches("\\d*")) {
            System.out.println(expression);
            return;
        }

        if (!expression.contains(String.valueOf(openBracket)) && !expression.contains(String.valueOf(closeBracket))) {
            System.out.println(evaluate(expression));
            return;
        }

        Stack<Character> parenthesisOccurrence = new Stack<>();
        Stack<Integer> parenthesisIndexes = new Stack<>();

        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == openBracket) {
                parenthesisOccurrence.push(c);
                parenthesisIndexes.push(i);
            } else {
                if (parenthesisOccurrence.size() > 0
                        && c == closeBracket
                        && parenthesisOccurrence.peek() == openBracket) {
                    startIndex = parenthesisIndexes.peek();
                    endIndex = i + 1;

                    innerExpression = expression.substring(startIndex, endIndex);
                    tempResult = innerExpression.split("[\\(\\)]")[1];

                    expression = expression.replace(expression.substring(startIndex, endIndex), String.valueOf(evaluate(tempResult)));
                    break;
                }
            }
        }
        solveExpression(expression);
    }

    static BigInteger evaluate(String s){
        BigInteger result = BigInteger.ZERO;
        BigInteger firstNumber;
        BigInteger secondNumber;
        String[] numbers;
        if(s.contains("+")){
            numbers = s.split("\\+");
            firstNumber = new BigInteger(numbers[0]);
            secondNumber = new BigInteger(numbers[1]);

            result = firstNumber.add(secondNumber);
        } else if(s.contains("-") && !s.contains("+") && !s.contains("*")){
            numbers = s.split("\\-");
            firstNumber = new BigInteger(numbers[0]);
            secondNumber = new BigInteger(numbers[1]);

            result = firstNumber.subtract(secondNumber);
        }else if(s.contains("*")){
            numbers = s.split("\\*");
            firstNumber = new BigInteger(numbers[0]);
            secondNumber = new BigInteger(numbers[1]);

            result = firstNumber.multiply(secondNumber);
        }

        return result;
    }
}