$(15$ points$).$ Using the Marie Simulator found on the web site, you will create a small

assembly language Marie program. The program is a simple multiplication app

$($MARIE does not have a MULT operator, so you have to figure out how to do this on

your own$).$ Basically, your program will issue a prompt $(">"),$ then accept a single

digit integer from the user. $($Hit the ENTER key to actually enter the value$).$ It will

then echo that integer to the screen, print a $"*"$ symbol, then wait for a second digit.

It will then echo this digit to the screen, followed by the $"="$ symbol and then the

result of the multiplication. There is no error checking, so all numbers entered should

be a single digit, and the result must also be a single digit. So $2**3=6$ or $8**1=8$

is okay, but $3**5=15$ is not $($i$.$e$.,$ your program is not expected to be able to

handle the third case properly$).$ When the calculation is finished, you must tell the

program whether to continue or not. If you enter a $"!",$ the program will print "BYE"

to the screen and halt. If you simply hit the ENTER key instead, it will loop and

provide a new prompt.

Note that IO is quite limited on Marie so you can't do anything fancy. You should

select the $"$no linefeed" option in the Output Window $-$ everything will be printed on

one line.

In addition, the data format of both the Input and Output registers should be set to

ASCII $($this is the default$).$ It must not be changed to anything else as the program is

running.

A sample output for a two iteration loop would be something like this:

$>3**3=9>1**4=4$BYE

MY CODE CAN SOMEONE PLEASE FIX IT: ORG $100$

Start, LOAD $>//$ Load X from memory

OUTPUT $//$ Output prompt

INPUT $//$ Input a digit $($first operand$)$

STORE X $//$ Store the digit in X

OUTPUT $//$ Output the entered digit

LOAD $*$

OUTPUT $//$ Output $\text{'}\text{'}$

INPUT $//$ Input a digit $($second operand$)$

STORE Y $//$ Store the digit in Y

LOAD X $//$ Load X $($first operand$)$

ADD Y $//$ Add Y $($second operand$)$

STORE Z $//$ Store the result in Z

LOAD X $//$ Load X $($first operand$)$

OUTPUT $//$ Output the first operand

OUTPUT $*//$ Output $\text{'}\text{'}$

LOAD Y $//$ Load Y $($second operand$)$

OUTPUT $//$ Output the second operand

OUTPUT $=//$ Output $\text{'}=\text{'}$

LOAD Z $//$ Load Z $($result$)$

OUTPUT $//$ Output the result

INPUT $//$ Input a character to determine continuation

SKIPCOND $400//$ Skip if the input is $\text{'}!\text{'}$

JUMP Finish $//$ If not $\text{'}!\text{'},$ finish

OUTPUT BYE$1//$ Output $\text{'}$B$\text{'}$ of BYE

OUTPUT BYE$2//$ Output $\text{'}$Y$\text{'}$ of BYE

OUTPUT BYE$3//$ Output $\text{'}$E$\text{'}$ of BYE

HALT

Finish, HALT

X$,$ DEC $0$

Y$,$ DEC $0$

Z$,$ DEC $0$

BYE$1,$ HEX $42//\text{'}$B$\text{'}$ in ASCII

BYE$2,$ HEX $59//\text{'}$Y$\text{'}$ in ASCII

BYE$3,$ HEX $45//\text{'}$E$\text{'}$ in ASCII

$*,$ HEX $2$A $//\text{'}*\text{'}$ in ASCII

$=,$ HEX $3$D $//\text{'}=\text{'}$ in ASCII

$>,$ HEX $3$E $//\text{'}>"$ in ASCII