#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <iterator>

using namespace std;

struct Term {
  int n;
  int exp[31];

  Term() {
    n = 1;
    memset(exp, 0, sizeof(exp));
  }
  Term& operator *=(const Term& b) {
    n *= b.n;
    for(int i = 0; i < 31; ++i)
      exp[i] += b.exp[i];
    return *this;
  }
  bool operator ==(const Term& b) const {
    return n == b.n && equal(exp, exp+31, b.exp);
  }
  bool operator <(const Term& b) const {
    for(int i = 0; i < 31; ++i)
      if(exp[i] != b.exp[i])
	return exp[i] < b.exp[i];
    return false;
  }
  bool eq(const Term& b) const {
    return equal(exp, exp+31, b.exp);
  }
  void print() const {
    cout << n;
    for(int i = 0; i < 31; ++i)
      if(exp[i])
	cout << " " << (char)(i+'a') << "^" << exp[i];
    cout << endl;
  }
};

struct Lex {
  const char* str;
  int index;

  Lex(const string& s) : str(s.c_str()), index(0) {}
  
  bool isNum() {
    ignoreSpace();
    return isdigit(str[index]);
  }
  int getNum() {
    ignoreSpace();
    int r = 0;
    while(isdigit(str[index])) {
      r = r * 10 + (str[index++]-'0');
    }
    return r;
  }
  char peak() {
    ignoreSpace();
    return str[index];
  }
  char getC() {
    ignoreSpace();
    return str[index++];
  }
  void ignoreSpace() {
    while(str[index] == ' ')
      ++index;
  }
};

vector<Term> check(vector<Term>& v) {
  vector<Term> r;
  if(v.empty())
    return r;
  sort(v.begin(), v.end());
  r.push_back(v[0]);
  for(int i = 1; i < (int)v.size(); ++i) {
    if(r.empty() || !r.back().eq(v[i])) {
      r.push_back(v[i]);
    } else {
      r.back().n += v[i].n;
      if(r.back().n == 0)
	r.pop_back();
    }
  }
  return r;
}

vector<Term> exp(Lex& lex);

vector<Term> fact(Lex& lex) {
  //cerr << "f";
  vector<Term> r;
  if(lex.isNum()) {
    Term t;
    t.n = lex.getNum();
    if(t.n)
      r.push_back(t);
  } else if(lex.peak() == '(') {
    lex.getC();
    r = exp(lex);
    assert(lex.peak() == ')');
    lex.getC();
  } else {
    int e = lex.getC() - 'a';
    int k = 1;
    if(lex.peak() == '^') {
      lex.getC();
      assert(lex.isNum());
      k = lex.getNum();
    }
    Term t;
    t.exp[e] = k;
    r.push_back(t);
  }
  return r;
}
vector<Term> term(Lex& lex) {
  //cerr << "t";
  vector<Term> r;
  r = fact(lex);
  while(lex.peak() != '+' && lex.peak() != '-'
	&& lex.peak() != ')' && lex.peak() != 0) {
    vector<Term> a = r;
    vector<Term> b = fact(lex);
    r.clear();
    for(int i = 0; i < (int)a.size(); ++i)
      for(int j = 0; j < (int)b.size(); ++j) {
	Term t = a[i];
	t *= b[j];
	if(t.n)
	  r.push_back(t);
      }
  }
  return r;
}
vector<Term> exp(Lex& lex) {
  //cerr << "e";
  vector<Term> r, t;
  t = term(lex);
  for(int i = 0; i < (int)t.size(); ++i) {
      if(t[i].n)
	r.push_back(t[i]);
  }
  while(lex.peak() == '+' || lex.peak() == '-') {
    bool minus = lex.getC() == '-';
    t = term(lex);
    for(int i = 0; i < (int)t.size(); ++i) {
      if(t[i].n) {
	if(minus)
	  t[i].n *= -1;
	r.push_back(t[i]);
      }
    }
  }
  return check(r);
}

void print(const vector<Term>& a) {
  for(int i = 0; i < (int)a.size(); ++i) {
    a[i].print();
  }
  cout << endl;
}

int main() {
  string line;
  while(getline(cin, line) && line[0] != '.') {
    Lex lex(line);
    vector<Term> base = exp(lex);
    while(getline(cin, line) && line[0] != '.') {
      Lex lex(line);
      vector<Term> a = exp(lex);
      //print(a);
      if(base == a) {
	cout << "yes" << endl;
      } else {
	cout << "no" << endl;
      }
    }
    cout << "." << endl;
  }
}