Maxim Vitalievich decided to learn a new programming language. One of his acquaintances recommended learning the Rust language, as it is the most promising. Yes, the language is really inspiring, but it forces you to face the harsh reality — the great and mighty borrow checker.

To say that Maxim Vitalyevich was somewhat at a loss would be an understatement. To get out of this situation and deal with the borrow checker, Maxim Vitalievich decided to simplify the language.

The new language only supports a predefined set of functions. In total, $$$n$$$ functions are available in the language, the description of each has the following syntax:

<char> := "a" | "b" | ... | "z"
<name> := <char> | <char> <name>
<nameOrRefName> := <name> | "&" <name>
<argument> := <nameOrRefName>
<arguments> := <argument> | <argument> ", " <arguments>
<functionName> := <nameOrRefName>
<functionArguments> := "" | <arguments>
<function> := "fn " <functionName> "(" <functionArguments> ")"

So <function> is a function description. You may notice that the function name can be either"name" or "&name". In the first case, the function returns a value; in the second case, a reference. Examples of correct functions:

fn input()        // The input function returns a value and does not contain any arguments.
fn sum(a, b)      // The sum function returns a value and takes two arguments by value.
fn add(&a, &b)    // The add function returns a value and takes arguments by reference.
fn &ref(a)        // The ref function returns a reference and takes an argument by value.
fn assign(a, &b)  // The assign function returns a value and takes the first argument
                  // by value, and the second by reference.

We also give incorrect examples (such examples cannot occur in the input data):

&fn funcd()      // Wrong character order.
fn funcb(a, b&)  // Wrong character order.
fn funcc(&&a)    // Cannot get reference to reference.
fn &&funca()     // Can't return a reference to a reference.
fn fn()          // Uses fn as the name.
fn funce(fn)     // Uses fn as the name.
fn funcf(a, a)   // Same argument names.
fn funcg(a, &a)  // Same argument names.

To implement some program, the language has the "<declare>" — construct to declare a new variable (or reference). The syntax can be described as follows:

<callArguments> := <expression> | <expression> ", " <callArguments>
<functionCallArguments> := "" | <callArguments>
<functionCall> := <name> "(" <functionCallArguments> ")"
<expression> := <nameOrRefName> | <functionCall>
<declare> := <name> " := " <expression>

Here are correct examples of using the construction:

a := input()      // Define a variable with the result value of input().
b := input()
c := a            // Assign the old value to the new variable.
d := add(&b, &c)  // Call the function, passing arguments by reference.
e := add(ref(b), ref(c))
f := &e

Here are incorrect examples of using the construction (such examples cannot be found in the input data):

a := &input()  // Can't get a reference to the result of a function.
fn := a        // Cannot use fn as a name.
&b := c        // Cannot declare a reference name.

Maxim Vitalievich believes that such a syntax is quite simple, so he cannot make syntax errors when using the language.

However, Maxim Vitalievich can make the following mistakes:

• Use a variable not previously declared with ":=".
• Use a non-existent function.
• Call a function with the wrong number of arguments (the number of arguments must match the definition).
• Pass a reference to a function argument that takes a value (or vice versa).
• Use the previously moved value of a variable (or a reference to such a variable) in the expression.

Let's take a closer look at the last point. Maksim Vitalyevich's language has its own borrow checker mechanism. The bottom line is that all variables that are used by value are moved and are no longer available. Consider the following example:

a := input()    // a is a value.
b := sum(a, a)  // Error!

In this case, the variable "a" is passed by value 2 times, but after the first use it is no longer available, thus an error occurs. In the same time:

a := input()      // a is a value.
b := sum(&a, &a)  // Correct if sum accepts references. Variable a
                  // remains available because it was not used by value.

After declaring a variable with the same name (:=), the old variable (if it is a value) is considered to be moved and is no longer available from the next line.

The following rules apply for links:

• Cannot get a reference for a moved variable.
• Cannot get a reference for a reference variable.
• You cannot use a reference to a moved variable.
• You cannot pass a value variable and a reference to that variable at the same time on the same line.

Consider the following examples:

a := input()
b := a
c := &a  // Error, variable a has been moved.

a := input()
b := &a
c := move(a)  // Same as c := a. In either case, the variable a is moved.
d := b        // Error, variable b is a reference to the value of a that has been moved.

a := input()
b := &a
c := call(a, b)  // Error. The variable a has been moved, so the reference cannot be used.

a := input()
b := &a
a := a         // The old value of variable a has been moved.
c := clone(b)  // Error, variable b refers to the old variable a, which
               // has been moved to the previous line.

Since Maxim Vitalievich invented the language and wants to use it, he asks you to implement a program that will check Maxim Vitalievich's code for errors.