.data

    # Prompts the user for an Int as the seed for the randomizer
	seedPrompt: .asciiz "Please enter a seed\n"

    # Prompts the user for an Int to use as the max possible target
	maxPrompt: .asciiz "Please specify the max number\n"

    # Prompts the user for their guess
    guessPrompt: .asciiz "Please enter your guess!\n"

    # Informs the user about their guess
	wrongVeryFar: .asciiz "Your guess was very far! Try again!\n"
	wrongFar: .asciiz "Your guess was far! Try again!\n"
	wrongNear: .asciiz "Your guess was near! Try again!\n"
	wrongVeryNear: .asciiz "Your guess was very near! Try again!\n"
	correct: .asciiz "Your guess was Correct! Well Done!!\n"

    vn: .float 0.05
    n: .float 0.1
    f: .float 0.25

.text
    .globl main
        main:
            # Asks user for max number in guess range
            li $v0, 4
            la $a0, maxPrompt
            syscall

            # Gets user's max number
            li $v0, 5
            syscall

            # Moves max number to $t0
            add $t0, $zero, $v0

            # Asks the user for their seed
            li $v0, 4
            la $a0, seedPrompt
            syscall

            # Gets user's seed
            li $v0,	5
            syscall

            # Moves seed to t1
            add	$t1, $zero,	$v0

            # Sets seed
            li $v0, 40
            # Creates ID
            li $a0,	0
            # Moves seed to $a1
            add $a1, $zero, $t1
            syscall

            # Random Number Generator
            li $v0,	42
            # Gives ID to generator
            li $a0,	0
            # Puts max in $a1
            add $a1, $zero,	$t0
            syscall

            # Returns to getLimits
            jal	getLimits

            # Main guessing and comparing loop
            loop:
                jal getUserInput
                add $a0, $zero,	$v0

                jal compareNumber
                b loop

        # Determines where very near, near, far and very far lie
        getLimits:

            addi $sp, $sp, -4
            sw $ra, 0($sp)

            # Moves target to $s0
            add $s0, $zero, $a0
            add $s1, $zero, $a1

            # Moves target to a float register
            mtc1 $s0, $f0
            mtc1 $t0, $f4
            # Converts target to a float
            cvt.s.w $f0, $f0
            cvt.s.w $f4, $f4

            l.s $f1, vn # 5%
            l.s $f2, n # 10%
            l.s $f3, f # 25%

            # 5% range of target
            mul.s $f1, $f4, $f1
            # 10% range of target
            mul.s $f2, $f4, $f2
            #25% range of target
            mul.s $f3, $f4, $f3

            # 5% above target
            add.s $f5, $f0, $f1
            # 10% above target
            add.s $f6, $f0, $f2
            #25% above target
            add.s $f7, $f0, $f3
            # 5% below target
            sub.s $f8, $f0, $f1
            # 10% below target
            sub.s $f9, $f0, $f2
            #25% below target
            sub.s $f10, $f0, $f3

            # Converting ranges to integers
            cvt.w.s $f5, $f5
            cvt.w.s $f6, $f6
            cvt.w.s $f7, $f7
            cvt.w.s $f8, $f8
            cvt.w.s $f9, $f9
            cvt.w.s $f10, $f10

            # Moving ranges to integer registers
            mfc1 $s1, $f5
            mfc1 $s2, $f6
            mfc1 $s3, $f7
            mfc1 $s4, $f8
            mfc1 $s5, $f9
            mfc1 $s6, $f10

            # Returns to start loop
            lw $ra, 0($sp)
            addi $sp, $sp, 4
            jr $ra

        # Gets the user's guess
        getUserInput:
            # Saves return address
            addi $sp, $sp, -4
            sw $ra, 0($sp)

            # Asks the user for their guess
            li $v0, 4
            la $a0, guessPrompt
            syscall

            # Gets the user's guess
            li $v0, 5
            syscall

            # Returns to compare
            lw $ra, 0($sp)
            addi $sp, $sp ,4
            jr $ra

        compareNumber:
            # Stores return address
            addi $sp, $sp, -4
            sw $ra, 0($sp)

            # Determine's if the user's guess is correct, very near, near, or far
            beq $a0, $s0, Exit # Correct Guess

            # Tests if the user's guess is below the target
            blt $a0, $s6, veryFarGuess
            blt $a0, $s5, farGuess
            blt $a0, $s4, nearGuess

            # Tests if the user's guess is above the target
            bgt $a0, $s3, veryFarGuess
            bgt $a0, $s2, farGuess
            bgt $a0, $s1, nearGuess


            # veryNearGuess
            # Tells the user that their guess was within 5% of the target
            li $v0, 4
            la $a0, wrongVeryNear
            syscall

            # Returns for another guess
            lw $ra, 0($sp)
            addi $sp, $sp, 4
            jr $ra

        nearGuess:
            # Tells the user that their guess was within 10% of the target
            li $v0, 4
            la $a0, wrongNear
            syscall

            # Returns for another guess
            lw $ra, 0($sp)
            addi $sp, $sp, 4
            jr $ra

        farGuess:
            # Tells the user that their guess was within 25% of the target
            li $v0, 4
            la $a0, wrongFar
            syscall

            # Returns for another guess
            lw $ra, 0($sp)
            addi $sp, $sp, 4
            jr $ra

        veryFarGuess:
            li $v0, 4
            la $a0, wrongVeryFar
            syscall

            # Returns for another guess
            lw $ra, 0($sp)
            addi $sp, $sp, 4
            jr $ra


        Exit:
            # Tells the user that their guess was correct
            li $v0, 4
            la $a0, correct
            syscall

            # Exits the program
            li $v0, 10
            syscall