B. Vasya and Types

Programmer Vasya is studying a new programming language &K*. The &K* language resembles the languages of the C family in its syntax. However, it is more powerful, which is why the rules of the actual C-like languages are unapplicable to it. To fully understand the statement, please read the language's description below carefully and follow it and not the similar rules in real programming languages. There is a very powerful system of pointers on &K* — you can add an asterisk to the right of the existing type _X_ — that will result in new type _X_ * . That is called pointer-definition operation. Also, there is the operation that does the opposite — to any type of _X_, which is a pointer, you can add an ampersand — that will result in a type &_X_, to which refers _X_. That is called a dereference operation. The &K* language has only two basic data types — _void_ and _errtype_. Also, the language has operators _typedef_ and _typeof_. * The operator "_typedef _A_ _B__" defines a new data type _B_, which is equivalent to _A_. _A_ can have asterisks and ampersands, and _B_ cannot have them. For example, the operator _typedef void** ptptvoid_ will create a new type _ptptvoid_, that can be used as _void**_. * The operator "_typeof _A__" returns type of _A_, brought to _void_, that is, returns the type _void**...*_, equivalent to it with the necessary number of asterisks (the number can possibly be zero). That is, having defined the _ptptvoid_ type, as shown above, the _typeof ptptvoid_ operator will return _void**_. An attempt of dereferencing of the _void_ type will lead to an error: to a special data type _errtype_. For _errtype_ the following equation holds true: _errtype*_ = _&errtype_ = _errtype_. An attempt to use the data type that hasn't been defined before that will also lead to the _errtype_. Using _typedef_, we can define one type several times. Of all the definitions only the last one is valid. However, all the types that have been defined earlier using this type do not change. Let us also note that the dereference operation has the lower priority that the pointer operation, in other words &_T_ *  is always equal to _T_. Note, that the operators are executed consecutively one by one. If we have two operators "_typedef &void a_" and "_typedef a* b_", then at first _a_ becomes _errtype_, and after that _b_ becomes _errtype* = errtype_, but **not** _&void* = void_ (see sample 2). Vasya does not yet fully understand this powerful technology, that's why he asked you to help him. Write a program that analyzes these operators. ## Input The first line contains an integer _n_ (1 ≤ _n_ ≤ 100) — the number of operators. Then follow _n_ lines with operators. Each operator is of one of two types: either "_typedef _A_ _B__", or "_typeof _A__". In the first case the _B_ type differs from _void_ and _errtype_ types, and besides, doesn't have any asterisks and ampersands. All the data type names are non-empty lines of no more than 20 lowercase Latin letters. The number of asterisks and ampersands separately in one type in any operator does not exceed 10, however if we bring some types to _void_ with several asterisks, their number may exceed 10. ## Output For every _typeof_ operator print on the single line the answer to that operator — the type that the given operator returned. [samples] ## Note Let's look at the second sample. After the first two queries _typedef_ the _b_ type is equivalent to _void*_, and _c_ — to _void**_. The next query _typedef_ redefines _b_ — it is now equal to _&b = &void* = void_. At that, the _c_ type doesn't change. After that the _c_ type is defined as _&&b* = &&void* = &void = errtype_. It doesn't influence the _b_ type, that's why the next _typedef_ defines _c_ as _&void* = void_. Then the _b_ type is again redefined as _&void = errtype_. Please note that the _c_ type in the next query is defined exactly as _errtype******* = errtype_, and not _&void******* = void******_. The same happens in the last _typedef_.