#include <fstream>
#include <cstring>
#include <cctype>

using namespace std;

ifstream f("evaluare.in");
ofstream g("evaluare.out");

const int MAX_LEN = 100000;

char expr[MAX_LEN + 1], *ind;

struct AbstractSyntaxTree
{
    struct Node
    {
        int val; char op;
        Node *left, *right;
        Node(int val = 0, char op = '\0',
             Node *left = NULL, Node *right = NULL)
        {
            this->val = val; this->op = op;
            this->left = left; this->right = right;
        }
    };
    Node *root;

    inline void BuildTree(char *&ind)
    {
        root = Expression(ind);
    }

    int Evaluate(Node *node)
    {
        if(node == NULL)
            return 0;
        if(node->op == '\0')
            return node->val;
        switch(node->op)
        {
        case '+':
            return Evaluate(node->left) + Evaluate(node->right);
        case '-':
            return Evaluate(node->left) - Evaluate(node->right);
        case '*':
            return Evaluate(node->left) * Evaluate(node->right);
        case '/':
            return Evaluate(node->left) / Evaluate(node->right);
        default:
            return 0;
        }
    }

    int Evaluate()
    {
        return Evaluate(root);
    }

    int GetValue(char *&ind)
    {
        int val = 0;
        while(isdigit(*ind))
        {
            val = val * 10 + (*ind - '0');
            ++ind;
        }
        return val;
    }

    Node* Expression(char *&ind)
    {
        if(*ind == '\0')
            return NULL;
        Node *node = Term(ind);
        while(*ind == '+' || *ind == '-')
        {
            char op = *ind;
            ind++;
            node = new Node(0, op, node, Term(ind));
        }
        return node;
    }

    Node* Term(char *&ind)
    {
        if(*ind == '\0')
            return NULL;
        Node *node = Factor(ind);
        while(*ind == '*' || *ind == '/')
        {
            char op = *ind;
            ind++;
            node = new Node(0, op, node, Factor(ind));
        }
        return node;
    }

    Node* Factor(char *&ind)
    {
        Node *node;
        if(*ind == '(')
        {
            ++ind;
            node = Expression(ind);
            ++ind;
            return node;
        }
        node = new Node(GetValue(ind));
        return node;
    }

    void DeleteTree(Node *node)
    {
        if(node == NULL)
            return;
        DeleteTree(node->left);
        DeleteTree(node->right);
        delete node;
    }

    ~AbstractSyntaxTree()
    {
        DeleteTree(root);
    }
};
AbstractSyntaxTree ast;

int main()
{
    f.getline(expr, MAX_LEN);
    ind = expr;
    ast.BuildTree(ind);
    g << ast.Evaluate();

    f.close();
    g.close();

    return 0;
}