#include <iostream>
#include <string>
#include <fstream>

int search_op_without_parantheses(const std::string& expression, int left, int right, char op1, char op2) {
    int counter = 0;

    for (int i = right; i >= left; i--) {
        if (expression[i] == ')') {
            counter++;
            continue;
        }
        else if (expression[i] == '(') {
            counter--;
            continue;
        }

        if ((expression[i] == op1 || expression[i] == op2) && counter == 0) {
            return i;
        }
    }

    return -1;
}

int get_parantheses_expression_left(const std::string& expression, int left) {
    int i = left;

    for (i = left; expression[i] != ')' && i < expression.size(); i++) {}

    if (i == expression.size()) return -1;

    return i;
}

int get_parantheses_expression_right(const std::string& expression, int right) {
    int i = right;

    for (i = right; expression[i] != '(' && i >= 0; i--) {}

    if (i == -1) return -1;

    return i;
}

bool verify_if_number(const std::string& expression, int left, int right) {
    if (expression[left] == '-') left++;

    for (int i = left; i <= right; i++) {

        if (!isalnum(expression[i])) return false;
    }

    return true;
}

int convert_to_number(const std::string& expression, int left, int right) {
    int pos = 1;
    int result = 0;

    bool ok = false;
    if (expression[left] == '-') {
        ok = true;
        left++;
    }

    for (int i = right; i >= left; i--, pos *= 10) {
        result += (expression[i] - '0') * pos;
    }

    if (ok) result *= -1;

    return result;
}

int algorithm_1(const std::string& expresion, int left, int right) {
    if (verify_if_number(expresion, left, right)) return convert_to_number(expresion, left, right);

    int result = 0;

    int pos;

    pos = search_op_without_parantheses(expresion, left, right, '+', '-');
    if (pos == -1) pos = search_op_without_parantheses(expresion, left, right, '*', '/');
    if (pos == -1) {
        result += algorithm_1(expresion, left + 1, right - 1);
        return result;
    }

    int number_left = algorithm_1(expresion, left, pos - 1);
    int number_right = algorithm_1(expresion, pos + 1, right);

    switch (expresion[pos]) {
    case '+':
        result += number_left + number_right;
        break;
    case '-':
        result += number_left - number_right;
        break;
    case '*':
        result += number_left * number_right;
        break;
    case '/':
        result += number_left / number_right;
        break;
    }

    return result;
}

int main()
{
    std::ifstream fin("evaluare.in");
    std::ofstream fout("evaluare.out");

    std::string expression;
    fin >> expression;
    fout << algorithm_1(expression, 0, expression.size() - 1);
}