$$LC$3$ PROGRAMMING ASSEMBLY LANGUAGE$$ Write an LC$-3$ assembler program that converts a number stored in memory into its binary

representation in the Minecraft world.

a$)$ Place your code in the assembly file "write$\_$binary.asm".

b$)$ The number to convert is specified in the LC$-3$ starter file as NUMBER$\_$TO$\_$CONVERT.

c$)$ You can assume that the number to convert will always be non$-$negative.

d$)$ Use air $($block ID #$0)$ to represent zeroes and stone blocks $($block ID #$1)$ to represent $1$s$.$

i$)$ The least significant bit should be written to $($playerPos$.$x$,$ playerPos.y$,$ playerPos.z$+1).$

ii$)$ The next bit should be written to $($playerPos$.$x$,$ playerPos.y$,$ playerPos.z$+2)$ and so on

$($see Figure $1$ for a visual explanation$).$

iii$)$ Since the word size in LC$-3$ is $16$ bits, your program should always output $16$ blocks,

writing extra zeroes as air blocks if necessary.

Figure $1$: Illustration of how to output the binary representation in Minecraft. The number

represented here is $237=0000000011101101.$ The least significant bit is closest to the player.

$.$ORIG x$3000$

; Get player's current position

TRAP x$29$ ; Get tile position $($R$0=$ x$,$ R$1=$ y$,$ R$2=$ z$)$

ADD R$2,$ R$2,$ #$1$ ; Start at z$+1($move placement one block forward$)$

LD R$6,$ NUMBER$\_$TO$\_$CONVERT ; Load the number to convert $(237$ in binary: $0000000011101101)$

LD R$4,$ BIT$\_$COUNT ; Set loop counter to $16($for $16$ bits in binary representation$)$

; Store player's x and y coordinates

ST R$0,$ PLAYER$\_$X

ST R$1,$ PLAYER$\_$Y

; Loop to process all $16$ bits

CONVERT$\_$LOOP

; Check if the least significant bit $($LSB$)$ is $1$ or $0$

AND R$3,$ R$6,$ #$1$ ; Mask the LSB $($check if it's $1)$

BRz CALL$\_$AIR ; If the bit is $0,$ branch to CALL$\_$AIR $($place air block$)$

; If the bit is $1,$ call the subroutine to place stone

JSR PLACE$\_$STONE

BR NEXT$\_$BIT

CALL$\_$AIR

JSR PLACE$\_$AIR ; Call subroutine to place air block

NEXT$\_$BIT

ADD R$2,$ R$2,$ #$1$ ; Increment the z$-$coordinate for the next block

ADD R$4,$ R$4,$ #$-1$ ; Decrement bit counter

BRz END$\_$CONVERSION ; If all bits are processed, end

; Shift number to the right by $1$ bit to check the next bit

ADD R$6,$ R$6,$ R$6$ ; Logical shift right $($move to the next bit$)$

ADD R$6,$ R$6,$ #$0$ ; This is just a filler to prevent errors, as LSR cannot be used.

ADD R$6,$ R$6,$ R$6$ ; Shift right by adding R$6$ to itself and discarding the result in the upper half

BR CONVERT$\_$LOOP

; Subroutine to place a stone block

PLACE$\_$STONE

LD R$3,$ STONE$\_$BLOCK ; Load stone block ID into R$3$

LD R$0,$ PLAYER$\_$X ; Load player's x coordinate into R$0$

LD R$1,$ PLAYER$\_$Y ; Load player's y coordinate into R$1$

TRAP $0$x$2$C ; Use setBlock $(0$x$2$C$)$ to place the stone block at $($R$0,$ R$1,$ R$2)$

RET ; Return from subroutine

; Subroutine to place an air block

PLACE$\_$AIR

LD R$3,$ AIR$\_$BLOCK ; Load air block ID into R$3$

LD R$0,$ PLAYER$\_$X ; Load player's x coordinate into R$0$

LD R$1,$ PLAYER$\_$Y ; Load player's y coordinate into R$1$

TRAP $0$x$2$C ; Use setBlock $(0$x$2$C$)$ to place air block at $($R$0,$ R$1,$ R$2)$

RET ; Return from subroutine

END$\_$CONVERSION

HALT ; End of program

; Data section

NUMBER$\_$TO$\_$CONVERT $.$FILL #$237$ ; The number $237$ in binary: $0000000011101101$

BIT$\_$COUNT $.$FILL #$16$ ; $16$ bits to process

STONE$\_$BLOCK $.$FILL #$1$ ; Stone block ID $(1)$

AIR$\_$BLOCK $.$FILL #$0$ ; Air block ID $(0)$

PLAYER$\_$X $.$BLKW #$1$ ; Reserve space to store player's x$-$coordinate

PLAYER$\_$Y $.$BLKW #$1$ ; Reserve space to store player's y$-$coordinate

$.$END

currently my code places stone then the rest is air

i want it to place stone air stone stone air stone stone stone then rest air

please fix it