1836. 表达式

print(int(eval(input())))

#include<bits/stdc++.h>
using namespace std;
int p; string s;
int exp();
int factor() {
    int val = 0;
    if (s[p] == '(')
        p++, val = exp(), p++;
    else
        while (isdigit(s[p]))
            val = val * 10 + s[p++] - '0';
    return val;
}
int term() {
    int val = factor();
    while (s[p] == '*' || s[p] == '/')
        if (s[p] == '*')
            p++, val *= factor();
        else
            p++, val /= factor();
    return val;
}
int exp() {
    int val = term();
    while (s[p] == '+' || s[p] == '-')
        if (s[p] == '+')
            p++, val += term();
        else
            p++, val -= term();
    return val;
}
int main() {
    cin >> s; p = 0;
    cout << exp() << endl;
}

using namespace std;
using i32 = int32_t
using u32 = uint32_t;

/*************************************************************************************************/

i32 eval_midexpr(string_view expr) {
    // this method reinterprets the input into a expression with no brackets.
    auto get_next = [ptr = expr.data(), ed = expr.data() + expr.size(), implicit_mul = false]()
        mutable {
        optional<variant<i32, char>> ret;
        if (ptr != ed) {
            if (*ptr == '(') {
                if (implicit_mul) {
                    implicit_mul = false;
                    ret = '*';
                } else {
                    implicit_mul = true;
                    auto i = ptr;
                    for (u32 cnt = 1; cnt;) {
                        if (*++i == '(') {
                            ++cnt;
                        } else if (*i == ')') {
                            --cnt;
                        }
                    }
                    ret = eval_midexpr({ ptr + 1, (size_t)(i - ptr) - 1});
                    ptr = i + 1;
                }
            } else if (*ptr == '*' || *ptr == '/') {
                implicit_mul = false;
                ret = *ptr++;
            } else {
                implicit_mul = true;
                auto const head = *ptr;
                if (head == '+' || head == '-') {
                    ++ptr;
                }
                i32 num = 0;
                while ('0' <= *ptr && *ptr <= '9') {
                    num = num * 10 + *ptr++ - '0';
                }
                ret = head == '+' ? num ? num : 1 : head == '-' ? num ? -num : -1 : num;
            }
        }
                // 也可以去掉上面内联的 flag 设置，在最后统一地写一句这个：
        // implicit_mul = ret && holds_alternative<i32>(ret.value());
        return ret;
    };
    vector<i32> buf;
    for (decltype(get_next()) i; i = get_next();) {
        if (holds_alternative<i32>(*i)) {
            buf.push_back(get<i32>(*i));
        } else { // When buf.size() == 1, adds a dummy 0 in the front.
            auto lhs = buf.back();
            auto acc = accumulate(begin(buf), prev(end(buf)), (i32)0);
            buf.resize(2);
            buf[0] = acc;
            if (get<char>(*i) == '*') {
                buf[1] = lhs * get<i32>(*get_next());
            } else {
                buf[1] = lhs / get<i32>(*get_next());
            }
        }
    }
    return accumulate(begin(buf), end(buf), (i32)0);
}

int main() {
    string expr; cin >> expr;
    cout << eval_midexpr(expr) << '\n';
}

auto get_next(char const*& ptr, char const* const ed, bool& implicit_mul) {
    // 函数体完全一致
}