Altri Linguaggi - [MIPS] Calcolo del prodotto scalare tra due matrici

Buongiorno a tutti, sono nuovo del forum!
Dopo ricerche di tutti i tipi mi rivolgo a voi sperando di trovare qualcuno che mi faccia capire dove sbaglio.
Per un progetto devo creare un programma MIPS che crei delle matrici quadrate di numeri interi (10x10 max) e ne calcoli il prodotto scalare di ciascun elemento, mettendo poi i risultati in una terza matrice.
Ora, le due matrici riesco a crearle senza, credo, problemi.
I problemi nascono quando devo moltiplicare i singoli elementi e metterli nella terza matrice (che dovrei anche stampare per capire che almeno sto facendo giusto).
Per l'uso dei registri: Ho usato $s0 per memorizzare il "lato" di ogni matrice, in modo da immetterlo da input ed averlo uguale per tutte le matrici. Idem per i due registri $t2, $t3 che utilizzo come indici i e j per scorrere le matrici.

Una nota. Sono sicuro di aver fatto confusione con i registri e a questo punto mi risulta difficile uscire da questo casino. Spero che un occhio esterno veda dove sto sbagliando, perchè comincio a non capirci più nulla. Il MIPS lo sto studiando da poco e sebbene sia affascinante mi sta provocando gran mal di testa..

vi allego il codice, spero di non essere stato troppo prolisso ma abbastanza dettagliato. se avete domande chiedete pure. Grazie a chi vorrà/potrà aiutarmi.

.data

string1: .asciiz "\ninserisci un numero che andrà nella riga "
string2: .asciiz "\ne nella colonna "
string3: .asciiz "\ninserisci un valore per il lato della matrice quadrata compreso tra 1 e 10: "
string4: .asciiz "\ninserisci un valore nella seconda matrice-operando nella riga : "
string5: .asciiz "\ne nella colonna "

capo: .asciiz "\n"

M: .word 0:100
M1: .word 0:100
M2: .word 0:100

.text
.globl main

main: #lettura

	li $v0, 4
	la $a0, string3
	syscall
	
	li $v0, 5
	syscall

	#qui va messo un controllo per avere 1 < N < 10

	add $s0, $v0, $zero
	
	li $t2, 0 #indice riga
	li $t3, 0 #indice colonna
	la $s1, M #indirizzo iniziale matrice M
	

cicloR: bge $t2, $s0, MAT1 #se l'indice riga è più grande del limite
cicloC: bge $t3, $s0, fineC #se l'indice colonna è più grande del limite

	#stampo riga
	li $v0, 4
	la $a0, string1
	syscall

	li $v0, 1
	add $a0, $t2, $zero
	syscall

	#stampo colonna
	li $v0, 4
	la $a0, string2
	syscall
	
	li $v0, 1
	add $a0 $t3, $zero
	syscall
	
	#a capo
	li $v0, 4
	la $a0, capo
	syscall

	#leggo il numero
	li $v0, 5
	syscall

	add $s7, $v0, $zero

 	
	j incremento

incremento:
	lw $s7, 0($s1)
	#stampa a video il numero in posizione
	#li $v0, 1
	#add $a0, $s7, $zero
	#syscall
	
	#invio
	li $v0, 4
	la $a0, capo
	syscall

	addi $t4, $s1, 4 #scorre le righe con incrementi di 4
	addi $t3, $t3, 1 #scorre le colonne con incrementi di 1

	j cicloC
	
fineC:  li $t3, 0
	addi $t2, $t2, 1
	j cicloR

	#####################################################################

MAT1:	#add $s0, $v0, $zero
	
	li $t2, 0 #indice riga
	li $t3, 0 #indice colonna
	la $s2, M1 #indirizzo iniziale matrice M1
	
	li $t2, 0 #riazzera gli indici
	li $t3, 0 #riazzera gli indici

cicloR1: bge $t2, $s0, MAT2 #se l'indice riga è più grande del limite

cicloC1: bge $t3, $s0, fineC1 #se l'indice colonna è più grande del limite

	#stampo riga
	li $v0, 4
	la $a0, string4
	syscall

	li $v0, 1
	add $a0, $t2, $zero
	syscall

	#stampo colonna
	li $v0, 4
	la $a0, string5
	syscall
	
	li $v0, 1
	add $a0 $t3, $zero
	syscall
	
	#a capo
	li $v0, 4
	la $a0, capo
	syscall

	#leggo il numero
	li $v0, 5
	syscall

	add $s5, $v0, $zero
	j incremento1

incremento1: 
	
	lw $s5, 0($s2)
	#li $v0, 1
	#add $a0, $s5, $zero
	#syscall
	
	li $v0, 4
	la $a0, capo
	syscall

	addi $t0, $t0, 4
	addi $t3, $t3, 1

	j cicloC1

fineC1: 	
	li $t3, 0
	addi $t2, $t2, 1
	j cicloR1
##########
	# matrice risultati

MAT2:	#add $s0, $v0, $zero
	
	li $t2, 0 #indice riga
	li $t3, 0 #indice colonna
	la $t0, M2 #indirizzo iniziale matrice M2
	
	li $t2, 0 #riazzera gli indici
	li $t3, 0 #riazzera gli indici
	add $t1, $zero, $zero
ciclo:

cicloR2: bge $t2, $s0, fineR2 #se l'indice riga è più grande del limite

cicloC2: bge $t3, $s0, fineC2 #se l'indice colonna è più grande del limite
	
	sub $s4, $s0, 1
	mul $s8, $s0, $s0
		
	#prodotto scalare
	mul $t6, $s7, $s5

	li $v0, 1
	move $a0, $t6
	syscall
	
	#a capo
	li $v0, 4
	la $a0, capo
	syscall

	#add $t6, $a0, $t6
	
	#addi $s7, $s7, 4
	#addi $s5, $s5, 4
	
	addi $t1, $t1, 1
	bne $t1, $s4, ciclo
	j fineR2
	
	
incremento2: 
	li $v0, 1
	add $a0, $t6, $zero
	syscall
	
	li $v0, 4
	la $a0, capo
	syscall

	addi $t0, $t0, 4
	addi $t3, $t3, 1


	j cicloC2
	

fineC2: 	
	li $t3, 0
	addi $t2, $t2, 1
	j cicloR2
	
###########
fineR2:
	li $v0, 10
	syscall