import java.util.*;

class FirstPass
{
    private static int sllvc = 0;
    private static int sravc = 0;
    private static int srlvc = 0;
    private static int sltuc = 0;
    private static int sltiuc = 0;
    private static int bgezc = 0;
    private static int bgezalc = 0;
    private static int bgtzc = 0;
    private static int bltzc = 0;
    private static int bltzalc = 0;
    private static int blezc = 0;
    
    public static String getCounters()
    {
	String results = "";

	results += "sllv:   " + sllvc   + "\n";
	results += "srav:   " + sravc   + "\n";
	results += "srlv:   " + srlvc   + "\n";
	results += "sltu:   " + sltuc   + "\n";
	results += "sltiu:  " + sltiuc  + "\n";
	results += "bgez:   " + bgezc   + "\n";
	results += "bgezal: " + bgezalc + "\n";
	results += "bltz:   " + bltzc   + "\n";
	results += "bltzal: " + bltzalc + "\n";
	results += "bgtz:   " + bgtzc   + "\n";
	results += "blez:   " + blezc   + "\n";

	return results;
    }
    
    public static Vector processLine(String inst)
    {
	// add commas to the standard StringTokenizer
	StringTokenizer st = new StringTokenizer(inst, " ,\n\r\f\t");

	// make sure line isn't blank
	String instruction = "blah";
	if(st.hasMoreTokens())
	    instruction = st.nextToken();

	Vector stuff = new Vector();

	/* Pseudo Instructions */
	if (instruction.equals("sllv"))
	    {
		sllvc++;
		stuff.add(inst);
	    }
	else if (instruction.equals("srav"))
	    {
		sravc++;
		stuff.add(inst);
	    }
	else if (instruction.equals("srlv"))
	    {
		srlvc++;
		stuff.add(inst);
	    }
	else if (instruction.equals("sltu"))
	    {
		sltuc++;

		String rd = st.nextToken();
		String rs = st.nextToken();
		String rt = st.nextToken();

		stuff.add("slt " + rd + ", " + rs + ", " + rt);

		//stuff.add(inst);
	    }
	else if (instruction.equals("sltiu"))
	    {
		sltiuc++;

		String rt = st.nextToken();
		String rs = st.nextToken();
		String imm = st.nextToken();

		stuff.add("slti " + rt + ", " + rs + ", " + imm);

		//stuff.add(inst);
	    }
	else if (instruction.equals("bltzal"))
	    {
		bltzalc++;
		stuff.add(inst);
	    }
	else if (instruction.equals("bgezal"))
	    {
		bgezalc++;
		stuff.add(inst);
	    }
	else if (instruction.equals("bgez"))
	    {
		bgezc++;
		
		String rsrc1 = st.nextToken();
		String rsrc2 = "$0";
		String offset = st.nextToken();

		stuff.add(".set noat");
		stuff.add("slt $1, " + rsrc1 + ", " + rsrc2);
		stuff.add("beq $1, $0, " + offset);
		stuff.add(".set at");

		//stuff.add("bge " + rsrc1 + ", $0, " + offset);

		//stuff.add(inst);
	    }
	else if (instruction.equals("bgtz"))
	    {
		bgtzc++;
		
		String rsrc1 = st.nextToken();
		String rsrc2 = "$0";
		String offset = st.nextToken();

		stuff.add(".set noat");
		stuff.add("slt $1, " + rsrc2 + ", " + rsrc1);
		stuff.add("bne $1, $0, " + offset);
		stuff.add(".set at");

		//stuff.add("bgt " + rsrc1 + ", $0, " + offset);
		
		//stuff.add(inst);
	    }
	else if (instruction.equals("blez"))
	    {
		blezc++;
		
		String rsrc1 = st.nextToken();
		String rsrc2 = "$0";
		String offset = st.nextToken();

		stuff.add(".set noat");
		stuff.add("slt $1, " + rsrc2 + ", " + rsrc1);
		stuff.add("beq $1, $0, " + offset);
		stuff.add(".set at");

		//stuff.add("ble " + rsrc1 + ", $0, " + offset);

		//stuff.add(inst);
	    }
	else if (instruction.equals("bltz"))
	    {
		bltzc++;
		
		String rsrc1 = st.nextToken();
		String rsrc2 = "$0";
		String offset = st.nextToken();
		
		stuff.add(".set noat");
		stuff.add("slt $1, " + rsrc1 + ", " + rsrc2);
		stuff.add("bne $1, $0, " + offset);
		stuff.add(".set at");

		//stuff.add("blt " + rs + ", $0, " + offset);
		
		//stuff.add(inst);
	    }
	else  // instruction that doesn't need to be fixed
	    {
		stuff.add(inst);
	    }

	return stuff;

	// other instructions that may or may not be needed
//  	else if(instruction.equals("abs"))
//  	    {
//  		/*Absolute
//  		  abs rdest, rsrc
//  		  ##
//  		  addu rdest, $0, rsrc
//  		  slt $1, rsrc, $0
//  		  beq $1, $0, 8
//  		  sub rdest, $0, rsrc
//  		*/

//  		String rdest = st.nextToken();
//  		String rsrc = st.nextToken();

//  		stuff.add("addu " + rdest + ", $0, " + rsrc);
//  		stuff.add("slt $1, " + rsrc + ", $0");
//  		stuff.add("beq $1, $0, 8");
//  		stuff.add("sub " + rdest + ", $0, " + rsrc);
//  	    }
//  	else if(instruction.equals("div"))
//  	    {
//  		String rdest = st.nextToken();
//  		String src1 = st.nextToken();

//  		if(!st.hasMoreTokens()) // two argument version
//  		    {
//  			stuff.add(inst);
//  		    }
//  		else // three argument pseudo instruction
//  		    {
//  			/*Divide w/ overflow
//  			  div rdest, rsrc1, src2
//  			  ##
//  			  bne src2, $0, 8
//  			  break 7
//  			  div rsrc1, src2
//  			  mflo rdest
//  			*/

//  			String src2 = st.nextToken();

//  			stuff.add("bne " + src2 + ", $0, 8");
//  			stuff.add("break 7");
//  			stuff.add("div " + src1 + ", " + src2);
//  			stuff.add("mflo " + rdest);
//  		    }
//  	    }
//  	else if(instruction.equals("divu"))
//  	    {
//  		String rdest = st.nextToken();
//  		String src1 = st.nextToken();
		
//  		if(!st.hasMoreTokens()) // two argument version
//  		    {
//  			stuff.add(inst);
//  		    }
//  		else // three argument pseudo instruction
//  		    {
//  			/*Divide w/o overflow
//  			  divu rdest, rsrc1, src2
//  			  ##  
//  			  bne src2, $0, 8
//  			  break 7
//  			  divu rsrc1, src2
//  			  mflo rdest			
//  			*/

//  			String src2 = st.nextToken();

//  			stuff.add("bne " + src2 + ", $0, 8");
//  			stuff.add("break 7");
//  			stuff.add("divu " + src1 + ", " + src2);
//  			stuff.add("mflo " + rdest);
//  		    }
//  	    }
//  	else if(instruction.equals("mul"))
//  	    {
//  		/*Multiply (No Overflow)
//  		  mul rdest, rsrc1, src2
//  		  ##
//  		  mult rsrc1, rsrc2
//  		  mflo rdest
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String src2 = st.nextToken();
		
//  		stuff.add("mult " + rsrc1 + ", " + src2);
//  		stuff.add("mflo " + rdest);
//  	    }
//  	else if(instruction.equals("mulo"))
//  	    {
//  		/*
//  		  Multiply (With Overflow) 
//  		  mulo, rdest, rsrc1, rsc2
//  		  ##
//  		  mult src1, src2
//  		  mfhi $1
//  		  mflo rdest
//  		  sra rdest, rdest, 31
//  		  beq $1, src1, 8
//  		  break 7
//  		  mflo rdest
//  		*/

//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("mult " + rsrc1 + ", " + rsrc2);
//  		stuff.add("mfhi $1");
//  		stuff.add("mflo " + rdest);
//  		stuff.add("sra " + rdest + ", " + rdest + ", 31");
//  		stuff.add("beq $1, " + rsrc1 + ", 8");
//  		stuff.add("break 7");
//  		stuff.add("mflo " + rdest);
//  	    }
//  	else if(instruction.equals("mulou"))
//  	    {
//  		/*
//  		  Unsigned multiply w/ overflow
//  		  mulou rdest, rsrc1, src2
//  		  ##  
//  		  multu rsrc1, src2
//  		  mfhi $1
//  		  beq $1, $0, 8
//  		  break 7
//  		  mflo rdest
//  		*/
    
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String src2 = st.nextToken();
		
//  		stuff.add("multu " + rsrc1 + ", " + src2);
//  		stuff.add("mfhi $1");
//  		stuff.add("beq $1, $0, 8");
//  		stuff.add("break 7");
//  		stuff.add("mflo " + rdest);
//  	    }
//  	else if(instruction.equals("neg"))
//  	    {
//  		/*
//  		  Negate value w/ overflow
//  		  neg rdest, rsrc
//  		  ##  
//  		  sub rdest, $0, rsrc
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc = st.nextToken();
		
//  		stuff.add("sub " + rdest + ", $0, " + rsrc);
//  	    }
//  	else if(instruction.equals("negu"))
//  	    {
//  		/*
//  		  Negate value w/o overflow
//  		  negu rdest, rsrc
//  		  ##  
//  		  subu rdest, $0, rsrc
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc = st.nextToken();
		
//  		stuff.add("subu " + rdest + ", $0, " + rsrc);
//  	    }
//  	else if(instruction.equals("not"))
//  	    {
//  		/*
//  		  Not
//  		  not rdest, rsrc
//  		  ##  
//  		  nor rdest, rsrc, $0
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc = st.nextToken();
		
//  		stuff.add("nor " + rdest + ", " + rsrc + ", $0");
//  	    }
//  	else if(instruction.equals("rem"))
//  	    {
//  		/*
//  		  Remainder
//  		  rem rdest, rsrc1, rsrc2
//  		  ##  
//  		  bne rsrc2, $0, 8
//  		  break 7
//  		  div rsrc1, rsrc2
//  		  mfhi rdest
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("bne " + rsrc2 + ", $0, 8");
//  		stuff.add("break 7");
//  		stuff.add("div " + rsrc1 + ", " + rsrc2);
//  		stuff.add("mfhi " + rdest);
//  	    }
//  	else if(instruction.equals("remu"))
//  	    {
//  		/*
//  		  Unsigned Remainder
//  		  remu rdest, rsrc1, rsrc2
//  		  ##  
//  		  bne rsrc2, $0, 8
//  		  break 7
//  		  divu rsrc1, rsrc2
//  		  mfhi rdest
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("bne " + rsrc2 + ", $0, 8");
//  		stuff.add("break 7");
//  		stuff.add("divu " + rsrc1 + ", " + rsrc2);
//  		stuff.add("mfhi " + rdest);
//  	    }
//   	else if(instruction.equals("rol"))
//  	    {
//  		/*
//  		  Rotate left
//  		  rol rdest, rsrc1, rsrc2
//  		  ##  
//  		  subu $1, $0, rsrc2
//  		  srlv $1, rsrc1, $1
//  		  sllv rdest, rsrc1, rsrc2
//  		  or rdest, rdest, $1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("subu $1, $0, " + rsrc2);
//  		stuff.add("srlv $1, " + rsrc1 + ", $1");
//  		stuff.add("sllv " + rdest + ", " + rsrc1 + ", " + rsrc2);
//  		stuff.add("or " + rdest + ", " + rdest + ", $1");
//  	    }
//  	else if(instruction.equals("ror"))
//  	    {
//  		/*
//  		  Rotate right
//  		  ror rdest, rsrc1, rsrc2
//  		  ##  
//  		  subu $1, $0, rsrc2
//  		  sllv $1, rsrc1, $1
//  		  srlv rdest, rsrc1, rsrc2
//  		  or rdest, rdest, $1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("subu $1, $0, " + rsrc2);
//  		stuff.add("sllv $1, " + rsrc1 + ", $1");
//  		stuff.add("srlv " + rdest + ", " + rsrc1 + ", " + rsrc2);
//  		stuff.add("or " + rdest + ", " + rdest + ", $1");
//  	    }
//  	else if(instruction.equals("li"))
//  	    {
//  		/*
//  		  Load Immediate
//  		  li rdest, imm
//  		  ##  
//  		  ori rdest, $0, imm
//  		*/

//  		String rdest = st.nextToken();
//  		String imm = st.nextToken();

//  		stuff.add("addi " + rdest + ", $0, " + imm + " # " + inst);
//  	    }
//  	else if(instruction.equals("seq"))
//  	    {
//  		/*
//  		  Set equal
//  		  seq rdest, rsrc1, rsrc2
//  		  ##  
//  		  beq rsrc2, rsrc1, 12
//  		  ori rdest, $0, 8
//  		  beq $0, $0, 8
//  		  ori rdest, $0, 1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("beq " + rsrc2 + ", " + rsrc1 + ", 12");
//  		stuff.add("ori " + rdest + ", $0, 8");
//  		stuff.add("beq $0, $0, 8");
//  		stuff.add("ori " + rdest + ", $0, 1");
//  	    }
//  	else if(instruction.equals("sge"))
//  	    {
//  		/*
//  		  Set greater than equal
//  		  sge rdest, rsrc1, rsrc2
//  		  ##  
//  		  bne rsrc2, rsrc1, 12
//  		  ori rdest, $0, 1
//  		  beq $0, $0, 8
//  		  slt rdest, rsrc2, rsrc1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("bne " + rsrc2 + ", " + rsrc1 + ", 12");
//  		stuff.add("ori " + rdest + ", $0, 1");
//  		stuff.add("beq $0, $0, 8");
//  		stuff.add("slt " + rdest + ", " + rsrc2 + ", " + rsrc1);
//  	    }
//   	else if(instruction.equals("sgeu"))
//  	    {
//  		/*
//  		  Set greater than equal unsigned
//  		  sgeu rdest, rsrc1, rsrc2
//  		  ##  
//  		  bne rsrc2, rsrc1, 12
//  		  ori rdest, $0, 1
//  		  beq $0, $0, 8
//  		  sltu rdest, rsrc2, rsrc1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("bne " + rsrc2 + ", " + rsrc1 + ", 12");
//  		stuff.add("ori " + rdest + ", $0, 1");
//  		stuff.add("beq $0, $0, 8");
//  		stuff.add("sltu " + rdest + ", " + rsrc2 + ", " + rsrc1);
//  	    }
//  	else if(instruction.equals("sgt"))
//  	    {
//  		/*
//  		  Set greater than
//  		  sgt rdest, rsrc1, rsrc2
//  		  ##  
//  		  slt rdest, rsrc2, rsrc1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("slt " + rdest + ", " + rsrc2 + ", " + rsrc1);
//  	    }
//  	else if(instruction.equals("sgtu"))
//  	    {
//  		/*
//  		  Set greater than unsigned
//  		  sgtu rdest, rsrc1, rsrc2
//  		  ##  
//  		  sltu rdest, rsrc2, rsrc1
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("sltu " + rdest + ", " + rsrc2 + ", " + rsrc1);
//  	    }
//  	else if(instruction.equals("sle"))
//  	    {
//  		/*
//  		  Set less than equal
//  		  sle rdest, rsrc1, rsrc2
//  		  ##  
//  		  bne rsrc2, rsrc1, 12
//  		  ori rdest, $0, 1
//  		  beq $0, $0, 8
//  		  slt rdest, rsrc1, rsrc2
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("bne " + rsrc2 + ", " + rsrc1 + ", 12");
//  		stuff.add("ori " + rdest + ", $0, 1");
//  		stuff.add("beq $0, $0, 8");
//  		stuff.add("slt " + rdest + ", " + rsrc1 + ", " + rsrc2);
//  	    }
//  	else if(instruction.equals("sleu"))
//  	    {
//  		/*
//  		  Set less than equal
//  		  sleu rdest, rsrc1, rsrc2
//  		  ##  
//  		  bne rsrc2, rsrc1, 12
//  		  ori rdest, $0, 1
//  		  beq $0, $0, 8
//  		  sltu rdest, rsrc1, rsrc2
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("bne " + rsrc2 + ", " + rsrc1 + ", 12");
//  		stuff.add("ori " + rdest + ", $0, 1");
//  		stuff.add("beq $0, $0, 8");
//  		stuff.add("sltu " + rdest + ", " + rsrc1 + ", " + rsrc2);
//  	    }
//  	else if(instruction.equals("sne"))
//  	    {
//  		/*
//  		  Set not equal
//  		  sne rdest, rsrc1, rsrc2
//  		  ##  
//  		  beq rsrc2, rsrc1, 12
//  		  ori rdest, $0, 1
//  		  beq $0, $0, 8
//  		  ori rdest, $0, 0
//  		*/
//  		String rdest = st.nextToken();
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
		
//  		stuff.add("beq " + rsrc2 + ", " + rsrc1 + ", 12");
//  		stuff.add("ori " + rdest + ", $0, 1");
//  		stuff.add("beq $0, $0, 8");
//  		stuff.add("ori " + rdest + ", $0, 0");
//  	    }
//  	else if(instruction.equals("b"))
//  	    {
//  		/*
//  		  Branch
//  		  b label 
//  		  ##
//  		  beq $0, $0, label
//  		*/
//  		String label = st.nextToken();
		
//  		stuff.add("beq $0, $0, " + label);
//  	    }
//  	else if(instruction.equals("beqz"))
//  	    {
//  		/*
//  		  Branch on equal zero
//  		  beqz rsrc, label
//  		  ##  
//  		  beq rsrc, $0, label
//  		*/
//  		String rsrc = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("beq " + rsrc + ", " + label);
//  	    }
//  	else if(instruction.equals("bge"))
//  	    {
//  		/*
//  		  Branch on greater than equal
//  		  bge rsrc1, rsrc2, label
//  		  ##  
//  		  slt $1, rsrc1, rsrc2
//  		  beq $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("slt $1, " + rsrc1 + ", " + rsrc2);
//  		stuff.add("beq $1, $0, " + label);
//  	    }
//  	else if(instruction.equals("bgeu"))
//  	    {
//  		/*
//  		  Branch on greater than equal unsigned
//  		  bgeu rsrc1, rsrc2, label
//  		  ##  
//  		  sltu $1, rsrc1, rsrc2
//  		  beq $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("sltu $1, " + rsrc1 + ", " + rsrc2);
//  		stuff.add("beq $1, $0, " + label);
//  	    }
//   	else if(instruction.equals("bgt"))
//  	    {
//  		/*
//  		  Branch on greater than
//  		  bgt rsrc1, rsrc2, label
//  		  ##  
//  		  slt $1, rsrc2, rsrc1
//  		  bne $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("slt $1, " + rsrc2 + ", " + rsrc1);
//  		stuff.add("bne $1, $0, " + label);
//  	    }
//   	else if(instruction.equals("bgtu"))
//  	    {
//  		/*
//  		  Branch on greater than unsigned
//  		  bgtu rsrc1,  rsrc2, label
//  		  ##
//  		  sltu $1, rsrc2, rsrc1
//  		  bne $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("sltu $1, " + rsrc2 + ", " + rsrc1);
//  		stuff.add("bne $1, $0, " + label);
//  	    }
//  	else if(instruction.equals("ble"))
//  	    {
//  		/*
//  		  Branch on less than equal
//  		  ble rsrc1, rsrc2, label
//  		  ##
//  		  slt $1, rsrc2, rsrc1
//  		  beq $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("slt $1, " + rsrc2 + ", " + rsrc1);
//  		stuff.add("beq $1, $0, " + label);
//  	    }
//  	else if(instruction.equals("bleu"))
//  	    {
//  		/*
//  		  Branch on less than equal unsigned
//  		  bleu rsrc1, rsrc2, label
//  		  ##
//  		  sltu $1, rsrc2, rsrc1
//  		  beq $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("sltu $1, " + rsrc2 + ", " + rsrc1);
//  		stuff.add("beq $1, $0, " + label);
//  	    }
//  	else if(instruction.equals("blt"))
//  	    {
//  		/*
//  		  Branch on less than
//  		  ble rsrc1, rsrc2, label
//  		  ##
//  		  slt $1, rsrc1, rsrc2
//  		  bne $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("slt $1, " + rsrc1 + ", " + rsrc2);
//  		stuff.add("bne $1, $0, " + label);
//  	    }
//   	else if(instruction.equals("bltu"))
//  	    {
//  		/*
//  		  Branch on less than unsigned
//  		  bleu rsrc1, src2, label
//  		  ##
//  		  sltu $1, rsrc1, src2
//  		  bne $1, $0, label
//  		*/
//  		String rsrc1 = st.nextToken();
//  		String rsrc2 = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("sltu $1, " + rsrc1 + ", " + rsrc2);
//  		stuff.add("bne $1, $0, " + label);
//  	    }
//  	else if(instruction.equals("bnez"))
//  	    {
//  		/*
//  		  Branch on not equal zero
//  		  bnez rsrc, label
//  		  ##
//  		  bne rsrc, $0, label
//  		*/
//  		String rsrc = st.nextToken();
//  		String label = st.nextToken();
		
//  		stuff.add("bne " + rsrc + ", $0, " + label);
//  	    }
//  	else if(instruction.equals("la"))
//  	    {
//  		/*
//  		  Load Address
//  		  la rdest, address
//  		  ##
//  		  ori rdest, $0, address
//  		*/
//  		String rdest = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("ori " + rdest + ", $0, " + address);
//  	    }
//  	else if(instruction.equals("ulh"))
//  	    {
//  		/** TODO: Check to see that the address + "+1" will work
//  		    Also, check about address 1234; is that relative to something? **/

//  		/*
//  		  Unaligned load halfword
//  		  ulh rdest, address
//  		  ##
//  		  lb rdest, address+1($0)
//  		  lbu $1, 1234($0)
//  		  sll rdest, rdest, 8
//  		  or rdest, rdest, $1
//  		*/
//  		String rdest = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("lb " + rdest + ", " + address + "+1($0)");
//  		stuff.add("lbu $1, 1234($0)");
//  		stuff.add("sll " + rdest + ", " + rdest + ", 8");
//  		stuff.add("or " + rdest + ", " + rdest + ", $1");
//  	    }
//  	else if(instruction.equals("ulhu"))
//  	    {
//  		/*
//  		  Unaligned load halfword unsigned
//  		  ulhu rdest, address
//  		  ##
//  		  lbu rdest, address+1($0)
//  		  lbu $1, 1234($0)
//  		  sll rdest, rdest, 8
//  		  or rdest, rdest, $1
//  		*/
//  		String rdest = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("lbu " + rdest + ", " + address + "+1($0)");
//  		stuff.add("lbu $1, 1234($0)");
//  		stuff.add("sll " + rdest + ", " + rdest + ", 8");
//  		stuff.add("or " + rdest + ", " + rdest + ", $1");
//  	    }
//  	else if(instruction.equals("ulw"))
//  	    {
//  		/*
//  		  Unalligned load word
//  		  ulw rdest, address
//  		  ##
//  		  lwl rdest, address+3($0)
//  		  lwr rdest, address($0)
//  		*/
//  		String rdest = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("lwl " + rdest + ", " + address + "+3($0)");
//  		stuff.add("lwr " + rdest + ", " + address + "($0)");
//  	    }	    
//  	else if(instruction.equals("sd"))
//  	    {
//  		/*
//  		  Store doubleword
//  		  sd rsrc, address
//  		  ##
//  		  sw rsrc, address($0)
//  		  sw rsrc+1, address+4($0)
//  		*/
//  		String rsrc = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("sw " + rsrc + ", " + address + "($0)");
//  		stuff.add("sw " + rsrc + ", " + address + "+4($0)");
//  	    }
//   	else if(instruction.equals("ush"))
//  	    {
//  		/*
//  		  Unaligned store halfword
//  		  ush rsrc, address
//  		  ##
//  		  sb rsrc, address($0)
//  		  srl $1, rsrc, 8
//  		  sb $1, address+1($0)
//  		*/
//  		String rsrc = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("sb " + rsrc + ", " + address + "($0)");
//  		stuff.add("srl $1, " + rsrc + ", 8");
//  		stuff.add("sb $1, " + address + "+1($0)");
//  	    }
//   	else if(instruction.equals("usw"))
//  	    {
//  		/*
//  		  Unaligned store word
//  		  usw rsrc, address
//  		  ##
//  		  swl rsrc, address+3($0)
//  		  swr rsrc, address($0)
//  		*/
//  		String rsrc = st.nextToken();
//  		String address = st.nextToken();
		
//  		stuff.add("swl " + rsrc + ", " + address + "+3($0)");
//  		stuff.add("swr " + rsrc + ", " + address + "($0)");
//  	    }
//  	else if(instruction.equals("move"))
//  	    {
//  		/*
//  		  Move
//  		  move rdest, rsrc
//  		  ##  
//  		  addu rdest, $0, rsrc
//  		*/

//  		String rdest = st.nextToken();
//  		String rsrc = st.nextToken();

//  		stuff.add("addu " + rdest + ", $0, " + rsrc);
//  	    }
//  	else if(instruction.equals("j"))
//  	    {
//  		//check for use of jr
//  		String rdest = st.nextToken();
//  		if(parseRegister(rdest) != -128) // compiler ment jr but said j
//  		    stuff.add("jr " + rdest);
//  		else
//  		    stuff.add(inst);
//  	    }
//  	else if (instruction.equals("sra"))
//  	    {
//  		String rd = st.nextToken();
//  		String rt = st.nextToken();
//  		int shamt = Integer.parseInt(st.nextToken());

//  		// compute the bit mask to "or" rd with if rt is negative
//  		// so that rd remains negative after the shift
//  		int imm = 0;
//  		if(shamt > 0)
//  		    imm = -(2^(32-shamt));
		
//  		String endlabel = "end" + srac + "sra";

//  		stuff.add(".set noat");
//  		//shift rt to the right the appropriate amount
//  		stuff.add("srl " + rd + ", " + rt + ", " + shamt);
//  		//check to see if rt is less than 0
//  		stuff.add("slt $1, " + rt + ", $0");
//  		//if rt is positive skip to the end label
//  		stuff.add("beq $1, $0, " + endlabel);
//  		//if rt is less than 0, then we need to make the digits
//  		// on the right of the shifted number 1s so that rd
//  		// remains negative
//  		stuff.add("li $1, " + imm);
//  		stuff.add("or " + rd + ", " + rd + ", $1");
//  		stuff.add(endlabel + ":");
//  		stuff.add(".set at");

//  		//stuff.add(inst);
//  	    }

    }

    // returns integer name of register
    public static byte parseRegister(String reg)
    {
	byte regnum = 0;
	if(reg.equals("$0")) regnum = 0;
	else if(reg.equals("$zero")) regnum = 0;
	else if(reg.equals("$1"))  regnum = 1;
	else if(reg.equals("$at")) regnum = 1;
	else if(reg.equals("$2"))  regnum = 2;
	else if(reg.equals("$v0")) regnum = 2;
	else if(reg.equals("$3"))  regnum = 3;
	else if(reg.equals("$v1")) regnum = 3;
	else if(reg.equals("$4"))  regnum = 4;
	else if(reg.equals("$a0")) regnum = 4;
	else if(reg.equals("$5"))  regnum = 5;
	else if(reg.equals("$a1")) regnum = 5;
	else if(reg.equals("$6"))  regnum = 6;
	else if(reg.equals("$a2")) regnum = 6;
	else if(reg.equals("$7"))  regnum = 7;
	else if(reg.equals("$a3")) regnum = 7;
	else if(reg.equals("$8"))  regnum = 8;
	else if(reg.equals("$t0")) regnum = 8;
	else if(reg.equals("$9"))  regnum = 9;
	else if(reg.equals("$t1")) regnum = 9;
	else if(reg.equals("$10")) regnum = 10;
	else if(reg.equals("$t2")) regnum = 10;
	else if(reg.equals("$11")) regnum = 11;
	else if(reg.equals("$t3")) regnum = 11;
	else if(reg.equals("$12")) regnum = 12;
	else if(reg.equals("$t4")) regnum = 12;
	else if(reg.equals("$13")) regnum = 13;
	else if(reg.equals("$t5")) regnum = 13;
	else if(reg.equals("$14")) regnum = 14;
	else if(reg.equals("$t6")) regnum = 14;
	else if(reg.equals("$15")) regnum = 15;
	else if(reg.equals("$t7")) regnum = 15;
	else if(reg.equals("$16")) regnum = 16;
	else if(reg.equals("$s0")) regnum = 16;
	else if(reg.equals("$17")) regnum = 17;
	else if(reg.equals("$s1")) regnum = 17;
	else if(reg.equals("$18")) regnum = 18;
	else if(reg.equals("$s2")) regnum = 18;
	else if(reg.equals("$19")) regnum = 19;
	else if(reg.equals("$s3")) regnum = 19;
	else if(reg.equals("$20")) regnum = 20;
	else if(reg.equals("$s4")) regnum = 20;
	else if(reg.equals("$21")) regnum = 21;
	else if(reg.equals("$s5")) regnum = 21;
	else if(reg.equals("$22")) regnum = 22;
	else if(reg.equals("$s6")) regnum = 22;
	else if(reg.equals("$23")) regnum = 23;
	else if(reg.equals("$s7")) regnum = 23;
	else if(reg.equals("$24")) regnum = 24;
	else if(reg.equals("$t8")) regnum = 24;
	else if(reg.equals("$25")) regnum = 25;
	else if(reg.equals("$t9")) regnum = 25;
	else if(reg.equals("$26")) regnum = 26;
	else if(reg.equals("$k0")) regnum = 26;
	else if(reg.equals("$27")) regnum = 27;
	else if(reg.equals("$k1")) regnum = 27;
	else if(reg.equals("$28")) regnum = 28;
	else if(reg.equals("$gp")) regnum = 28;
	else if(reg.equals("$29")) regnum = 29;
	else if(reg.equals("$sp")) regnum = 29;
	else if(reg.equals("$30")) regnum = 30;
	else if(reg.equals("$fp")) regnum = 30;
	else if(reg.equals("$31")) regnum = 31;
	else if(reg.equals("$ra")) regnum = 31;
	else regnum = -128;
	return regnum;
    }
}