#include<algorithm>
#include<cassert>
#include<cstdlib>
#include<string>
#include<iostream>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n)   REP(i,0,n)
typedef long long ll;

ll gcd(ll a,ll b){
  return b==0?a:gcd(b,a%b);
}

class Q{
public:
  ll u,v;// u/v
  Q():u(0),v(1){}
  Q(ll tu):u(tu),v(1){};
  Q(ll tu,ll tv):u(tu),v(tv){
    if (tu == 0){
      v=1;
      return;
    }
    if (v < 0){
      v*=-1;
      u*=-1;
    }
    ll g = gcd(u>0?u:-u,v);
    u/=g;
    v/=g;
  };
  Q operator+(const Q a)const{
    ll tu,tv;
    tv=v*a.v;
    tu=u*a.v + a.u*v;
    return Q(tu,tv);
  }
  Q operator-(const Q a)const{
    ll tu,tv;
    tv=v*a.v;
    tu=u*a.v-a.u*v;
    return Q(tu,tv);
  }
  Q operator*(const Q a)const{
    ll tu,tv;
    tv=v*a.v;
    tu=u*a.u;
    return Q(tu,tv);
  }
  Q operator/(const Q a)const{
    ll tu,tv;
    tv=v*a.u;
    tu=u*a.v;
    return Q(tu,tv);
  }
  bool operator<(const Q a)const{
    return u*a.v < v*a.u;
  }
  ll myabs()const{
    return u>0?u:-u;
  }
  ll myabsv()const{
    return v > 0?v:-v;
  }
};

const int N = 11;

class eq{
public:
  Q cof[N];
  eq(){rep(i,N)cof[i]=Q();}
  eq operator+(const eq &a){
    eq ret=(*this);
    rep(i,11)ret.cof[i]=ret.cof[i]+a.cof[i];
    return ret;
  }
  eq operator-(const eq &a){
    eq ret=*this;
    rep(i,11)ret.cof[i]=ret.cof[i]-a.cof[i];
    return ret;
  }
  eq operator*(const eq &b){
    eq ret;
    rep(i,N){
      rep(j,N){
	if (i+j < N)
	  ret.cof[i+j]=ret.cof[i+j]+(cof[i])*b.cof[j];
      }
    }
    return ret;
  }

  bool iszero(){
    rep(i,N)if(cof[i].u != 0)return false;
    return true;
  }

  int findmaxdeg()const{
    for(int i=N-1;i>=0;i--){
      if (cof[i].u != 0)return i;
    }
    return -1;
  }

  void op()const{
    for(int i=N-1;i>=0;i--){
      if (cof[i].u ==0 && i!= 0)continue;
      cout <<"("<< cof[i].u<<"/"<<cof[i].v <<")x^" << i <<" ";
    }
    cout << endl;
  }

  void opans()const{
    bool isfirst=true;
    for(int i=N-1;i>=0;i--){
      if (cof[i].u == 0 )continue;
      //assert(cof[i].v == 1);

      if (!isfirst && cof[i].u > 0)cout <<"+";
      isfirst=false;
      if (cof[i].u < 0)cout <<'-';
      //if (llabs(cof[i].u) != 1||i==0)cout << llabs(cof[i].u);
      if (cof[i].myabs() != 1||i==0)cout << cof[i].myabs();
      if (i)cout <<"x";
      if (i>=2)cout <<"^"<<i;
    }
    cout << endl;
    assert(!isfirst);
  }

  void divide(ll g){
    rep(i,N)cof[i].u/=g;
  }

  ll fact(){
    ll g = 0;
    //rep(i,N)if (cof[i].u != 0)g=llabs(cof[i].u);
    rep(i,N)if (cof[i].u != 0)g=cof[i].myabs();
    if (g != 0){
      //rep(i,N)if (cof[i].u != 0)g=gcd(llabs(cof[i].u),g);
      rep(i,N)if (cof[i].u != 0)g=gcd(cof[i].myabs(),g);
    }
    return g;
  }

  eq operator/(eq &b)const{// a/b
    eq a = (*this);
    while(true){
      int adeg=a.findmaxdeg(),bdeg=b.findmaxdeg();
      if (adeg < bdeg)break;
      Q  inv=a.cof[adeg]/b.cof[bdeg];
      eq tmp;tmp.cof[adeg-bdeg]=inv;
      eq tmpb=tmp*b;
      
      /*
      cout << adeg-bdeg << endl;
      cout <<"a " ;a.op();
      cout<<"tmp ";tmp.op();
      cout <<"b " ;b.op();
      cout << a.cof[adeg].u<<"/"<<a.cof[adeg].v <<" "
	   << b.cof[bdeg].u<<"/"<<b.cof[bdeg].v << endl;
      */

      a=a-tmpb;

      /*
      cout << inv.u<<"/"<<inv.v  << endl;
      cout <<"tmpb ";tmpb.op();
      cout <<"newa ";   a.op();
      */

      /*
      cout <<"newb ";   b.op();
      cout<<"end " << endl;
      */
      
    }
    //ll g=a.fact();
    //if (g != 0)return b/a;
    //b.fact();
    //return b;
    a.convert();
    b.convert();
    if (a.iszero())return b;
    ll g=a.fact();
    a.divide(g);
    return b/a;
  }
  bool operator<(eq & a)const{
    for(int i=N-1;i>=0;i--){
      if (cof[i].u == 0 && a.cof[i].u == 0);
      else if (cof[i].u != 0 && a.cof[i].u == 0)return false;
      else if (cof[i].u == 0 && a.cof[i].u != 0)return true;
      else if (cof[i]   < a.cof[i])return false;
      else if (a.cof[i] < cof[i]  )return true;
    }
    return false;
  }

  void convert(){
    ll g = 0;
    ll lcm=1;
    rep(i,N){
      if (cof[i].u ==0)continue;
      if (g == 0)g=cof[i].myabsv();
      else  g =gcd(cof[i].myabsv(),g);
    }
    lcm=g;
    rep(i,N){
      if (cof[i].u == 0)continue;
      lcm*=cof[i].myabsv()/g;
    }
    rep(i,N){
      if (cof[i].u == 0)continue;
      cof[i].u*=(lcm/(cof[i].myabsv()));
      cof[i].v=1;
    }
  }

};



eq term(string &in,int &p);
eq factor(string &in,int &p);
eq primary(string &in,int &p);
int digit(string &in,int &p);

eq exp(string &in,int &p){
  bool isminus=false;
  if (in[p] == '-')isminus=true,p++;
  eq ret=term(in,p);
  if (isminus){
    eq mul;mul.cof[0]=Q(-1);
    ret=ret*mul;
  }
  while(p < in.size()){
    if (in[p] == '+'){
      p++;
      eq tmp=term(in,p);
      ret=ret+tmp;
    }else if (in[p] == '-'){
      p++;
      eq tmp=term(in,p);
      ret=ret-tmp;
    }else break;
  }
  return ret;
}

eq term(string &in,int &p){
  eq ret=factor(in,p);
  while(p < in.size()){
    //( or x or??
    /*
    if (in[p]=='+'||in[p]=='-'||in[p]==')')break;
    else {
      eq tmp=factor(in,p);
      ret=ret*tmp;
    }
    */
    if (in[p] == '('||in[p] == 'x'||isdigit(in[p])){
      eq tmp=factor(in,p);
      ret=ret*tmp;
    }else break;
  }
  return ret;
}

eq factor(string &in,int &p){
  eq ret=primary(in,p);
  if (in[p] == '^'){
    p++;
    int power=digit(in,p);
    //cout <<"power " << power << endl;
    eq tmp=ret;
    REP(i,2,power+1)ret=ret*tmp;
  }
  return ret;
}

eq primary(string &in,int &p){
  eq ret;
  //cout << "primary " << in <<" " << p << endl;
  if (in[p] == 'x'){
    p++;
    ret.cof[1]=Q(1);
  }else if (in[p] == '('){
    p++;
    //cout << "( " << p << " "<< in<<endl;
    ret=exp(in,p);
    p++;
    //cout << ")" << p <<" " << in << endl;
  }else {
    int dig=digit(in,p);
    ret.cof[0]=Q(dig);
  }
  return ret;
}

int digit(string &in,int &p){
  int ret=0;
  while(p < in.size() && isdigit(in[p]))
    ret=ret*10+(in[p++]-'0');
  return ret;
}

main(){
  //test();
  string in[2];
  while(cin>>in[0] && in[0] != "."){
    cin>>in[1];
    eq data[2];
    rep(i,2){
      int p=0;
      data[i]=exp(in[i],p);
      //data[i].opans();
    }
    eq ans=data[0]/data[1];
    ans.divide(ans.fact());
    ans.convert();

    int ind = ans.findmaxdeg();
    if (ans.cof[ind].u < 0)ans.divide(-1);
    ans.opans();
  }
  return false;
}

Measured memory_bytes: 0