Last login: Wed Jan 22 18:44:18 on ttys000
luke@Lukes-MacBook-Pro ~ % open .
luke@Lukes-MacBook-Pro ~ % cd
luke@Lukes-MacBook-Pro ~ % ls
154sort		Documents	Movies		Public		nano.save
Applications	Downloads	Music		PycharmProjects
CLionProjects	IdeaProjects	Musing		School
Desktop		Library		Pictures	bin
luke@Lukes-MacBook-Pro ~ % nano 154sort






















































  GNU nano 2.0.6                                                        File: 154sort                                                                                                             Modified

.data:


.text
        swap:                                   #a1 = index k, a0 = vector v
                sll     $t1, $a1, 2             #t1 = k * 4
                add     $t1, $a0, $t1           #t1 = v + (k * 4). i.e memory address of kth element in v
                lw      $t0, 0($t1)             #t0 (temp) = v[k]
                lw      $t2, 4($t1)             #t2 = v[k+1]
                sw      $t2, 0($t1)             #v[k] = word in t2
                sw      $t0, 4($t1)             #v[k+1] = word in t0. v[k] and v[k+1] have been swapped
                jr      $ra                     #return to caller
        sort:                                   #array length = 16 = 16*4 bytes = 64 bytes
                addi    $sp, $sp, -20           #making room for 5 registers
                sw      $s0, 0($sp)
                sw      $s1, 4($sp)
                sw      $s2, 8($sp)
                sw      $s3, 12($sp)
                sw      $ra, 16($sp)
                move    $s0, $a0                #preserving a0 (v)
                move    $s1, $a1                #preserving a1 (k)
                move    $s2, $zero              #s2 = i = 0
        outerloop:
                slt     $t0, $s2, $s1           #check if i < n. t0 = 0 if i >= n
                beq     $t0, $zero, exit        #i >= n : exit loop

                addi    $s1, $s2, -1            #j = i -1
        innerloop:
                slti    $t0, $s1, 0             #t0 = 1 if j < 0
                bne     $t0, $zero, iterate     #exit if j < 0
                sll     $t1, $s1, 2             #t1 = j*4
                add     $t2, $a0, $t1           #t2 = v + (j*4). i.e memory address of jth element in v
                lw      $t3, 0($t2)             #t3 = v[j]
                lw      $t4, 4($t2)             #t4 = v[j+1]
                slt     $t0, $t4, $t3           #t0 = 0 if v[j+1] > v[j]
                beq     $t0, $zero, iterate     #back to outerloop if v[j+1] > v[j]
                move    $a0, $s0                #moving back paramaters to call
                move    $a1, $s1
                jal     swap
                addi    $s1, $s1, -1            #j -= 1
                j       innerloop               #inner loop iterate
        iterate:
                addi    $s2, $s2, 1             #i += 1
                j       outerloop               #outer loop iterate

        exit:
                lw      $s0, 0($sp)
                lw      $s1, 4($sp)
                lw      $s2, 8($sp)
                lw      $s3, 12($sp)
                lw      $ra, 16($sp)
                addi    $sp, $sp, 20            #restoring stack