C$/$C$++$ to Mips

don't change the code just modify it according to the instructions, and give me whole code with proper comments don't use ai please, or copy other answer $.$

main$()\{$

x $=2*$foo$(4*$y$+4)$;

x $=$ x$+(4*$y$+4)$;

$\{$

int foo$($int n$)$

$\{$

int magic$[12]$;$//$Mod$1-$assumemagicisstoredabove$($i$.$e$.,$ loweraddress

junk on stack

int junk$[10]=\{0,1,2,3,4,5,6,7,8,9\}$;

junk$[4]+=2-$magic$[5]$;$//$Mod$2$

if$($n$<1)$return$1$;

elsereturn$2*$bar$($n$,$magic$[5],$n$,$n$,$magic$[5])+$junk$[4]+$foo$($n$-1)$;$//$Mod$3$

$\}$

Modify the following assembly language for this revised program. You may assume that bar is an OS function that has already been written. Of course, you have to use the procedure convention described in class. In cases where the convention was left unspecified, use the convention of the example. Also note that we need to call bar before foo as in the HLL code, since the compiler doesn$$t know whether bar has side effects such as $[$unadvisedly$]$ playing with pointers to modify a variable in foo. Make sure to use a different ink color $($or boldface font$)$ to make your modifications clear, and label your program to indicate which changes support which mod. DO NOT change the original code, except as needed for these modifiations.

Thank you.

The assembly code I gave

in class $($or a slight variation$)$ is below:

# Allocate Registers:

x$->$$s$0,$ y$->$$s$1$

# Assume optimizing compiler avoids computing $4*$y$+4$ twice

Main: add $t$0,$$s$1,$$s$1$ # $t$02$y

add $t$0,$$t$0,$$t$0$ # $t$04$y

addi $t$0,$$t$0,4$ # $t$04$y$+4$

addi $sp$,$$sp$,-4$ # Push $t$0$

sw $t$0,0($$sp$)$

add $a$0,$$t$0,$$zero # arg$04$y$+4$

jal Foo # Call foo

lw $t$0,0($$sp $)$ # Pop $t$0$

addi $sp$,$$sp$,4$ #

add $s$0,$$v$0,$$v$0$ # x $2*$foo$(4*$y$+4)$

add $s$0,$$t$0,$$s$0$ # x $$ x$+4*$y$+4$

$...$ # End of Main

Foo: addi $sp$,$$sp$,-48$ # Push:

sw $ra$,44($$sp$)$ # $ra

sw $fp$,40($$sp$)$ # $fp

addi $fp$,$$sp$,44$ # Set $fp to point to frame

add $t$1,$$zero,$zero # $t$10$

sw $t$1,-44($$fp$)$ # junk$[0]0$

addi $t$1,$$t$1,1$ # $t$11$

sw $t$1,-40($$fp$)$ # junk$[1]1$

$...$

addi $t$1,$$t$1,9$ # $t$19$

sw $t$1,-8($$fp$)$ # junk$[9]9$

lw $t$1,-28($$fp$)$ # $t$1$ junk$[4]$

addi $t$1,$$t$1,2$ # $t$1$ junk$[4]+2$

sw $t$1,-28($$fp$)$ # junk$[4]$ junk$[4]+2$

slti $t$0,$$a$0,1$ # $t$01$ if n$<1$; else $0$

bne $t$0,$$zero,RetOne # Return $1$ if n$<1$

# Call foo$($n$-1)$

addi $sp$,$$sp$,-4$ # Push

sw $a$0,0($$sp$)$ # $...$ $a$0$

addi $a$0,$$a$0,-1$ # arg$0$ n$-1$

jal Foo # Call foo$($n$-1)$

lw $a$0,0($$sp$)$ # Pop $a$0$

addi $sp$,$$sp$,4$

lw $t$1,-28($$fp$)$ # $t$1$ junk$[4]$

add $v$0,$$v$0,$$t$1$ # $v$0$ foo$($n$-1)+$junk$[4]$

j Ret # Return

RetOne: addi $v$0,$$zero,$1$ # $v$01$

Ret: lw $fp$,40($$sp$)$ # pop $fp

lw $ra$,44($$sp$)$ # pop $ra

addi $sp$,$$sp$,48$ # reclaim stack space

jr $ra # return to call

This is the procedure convention