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

namespace ALDS1_3_A
{
    class Program
    {
        static void Main(string[] args)
        {
            var expression = Console.ReadLine();
            var caliculator = new ReversePolishNotationCaliculator(expression);
            Console.WriteLine(caliculator.Calc().Value);
        }
    }

    public class ReversePolishNotationCaliculator
    {
        string _expression;
        char _separator;

        public ReversePolishNotationCaliculator(string expression, char separator = ' ')
        {
            _expression = expression;
            _separator = separator;
        }

        public Integer Calc()
        {
            var items = _expression.Split(_separator);
            var stack = new Stack<Integer>();
            var factory = new ExpressionFactory<Integer>();

            foreach(var item in items)
            {
                BaseExpression<Integer> expression = factory.Create(item);
                if(expression != null)
                {
                    expression.Right = stack.Pop();
                    expression.Left = stack.Pop();
                    stack.Push(expression.Calc());
                }
                else
                {
                    stack.Push(new Integer(int.Parse(item)));
                }
            }
            return stack.Pop();
        }
    }

    public class Integer : IPlus<Integer>, IMinus<Integer>, IMulti<Integer>
    {
        public int Value { get; private set; }
        public Integer(int value)
        {
            Value = value;
        }

        public Integer Plus(Integer value)
        {
            return new Integer(Value + value.Value);
        }

        public Integer Minus(Integer value)
        {
            return new Integer(Value - value.Value);
        }

        public Integer Multi(Integer value)
        {
            return new Integer(Value * value.Value);
        }

    }

    public class ExpressionFactory<T> where T : IPlus<T>, IMinus<T>, IMulti<T>
    {
        public BaseExpression<T> Create(string expression)
        {
            switch (expression)
            {
                case "+":
                    return new PlusExpression<T>();
                case "-":
                    return new MinusExpression<T>();
                case "*":
                    return new MultiExpression<T>();
                default:
                    return null;
            }
        }
    }

    public abstract class BaseExpression<T>
    {
        public T Left { get; set; }
        public T Right { get; set; }
        public abstract T Calc();
    }

    public class PlusExpression<T> : BaseExpression<T> where T : IPlus<T>
    {
        public override T Calc()
        {
            return Left.Plus(Right);
        }
    }
    public interface IPlus<T>
    {
        T Plus(T value);
    }

    public class MinusExpression<T> : BaseExpression<T> where T : IMinus<T>
    {
        public override T Calc()
        {
            return Left.Minus(Right);
        }
    }
    public interface IMinus<T>
    {
        T Minus(T value);
    }

    public class MultiExpression<T> : BaseExpression<T> where T : IMulti<T>
    {
        public override T Calc()
        {
            return Left.Multi(Right);
        }
    }
    public interface IMulti<T>
    {
        T Multi(T value);
    }
}



Measured memory_bytes: 18324