// ConsoleApplication1.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include "pch.h"
#include <iostream>
#include <vector>
#include <string>
#include <memory>
using namespace std;

struct Token
{
    enum tt { num, plus, left_p, right_p, mult};

    tt type;
    int n;

    Token(tt t, int n = 0) : type(t), n(n) {}
};

class Expr {
public:
    virtual int eval() = 0;
};

class NumExpr : public Expr {
private:
    int val;
public:
    int eval() {
        return val;
    }
    NumExpr(int val) : val(val) {}
};

class AddExpr : public Expr {
private:
    unique_ptr<Expr> l, r;

public:

    AddExpr(unique_ptr<Expr> &&l, unique_ptr<Expr> &&r) : l(move(l)), r(move(r))
    {}

    int eval()
    {
        return l->eval() + r->eval();
    }
};

class MulExpr : public Expr {
private:
    unique_ptr<Expr>l, r;

public:

    MulExpr(unique_ptr<Expr> &&l, unique_ptr<Expr> &&r) : l(move(l)), r(move(r))
    {}

    int eval()
    {
        return l->eval() * r->eval();
    }
};

vector<Token> tokenize(istream &is)
{
    string str;

    vector<Token> vec;

    while (is >> str) {
        if (str == "*") {
            vec.emplace_back(Token::mult);
        }
        else if (str == "+") {
            vec.emplace_back(Token::plus);
        }
        else if (str == "(") {
            vec.emplace_back(Token::left_p);
        }
        else if (str == ")") {
            vec.emplace_back(Token::right_p);
        }
        else {
            vec.emplace_back(Token::num, stoi(str));
        }
    }

    return vec;
}
unique_ptr<Expr> parseAddExpr(const vector<Token> &tokens, size_t &pos);
unique_ptr<Expr> parseMultExpr(const vector<Token> &tokens, size_t &pos);


unique_ptr<Expr> parseExp(const vector<Token> &tokens, size_t &pos){
    return parseAddExpr(tokens, pos);
}

unique_ptr<Expr> parseNum(const vector<Token> &tokens, size_t &pos) {
    if (pos < tokens.size() && tokens[pos].type == Token::num)
    {
        return make_unique<NumExpr>(tokens[pos++].n);
    }
    else
    {
        return unique_ptr<Expr>();
    }
}

unique_ptr<Expr> parseSimExpr(const vector<Token> &tokens, size_t &pos)
{
    size_t bak = pos;
   
    if (pos < tokens.size() && tokens[pos].type == Token::left_p)
    {
        unique_ptr<Expr> res = parseAddExpr(tokens, ++pos);
        if (res && pos < tokens.size() && tokens[pos].type == Token::right_p)
        {
            pos++;
            return res;
        }
    }

    pos = bak;
    return parseNum(tokens, pos);
}
unique_ptr<Expr> parseAddExpr(const vector<Token> &tokens, size_t &pos) {
    unique_ptr<Expr> left = parseMultExpr(tokens, pos);
    size_t bak = pos;
    if (!left) return unique_ptr<Expr>();
    if (pos < tokens.size() && tokens[pos].type == Token::plus) {
        unique_ptr<Expr> right = parseAddExpr(tokens, ++pos);
        if (right) return make_unique<AddExpr>(move(left), move(right));
    }
    pos = bak;
    return left;
}
unique_ptr<Expr> parseMultExpr(const vector<Token> &tokens, size_t &pos) {
    unique_ptr<Expr> left = parseSimExpr(tokens, pos);
    size_t bak = pos;
    if (!left) return unique_ptr<Expr>();
    if (pos < tokens.size() && tokens[pos].type == Token::plus) {
        unique_ptr<Expr> right = parseMultExpr(tokens, ++pos);
        if (right) return make_unique<MulExpr>(move(left), move(right));
    }
    pos = bak;
    return left;
}
int main()
{
    size_t p = 0;

    auto tokens = tokenize(cin);
    auto e = parseExp(tokens, p);


    std::cout << e->eval();
}