	.text
main:
	sub  $sp, $sp, 8
	move $fp, $sp
	sw   $a0, 8($fp)
	sw   $a1, 4($fp)
# Simulation sauvegarde FP, RA
	sub  $sp, $sp, 8
# Allocation des variables locales
	sub  $sp, $sp, 0

# Appel a la fonction run---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 0
# On calcule les arguments 
# On calcule l'argument
# A0 <- 30
	li   $a0, 30
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  run
# On restaure SP
	add  $sp, $fp, 4
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

	li   $v0, 10
	syscall
print:
	li   $v0, 1
	syscall
	li   $v0, 4
	la   $a0, newline
	syscall
	jr   $ra
putchar:
	li   $v0, 11
	lw   $a0, 4($fp)
	syscall
	add  $sp, $sp, 16
	jr   $ra
sbrk:
	li   $v0, 9
	lw   $a0, 4($fp)
	syscall
	add  $sp, $sp, 16
	sw   $v0, 0($sp)
	jr   $ra
add:
# Allocation des variables locales
	sub  $sp, $sp, 0
# On returne ----------------
# On compile le renvoi -------------
# Calcul de l'expression à gauche

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	add  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
div:
# Allocation des variables locales
	sub  $sp, $sp, 4

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2
# Calcul de l'expression à gauche

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 8192
	li   $a0, 8192
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	mul  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------

# On returne ----------------
# On compile le renvoi -------------
# Calcul de l'expression à gauche
# Calcul de l'expression à gauche

# Calcul de t-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de t--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# Calcul de l'expression à gauche

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 2
	li   $a0, 2
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	div  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	add  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	div  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
inside:
# Allocation des variables locales
	sub  $sp, $sp, 0
# On returne ----------------
# On compile le renvoi -------------

# Appel a la fonction iter---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  iter
# On restaure SP
	add  $sp, $fp, 24
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
iter:
# Allocation des variables locales
	sub  $sp, $sp, 8

# If-then-else ======================
# On calcule le test 
# Calcul de l'expression à gauche

# Calcul de n-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 20
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de n--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 100
	li   $a0, 100
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	seq  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On cherche le test en memoire, il se fera ecraser plus tard 
	lw   $a0, 0($sp)
# Si A0 = 0, i.e. si faux, on va a l0
	beqz $a0, l0
# Sinon, on effectue then ---------------
# On returne ----------------
# On compile le renvoi -------------
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 24($fp)
	jr   $ra
# On saute apres le else 
	b    l1
# Le else --------------------
l0:
l1:
# Fin If-then-else ======================

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction mul---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de xn-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xn--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de xn-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xn--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  mul
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction mul---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de yn-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de yn--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de yn-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de yn--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  mul
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# If-then-else ======================
# On calcule le test 
# Calcul de l'expression à gauche

# Appel a la fonction add---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de xn2-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xn2--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de yn2-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de yn2--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  add
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 4
	li   $a0, 4
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	sgt  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On cherche le test en memoire, il se fera ecraser plus tard 
	lw   $a0, 0($sp)
# Si A0 = 0, i.e. si faux, on va a l2
	beqz $a0, l2
# Sinon, on effectue then ---------------
# On returne ----------------
# On compile le renvoi -------------
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 24($fp)
	jr   $ra
# On saute apres le else 
	b    l3
# Le else --------------------
l2:
l3:
# Fin If-then-else ======================
# On returne ----------------
# On compile le renvoi -------------

# Appel a la fonction iter---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# Calcul de l'expression à gauche

# Calcul de n-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 20
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de n--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	add  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de a-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 16
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de a--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de b-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de b--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction add---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction sub---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de xn2-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xn2--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de yn2-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de yn2--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  sub
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de a-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 16
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de a--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  add
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction add---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction mul---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 2
	li   $a0, 2
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction mul---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de xn-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xn--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de yn-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de yn--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  mul
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  mul
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de b-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de b--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  add
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  iter
# On restaure SP
	add  $sp, $fp, 24
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

	lw   $a0, 0($sp)
	sw   $a0, 24($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 24($fp)
	jr   $ra
mul:
# Allocation des variables locales
	sub  $sp, $sp, 4

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2
# Calcul de l'expression à gauche

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	mul  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------

# On returne ----------------
# On compile le renvoi -------------
# Calcul de l'expression à gauche
# Calcul de l'expression à gauche

# Calcul de t-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de t--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# Calcul de l'expression à gauche
# A0 <- 8192
	li   $a0, 8192
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 2
	li   $a0, 2
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	div  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	add  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 8192
	li   $a0, 8192
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	div  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
of_int:
# Allocation des variables locales
	sub  $sp, $sp, 0
# On returne ----------------
# On compile le renvoi -------------
# Calcul de l'expression à gauche

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 8192
	li   $a0, 8192
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	mul  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 8($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 8($fp)
	jr   $ra
run:
# Allocation des variables locales
	sub  $sp, $sp, 28

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# Calcul de l'expression à gauche
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 2
	li   $a0, 2
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	sub  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -16
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction div---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction sub---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de xmax-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xmax--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de xmin-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xmin--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  sub
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# Calcul de l'expression à gauche
# A0 <- 2
	li   $a0, 2
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de steps-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de steps--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	mul  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  div
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -20
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# Calcul de l'expression à gauche
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	sub  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -24
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -28
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction div---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction sub---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de ymax-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -24
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de ymax--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de ymin-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -20
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de ymin--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  sub
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de steps-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de steps--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  div
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Calcul de i-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de i--------------------

# Allocation des variables locales
	sub  $sp, $sp, 0

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# While ==================================
	b    l5
# Le corps de la boucle -----------------
l4:
# Allocation des variables locales
	sub  $sp, $sp, 0
# Allocation des variables locales
	sub  $sp, $sp, 8

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction add---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de ymin-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -20
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de ymin--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction mul---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de i-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de i--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de deltay-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -28
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de deltay--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  mul
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  add
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# Calcul de j-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de j--------------------

# Allocation des variables locales
	sub  $sp, $sp, 0

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2
# A0 <- 0
	li   $a0, 0
	sw   $a0, 0($sp)
# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# While ==================================
	b    l7
# Le corps de la boucle -----------------
l6:
# Allocation des variables locales
	sub  $sp, $sp, 0
# Allocation des variables locales
	sub  $sp, $sp, 4

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2

# Appel a la fonction add---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de xmin-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de xmin--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Appel a la fonction mul---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Appel a la fonction of_int---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de j-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de j--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  of_int
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de deltax-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -16
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de deltax--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  mul
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  add
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------


# If-then-else ======================
# On calcule le test 

# Appel a la fonction inside---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

# On avance 
	sub  $sp, $sp, 4
# On calcule l'argument

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  inside
# On restaure SP
	add  $sp, $fp, 12
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On cherche le test en memoire, il se fera ecraser plus tard 
	lw   $a0, 0($sp)
# Si A0 = 0, i.e. si faux, on va a l8
	beqz $a0, l8
# Sinon, on effectue then ---------------

# Appel a la fonction putchar---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 48
	li   $a0, 48
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  putchar
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# On saute apres le else 
	b    l9
# Le else --------------------
l8:

# Appel a la fonction putchar---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 49
	li   $a0, 49
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  putchar
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

l9:
# Fin If-then-else ======================
# Incrementation droite ==============
# On calcule n et on le met sur SP

# Calcul de j-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de j--------------------

# On decale SP
	add  $sp, $sp, -4
# On fait n=n+1 (osef du resultat)

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2
# Calcul de l'expression à gauche

# Calcul de j-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de j--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	add  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------

# On jette le resultat de n=n+1 a la poubelle
	add  $sp, $sp, 4
# Fin incrementation droite ==============
# Fin du corps de la boucle ------------
# Le test
l7:
# Calcul de l'expression à gauche

# Calcul de j-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -12
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de j--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# Calcul de l'expression à gauche
# A0 <- 2
	li   $a0, 2
	sw   $a0, 0($sp)
	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de steps-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de steps--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	mul  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	slt  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On charge le test en memoire 
	lw   $a0, 0($sp)
	bnez $a0, l6
# Fin du While ==========================

# Appel a la fonction putchar---------------------
# On alloue la place pour le resultat 
	sub  $sp, $sp, 4
# On calcule les arguments 
# On calcule l'argument
# A0 <- 10
	li   $a0, 10
	sw   $a0, 0($sp)
# On avance 
	sub  $sp, $sp, 4
# On sauvegarde FP et RA
	sw   $fp, 0($sp)
	sw   $ra, -4($sp)
# On place FP et SP
	move $fp, $sp
	sub  $sp, $sp, 8
# On appelle la fonction
	jal  putchar
# On restaure SP
	add  $sp, $fp, 8
# On restaure RA et FP
	lw   $ra, -4($fp)
	lw   $fp, 0($fp)
# Fin appel ------------------------------------------------

# Incrementation droite ==============
# On calcule n et on le met sur SP

# Calcul de i-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de i--------------------

# On decale SP
	add  $sp, $sp, -4
# On fait n=n+1 (osef du resultat)

# Affectation e1=e2 -------------------------
# Calcul de l'adresse de e1
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Decalage
	sub  $sp, $sp, 4
# Calcul de e2
# Calcul de l'expression à gauche

# Calcul de i-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de i--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite
# A0 <- 1
	li   $a0, 1
	sw   $a0, 0($sp)
# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	add  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# Chargement de l'adresse de e1
	lw   $s0, 4($sp)
# Copie de e2 a l'adresse indiquee4
	lw   $a0, 0($sp)
	sw   $a0, 0($s0)
# Dernier decalage : on revient
	add  $sp, $sp, 4
# Copie de e1 sur SP
	lw   $a0, -4($sp)
	sw   $a0, 0($sp)
#--------------------------------------------

# On jette le resultat de n=n+1 a la poubelle
	add  $sp, $sp, 4
# Fin incrementation droite ==============
# Fin du corps de la boucle ------------
# Le test
l5:
# Calcul de l'expression à gauche

# Calcul de i-------------------------
# Calcul de l'adresse
	add  $a0, $fp, -32
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de i--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de steps-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de steps--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	slt  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
# On charge le test en memoire 
	lw   $a0, 0($sp)
	bnez $a0, l4
# Fin du While ==========================
	jr   $ra
sub:
# Allocation des variables locales
	sub  $sp, $sp, 0
# On returne ----------------
# On compile le renvoi -------------
# Calcul de l'expression à gauche

# Calcul de x-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 8
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de x--------------------

	sub  $sp, $sp, 4
# Calcul de l'expression à droite

# Calcul de y-------------------------
# Calcul de l'adresse
	add  $a0, $fp, 4
	sw   $a0, 0($sp)
# Chargement de l'adresse en memoire
	lw   $s0, 0($sp)
# Copie de la variable sur le sommet de la pile
	lw   $a0, 0($s0)
	sw   $a0, 0($sp)
# Fin du calcul de y--------------------

# On les charge dans A0 et A1
	lw   $a1, 0($sp)
	add  $sp, $sp, 4
	lw   $a0, 0($sp)
# Calcul
	sub  $a0, $a0, $a1
# On met le résultat sur la pile
	sw   $a0, 0($sp)
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
	lw   $a0, 0($sp)
	sw   $a0, 12($fp)
	jr   $ra
	.data
newline:
	.asciiz "\n"

