// cl /EHsc infixExpression00.cpp

#include <cassert>
#include <iostream>
using std::cin;
using std::cout;

#define STSIZE 100

// 定義 Operand Stack
struct OperandStack
{
    int top;
    int data[STSIZE];
};

void push(OperandStack &stack, int c);
void pop(OperandStack &stack);
int  top(OperandStack &stack);
int  isEmpty(OperandStack &stack);
void init(OperandStack &stack);

// 定義 Operator Stack
struct OperatorStack
{
    int top;
    char data[STSIZE];
};

void push(OperatorStack &stack, char c);
void pop(OperatorStack &stack);
char top(OperatorStack &stack);
int  isEmpty(OperatorStack &stack);
void init( OperatorStack &stack);

void calculate(OperandStack &operandStack, char op);
int precedence(char op1, char op2);

int readExpression(int data[]);

int main()
{
    int operand1, operand2, i, ndata, data[100];
    char op;
    OperandStack operandStack;
    OperatorStack operatorStack;
    init(operandStack);
    init(operatorStack);

    ndata = readExpression(data); // 由鍵盤讀入 infix expression
                                  // 到陣列 data[] 中, 共有 ndata 項,
                                  // 所有 operator 以負的ASCII 表示,
                                  // operand 為正整數

    for (i=0; i<ndata; i++)
    {
        if (data[i]>=0) // operand: 0~999
        {
            cout << data[i] << ' ';
            push(operandStack, data[i]);
        }
        else if (data[i] == -')')
        {
            while ((op = -top(operatorStack)) != '(')
            {
                cout << op << ' ';
                calculate(operandStack, op); // 由 operandStack 上取得
                                             // 兩個 operand, 計算完再
                                             // push 回 operandStack
                pop(operatorStack);
            }
            pop(operatorStack);
        }
        else if ((data[i] == -'(') ||
                 (precedence(data[i], top(operatorStack)) > 0))
            push(operatorStack, data[i]);
        else
        {
            do
            {
                cout << (op=-top(operatorStack)) << ' ';
                pop(operatorStack);
                calculate(operandStack, op);
            }
            while (precedence(data[i], top(operatorStack)) <= 0);
            push(operatorStack, data[i]);
        }
    }
    while (!isEmpty(operatorStack))
    {
        cout << (op=-top(operatorStack)) << ' ';
        pop(operatorStack);
        calculate(operandStack, op);
    }

    cout << '\n' << top(operandStack) << '\n';

    return 0;
}

int readExpression(int data[])
{
    char c;
    int ndata=0;
    while ((c=cin.get())!=EOF)
    {
        if (c == '\n')
            break;
        else if (c == ' ' || c == '\t')
            continue;
        else if ((c == '+') || (c == '-') || 
                 (c == '*') || (c == '/') || (c == '%') ||
                 (c == '(') || (c == ')') )
            data[ndata++] = -c;
        else
        {
            cin.unget();
            cin >> data[ndata++];
        }
    }
    return ndata;
}

int precedence(char op1, char op2)
{                                                    // 99: eos
    static char op[] = {'(', ')', '+', '-', '*', '/', '%', 99};
    static int isp[] = { 0, 19, 12, 12, 13, 13, 13, 0};
    static int icp[] = {20, 19, 12, 12, 13, 13, 13, 0};
    static int nops = sizeof(op)/sizeof(char);
    int indOP1, indOP2;
    for (indOP1=0; indOP1<nops; indOP1++)
        if (-op1 == op[indOP1]) break;
    for (indOP2=0; indOP2<nops; indOP2++)
        if (-op2 == op[indOP2]) break;
    return icp[indOP1] - isp[indOP2];
}


void calculate(OperandStack &operandStack, char op)
{
    int operand1, operand2;
    operand1 = top(operandStack); pop(operandStack);
    operand2 = top(operandStack); pop(operandStack);
    if (op == '+')
        push(operandStack, operand1+operand2);
    else if (op == '-')
        push(operandStack, operand2-operand1);
    else if (op == '*')
        push(operandStack, operand1*operand2);
    else if (op == '/')
        push(operandStack, operand2/operand1); // integer division
    else if (op == '%')
        push(operandStack, operand2%operand1); // integer remainder
}


void init(OperandStack &stack)
{
    stack.top = 0;
}

void init(OperatorStack &stack)
{
    stack.top = 0;
}


int isEmpty(OperandStack &stack)
{
    return stack.top == 0;
}

int isEmpty(OperatorStack &stack)
{
    return stack.top == 0;
}

int top(OperandStack &stack)
{
    if (stack.top > 0)
        return stack.data[stack.top-1];
    else
        return -99; // eos
}

char top(OperatorStack &stack)
{
    if (stack.top > 0)
        return stack.data[stack.top-1];
    else
        return -99; // eos
}

void push(OperandStack &stack, int c)
{
    assert(stack.top <= STSIZE-1);
    stack.data[(stack.top)++] = c;
}

void push(OperatorStack &stack, char c)
{
    assert(stack.top <= STSIZE-1);
    stack.data[(stack.top)++] = c;
}

void pop(OperandStack &stack)
{
    if (stack.top > 0)
        (stack.top)--;
}

void pop(OperatorStack &stack)
{
    if (stack.top > 0)
        (stack.top)--;
}

/*

23 * 312 + ( 525 - 411 ) 

23 312 * 525 411 - +
7290

2 * 3 + ( 5 - 4 )

2 3 * 5 4 - +
7


2 * 4 - 2 * 3 / ( 6 - 2 * 2 )

2 4 * 2 3 * 6 2 2 * - / -
5


1 - 2 * 3 / ( 6 - 5 * ( 1 + 2 * 2 - 3 ) % 7 )

1 2 3 * 6 5 1 2 2 * + 3 - * 7 % - / -
-1

*/
 1 2 2 * + 3 - * 7 % - / -
-1

*/