# 
# boot1.s - version 0.3
#
#  Contains tests for your microprocessor.
#
#  To use:
#   1. Select test number on dip switch (0-3)
#   2. Reset
#   3. Should see 0xdeadbeef
#   4. Resume
#   5. Should see 0xc0de0000 | [test#]
#   6. Resume to execute test.
#
#  Boot Error codes:
#   1. 0xDeadc0de -> Invalid (too high) test number
#
#  Included tests:	
#
#   T 0: Loop forever.
#   T 1: Basic from lab 4
#   T 2: Corner from lab 4
#
#
#  To add a test:
#   1. Create block(s).
#	o Run your block in spim first!!
#       o Use .address to set where you want
#         block to be. This will make jumps
#         work. If you don't care where the
#         block ends up, don't use this.
#       o Set length using .count directive.
#       o Set execution address using
#	  .word directive with argument
#	  of the label of the first instruction
#	  the block.
#       o Look at B0 and T1 for help.
#   2. In B0:	
#       o Update # of tests (label B0_tn)
#       o Add jump table entry (label B0_jt)
#   3. Assemble
#       o Use new web-based mipsasm. The new
#         version does very little error and
#         syntax checking, so make sure that
#         you test your block in spim.


__start:

#
# Block 0: Select and run test from dipswitches
#
	.address 0x00000004	# Write this at 0x4
B0:	.count words B0_s B0_e	# length of Block 0
	.word B0_s		# Starting address	
B0_s:	lw $t0 -8($0)		# Get test # from dipswitch
	lui $t2 B0_xx		# La B0_xx (for bogus stores)
	ori $t2 $t2 B0_xx
	sw $0 0($t2)		# 4 bogus stores to flush WB
	sw $0 4($t2)
	sw $0 8($t2)
	sw $0 12($t2)
	lui $t1	0xc0de		# put test # on dp0+1
	ori $t1 $t1 $t0		
	sw $t1 -16($0)		
	sw $t1 -12($0)
	lui $t1 B0_tn		# Get total # of tests
	ori $t1 $t1 B0_tn
	lw $t1 0($t1)
	sltu $t1 $t0 $t1	# check: test # in bounds?
	beq $t1 $0 B0_it	 
	lui $t3 B0_jt		# la B0_jt (jumptable)
	ori $t3 $t3 B0_jt	
	sll $t0 $t0 2		# Calculate index+jt address
	addiu $t3 $t0 $t3
	lw $t3 0($t3)		# Load test starting address
	break 1			# Pause
	jr $t1			# Go!

B0_it:	lui $t1 0xdead		# invalid test number.
	ori $t1 $t1 0xc0de
	sw $t1 -8($0)		# print error to DP0
	j B0_it			# loop forever
	sll $0 $0 0	
	
B0_tn:	.word 4			# Of tests (including Test 0)

B0_jt:	.word B0_s		# Test 0: Loop forever	
	.word T1_s		# Test 1: Basic from lab 4
	.word T2_s		# Test 2: Corner from lab 4
	
B0_xx	.word 0xdead0000	# Extra storage
	.word 0xdead0001
	.word 0xdead0002
	.word 0xdead0003
		
B0_e:	.word -1		# B0 endpoint boundary	


############################################################
############################################################	
#
#  Test 1: Basic from lab 4
#

B1:	
	#.address		# we will leave address unchanged
				# This block will be right up
				# against B0.
	.count words B1_s B1_e	# length of B1
	.word B1_s		# Execution address
B1_s:
T1_s:	
B1_test0:
	addiu	$2, $0, 5	#testing addiu
	addiu	$3, $0, 5	#testing addiu
	addiu	$4, $0, -5
	addiu	$23, $0, 0	#used to keep track of failed tests

	beq	$2, $2, B1_L1 	#testing beq
	ori	$0, $0, 0
	addiu	$2, $2, -5
B1_L1:	
	bne	$3, $0, B1_L2	#testing bne 
	ori	$0, $0, 0
	addiu	$3, $3, -5
B1_L2:	
	beq	$2, $0, B1_test0_fail
	ori	$0, $0, 0
	bne	$2, $3, B1_test0_fail
	ori	$0, $0, 0
	beq	$2, $0, B1_test0_fail
	ori	$0, $0, 0
	bne	$2, $2, B1_test0_fail
	ori	$0, $0, 0
	ori	$0, $0, 0
	
	lui	$5, 0xFFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$5, $5, 0xFFFB
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$4, $5, B1_test0_fail
	ori	$0, $0, 0
	j B1_test1
	ori	$0, $0, 0	#NOP
B1_test0_fail:
	ori	$23, $23, 0x1
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2

B1_test1: #test addu, addiu, subu
	addiu	$6, $0, 1	#$6 = small number
	addiu	$7, $0, 52	#$7 = another number
	lui	$8, 0x8000	#$8 = smallest negative number (0x80000000)
	addiu	$9, $0, -5	#$9 = negative number
	addiu	$10, $0, -48	#$10 = negative number
	ori	$0, $0, 0
	addiu	$11, $8, -1	#$11 = largest number(0x7FFFFFFF)
	
	addu	$12, $6, $7	#testing addu with 2 positive numbers
	addiu	$13, $0, 53
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0	
	bne	$12, $13, B1_test1_fail
	
	addu	$14, $9, $10	#testing addu for adding 2 negative numbers
	addiu	$15, $0, -53
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$14, $15, B1_test1_fail

	addu	$16, $6, $9	#test addu with one pos and one neg number
	addiu	$17, $0, -4
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$16, $17, B1_test1_fail

	addiu	$18, $6, 52	#testing addiu with 2 positive numbers
	addiu	$19, $0, 53
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0	
	bne	$18, $19, B1_test1_fail
	
	addiu	$20, $9, -48	#testing addiu for adding 2 negative numbers
	addiu	$21, $0, -53
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$20, $21, B1_test1_fail

	addiu	$24, $6, -5	#test addiu with one pos and one neg number
	addiu	$25, $0, -4
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$24, $25, B1_test1_fail

	subu	$26, $6, $7	#testing subu with 2 positive numbers
	addiu	$27, $0, -51
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0	
	bne	$26, $27, B1_test1_fail
	
	subu	$2, $9, $10	#testing subu for adding 2 negative numbers
	addiu	$3, $0, 43
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$2, $3, B1_test1_fail

	subu	$4, $6, $9	#test subu with one pos and one neg number
	addiu	$5, $0, 6
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$4, $5, B1_test1_fail
	ori	$0, $0, 0
	j B1_test2
	ori	$0, $0, 0	#NOP
B1_test1_fail:
	ori	$23, $23, 0x2
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2
	
B1_test2:	#test and, andi, or, ori
	addiu	$2, $0, 0x5A5A		#$2 = 0x00005A5A
	addiu	$3, $0, 0x2525		#$3 = 0x00002525
	ori	$4, $0, 0xFFFF		#$4 = 0x0000FFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	
	and	$5, $2, $3		#test and
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$5, $0, B1_test2_fail

	lui	$6, 0x6789		#test and for no sign extension
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	and	$7, $6, $4
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$7, $0, B1_test2_fail
	
	andi	$8, $2, 0x2525		#test andi
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$8, $0, B1_test2_fail
	
	lui	$9, 0x6789		#test andi for no sign extension
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	andi	$10, $9, 0xFFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0	
	bne	$10, $0, B1_test2_fail

	or	$11, $2, $3		#test or
	addiu	$12, $0, 0x7F7F
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$11, $12, B1_test2_fail
	
	lui	$13, 0x6789		#test or for no sign extension
	addiu	$14, $0, -1 
	ori	$0, $0, 0
	or	$13, $13, $4
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0	
	beq	$13, $14, B1_test2_fail

	ori	$15, $2, 0x2525		#test ori
	addiu	$16, $0, 0x7F7F
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$15, $16, B1_test2_fail
	
	lui	$17, 0x6789		#test ori for no sign extension
	addiu	$18, $0, -1
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$17, $17, 0xFFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0	
	beq	$17, $18, B1_test2_fail
	
	ori	$0, $0, 0	#NOP
	j B1_test3
	ori	$0, $0, 0	#NOP
B1_test2_fail:
	ori	$23, $23, 0x4
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2

B1_test3:	#test xor, xori, lui
	addiu	$2, $0, 0x0F0F		#$2 = 0x00000F0F
	ori	$3, $0, 0xFF00		#$3 = 0x0000FF00
	ori	$4, $0, 0xF00F		#$4 = 0x0000F00F
	ori	$0, $0, 0
	ori	$0, $0, 0
	
	xor	$5, $2, $3		#testing xor 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$5, $4, B1_test3_fail

	xori	$6, $3, 0x0F0F		#testing xori 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$6, $4, B1_test3_fail		

	xori	$7, $2, 0xFF00		#testing xori for no sign extension
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$7, $4, B1_test3_fail

	addiu	$8, $0, 0x0001		#testing lui, especially for setting last 16bits to 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	lui	$8, 0xFFFF
	addiu	$9, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	lui	$9, 0xFFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$8, $9, B1_test3_fail
	
	ori	$0, $0, 0	#NOP
	j B1_test4
	ori	$0, $0, 0	#NOP
B1_test3_fail:
	ori	$23, $23, 0x8
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2

B1_test4:  #test sll, sra, srl
	addiu	$2, $0, 0x5A5A		#$2 = 0x00005A5A
	addiu	$3, $0, 0x2525		#s1 = 0x00002525
	ori	$0, $0, 0
	ori	$0, $0, 0
	
	sll	$4, $2, 16		#testing sll
	addiu	$5, $0, 0
	lui	$5, 0x5A5A
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$4, $5, B1_test4_fail

	#sll	$6, $2, -5		#testing sll with negative shift
	#addiu	$7, $0, 0
	#lui	$7, 0xD000
	#ori	$0, $0, 0
	#ori	$0, $0, 0
	#ori	$0, $0, 0
	#bne	$6, $7, B1_test4_fail
	
	sll	$8, $4, 16		#testing that the bits at the end fall off
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$8, $0, B1_test4_fail

	lui	$9, 0x0FFF		#test sra
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0 
	sra	$10, $9, 16
	ori	$11, $0, 0x0FFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$10, $11, B1_test4_fail

	lui	$12, 0xFFFF		#test sra for sign extension
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0 
	sra	$13, $12, 16
	addiu	$14, $0, -1
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$13, $14, B1_test4_fail
	
	sra	$15, $10, 16		#testing that the bits at end fall off
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$15, $0, B1_test4_fail

	lui	$16, 0x0FFF		#test srl
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0 
	srl	$17, $16, 16
	ori	$18, $0, 0x0FFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$17, $18, B1_test4_fail

	lui	$19, 0xFFFF		#test srl for no sign extension
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0 
	srl	$20, $19, 16
	ori	$21, $0, 0xFFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$20, $21, B1_test4_fail
	
	srl	$22, $20, 16		#testing that the bits at end fall off
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$22, $0, B1_test4_fail

	ori	$0, $0, 0	#NOP
	j B1_test5
	ori	$0, $0, 0	#NOP 
B1_test4_fail:
	ori	$23, $23, 0x10
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2

B1_test5: #testing slt, sltu
	addiu	$2, $0, 1	#$2 = small number
	addiu	$3, $0, 52	#$3 = another number
	lui	$4, 0x8000	#$4 = smallest negative number (0x80000000)
	addiu	$5, $0, -5	#$5 = negative number
	addiu	$6, $0, -48	#$6 = negative number
	ori	$0, $0, 0
	addiu	$7, $4, -1	#$7 = largest number(0x7FFFFFFF)
	
	slt	$8, $2, $3	#testing slt with 2 pos num
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$8, $0, B1_test5_fail

	slt	$9, $3, $2	#with 2 pos num, reg reversed 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$9, $0, B1_test5_fail
	
	slt	$10, $5, $6	#with 2 neg num 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$10, $0, B1_test5_fail

	slt	$11, $6, $5	#with 2 neg num, reg reversed
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$11, $0, B1_test5_fail
	
	slt	$12, $3, $6	#with one pos and one neg number
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$12, $0, B1_test5_fail

	slt	$13, $6, $3	#with one pos and one neg num, reg reversed
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$13, $0, B1_test5_fail

	slt	$14, $6, $6	#test if both reg are equal
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$14, $0, B1_test5_fail
	
	slt	$15, $4, $4	#test if both reg are equal
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$15, $0, B1_test5_fail

	slt	$16, $4, $2	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$16, $0, B1_test5_fail

	slt	$17, $7, $5	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$17, $0, B1_test5_fail

	sltu	$18, $2, $3	#testing sltu with 2 pos num
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$18, $0, B1_test5_fail

	sltu	$19, $3, $2	#with 2 pos num, reg reversed 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$19, $0, B1_test5_fail

	sltu	$20, $6, $6	#test if both reg are equal
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$20, $0, B1_test5_fail
	
	sltu	$21, $4, $4	#test if both reg are equal
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$21, $0, B1_test5_fail

	sltu	$22, $4, $2	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$22, $0, B1_test5_fail

	sltu	$24, $7, $5	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$24, $0, B1_test5_fail

	sltu	$25, $7, $4
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$25, $0, B1_test5_fail
	ori	$0, $0, 0	#NOP
	j B1_test6
	ori	$0, $0, 0	#NOP 
B1_test5_fail:
	ori	$23, $23, 0x20
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2
test6:	#testing slti, sltiu
	slti	$8, $2, 52	#testing slti with 2 pos num
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$8, $0, B1_test6_fail

	slti	$9, $3, 1	#with 2 pos num, reg reversed 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$9, $0, B1_test6_fail
	
	slti	$10, $5, -48	#with 2 neg num 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$10, $0, B1_test6_fail

	slti	$11, $6, -5	#with 2 neg num, reg reversed
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$11, $0, B1_test6_fail
	
	slti	$12, $3, -48	#with one pos and one neg number
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$12, $0, B1_test6_fail

	slti	$13, $6, 52	#with one pos and one neg num, reg reversed
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$13, $0, B1_test6_fail

	slti	$14, $6, -48	#test if both reg are equal
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$14, $0, B1_test6_fail

	slti	$16, $4, 1	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$16, $0, B1_test6_fail

	slti	$17, $7, -5	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$17, $0, B1_test6_fail

	sltiu	$18, $2, 52	#testing sltiu with 2 pos num
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$18, $0, B1_test6_fail

	sltiu	$19, $3, 1	#with 2 pos num, reg reversed 
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$19, $0, B1_test6_fail

	sltiu	$20, $6, -48	#test if both reg are equal
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$20, $0, B1_test6_fail

	sltiu	$22, $4, 1	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$22, $0, B1_test6_fail

	sltiu	$24, $7, -5	#test for ovf condition
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	beq	$24, $0, B1_test6_fail

	ori	$0, $0, 0	#NOP
	j B1_test7
	ori	$0, $0, 0	#NOP 
B1_test6_fail:
	ori	$23, $23, 0x40
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2

B1_test7: #test lw, sw
	lui	$29, 0x1000
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$29, $29, -8
	addiu	$2, $0, 0x5A5A
	addiu	$3, $0, 0xFFFF
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	
	sw	$2, 0($29);
	sw	$3, 4($29);
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	lw	$4, 0($29);
	lw	$5, 4($29);
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$2, $4, B1_test7_fail
	ori	$0, $0, 0
	bne	$3, $5, B1_test7_fail
	ori	$0, $0, 0
	
	sw	$3, 0($29);
	lw	$4, 0($29);
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	bne	$4, $3, B1_test7_fail	

	addiu	$29, $29, 8
	ori	$0, $0, 0	#NOP
	j B1_test8
	ori	$0, $0, 0	#NOP 
B1_test7_fail:
	ori	$23, $23, 0x80
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2
B1_test8:	#bgez, bltz, j, jr, jal
	addiu	$2, $0, 5
	addiu	$3, $0, -5
	addiu 	$4, $0, 4
	addiu	$5, $0, 5
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	
	bgez	$2, B1_L3		#test bgez
	ori	$0, $0, 0
	j	test8_fail
	ori	$0, $0, 0
B1_L3:	
	bgez	$0, B1_L4
	ori	$0, $0, 0
	j	test8_fail
	ori	$0, $0, 0
B1_L4:	
	bgez	$3, B1_L5
	ori	$0, $0, 0
	j	B1_L6
	ori	$0, $0, 0
B1_L5:
	sll	$0, $0, 1
	j	test8_fail
	ori	$0, $0, 0
B1_L6:	
	bltz	$3, B1_L7		#test bltz
	ori	$0, $0, 0
	j	test8_fail
	ori	$0, $0, 0
B1_L7:	
	bltz	$0, B1_L8
	ori	$0, $0, 0
	j	B1_L9
	ori	$0, $0, 0
B1_L8:
	j	test8_fail
	ori	$0, $0, 0
B1_L9:	
	bltz	$2, B1_L10
	ori	$0, $0, 0
	j	B1_L11
	ori	$0, $0, 0
B1_L10:
	j	test8_fail
	ori	$0, $0, 0
B1_L11:
	jal	test8_2
	addiu	$4, $0, 10
	
	addiu	$4, $0, 5	#return from jr, make $4 = 5
	beq	$4, $5, B1_L12	#make sure we JRed to the right place
	ori	$0, $0, 0	#NOP
B1_L12:	
	j B1_test9
	ori	$0, $0, 0	#NOP 
B1_test8_fail:	
	ori	$23, $23, 0x100
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2
B1_test9:
	addu	$4, $0, $0
	addiu	$5, $0, 15
	lui	$2, 0xFF83
	lui	$3, 0xFFA3
	sll	$0, $0, 0
	sll	$0, $0, 0
	sll	$0, $0, 0
	ori	$2, $2, 0x4513	#$2 = 0xFF83 4513
	ori	$3, $3, 0x1234	#$3 = 0xFFA3 1234
	sll	$0, $0, 0
	sll	$0, $0, 0
	sll	$0, $0, 0
	multu	$2, $3
#loop so that multu can finish...
# 7 instructions per loop, 15 iterations, multu has 105 cycles to finish
B1_test9_loop:
	beq	$4, $5, loop_done
	sll	$0, $0, 0
	sll	$0, $0, 0
	sll	$0, $0, 0
	addiu	$4, $4, 1
	j	test9_loop
	sll	$0, $0, 0
B1_loop_done:
	lui	$6, 0xFF26
	lui	$7, 0x099E
	sll	$0, $0, 0
	sll	$0, $0, 0
	sll	$0, $0, 0
	ori	$6, $6, 0x848E	#$6 = 0xFF26 848E--should equal hi reg
	ori	$7, $7, 0x5DDC	#$7 = 0x099E 5DDC--should equal lo reg
	mfhi	$8
	mflo	$9
	sll	$0, $0, 0
	sll	$0, $0, 0
	sll	$0, $0, 0
	bne	$6, $8, B1_test9_fail
	ori	$0, $0, 0
	bne	$7, $9, B1_test9_fail
	ori	$0, $0, 0
	j	done
	ori	$0, $0, 0	

B1_test9_fail:
	ori	$23, $23, 0x200
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	addiu	$23, $23, 0
	break 2
B1_done:	
	j	exit
	ori	$0, $0, 0
B1_test8_2:	
	sll	$0, $0, 0
	sll	$0, $0, 0
	sll	$0, $0, 0
	jr	$31
	ori	$0, $0, 0
	j	test8_fail
	ori	$0, $0, 0
B1_exit:	
	addiu	$23, $23, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	sw	$23, -16($0)	# store $23 into IO Space
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
B1_exit2:
	break 3
	ori	$0, $0, 0
	ori	$0, $0, 0
	ori	$0, $0, 0
	j	exit2
	ori	$0, $0, 0
B1_e:	.word -1		# End B1: Test 1 (basic)

	
############################################################
############################################################	
#
#  Test 2: Corner from lab 4
#

B2:	
	#.address		# we will leave address unchanged
				# This block will be right up
				# against B1.
	.count words B2_s B2_e	# length of B2
	.word B2_s		# Execution address
B2_s:
T2_s:	
	# initial values to play with (some forwarding)
	addiu	$4, $0, 33	# $4 = 33 
	sll	$5, $4, 1	# $5 = 66  
	andi	$6, $4, 56	# $6 = 32
	addiu	$7, $0, 1	# $7 = 1	
	addu	$2, $0, $0	# clear $2
	addiu	$29, $0, 1024	# $29 = 1024
	
	########## 3rd stage forwarding (no stalls)

	addu	$3, $0, $0	# clear $3

	addiu	$8, $0, 32	# $8 = 32
	addiu	$9, $8, -31	# $9 = 1
	addu	$10, $8, $9	# $10 = 33
	addu	$11, $10, $8	# $11 = 65
	addiu	$11, $11, 1	# $11 = 66

	beq	$8, $6, B2_link1	# go to link1
	addiu	$12, $0, 1	# $12 = 1
	addiu	$3, $0, 1	# $3 = 1 (error)	

B2_link1:
	beq	$9, $7, B2_link2	# go to link2
	addiu	$12, $12, 1	# $12 = 2
	sll	$0, $0, 0
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link2:
	beq	$10, $4, B2_link3	# go to link3
	addiu	$12, $12, 1	# $12 = 3
	sll	$0, $0, 0
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link3:
	beq	$11, $5, B2_link4	# go to link4
	addiu	$12, $12, 1	# $12 = 4
	sll	$0, $0, 0
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link4:	
	beq	$3, $0, B2_safe1	# go to safe1 if no error
	sll	$0, $0, 0	# nop
	sll	$0, $0, 0
	addiu	$2, $0, 1	# $2 = 1

B2_safe1:	########## Results should be: $2 = 0, $12 = 4

	########## 2nd stage forwarding (stalls)

	addu	$3, $0, $0	# clear $3

	addiu	$8, $0, 5	# $8 = 5
	addiu	$9, $0, 5	# $9 = 5
	beq	$8, $9, B2_link5	# go to link5
	addiu	$12, $12, 1	# $12 = 5
	sll	$0, $0, 0
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link5:
	addiu	$8, $0, 143	# $8 = 143
	addiu	$9, $0, 143	# $9 = 143
	beq	$9, $8, B2_link6	# go to link6
	addiu	$12, $12, 1	# $12 = 6
	sll	$0, $0, 0
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link6:
	addiu	$8, $0, 0	# $8 = 0
	bne	$8, $9, B2_link7	# go to link7
	addiu	$12, $12, 1	# $12 = 7
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link7:	# no stalls
	addiu	$8, $0, 12	# $8 = 12
	addiu	$9, $0, 12	# $9 = 12
	sll	$0, $0, 0	# nop
	beq	$8, $9, B2_link8	# go to link8
	addiu	$12, $12, 1	# $12 = 8
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link8:	# no stalls
	addiu	$9, $0, 431	# $9 = 431
	addiu	$8, $0, 431	# $8 = 431
	sll	$0, $0, 0	# nop
	beq	$8, $9, B2_link9	# go to link9
	addiu	$12, $12, 1	# $12 = 9
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link9:
	beq	$3, $0, B2_safe2	# go to safe2 if no error
	sll	$0, $0, 0	# nop
	addiu	$2, $2, 2	# add 2 to $2

B2_safe2:	########## Results should be: $2 = 0, $12 = 9

	########## Jumping Tests for Delay Slots & Jal, Jr combo

	addiu	$22, $0, 0xffff	# diagnostic

	jal	B2_link11		# go to link11, link $ra
	addiu	$13, $0, 1	# $13 = 1
	addiu	$13, $13, 8	# $13 = 13	

B2_link10:
	j	B2_link12		# go to link12
	sll	$13, $13, 1	# $13 = 26

B2_link11:
	jr	$31		# should go to inst before link10
	ori	$13, $13, 4	# $13 = 5

B2_link12:
	addiu	$13, $13, 40	# $13 = 66
	beq	$13, $5, B2_link13	# go to link13
	addiu	$12, $12, 1	# $12 = 10
	addiu	$2, $2, 4	# add 4 to $2 (error)

B2_link13:	########## Results should be: $2 = 0, $12 = 10
	
	########## Changing $ra for Jr (stall & forwarding)

	addiu	$21, $0, 0xffff	# DIAGNOSTIC

	addu	$13, $0, $0	# clear #13
	jal	B2_link15		# go to link14
	addiu	$12, $12, 1	# $12 = 11
	addiu	$13, $0, 1	# $13 = 1 (shouldn't happen)

B2_link14:
	beq	$13, $0, B2_link16	# go to link16
	addiu	$12, $12, 1	# $12 = 13
	j	B2_link16		# shouldn't take this jump
	addiu	$2, $2, 8	# add 8 to $2 (error)

B2_link15:
	addiu	$31, $31, 4	# increment the $ra by 4
	jr	$31		# should essentially go to link14 and bypass the add to 13
	addiu	$12, $12, 1	# $12 = 12

B2_link16:
	addu	$13, $0, $0	# clear #13
	jal	B2_link18		# go to link18
	addiu	$12, $12, 1	# $12 = 14
	addiu	$13, $0, 1	# $13 = 1 (shouldn't happen)	

B2_link17:
	beq	$13, $0, B2_link19	# go to link19
	addiu	$12, $12, 1	# $12 = 16
	j	B2_link19		# shouldn't take this jump
	addiu	$2, $2, 16	# add 16 to $2 (error)

B2_link18:	
	addiu	$31, $31, 4	# increment the $ra by 4
	sll	$0, $0, 0	# nop
	jr	$31		# should essentially go to link17 and bypass the add to 13
	addiu	$12, $12, 1	# $12 = 15

B2_link19:	########## Results should be: $2 = 0, $12 = 16

	########## Forwarding a change to $0

	addu	$3, $0, $0	# clear $3

	addiu	$0, $0, 33	# try to change $0
	addu	$8, $0, $0	# $8 = 0
	addu	$9, $0, $0	# $9 = 0
	addu	$10, $0, $0	# $10 = 0

	bne	$0, $4, B2_link20	# go to link20
	addiu	$12, $12, 1	# $12 = 17
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link20:
	beq	$8, $0, B2_link21	# go to link21
	addiu	$12, $12, 1	# $12 = 18
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link21:
	beq	$9, $0, B2_link22	# go to link22
	addiu	$12, $12, 1	# $12 = 19
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link22:
	beq	$10, $0, B2_link23	# go to link23
	addiu	$12, $12, 1	# $12 = 20	
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link23:
	beq	$3, $0, B2_safe3	# go to safe3 if no error
	sll	$0, $0, 0	# nop
	addiu	$2, $2, 32	# add 32 to $2

B2_safe3:	########## Results should be: $2 = 0, $12 = 20

	########## 2nd stage forwarding w/ $0 (no forwarding)

	addu	$3, $0, $0	# clear $3

	addiu	$8, $0, 5	# $8 = 5
	addiu	$0, $0, 5	# $0 = 0
	bne	$8, $0, B2_link24	# go to link24
	addiu	$12, $12, 1	# $12 = 21
	addiu	$3, $0, 1	# $3 to 1 (error)

B2_link24:
	addiu	$8, $0, 143	# $8 = 143
	addiu	$0, $0, 143	# $0 = 0
	bne	$0, $8, B2_link25	# go to link25
	addiu	$12, $12, 1	# $12 = 22
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link25:
	addiu	$8, $0, 12	# $8 = 12
	addiu	$0, $0, 12	# $0 = 0
	sll	$0, $0, 0	# nop
	bne	$8, $0, B2_link26	# go to link26
	addiu	$12, $12, 1	# $12 = 23
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link26:
	addiu	$0, $0, 431	# $0 = 0
	addiu	$8, $0, 431	# $8 = 431
	sll	$0, $0, 0	# nop
	bne	$8, $0, B2_link27	# go to link27
	addiu	$12, $12, 1	# $12 = 24
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link27:
	beq	$3, $0, B2_safe4	# go to safe4 if no error
	sll	$0, $0, 0	# nop
	addiu	$2, $2, 64	# add 64 to $2

B2_safe4:	########## Results should be: $2 = 0, $12 = 24

	########## lw following ALU function

	addu	$3, $0, $0	# clear $3
	
	sw	$5, -4($29)	# mem(1020) = 66
	sw	$6, 0($29)	# mem(1024) = 32
	addiu	$8, $0, 433	# $8 = 433
	addiu	$29, $29, -4	# $29 = 1020
	lw	$8, 0($29)	# $8 = 66
	lw	$9, 0($29)	# $9 = 66
	lw	$10, 0($29)	# $10 = 66

	beq	$8, $5, B2_link28	# go to link28
	addiu	$12, $12, 1	# $12 = 25
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link28:
	beq	$9, $5, B2_link29	# go to link29
	addiu	$12, $12, 1	# $12 = 26
	addiu	$3, $0, 1	# $3 = 1 (error)
	
B2_link29:
	beq	$10, $5, B2_link30	# go to link30
	addiu	$12, $12, 1	# $12 = 27
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link30:
	addiu	$29, $29, 4	# restore $29
	beq	$3, $0, B2_safe5	# go to safe5 if no error
	sll	$0, $0, $0	# nop
	addiu	$2, $2, 128	# add 128 to $2

B2_safe5:	########## Results should be: $2 = 0, $12 = 27

	########## Addiu after Lw (delay and no delay)

	##### delay slot

	addu	$3, $0, $0	# clear $3

	sw	$4, 0($29)	# mem(1024) = 33
	lw	$8, 0($29)	# $8 = 33
	addiu	$12, $12, 1	# $12 = 28
	addu	$9, $8, $8	# $9 = 66
	beq	$9, $5, B2_link31	# go to link31
	addiu	$12, $12, 1	# $12 = 29
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link31:
	##### no delay slot

	addiu	$8, $0, 1	# $8 = 1
	lw	$8, 0($29)	# $8 = 33
	addu	$9, $8, $8	# $9 = 66
	beq	$9, $5, B2_link32	# go to link32
	addiu	$12, $12, 1	# $12 = 30
	addiu	$3, $0, 1	# $3 = 1 (error)

B2_link32:
	beq	$3, $0, B2_safe6	# go to safe6 if no error
	sll	$0, $0, $0	# nop
	addiu	$2, $2, 256	# add 256 to $2

B2_safe6:	########## Results should be: $2 = 0, $12 = 30

	########## lw followed by beq.. special case

	##### delay slot

	addiu	$10, $0, 443	# $10 = 443
	sw	$7, 0($29)	# mem(1024) = 33
	lw	$10, 0($29)	# $10 = 1
	addiu	$12, $12, 1	# $12 = 31
	beq	$10, $7, B2_link33	# go to link33
	addiu	$12, $12, 1	# $12 = 32
	addiu	$2, $2, 512	# add 512 to $2

B2_link33:
	##### no delay slot

	addiu	$11, $0, 451	# $11 = 451
	sw	$6, 0($29)	# mem(1024) = 32
	lw	$11, 0($29)	# $11 = 32
	beq	$11, $6, B2_link34	# go to link34
	addiu	$12, $12, 1	# $12 = 33
	addiu	$2, $2, 1024	# add 1024 to $2

B2_link34:	########## Results should be: $2 = 0, $12 = 33

	addiu	$19, $0, 0xffff	# DIAGNOSTIC

	########## lw followed by jr.. another special case

	##### delay slot

	addu	$3, $0, $0	# clear $3

	jal	B2_link35		# go to link35
	addiu	$12, $12, 1	# $12 = 34
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)

	beq	$3, $0, B2_link36	# go to link36
	addiu	$12, $12, 1	# $12 = 35
	addiu	$2, $2, 2048	# add 2048 to $2
	j	B2_link36		# go to link36
	sll	$0, $0, 0	# nop

B2_link35:
	addiu	$8, $31, 4	# increment $ra by 4
	sw	$8, 0($29)	# mem(1024) = $ra + 4
	sll	$0, $0, 0	# nop
	sll	$0, $0, 0	# nop
	sll	$0, $0, 0	# nop
	sll	$0, $0, 0	# nop, these are the make sure we don't forward and actually read from mem
	lw	$31, 0($29)	# $ra = $ra + 4
	sll	$0, $0, 0	# nop
	jr	$31
	sll	$0, $0, 0	# nop			

B2_link36:	########## Results should be: $2 = 0, $12 = 35

	### test multu, mfhi, mflo
	addiu	$3, $0, 0	# clear $3
	addiu	$8, $0, 152	# $8 = 152
	addiu	$9, $0, 61	# $9 = 61
	multu	$8, $9		#forwarded values of $8 and $9?
	addu	$11, $0, $0	# $11 = 0
	mflo	$11		# needs to stall, #11=9272, or 0x00002438
	mfhi	$10		# $10 = 0
	addiu	$8, $0, 9272	# $8 = 9272
	beq	$8, $11, B2_link37	# go to link37
	addiu	$12, $12, 1	# $12 = 36
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)

B2_link37:
	addiu	$8, $0, 0	# $8 = 0
	beq	$8, $10, B2_link38	# go to link38
	addiu	$12, $12, 1	# $12 = 37
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)

B2_link38:
	addiu	$8, $0, 152	# $8 = 152
	multu	$9, $8		# multiply in reverse order
	mfhi	$10		# $10 = 0
	mflo	$11		# $11 = 9272
	addu	$8, $10, $11	# $8 = 9272
	addu	$9, $10, $11	# $9 = 9272
	addu	$10, $10, $11	# $10 = 9272

	beq	$8, $11, B2_link39	# go to link39
	addiu	$12, $12, 1	# $12 = 38
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)

B2_link39:
	beq	$9, $11, B2_link40	# go to link40
	addiu	$12, $12, 1	# $12 = 39
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)
B2_link40:
	beq	$10, $11, B2_link41	# go to link41
	addiu	$12, $12, 1	# $12 = 40
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)

B2_link41: 
	beq	$3, $0, B2_link42	#go to link42
	sll	$0, $0, 0
	addiu	$2, $2, 4096	# add 4096 to $2


B2_link42: ############## Results should be:$2 = 0, $12 = 40

	# now a very difficult sequence
	addiu	$30, $0, 0	# if they fail this later they jump to the beginning of the test!
	jal	B2_setup		#allows us to put a value into $31 corresponding to setup
	sll	$0, $0, 0
B2_setup:
	addiu	$31, $31, 40	# increment $31 to escape 2
	sw	$31, 0($29)	# mem(1024) = escape 2 address

	jal	B2_there
	addiu	$31, $31, 4
	addiu	$3, $0, 1	# $3 = 1 (shouldn't happen)
	jr	$31		#returns to here, $31 has been += 16, should get to escape1
	lw	$30, 0($29)	# $31 = mem(1024) = escape 2
B2_there:
	jr	$31		# should return to jr above it
	addiu	$31, $31, 16
### escape1
	jr	$30		# jump to escape 2
	addiu	$12, $12, 1	# $12 = 41
### escape 2
	addiu	$12, $12, 1	# $12 = 42
	j	done		# jump to done
	sll	$0, $0, 0	# nop

B2_done:
	addiu	$12, $12, 1	# $12 = 43
	sw	$12, -16($0)	# i/o1 should display 43 or 0x2B
	sw	$2, -12($0)	# i/o2 should display 0
	
B2_endloop:
	break	9		# end break
	j	B2_endloop
	sll	$0, $0, 0	# nop
B2_e:	.word -1		# End test 2: Corner