`timescale 1ns / 1ps

module instructionMemory(
    input wire [8:0] address,
    output reg [8:0] readData
    );
    
    reg [8:0] memory [18:0];   // Maximum of 512 memory locations
                                // Vivado will give warnings of unconnected ports on the "address" bus if they are unused
    
    initial begin
        //Equation Solver
        memory[0] <= 9'b000000000; //Stall
        memory[1] <= 9'b000000000; //Stall
        memory[2] <= 9'b011000000; //addi
        memory[3] <= 9'b000000000; //Stall
        memory[4] <= 9'b000000000; //Stall
        memory[5] <= 9'b011001001; //addi
        memory[6] <= 9'b000000000; //Stall
        memory[7] <= 9'b000000000; //Stall
        memory[8] <= 9'b000100000; //load
        memory[9] <= 9'b000000000; //Stall
        memory[10] <= 9'b000101010; //load
        memory[11] <= 9'b010100010; //add    
        memory[12] <= 9'b111100000; //shift left
        memory[13] <= 9'b111100000; //shift left
        memory[14] <= 9'b000000000; //Stall
        memory[15] <= 9'b000000000; //Stall
        
//        //Testing all instructions
//        memory[6] <= 9'b010100011; //sub
//        memory[7] <= 9'b011001011; //addi
//        memory[8] <= 9'b011110000; //slt
//        memory[9] <= 9'b110111000; //nor
//        memory[10] <= 9'b111011000; //or
//        memory[11] <= 9'b111011001; //and
//        memory[12] <= 9'b111111000; //sll
//        memory[13] <= 9'b111111001; //srl
//   //     memory[14] <= 9'b100100010; //j
//        memory[14] <= 9'b010001000; //zero
//        memory[15] <= 9'b110001001; //beq
//        memory[16] <= 9'b100001000; //jr
//        memory[17] <= 9'b100111100; //j
        
        
        //String Compare
//        memory[0] <= 9'b000000000;
//        memory[1] <= 9'b010000000;
//        memory[2] <= 9'b010001000;
//        memory[3] <= 9'b010010000;
//        memory[4] <= 9'b010011000;
//        memory[5] <= 9'b000100000;
//        memory[6] <= 9'b011001001;
//        memory[7] <= 9'b000101010;
//        memory[8] <= 9'b011010010;
//        memory[9] <= 9'b000110100;
//        memory[10] <= 9'b011011011;
//        memory[11] <= 9'b000111110;
//        memory[12] <= 9'b101010000;
//        memory[13] <= 9'b101000010;
//        memory[14] <= 9'b101001100;
//        memory[15] <= 9'b101011110; //ends initialization
//        memory[16] <= 9'b101000011;
//        memory[17] <= 9'b101001101;
//        memory[18] <= 9'b000110000;
//        memory[19] <= 9'b000111010;
//        memory[20] <= 9'b110010001;
//        memory[21] <= 9'b100100001;
//        memory[22] <= 9'b100110000;
//        memory[23] <= 9'b110011001;
//        memory[24] <= 9'b100100001;
//        memory[25] <= 9'b100101101;
//        memory[26] <= 9'b011000001;
//        memory[27] <= 9'b011001001;
//        memory[28] <= 9'b101000010;
//        memory[29] <= 9'b101001100;
//        memory[30] <= 9'b010110111;
//        memory[31] <= 9'b110010001;
//        memory[32] <= 9'b101110001;
//        memory[33] <= 9'b101000001;
//        memory[34] <= 9'b101001111;
//        memory[35] <= 9'b001001000;
//        memory[36] <= 9'b011000001;
//        memory[37] <= 9'b101000000;
//        memory[38] <= 9'b101110111;
//        memory[39] <= 9'b000000000;
        

//    //Bubble Sort
//            memory[0] <= 9'b000000001; // nop
//        // Setup
//            memory[1] <= 9'b010000000; // zero      $a
//            memory[2] <= 9'b000100000; // lb		$a, $a
//            memory[3] <= 9'b010001000; // zero      $b
//            memory[4] <= 9'b010010000; // zero      $c
//            memory[5] <= 9'b010011000; // zero      $d
//            memory[6] <= 9'b101001000; // banks	    $b, $0
//            memory[7] <= 9'b101001010; // banks	    $b, $1
//            memory[8] <= 9'b100100011; // jf		EndChk
//        // Increment current index to compare next pair of values
//            // Inc:
//            memory[9] <= 9'b101001001; // bankl	    $b, $0
//            memory[10] <= 9'b011001001; // addi	    $b, 1
//            memory[11] <= 9'b101001000; // banks	$b, $0
//        // Check if at the end of the array
//            // EndChk:
//            memory[12] <= 9'b101001001; // bankl    $b, $0
//            memory[13] <= 9'b011101000; // slt      $b, $a
//            memory[14] <= 9'b110001001; // beq      $b, JSC
//            memory[15] <= 9'b100100001; // jf		LoadNext
//            // JSC:
//            memory[16] <= 9'b100110100; // jf		SwapChk
//        // Load next values for comparison
//            // LoadNext:
//            memory[17] <= 9'b101001001; // bankl	$b, $0
//            memory[18] <= 9'b011001001; // addi	    $b, 1
//            memory[19] <= 9'b000110010; // lb		$c, $b
//            memory[20] <= 9'b011001001; // addi	    $b, 1
//            memory[21] <= 9'b000111010; // lb		$d, $b
//        // Compare loaded values to see if they need to be swapped
//            memory[22] <= 9'b101011110; // banks	$d, $3
//            memory[23] <= 9'b011111100; // slt      $d, $c
//            memory[24] <= 9'b110011001; // beq      $d, JI
//            memory[25] <= 9'b100100001; // jf		Swap
//            // JI:
//            memory[26] <= 9'b101110010; // jb		Inc
//        // Swap values in array
//            // Swap:
//            memory[27] <= 9'b101001001; // bankl	$b, $0
//            memory[28] <= 9'b011001001; // addi	    $b, 1
//            memory[29] <= 9'b101011111; // bankl	$d, $3
//            memory[30] <= 9'b001011010; // sb		$d, $b
//            memory[31] <= 9'b011001001; // addi	    $b, 1
//            memory[32] <= 9'b001010010; // sb		$c, $b
//            memory[33] <= 9'b010001000; // zero	    $b
//            memory[34] <= 9'b011001001; // addi	    $b, 1
//            memory[35] <= 9'b101001010; // banks	$b, $1
//            memory[36] <= 9'b101111100; // jb		Inc
//        // Check to see if any swaps have been made in the last iteration
//            // SwapChk:
//            memory[37] <= 9'b101001011; // bankl	$b, $1
//            memory[38] <= 9'b110001001; // beq      $b, JE
//            memory[39] <= 9'b100100001; // jf		Reset
//            // JE:
//            memory[40] <= 9'b100100011; // jf		End
//            // Reset:
//            memory[41] <= 9'b010001000; // zero	    $b
//            memory[42] <= 9'b101001000; // banks	$b, $0
//            memory[43] <= 9'b101111011; // jb		LoadNext
//            // End:
//            memory[44] <= 9'b000000000; // halt


         // Binary Search  
        
//           memory[0] <= 9'b000000000; 
//           memory[1] <= 9'b000000000; 
//           memory[2] <= 9'b000000000; 
//           memory[3] <= 9'b000000000; 
//           memory[4] <= 9'b000000000; 
//           memory[5] <= 9'b011001011; //addi R1, 3 (N = 3)  
//           memory[6] <= 9'b011001011; //addi R1, 3 (N = 3) 
//           memory[7] <= 9'b011001011; //addi R1, 3 (N = 3) 
//           memory[8] <= 9'b011001011; //addi R1, 3 (N = 3) 
//           memory[9] <= 9'b011001011; //addi R1, 3 (N = 3) 
//          memory[10] <= 9'b011011010; //addi R3, 2 (inputAddr = 2)
//          memory[11] <= 9'b000111110; //lb R3, R3                 
//          memory[12] <= 9'b101011010; //banks R3, 1               
//          memory[13] <= 9'b011001011; //addi R1, 3 (N = 3)        
//          memory[14] <= 9'b101000000; //loop: banks R0, 0         
//          memory[15] <= 9'b011100010; //slt R0, R1                
//          memory[16] <= 9'b110000001; //beq R0, Exit              
//          memory[17] <= 9'b100100001; //j Skip0                   
//          memory[18] <= 9'b100101111; //Exit: j Loose  
//          memory[19] <= 9'b101000001; //Skip0: bankl R0, 0
//          memory[20] <= 9'b010110000; //add R2, R0      
//          memory[21] <= 9'b010110010; //add R2, R1                
//          memory[22] <= 9'b111110001; //srl R2                    
//          memory[23] <= 9'b101011011; //bankl R3,1                
//          memory[24] <= 9'b010111100; //add R3, R2                
//          memory[25] <= 9'b101001100; //banks R1, 2               
//          memory[26] <= 9'b000100110; //lb R0, R3                 
//          memory[27] <= 9'b010001000; //zero R1                   
//          memory[28] <= 9'b011001001; //addi R1, 1 (numAddr = 1)  
//          memory[29] <= 9'b000101010; //lb R1, R1                 
//          memory[30] <= 9'b100100001; //j SkipU                   
//          memory[31] <= 9'b101110010; //j TransLoop               
//          memory[32] <= 9'b101010110; //SkipU: banks R2, 3        
//          memory[33] <= 9'b100100001; //j SkipD                   
//          memory[34] <= 9'b100110111; //j TransLoose              
//          memory[35] <= 9'b010010000; //SkipD: zero R2            
//          memory[36] <= 9'b010110010; //add R2, R1                
//          memory[37] <= 9'b010101001; //sub R1, R0                
//          memory[38] <= 9'b110001001; //beq R1, Go1               
//          memory[39] <= 9'b100100001; //j Skip1                   
//          memory[40] <= 9'b100101001; //Go1: j Win                
//          memory[41] <= 9'b010001000; //Skip1: zero R1            
//          memory[42] <= 9'b010101100; //add R1, R2                
//          memory[43] <= 9'b011100010; //slt R0, R1                
//          memory[44] <= 9'b110000001; //beq R0, Go2               
//          memory[45] <= 9'b100100110; //j Skip2                   
//          memory[46] <= 9'b010000000; //Go2: zero R0              
//          memory[47] <= 9'b011000001; //addi R0, 1                
//          memory[48] <= 9'b101001111; //bankl R1,3                
//          memory[49] <= 9'b010100010; //add R0, R1                
//          memory[50] <= 9'b101001101; //bankl R1,2                
//          memory[51] <= 9'b101110101; //j loop                    
//          memory[52] <= 9'b010001000; //Skip2: zero R1            
//          memory[53] <= 9'b011001111; //addi R1, -1               
//          memory[54] <= 9'b101000111; //bankl R0, 3               
//          memory[55] <= 9'b010101000; //add R1, R0                
//          memory[56] <= 9'b101000001; //bankl R0,0                
//          memory[57] <= 9'b101111011; //j loop                    
//          memory[58] <= 9'b010000000; //Loose: zero R0            
//          memory[59] <= 9'b011000111; //addi R0, -1               
//          memory[60] <= 9'b101000110; //banks R0, 3               
//          memory[61] <= 9'b100100000; //j Win                     
//          memory[62] <= 9'b000000000; //Win: halt                 
          
 
    end
    
    always @ (address)
        readData <= memory[address];
endmodule


module instructionMemory_tb();
    reg [8:0] address;
    wire [8:0] readData;
    
    instructionMemory iM0(
        .address(address),
        .readData(readData)
    );
    
    initial begin
        #10
        address = 9'b000000000;
        #5
        address = 9'b000000001;
        #5
        address = 9'b000000010;
        #5
        address = 9'b000000011;
        #5
        address = 9'b000000100;
        #5
        address = 9'b000000101;
        #5
        address = 9'b000000111;
        #5
        $finish;
    end
endmodule