TM assembly: Design a TM to execute programs written in a simplified assembly-like language. There are just four instructions: L, Mx, My, and A operating on three registers x, y, and z each

holding a nonnegative integer.

L instructions load a certain constant number, represented in binary, into register z. For example, the instruction L00000101 loads the integer 5 (represented by the bits 00000101) into z. Other bit strings can be specified. The number of bits may be arbitrary, but you may assume it is the same for all load instructions in the program. For instance, if the first instruction is L0011001100110011, then all remaining L instructions will be followed by exactly 16 bits.

Mx and My instructions move the value from z into x or y, respectively. (Actually, its more like copy since the value in z is not erased.)

A instructions add the values in registers x and y and store the result in register z. If the result overflows, the new most significant 1 is simply omitted; i.e., the result is taken mod 2k, where k is the number of bits specified in the first load instruction. For example, adding 11111111 (255) to 00000001 (1) results in 00000000 (0), and adding 11111010 (250) to 00001001 (9) results in 00000011 (3).

If an instruction needs to read a register (add must read x and y, and copy must read z), then you may assume that register has already had a value written to it.

The input will be a $ followed by a list of instructions, each followed by a colon, such as

 $L00000110:Mx:L00000111:My:A:Mx:L00001001:My:A: 

The above program does the following

load the value 6 into z and then move it into x, load the value 7 into z and then move it into y, add x and y and store the result (13) in z, move the value in z (13) into x,

load the value 9 into z and move it into y, add x and y and store the result (22) in z.

Your TM should produce a string output equal to the value of register z (represented as a binary string) after the last instruction executes. So the correct output above is 00010110.