Your task

Your code should

$1.$Load the values in memory at addresses $0$x$01$ and $0$x$03$ into registers

Note: since we have not discussed ways to get other data into our memory yet, we will directly modify your code so that the second $(0$x$01)$ and fourth $(0$x$03)$ bytes are the input values. This means your first $(0$x$00)$ and third $(0$x$02)$ bytes $($instructions$)$ should be very specific operations.

$2.$ Compute the modulo of those values $($i$.$e$.,($what$$s at $0$x$01)$ mod $($what$$s at $0$x$03))$

$3.$ Store the product at address $0$xD$0$

$4.$ Halt once it is done

For example, if mod.binary begins $\_\_10\_\_06$ then when it is finished it should have $04$ in address $0$xD$0$; in decimal, that is $16$ mod $6,$ which is $4.$ If mod.binary begins $\_\_7$F $\_\_0$A then when it is finished it should have $07$ in address $0$xD$0$; in decimal, that is $127$ mod $10,$ which is $7.$

Note: We should be able to change the second and fourth bytes of your program to do other modulo calculations too.

You may assume that neither value will be negative, but either may be zero. If either operand is $0,$ your code should set the value at $0$xD$0$ to $0$x$00.$

Hints, tips, and suggestions

How to compute modulo

Modulo, a mod n or a $\%$ n$,$ is defined as the remainder when dividing a by n$.$ As in our examples above with $16$ mod $6,16/6=6*2+4,$ where the quotient is $2$ and the remainder is $4.$ Therefore, $16$ mod $6=4.$

Hint: For the division operation, think along the lines of $$how many times can fit into $?$ You may wish to consider multiples of

$.$

You definitely want to make sure you can write working code for this in some language you know well before trying to convert that code into binary.

How to write binary

We suggest following these steps, carefully, saving the result of each in a file so you can go back and fix them if they were wrong:

Write pseudocode that does the desired task

Convert any for loops to while loops with explicit counters

Change any if or while guards to the form something $<=0$

a $<=$ b becomes a$-$b $<=0$

a $<$ b becomes a$+1<=$ b becomes a$+1-$b $<=0$

a $>=$ b becomes $0>=$ b$-$a becomes b$-$a $<=0$

a $>$ b becomes $0>$ b$-$a becomes b$+1-$a $<=0$

a $==$ b becomes a$-$b $==0$ becomes $!($a$-$b$)==1$ becomes $!!($a$-$b$)<=0$

a $!=$ b becomes a$-$b $!=0$ becomes $!($a$-$b$)==0$ becomes $!($a$-$b$)<=0$

Add more variables to split multi$-$operation lines into a series of single$-$operation lines

Add more operations to convert ones not in the instruction set into ones in the instruction set

Change each loop into a pair of instructions, opening with $$spot$1=$ pc$$ and closing with $$if $...,$ goto spot$1$

Count the number of variables needed

If$1$ it is $<=4,$ skip to step $10$

else$2,$ continue with next step

Pick a memory address for each variable. Make these big enough your code is unlikely to get that big; for example, you might pick $0$x$80$ though $0$x$80+$ number of variables

Convert each statement that uses variables into

register $$ load variable$$s memory

original statement

store variable$$s memory $$ register

translate each instruction into numeric $($icode$,$ a$,$ b$)$ triples, possibly followed by a M$[$pc$+1]$ immediate value

turn $($icode$,$ a$,$ b$)$ into hex

Write all the hex into mod.binary