Furiosa AI está desarrollando una NPU (Neural Processing Unit) que puede realizar el aprendizaje y la inferencia de modelos de inteligencia artificial más rápido que las unidades de procesamiento convencionales. Un programa que se ejecuta en una unidad de procesamiento convencional procesa datos almacenados en un host utilizando varios tipos de operadores para calcular los valores deseados. En este problema, simplificamos este proceso y consideramos el siguiente entorno:

• El host tiene un espacio para almacenar $1\,000\,000$ datos, y cada espacio está numerado del $0$ al $999\,999$.
• Cada operador recibe uno o más datos de entrada y calcula un dato de salida. Los operadores también están numerados del $0$ al $999\,999$.

• El programa se expresa mediante la siguiente BNF (Backus-Naur Form):

  <number> ::= 0 | 1 | ... | 999999 <value> ::= <number> | <number>(<list>) <list> ::= <value> | <list>,<value>

• El programa calcula un único valor. Es decir, el programa es una cadena de caracteres que corresponde a <value>.

• El valor de <value> se calcula de la siguiente manera:
  • Si <value> se expresa como <number>, es el dato almacenado en el espacio <number> del host antes de que comience el programa.
  • Si <value> se expresa como <number>(<list>), es el dato de salida calculado utilizando el operador <number>, tomando los <value> dentro de <list> como datos de entrada en orden.
• En un mismo programa, un mismo <number> no aparece más de una vez.

La NPU que desarrolla Furiosa AI puede ejecutar el mismo programa más rápido que una unidad de procesamiento convencional, pero para ello requiere un compilador que recompile el programa en instrucciones de bajo nivel utilizadas por la NPU. Dado que el uso de memoria y el tiempo de ejecución del programa cambian según cómo se compile el mismo programa, se necesita un compilador optimizado para utilizar la NPU de manera eficiente.

La NPU tiene una memoria que puede almacenar $M$ datos, y cada espacio de memoria está numerado del $0$ al $M-1$. La NPU admite los siguientes tres tipos de instrucciones:

• a >> b
  • Copia el dato $a$ del host al espacio $b$ de la memoria. ($0 \le a < 1\,000\,000$; $0 \le b < M$). Si el dato ya existe, se sobrescribe.
• a << b
  • Copia el dato $b$ de la memoria al espacio $a$ del host. ($0 \le a < 1\,000\,000$; $0 \le b < M$). Si el dato ya existe, se sobrescribe.
• o = w | m1 m2 ... ml
  • Almacena en el espacio $o$ de la memoria el dato de salida del operador $w$, tomando los valores de las direcciones $m_1, m_2, \dots, m_l$ de la memoria como datos de entrada en orden.
  • El espacio donde se almacena el dato de salida debe ser diferente de los espacios donde están almacenados los datos de entrada. Es decir, $o \neq m_i$ ($1 \le i \le l$).

Un programa de NPU es una secuencia de las instrucciones anteriores; cuando se ejecuta el programa, las instrucciones que lo componen se ejecutan en orden.

Aunque la eficiencia de un programa está determinada por varios factores, es probable que sea un programa eficiente si el número de instrucciones utilizadas es pequeño. Dada una cadena de caracteres que corresponde a <value>, intentemos convertirla en un programa de NPU que calcule el valor de <value> y lo almacene en la memoria $0$, utilizando la menor cantidad de instrucciones posible.

Entrada

En la primera línea se proporciona el tamaño $M$ de la memoria de la NPU. ($1 \le M \le 1\,000\,000$) En la segunda línea se proporciona la cadena de caracteres que corresponde al <value> a calcular. La longitud de esta cadena es de $1\,000\,000$ o menos.

Salida

Si el programa no se puede compilar debido a que la memoria de la NPU es insuficiente, imprima $-1$. Si el programa se puede compilar, imprima en la primera línea el número de instrucciones del programa que calcula <value> utilizando el mínimo de instrucciones. A partir de la siguiente línea, imprima las instrucciones que componen el programa, una por línea, en orden. Debe haber un espacio entre todos los tokens de una instrucción. Si hay varias respuestas posibles, imprima cualquiera de ellas.

Ejemplos

Entrada 1

7
71(72(41,42),73(43,44))

Salida 1

7
41 >> 3
42 >> 4
43 >> 5
44 >> 6
1 = 72 | 3 4
2 = 73 | 5 6
0 = 71 | 1 2

Entrada 2

3
71(72(41,42),73(43,44))

Salida 2

9
43 >> 2
44 >> 0
1 = 73 | 2 0
59 << 1
41 >> 2
42 >> 0
1 = 72 | 2 0
59 >> 2
0 = 71 | 1 2

Entrada 3

2
71(72(41,42),73(43,44))

Salida 3

-1