.text

## bool
## board_done(unsigned short board[16][16]) {
##   for (int i = 0 ; i < 16 ; ++ i) {
##     for (int j = 0 ; j < 16 ; ++ j) {
##       if (!has_single_bit_set(board[i][j])) {
##         return false;
##       }
##     }
##   }
##   return true;
## }

.globl board_done
board_done:
    sub $sp, $sp, 16        # allocate stack
    sw  $ra, 0($sp)     # save $ra
    sw  $s0, 4($sp)     # save $s0
    sw  $s1, 8($sp)     # save $s1
    sw  $s2, 12($sp)        # save $s2

    move    $s0, $a0        # save &board because it will be overwritten before jal

    li  $s1, 0          # i = 0

outer_loop:
    li  $s2, 0          # j = 0

inner_loop:
    mul $t0, $s1, 16        # i * N
    add $t0, $t0, $s2       # (i * N) + j
    mul $t0, $t0, 2     # ((i * N) + j) * sizeof(element)

    move    $a0, $s0        # restore $a0
    add $t0, $t0, $a0       # &board[i][j]
    lhu $a0, 0($t0)     # board[i][j]
    jal has_single_bit_set  # has_single_bit_set(board[i][j])

    beq $v0, 1, end_loop    # if (!has_single_bit_set(board[i][j]))
    move    $v0, $zero      # return false
    lw  $ra, 0($sp)     # restore $ra
    jr  $ra

end_loop:
    add $s2, $s2, 1     # ++j
    blt $s2, 16, inner_loop # j < 16

    add $s1, $s1, 1     # ++i
    blt $s1, 16, outer_loop # i < 16

    add $v0, $zero, 1       # return true


    lw  $ra, 0($sp)     # restore $ra
    lw  $s0, 4($sp)     # restore $s0
    lw  $s1, 8($sp)     # restore $s1
    lw  $s2, 12($sp)        # restore $s2
    add $sp, $sp, 16        # deallocate stack

    jr  $ra


## void
## print_board(unsigned short board[16][16]) {
##   for (int i = 0 ; i < 16 ; ++ i) {
##     for (int j = 0 ; j < 16 ; ++ j) {
##       int value = board[i][j];
##       char c = '*';
##       if (has_single_bit_set(value)) {
##         int num = get_lowest_set_bit(value) + 1;
##         c = symbollist[num];
##       }
##       putchar(c);
##     }
##     putchar('\n');
##   }
## }

.globl print_board
print_board:
    sub $sp, $sp, 28        # allocate stack
    sw  $ra, 0($sp)     # save $ra
    sw  $s0, 4($sp)     # save $s0
    sw  $s1, 8($sp)     # save $s1
    sw  $s2, 12($sp)        # save $s2
    sw  $s3, 16($sp)        # save $s3
    sw  $s4, 20($sp)        # save $s4
    sw  $s5, 24($sp)        # save $s5
    #sw $s6, 28($sp)        # save $s6

    move    $s0, $a0        # save $a0
    li  $s1, 0          # i = 0

outer_loop2:
    li  $s2, 0          # j = 0

inner_loop2:
    mul $t0, $s1, 16        # i * N
    add $t0, $t0, $s2       # (i * N) + j
    mul $t0, $t0, 2     # ((i * N) + j) * sizeof(element)

    move    $a0, $s0        # restore $a0
    add $t0, $t0, $a0       # &board[i][j]
    lhu $a0, 0($t0)     # value = board[i][j]
    li  $s3, '*'        # c = '*'
    jal has_single_bit_set  # has_single_bit_set(value)
    beq $v0, $zero, skip    # if (has_single_bit_set(value)
    jal get_lowest_set_bit  # get_lowest_set_bit(value)
    add $s4, $v0, 1     # num = get_lowest_set_bit(value) + 1

    la  $s5, symbollist     # &symbollist
    #mul    $s4, $s4, 1     # num *= 4
    add $s4, $s4, $s5       # num += &symbollist
    lb  $s3, 0($s4)     # c = symbollist[num]
skip:
    move    $a0, $s3        # putchar(c)
    li  $v0, 11
    syscall

end_loop2:
    add $s2, $s2, 1     # ++j
    blt $s2, 16, inner_loop2    # j < 16

    li  $a0, '\n'       # putchar('\n')
    li  $v0, 11
    syscall

    add $s1, $s1, 1     # ++i
    blt $s1, 16, outer_loop2    # i < 16

    lw  $ra, 0($sp)     # restore $ra
    lw  $s0, 4($sp)     # restore $s0
    lw  $s1, 8($sp)     # restore $s1
    lw  $s2, 12($sp)        # restore $s2
    lw  $s3, 16($sp)        # restore $s3
    lw  $s4, 20($sp)        # restore $s4
    lw  $s5, 24($sp)        # restore $s5
    #lw $s6, 28($sp)        # restore $s6
    add $sp, $sp, 28        # deallocate stack

    jr  $ra