Description

Daning’s potato field works at the granularity of plots. The set of all potatoes in a plot is called a processing unit. Each processing unit can store two values: key and tmp, both are 32-bit signed integers. Each unit can execute several commands. Daning will power the processing units one by one by riding his bicycle. The order is shown in the figure below; it shows a potato field split into $4 \times 4$ processing units:

The unit number is the power-on order. Each time, units are visited in order from No. $1$ to No. $n \times m$.

Each complete traversal is called one cycle.

Only when the potatoes in a plot are powered will they work and execute commands. After all commands finish, Daning will stop supplying power.

For each processing unit, the command formats are as follows:

1. in Read a number and store it into this unit’s $\\text{tmp}$. (If there is already a number in $\\text{tmp}$, it is overwritten; the same applies to all stores below.)
2. out Output the current unit’s $\\text{key}$.
3. swap Swap this unit’s $\\text{key}$ and $\\text{tmp}$.
4. add X Add $X$ to $\\text{key}$. $X$ can only be a constant or $\\text{tmp}$; same below.
5. set X Set $\\text{key}$ to $X$.
6. opp Negate $\\text{key}$.
7. rev Bitwise NOT on $\\text{key}$.
8. L/R X Left/Right shift $\\text{key}$ by $X$ bits.
9. get u/d/l/r Read the $\\text{key}$ of the unit above (u) / below (d) / left (l) / right (r) and copy it into this unit’s $\\text{tmp}$. Neighbor positions follow the picture above.
10. or/and/xor X Bitwise OR/AND/XOR $\\text{key}$ with $X$.
11. wait Wait during this power-on period; i.e., do nothing.
12. if X If $X$ (can only be $\\text{key}$ or $\\text{tmp}$) is not equal to $0$, then during the next time this unit is powered, execute the next instruction; otherwise skip the next instruction and execute the one after that (if it exists).
13. goto Y During the next time this unit is powered, start execution from instruction No. $Y$. $Y$ must be a constant.
14. end Forcibly end the commands of all processing units, ignoring all remaining unexecuted commands.

We provide check.exe. Put your potato program potato.out and the input testdata you want to use potato.in in the same folder as check.exe. After running, you can view the detailed running status of your program in report.txt.

We also provide another sample potato program example2.out, a potato program using $2 \times 2$ processing units that computes $10$ times an integer $a$. You can read it yourself (this sample is not the optimal solution for that computation; it is only to demonstrate the commands).

Below is a $1 \times 3$ processing unit layout. Not all units must be used.

You have the following tasks to complete by writing potato programs:

Input Format

This is an output-only problem.

Output Format

The first line contains $n$ and $m$, indicating you used $n$ rows and $m$ columns.

Then there are $n \\times m$ sections. In the $i$-th section, the first line contains $t_i$, the number of commands in the $i$-th processing unit (can be $0$). The next $t_i$ lines each describe a command, as described above.

例：一个使用1*1的土豆田处理单元(下称处理单元)的A+B problem
输入两个整数a,b,|a|,|b|<=10^9
输出a+b

1 1
5
in
swap
in
add tmp
out

解释：
第一行的1 1表示用的处理单元为1*1
第二行表示第一个处理单元有5条指令。
第三行的命令在第一个周期执行，读入了一个数(假定为a) ，此时该单元的状态为key=0,tmp=a
第四行在第二个周期执行，交换了key和tmp,状态为key=a,tmp=0
第五行在第三个周期执行，读入了另一个数b，状态为key=a,tmp=b
第六行在第四个周期执行，给key加上tmp，状态为key=a+b,tmp=b
第七行在第五个周期执行，输出该单元的key，即输出了a+b

Hint

Explanation of Sample #1

This sample implements the A+B problem.

The first line 1 1 indicates the processing unit size is $1 \\times 1$.

The second line indicates there are $5$ instructions in the first processing unit.

The command on the third line executes in the first cycle and reads a number (assume it is $a$). At this time, the unit’s state is $\\text{key} = 0, \\text{tmp} = a$.

The fourth line executes in the second cycle and swaps $\\text{key}$ and $\\text{tmp}$. The state becomes $\\text{key} = a, \\text{tmp} = 0$.

The fifth line executes in the third cycle and reads another number $b$. The state is $\\text{key} = a, \\text{tmp} = b$.

The sixth line executes in the fourth cycle and adds $\\text{tmp}$ to $\\text{key}$. The state is $\\text{key} = a + b, \\text{tmp} = b$.

The seventh line executes in the fifth cycle and outputs this unit’s $\\text{key}$, i.e., it outputs $a + b$.

If your program does not finish within $2000$ cycles, or has a syntax error, or exceeds the processing unit size limit, you get $0$ points.

If your program for task $i$ produces the correct result, and the number of cycles required is the same as or fewer than the standard solution, you get full points for that test point. Otherwise, suppose your program ran for $a$ cycles and the standard solution ran for $s$ cycles. Your score is $\\left\\lfloor \\text{(points for that test point)} \\times \\left( \\dfrac{s}{a} \\right) \\times 0.8 \\right\\rfloor$. Note that even if it shows WA for partially correct solutions, you still receive points.

P1=7
P2=9
P3=12
P4=12
P5=13
P6=13
P7=14
P8=20

PS: If you craft any fun potato programs (they can be unrelated to the tasks in this problem), please reply under the Q&A blog or send me a private message. Rewards will be given at my discretion.

Check download is available in the attachment.

example2.out:

2 2 8 in add tmp
L 3 get r add tmp
get d add tmp
out 3 wait get l add tmp
3 wait get u add tmp

Translated by ChatGPT 5