main:

    # for t0 = 1 to 10 words
    li $t0 0
    for1:
    slti $t1 $t0 40
    beq $t1 $zero endfor1
    #

    # input word
    li $v0 5
    syscall
    sw $v0 a($t0)
    #

    # next t0
    addi $t0 4
    j for1
    endfor1:
    #

    # test
    la $a0 a
    li $a1 0
    li $a2 36
    jal maxSumRec
    move $v1 $v0
    #


    # exit
    li $v0 10
    syscall
    #


#   private static int maxSumRec( int [ ] a, int left, int right )
#   {
    maxSumRec:
    addi $sp $sp -32
    sw $ra 28($sp)
    sw $s3 24($sp)
    sw $s2 20($sp)
    sw $s1 16($sp)
    sw $s0 12($sp)
    sw $a2 8($sp)
    sw $a1 4($sp)
    sw $a0 0($sp)
#       if( left == right )  // Base case
        bne $a1 $a2 endif1
#           if( a[ left ] > 0 )
            lw $t1 a($a1)
            slt $t0 $zero $t1
            beq $t0 $zero else1
#               return a[ left ];
                move $v0 $t1
                j return
#           else
            else1:
#               return 0;
                li $v0 0
                j return
        endif1:

#       int center = ( left + right ) / 2;
        add $s0 $a1 $a2
        srl $s0 $s0 1
#       int maxLeftSum  = maxSumRec( a, left, center );
        move $s3 $a2
        move $a2 $s0
        jal maxSumRec
        move $s1 $v0
        move $a2 $s3
#       int maxRightSum = maxSumRec( a, center + 1, right );
        move $s3 $a1
        addi $a1 $s0 4
        jal maxSumRec
        move $s2 $v0
        move $a1 $s3

#       int maxLeftBorderSum = 0, leftBorderSum = 0;
        li $t1 0
        li $t2 0
#       for( int i = center; i >= left; i-- )
        move $t0 $s0
        for2:
        slt $t3 $t0 $a1
        bne $t3 $zero endfor2
#       {
#           leftBorderSum += a[ i ];
            lw $t4 a($t0)
            add $t2 $t2 $t4
#           if( leftBorderSum > maxLeftBorderSum )
            slt $t3 $t1 $t2
            bne $t3 $zero endif2
#               maxLeftBorderSum = leftBorderSum;
                move $t1 $t2
            endif2:
#       }
        addi $t0 $t0 -4
        j for2
        endfor2:

        move $t6 $t1

#       int maxRightBorderSum = 0, rightBorderSum = 0;
        li $t1 0
        li $t2 0
#       for( int i = center + 1; i <= right; i++ )
        addi $t0 $s0 4
        for3:
        slt $t3 $s0 $s2
        bne $t3 $zero endfor3
#       {
#           rightBorderSum += a[ i ];
            lw $t4 a($t0)
            add $t2 $t2 $t4
#           if( rightBorderSum > maxRightBorderSum )
            slt $t3 $t1 $t2
            bne $t3 $zero endif3
#               maxRightBorderSum = rightBorderSum;
                move $t1 $t2
            endif3:
#       }
        addi $t0 $t0 4
        j for3
        endfor3:



#       return max3( maxLeftSum, maxRightSum,
#                    maxLeftBorderSum + maxRightBorderSum );
        move $a0 $s1
        move $a1 $s2
        add $a2 $t1 $t6
        jal max3

        return:
        lw $ra 28($sp)
        lw $s3 24($sp)
        lw $s2 20($sp)
        lw $s1 16($sp)
        lw $s0 12($sp)
        lw $a2 8($sp)
        lw $a1 4($sp)
        lw $a0 0($sp)
        addi $sp $sp 32

        jr $ra
#   }


#   private static int max3( int a, int b, int c )
    max3:
#   {
#       return a > b ? a > c ? a : c : b > c ? b : c;
        move $v0 $a0
        slt $t0 $v0 $a1
        beq $t0 $zero skip1
        move $v0 $a1
        skip1:
        slt $t0 $v0 $a2
        beq $t0 $zero skip2
        move $v0 $a2
        skip2:
        jr $ra
#   }

.data
    a: .space 40    # array to hold 10 words or integers