#include <iostream>
#include <istream>
#include <string>
#include <sstream>
#include <stack>
#include <vector>

using polynom = std::vector<int>;

struct Token
{
  bool isNumber;
  union {
    int number;
    char operation;
  };
  Token() {}
  Token(int value):isNumber(true), number(value){} 
  Token(char op)  :isNumber(false), operation(op){}
};
bool is_operator(char c){
  switch(c){
    case '+':
    case '-':
    case '*':
    case '/':
    case '%':
    case 'p':
    case 'd':
    case 'c':
    case 'e':
    case 'x':
    case 'q':
    return true;
    default: return false;
  }
}
std::istream& operator>>(std::istream& is, Token & token){
  std::string s;
  if (!(is >> s)) {
    return is;
  }
  if (s.length() == 1 && is_operator(s[0])){
    token = Token(s[0]);
    return is;
  }
  std::istringstream ss(s);
  int i;
  if (!(ss >> i)) {
    return is;
  } 
  token = Token(i);
  return is;
}

void remove_padding_zeros(polynom& p) {
  // [1 2 3 0 0 0]
  // [1 2 3]
  for(size_t i = p.size(); i > 0; i--) {
    if(p[i-1] != 0) {
      p.resize(i);
      return;
    }
  }
  p.clear();
}

polynom operator+(const polynom& p1, const polynom& p2) {
  polynom ans(std::max(p1.size(), p2.size()), 0);

  for (size_t i = 0; i < p1.size(); ++i)
    ans[i] = p1[i];

  for (size_t i = 0; i < p2.size(); ++i)
    ans[i] += p2[i];

  remove_padding_zeros(ans);
  return ans;
}

polynom operator-(const polynom& p1, const polynom& p2) {
  polynom ans(std::max(p1.size(), p2.size()), 0);

  for (size_t i = 0; i < p1.size(); ++i)
    ans[i] = p1[i];

  for (size_t i = 0; i < p2.size(); ++i)
    ans[i] -= p2[i];

  remove_padding_zeros(ans);
  return ans;
}

polynom operator*(const polynom& p1, const polynom& p2) {
  polynom ans(p1.size() + p2.size(), 0);
  for(size_t i=0; i<p1.size(); ++i)
    for(size_t j=0; j<p2.size(); ++j)
      ans[i+j] += p1[i] * p2[j];
  remove_padding_zeros(ans);
  return ans;
}

polynom operator%(const polynom &p1, const polynom &p2){
  polynom aku;
  for(size_t i = p1.size(); i > 0; i--){
    aku = aku * p2;
    if(aku.size())
      aku[0] += p1[i-1];
    else aku.push_back(p1[i-1]);
  }
  return aku;
}

// [1 2 *3*]
// [0 1 *1*]
//  0 1   
// [1 1]
// [1 1 2]   - 0 1
// [1 0 1]   - 0 1
// [1 -1 0]  - 0 1
// [1 -1]    - -1
// [2 0]
// [2]        [-1 1]

polynom operator/(polynom p1, const polynom &p2){
  polynom aku;

  for(size_t i = p1.size(); i > 0; i--){
    if(p2.size() + i-1 > p1.size()){
        continue;
    }
    //TODO zaporne p2 a p1
    while(p1[p2.size()+i-2] >= p2.back() /*|| p1.back() < 0*/){
      for(size_t j=0; j<p2.size(); ++j){
        p1[j+i-1]-=p2[j];
      }
      if(aku.size()<i)
        aku.resize(i,0);
      ++aku[i-1];
    }
  }

  return aku;
}

// 3*x^1 + 1*x^0
// [1,3]

// 123*x^0
// [123]

int main() {
  std::stack<polynom> s;
  Token t;
  while(std::cin >> t){
    if (t.isNumber) {
      s.push(polynom(1, t.number));
      continue;
    }

    if (t.operation == 'x') {
      s.push(polynom {0, 1});
      continue;
    }

#define EXPAND_OPERATOR_IF(OPERATOR) \
    if (t.operation == #OPERATOR[0]) { \
      if (s.size() < 2) { \
        std::cerr << "Operation " #OPERATOR " error" << std::endl; \
        continue; \
      } \
      auto a = s.top(); \
      s.pop(); \
      auto b = s.top(); \
      s.pop(); \
      s.push(b OPERATOR a); \
      continue; \
    }

    EXPAND_OPERATOR_IF(+)
    EXPAND_OPERATOR_IF(-)
    EXPAND_OPERATOR_IF(*)
    EXPAND_OPERATOR_IF(/)
    EXPAND_OPERATOR_IF(%)
#undef EXPAND_OPERATOR_IF
#define EXPAND_OPERATION(OPERATOR, ELEMS, CODE) \
    if (t.operation == OPERATOR){ \
      if (s.size() < ELEMS) { \
        std::cerr << "Operation " #OPERATOR " error"<< std::endl;\
        continue;\
      }\
      CODE;\
      continue;\
    }

    EXPAND_OPERATION('p', 1, 
    {auto pol = s.top();
      for(size_t i = pol.size(); i > 0; i--){
        std::cout << pol[i - 1] << "x^" << i-1;
        if (i > 1)
          std::cout << " + ";
        else 
          std::cout << std::endl;
      }
    });
    EXPAND_OPERATION('d', 1, s.pop());
    EXPAND_OPERATION('e', 2, 
    {auto a = s.top();
      s.pop();
      auto b = s.top();
      s.pop();
      s.push(a);
      s.push(b);});
    EXPAND_OPERATION('c', 1, s.push(s.top()));
    EXPAND_OPERATION('q', 0, break);
#undef EXPAND_OPRATION
  }
}