Assembly - Divisão

[RS25]

Gostaria de saber como fazer para efetuar a seguinte conta no Assembly

T <- -T x A² / 2 x N x (2 x N + 1)

Eu sei que devo usar o add, mult e div mas não consigo colocar isto na linguagem Assembly

[Mnemonic]

Só fazer por partes.

T <- -T x A² / 2 x N x (2 x N + 1)

add t0, N, N

add t1, t0 1 # t1 = 2xN + 1

mult t1, t1, t0 #t1 = 2 x N x 2 x N + 1

...etc...

[RS25]

Só fazer por partes.

T <- -T x A² / 2 x N x (2 x N + 1)

add t0, N, N

add t1, t0 1 # t1 = 2xN + 1

mult t1, t1, t0 #t1 = 2 x N x 2 x N + 1

...etc...

Então e que eu estou querendo transformar o seguinte algoritmo em C para Assembly

{ //inicio do algoritmo
     
int A,N,SENA,T;

A = 0;

do { //inicio 1

  if (A > 1.6) {
  break;
  }
  
  SENA = 0;
  T = A;
  N = 0;
  
  do { //inicio 2
   
   if (T < 0.0001) {
   break;
   }
   
   SENA = SENA + T;
   N = N + 1;
  
  T = -T * (A * A) / (2 * N * (2 * N + 1));
  } //fim do Do 2
  
  printf("A: %f",A);  
  printf("\n\n");  
  printf("SENA: %f",SENA);  
  printf("\n\n");  
  printf("N: %f",N);  

A = A + 0.1;
} //fim Do
     
    
} //fim do algoritmo

Fiz assim:

#O registrador $t0 será usado para mostrar o valor A
#O registrador $t1 será usado para mostrar o valor de SENA
#O registrador $t2 será usado para mostrar o valor N
.data
A: .asciiz "\n A($t0:) " #mostra o valor de A
SENA: .asciiz "\n SENA($t1:) " #mostra o valor de SENA
N: .asciiz "\n N($t2:) " #mostra o valor de N
.globl main
.text
main:

li $t0, 0 #inicializa A com 0
loop1: #inicia o Loop 1
addi $t0,$t0,0.1 #O registrador $t0 recebe $t0 + 0.1
bgt $t0, 1.6, parar1 #se $t3 (A > 1.6) desvia para o rotulo (parar1)
b loop1 # fica em looping até que o valor da soma $t0 + 0.1 seja maior que 1.6
parar1:
#O registrador $t1 será usado para armazenar 0 em SENA (0 mesmo que irá mostrar o resultado no final)
#O registrador $t3 será usado para armazenar o valor de A
li $t1, 0 #inicializa SENA com 0
li $t3,$t3 #inicializa T com o valor calculado de A
li $t2,0 #inicializa N com O

loop2:
blt $t3, 0.0001, parar2 #se $t3 < 0.0001 desvia para o rotulo (parar2)

add $t1,$t1,$t3 #O registrador $t1 recebe a soma de $t1 com $t3
addi $t2,$t2,1 #O registrador $t2 recebe a soma de $t2 com 1

#calculo da expressão: T = -T  x  AxA / (2 x N x (2 x N + 1));
addi $t2, $t2,1 #N + 1
mult $t2,$t2,2 #N x 2
mult $t2,$t2,2  #N x 2
mult $t0,$t0,$t0 # $t0 = $t0,$t0
div $t3,$t0,$t2 #divide A x A por (2 x N x (2 x N + 1))
neg $t3,-1 #faz com que o registrador fique negativo
b loop2 # fica em looping até que o valor da soma de $t3 seja menor que 0.0001

#Procedimentos para escrever o resultado (parar 2)
li $v0, 4
la $a0, A
la $a1, SENA
la $a3, N
syscall
li $v0, 1
move $a0, $t0
move $a0, $t1
move $a0, $t2
syscall

nop # Diretiva para o SO interromper a execução. Alguma “coisa” do tipo “não faça nada! ”

Mas esta dando erro no código a parte da divisão eu segui o que você disse mas não consegui fazer a divisão corretamente poderia me ajudar a terminar este algoritmo em assembly?