#include <iostream>
#include <stack>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

// 定义节点，用于存储后缀表达式的元素
struct Node {
    bool isOp;  // 是否是运算符
    long long num;    // 如果是数字，存数值
    char op;    // 如果是运算符，存符号
};

// 获取运算符优先级
int getPriority(char op) {
    if (op == '^') return 3;
    if (op == '*' || op == '/') return 2;
    if (op == '+' || op == '-') return 1;
    return 0; // '(' 的优先级最低
}

// 执行单步运算
long long calc(long long a, long long b, char op) {
    switch(op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
        case '^': return pow(a, b);
    }
    return 0;
}

// 打印当前的表达式序列
void printList(const vector<Node>& list) {
    for (size_t i = 0; i < list.size(); i++) {
        if (list[i].isOp) cout << list[i].op << " ";
        else cout << list[i].num << " ";
    }
    cout << endl;
}

int main() {
    string s;
    cin >> s;

    stack<char> opStack;
    vector<Node> postfixList;

    // --- 阶段 1: 中缀 转 后缀 ---
    for (char c : s) {
        if (isdigit(c)) {
            // 题目保证数字只有一位，直接存入
            postfixList.push_back({false, (long long)(c - '0'), 0});
        } else if (c == '(') {
            opStack.push(c);
        } else if (c == ')') {
            while (!opStack.empty() && opStack.top() != '(') {
                postfixList.push_back({true, 0, opStack.top()});
                opStack.pop();
            }
            opStack.pop(); // 弹出 '('
        } else {
            // 是运算符
            int curPri = getPriority(c);
            while (!opStack.empty()) {
                char topOp = opStack.top();
                int topPri = getPriority(topOp);
                
                // 核心逻辑：
                // 1. 如果栈顶优先级 > 当前，必须弹
                // 2. 如果优先级相等：
                //    如果是左结合 (+ - * /)，要弹 (先进先算)
                //    如果是右结合 (^)，不弹 (后进先算)
                if (topPri > curPri || (topPri == curPri && c != '^')) {
                    postfixList.push_back({true, 0, topOp});
                    opStack.pop();
                } else {
                    break;
                }
            }
            opStack.push(c);
        }
    }
    // 将栈中剩余运算符弹出
    while (!opStack.empty()) {
        postfixList.push_back({true, 0, opStack.top()});
        opStack.pop();
    }

    // --- 阶段 2: 运算并输出过程 ---
    
    // 先输出最原始的后缀表达式
    printList(postfixList);

    while (postfixList.size() > 1) {
        // 寻找第一个运算符
        int idx = -1;
        for (int i = 0; i < postfixList.size(); i++) {
            if (postfixList[i].isOp) {
                idx = i;
                break;
            }
        }

        // 找到运算符后，前面两个必定是数字 (后缀表达式特性)
        long long b = postfixList[idx-1].num; // 栈顶元素 (右操作数)
        long long a = postfixList[idx-2].num; // 次栈顶元素 (左操作数)
        char op = postfixList[idx].op;

        // 计算结果
        long long res = calc(a, b, op);

        // 修改列表：将 [idx-2, idx] 这三项替换为 res
        // 为了方便，我们在 idx-2 处修改为结果，然后删除 idx-1 和 idx
        postfixList[idx-2] = {false, res, 0};
        postfixList.erase(postfixList.begin() + idx - 1, postfixList.begin() + idx + 1);

        // 输出当前状态
        printList(postfixList);
    }

    return 0;
}