import java.io.*;

// Stack to hold integer operands during evaluation
class OperandStack {
    int size;
    int item[];
    int top;

    public OperandStack() {
        size = 100;
        item = new int[size];
        top = -1;  // -1 means stack is empty
    }

    // Push an integer value onto the stack
    public void push(int ele) {
        if (top == (size - 1)) {
            System.out.println("Stack Overflow");
        } else {
            top++;
            item[top] = ele;
        }
    }

    // Pop and return the top value from the stack
    public int pop() {
        if (top == -1) {
            System.out.println("Stack is empty - cannot pop");
            return -1;
        } else {
            int x = item[top];
            top--;
            return x;
        }
    }

    // Peek at the top value without removing it
    public int peek() {
        if (top == -1) {
            System.out.println("Stack is empty - cannot peek");
            return -1;
        } else {
            return item[top];
        }
    }
}

// Evaluates a postfix (Reverse Polish Notation) expression
class PostfixEvaluator {
    OperandStack stack = new OperandStack();
    String postfixExpression;

    public PostfixEvaluator(String expression) {
        postfixExpression = expression;
    }

    // Returns true if the character is a single-digit operand
    public boolean isOperand(char ch) {
        return (ch >= '0' && ch <= '9');
    }

    // Evaluates the postfix expression and returns the integer result
    public int evaluate() {
        char[] chars = postfixExpression.toCharArray();
        int i = 0, operandA, operandB;

        while (i < chars.length) {
            if (isOperand(chars[i])) {
                // Convert char digit to its integer value and push
                stack.push(chars[i] - '0');
            } else {
                // Pop two operands; 'a' was pushed last (top), 'b' was below it
                operandA = stack.pop();
                operandB = stack.pop();

                switch (chars[i]) {
                    case '+':
                        stack.push(operandA + operandB);
                        break;
                    case '-':
                        stack.push(operandB - operandA);  // b - a to maintain order
                        break;
                    case '*':
                        stack.push(operandA * operandB);
                        break;
                    case '/':
                        stack.push(operandB / operandA);  // b / a to maintain order
                        break;
                    case '%':
                        stack.push(operandB % operandA);
                        break;
                }
            }
            i++;
        }
        return stack.pop();  // The final result remains on the stack
    }
}

public class PostfixEval {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter postfix expression:");
        String expression = reader.readLine();
        PostfixEvaluator evaluator = new PostfixEvaluator(expression);
        System.out.println("Result: " + evaluator.evaluate());
    }
}