#include <cassert>
#include <functional>
#include <iostream>
#include <memory>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
using ll = long long;
using namespace std;

struct tree_t {
    shared_ptr<tree_t> l, r;
};

shared_ptr<tree_t> parse_tree(string::const_iterator & first, string::const_iterator last) {
    assert (first != last);
    if (*first == 'x') {
        ++ first;
        return shared_ptr<tree_t>();
    } else {
        assert (*first == '(');
        ++ first;
        auto l = parse_tree(first, last);
        assert (*first == ' ');
        ++ first;
        auto r = parse_tree(first, last);
        assert (*first == ')');
        ++ first;
        return make_shared<tree_t>((tree_t) { l, r });
    }
}
shared_ptr<tree_t> parse_tree(string const & s) {
    auto it = s.begin();
    auto tree = parse_tree(it, s.end());
    assert (it == s.end());
    return tree;
}

struct rational {
    int num, den;
};
bool operator < (rational a, rational b) {
    return a.num *(ll) b.den < b.num *(ll) a.den;
}
bool operator > (rational a, rational b) {
    return a.num *(ll) b.den > b.num *(ll) a.den;
}

string signature(shared_ptr<tree_t> const & tree) {
    if (not tree) {
        return "x";
    } else {
        string l = signature(tree->l);
        string r = signature(tree->r);
        if (l > r) swap(l, r);
        return "(" + l + " " + r + ")";
    }
}

void normalize(shared_ptr<tree_t> root) {
    unordered_map<string, unordered_set<string> > subtrees; {
        function<void (shared_ptr<tree_t> const &)> go = [&](shared_ptr<tree_t> const & tree) {
            subtrees[signature(tree)].insert(signature(tree));
            if (tree) {
                go(tree->l);
                go(tree->r);
                for (auto it : subtrees[signature(tree->l)]) {
                    subtrees[signature(tree)].insert(it);
                }
                for (auto it : subtrees[signature(tree->r)]) {
                    subtrees[signature(tree)].insert(it);
                }
            }
        };
        go(root);
    }
    unordered_map<string, rational> sim; {
        function<void (shared_ptr<tree_t> const &)> go = [&](shared_ptr<tree_t> const & tree) {
            if (not tree) {
                sim[signature(tree)] = (rational) { 0, 1 };
            } else {
                auto l = subtrees[signature(tree->l)];
                auto r = subtrees[signature(tree->r)];
                int num = 0;
                for (auto it : l) {
                    num += r.count(it);
                }
                int den = l.size() + r.size() - num;
                sim[signature(tree)] = (rational) { num, den };
                go(tree->l);
                go(tree->r);
            }
        };
        go(root);
    }
    const int LT = -1;
    const int EQ =  0;
    const int GT = +1;
    function<int (shared_ptr<tree_t> const &, shared_ptr<tree_t> const &)> cmp = [&](shared_ptr<tree_t> const & a, shared_ptr<tree_t> const & b) {
            rational sim_a = sim[signature(a)];
            rational sim_b = sim[signature(b)];
            // 1.
            if (sim_a < sim_b) return GT;
            if (sim_a > sim_b) return LT;
            // 2.
            if (not a and not b) return EQ;
            // 3.
            auto al = a->l, ar = a->r;
            auto bl = b->l, br = b->r;
            if (cmp(al, ar) == GT) swap(al, ar);
            if (cmp(bl, br) == GT) swap(bl, br);
            int cmp_ar_br = cmp(ar, br);
            if (cmp_ar_br != EQ) return cmp_ar_br;
            // 4.
            int cmp_al_bl = cmp(al, bl);
            if (cmp_al_bl != EQ) return cmp_al_bl;
            // 5.
            return EQ;
    };
    function<void (shared_ptr<tree_t>, bool)> go = [&](shared_ptr<tree_t> tree, bool is_right) {
        if (not tree) {
            // nop
        } else {
            if (cmp(tree->l, tree->r) == (is_right ? GT : LT)) {
                swap(tree->l, tree->r);
            }
            go(tree->l, false);
            go(tree->r, true);
        }
    };
    go(root, false);
}

string format_tree(shared_ptr<tree_t> const & tree) {
    if (not tree) {
        return "x";
    } else {
        return "(" + format_tree(tree->l) + " " + format_tree(tree->r) + ")";
    }
}

int main() {
    while (true) {
        string s; getline(cin, s);
        if (s == "0") break;
        auto tree = parse_tree(s);
        normalize(tree);
        cout << format_tree(tree) << endl;
    }
    return 0;
}