$.$data

ARR$\_$SIZE: $.$word $20$

MAX$\_$ELEMENT$\_$IN$\_$ARR: $.$word $3300$

ARR: # Initialize ARR array

$.$word $7,17,13,18,14,15,16,1,20,10,200,3300,250,12,11,9,8,19,2,3$

COUNT: # Initialize COUNT array

$.$word $1000,1999,25,90,100,45,67,89,12,34,56,78,90,123,456,789,321,654,987,432$

RESULT: # Initialize RESULT array

$.$space $80$ # Space for $20$ words $(4$ bytes per word, $20$ words $=80$ bytes$)$

TEMP$\_$ARR: # Temporary array to store counts

$.$space $13200$ # Space for MAX$\_$ELEMENT$\_$IN$\_$ARR words $(4$ bytes per word, $3300$ words $=13200$ bytes$)$

$.$text

$.$globl $\_$start

$\_$start:

# Initialize temporary array

la t$0,$ TEMP$\_$ARR

li t$1,0$

li t$2,0$

li t$3,0$

li t$4,0$

li t$5,0$

# Load constants

la t$6,$ ARR$\_$SIZE

lw t$6,0($t$6)$

la t$7,$ MAX$\_$ELEMENT$\_$IN$\_$ARR

lw t$7,0($t$7)$

# Count occurrences of each element in ARR

la t$8,$ ARR

la t$9,$ COUNT

loop$\_$count:

lw t$10,0($t$8)$ # Load element from ARR

lw t$11,0($t$9)$ # Load count for current element

addi t$9,$ t$9,4$ # Move to next count

addi t$8,$ t$8,4$ # Move to next element

slli t$12,$ t$10,2$ # Multiply element by $4$ to get byte offset

add t$12,$ t$12,$ t$0$ # Calculate address for temporary array

sw t$11,0($t$12)$ # Store count in temporary array

add t$1,$ t$1,$ t$11$ # Accumulate total count

addi t$3,$ t$3,1$ # Increment loop counter

blt t$3,$ t$6,$ loop$\_$count

# Compute starting index for each element in RESULT

li t$3,0$

la t$9,$ TEMP$\_$ARR

la t$12,$ RESULT

loop$\_$start$\_$index:

lw t$10,0($t$9)$ # Load count

add t$10,$ t$10,$ t$2$ # Add previous count

add t$10,$ t$10,$ t$3$ # Add loop counter

sw t$10,0($t$12)$ # Store starting index in RESULT

addi t$12,$ t$12,4$ # Move to next index in RESULT

add t$2,$ t$2,$ t$10$ # Update previous count

addi t$3,$ t$3,1$ # Increment loop counter

blt t$3,$ t$6,$ loop$\_$start$\_$index

# Place elements from ARR into RESULT

la t$8,$ ARR

li t$3,0$

loop$\_$place$\_$elements:

lw t$10,0($t$8)$ # Load element from ARR

la t$11,$ COUNT

slli t$12,$ t$3,2$ # Multiply loop counter by $4$ to get byte offset

add t$11,$ t$11,$ t$12$ # Calculate address for count

lw t$12,0($t$11)$ # Load count

la t$13,$ RESULT

loop$\_$place$\_$element:

lw t$14,0($t$13)$ # Load starting index

add t$15,$ t$14,$ t$12$ # Calculate index for placement

sw t$10,0($t$15)$ # Place element in RESULT

addi t$13,$ t$13,4$ # Move to next index in RESULT

sub t$12,$ t$12,1$ # Decrement count

bgez t$12,$ loop$\_$place$\_$element

addi t$8,$ t$8,4$ # Increment ARR address

addi t$3,$ t$3,1$ # Increment loop counter

blt t$3,$ t$6,$ loop$\_$place$\_$elements

# Store RESULT back into ARR

la t$8,$ ARR

la t$9,$ RESULT

li t$3,0$

loop$\_$store$\_$result:

lw t$10,0($t$9)$ # Load element from RESULT

sw t$10,0($t$8)$ # Store element back into ARR

addi t$8,$ t$8,4$ # Move to next element in ARR

addi t$9,$ t$9,4$ # Move to next element in RESULT

addi t$3,$ t$3,1$ # Increment loop counter

blt t$3,$ t$6,$ loop$\_$store$\_$result

# Exit program

li a$7,10$

ecall

how to convert this program.s to hex file?