.data
x0:	.word 0x12345678
x1: .word 0x00000000
x2: .word 0x90ABCDEF
x3: .word 0x12345678
nl: .ascii "\n"
m64: .asciiz "mul64:\n"
m128: .asciiz "mul128:\n"
buf:.space(34)
	.text
	.globl	main
	
changesign:
	nor   $v0, $a0, $0
	nor   $v1, $a1, $0
	addiu $t0, $v0, 1
	sltu  $t1, $t0, $v0
	addu  $v1, $v1, $t1
	add   $v0, $t0, $0
	jr    $ra
	
mul64:	
	addi  $sp, $sp, -8   # space for ra and 5th param of hexprint
	sw    $ra, 4($sp)
	multu $a0, $a2       # a0*a2
	mflo  $v0            # lo(a0*a2)
	mfhi  $v1            # hi(a0*a2)
	multu $a1, $a2       # a1*a2
	mflo  $t0            # lo(a1*a2)
	addu  $v1, $v1, $t0  # hi(a0*a2)+lo(a1*a2)
	multu $a0, $a3       # a0*a3
	mflo  $t0            # lo(a0*a3)
	addu  $v1, $v1, $t0  # hi(a0*a2)+lo(a1*a2)+lo(a0*a3)
	add   $a0, $0, $v0
	add   $a1, $0, $v1
	addi  $t9, $0, 16    # 64 bit printing
	sw    $t9, 0($sp)    # push onto the stack the 5th param
	jal   hexprint		 # print result
	lw    $ra, 4($sp)
	addi  $sp, $sp, 8
	jr    $ra
	
mul128:
	addi  $sp, $sp, -8   # space for ra and 5th param of hexprint
	sw    $ra, 4($sp)
	slt   $t9, $a3, $0   # sgn(a3:a2)
	slt   $t8, $a1, $0   # sgn(a1:a0)
	xor   $t7, $t9, $t8  # sgn(a3:a2) XOR sgn(a1:a0)
	
	beq   $t8, $0, noch1
	jal   changesign
	add   $a0, $v0, $0
	add   $a1, $v1, $0
noch1:
	beq   $t9, $0, noch2
	addi  $sp, $sp, -8
	sw    $a0, 0($sp)    # save $a0, $a1
	sw    $a1, 4($sp)
	add   $a0, $a2, $0
	add   $a1, $a3, $0
	jal   changesign
	add   $a2, $v0, $0
	add   $a3, $v1, $0
	lw    $a0, 0($sp)    # restore $a0, $a1
	lw    $a1, 4($sp)
	addi  $sp, $sp, 8
noch2:
	
	multu $a0, $a2       # a0*a2
	mflo  $t0            # lo(a0*a2)
	mfhi  $t1			 # hi(a0*a2)
	nor   $t5, $t1, $0   #
	multu $a1, $a2       # a1*a2
	mflo  $t4            # lo(a1*a2)
	mfhi  $t2            # hi(a1*a2)
	sltu  $t5, $t5, $t4  # carry(hi(a0*a2)+lo(a1*a2)
	addu  $t1, $t1, $t4  # hi(a0*a2)+lo(a1*a2)
	multu $a0, $a3       # a0*a3
	add   $t2, $t2, $t5  # hi(a1*a2)+carry
	nor   $t5, $t1, $0   # 
	mflo  $t4            # lo(a0*a3)
	mfhi  $t3            # hi(a0*a3)
	sltu  $t5, $t5, $t4  # carry(hi(a0*a2)+lo(a1*a2)+lo(a0*a3))
	addu  $t1, $t1, $t4  # hi(a0*a2)+lo(a1*a2)+lo(a0*a3)
	multu $a1, $a3       # a1*a3
	add	  $t2, $t2, $t5  # hi(a1*a2)+carry+carry
	nor   $t4, $t2, $0   #
	sltu  $t4, $t4, $t3  # carry(hi(a1*a2)+hi(a0*a3))
	addu  $t2, $t2, $t3  # hi(a1*a2)+hi(a0*a3)
	nor   $t5, $t2, $0   #
	mfhi  $t3            # hi(a1*a3)
	add   $t3 $t3, $t4   # hi(a1*a3)+carry(hi(a1*a2)+hi(a0*a3))
	mflo  $t4            # lo(a1*a3)
	sltu  $t5, $t5, $t4  # carry(hi(a1*a2)+hi(a0*a3)+lo(a3*a0))
	add   $t3, $t3, $t5  # hi(a1*a3)+carry+carry
	addu  $t2, $t2, $t4  # hi(a1*a2)+hi(a0*a3)+lo(a3*a0)

	beq   $t7, $0, noch3
	nor   $t0, $t0, $0
	nor   $t1, $t1, $0
	nor   $t2, $t2, $0
	nor   $t3, $t3, $0
	
	addiu $t4, $t0, 1
	sltu  $t5, $t4, $t0
	add   $t0, $t4, $0
	
	addu  $t4, $t1, $t5
	sltu  $t5, $t4, $t1
	add   $t1, $t4, $0
	
	addu  $t4, $t2, $t5
	sltu  $t5, $t4, $t2
	add   $t2, $t4, $0
	
	addu  $t3, $t3, $t5
noch3:
	add   $a0, $0, $t0
	add   $a1, $0, $t1
	add   $a2, $0, $t2
	add   $a3, $0, $t3
	addi  $t9, $0, 32    # 128 bit printing
	sw    $t9, 0($sp)    # push onto the stack the 5th param
	jal   hexprint       # print result
    
	lw    $ra, 4($sp)
	addi  $sp, $sp, 8
	jr    $ra
	
hexprint:
	lw    $t9, 0($sp)    # read the lenght of the hex string
	la    $t0, buf 		 # buffer address
	add   $t1, $t0, $t9	 #
	addi  $t1, $t0, 1  	 # point ot the end of the buffer
	sb    $0,  0($t1)  	 # end of string
	la    $t1, nl      	 # read the new line character
	lb    $t1, 0($t1)  	 #
	add   $t0, $t0, $t9  # point to the last character of the buf
	addi  $t8, $0, 8     # constant 8

loop1:
	sb    $t1, 0($t0)    # store character
	addi  $t9, $t9, -1   # update buffer counter
	addi  $t0, $t0, -1   # update buffer pointer
	slti  $t3, $t9, 0    
	andi  $t1, $a0, 0xF  # get last hex digit
	srl   $a0, $a0, 4    # shift right the other digits
	addi  $t1, $t1, 0x30 # transform into a ASCII char
	slti  $t2, $t1, 0x3A #
	bne	  $t2, $0,  step1# if greater than 9
	addi  $t1, $t1, 7    # add 7 --> A, B, C, D, E, F 
step1:
	div   $t9, $t8       # check if done with 8 digits
	mfhi  $t4            # 
	bne   $t4, $0,  step2# if so:
	add   $a0, $a1, $0   # shift right the other registers
	add   $a1, $a2, $0   #
	add   $a2, $a3, $0   #
step2:	
	beq   $t3, $0,  loop1# loop on all digits
	addi  $a0, $t0, 1    # point to the beginning of the buf
	addi  $v0, $0,  4    # print the hex string
	syscall
	jr    $ra
	
main:
	la    $a0, m64
	addi  $v0, $0, 4
	syscall              # print "mul64:"

	la    $s0, x0        # (s1:s0)=(x1:x0)
	lw    $s0, 0($s0)
	la    $s1, x1
	lw    $s1, 0($s1)
	
	add   $a0, $s0, $0   # print 1st operand
	add   $a1, $s1, $0
	addi  $t9, $0, 16    # 64 bit printing
	addi  $sp, $sp, -4
	sw    $t9, 0($sp)    # push onto the stack the 5th param
	jal   hexprint		 # print operand
	addi  $sp, $sp 4     # restore the stack

	add   $a0, $s0, $0
	add   $a1, $s1, $0
	jal changesign
	add   $s2, $v0, $0
	add   $s3, $v1, $0

	add   $a0, $v0, $0   # print 2nd operand
	add   $a1, $v1, $0
	addi  $t9, $0, 16    # 64 bit printing
	addi  $sp, $sp, -4
	sw    $t9, 0($sp)    # push onto the stack the 5th param
	jal   hexprint		 # print operand
	addi  $sp, $sp 4     # restore the stack

	add   $a0, $s0, $0
	add   $a1, $s1, $0
	add   $a2, $s0, $0
	add   $a3, $s1, $0
	jal   mul64          # do 64-bit multiplication

	add   $a0, $s0, $0
	add   $a1, $s1, $0
	add   $a2, $s2, $0
	add   $a3, $s3, $0
	jal   mul64          # do 64-bit multiplication

	la    $a0, m128
	addi  $v0, $0, 4
	syscall			 	 # print "mul128:"

	la    $s0, x2        # (s1:s0)=(x3:x2)
	lw    $s0, 0($s0)
	la    $s1, x3
	lw    $s1, 0($s1)
	
	add   $a0, $s0, $0   # print 1st operand
	add   $a1, $s1, $0
	
	addi  $t9, $0, 16    # 64 bit printing
	addi  $sp, $sp, -4
	sw    $t9, 0($sp)    # push onto the stack the 5th param
	jal   hexprint		 # print operand
	addi  $sp, $sp 4     # restore the stack

	add   $a0, $s0, $0
	add   $a1, $s1, $0
	jal changesign
	add   $s2, $v0, $0   # (s3:s2)= - (x3:x2)
	add   $s3, $v1, $0

	add   $a0, $v0, $0   # print 2nd operand
	add   $a1, $v1, $0
	
	addi  $t9, $0, 16    # 64 bit printing
	addi  $sp, $sp, -4
	sw    $t9, 0($sp)    # push onto the stack the 5th param
	jal   hexprint		 # print operand
	addi  $sp, $sp 4     # restore the stack
	
	add   $a0, $s0, $0
	add   $a1, $s1, $0
	add   $a2, $s0, $0
	add   $a3, $s1, $0
	jal   mul128          # do 128-bit multiplication

	add   $a0, $s0, $0
	add   $a1, $s1, $0
	add   $a2, $s2, $0
	add   $a3, $s3, $0
	jal   mul128          # do 128-bit multiplication

	addi  $v0, $0, 10
	syscall