# a0 is return var
# a1, a2 are func arguments

.data
argument:      .word 7
start_str:     .string "["
div_str:       .string ","
end_str:       .string "]"

.text
main:
    lw  s0, argument            # a_n = argument     (a_n is s0)                 
    li  s1, 0                   # nStar = 0          (nStar is s1)                
    jal ra, print_start
main_loop:
    li t0, 4                    # if res == 4 { goto end_loop }
    beq s0, t0, end_loop        # |     
    
    mv a0, s0                   # print_num(a_n)
    jal ra, print_num           # |
    jal ra, print_div           # print_div()
    
    mv a1, s0                   # res = a_n % 2 (res is a0)
    li a2, 2                    # |
    jal ra, modulo              # |
    
    bne a0, x0, else            # if res != 0 { goto else }
    
    mv a1, s0                   # a_n = a_n / 2
    li a2, 2                    # |
    jal ra, div                 # |
    mv s0, a0,                  # |
    
    j end                       # goto end      
else:
    li a1, 3                    # a_n = 3 * a_n + 1
    mv a2, s0                   # |
    jal ra, mul                 # |
    addi s0, a0, 1              # |
end:
    addi, s1, s1, 1             # nStar = nStar + 1
    j main_loop                 # goto main_loop
end_loop:
    
    mv a0, s0                   # print_num(a_n)
    jal ra, print_num           # |
    jal ra, print_end           # print_end()         
    
exit:
    li a0, 0
    li a7, 10
    ecall



                                
                                # x is a1
                                # y is a2
                                # res is a0
                                # i is t0
                                
mul:                            # fn mul(int x, int y) -> int   
    mv a0, x0                   # res = 0                            
    li t0, 0                    # i = 0                              
mul_loop:
    bge t0, a2, mul_return      # if i >= y { goto mul_return }
    add a0, a0, a1              # res = res + x
    addi t0, t0, 1              # i = i + 1
    j mul_loop                  # goto mul_loop
mul_return:
    jr ra                       # return res
    
                            
div:                            # fn div(int x, int y) -> int        
    mv a0, x0                   # res = 0                            
div_loop:
    blt a1, a2, div_return      # if x < y { goto div_return }
    sub a1, a1, a2              # x = x - y
    addi a0, a0, 1              # res = res + 1
    j   div_loop                # goto div_loop
    
div_return:
    jr ra                       # return res
    
    
    
                                # x is a1
                                # y is a2
                                
modulo:                         # fn modulo(int x, int y) -> int 
modulo_loop:                       
    blt a1, a2, modulo_return   # if x < y { goto modulo_return }
    sub a1, a1, a2              # x = x - y
    j   modulo_loop             # goto modulo_loop
modulo_return:                     
    mv a0, a1                   # return x
    jr ra                       # |
      
      
      
                                # x is a1
                                
print_num:                      # fn print(int x) 
    li a7, 1                    # print(x)
    ecall                       # |
    jr ra                       # return
    
    
print_start:                    # fn print_start()       
    la a0, start_str            # print(start_str)
    li a7, 4                    # |
    ecall                       # |
    jr ra                       # return
    
    
    
print_div:                      # fn print_div()       
    la a0, div_str              # print(div_str)
    li a7, 4                    # |
    ecall                       # |
    jr ra                       # return
    
    
    
print_end:                      # fn print_end()       
    la a0, end_str              # print(end_str)
    li a7, 4                    # |
    ecall                       # |
    jr ra                       # return