class SixPackJoy
{
    public static void Main(string[] args)
    {
        Console.WriteLine ("Expression: ");
        var expression = Console.ReadLine().Replace(" ", "");
        var output = new Stack<BinaryNode> ();
        var stack = new Stack<Operator> ();
        var index = -1;
 
        foreach (var token in expression)
        {
            index++;
            if ("0123456789".Contains(token)) //numeric token
            {
                output.Push(new BinaryNode (token));
            }
            else if ("*/+-".Contains(token)) //operator token
            {
                var op = new Operator (token);
 
                var lastOperator = stack.Count > 0 ? stack.Peek() : null;
                if (lastOperator != null && 
                    !lastOperator.IsParenthesis && 
                    op.ComparePrecedence(stack.Peek()) <= 0)
                {
                    var node = new BinaryNode(stack.Pop().Value);
                    if (output.Count < 2)
                    {
                        Console.WriteLine("Insuficcient operator argumets, process halted");
                        return;
                    }
                    node.RightChild = output.Pop();
                    node.LeftChild = output.Pop();
                    output.Push(node);
                }
                stack.Push(op);
            }
            else if (token == '(')
            {
                stack.Push(new Operator(token));
            }
            else if (token == ')')
            {
                while (true)
                {
                    if (stack.Count == 0)
                    {
                        Console.WriteLine("Parenthesis missmatch at {0}, process halted", index);
                        return;
                    }
                    var op = stack.Pop();
                    if (op.IsParenthesis)
                        break;
 
                    if (output.Count < 2)
                    {
                        Console.WriteLine ("Insuficcient operator argumets, process halted");
                        return;
                    }
                    var node = new BinaryNode (op.Value);
                    node.RightChild = output.Pop ();
                    node.LeftChild = output.Pop ();
                    output.Push (node);
                }
            }
            else
            {
                Console.WriteLine("Invalid token '{0}' at {1}, process halted", token, index);
                return;
            }
        }
 
        while (stack.Count != 0)
        {
            var op = stack.Pop();
            if (op.IsParenthesis)
            {
                Console.WriteLine ("Parenthesis missmatch, process halted");
                return;
            }
            if (output.Count < 2)
            {
                Console.WriteLine("Insuficcient operator argumets, process halted");
                return;
            }
            var node = new BinaryNode(op.Value);
            node.RightChild = output.Pop();
            node.LeftChild = output.Pop();
            output.Push(node);
        }
 
 
        if (output.Count != 1)
        {
            Console.WriteLine("Invalid expression, process halted");
            return;
        }
 
        var ast = output.Pop();
        Console.WriteLine("{0} = {1}", ast.GetSufixNotation (), ast.Evaluate());
 
    }
}
 
class BinaryNode
{
    public BinaryNode LeftChild;
    public BinaryNode RightChild;
 
    public BinaryNode(char value)
    {
        Value = value;
    }
 
    public char Value;
 
    public double Evaluate()
    {
        if (LeftChild == null)
            return double.Parse(Value.ToString ());
 
        var operations = new Dictionary<char, Func<double, double, double>> ()
          {
             {'*', (x, y) => x * y},
             {'/', (x, y) => x / y},
             {'+', (x, y) => x + y},
             {'-', (x, y) => x - y},
          };
 
        return operations[Value](LeftChild.Evaluate(), RightChild.Evaluate());
    }
 
    public string GetSufixNotation()
    {
        if (LeftChild == null)
            return Value.ToString ();
 
        return string.Format("{0} {1} {2}",
            LeftChild.GetSufixNotation(),
            RightChild.GetSufixNotation(),
            Value);
    }
}
 
 
class Operator
{
 
    public char Value;
 
    public Operator(char value)
    {
        Value = value;
    }
 
    public bool IsParenthesis
    {
        get
        {
            return Value == '(';
        }
    }
 
    public int ComparePrecedence(Operator o)
    {
        if ("+-".Contains(Value))
        {
            if ("+-".Contains(o.Value))
                return 0;
            else
                return -1;
        }
        else if ("+-".Contains(o.Value))
            return 1;
        else
            return 0;
    }
}