#include <iostream>
#include <fstream>
#include <stack>
#include <vector>

using namespace std;

ifstream fin("evaluare.in");
ofstream fout("evaluare.out");

string expression;
stack<char> operator_stack;
stack<int> operand_stack;
vector<string> polish_expression;

int priority(char operator_) {
    switch (operator_) {
        case '(':
        case ')':
            return 0;
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

string char_to_string(char ch) {
    string s;
    s += ch;
    return s;
}

void pop_operator_stack() {
    char operator_ = operator_stack.top();
    operator_stack.pop();
    polish_expression.push_back(char_to_string(operator_));
}

void convert() {
    for (int i = 0; i < expression.size(); i++) {
        if (isdigit(expression[i])) {
            int value = expression[i] - '0';
            while (isdigit(expression[i + 1])) {
                value = value * 10 + expression[i + 1] - '0';
                i++;
            }
            polish_expression.push_back(to_string(value));
        } else if (expression[i] == '(') {
            operator_stack.push('(');
        } else if (expression[i] == ')') {
            while (operator_stack.top() != '(') {
                pop_operator_stack();
            }
            operator_stack.pop();
        } else if (operator_stack.empty() || priority(expression[i]) >= priority(operator_stack.top())) {
            operator_stack.push(expression[i]);
        } else if (priority(expression[i]) < priority(operator_stack.top())) {
            while (!operator_stack.empty() && priority(expression[i]) < priority(operator_stack.top())) {
                pop_operator_stack();
            }
            operator_stack.push(expression[i]);
        }
    }
    while (!operator_stack.empty()) {
        pop_operator_stack();
    }
//    for (auto e: polish_expression) {
//        cout << e << ' ';
//    }
}

int compute(int number1, char operator_, int number2) {
    switch (operator_) {
        case '+':
            return number1 + number2;
        case '-':
            return number1 - number2;
        case '*':
            return number1 * number2;
        case '/':
            return number1 / number2;
        default:
            return 0;
    }
}

int evaluate() {
    for (auto element: polish_expression) {
        if (isdigit(element[0]) || element.size() > 1) {
            int number = stoi(element);
            operand_stack.push(number);
        } else {
            char operator_ = element[0];
            int number2 = operand_stack.top();
            operand_stack.pop();
            int number1 = operand_stack.top();
            operand_stack.pop();
            int result = compute(number1, operator_, number2);
            operand_stack.push(result);
        }
    }
    return operand_stack.top();
}

int main() {
    fin >> expression;
    convert();
    fout << evaluate();
    return 0;
}