Problem:
Problem B: Equals are Equals

Mr. Simpson got up with a slight feeling of tiredness. It was the start of another day of hard work. A bunch of papers were waiting for his inspection on his desk in his office. The papers contained his students' answers to questions in his Math class, but the answers looked as if they were just stains of ink.

His headache came from the ``creativity'' of his students. They provided him a variety of ways to answer each problem. He has his own answer to each problem, which is correct, of course, and the best from his aesthetic point of view.

Some of his students wrote algebraic expressions equivalent to the expected answer, but many of them look quite different from Mr. Simpson's answer in terms of their literal forms. Some wrote algebraic expressions not equivalent to his answer, but they look quite similar to it. Only a few of the students' answers were exactly the same as his.

It is his duty to check if each expression is mathematically equivalent to the answer he has prepared. This is to prevent expressions that are equivalent to his from being marked as ``incorrect'', even if they are not acceptable to his aesthetic moral.

He had now spent five days checking the expressions. Suddenly, he stood up and yelled, ``I've had enough! I must call for help.''

Your job is to write a program to help Mr. Simpson to judge if each answer is equivalent to the ``correct'' one. Algebraic expressions written on the papers are multi-variable polynomials over variable symbols a, b,..., z with integer coefficients, e.g.,

(a + b2)(a - b2), ax2 +2bx + c and (x2 +5x + 4)(x2 + 5x + 6) + 1.

Mr. Simpson will input every answer expression as it is written on the papers; he promises you that an algebraic expression he inputs is a sequence of terms separated by additive operators `+' and `-', representing the sum of the terms with those operators, if any; a term is a juxtaposition of multiplicands, representing their product; and a multiplicand is either (a) a non-negative integer as a digit sequence in decimal, (b) a variable symbol (one of the lowercase letters `a' to `z'), possibly followed by a symbol `^' and a non-zero digit, which represents the power of that variable, or (c) a parenthesized algebraic expression, recursively. Note that the operator `+' or `-' appears only as a binary operator and not as a unary operator to specify the sing of its operand.

He says that he will put one or more space characters before an integer if it immediately follows another integer or a digit following the symbol `^'. He also says he may put spaces here and there in an expression as an attempt to make it readable, but he will never put a space between two consecutive digits of an integer. He remarks that the expressions are not so complicated, and that any expression, having its `-'s replaced with `+'s, if any, would have no variable raised to its 10th power, nor coefficient more than a billion, even if it is fully expanded into a form of a sum of products of coefficients and powered variables.

Input

The input to your program is a sequence of blocks of lines. A block consists of lines, each containing an expression, and a terminating line. After the last block, there is another terminating line. A terminating line is a line solely consisting of a period symbol.

The first expression of a block is one prepared by Mr. Simpson; all that follow in a block are answers by the students. An expression consists of lowercase letters, digits, operators `+', `-' and `^', parentheses `(' and `)', and spaces. A line containing an expression has no more than 80 characters.

Output

Your program should produce a line solely consisting of ``yes'' or ``no'' for each answer by the students corresponding to whether or not it is mathematically equivalent to the expected answer. Your program should produce a line solely containing a period symbol after each block.

Sample Input

a+b+c
(a+b)+c
a- (b-c)+2
.
4ab
(a - b) (0-b+a) - 1a ^ 2 - b ^ 2
2 b 2 a
.
108 a
2 2 3 3 3 a
4 a^1 27
.
.

Output for the Sample Input

yes
no
.
no
yes
.
yes
yes
.

Solution in Ruby (judge verdict: Accepted)

### constant

MINUS = [[0] * 26 + [-1]]

### subroutines

def normalize(expr)
  return expr if expr.empty?

  expr.sort!
  term0 = expr.shift
  expr0 = []

  for term1 in expr
    if term0[0, 26] == term1[0, 26]
      term0[26] += term1[26]
    else
      expr0 << term0 if term0[26] != 0
      term0 = term1
    end
  end
  expr0 << term0 if term0[26] != 0

  expr0
end

def add_expr(expr0, expr1)
  #p ["add", expr0, expr1]
  expr = normalize(expr0 + expr1)
  #p ["add -> ", expr]
  expr
end

def mul_expr(expr0, expr1)
  #p ["mul", expr0, expr1]
  expr = []
  for term0 in expr0
    for term1 in expr1
      term = []
      (0...26).each{|i| term[i] = term0[i] + term1[i]}
      term[26] = term0[26] * term1[26]
      expr << term
    end
  end
  expr = normalize(expr)
  #p ["mul -> ", expr]
  expr
end

# <expr> := <term> ( ('+' | '-') <term>)*
# <term> := (<mult>)+
# <mult> := <num> | <var> ('^' <num>) | '(' <expr> ')'
# <num> := ('0'..'9')+
# <var> := 'a'..'z'

def skip_space(str)
  while str[$pos] == ' '
    $pos += 1
  end
end

def expr(str)
  skip_space(str)
  t0 = term(str)
  skip_space(str)

  while str[$pos] =~ /[\+\-]/
    op = str[$pos]
    $pos += 1

    skip_space(str)
    t1 = term(str)
    skip_space(str)

    t1 = mul_expr(t1, MINUS) if op == '-'
    t0 = add_expr(t0, t1)
  end

  t0
end

def term(str)
  skip_space(str)
  m0 = mult(str)
  skip_space(str)

  while str[$pos] =~ /[0-9a-z\(]/
    m1 = mult(str)
    skip_space(str)
    m0 = mul_expr(m0, m1)
  end

  m0
end

def mult(str)
  skip_space(str)

  m0 = [0] * 27

  case str[$pos]
  when '0'..'9'
    n = num(str)
    m0[26] = n
    return [m0]
  when 'a'..'z'
    v = str[$pos].ord - 'a'.ord
    $pos += 1
    skip_space(str)

    n = 1
    if str[$pos] == '^'
      $pos += 1
      skip_space(str)
      n = num(str)
      skip_space(str)
    end

    m0[v] = n
    m0[26] = 1
    return [m0]
  when '('
    $pos += 1
    skip_space(str)
    expr = expr(str)
    skip_space(str)
    $pos += 1
    return expr
  end
  nil
end

def num(str)
  n = 0
  while str[$pos] =~ /[0-9]/
    n = n * 10 + str[$pos].to_i
    $pos += 1
  end
  n
end

### main

loop do
  tstr = gets.strip
  break if tstr == '.'

  $pos = 0
  texpr = normalize(expr(tstr))
  #p [tstr, '=>' , texpr]

  loop do
    sstr = gets.strip
    break if sstr == '.'

    $pos = 0
    sexpr = normalize(expr(sstr))
    #p [sstr, '=>' , sexpr]

    puts (texpr == sexpr) ? 'yes' : 'no'
  end
  puts '.'
end