Provided skeleton file below.

$$ conv$2$d$.$asm

You must follow the MIPS calling convention. Be sure to actually follow the calling convention; solutions which do not follow the MIPS calling convention are not correct!

$2$d convol

Last week you implemented a simple $1$D convolution function $($prompt and skeleton code below$)$ with some basic assumptions about how that convolution operates such as filter size, stride and padding. This week you're going to create a function that performs $2$D convolution by calling that original function, using many of the same assumptions $($a fixed $3$x$3$ filter, with a stride of $1$ and no padding$).$ However, this time you$$re going to need to write the output array on the stack and print the entire array within the function. Your $2$D convolution function will accept $4$ parameters, input height, input width, a pointer to the start of the input array and a pointer to the filter array. You can assume the input and output matrices will be no larger than $25$ by $25.$ See below for the C code that implements the equivalent function.

Representing a $2$D array

Multi$-$dimensional arrays in memory do not actually have multiple dimensions, but are instead flattened. The way these arrays are flattened are determined by the programmer or the language, and fall into two general categories, row major and column major. Row major indicates that elements in the same row are physically next to each other in memory, while column major has elements in the same column next to each other. In order to index the array you need to know the length of the major axis. For example, a column major system indexed by array$[$row$][$column$],$ the memory location of array$[$i$][$j$]$ becomes array$[$ i $*$ column$\_$length $+$ j $].$ For this lab assume all arrays $($the filter, input, and output$)$ are all row major $($the c code is already written in row major, so just follow that$).$

Function call notes:

There$$s a lot of iteration variables that you$$ll need to keep track of across calls to the original conv function. This is a great time to use the $s registers, but in order to ensure correctness you need to make sure to save and restore those registers in the conv function using the stack. Also, we expect the conv$2$D function to properly handle the $s registers, so your function will be tested in a way that ensures those registers are unaffected.

Skeleton code information:

The skeleton code has a main that accepts input height and width from the command line $($in that order$),$ then uses that to calculate the size of the input. Then it accepts all of the values in the input array from the command line as well. You can either input these manually, or prepare the inputs in a text file, then use the command:

spim $-$f conv$2$d$.$asm $$ inp.txt

An example input file is provided in the drive.

Equivalent C code

void conv$($int inp$[],$ int filt$[],$ int result$[],$ int result$\_$l$)\{$

int filt$\_$width $=3$;

for$($int i $=0$; i $$ result$\_$l; i$++)\{$

for$($int j $=0$; j $$ filt$\_$width; j$++)\{$

result$[$i$]+=$ inp$[$i $+$ j$]*$ filt$[$j$]$;

$\}$

$\}$

$\}$

$//$The a registers match the order of the arguments

$//$$a$0->$ inp$\_$height, $a$1->$ inp$\_$width, $a$2->$ inp, $a$3->$ filt

void conv$2$D$($int inp$\_$height, int inp$\_$width, int inp$[],$ int filt$[])\{$

int filter$\_$height $=3$;

int filter$\_$width $=3$;

int out$\_$height $=$ inp$\_$height $-$ filter$\_$height $+1$;

int out$\_$width $=$ inp$\_$width $-$ filter$\_$width $+1$;

if$($out$\_$height out$\_$width

return;

int output$[$out$\_$height $*$ out$\_$width$]$;

for$($int i$=0$; i