Quicksort, MIPS

Hej, jag försöker implementera en quicksort program i Mips assembly kod men någonting fungerar inte korrekt som jag inte kan lista ut. Den fungerar första gången den kommer in i partition och första och sista elementet i arrayen byter plats men sedan sorteras inget annat element. Uppgiften var att översätta denna C kod till Assembly kod:

 

 

Här är min översatta Mips kod och outputen:

Tack i förhand!

.data
	antal: .word 10
	vek: .word 10,9,8,7,6,5,4,3,2,1
	newline:    .asciiz "\n"
	space:      .asciiz " "
.text
	.globl main
	main: 
	
    	la $a0, vek         
    	lw $a1, antal       
    	jal skriv
	
	la $a0, vek         
   	li $a1, 0           # Lower a
   	lw $a2, antal       # Upper b initialized to antal
    	subi $a2, $a2, 1   	
   	jal quicksort

    	# Print sorterad array
  	la $a0, vek         
   	lw $a1, antal       
    	jal skriv	
	
	li $v0, 10
	syscall
	
	#   $a0 Address  array v
	#   $a1  Lower  a
	#   $a2 Upper  b
	# Returnerar:
	#   $v0 upper
	partition:
	
	subu $sp, $sp, 32   
    	sw $ra, 28($sp)       
    	sw $s4, 24($sp)
    	sw $s0, 20($sp)
    	sw $s1, 16($sp)
    	sw $s2, 12($sp)
   	sw $a0, 8($sp)       #vek
    	sw $a1, 4($sp)       # a
    	sw $a2, 0($sp)      # b
	move $t3, $a0       # Kopiera adress av array till t3
	lw $t4, 0($t3)	     # t4 = v[a]
	addi $s0, $a1, 1        # Initsiera lower to a +1
	move $s1, $a2     # Initsiera upper to b
	
	
	
	while1:
   	 # Första while loopen i do while: v[lower] <= pivot && lower <= upper
   	sll $t5, $s0,2 #t5 = 4*lower
   	add $t5, $t3, $t5 #t5 = vek + 4*lower
   	lw $t5, 0($t5) #t5 = vek[lower]
   	bgt $t5, $t4, while2 # Exit loop if v[lower] > pivot 
   	bgt $s0, $s1, while2 # Exit loop if lower > upper
   	addi $s0, $s0, 1 
   	j while1
   	
   	while2: 
   	# Andra while loopen: v[upper] > pivot && lower <= upper
   	sll $t6, $s1,2 #t6 = 4*upper
   	add $t6, $t3, $t6 #t6 = vek + 4*upper
   	lw $t6, 0($t6) #t6 = vek[upper]	
   	
   	ble $t6, $t4, swap_elements_partition
   	bgt $s0, $s1, swap_elements_partition
   	subi $s1, $s1, 1
   	j while2
   	
   	swap_elements_partition:
   	sll $t7, $s0,2 #t7 = 4*lower
   	add $t7, $t3, $t7 #t7 = vek + 4*lower
   
   	sll $t8, $s1,2 #t8 = 4*upper
   	add $t8, $t3, $t8 #t8 = vek + 4*upper
   	
   	# Swap v[lower] och v[upper] om lower <= upper
   	bgt $s0, $s1, while
   	
    	sw $t6, 0($t7)
    	sw $t5, 0($t8)
    	
    	addi $s0, $s0, 1
    	subi $s1, $s1, 1
    	
    	b while
    	
   	while: 
   	bgt $s0, $s1, swap_other
   	j while1
   	
   	swap_other:
  	sll $s4, $a1,2 #s4 = 4*a
   	add $s4, $t3, $s4 #s4 = vek + 4*a
   
   	sll $t8, $s1,2 #t8 = 4*upper
   	add $t8, $t3, $t8 #t8 = vek + 4*upper
  	
  	sw $t4, 0($t8)
  	sw $t6, 0($s4)
   	
   	move $v0, $s1
    	                  
    	lw $a2, 0($sp)
    	lw $a1, 4($sp)
    	lw $a0, 8($sp)
    	lw $s2, 12($sp)
    	lw $s1, 16($sp)
    	lw $s0, 20($sp) 
    	lw $s4, 24($sp)   
    	lw $ra, 28($sp)
   	    
   	addiu $sp, $sp, 32
   	jr $ra
   	
	quicksort:
	
	#$a0 - Address av array
	#a1 - Lower a
	#$a2 Upper b
	#Spara $ra till stacken
    	subu $sp, $sp, 24
    	sw $ra, 12($sp) 
    	sw $s3, 8($sp)
    	sw $s4, 4($sp)
    	sw $s5, 0($sp)   
    	
    	#Kolla om a < b
    	bge $a1, $a2, end_quickSort
    	
    	
   	jal partition
   	move $s5, $v0  # $s5 = k
   	addi $t9, $s5, 1 #k+1
   	subi $s3, $s5, 1 #k-1
   	move $s4, $a2
   	move $a2, $s3
   	
   	jal quicksort
   	
   	move $a2, $s4
   	move $a1, $t9
   	jal quicksort
   	
   	
    	lw $s5, 0($sp)
    	lw $s4, 4($sp)
    	lw $s3, 8($sp)
    	lw $ra, 12($sp)
    	addiu $sp, $sp, 24
   	
   	end_quickSort:
    	jr $ra
    	
	skriv:
   	li $t0, 0           #index=0
   	move $t2, $a0       #Kopiera adress av array till t2
   	
   	li $v0, 4
   	la $a0, newline
   	syscall
   	loop: 
   	bge $t0, $a1, end
   	lw $t1, 0($t2)
   	li $v0, 1
   	move $a0, $t1
   	syscall
   	
   	li $v0, 4           
    	la $a0, space       
    	syscall
    	
    	addi $t0, $t0, 1    #i++
    	addi $t2, $t2, 4    #Gå vidare till nästa element i array
    	j loop
   	
   	end: 
   	li $v0, 4           
   	la $a0, newline     
    	syscall
   	
	jr $ra