using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        enum TokenType { TNUMBER, TPLUS, TMUL, EOF, LPAR, RPAR};


        struct Token
        {
            public TokenType tokenType;
            public int value;

            public Token (TokenType type, int value = 0)
            {
                this.tokenType = type;
                this.value = value;
            }

           

        }

        abstract class Expression
        {
            abstract public int Eval();
        }

        class Num: Expression
        {
            int number;

            public Num(int value)
            {
                this.number = value;
            }

            public override int Eval()
            {
                return number;
            }

        }

        class Plus: Expression
        {
            Expression left;
            Expression right;

            public Plus(Expression l,Expression r)
            {
                left = l;
                right = r;
            }
            public override int Eval()
            {
                return left.Eval() + right.Eval();
            }
        }

        class Mult : Expression
        {
            Expression left;
            Expression right;

            public Mult(Expression l, Expression r)
            {
                left = l;
                right = r;
            }
            public override int Eval()
            {
                return left.Eval() * right.Eval();
            }
        }

        static Expression ParseAE(ref Queue<Token> queue)
        {
            
            Expression e = ParseME(ref queue);
            if (queue.Peek().tokenType == TokenType.TPLUS)
            {
                queue.Dequeue();
                Expression f = ParseAE(ref queue);
                return new Plus(e, f);            }
            else
            {
                return e;
            }


        }
        static Expression ParseME(ref Queue<Token> queue)
        {

            Expression e = ParseSE(ref queue);
            if (queue.Peek().tokenType == TokenType.TMUL)
            {
                queue.Dequeue();
                Expression f = ParseME(ref queue);
                return new Mult(e, f);
            }
            else
            {
                return e;
            }
        }

        static Expression ParseSE(ref Queue<Token> queue)
        {
            if(queue.Peek().tokenType==TokenType.TNUMBER)
            {
                return new Num(queue.Dequeue().value); 
            }
            else if (queue.Peek().tokenType == TokenType.LPAR)
            {
                queue.Dequeue();
                Expression u = ParseAE(ref queue);
                if (queue.Peek().tokenType == TokenType.RPAR)
                {
                    queue.Dequeue();
                    return u;
                }
                else
                {
                    throw new Exception("Parse Error 3.");
                }
            }
            else
            {
                throw new Exception("Parse Error");
            }
        }



        static void Main(string[] args)
        {
            string[] line = Console.ReadLine().Split(' ');

            Queue<Token> queue = new Queue<Token>();

            foreach (string item in line)
            {
                int num;

                if (int.TryParse(item, out num))
                    queue.Enqueue(new Token(TokenType.TNUMBER, num));
                else if (item == "+")
                    queue.Enqueue(new Token(TokenType.TPLUS));
                else if (item == "*")
                    queue.Enqueue(new Token(TokenType.TMUL));
                else if (item == "(")
                    queue.Enqueue(new Token(TokenType.LPAR));
                else if (item == ")")
                    queue.Enqueue(new Token(TokenType.RPAR));
            }
            queue.Enqueue(new Token(TokenType.EOF));

            try
            {
                Expression e = ParseAE(ref queue);

                if (queue.Peek().tokenType == TokenType.EOF)
                    Console.WriteLine(e.Eval());
                else
                    throw new Exception("Parse error 2");
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("Vyskytla se chyba {0} v :", ex.Message);

                for (int i = 0; i < 5; i++)
                {
                    if (queue.Count < 1)
                        break;

                    Token token = queue.Dequeue();

                    Console.Write("{0} {1} ; ", token.tokenType, token.value);
                }
                Console.WriteLine();

                Console.ForegroundColor = ConsoleColor.White;
            }

            //Console.WriteLine((new Plus(new Num(1), new Mult(new Num(3), new Num(2)))).Eval()); 

        }
    }
}