diff --git a/build.sh b/build.sh
new file mode 100755
index 0000000..f4e6621
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+mvn clean package -e
diff --git a/generate_assembly_r.sh b/generate_assembly_r.sh
new file mode 100755
index 0000000..fb40b97
--- /dev/null
+++ b/generate_assembly_r.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+FILENAME=$1
+
+if [ -z "$1" ] ; then
+    echo "FILENAME is missing"
+    exit 1
+fi
+
+echo "Generating assembly code for file ${FILENAME}"
+
+java -cp "chocopy-ref.jar:target/assignment.jar" chocopy.ChocoPy --pass=rrr ${FILENAME}
diff --git a/generate_assembly_s.sh b/generate_assembly_s.sh
new file mode 100755
index 0000000..129dd7f
--- /dev/null
+++ b/generate_assembly_s.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+FILENAME=$1
+
+if [ -z "$1" ] ; then
+    echo "FILENAME is missing"
+    exit 1
+fi
+
+echo "Generating assembly code for file ${FILENAME}"
+
+java -cp "chocopy-ref.jar:target/assignment.jar" chocopy.ChocoPy --pass=rrs ${FILENAME}
diff --git a/run_r.sh b/run_r.sh
new file mode 100755
index 0000000..2ab3ab0
--- /dev/null
+++ b/run_r.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+FILENAME=$1
+
+if [ -z "$1" ] ; then
+    echo "FILENAME is missing"
+    exit 1
+fi
+
+echo "Running file ${FILENAME}"
+
+java -cp "chocopy-ref.jar:target/assignment.jar" chocopy.ChocoPy --pass=rrr --run ${FILENAME}
diff --git a/run_s.sh b/run_s.sh
new file mode 100755
index 0000000..9d41415
--- /dev/null
+++ b/run_s.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+FILENAME=$1
+
+if [ -z "$1" ] ; then
+    echo "FILENAME is missing"
+    exit 1
+fi
+
+echo "Running file ${FILENAME}"
+
+java -cp "chocopy-ref.jar:target/assignment.jar" chocopy.ChocoPy --pass=rrs --run ${FILENAME}
diff --git a/src/main/asm/chocopy/common/allChars.s b/src/main/asm/chocopy/common/allChars.s
new file mode 100644
index 0000000..0058fdd
--- /dev/null
+++ b/src/main/asm/chocopy/common/allChars.s
@@ -0,0 +1,2 @@
+.space 5120
+    .text
\ No newline at end of file
diff --git a/src/main/asm/chocopy/common/initchars.s b/src/main/asm/chocopy/common/initchars.s
new file mode 100644
index 0000000..ffd40c3
--- /dev/null
+++ b/src/main/asm/chocopy/common/initchars.s
@@ -0,0 +1,22 @@
+       la a0, $str$prototype
+        lw t0, 0(a0)
+        lw t1, 4(a0)
+        lw t2, 8(a0)
+        li t3, 1
+        la a0, allChars
+        li t4, 256
+        mv t5, zero
+initchars_1:
+        sw t0, 0(a0)
+        sw t1, 4(a0)
+        sw t2, 8(a0)
+        sw t3, 12(a0)
+        sw t5, 16(a0)
+        addi a0, a0, 20
+        addi t5, t5, 1
+        bne t4, t5, initchars_1
+        jr  ra
+        .data
+        .align 2
+
+        
\ No newline at end of file
diff --git a/src/main/asm/chocopy/common/makeint.s b/src/main/asm/chocopy/common/makeint.s
index 7fd541d..9fbf065 100644
--- a/src/main/asm/chocopy/common/makeint.s
+++ b/src/main/asm/chocopy/common/makeint.s
@@ -1,11 +1,11 @@
-
-    addi sp, sp, -8
-    sw ra, 4(sp)
-    sw a0, 0(sp)
-    la a0, $int$prototype
-    jal ra, alloc
-    lw t0, 0(sp)
-    sw t0, @.__int__(a0)
-    lw ra, 4(sp)
-    addi sp, sp, 8
-    jr ra
\ No newline at end of file
+# Box integer
+	addi sp, sp, -8
+	sw ra, 4(sp)
+	sw a0, 0(sp)
+	la a0, $int$prototype
+	jal ra, alloc
+	lw t0, 0(sp)
+	sw t0, @.__int__(a0)
+	lw ra, 4(sp)
+	addi sp, sp, 8
+	jr ra
\ No newline at end of file
diff --git a/src/main/java/chocopy/pa3/CodeGenImpl.java b/src/main/java/chocopy/pa3/CodeGenImpl.java
index 06bf552..d75e2b8 100644
--- a/src/main/java/chocopy/pa3/CodeGenImpl.java
+++ b/src/main/java/chocopy/pa3/CodeGenImpl.java
@@ -1,18 +1,18 @@
 package chocopy.pa3;
 
-import java.net.Socket;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Stack;
 
-import chocopy.common.analysis.AbstractNodeAnalyzer;
-import chocopy.common.analysis.SymbolTable;
+import chocopy.common.analysis.*;
 import chocopy.common.astnodes.*;
 import chocopy.common.analysis.types.*;
 import chocopy.common.codegen.*;
 
-import static chocopy.common.codegen.RiscVBackend.Register.*;
 import chocopy.common.codegen.RiscVBackend.Register;
+import static chocopy.common.codegen.RiscVBackend.Register.*;
 
 
 /**
@@ -33,15 +33,15 @@ public class CodeGenImpl extends CodeGenBase
 {
     /** Label for built-in routines. */
     protected final Label makeintLabel = new Label("makeint");
-    protected final Label strneqlLablel = new Label("strneql");
-    protected final Label streqlLablel = new Label("streql");
-    protected final Label makeboolLablel = new Label("makebool");
-    protected final Label strcatLablel = new Label("strcat");
-    protected final Label concatLablel = new Label("concat");
-    protected final Label conslistLablel = new Label("conslist");
-
-
-    
+    protected final Label strneqlLabel = new Label("strneql");
+    protected final Label streqlLabel = new Label("streql");
+    protected final Label makeboolLabel = new Label("makebool");
+    protected final Label strcatLabel = new Label("strcat");
+    protected final Label concatLabel = new Label("concat");
+    protected final Label conslistLabel = new Label("conslist");
+    protected final Label initcharsLabel = new Label("initchars");  
+    protected final Label allCharsLabel = new Label("allChars");
+      
 
     /** Operation on None. */
     private final Label errorNone = new Label("error.None");
@@ -56,8 +56,12 @@ public class CodeGenImpl extends CodeGenBase
     /** A code generator emitting instructions to BACKEND. */
     public CodeGenImpl(RiscVBackend backend) 
     {
+    		
         super(backend);
-        
+        backend.defineSym("listHeaderWords", "4"); 
+        backend.defineSym("strHeaderWords", "4");
+        backend.defineSym("bool.True", "const_1"); 
+        backend.defineSym("bool.False", "const_0");
     }
     
     
@@ -76,16 +80,19 @@ public class CodeGenImpl extends CodeGenBase
      */
     protected void emitTopLevel(List<Stmt> statements) 
     {
+    	
         StmtAnalyzer stmtAnalyzer = new StmtAnalyzer(null);
         backend.emitADDI(SP, SP, -2 * backend.getWordSize(), "Saved FP and saved RA (unused at top level).");
         backend.emitSW(ZERO, SP, 0, "Top saved FP is 0.");
         backend.emitSW(ZERO, SP, 4, "Top saved RA is 0.");
         backend.emitADDI(FP, SP, 2 * backend.getWordSize(), "Set FP to previous SP.");
-
+        backend.emitJAL(initcharsLabel,"Initialize one-character strings");
         for (Stmt stmt : statements) 
         {
             stmt.dispatch(stmtAnalyzer);
         }
+        stmtAnalyzer.emitSizeLabel();
+
         backend.emitLI(A0, EXIT_ECALL, "Code for ecall: exit");
         backend.emitEcall(null);
     }
@@ -109,9 +116,8 @@ public class CodeGenImpl extends CodeGenBase
         // space for return address = 1
         // space for control link = 1
         // space for static link =  1
-        // space for params = num of params 
         // space for locals = num of locals
-        int requiredStackSpace = (1 + 1 + 1 + funcInfo.getLocals().size() + funcInfo.getParams().size())*wordSize;
+        int requiredStackSpace = (1 + 1 + 1 + funcInfo.getLocals().size())*wordSize;
         
         backend.emitADDI(SP, SP, -requiredStackSpace, "Reserve space for stack frame.");
         backend.emitSW(RA, SP, requiredStackSpace-4, "return address");
@@ -122,27 +128,26 @@ public class CodeGenImpl extends CodeGenBase
         
         
         StmtAnalyzer stmtAnalyzer = new StmtAnalyzer(funcInfo);
-        int emptySlotNum = 4;
+        int emptySlotNum = 3;
         for (StackVarInfo var : funcInfo.getLocals()) {
-    			// store at requiredStackSpace-emptySlotNum*wordSize(SP), then emptySlotNum++
-        		Literal varLitral = var.getInitialValue();
-        		varLitral.dispatch(stmtAnalyzer);
+        		Literal varLiteral = var.getInitialValue();
+        		varLiteral.dispatch(stmtAnalyzer);
         		// All Literals should save locations for the values in A0
     			backend.emitSW(A0, SP, requiredStackSpace-emptySlotNum*wordSize, "Push local variable " + var.getVarName() + " onto stack");
     			emptySlotNum++;
         }
         
+        
         // --- Function Body ---
         // statements load all the variables that caller put on stack
         // statements use fp to load the variables
         // example: 0(fp) is the last variable (z) while 8(fp) is the first variable (x) 
         // for function with 3 params f(x, y, z)
         for (Stmt stmt : funcInfo.getStatements()) {
-        	    //System.out.println(stmt.toString());
             stmt.dispatch(stmtAnalyzer);
         }
+        stmtAnalyzer.emitSizeLabel();
         backend.emitJ(stmtAnalyzer.epilogue, "Jump to function epilogue");
-
         
         
         // --- Epilogue ---
@@ -192,16 +197,48 @@ public class CodeGenImpl extends CodeGenBase
         private final FuncInfo funcInfo;
 
         /** Label of code that exits from block. */
-        protected Label elseBlock;
+        protected Stack<Label> elseBlock = new Stack<Label>();
 
-        /** Variable to keep track of offsets of stored variables */
-        private Map<SymbolInfo, Integer> offsetMap = new HashMap<>();
+     
+        
         private final String size_label;
         /** Variable to store offset from frame pointer to identify next 
           * empty space on stack frame to store variable*/
         private int sp_off;
         /** Variable to store maximum possible offset depending on stack size.*/
         private int max_sp;
+        private boolean l_value = false;
+        private final Register[] registerPool = {T2,T3, T4, T5, T6, A2, A3, A4, A5, A6, A7};
+        private final boolean[] registerAvilMap = {true, true, true, true, true, true, true, true, true, true, true};
+        private int getRegister(){ //return a handle of a vacant register
+            for(int i = 0; i < 11; ++i)
+                if(registerAvilMap[i])
+                {
+                    registerAvilMap[i]=false;
+                    return i;
+                }
+            for(int i = 0; i < 11; ++i)
+            {
+                System.out.println("Insufficient Registers!!!");
+                registerAvilMap[i] = true; //freeall;
+            }
+            return 0;
+        }
+        private void freeRegister(int handle){ //handle used to free the register
+            registerAvilMap[handle] = true;
+        }
+        
+        private int getParamLocationOffset(int index, int paramSize) {
+        		return (paramSize - index - 1) * wordSize;
+        }
+        
+        private int getLocalVarLocationOffset(int index, int paramSize) {
+    			return - (index - paramSize + 1) * wordSize;
+        }
+        
+        private int getStaticLinkOffset(int paramSize) {
+    			return paramSize * wordSize;
+        }
         
         /**
          * An analyzer for the function described by FUNCINFO0, which is null for the
@@ -215,24 +252,28 @@ public class CodeGenImpl extends CodeGenBase
                 size_label = "@..main.size";
             } else {
                 sym = funcInfo.getSymbolTable();
-                sp_off = max_sp = funcInfo0.getLocals().size() + 2;
+                sp_off = max_sp = funcInfo0.getLocals().size() + 2 + 1;
                 size_label = "@"+funcInfo0.getFuncName()+".size";
             }
             epilogue = generateLocalLabel();
         }
         private void incSp(int i){
-            sp_off+=i+1;
+            sp_off+=i;
             max_sp = max_sp >= sp_off?max_sp:sp_off;
         }
         
-        
+        public void emitSizeLabel(){
+            backend.defineSym(size_label, max_sp*wordSize);
+        }
         
         
         // *********** functions start ***********
         
         public Register analyze(CallExpr node) {
-        		backend.emitLW(T6, FP, 0, "Inside CallExpr: " + node.function.name);
-            SymbolInfo Ty = globalSymbols.get(node.function.name);
+        	    System.out.println("Inside CallExpr: " + node.function.name);
+        		//ackend.emitLW(T6, FP, 0, "Inside CallExpr: " + node.function.name);
+        		
+            SymbolInfo Ty = sym.get(node.function.name);
             if(Ty instanceof ClassInfo){
                 //object create
                 ClassInfo cls = (ClassInfo) Ty;
@@ -252,10 +293,10 @@ public class CodeGenImpl extends CodeGenBase
                     String.format("Load pointer to prototype of: %s", cls.getClassName()));
                 backend.emitJAL(objectAllocLabel, "Allocate new object in A0");
                 backend.emitSW(A0, FP, -sp_off*wordSize, String.format("Push on stack slot %d", sp_off));
-                incSp(0);
+                incSp(1);
 
                 backend.emitSW(A0, FP, -sp_off*wordSize, "Push argument 0 from last.");
-                backend.emitADDI(SP, FP, sp_off, "Set SP to last argument.");
+                backend.emitADDI(SP, FP, -sp_off*wordSize, "Set SP to last argument.");
                 backend.emitLW(A1, A0, getDispatchTableOffset(), "Load address of object's dispatch table");
                 backend.emitLW(A1, A1, getMethodOffset(cls, "__init__"), String.format("Load address of method: %s.__init__", cls.getClassName()));
                 backend.emitJALR(A1, String.format("Invoke method: %s.__init", cls.getClassName()));
@@ -265,29 +306,82 @@ public class CodeGenImpl extends CodeGenBase
             } else {	    			
 	        		// function
 	        		Identifier functionId = node.function;
+	        		FuncInfo calleeFunctionInfo = (FuncInfo) sym.get(node.function.name);
+	        		boolean isInMainFunction = funcInfo == null;
+	        		if (!isInMainFunction) {
+                        System.out.println("--> caller: " + funcInfo.getFuncName() + " depth: " + funcInfo.getDepth());
+                        System.out.println("--> callee: " + calleeFunctionInfo.getFuncName() + " depth: " + calleeFunctionInfo.getDepth()); 
+                    
+                        int calleeDepth = calleeFunctionInfo.getDepth();
+                    int callerDepth = funcInfo.getDepth();
+                    int jumps = callerDepth - calleeDepth + 1;
+                    
+                    int tmpHandle = getRegister();
+                    Register tmp = registerPool[tmpHandle];
+                    
+                    backend.emitMV(tmp, FP, "Load FP");
+                    
+                    FuncInfo curr = funcInfo;
+                    for (int i = 0; i < jumps; i++) {
+                    		backend.emitLW(tmp, tmp, curr.getParams().size()*wordSize, "Load static link to " + curr.getFuncName());
+                    		curr = curr.getParentFuncInfo();
+                    }
+                                   
+                    backend.emitSW(tmp, FP, -(1+sp_off) * wordSize, "Push static link onto active frame.");
+                    freeRegister(tmpHandle);
+                    } 
+                    else {
+	        			backend.emitSW(FP, FP, -(1+sp_off) * wordSize, "Push static link onto active frame.");
+	        		}
 	        		
-	        		List<Expr> args = node.args;
-	        		int spaceRequiredForArgs = (args.size() + 1)*4;
-	        		//backend.emitSW(A0, SP, -4, "Put static link");
+     			List<Expr> args = node.args;
+                int spaceRequiredForArgs = (args.size() + 1)*4;
 	        		for (int i = 0; i < args.size(); i++) {
 	        			int argNum = i + 1;
 	        			int slotNum = argNum + 1; // We have extra slot for static link
 	        			Expr expr = args.get(i);
 	        			expr.dispatch(this);
+	        			
+	        			String formalParamName = calleeFunctionInfo.getParams().get(i);
+	        			StackVarInfo formalParamInfo = (StackVarInfo) calleeFunctionInfo.getSymbolTable().get(formalParamName);
+	        			
+	        			if (expr.getInferredType().equals(Type.INT_TYPE)) {
+	        				if ((functionId.name.equals("print")) &&(formalParamInfo.getVarType().equals(Type.OBJECT_TYPE) || formalParamInfo.getVarType().equals(Type.INT_TYPE))) {
+                                if(!(args.size() == 1 && (args.get(0) instanceof CallExpr) && 
+                                    (sym.get(((CallExpr) args.get(0)).function.name) instanceof ClassInfo)))
+                                    backend.emitJAL(makeintLabel, "Box integer");
+
+
+	        				} else  {
+	        					// FIXME: passed argument does not match formal parameter
+	        				}
+	                } else if (expr.getInferredType().equals(Type.BOOL_TYPE)) { 
+	                    	if ((functionId.name.equals("print"))&&(formalParamInfo.getVarType().equals(Type.OBJECT_TYPE) || formalParamInfo.getVarType().equals(Type.BOOL_TYPE))) {
+	                    		if(!(args.size() == 1 && (args.get(0) instanceof CallExpr) && 
+                                    (sym.get(((CallExpr) args.get(0)).function.name) instanceof ClassInfo)))
+                                        backend.emitJAL(makeboolLabel, "Box boolean");
+                        } 
+                        else {
+	                    		// FIXME: passed argument does not match formal parameter
+	                    }
+                    }
+	        			
 	        			// All expressions should save their end result in A0
-	        			// So, once expr is evaluated add value inside A0 onto stack as an argument
-	        			backend.emitSW(A0, SP, -wordSize*slotNum, "Push argument " + argNum + " from left");
+	        			// So, once expr is evaluated add value inside A0 onto stack as an actual argument
+	        			backend.emitSW(A0, FP, -(slotNum+sp_off) * wordSize, "Push actual argument for " + formalParamName + " onto stack");
 	        		}
 	        		
-	        		backend.emitADDI(SP, SP, -spaceRequiredForArgs, "Set SP to last argument.");
-	        		backend.emitJAL(new Label("$"+functionId.name), "Invoke function: " + functionId.name);
-	        		backend.emitADDI(SP, SP, spaceRequiredForArgs, "Set SP to stack frame top.");
+	        		backend.emitADDI(SP, FP, -spaceRequiredForArgs-sp_off*wordSize, "Set SP to last argument.");
+	        		backend.emitJAL(calleeFunctionInfo.getCodeLabel(), "Invoke function: " + functionId.name);
+	        		backend.emitADDI(SP, FP, spaceRequiredForArgs+sp_off*wordSize, "Set SP to stack frame top.");
             }
+            
             return A0;
         }
         
         public Register analyze(MethodCallExpr node) {
-        		backend.emitLW(T6, FP, 0, "Inside MethodCallExpr: " + node.method.member.name);
+        		System.out.println("Inside MethodCallExpr: " + node.method.member.name);
+        	//	backend.emitLW(T6, FP, 0, "Inside MethodCallExpr: " + node.method.member.name);
             Register obj = node.method.object.dispatch(this);
             int n_args = node.args.size();
             
@@ -303,8 +397,11 @@ public class CodeGenImpl extends CodeGenBase
                     String.format("Push argument %d from last.", n_args - i - 1));
             
             backend.emitLW(A0, FP, (n_args- sp_off) * wordSize, String.format("Peek stack slot %d", sp_off - (n_args + 1)));
-            ClassInfo objectClass = (ClassInfo)sym.get(((Identifier)node.method.object).name);
-
+            ClassInfo objectClass = null;
+            if(node.method.object instanceof CallExpr)
+                objectClass = (ClassInfo)globalSymbols.get(((CallExpr)node.method.object).getInferredType().className());
+            else 
+                objectClass = (ClassInfo)globalSymbols.get(node.method.object.getInferredType().className());
             backend.emitLW(A1, A0, getDispatchTableOffset(), "Load address of object's dispatch table");
             backend.emitLW(A1, A1, getMethodOffset(objectClass, node.method.member.name), 
                 String.format("Load address of method: %s.%s", objectClass.getClassName(), node.method.member.name));
@@ -319,7 +416,8 @@ public class CodeGenImpl extends CodeGenBase
         
         @Override
         public Register analyze(ReturnStmt stmt) {
-        		backend.emitLW(T6, FP, 0, "Inside ReturnStmt: ");
+        		System.out.println("Inside ReturnStmt: ");
+        	//	backend.emitLW(T6, FP, 0, "Inside ReturnStmt: ");
         	    Expr expr = stmt.value;
         	    if (expr == null) {
         	    		backend.emitMV(A0, ZERO, "Return None");
@@ -328,7 +426,7 @@ public class CodeGenImpl extends CodeGenBase
         	    
         	    // All expressions should save their end result in A0
         	    expr.dispatch(this);
-                
+        	    backend.emitJ(this.epilogue, "Jump to function epilogue");
             return A0;
         }
         
@@ -339,7 +437,8 @@ public class CodeGenImpl extends CodeGenBase
         @Override
         public Register analyze(NoneLiteral node) 
         {
-        		backend.emitLW(T6, FP, 0, "Inside NoneLiteral: ");
+        		System.out.println("Inside NoneLiteral: ");
+        	//	backend.emitLW(T6, FP, 0, "Inside NoneLiteral: ");
             backend.emitMV(Register.A0, Register.ZERO, "Load none");
             return Register.A0;
         }
@@ -347,7 +446,8 @@ public class CodeGenImpl extends CodeGenBase
         @Override
         public Register analyze(StringLiteral node) 
         {
-        		backend.emitLW(T6, FP, 0, "Inside StringLiteral: ");
+        	System.out.println("Inside StringLiteral: ");
+        		//backend.emitLW(T6, FP, 0, "Inside StringLiteral: ");
             Label l = constants.getStrConstant(node.value);
             backend.emitLA(Register.A0, l, "Load string literal");
             return Register.A0;
@@ -356,58 +456,138 @@ public class CodeGenImpl extends CodeGenBase
         @Override
         public Register analyze(BooleanLiteral node) 
         {
-        		backend.emitLW(T6, FP, 0, "Inside BooleanLiteral: ");
+        		System.out.println("Inside BooleanLiteral: ");
+        	//	backend.emitLW(T6, FP, 0, "Inside BooleanLiteral: ");
             if(node.value==true)
                 backend.emitLI(Register.A0, 1, "Load boolean literal: true ");
             else
                 backend.emitLI(Register.A0, 0, "Load boolean literal: false ");
             return Register.A0;
         }
+        
+        class StackVarRuntimeInfo {
+            public final int off;
+            public final Register sl;
+            public int regHandle;
+            StackVarRuntimeInfo(Register sl, int off){
+                this.off = off;
+                this.sl = sl;
+                regHandle = -1;
+            }
+            StackVarRuntimeInfo(Register sl, int off, int regHandle){
+                this.off = off;
+                this.sl = sl;
+                this.regHandle = regHandle;
+            }
+            public void free(){
+                if(regHandle >= 0){
+                    freeRegister(regHandle);
+                    regHandle = -1;
+                }
+            }
+        }
+        
+        private Object getVar(Identifier id){
+            SymbolInfo info = sym.get(id.name);
+            if(info instanceof StackVarInfo)
+                return getStackVar((StackVarInfo)info);
+            else
+                return ((GlobalVarInfo)info).getLabel();
+        }
+        
+        private StackVarRuntimeInfo getStackVar(StackVarInfo info){
+        		FuncInfo varFuncInfo = info.getFuncInfo();
+        		System.out.println("var name: " + info.getVarName());
+        		System.out.println("varfuncInfo name: " + varFuncInfo.getFuncName());
+        		System.out.println("var idx: " + varFuncInfo.getVarIndex(info.getVarName()));
+        		
+            int tmpHandle = getRegister();
+            Register tmp = registerPool[tmpHandle];
+                
+        		if (funcInfo != null && funcInfo != info.getFuncInfo()) {                 
+                int varFunDepth = varFuncInfo.getDepth();
+                int callerDepth = funcInfo.getDepth();
+                int jumps = callerDepth - varFunDepth;
+                System.out.println("varFunDepth: " + varFunDepth);
+        		    System.out.println("callerDepth: " + callerDepth);
 
+                
+                backend.emitMV(tmp, FP, "Load FP");
+                
+                FuncInfo curr = funcInfo;
+                for (int i = 0; i < jumps; i++) {
+                		backend.emitLW(tmp, tmp, curr.getParams().size()*wordSize, "Load static link from " + curr.getFuncName() + " to " + curr.getParentFuncInfo().getBaseName());
+                		curr = curr.getParentFuncInfo();
+                }
+                
+                System.out.println("We are referencing non local variable");
+        		} else {
+        			System.out.println("We are referencing local variable");
+        			backend.emitMV(tmp, FP, "We are referencing local variable");
+        		}
+        		
+        		int idx = varFuncInfo.getVarIndex(info.getVarName());
+        		int paramSize = varFuncInfo.getParams().size();
+        		int offset = getLocalVarLocationOffset(idx, paramSize);
+        		return new StackVarRuntimeInfo(tmp, offset, tmpHandle);
+        }
         
         @Override
         public Register analyze(AssignStmt node) 
         {
-            backend.emitLW(T6, FP, 0, "Inside AssignStmt: ");
-            Type t = node.value.getInferredType();
+        	System.out.println("Inside AssignStmt: ");
+            //backend.emitLW(T6, FP, 0, "Inside AssignStmt: ");
+            //Type t = node.value.getInferredType();
             // if(t.isSpecialType() || t.isListType())
-            {
+            //{
                 Register reg = node.value.dispatch(this);
                 if (reg == null)
                     reg = A0;
-                if (sym.getParent() == null) 
+                for(Expr target: node.targets)
                 {
-                    for(Expr target: node.targets)
+                    if(target instanceof Identifier)
                     {
-                        if(target instanceof Identifier)
-                        {
-                            GlobalVarInfo gvi=(GlobalVarInfo)sym.get(((Identifier)target).name);
-                            backend.emitSW(reg, gvi.getLabel(), Register.T0, "Assign global: "+gvi.getVarName()+"(using tmp register)");
-                        }
+                        Identifier targetID = (Identifier)target;
+                        Object var = getVar(targetID);
+                        if(var instanceof StackVarRuntimeInfo){
+                            StackVarRuntimeInfo rtinfo = (StackVarRuntimeInfo) var;
+                            backend.emitSW(reg, rtinfo.sl, rtinfo.off ,"Store local variable: "+((Identifier)target).name);
+                            rtinfo.free();
+                        } 
                         else
-                        {
-                            Register ret = target.dispatch(this);
-                            backend.emitSW(T1, ret, 0, "Set list element"); 
-                        }
+                            backend.emitSW(reg, (Label)var, T0, "Store Global variable: " + ((Identifier)targetID).name);
                     }
-                }
-                else
-                {
-                    for(Expr target: node.targets)
+                    else
                     {
-                        StackVarInfo svi = (StackVarInfo) sym.get(((Identifier)target).name);
-                        int loc = offsetMap.get(svi);
-                        backend.emitSW(reg, Register.FP, -loc*4, "Load local variable: "+svi.getVarName());
+                        backend.emitSW(reg, Register.FP, -sp_off*wordSize, "Store value to b stored");
+                        incSp(1);
+                        boolean old_lvalue = l_value;
+                        l_value = true;
+                        Register ret = target.dispatch(this);
+                        l_value = old_lvalue;
+                        sp_off--;
+                        Register tmp = reg;
+                        int tmpHandle = -1;
+                        if(ret.equals(reg))
+                        {
+                            tmpHandle = getRegister();
+                            tmp = registerPool[tmpHandle];
+                        }
+                        backend.emitLW(tmp, Register.FP, -sp_off*wordSize, "Load value to b stored");
+                        backend.emitSW(tmp, ret, 0, "Set list element"); 
+                        if(tmpHandle >= 0)
+                            freeRegister(tmpHandle);
                     }
                 }
-            }
-            return Register.A0;
+            //}
+            return null;
         }
         
         @Override
         public Register analyze(ExprStmt node) 
         {
-        		backend.emitLW(T6, FP, 0, "Inside ExprStmt: ");
+        	System.out.println("Inside ExprStmt: ");
+        	//    backend.emitLW(T6, FP, 0, "Inside ExprStmt: ");
             node.expr.dispatch(this);
             return null;
         }
@@ -415,13 +595,21 @@ public class CodeGenImpl extends CodeGenBase
         @Override
         public Register analyze(IfExpr node) 
         {
+        	System.out.println("Inside IfExpr: ");
             Register result = node.condition.dispatch(this);
             Label ln = generateLocalLabel();
-            backend.emitBEQZ(result, ln,"Jump to beginning of loop");
-            node.thenExpr.dispatch(this);
+            elseBlock.push(generateLocalLabel());
+
+            backend.emitBEQZ(result, elseBlock.peek(),"Jump to end of loop");
+            result = node.thenExpr.dispatch(this);
+            if(result != A0)
+                backend.emitMV(A0, result, "move result");
             backend.emitJ(ln, "Jump to end of if expression");
-            backend.emitLocalLabel(elseBlock, "Else part of if expression");
-            node.elseExpr.dispatch(this);
+            backend.emitLocalLabel(elseBlock.peek(), "Else part of if expression");
+            result = node.elseExpr.dispatch(this);
+            if(result != A0)
+                backend.emitMV(A0, result, "move result");
+            elseBlock.pop();
             backend.emitLocalLabel(ln, "End of if expression");
             return A0;
         }
@@ -429,94 +617,38 @@ public class CodeGenImpl extends CodeGenBase
         @Override
         public Register analyze(IfStmt node) 
         {
+        	System.out.println("Inside IfStmt: ");
             Register result = node.condition.dispatch(this);
+
             Label ln = generateLocalLabel();
-            backend.emitBEQZ(result, ln,"Jump to beginning of loop");
+            elseBlock.push(generateLocalLabel());
+            backend.emitBEQZ(result, elseBlock.peek(),"Jump to end of loop");
             for(Stmt s:node.thenBody)
                 s.dispatch(this);
             backend.emitJ(ln, "Jump to end of if statement");
-            backend.emitLocalLabel(elseBlock, "Else part of if statement");
+            backend.emitLocalLabel(elseBlock.peek(), "Else part of if statement");
             for(Stmt s:node.elseBody)
                 s.dispatch(this);
+            elseBlock.pop();
             backend.emitLocalLabel(ln, "End of if statement");
             return null;
         }
-        public void copyList(Register dest, Register src, Register size) {
-            Label begin = generateLocalLabel();
-            Label exit = generateLocalLabel();
-            backend.emitLocalLabel(begin, "Start loop for copying");
-            backend.emitBEQ(size, Register.ZERO, exit, "Exit when copy completes");
-            backend.emitLW(Register.A2, src, 0, "Load Word from Source");
-            backend.emitSW(Register.A2, dest, 0, "Store Word in Destination");
-            backend.emitADDI(src, src, wordSize, "Increment Source Address");
-            backend.emitADDI(dest, dest, wordSize, "Increment Destination Address");
-            backend.emitADDI(size, size, -1, "Decrement size left to copy");
-            backend.emitJ(begin, "Jump to beginning of loop");
-            backend.emitLocalLabel(exit,"Exit loop for copying");
-        }
-        private Register addLists() {
-            // Check for Null operands
-            Label label = generateLocalLabel();
-            backend.emitBNEZ(Register.A0, label, "Left operand is NULL");
-            backend.emitBNEZ(Register.T0, label, "Right operand is NULL");
-            backend.emitJAL(errorNone, "Operand is Null");
-            backend.emitLocalLabel(label, "List Addition");
-
-            //Get lengths of the two lists
-            backend.emitLW(Register.T1, Register.A0,0,"Load length of first list");
-            backend.emitLW(Register.T2, Register.T0,0,"Load length of second list");
-            backend.emitADD(Register.A1, Register.T2,Register.T1,"Add lengths of lists");
-            backend.emitMV(Register.T3,Register.A1,"Store total length combined list");
-            backend.emitADDI(Register.A1, Register.A1,1,"Add 1 to store length of new list");
-            
-            //Store address and length of lists on stack
-            backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Store address of first list");
-            sp_off++;
-            backend.emitSW(Register.T0, Register.FP, -sp_off*wordSize, "Store address of second list");
-            sp_off++;
-            backend.emitSW(Register.T3, Register.FP, -sp_off*wordSize, "Store length of combined list");
-            sp_off++;
-            
-            //Allocate space on heap
-            backend.emitLA(Register.A0, listClass.getPrototypeLabel(), "Load empty list");
-            backend.emitJAL(objectAllocResizeLabel, "Allocate list");
-            backend.emitMV(Register.A1, Register.A0, "Store address of allocated space");
-            backend.emitMV(Register.T5, Register.A1, "Make a copy of address of allocated space");
-            
-            //Pop length and address from stack
-            sp_off--;
-            backend.emitLW(Register.T3, Register.FP, -sp_off*wordSize, "Load length of combined list");
-            sp_off--;
-            backend.emitLW(Register.T0, Register.FP, -sp_off*wordSize, "Load address of second list");
-            sp_off--;
-            backend.emitLW(Register.A0, Register.FP, -sp_off*wordSize, "Load address of first list");
-            
-            backend.emitLW(Register.T1, Register.A0,0,"Load length of first list");
-            backend.emitLW(Register.T2, Register.T0,0,"Load length of second list");
-            
-            //Copy each list in newly allocated space
-            backend.emitSW(Register.T3,Register.T5,0,"Store length of combined list ");
-            backend.emitADDI(Register.T5,Register.T5,wordSize,"Increment address");
-            backend.emitADDI(Register.A0,Register.A0,wordSize,"Increment address");
-            copyList(Register.T5, Register.A0, Register.T1);
-            backend.emitADDI(Register.T0,Register.T0,wordSize,"Increment address");
-            copyList(Register.T5, Register.T0, Register.T2);
-            
-            backend.emitMV(Register.A0,Register.A1,"Load address of combined list");
-            return Register.A0;
-        }
+        
         @Override
         public Register analyze(BinaryExpr node) 
         {
+        	System.out.println("Inside BinaryExpr: ");
             String operator = node.operator;
-            backend.emitLW(T6, FP, 0, "Inside BinaryExpr: ");
+            //backend.emitLW(T6, FP, 0, "Inside BinaryExpr: ");
 
             if(node.left.getInferredType().equals(Type.INT_TYPE) && node.right.getInferredType().equals(Type.INT_TYPE))
             {
-                node.right.dispatch(this);
-                backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
-                sp_off++;
-                node.left.dispatch(this);
+                Register r = node.right.dispatch(this);
+                backend.emitSW(r, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
+                incSp(1);
+                Register l = node.left.dispatch(this);
+                if(l != A0)
+                    backend.emitMV(A0, l, "mv l to A0");
                 sp_off--;
                 backend.emitLW(Register.T0, Register.FP, -sp_off*wordSize, "Pop stack slot "+sp_off);
             
@@ -568,13 +700,14 @@ public class CodeGenImpl extends CodeGenBase
                     else if(operator.equals(">="))
                     {
                         backend.emitADDI(Register.A0,Register.A0, 1, "Increment by 1");
-                        backend.emitSLT(Register.A0, Register.A0, Register.T0, comment);
-                    }   
+                        backend.emitSLT(Register.A0, T0, A0, comment);
+                    }
+                    /* Maybe NA 
                     else if(operator.equals("is"))
                     {
                         backend.emitXOR(Register.A0,  Register.A0, Register.T0, comment);
                         backend.emitSEQZ(Register.A0,  Register.A0, "Result is True if XOR equals 0");
-                    }
+                    }*/
                     else
                     {
                         backend.emitJAL(errorNI, "Operator not implemented for integer operands");
@@ -585,12 +718,11 @@ public class CodeGenImpl extends CodeGenBase
             {
                 
                 // Comparison operators
-                String comment="Operator: "+operator;
                 if(operator.equals("=="))
                 {
                     node.right.dispatch(this);
                     backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
-                    sp_off++;
+                    incSp(1);
                     node.left.dispatch(this);
                     sp_off--;
                     backend.emitLW(Register.T0, Register.FP, -sp_off*wordSize, "Pop stack slot "+sp_off);
@@ -601,7 +733,7 @@ public class CodeGenImpl extends CodeGenBase
                 {
                     node.right.dispatch(this);
                     backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
-                    sp_off++;
+                    incSp(1);
                     node.left.dispatch(this);
                     sp_off--;
                     backend.emitLW(Register.T0, Register.FP, -sp_off*wordSize, "Pop stack slot "+sp_off);
@@ -613,7 +745,7 @@ public class CodeGenImpl extends CodeGenBase
                     Label label = generateLocalLabel();
                     node.left.dispatch(this);
                     backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
-                    sp_off++;
+                    incSp(1);
                     backend.emitBEQZ(Register.A0, label, "If first operand is false, don't check second");
                     node.right.dispatch(this);
                     sp_off--;
@@ -626,19 +758,20 @@ public class CodeGenImpl extends CodeGenBase
                     Label label = generateLocalLabel();
                     node.left.dispatch(this);
                     backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
-                    sp_off++;
+                    incSp(1);
                     backend.emitBNEZ(Register.A0, label, "If first operand is true, don't check second");
                     node.right.dispatch(this);
                     sp_off--;
                     backend.emitLW(Register.T0, Register.FP, -sp_off*wordSize, "Pop stack slot "+sp_off);
                     backend.emitOR(Register.A0, Register.A0, Register.T0, "OR operation");
                     backend.emitLocalLabel(label, "Next step after OR");
-                }   
+                }
+                /*Maybe NA
                 else if(operator.equals("is"))
                 {
                     backend.emitXOR(Register.A0,  Register.A0, Register.T0, comment);
                     backend.emitSEQZ(Register.A0,  Register.A0, "Result is True if XOR equals 0");
-                }
+                }*/
                 else
                 {
                     backend.emitJAL(errorNI, "Operator not implemented for boolean operands");
@@ -646,18 +779,69 @@ public class CodeGenImpl extends CodeGenBase
             }
             else if(node.left.getInferredType().isListType() && node.right.getInferredType().isListType())
             {
-                node.right.dispatch(this);
-                backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
-                sp_off++;
-                node.left.dispatch(this);
-                sp_off--;
-                backend.emitLW(Register.T0, Register.FP, -sp_off*wordSize, "Pop stack slot "+sp_off);
                 if(operator.equals("+"))
-                    addLists();
+                {
+                    node.left.dispatch(this);
+                    backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push left operand on stack slot "+sp_off);
+                    incSp(1);
+                    node.right.dispatch(this);
+                    backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push right operand on stack slot "+sp_off);
+                    incSp(1);
+                    backend.emitADDI(Register.SP,Register.FP,-(sp_off-1)*wordSize,"Set SP to last argument");
+                    backend.emitJAL(concatLabel, "Call concatenation routine");
+                    backend.emitADDI(Register.SP, Register.FP, "-"+size_label, "Set SP to stack frame");
+                    return Register.A0;
+                    //addLists();
+                }
+                else
+                    backend.emitJAL(errorNI, "Operator not implemented for list operands");
+                 
             }
             else if(node.left.getInferredType().equals(Type.STR_TYPE) && node.right.getInferredType().equals(Type.STR_TYPE))
             {
-                
+                if(operator.equals("=="))
+                {
+                incSp(2);
+                backend.emitSW(node.left.dispatch(this), FP, (1 - sp_off) *wordSize, "Push argument 0 from last.");
+                backend.emitSW(node.right.dispatch(this), FP, ( - sp_off) *wordSize, "Push argument 1 from last.");
+                backend.emitADDI(SP, FP, -sp_off * wordSize, "Set SP to last argument.");
+                backend.emitJAL(streqlLabel, "Invoke method:streql");
+                sp_off -= 2;
+                backend.emitADDI(SP, FP, -sp_off*wordSize, "restore sp");
+                }
+                else if(operator.equals("!="))
+                {
+                incSp(2);
+                backend.emitSW(node.left.dispatch(this), FP, (1 - sp_off) *wordSize, "Push argument 0 from last.");
+                backend.emitSW(node.right.dispatch(this), FP, ( - sp_off) *wordSize, "Push argument 1 from last.");
+                backend.emitADDI(SP, FP, -sp_off * wordSize, "Set SP to last argument.");
+                backend.emitJAL(strneqlLabel, "Invoke method:strneql");
+                sp_off -= 2;
+                backend.emitADDI(SP, FP, -sp_off*wordSize, "restore sp");
+                }
+                else if(operator.equals("+"))
+                {
+                    incSp(2);
+                    backend.emitSW(node.left.dispatch(this), FP, (1 - sp_off) *wordSize, "Push argument 0 from last.");
+                    backend.emitSW(node.right.dispatch(this), FP, ( - sp_off) *wordSize, "Push argument 1 from last.");
+                    backend.emitADDI(SP, FP, -sp_off * wordSize, "Set SP to last argument.");
+                    backend.emitJAL(strcatLabel, "Invoke method:strcat");
+                    sp_off -= 2;
+                    backend.emitADDI(SP, FP, -sp_off*wordSize, "restore sp");
+                }
+                else
+                    backend.emitJAL(errorNI, "Operator not implemented for String operands");
+            }
+            else if(operator.equals("is"))
+            {
+                Register l = node.right.dispatch(this);
+                backend.emitSW(l, FP, -sp_off*wordSize, "Push on stack slot "+sp_off);
+                incSp(1);
+                Register r = node.left.dispatch(this);
+                sp_off--;
+                backend.emitLW(T0, FP, -sp_off*wordSize, "Pop stack slot "+sp_off);
+                backend.emitXOR(A0,  r, T0, "Operator: is");
+                backend.emitSEQZ(A0,  r, "Result is True if XOR equals 0");
             }
             else
             {
@@ -670,61 +854,45 @@ public class CodeGenImpl extends CodeGenBase
         public Register analyze(UnaryExpr node) 
         {
             if(node.operator.equals("-") && node.getInferredType().equals(Type.INT_TYPE))
-            {
-                node.operand.dispatch(this);    
-                backend.emitLI(Register.T0, -1, "Set value of Register T0 to -1");
-                backend.emitMUL(Register.A0, Register.A0, Register.T0, "Multiply by -1");
-            }
+                backend.emitSUB(A0, ZERO, node.operand.dispatch(this), "Unary negation");
             else if(node.operator.equals("not") && node.getInferredType().equals(Type.BOOL_TYPE))
-            {    
-                node.operand.dispatch(this);
-                backend.emitSEQZ(Register.T0, Register.A0, "Not operation on Register A0");
-            }
+                backend.emitSEQZ(A0, node.operand.dispatch(this), "Not operation on Register A0");
             else
-                return null;
-            return Register.A0;
+                backend.emitJAL(errorNI, "Operator not implemented");
+            return A0;
         }
-        
         @Override
         public Register analyze(Identifier node) 
         {
-        		backend.emitLW(T6, FP, 0, "Inside Identifier: ");
-            if (sym.getParent() == null) 
-            {
-                GlobalVarInfo gvi=(GlobalVarInfo) sym.get(node.name);
-                backend.emitLW(Register.A0, gvi.getLabel(), "Load global: "+gvi.getVarName());
-            }
-            else
-            {
-// FIXME: This breaks, so had to comment it
-//            	  VarInfo svi = (VarInfo) sym.get(node.name);
-//                int loc = offsetMap.get(svi);
-//                backend.emitLW(Register.A0, Register.FP, -loc*4, "Load local variable: "+svi.getVarName());
+        	//backend.emitLW(T6, FP, 0, "Inside Identifier: ");
+            System.out.println(node.getInferredType());
+            Identifier targetID = (Identifier)node;
+            Object var = getVar(targetID);
+            if(var instanceof StackVarRuntimeInfo){
+                StackVarRuntimeInfo rtinfo = (StackVarRuntimeInfo) var;
+                backend.emitLW(A0, rtinfo.sl, rtinfo.off,"Load local variable: "+node.name);
+                rtinfo.free();
             }
-            return null;
+            else 
+                backend.emitLW(A0, (Label) var, "Load local variable: "+node.name);
+
+            return Register.A0;
         }
         
-        @Override
-        public Register analyze(VarDef node) 
-        {
-            StackVarInfo svi = (StackVarInfo) sym.get(node.var.identifier.name);
-            node.value.dispatch(this);
-            backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Store variable "+node.var.identifier.name+" value in Stack");
-            offsetMap.put(svi, sp_off);
-            sp_off++;
-            return null;
-        }
-
+       
         @Override
         public Register analyze(WhileStmt node) 
         {
+        		System.out.println("Inside WhileStmt: ");	
             Label startLoop = generateLocalLabel(); 
             backend.emitLocalLabel(startLoop, "Beginning of while loop");
             Register result = node.condition.dispatch(this);
-            Label endLoop = elseBlock;
-            backend.emitBEQZ(result, endLoop,"Jump to beginning of loop");
-            for(Stmt stmt:node.body)
+            Label endLoop = generateLocalLabel();
+
+            backend.emitBEQZ(result, endLoop,"Jump to end of the loop");
+            for(Stmt stmt:node.body) 
                 stmt.dispatch(this);
+            
             backend.emitJ(startLoop, "Jump to beginning of loop");
             backend.emitLocalLabel(endLoop, "End of while loop");
             return null;
@@ -733,25 +901,33 @@ public class CodeGenImpl extends CodeGenBase
         @Override
         public Register analyze(ListExpr node) {
             int l = node.elements.size();
-            backend.emitLI(Register.A1, l+1, "Load length of list+1 in words");
-            backend.emitLA(Register.A0, listClass.getPrototypeLabel(), "Load empty list");
-            backend.emitJAL(objectAllocResizeLabel, "Allocate list");
-            backend.emitMV(Register.A1, Register.A0, "Store address of allocated space");
-            backend.emitMV(Register.T0, Register.A1, "Make a copy of address of allocated space");
-            
-            int i = l;
-            backend.emitLI(Register.A0,l,"Load length of list in words");
-            backend.emitSW(Register.A0,Register.T0,0,"Store length of list: "+i);
-            backend.emitADDI(Register.T0,Register.T0,wordSize,"Increment address");
-                
+            int i=l;
             for(Expr exp:node.elements)
             {
                 Register r = exp.dispatch(this);
-                backend.emitSW(r,Register.T0,0,"Store element "+i+" from last.");
-                backend.emitADDI(Register.T0,Register.T0,wordSize,"Increment address");
+                if (exp.getInferredType().equals(Type.INT_TYPE) && !node.elements.get(0).getInferredType().equals(Type.INT_TYPE))
+                {
+                    if(r!=Register.A0)
+                        backend.emitMV(r, Register.A0, "Copy to Register A0");
+                    backend.emitJAL(makeintLabel, "Box integer");
+                }
+                else if (exp.getInferredType().equals(Type.BOOL_TYPE) && !node.elements.get(0).getInferredType().equals(Type.BOOL_TYPE)) 
+                {
+                    if(r!=Register.A0)
+                        backend.emitMV(r, Register.A0, "Copy to Register A0");
+                    backend.emitJAL(makeboolLabel, "Box boolean");
+                }
+                backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push argument "+i+" from last");
+                incSp(1);
                 i--;
             }
-            backend.emitMV(Register.A0,Register.A1,"Load address of list");
+            backend.emitLI(Register.A0, l, "Pass list length");
+            backend.emitSW(Register.A0, Register.FP, -sp_off*wordSize, "Push length of list");
+            incSp(1);
+            backend.emitADDI(Register.SP, Register.FP, -(sp_off-1)*wordSize, "Set SP to last argument");
+            backend.emitJAL(conslistLabel, "Move values to new list object");
+            backend.emitADDI(Register.SP, Register.FP, "-"+size_label, "Set SP to stack frame");
+            sp_off-=l;
             return Register.A0;
         }
 
@@ -759,54 +935,219 @@ public class CodeGenImpl extends CodeGenBase
 
         @Override
         public Register analyze(IntegerLiteral node) {
-        		backend.emitLW(T6, FP, 0, "Inside IntegerLiteral: " + node.value);
+        		System.out.println("Inside IntegerLiteral: " + node.value);	
+        		//backend.emitLW(T6, FP, 0, "Inside IntegerLiteral: " + node.value);
         		backend.emitLI(A0, node.value, "Load integer literal " + node.value);
-        		backend.emitJAL(makeintLabel, "Box integer");
-//    			System.out.println("+++ Inside IntegerLiteral");
-//    			backend.emitLA(A0, new Label("$int$prototype"), "Load prototype");
-//    			backend.emitJAL(new Label("ra, alloc"), "");
-//    			backend.emitLI(T0, node.value, "Load integer " + node.value);
-//    			backend.emitSW(T0, A0, "@.__int__", null);
         		
             return A0;
         }
 
         
-         @Override
-         public Register analyze(ForStmt node) {
-            //System.out.println(node);
-            /*
-            node.
-            Label startLoop = generateLocalLabel(); 
-            backend.emitLocalLabel(startLoop, "Beginning of while loop");
-            node.condition.dispatch(this);
-            Label endLoop = elseBlock;
-            for(Stmt stmt:node.body)
-                stmt.dispatch(this);
-            backend.emitJ(startLoop, "Jump to beginning of loop");
-            backend.emitLocalLabel(endLoop, "End of while loop");*/
+        @Override
+        public Register analyze(ForStmt node) 
+        {
+            int r;
+            List<Integer> regs= new ArrayList<Integer>();
+            if (node.iterable.getInferredType().isListType()) 
+            {
+                Label startLoop = generateLocalLabel();
+                Label endLoop = generateLocalLabel();
+                Label temp = generateLocalLabel();
+                r=getRegister();
+                regs.add(r);
+                Register iden = registerPool[r];
+                node.iterable.dispatch(this);
+                r=getRegister();
+                regs.add(r);
+                Register l = registerPool[r];
+                r=getRegister();
+                regs.add(r);
+                Register ln = registerPool[r];
+                backend.emitBNEZ(Register.A0, temp, "Ensure not none");
+                backend.emitJ(errorNone, "Empty List");
+                backend.emitLocalLabel(temp, "Continue execution for for-loop");
+                backend.emitMV(l,Register.A0,"Location of list");
+                r=getRegister();
+                regs.add(r);
+                Register iter = registerPool[r];
+                backend.emitSW(l, Register.FP, -sp_off*wordSize, "Store location on stack");
+                incSp(1);
+                backend.emitMV(iter, Register.ZERO, "Initialize index variable");
+                backend.emitSW(iter, Register.FP, -sp_off*wordSize, "Store index on stack");
+                incSp(1);
+                backend.emitLocalLabel(startLoop, "Start for loop");
+                sp_off--;
+                backend.emitLW(iter, Register.FP, -sp_off*wordSize, "Load index from stack");
+                backend.emitLW(l, Register.FP, -(sp_off-1)*wordSize, "Store list location from stack");
+                backend.emitLW(ln, l, getAttrOffset(listClass, "__len__"), "Get attribute __len__");
+                backend.emitBGEU(iter, ln, endLoop, "Jump to end loop if counter exceeds length");
+                backend.emitADDI(iter, iter, 1, "Increment counter");
+                backend.emitSW(iter, Register.FP, -sp_off*wordSize, "Store index on stack");
+                incSp(1);
+                backend.emitADDI(iden, iter, 3, "Compute list element offset in words");
+                backend.emitLI(ln, wordSize, "Word size in bytes");
+                backend.emitMUL(iden, iden, ln, "Compute list element offset in bytes");
+                backend.emitADD(iden, l, iden, "Pointer to list element");
+                backend.emitLW(iden, iden, 0, "Set list element");
+                SymbolInfo info = sym.get(node.identifier.name);
+                if(info instanceof GlobalVarInfo)
+                {
+                    GlobalVarInfo gvi=(GlobalVarInfo) info;
+                    backend.emitSW(iden, gvi.getLabel(), Register.T0, "Assign global: "+node.identifier.name+"(using tmp register)");
+                }
+                else
+                {
+                    StackVarRuntimeInfo rtinfo = (StackVarRuntimeInfo) getVar(node.identifier);
+                    backend.emitSW(iden, rtinfo.sl, rtinfo.off,"Store local variable: "+node.identifier.name);
+                    rtinfo.free();
+                }
+                for(Stmt stmt:node.body)
+                    stmt.dispatch(this);
+                backend.emitJ(startLoop, "Jump to beginning of loop");
+                backend.emitLocalLabel(endLoop, "End of for loop");
+            }
+            else if (node.iterable.getInferredType().equals(Type.STR_TYPE))
+            {
+                Label startLoop = generateLocalLabel();
+                Label endLoop = generateLocalLabel();
+                //Label temp = generateLocalLabel();
+                r=getRegister();
+                regs.add(r);
+                Register iden = registerPool[r];
+                node.iterable.dispatch(this);
+                r=getRegister();
+                regs.add(r);
+                Register l = registerPool[r];
+                r=getRegister();
+                regs.add(r);
+                Register ln = registerPool[r];
+                backend.emitMV(l,Register.A0,"Location of String");
+                r=getRegister();
+                regs.add(r);
+                Register iter = registerPool[r];
+                backend.emitSW(l, Register.FP, -sp_off*wordSize, "Store location on stack");
+                incSp(1);
+                backend.emitMV(iter, Register.ZERO, "Initialize index variable");
+                backend.emitSW(iter, Register.FP, -sp_off*wordSize, "Store index on stack");
+                incSp(1);
+                //backend.emitADDI(Register.SP, Register.SP, -2*wordSize, "Set SP to last argument");
+                backend.emitLocalLabel(startLoop, "Start for loop");
+                backend.emitLW(iter, Register.FP, -(sp_off-1)*wordSize, "Load index from stack");
+                backend.emitLW(l, Register.FP, -(sp_off-2)*wordSize, "Load string location from stack");
+                backend.emitLW(ln, l, getAttrOffset(strClass, "__len__"), "Get attribute __len__");
+                backend.emitBGEU(iter, ln, endLoop, "Jump to end loop if counter exceeds length");
+                backend.emitADDI(iden, iter, 1, "Increment counter");
+                backend.emitSW(iden, Register.FP, -(sp_off-1)*wordSize, "Store index on stack");
+                backend.emitADDI(iden, iter, 4 * wordSize, "Convert index to offset to char in bytes");
+                backend.emitADD(iden, l, iden, "Get pointer to char");
+                backend.emitLBU(iden, iden, 0, "Load character");
+                backend.emitLI(iter, 20, "Load register");
+                backend.emitMUL(iden, iden, iter, "Multiply by size of String object");
+                backend.emitLA(l, allCharsLabel, "Index into single-char table");
+                backend.emitADD(l, l, iden, "Add size to chartable index");
+                SymbolInfo info = sym.get(node.identifier.name);
+                if(info instanceof GlobalVarInfo)
+                {
+                    GlobalVarInfo gvi=(GlobalVarInfo) info;
+                    backend.emitMV(Register.A0,l,"Copy value");
+                    backend.emitSW(Register.A0, gvi.getLabel(), Register.T0, "Assign global: "+node.identifier.name+"(using tmp register)");
+                }
+                else
+                {
+                    StackVarRuntimeInfo rtinfo = (StackVarRuntimeInfo) getVar(node.identifier);
+                    backend.emitSW(l, rtinfo.sl, rtinfo.off,"Store local variable: "+node.identifier.name);
+                    rtinfo.free();
+                }
+                for(Stmt stmt:node.body)
+                    stmt.dispatch(this);
+                backend.emitJ(startLoop, "Jump to beginning of loop");
+                backend.emitLocalLabel(endLoop, "End of for loop");
+            } 
+            else
+            {
+                System.out.println("Iterable not a list or a string");
+            }
+            for(int n:regs)
+                freeRegister(n);
             return null;
             
-         }
+        }
          
-            @Override
-            public Register analyze(IndexExpr node) 
+        @Override
+        public Register analyze(IndexExpr node) 
+        {
+            boolean old_lvalue = l_value;
+            l_value = false;
+            Register listObj = node.list.dispatch(this);
+            backend.emitSW(listObj, FP, -sp_off * wordSize, String.format("Push on stack slot %d", sp_off));
+            incSp(1);
+            
+            Register index = node.index.dispatch(this);
+            l_value = old_lvalue;
+            Register vacantReg = (index != A0) ? A0 : A1;
+            int tmpHandle = getRegister();
+            Register temp = registerPool[tmpHandle];
+
+            if (node.list.getInferredType().isListType()) 
             {
-		//TODO: Not Implemented
-		return A0;
+                backend.emitLW(vacantReg, FP, -(sp_off-1) * wordSize, String.format("Pop stack slot %d", sp_off-1));
+                final Label bp = generateLocalLabel();
+                backend.emitBNEZ(vacantReg, bp, "Ensure not None");
+                backend.emitJ(errorNone, "Go to error handler");
+                backend.emitLocalLabel(bp, "Not None");
+                final Label bt = generateLocalLabel();
+                backend.emitLW(temp, vacantReg, getAttrOffset(listClass, "__len__"), "Load attribute: __len__");
+                backend.emitBLTU(index, temp, bt, "Ensure 0 <= index < len");
+                backend.emitJ(errorOob, "Go to error handler");
+                backend.emitLocalLabel(bt, "Index within bounds");
+                backend.emitADDI(index, index, 4, "Compute list element offset in words");
+                backend.emitLI(temp, wordSize, "Word size in bytes");
+                backend.emitMUL(index, index, temp, "Compute list element offset in bytes");
+                backend.emitADD(vacantReg, vacantReg, index, "Pointer to list element");
+                if(l_value)
+                    backend.emitMV(A0,vacantReg,"Copy Result");
+                else 
+                    backend.emitLW(A0, vacantReg, 0, "Load list element"); 
+            } 
+            else 
+            {
+                backend.emitLW(vacantReg, FP, - (sp_off-1) * wordSize, String.format("Peek stack slot %d", sp_off-  1));
+                Label boundchk = generateLocalLabel();
+                backend.emitLW(temp, vacantReg, getAttrOffset(strClass, "__len__"), "Load attribute: __len__");
+                backend.emitBLTU(index, temp, boundchk, "Ensure 0 <= idx < len");
+                backend.emitJ(errorOob, "Go to error handler");
+                backend.emitLocalLabel(boundchk, "Index within bounds");
+                backend.emitADDI(T0, vacantReg, 4 * wordSize, "Convert index to offset to char in bytes");
+                backend.emitADD(T0, T0, index, "load char loc");
+                backend.emitLBU(T0, T0, 0, "Load character");
+                backend.emitSLLI(A0, T0, 2, "A0 = T0 * 4");
+                backend.emitSLLI(T0, T0, 4, "T0 = T0 * 16");
+                backend.emitADD(T0, T0, A0, "  T0*20 = offset to all chars");
+                backend.emitLA(A0, allCharsLabel, "All chars");
+                backend.emitADD(A0, A0, T0, "get the char");
             }
+            freeRegister(tmpHandle);
+            -- sp_off;
+            return A0;
+        }
   
         public Register analyze(MemberExpr node) 
         {
             ClassInfo objectClass = (ClassInfo) globalSymbols.get(node.object.getInferredType().className());
             Label label = generateLocalLabel();
+            boolean old_lvalue = l_value;
+            l_value = false;
             Register obj = node.object.dispatch(this);
+            l_value = old_lvalue;
 
             backend.emitBNEZ(obj, label, "Ensure not None");
             backend.emitJ(errorNone, "Go to error handler");
             backend.emitLocalLabel(label, "Not None");
-            backend.emitLW(A0, obj, getAttrOffset(objectClass, node.member.name),
-                 String.format("Get attribute: %s.%s",  objectClass.getClassName(), node.member.name));
+            if(l_value)
+                backend.emitADDI(A0, obj, getAttrOffset(objectClass, node.member.name), "get address of attr");
+            else
+                backend.emitLW(A0, obj, getAttrOffset(objectClass, node.member.name),
+                 String.format("Get value of attribute: %s.%s",  objectClass.getClassName(), node.member.name));
             return A0;
         }
     }
@@ -830,7 +1171,6 @@ public class CodeGenImpl extends CodeGenBase
      * to out-of-bounds error and abort");
      */
     protected void emitCustomCode() {
-        
         emitStdFunc("concat");
         emitStdFunc("conslist");
         emitStdFunc("strcat");
@@ -838,17 +1178,26 @@ public class CodeGenImpl extends CodeGenBase
         emitStdFunc("strneql");
         emitStdFunc("makeint");
         emitStdFunc("makebool");
+        emitStdFunc("initchars");
+        emitStdFunc("allChars");
 
         emitErrorFunc(errorNone, "Operation on None");
         emitErrorFunc(errorDiv, "Division by zero");
         emitErrorFunc(errorOob, "Index out of bounds");
-        // emitErrorFunc(errorNI, "Not Implemented.");
+        emitErrorFunc(errorNI, "Not Implemented.");
     }
 
     /** Emit an error routine labeled ERRLABEL that aborts with message MSG. */
     private void emitErrorFunc(Label errLabel, String msg) {
         backend.emitGlobalLabel(errLabel);
-        backend.emitLI(A0, ERROR_NONE, "Exit code for: " + msg);
+        if(errLabel==errorOob)
+            backend.emitLI(A0, ERROR_OOB, "Exit code for: " + msg);
+        else if(errLabel==errorDiv)
+            backend.emitLI(A0, ERROR_DIV_ZERO, "Exit code for: " + msg);
+        else if(errLabel==errorNI)
+            backend.emitLI(A0, ERROR_NYI, "Exit code for: " + msg);    
+        else    
+            backend.emitLI(A0, ERROR_NONE, "Exit code for: " + msg);
         backend.emitLA(A1, constants.getStrConstant(msg), "Load error message as str");
         backend.emitADDI(
                 A1, A1, getAttrOffset(strClass, "__str__"), "Load address of attribute __str__");
diff --git a/test_sample.sh b/test_sample.sh
new file mode 100755
index 0000000..b6da460
--- /dev/null
+++ b/test_sample.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+
+echo "Running all test cases inside src/test/data/pa3/sample/ folder)"
+java -cp "chocopy-ref.jar:target/assignment.jar" chocopy.ChocoPy --pass=rrs --test --run --dir src/test/data/pa3/sample/  --maxCycles 65536