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 <bits/stdc++.h>
using namespace std;

#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;

template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
	return os<<'('<<p.first<<','<<p.second<<')';
}

template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
	print_tuple<Cdr...>(os,t);
	os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
	print_tuple<Args...>(os<<'(',t);
	return os<<')';
}

template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
	os<<'[';
	for(auto i=begin(c);i!=end(c);++i)
		os<<(i==begin(c)?"":" ")<<*i;
	return os<<']';
}

constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;

tuple<vi,int> expr(const string& s,int i,const map<string,vi>& utod,const map<string,string>& vtou);
	
tuple<vi,int> fact(const string& s,int i,const map<string,vi>& utod,const map<string,string>& vtou)
{
	if(s[i]=='('){
		vi ds; tie(ds,i)=expr(s,i+1,utod,vtou);
		return mt(ds,i+1);
	}
	else{
		string var;
		for(;i<s.size() && isalpha(s[i]);i++)
			var+=s[i];
		return mt(utod.at(vtou.at(var)),i);
	}
}
tuple<vi,int> term(const string& s,int i,const map<string,vi>& utod,const map<string,string>& vtou)
{
	vi ds; tie(ds,i)=fact(s,i,utod,vtou);
	while(i<s.size() && (s[i]=='*' || s[i]=='/')){
		//dump(mt(__func__,i,s[i]));
		assert(s[i]=='*' || s[i]=='/');
		char op=s[i];
		vi ds2; tie(ds2,i)=fact(s,i+1,utod,vtou);
		if(op=='*')
			rep(j,ds.size()) ds[j]+=ds2[j];
		else
			rep(j,ds.size()) ds[j]-=ds2[j];
	}
	return mt(ds,i);
}
tuple<vi,int> expr(const string& s,int i,const map<string,vi>& utod,const map<string,string>& vtou)
{
	vi ds; tie(ds,i)=term(s,i,utod,vtou);
	while(i<s.size() && s[i]!=')'){
		//dump(mt(__func__,i,s[i]));
		assert(s[i]=='+' || s[i]=='-');
		vi ds2; tie(ds2,i)=term(s,i+1,utod,vtou);
		if(ds!=ds2) throw "error";
	}
	return mt(ds,i);
}

int main()
{
	for(int n,m,p;cin>>n>>m>>p && n|m|p;){
		map<string,vi> utod; // unit -> dimension
		rep(i,m){
			string unit; cin>>unit;
			vi ds(n);
			rep(j,n) cin>>ds[j];
			utod[unit]=ds;
		}
		string s; cin>>s;
		map<string,string> vtou; // variable -> unit
		rep(i,p){
			string var,unit; cin>>var>>unit;
			vtou[var]=unit;
		}
		//dump(mt(n,m,p)); dump(s); dump(utod); dump(vtou);
		
		try{
			vi ds; tie(ds,ignore)=expr(s,0,utod,vtou);
			string res="undefined";
			for(auto p:utod)
				if(ds==p.second)
					res=p.first;
			cout<<res<<endl;
		}
		catch(const char* msg){
			cout<<msg<<endl;
		}
	}
}