The dimension of quantity is a concept that ignores concrete numerical values ​​from the relational expressions between different quantities and focuses only on the type of quantity and its power. Specifically, the relational expression of the dimension is expressed as an equation ignoring the constant coefficient. That is, if the dimension of the quantity q is expressed as [q], the following relational expressions of several dimensions can be exemplified.

* [Area] = [Length] 2
* [Volume] = [Length] 3
* [Speed] = [Length] [Time] -1
* [Acceleration] = [Length] [Time] -2
* [Force] = [Mass] [Length] [Time] -2
* [Work] = [Mass] [Length] 2 [Time] -2



(Excerpt from Wikipedia "Quantity" URL http://ja.wikipedia.org/wiki/%E9%87%8F)

The amount is classified into the basic amount and the assembled amount. In this problem, n basic quantities and m assembly quantities are given. The dimensions of a given m assembly can all be represented by the product of n base unit dimensions. Also, when two dimensions are represented by the product of the dimensions of the basic quantities, it can be said that the two dimensions are equal if all the indices of the basic quantities match.

Given information about the quantity of expressions and variables and the dimension of the quantity, analyze the equation and output the name of the quantity represented by that dimension. If the name is not defined, output undefined. In addition, an operation that adds or subtracts two different dimensions in the calculation process is defined as an "illegal operation". If there is an "illegal operation", output error. The given equation satisfies:

1. All variables are assigned to the assembly dimension.
2. The expression contains only four arithmetic operations +,-, /, *, parentheses () and variables.
3. The four arithmetic operations are well known and shall be described correctly. Strictly speaking, it follows the following BNF. Also, unary operators are not used. There is no such thing as (x * (-a)).




<formula> :: = <term> | <formula> + <term> | <formula>-<term>
<term> :: = <factor> | <term> * <factor> | <term> / <factor>
<factor> :: = <variable> | (<formula>)
<variable> :: = <string>
<string> :: = <char> | <string> <char>
<char> :: = a ~ z | A ~ Z
<formula> represents an expression and <variable> represents a variable name.




Input

The input consists of multiple datasets. The number of datasets does not exceed 1,000. The dataset is given in the following format.


n m p
derived1
d1,1 d1,2 d1,3 .... d1, n
derived2
d2,1 d2,2 d2,3 .... d2, n
...
derivedm
dm, 1 dm, 2 dm, 3 .... dm, n
formula
v1 D1
v2 D2
...
vp Dp


n (1 ≤ n ≤ 5) is the number of basic quantities m (1 ≤ m ≤ 10) is the number of assemblies p (1 ≤ p ≤ 15) is the number of variable types. derivedi is the name of the i-th assembly. It is composed of uppercase and lowercase letters and does not exceed 20 characters in length. di, j (-10 ≤ di, j ≤ 10) represents the dimension of the j-th basic quantity of the i-th assembly (1 ≤ i ≤ m, 1 ≤ j ≤ n). The name of the same assembly does not appear multiple times. The assembly quantity of the same dimension may appear multiple times, in which case the last defined name will be the name of the assembly quantity. formula represents the formula to be analyzed. The length does not exceed 100 characters. vi represents a variable name. It is composed of uppercase and lowercase letters and does not exceed 20 characters in length. Di represents the name of the dimension of vi. It is guaranteed to be the name of the assembly already given. The numbers you are typing (n, m, p, d) are all integers. The end of the input is indicated by a line where each of the three 0s is separated by a single character space.

Output

Analyze the formula in one line and output the name of the dimension. If the name is not defined, output undefined. Also, if an invalid operation is included, output error.

Example

Input

2 3 2
length
1 0
time
0 1
speed
1 -1
a/b
a length
b time
2 3 3
length
1 0
time
0 1
speed
1 -1
a/b+c
a length
b time
c speed
2 3 3
length
1 0
time
0 1
speed
1 -1
a/b+c
a length
b time
c time
2 3 2
length
1 0
time
0 1
speed
1 -1
a/b/b
a length
b time
3 6 6
speed
1 -1 0
acceleration
1 -2 0
force
1 -2 1
length
1 0 0
time
0 1 0
weight
0 0 1
((v+l/t)+a*t)/(t*t)*w*t+f+w*a
v speed
l length
a acceleration
t time
w weight
f force
0 0 0


Output

speed
speed
error
undefined
force
#include <cstdio>
#include <cstdint>
#include <cassert>
#include <cctype>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <stdexcept>

struct Dimension: std::vector<int> {
  Dimension(size_t n=0): std::vector<int>(n) {}
  Dimension &operator +=(const Dimension &oth) {
    if (*this != oth) throw std::logic_error("mismatch");
    return *this;
  }
  Dimension &operator -=(const Dimension &oth) {
    if (*this != oth) throw std::logic_error("mismatch");
    return *this;
  }
  Dimension &operator *=(const Dimension &oth) {
    for (size_t i=0; i<size(); ++i)
      (*this)[i] += oth[i];

    return *this;
  }
  Dimension &operator /=(const Dimension &oth) {
    for (size_t i=0; i<size(); ++i)
      (*this)[i] -= oth[i];

    return *this;
  }
};

Dimension parse(
    const std::string &s, size_t &i,
    const std::map<std::string, Dimension> expr, size_t preced=0) {

  const std::vector<std::string> ops={"+-", "*/"};

  if (preced == ops.size()) {
    if (s[i] == '(') {
      Dimension res=parse(s, ++i, expr, 0);
      assert(s[i] == ')');
      ++i;
      return res;
    }
    if (isalpha(s[i])) {
      std::string name(1, s[i]);
      while (++i < s.length() && isalpha(s[i]))
        name += s[i];

      return expr.at(name);
    }
    assert(false);
  }

  Dimension lhs=parse(s, i, expr, preced+1);
  while (i < s.length()) {
    char op=s[i];
    if (!std::count(ops[preced].begin(), ops[preced].end(), op)) break;
    Dimension rhs=parse(s, ++i, expr, preced+1);
    if (op == '+') lhs += rhs;
    if (op == '-') lhs -= rhs;
    if (op == '*') lhs *= rhs;
    if (op == '/') lhs /= rhs;
  }
  return lhs;
}

int testcase_ends() {
  size_t n, m, p;
  scanf("%zu %zu %zu", &n, &m, &p);
  if (n == 0 && m == 0 && p == 0) return 1;

  std::map<std::string, Dimension> stod;
  std::map<Dimension, std::string> dtos;
  for (size_t i=0; i<m; ++i) {
    char buf[32];
    scanf("%s", buf);
    std::string s=buf;
    Dimension d(n);
    for (size_t j=0; j<n; ++j)
      scanf("%d", &d[j]);

    stod[s] = d;
    dtos[d] = s;
  }

  std::string s;
  {
    char buf[128];
    scanf("%s", buf);
    s = buf;
  }

  std::map<std::string, Dimension> expr;
  for (size_t i=0; i<p; ++i) {
    char buf[128];
    scanf("%s", buf);
    std::string lhs=buf;
    scanf("%s", buf);
    std::string rhs=buf;
    expr[lhs] = stod[rhs];
  }

  size_t i=0;
  try {
    Dimension res=parse(s, i, expr);
    printf("%s\n", dtos.at(res).c_str());
  } catch (std::out_of_range &e) {
    printf("undefined\n");
  } catch (std::logic_error &e) {
    printf("error\n");
  }

  return 0;
}
  
int main() {
  while (!testcase_ends()) {}
}

