import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public Main() {
    }

    public static void main(String[] args ) {
    		Main main = new Main();
    		main.exec();
    }

    public void exec() {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    }

    public class MyStack {
        public static final int MAX = 1000;
        int[] values = new int[MAX];
        int index = 0;

        public MyStack() {}

        void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        }

        int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        }

        boolean isEmpty() {
            return index <= 0;
        }

        boolean isFull() {
            return index >= 1000;
        }
    }
} import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStreamReader; InputStreamReader java.io public class Main {
    public Main() {
    }

    public static void main(String[] args ) {
    		Main main = new Main();
    		main.exec();
    }

    public void exec() {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    }

    public class MyStack {
        public static final int MAX = 1000;
        int[] values = new int[MAX];
        int index = 0;

        public MyStack() {}

        void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        }

        int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        }

        boolean isEmpty() {
            return index <= 0;
        }

        boolean isFull() {
            return index >= 1000;
        }
    }
} Main public Main() {
    } Main {
    } public static void main(String[] args ) {
    		Main main = new Main();
    		main.exec();
    } main {
    		Main main = new Main();
    		main.exec();
    } Main main = new Main(); main new Main() main.exec() main.exec main String[] args args public void exec() {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    } exec {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    } BufferedReader bf = null; bf null try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		} IOException e {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		} e.printStackTrace() e.printStackTrace e {
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        } if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            } bf != null bf null {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            } try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				} IOException e {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				} e.printStackTrace() e.printStackTrace e {
					bf.close();
				} bf.close() bf.close bf {
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } bf = new BufferedReader(new InputStreamReader(System.in)) bf new BufferedReader(new InputStreamReader(System.in)) String line = bf.readLine(); line bf.readLine() bf.readLine bf String[] values = line.split(" "); values line.split(" ") line.split line " " MyStack mys = new MyStack(); mys new MyStack() for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            } String value values {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            } {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            } if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                } "+".equals(value) "+".equals "+" value {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } int right = mys.pop(); right mys.pop() mys.pop mys int left = mys.pop(); left mys.pop() mys.pop mys mys.push(left+right) mys.push mys left+right left right if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                } "-".equals(value) "-".equals "-" value {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } int right = mys.pop(); right mys.pop() mys.pop mys int left = mys.pop(); left mys.pop() mys.pop mys mys.push(left-right) mys.push mys left-right left right if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                } "*".equals(value) "*".equals "*" value {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } int right = mys.pop(); right mys.pop() mys.pop mys int left = mys.pop(); left mys.pop() mys.pop mys mys.push(left*right) mys.push mys left*right left right {
                    mys.push(Integer.parseInt(value));
                } mys.push(Integer.parseInt(value)) mys.push mys Integer.parseInt(value) Integer.parseInt Integer value System.out.println(mys.pop()) System.out.println System.out System System.out mys.pop() mys.pop mys public class MyStack {
        public static final int MAX = 1000;
        int[] values = new int[MAX];
        int index = 0;

        public MyStack() {}

        void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        }

        int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        }

        boolean isEmpty() {
            return index <= 0;
        }

        boolean isFull() {
            return index >= 1000;
        }
    } MyStack public static final int MAX = 1000; MAX 1000 int[] values = new int[MAX]; values new int[MAX] MAX int index = 0; index 0 public MyStack() {} MyStack {} void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        } push {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        } if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            } isFull() isFull {
                throw new RuntimeException("MyStack is Full.");
            } throw new RuntimeException("MyStack is Full."); new RuntimeException("MyStack is Full.") index++ index values[index] = val values[index] values index val int val val int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        } pop {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        } if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            } isEmpty() isEmpty {
                throw new RuntimeException("MyStack is Empty.");
            } throw new RuntimeException("MyStack is Empty."); new RuntimeException("MyStack is Empty.") index-- index return values[index+1]; values[index+1] values index+1 index 1 boolean isEmpty() {
            return index <= 0;
        } isEmpty {
            return index <= 0;
        } return index <= 0; index <= 0 index 0 boolean isFull() {
            return index >= 1000;
        } isFull {
            return index >= 1000;
        } return index >= 1000; index >= 1000 index 1000 public class Main {
    public Main() {
    }

    public static void main(String[] args ) {
    		Main main = new Main();
    		main.exec();
    }

    public void exec() {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    }

    public class MyStack {
        public static final int MAX = 1000;
        int[] values = new int[MAX];
        int index = 0;

        public MyStack() {}

        void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        }

        int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        }

        boolean isEmpty() {
            return index <= 0;
        }

        boolean isFull() {
            return index >= 1000;
        }
    }
} public class Main {
    public Main() {
    }

    public static void main(String[] args ) {
    		Main main = new Main();
    		main.exec();
    }

    public void exec() {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    }

    public class MyStack {
        public static final int MAX = 1000;
        int[] values = new int[MAX];
        int index = 0;

        public MyStack() {}

        void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        }

        int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        }

        boolean isEmpty() {
            return index <= 0;
        }

        boolean isFull() {
            return index >= 1000;
        }
    }
} Main
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public Main() {
    }

    public static void main(String[] args ) {
    		Main main = new Main();
    		main.exec();
    }

    public void exec() {
        BufferedReader bf = null;
        try{
            bf = new BufferedReader(new InputStreamReader(System.in));
            String line = bf.readLine();
            String[] values = line.split(" ");

            MyStack mys = new MyStack();
            for( String value : values ) {
                if( "+".equals(value)) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left+right);
                } else if ( "-".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left-right);
                } else if ( "*".equals(value) ) {
                    int right = mys.pop();
                    int left = mys.pop();
                    mys.push(left*right);
                } else {
                    mys.push(Integer.parseInt(value));
                }
            }

            System.out.println(mys.pop());
        } catch (IOException e) {
			// TODO 自動生成された catch ブロック
			e.printStackTrace();
		}
        finally{
            if( bf != null ) {
                try {
					bf.close();
				} catch (IOException e) {
					// TODO 自動生成された catch ブロック
					e.printStackTrace();
				}
            }
        }
    }

    public class MyStack {
        public static final int MAX = 1000;
        int[] values = new int[MAX];
        int index = 0;

        public MyStack() {}

        void push( int val ) {
            if( isFull() ) {
                throw new RuntimeException("MyStack is Full.");
            }

            index++;
            values[index] = val;
        }

        int pop() {
            if( isEmpty() ) {
                throw new RuntimeException("MyStack is Empty.");
            }

            index--;
            return values[index+1];
        }

        boolean isEmpty() {
            return index <= 0;
        }

        boolean isFull() {
            return index >= 1000;
        }
    }
}
