diff --git a/Makefile b/Makefile
index 6a8e88d..794b839 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,8 @@ CC := gcc
 FLEX := flex
 BISON = bison
 
-CFLAGS := -ggdb
+CFLAGS := -ggdb -g -O0 #-fsanitize=address
+# LDFLAGS := -fsanitize=address
 BISONFLAGS := -d -Wcounterexamples
 
 LEX := src/lexicalStructure.lex
@@ -24,7 +25,7 @@ TESTS-S4 := $(wildcard tests/sprint4/test/*.alpha)
 all: compiler
 
 compiler: clean tmp $(OBJS)
-	$(CC) $(CFLAGS) -o $(EXE) $(OBJS)
+	$(CC) $(CFLAGS) -o $(EXE) $(OBJS) $(LDFLAGS)
 
 clean:
 	rm -f $(EXE)
diff --git a/src/codegen.c b/src/codegen.c
index 8e63df4..09c6af2 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -46,7 +46,7 @@ int generate(){
             break;
         case E_IF_X_TRUE:
             generateIfTrue(i);
-            break;    
+            break;
         case E_IF_X_FALSE:
             generateIfFalse(i);
             break;
@@ -118,7 +118,7 @@ CGNode *findCG(TableNode *tn) {
 CGNode *addCG(TableNode *tn, int sp) {
     CGNode *cg = calloc(1, sizeof(CGNode));
     cg->tn = tn;
-    offset += 4; // <- quick fix   getPrimSize(getTypeEntry(tn)) 
+    offset += getPrimSize(getTypeEntry(tn));
     cg->address = offset;
     cg->next = cgList;
     cgList = cg;
@@ -139,7 +139,7 @@ int generateAdd(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("generateAdd failed, NULL operand");
         return -1;
@@ -148,8 +148,8 @@ int generateAdd(Instruction *inst) {
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
-    
+
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op1));
     if (op1CG == NULL) {
@@ -177,7 +177,7 @@ int generateSub(Instruction *instruction) {
     TNodeOrConst *op1 = getOperand1(instruction);
     TNodeOrConst *op2 = getOperand2(instruction);
     CGNode *cg = findCG(getResult(instruction));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("generateSub failed, NULL operand");
         return -1;
@@ -186,7 +186,7 @@ int generateSub(Instruction *instruction) {
     if (cg == NULL) {
         cg = addCG(getResult(instruction), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -214,7 +214,7 @@ int generateMult(Instruction *inst){
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("generateMult failed, NULL operand");
         return -1;
@@ -250,7 +250,7 @@ int generateDiv(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("generateDiv failed, NULL operand");
         return -1;
@@ -259,7 +259,7 @@ int generateDiv(Instruction *inst) {
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -275,7 +275,7 @@ int generateDiv(Instruction *inst) {
     fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#division start\n", getAddress(op1CG)); //moves dividend into eax
     fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
     fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack
-    fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#division end\n", getAddress(cg)); //stores result 
+    fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#division end\n", getAddress(cg)); //stores result
     return 0;
 }
 
@@ -288,7 +288,7 @@ int generateMod(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("generateMod failed, NULL operand");
         return -1;
@@ -303,12 +303,12 @@ int generateMod(Instruction *inst) {
         printdebug("generateMod failed, op1 is not constant but not in CGlist");
         return -1;
     }
-    
+
     if (op2CG == NULL) {
         printdebug("generateMod failed, %s is not initialized/in CG", getName(getTN(op2)));
         return -1;
     }
-    
+
     fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#mod start\n", getAddress(op1CG)); //moves dividend into eax
     fprintf(cg_flag, "\tcltd\n"); //sign extends the dividend in eax
     fprintf(cg_flag, "\tidivl\t%d(%%rbp)\n", getAddress(op2CG));//divides edx by value accessed from stack
@@ -325,7 +325,7 @@ int generateOr(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("generateOr failed, NULL operand");
         return -1;
@@ -334,7 +334,7 @@ int generateOr(Instruction *inst) {
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -349,22 +349,22 @@ int generateOr(Instruction *inst) {
 
     int label = label_gen();
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start or\n", getAddress(op1CG)); 
+    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start or\n", getAddress(op1CG));
     fprintf(cg_flag, "\tjne\t.L%dor2\n", label);
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG)); 
+    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG));
     fprintf(cg_flag, "\tje\t.L%dor3\n", label);
 
     fprintf(cg_flag, ".L%dor2:\n", label);
-    fprintf(cg_flag, "\tmovl\t$1, %%eax\n"); 
+    fprintf(cg_flag, "\tmovl\t$1, %%eax\n");
     fprintf(cg_flag, "\tjmp\t.L%dor4\n", label);
-    
+
     fprintf(cg_flag, ".L%dor3:\n", label);
-    fprintf(cg_flag, "\tmovl\t$0, %%eax\n"); 
-    
+    fprintf(cg_flag, "\tmovl\t$0, %%eax\n");
+
     fprintf(cg_flag, ".L%dor4:\n", label);
     fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg));
-    fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#or end\n", getAddress(cg)); //stores result 
+    fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#or end\n", getAddress(cg)); //stores result
     return 0;
 }
 
@@ -377,7 +377,7 @@ int generateAnd(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("%sgenerateAnd failed, NULL operand", COLOR_RED);
         return -1;
@@ -386,7 +386,7 @@ int generateAnd(Instruction *inst) {
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -400,27 +400,27 @@ int generateAnd(Instruction *inst) {
     }
      int label = label_gen();
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG)); 
+    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG));
     fprintf(cg_flag, "\tje\t.L%dor2\n", label);
 
-    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG)); 
+    fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\n", getAddress(op2CG));
     fprintf(cg_flag, "\tje\t.L%dor2\n", label);
 
-    fprintf(cg_flag, "\tmovl\t$1, %%eax\n"); 
+    fprintf(cg_flag, "\tmovl\t$1, %%eax\n");
     fprintf(cg_flag, "\tjmp\t.L%dor3\n", label);
 
     fprintf(cg_flag, ".L%dor2:\n", label);
-    fprintf(cg_flag, "\tmovl\t$0, %%eax\n"); 
-    
+    fprintf(cg_flag, "\tmovl\t$0, %%eax\n");
+
     fprintf(cg_flag, ".L%dor3:\n", label);
     fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\n", getAddress(cg));
-    fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#and end\n", getAddress(cg)); //stores result 
+    fprintf(cg_flag, "\tandb\t$1, %d(%%rbp)\t#and end\n", getAddress(cg)); //stores result
     return 0;
 }
 int generateNeg(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL) {
         printdebug("generateNeg failed, NULL operand");
         return -1;
@@ -429,14 +429,14 @@ int generateNeg(Instruction *inst) {
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     if (op1CG == NULL) {
         printdebug("generateNeg failed, op1 is not constant but not in CGlist");
         return -1;
     }
 
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#negation start\n", getAddress(op1CG)); 
+    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#negation start\n", getAddress(op1CG));
     fprintf(cg_flag, "\tnegl\t%%eax\n");
     fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#negation end\n", getAddress(cg));
     return 0;
@@ -444,7 +444,7 @@ int generateNeg(Instruction *inst) {
 int generateNot(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL) {
         printdebug("generateNot failed, NULL operand");
         return -1;
@@ -453,7 +453,7 @@ int generateNot(Instruction *inst) {
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     if (op1CG == NULL) {
         printdebug("generateNot failed, op1 is not constant but not in CGlist");
@@ -474,7 +474,7 @@ int generateAssign(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     CGNode *cg = findCG(getResult(inst));
 
-    
+
     if (op1 == NULL) {
         printdebug("generateAssign failed, NULL operand");
         return -1;
@@ -490,14 +490,14 @@ int generateAssign(Instruction *inst) {
         fprintf(cg_flag, "\tmovl\t$%d, %d(%%rbp)\t#constant assign\n", getConst(op1), getAddress(cg));
         return 0;
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     if (op1CG == NULL) {
         printdebug("generateAssign failed, op1 is not constant but not in CGlist");
         return -1;
     }
-    
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#assign start\n", getAddress(op1CG)); 
+
+    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#assign start\n", getAddress(op1CG));
     fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#assign end\n", getAddress(cg));
     return 0;
 }
@@ -528,7 +528,7 @@ int generateLessThan(Instruction *inst){
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("%sgenerateLessThan failed, NULL operand", COLOR_RED);
         return -1;
@@ -537,7 +537,7 @@ int generateLessThan(Instruction *inst){
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -550,7 +550,7 @@ int generateLessThan(Instruction *inst){
         return -1;
     }
 
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#less than start\n", getAddress(op1CG)); 
+    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#less than start\n", getAddress(op1CG));
     fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG));
     fprintf(cg_flag, "\tsetl\t%%al\n");
     fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#less than end\n", getAddress(cg));
@@ -566,7 +566,7 @@ int generateEqualTo(Instruction *inst){
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     CGNode *cg = findCG(getResult(inst));
-    
+
     if (op1 == NULL || op2 == NULL) {
         printdebug("%sgenerateLessThan failed, NULL operand", COLOR_RED);
         return -1;
@@ -575,7 +575,7 @@ int generateEqualTo(Instruction *inst){
     if (cg == NULL) {
         cg = addCG(getResult(inst), offset);
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -588,7 +588,7 @@ int generateEqualTo(Instruction *inst){
         return -1;
     }
 
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#equal to start\n", getAddress(op1CG)); 
+    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#equal to start\n", getAddress(op1CG));
     fprintf(cg_flag, "\tcmpl\t%d(%%rbp), %%eax\n", getAddress(op2CG));
     fprintf(cg_flag, "\tsete\t%%al\n");
     fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#equal to end\n", getAddress(cg));
@@ -614,4 +614,4 @@ int generateAddressOf(Instruction *instruction){
 int generateParam(Instruction *instruction){
     //need to check if op1 is null, then add it to the appropriate register/cg node. need a way to keep track of this, maybe just have global count of params generated
     return -1;
-}
\ No newline at end of file
+}
diff --git a/src/grammar.h b/src/grammar.h
index 055d1b4..5e1276b 100644
--- a/src/grammar.h
+++ b/src/grammar.h
@@ -31,4 +31,6 @@ int offset;
 int currentsp;
 CGNode *cgList;
 
-extern Stack* stack;
\ No newline at end of file
+Stack* stack;
+Stack* TrueList;
+Stack* FalseList;
diff --git a/src/grammar.y b/src/grammar.y
index 204898b..1b3b04a 100644
--- a/src/grammar.y
+++ b/src/grammar.y
@@ -123,7 +123,7 @@ prototype_or_definition_list:
 
 prototype:
         L_PAREN EXTERNAL R_PAREN FUNCTION ID COLON ID
-    
+
     ;
 
 
@@ -131,40 +131,29 @@ prototype:
 definition:
         TYPE ID COLON
         {
-
             printdebug("Currently see a record definition for %s", $2);
             tn = CreateEntry(getAncestor(cur),TYPE_RECORD_TYPE, recprime, $2, CreateRecordInfo(0, cur = CreateScope(cur, 0, 0)));
             printdebug("Created a new scope");
-            //if (look_up(cur, $2) == undefined) {
-            //    printdebug("rec not found");
-            //}
-        }
-        dblock
-        {
-            //We are scanning through the dblock scope to get the length of the dblock (num of elements) from getRecSize
-            //and then putting it in the entry that we created above.
+        } dblock {
             setRecSize(look_up(getParent(cur), $2), getRecSize(cur));
-            //putting in all the offsets
             setRecOffsetInfo(cur, look_up(getParent(cur),$2));
             printdebug("Moving up a scope after seeing a record definition");
             cur = getParent(cur);
         }
 
-    |   TYPE ID COLON C_INTEGER ARROW id_or_types 
+    |   TYPE ID COLON C_INTEGER ARROW id_or_types
         {
-            printdebug("Currently see a array definition of name %s,storing type %s, of dimensions %d", $2, getName((TableNode*)$6), $4); 
+            printdebug("Currently see a array definition of name %s,storing type %s, of dimensions %d", $2, getName((TableNode*)$6), $4);
             CreateEntry(cur,TYPE_ARRAY_TYPE, arrayprim, $2, CreateArrayInfo($4, (TableNode*)$6));
             printdebug("%sID: %s, dimensions: %d, typeOfArray: %s", COLOR_GREEN, $2, $4, getName((TableNode*)$6));
         }
-    
     |   function_declaration
-    
     |   TYPE ID COLON id_or_types ARROW id_or_types
         {
             printdebug("Currently see a function type definition of name %s,parameter type %s, of return type %s", $2, getName((TableNode*)$4), getName((TableNode*)$6));
             CreateEntry(cur,TYPE_FUNCTION_TYPE,funtypeprime,$2,CreateFunctionTypeInfo((TableNode*)$4 ,(TableNode*)$6));
-        }  
-    
+        }
+
     | ID {
         emit_function_start(table_lookup(cur,$1));
         //printf("ID: %s\n", $1);
@@ -175,11 +164,11 @@ definition:
             printdebug("Undefined node declared.");
         }else if(getAdInfoType(node) != TYPE_FUNCTION_DECLARATION){
             throw_error(ERROR_SYNTAX, "Not a valid function declaration.");
-        }  
+        }
         else {
             printdebug("setting as keyword to true");
             setStartLine(node, @1.first_line);
-            setAsKeyword(node, true); 
+            setAsKeyword(node, true);
         }
         cur = CreateScope(cur, 0, 0);
         printdebug("Created a new scope");
@@ -195,10 +184,10 @@ definition:
             || type_of_param_type == TYPE_FUNCTION_DECLARATION
             || type_of_param_type == TYPE_ARRAY
             || type_of_param_type == TYPE_PRIMITIVE
-            || type_of_param_type == TYPE_ALL_ELSE 
+            || type_of_param_type == TYPE_ALL_ELSE
             || type_of_param_type == TYPE_SYSTEM_DEFINED
             || type_of_param_type == TYPE_RECORD
-            || type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused 
+            || type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused
             throw_error(ERROR_TYPE, "Invalid type (%s) of parameter in function definition.", getAdInfo(parameter));
             type_of_param_type = TYPE_UNDEFINED; // setting tag as undefined in these cases
             }
@@ -230,10 +219,10 @@ definition:
                     || type_of_param_type == TYPE_FUNCTION_TYPE
                     || type_of_param_type == TYPE_ARRAY_TYPE
                     || type_of_param_type == TYPE_PRIMITIVE_TYPE
-                    || type_of_param_type == TYPE_ALL_ELSE 
+                    || type_of_param_type == TYPE_ALL_ELSE
                     || type_of_param_type == TYPE_SYSTEM_DEFINED
                     || type_of_param_type == TYPE_RECORD_TYPE
-                    || type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused 
+                    || type_of_param_type == TYPE_STRING){ // note that strings are actually arrays so this is unused
                     throw_error(ERROR_TYPE, "Invalid type (%s) of parameter in function definition.", getAdInfo(entry));
                     type_of_param_type = TYPE_UNDEFINED; // setting tag as undefined in these cases
                 }else{
@@ -259,6 +248,7 @@ definition:
                     if(type_of_param_type == TYPE_PRIMITIVE){
                         printdebug("primitive type of parameter inside record");
                     CreateEntry(cur, TYPE_PRIMITIVE, getTypeEntry(entry),NULL, getAdInfo(entry));
+
                         //throw_error(ERROR_TYPE, "Duplicate defination of parameter in function definition.");}
                     }
                     if(type_of_param_type == TYPE_RECORD){
@@ -266,6 +256,7 @@ definition:
                     CreateEntry(cur, TYPE_RECORD, getTypeEntry(entry),NULL, getAdInfo(entry));
                         //throw_error(ERROR_TYPE, "Duplicate defination of parameter in function definition.");}
                     }          
+
                             /*printdebug("creating entry of type %s for function", getType(entry));
                             CreateEntry(cur, getTypeEntry(entry), "undefined", NULL);*/
                 }
@@ -289,13 +280,13 @@ definition:
             }
         //printf("Ending ID: %s\n", $1);
         //printf("Ending Type: %s\n", getType(table_lookup(getAncestor(cur), $1)));
-        }
+}
 
     ;
 
 function_declaration:
         FUNCTION ID COLON ID
-        {   
+        {
             if(getAdInfoType(table_lookup(cur, $4))==TYPE_FUNCTION_TYPE){
             //printf("%s\n",$2);
             //printf("%s\n",getName(table_lookup(cur, $4)));
@@ -309,7 +300,7 @@ function_declaration:
         }
 
     |   EXTERNAL FUNCTION ID COLON ID
-        {   
+        {
             if(getAdInfoType(look_up(cur, $5))==TYPE_FUNCTION_TYPE){
             CreateEntry(cur,TYPE_FUNCTION_DECLARATION, look_up(cur, $5), $3, CreateFunctionDeclarationInfo(-1, false));
         }
@@ -357,7 +348,7 @@ idlist:
         {
             $$ = $4 + 1;
         }
-    
+
     |   ID
         {   printdebug("idlist rule 2 ID: %s", $1);
             TableNode *entry = getFirstEntry(cur);
@@ -379,13 +370,14 @@ idlist:
             printdebug("Type of entry is %s", getType(entry));
             printdebug("tag is %d", getAdInfoType(entry));
         }
-    
+
     ;
 
 
 sblock:
         L_BRACE
         {
+                // emit_label(label_gen());
             if (getLine(cur) != 0) {
                 cur = CreateScope(cur,@1.first_line,@1.first_column);
                 printdebug("Created a new scope");
@@ -402,7 +394,7 @@ sblock:
         }
         R_BRACE
         {$$ = $3;}
-        
+
     |   L_BRACE
         {
             if (getLine(cur) != 0) {
@@ -423,87 +415,95 @@ sblock:
             printdebug("Moving up a scope after seeing sblock with dblock");
             cur = getParent(cur);
             //$<tn>$ = $5;
-            
-        } 
+
+        }
         R_BRACE
         {$$ = $5;}
-    
+
     ;
 
 
 
 dblock:
 
-        L_BRACKET 
+        L_BRACKET
         {
             if (getLine(cur) == 0) {
-                setLineNumber(cur, @1.first_line); 
+                setLineNumber(cur, @1.first_line);
                 setColumnNumber(cur,@1.first_line);
                 printdebug("Did not create a new scope when saw dblock, set line number to %d instead", @1.first_line);
             } else{
                 //cur = CreateScope(cur,@1.first_line,@1.first_column); // <----- What is this?
                 printdebug("Created a new scope when seeing a dblock");
             }
-        } 
+        }
         declaration_list R_BRACKET
 
-    
+
     ;
 
 
 
 declaration_list:
-        declaration SEMI_COLON declaration_list
-    |   declaration
+      declaration SEMI_COLON declaration_list
+    | declaration
     | error SEMI_COLON { yyerrok; } declaration_list //only perform error recovery once we see semi-colon
-    
+
     ;
 
 
 
 declaration:
-        id_or_types COLON ID 
+        id_or_types COLON ID
         {
             printdebug("ID/TYPE: %s,  ID: %s", getName((TableNode*)$1), $3) ;
             int d = getAdInfoType((TableNode*)$1);
             if(d == TYPE_UNDEFINED) {
                 throw_error(ERROR_TYPE, "Undefined type passed in declaration list");
                 printdebug("Undefined type passed in declaration list");
-                CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)); 
+                CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1));
             }
             else if(d == TYPE_FUNCTION_TYPE) {
                 printdebug("invalid (function) type passed in declaration list in dblock", @2.first_line, @2.first_column);
                 d = TYPE_FUNCTION_DECLARATION;
+
                 if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){
                     throw_error(ERROR_TYPE, "Duplicate defination of function in declaration list");
                 } 
+
             }
             else if(d == TYPE_ARRAY_TYPE){
                 printdebug("array variable at line %d and column %d", @2.first_line, @2.first_column);
                 d = TYPE_ARRAY;
+
                 if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){
                     throw_error(ERROR_TYPE, "Duplicate defination of array in declaration list");
                 }
+
             }
             else if(d == TYPE_RECORD_TYPE){
                 printdebug("record variable at line %d and column %d", @2.first_line, @2.first_column);
                 d = TYPE_RECORD;
+
                 if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1))== undefined){
                     throw_error(ERROR_TYPE, "Duplicate defination of record in declaration list");
                 }
+
             }
             else if(d == TYPE_PRIMITIVE_TYPE){
                 printdebug("primitive variable at line %d and column %d", @2.first_line, @2.first_column);
                 d = TYPE_PRIMITIVE;
+
                 if(CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)) == undefined){
                     throw_error(ERROR_TYPE, "Duplicate defination of primitive in declaration list");
                 }
+
             }else {
                 throw_error(ERROR_TYPE, "%s is being defined with an undefined type", $3);
-                CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1)); 
+                CreateEntry(cur,d,(TableNode*)$1,$3,getAdInfo((TableNode*)$1));
             }
         }
-    
+
     ;
 
 
@@ -514,13 +514,13 @@ id_or_types:
             printdebug("string of id is %s in ID pattern of id_or_type rule.", $1);
             $$ = table_lookup(getAncestor(cur), $1);
         }
-    
+
     |   types
         {
             printdebug("string of type is %s in types pattern of id_or_type rule.",getName((TableNode*)$1));
             $$ = (TableNode*)$1;
         }
-    
+
     ;
 
 
@@ -548,7 +548,7 @@ compound_statement statement_list {
 }
         |   compound_statement {
             $$ = $1;
-        } 
+        }
         |   simple_statement SEMI_COLON statement_list{
             if ($1 == undefined && $3 != undefined) {
                 $$ = $3;
@@ -579,24 +579,55 @@ compound_statement statement_list {
 
 
 compound_statement:
-WHILE L_PAREN expression R_PAREN sblock {
-    $$ = $5;
-}
-    |   IF L_PAREN expression R_PAREN THEN sblock ELSE sblock {
-            if ($6 == undefined && $8 != undefined) {
+        WHILE L_PAREN {
+                S_Push(TrueList, S_Init(), 0);
+                S_Push(FalseList, S_Init(), 0);
+                int *l = calloc(1, sizeof(int));
+                *l = label_gen();
+                emit_label(*l);
+                S_Push(stack, l, 2);
+        } expression R_PAREN {
+                emit_label(label_gen());
+                emit_backpatch(S_Pop(TrueList), getLabel(current));
+        } sblock {
+                $$ = $7;
+                int l = label_gen();
+                emit_backpatch(S_Pop(FalseList), l);
+                emit_goto(*(int*)(S_Pop(stack)));
+                emit_label(l);
+        }
+    |   IF L_PAREN {
+                S_Push(TrueList, S_Init(), 0);
+                S_Push(FalseList, S_Init(), 0);
+        }expression R_PAREN THEN {
+                emit_label(label_gen());
+                emit_backpatch(S_Pop(TrueList), getLabel(current));
+        } sblock ELSE {
+                // NOTE we are not going back to
+                int l = label_gen();
+                emit_backpatch(S_Pop(FalseList), l);
+                S_Push(FalseList, S_Init(), 0);
+                emit_goto(0);
+                S_Push(S_Peek(FalseList), current, 1);
+                emit_label(l);
+        } sblock {
+                int l = label_gen();
+                emit_backpatch(S_Pop(FalseList), l);
+                emit_label(l);
+            if ($8 == undefined && $11 != undefined) {
+                $$ = $11;
+            } else if ($8 != undefined && $11 == undefined) {
                 $$ = $8;
-            } else if ($6 != undefined && $8 == undefined) {
-                $$ = $6;
-            } else if ($6 == $8) {
-                $$ = $6;
-            }else if((getAdInfoType((TableNode*)$6) == TYPE_ARRAY_TYPE) && ((TableNode*)$8)==addr){
-                $$ = $6;
-            }else if((getAdInfoType((TableNode*)$6) == TYPE_RECORD_TYPE) && ((TableNode*)$8)==addr){
-                $$ = $6;
-            }else if(((TableNode*)$6)==addr && (getAdInfoType((TableNode*)$8) == TYPE_ARRAY_TYPE)){
+            } else if ($8 == $11) {
                 $$ = $8;
-            }else if(((TableNode*)$6)==addr && (getAdInfoType((TableNode*)$8) == TYPE_RECORD_TYPE)){
+            }else if((getAdInfoType((TableNode*)$8) == TYPE_ARRAY_TYPE) && ((TableNode*)$11)==addr){
                 $$ = $8;
+            }else if((getAdInfoType((TableNode*)$8) == TYPE_RECORD_TYPE) && ((TableNode*)$11)==addr){
+                $$ = $8;
+            }else if(((TableNode*)$8)==addr && (getAdInfoType((TableNode*)$11) == TYPE_ARRAY_TYPE)){
+                $$ = $11;
+            }else if(((TableNode*)$8)==addr && (getAdInfoType((TableNode*)$11) == TYPE_RECORD_TYPE)){
+                $$ = $11;
             } else {
                 printdebug("3 differing return types within same function at line %d, column %d", @1.first_line, @1.first_column);
                 //printf("%s\n", getName((TableNode*)$6));
@@ -604,7 +635,7 @@ WHILE L_PAREN expression R_PAREN sblock {
                 $$ = undefined;
             }
         }
-    
+
     |   sblock {
             $$ = $1;
         }
@@ -614,14 +645,14 @@ WHILE L_PAREN expression R_PAREN sblock {
 
 
 simple_statement:
-        assignable ASSIGN expression 
-         {  printdebug("simple statement");   
+        assignable ASSIGN expression
+         {  printdebug("simple statement");
             TableNode* node;
             if((getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_FUNCTION_TYPE)||
                 (getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_ARRAY_TYPE)||
                 (getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_RECORD_TYPE)||
                 (getAdInfoType((getTypeEntry((TableNode*)$1))) == TYPE_PRIMITIVE_TYPE)){
-            
+
                 node = ((TableNode*)$1);
             } else {
                 //printf("%d\n",getAdInfoType((getTypeEntry((TableNode*)$1))));
@@ -643,8 +674,8 @@ simple_statement:
                 emit_assignment($1, tn_or_const(NODE, $3));
                 printdebug("%s[☺] Passed type check; %s = %s", COLOR_GREEN, getType(node), getType((TableNode*)$3));
             }
-            
-            
+
+
             else {
                 //printf("%d\n",getAdInfoType((TableNode*)$1));
                 //printf("%d\n",getAdInfoType((TableNode*)$3));
@@ -660,9 +691,9 @@ simple_statement:
     |   RETURN expression {
             $$ = getTypeEntry((TableNode*)$2);
             emit_return(tn_or_const(NODE,(TableNode*)$2));}
-    |simple_statement error {yyerrok; printdebug("error in simple statement");}
+    |simple_statement error {yyerrok; yyclearin; printdebug("error in simple statement");}
+
 
-    
     ;
 
 
@@ -670,49 +701,61 @@ simple_statement:
 rec_op:
         DOT
 
-    
+
     ;
 
 
 ablock:
-        L_PAREN argument_list R_PAREN
+        L_PAREN{
+            if (stack == NULL){
+                    stack = S_Init();
+            }
+            Stack * t = S_Init();
+            S_Push(stack, t, 0);
+        }
+        argument_list {
+        } R_PAREN
         {
-            $$ = $2;
+// here
+            $$ = $3;
             printdebug("ablock is %d", $$);
         }
 
-    
+
     ;
 
 
 
 argument_list:
-        //NEED TO EMIT PARAMETERS HERE. MAYBE USE STACK STRUCTURE
         expression{
-            char* name = arg_var_gen();
-            TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), name, NULL);
-            emit_parameter(tn_or_const(NODE,arg));
-            //S_Push(stack,current);
-            //emit_detach();
-            //printdebug("[ARGUMENT_LIST] argument list is %d", $$);
+            TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), arg_var_gen(), NULL);
+// ----------------------------------------------------------------------------
+            // this is emitting the param withthe wrong TableNode
+            // We need to fiture out how to get the right one.
+            Stack * t = S_Peek(stack);
+                if(t==NULL){
+                        t = S_Init();
+                        S_Push(stack, t, 1);
+                }
+            emit_parameter(tn_or_const(NODE,$1));
+            S_Push(t, current, 1);
+            emit_detach();
+// ----------------------------------------------------------------------------
         }
          COMMA argument_list
          {$$ = $4 + 1;}
 
     |   expression
 
-        {   
-            char* name = arg_var_gen();
-            TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), name, NULL);
-            emit_parameter(tn_or_const(NODE,arg));
-            //S_Push(stack,current);
-            //emit_detach();
+        {
+            TableNode* arg = CreateEntry(cur, getAdInfoType((TableNode*)$1), getTypeEntry((TableNode*)$1), arg_var_gen(), NULL);
+            emit_parameter(tn_or_const(NODE,$1));
             $$ = 1;
             printdebug("[ARGUMENT_LIST] argument list is %d", $$);
         }
 
 
-    
+
     ;
 
 
@@ -855,14 +898,27 @@ expression:
                 throw_error(ERROR_TYPE, "Object %s of type %s and Object %s of type %s must both be Boolean", getName((TableNode*)$1), getType((TableNode*)$1), getName((TableNode*)$3), getType((TableNode*)$3));
             }
         }
-                    
-    |   expression LESS_THAN expression 
+
+    |   expression LESS_THAN expression
 		{
+                emit_conditional_jump(E_LESS_THAN, 0, tn_or_const(NODE,$1), tn_or_const(NODE,$3));
+                Stack * t = S_Peek(TrueList);
+                if(t==NULL){
+                        t = S_Init();
+                        S_Push(TrueList, t, 1);
+                }
+                S_Push(t, current, 1);
+                emit_goto(0);
+                t = S_Peek(FalseList);
+                if(t==NULL){
+                        t = S_Init();
+                        S_Push(FalseList, t, 1);
+                }
+                S_Push(t, current, 1);
             printdebug("less than expression");
             if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==integ) {
                 char* temp = temp_var_gen();
                 TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
-                emit_binary_op(E_LESS_THAN,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
                 $$ = node;
             } else if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1)==boo){
                 char* temp = temp_var_gen();
@@ -881,9 +937,22 @@ expression:
             if(getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3) && getTypeEntry((TableNode*)$1) != undefined) {
                 char* temp = temp_var_gen();
                 TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
-                emit_binary_op(E_EQUAL_TO,node,tn_or_const(NODE,$1),tn_or_const(NODE,$3));
+                emit_conditional_jump(E_EQUAL_TO, 0, tn_or_const(NODE,$1), tn_or_const(NODE,$3));
+                Stack * t = S_Peek(TrueList);
+                if(t==NULL){
+                        t = S_Init();
+                        S_Push(TrueList, t, 1);
+                }
+                S_Push(t, current, 1);
+                emit_goto(0);
+                t = S_Peek(FalseList);
+                if(t==NULL){
+                        t = S_Init();
+                        S_Push(FalseList, t, 1);
+                }
+                S_Push(t, current, 1);
                 $$ = node;
-                
+
             } else {
                 $$ = undefined;
                 throw_error(ERROR_TYPE, "Object %s of type %s and Object %s of type %s must both be the same type", getName((TableNode*)$1), getType((TableNode*)$1), getName((TableNode*)$3), getType((TableNode*)$3));
@@ -894,15 +963,19 @@ expression:
         {
             $$ = $1;
         }
-    
+
     |   L_PAREN expression R_PAREN
         {
             printdebug("paren expression. current type is %s",getType((TableNode*)$2));
             $$=$2;
         }
 
-    |   RESERVE assignable
-        {   
+        // TODO: We need to type check this.
+    |   RESERVE ID {$$ = undefined; }
+    |   RELEASE ID {$$ = undefined; }
+    |   RESERVE ID L_PAREN argument_list R_PAREN {$$ = undefined; }
+    |   RELEASE ID L_PAREN argument_list R_PAREN
+        {
             int d = getAdInfoType((TableNode*)$2);
             //commenting out type checks for now since assignable is being resolved to something before reserve is being applied which is tricky
             //if(d == TYPE_ARRAY ||d == TYPE_RECORD) {
@@ -915,6 +988,7 @@ expression:
            //     $$=undefined;
            // }
         }
+/*
     |   RELEASE assignable
         {
             int d = getAdInfoType((TableNode*)$2);
@@ -929,7 +1003,8 @@ expression:
            //     $$=undefined;
            // }
         }
-    
+*/
+
     ;
 
 //UPDATED $$ for tablenodes to this point
@@ -938,17 +1013,16 @@ expression:
 // add array case
 // include type check for ablock in arrays - ablock is always the int of the elements in array/rec
 assignable:
-        ID 
+        ID
         {
             TableNode* pass = look_up(cur,$1);
             if(pass == undefined){
                 throw_error(ERROR_TYPE, "Undefined variable %s", $1);
             }
-            $$ = pass; 
+            $$ = pass;
             printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getType(pass), getName(pass));
         }
-
-    |   assignable 
+    |   assignable
         {
             printdebug("%sBeginning rule 2 of assignable.", COLOR_CYAN);
             //Creating a dummy scope where we create entries for all the arguments of a function call
@@ -956,13 +1030,13 @@ assignable:
             cur = CreateScope(cur, -1,-1);
         }
         //we have to consider emmissions in ablocks
-        ablock 
+        ablock
         {
             //int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1)));
             int type = getAdInfoType(getTypeEntry((TableNode*)$1));
             printdebug("%stype is %d", COLOR_PURPLE, type);
             printdebug("%s", getName((TableNode*)$1));
-              
+
             if (type == TYPE_FUNCTION_TYPE) {
                 printdebug("%sEntering function call", COLOR_LIGHTGREEN);
                 //getting the parameter. The type of assignable is a function type so we need to access the paramater of the type
@@ -1034,6 +1108,14 @@ assignable:
                     throw_error(ERROR_TYPE, "Undefined type returned by function.");
                 }
                 TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
+//-----------------------------------------------------------------------------
+                // Please don't touch
+                // the + 1 is here because I don't detach the last param
+                int a = S_Size(S_Peek(stack)) + 1;
+                emit_push_all(S_Peek(stack));
+                S_Pop(stack);
+                emit_function_call(node, a, tn_or_const(NODE, $1));
+//-----------------------------------------------------------------------------
                 $$ = node;
                 //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK for function call)
                 printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName(typeNode2), getName((TableNode*)$1));
@@ -1062,8 +1144,8 @@ assignable:
                     throw_error(ERROR_TYPE, "Undefined type stored in array.");
                 }
                 TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
-                //emit assign here
-                //emit_array_access(char* node, char* array, ...)
+                //TODO: emit assign here
+                //TODO: emit_array_access(char* node, char* array, ...)
                 $$ = node;
                 printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getType((TableNode*)$1), getName((TableNode*)$1));
             }
@@ -1086,8 +1168,8 @@ assignable:
         }
 
     |   assignable rec_op ID
-        {   
-            
+        {
+
             if(getAdInfoType((TableNode*)$1) != TYPE_RECORD){
                 throw_error(ERROR_TYPE, "Invalid type passed to record access");
                 $$ = undefined;
@@ -1115,16 +1197,16 @@ assignable:
 
                 TableNode* node = CreateEntry(cur,t, type, temp, NULL);
                 //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
-                //emit_field_access(char* node, char* record, $3)  
+                //emit_field_access(char* node, char* record, $3)
                 $$=node;
             }else{
                 throw_error(ERROR_TYPE, "Invalid field access %s", $3);
                 $$=undefined;
-            } 
+            }
             printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3));
         }
 
-    
+
     ;
 
 
@@ -1146,7 +1228,7 @@ constant:
             printdebug("number of C_INTEGER in constant is %d", $1);
             $$ = node;
         }
-    
+
     |   C_NULL
         {
             char* temp = temp_var_gen();
@@ -1155,7 +1237,7 @@ constant:
             printdebug("string of C_NULL in constant is NULL");
             $$ = node;
         }
-    
+
     |   C_CHARACTER
         {
             char* temp = temp_var_gen();
@@ -1164,7 +1246,7 @@ constant:
             printdebug("string of C_CHARACTER in constant is %s",$1);
             $$ = node;
         }
-    
+
     |   C_TRUE
         {
             char* temp = temp_var_gen();
@@ -1174,7 +1256,7 @@ constant:
             printdebug("string of C_TRUE in constant is true");
             $$ = node;
         }
-    
+
     |   C_FALSE
         {
             char* temp = temp_var_gen();
@@ -1189,25 +1271,25 @@ constant:
 
 
 
-types:	
+types:
         T_INTEGER
         {
             $$ = $1;
             printdebug("string of T_INTEGER in types is %s",getName((TableNode*)$1));
         }
-    
+
     |   T_ADDRESS
         {
             $$ = $1;
             printdebug("string of T_ADDRESS in types is %s",getName((TableNode*)$1));
         }
-    
+
     |   T_CHARACTER
         {
             $$ = $1;
             printdebug("string of T_CHARACTER in types is %s",getName((TableNode*)$1));
         }
-    
+
     |   T_BOOLEAN
         {
             $$ = $1;
@@ -1294,7 +1376,7 @@ void throw_error(ErrorType error_type, const char *format, ...) {
 void yyerror(const char *err) {
     int line = yylloc.first_line;
     int column = yylloc.first_column;
-    
+
     // Grammar Fallback Case
     if (strcmp(err, "syntax error") == 0) {
         if (asc_flag != NULL) {
diff --git a/src/intermediate_code.c b/src/intermediate_code.c
index aee5862..44c6016 100644
--- a/src/intermediate_code.c
+++ b/src/intermediate_code.c
@@ -15,16 +15,17 @@ void S_Free(Stack *s){
     free(s);
 }
 
-void S_Push(Stack * s, void *v) {
+void S_Push(Stack * s, void *v, int i) {
     __Node * n = calloc(1, sizeof(*n));
     n->v = v;
     n->next = s->n;
     s->n = n;
+    s->w = i;
     s->size = s->size + 1;
 }
 
 void * S_Pop(Stack *s) {
-    if (s->size == 0) {
+    if (s == NULL || S_IsEmpty(s)) {
             return NULL;
     }
     __Node * node = s->n;
@@ -37,22 +38,31 @@ void * S_Pop(Stack *s) {
 
 
 void * S_Peek(Stack *s){
-    if (!S_IsEmpty(s)) {
+    if (s == NULL || S_IsEmpty(s)) {
             return NULL;
     }
     return s->n->v;
 }
 
 bool S_IsEmpty(Stack *s){
-    if(!s->size) {
+    if(s == NULL || s->size == 0) {
             return true;
     }
     return false;
 }
 
 int S_Size(Stack *s){
+    if (s == NULL || S_IsEmpty(s)) {
+            return 0;
+    }
     return s->size;
 }
+
+void emit_backpatch(Stack * s, int l){
+        for (Instruction * i = S_Pop(s); i; i = S_Pop(s)){
+                i->label = l;
+        }
+}
 //_______________________________________________________________________
 
 char * temp = NULL;
@@ -64,11 +74,28 @@ char * temp = NULL;
         otherwise make it next of current and set cur to your instruction.
        */
 
+void emit_push_all(Stack * s){
+        for (Instruction * i = S_Pop(s); i; i = S_Pop(s)){
+                current->next = i;
+                i->prev = current;
+                i->index = current->index + 1;
+                current = i;
+                current->next = NULL;
+        }
+}
+
 void emit_detach(){
         current = current->prev;
         current->next = NULL;
 }
 
+void backpatch(Stack *s, int l){
+        while (!S_IsEmpty(s)){
+                Instruction * i = S_Pop(s);
+                set_label(i, l);
+        }
+}
+
 TNodeOrConst * getOperand1(Instruction * i){
         return i->operand1;
 }
@@ -155,6 +182,12 @@ void emit_binary_op(
         current->operand2 = arg2;
  }
 
+void emit_goto(int i){
+        emit_helper();
+        current->opcode = E_GOTO;
+        current->label = i;
+}
+
 void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){
         emit_helper();
         current->opcode = op;
@@ -250,8 +283,8 @@ void emit_function_call(
                 ){
         emit_helper();
         current->opcode = E_CALL;
-        current->operand1 = tn_or_const(INTEGER, &param_count);
-        current->operand2 = name;
+        current->operand1 = name;
+        current->operand2 = tn_or_const(INTEGER, &param_count);
         current->result = result;
 }
 
@@ -349,6 +382,11 @@ int label_gen(){
 }
 
 void emit_as_file(FILE * out_file, Instruction * i){
+        if (out_file == NULL){
+                fprintf(stderr, "Error: output file is NULL\n");
+                return;
+        }
+
         if(i == NULL){
                 return;
         }
@@ -463,7 +501,7 @@ void emit_as_file(FILE * out_file, Instruction * i){
                         break;
                 case E_IF_X_TRUE:
                         fprintf(out_file,
-                                "%4.d:  if %s goto %d\n",
+                                "%4.d:  if %s GOTO %d\n",
                                 i->index,
                                 get_string(i->operand1),
                                 i->label
@@ -471,7 +509,7 @@ void emit_as_file(FILE * out_file, Instruction * i){
                         break;
                 case E_IF_X_FALSE:
                         fprintf(out_file,
-                                "%4.d:  if %s false goto %d\n",
+                                "%4.d:  if %s false GOTO %d\n",
                                 i->index,
                                 get_string(i->operand1),
                                 i->label
@@ -480,21 +518,21 @@ void emit_as_file(FILE * out_file, Instruction * i){
                case E_LESS_THAN:
                         // this feels wrong I need to TODO: this
                         fprintf(out_file,
-                                "%4.d:  %s = %s < %s\n",
+                                "%4.d:  if ( %s < %s ) GOTO %d\n",
                                 i->index,
-                                getName(i->result),
                                 get_string(i->operand1),
-                                get_string(i->operand2)
+                                get_string(i->operand2),
+                                i->label
                                 );
                         break;
                 case E_EQUAL_TO:
                         // this feels wrong I need to TODO: this
                         fprintf(out_file,
-                                "%4.d:  %s = %s == %s\n",
+                                "%4.d:  if ( %s = %s ) GOTO %d\n",
                                 i->index,
-                                getName(i->result),
                                 get_string(i->operand1),
-                                get_string(i->operand2)
+                                get_string(i->operand2),
+                                i->label
                                 );
                         break;
                 case E_CALL:
diff --git a/src/intermediate_code.h b/src/intermediate_code.h
index 60b64a0..0906cb1 100644
--- a/src/intermediate_code.h
+++ b/src/intermediate_code.h
@@ -22,11 +22,12 @@ typedef struct __Node {
 
 typedef struct Stack {
         __Node * n;
+        int w;
         int size;
 } Stack;
 Stack * S_Init();
 void S_Free(Stack *s);
-void S_Push(Stack * s, void *v);
+void S_Push(Stack * s, void *v, int i);
 void * S_Pop(Stack *s);
 void * S_Peek(Stack *s);
 bool S_IsEmpty(Stack *s);
@@ -108,19 +109,20 @@ typedef struct TFList {
         TFList       * next;
 } TFList;
 
-TFList * make_list(Instruction * i);
+// TFList * make_list(Instruction * i);
   // - makelist(i) function to create instruction lists
-void merge(TFList * l1, TFList * l2);
+// void merge(TFList * l1, TFList * l2);
   // - merge(p1,p2) function to concatenate lists
-void backpatch(TFList * l, int label);
+// void backpatch(TFList * l, int label);
   // - backpatch(p,i) function to fill in jump targets
-void bp_temp(int n);
+// void bp_temp(int n);
 
 
 extern Instruction   * begin;
 extern Instruction   * current;
 extern int label_count;
 extern bool code_gen;
+extern FILE * ir_flag;
 
 
 TNodeOrConst * tn_or_const(Discriminant , void * );
@@ -142,6 +144,9 @@ void emit_release(TableNode * pointer);
 void emit_field_access(char* result, char* record, char* field);
 void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index);
 void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr);
+void emit_goto(int i);
+void emit_detach();
+void emit_push_all(Stack * s);
 
 
 int getLabel(Instruction * i);
@@ -159,3 +164,5 @@ int get_index(Instruction * i);
 void set_label(Instruction * i, int label);
 bool isConst(TNodeOrConst * tnc);
 int label_gen();
+void backpatch(Stack *s, int l);
+void emit_backpatch(Stack *s, int l);
diff --git a/src/runner.c b/src/runner.c
index c134dc4..09a080f 100644
--- a/src/runner.c
+++ b/src/runner.c
@@ -102,7 +102,7 @@ void print_tok(int tok) {
 int run(FILE *alpha) {
     int token;
     top = cur = init(CreateScope(NULL, 1, 1));
-    Stack *s = S_Init();
+
 
     // If file is not found
     if (alpha == NULL) {
@@ -127,6 +127,9 @@ int run(FILE *alpha) {
     fseek(alpha, 0, SEEK_SET);
 
     yyin = alpha;
+    stack = S_Init();
+    TrueList = S_Init();
+    FalseList = S_Init();
     yyparse();
 
     if (tok_flag != NULL) {
@@ -192,7 +195,7 @@ int new_file(char *arg, char *alpha) {
 
     mkdir("./out", 0777);
 
-    char *new_basename = calloc(strlen(basename) + 5, sizeof(char));
+    char *new_basename = calloc(strlen(basename) + 7, sizeof(char));
     strcpy(new_basename, "./out/");
     strcat(new_basename, basename);
     basename = new_basename;
@@ -335,4 +338,4 @@ char *file_read_line(FILE *fp) {
 
     str[len] = '\0';
     return str;
-}
\ No newline at end of file
+}
diff --git a/src/runner.h b/src/runner.h
index 9971eed..979c36b 100644
--- a/src/runner.h
+++ b/src/runner.h
@@ -70,6 +70,9 @@ TableNode *recprime;
 TableNode *funtypeprime;
 TableNode *undefined;
 extern Instruction *begin;
+extern Stack* stack;
+extern Stack* TrueList;
+extern Stack* FalseList;
 
 int main(int argc, char *argv[]);
 int check_flag(char *arg, char *alpha);
@@ -108,4 +111,4 @@ CodeLine *code_head;
 char *file_read_line(FILE *fp);
 void insert_code_line(char * error_message, int line_number);
 void append_code_line(CodeLine *code_line);
-void print_code_lines();
\ No newline at end of file
+void print_code_lines();
diff --git a/tests/carl/NoErrors/selectionSort.alpha b/tests/carl/NoErrors/selectionSort.alpha
index edd2076..24fb000 100644
--- a/tests/carl/NoErrors/selectionSort.alpha
+++ b/tests/carl/NoErrors/selectionSort.alpha
@@ -45,9 +45,9 @@ selectionSort(data) := {
         data(i) := temp;
         i := i + 1;
     }
-    return true; 
+    return true;
 }
- 
+
 
 (* Function definition
    entry is the first function called
diff --git a/tests/sprint1/test/sp1_simple_alpha.alpha b/tests/sprint1/test/sp1_simple_alpha.alpha
new file mode 100644
index 0000000..719384b
--- /dev/null
+++ b/tests/sprint1/test/sp1_simple_alpha.alpha
@@ -0,0 +1,6 @@
+type main: string -> integer
+function entry: main
+
+entry(arg) := {
+    return 0;
+}
\ No newline at end of file
diff --git a/tests/sprint2/test/sp2_llnode.alpha b/tests/sprint2/test/sp2_llnode.alpha
index 3ecfb11..c78687d 100644
--- a/tests/sprint2/test/sp2_llnode.alpha
+++ b/tests/sprint2/test/sp2_llnode.alpha
@@ -15,7 +15,6 @@ function make_list : list
 
 make_list (a) := {
     [integer:orig_a; llnode: ret; llnode: curr; llnode: temp]
-
     if (a < 0 | a = 0) then {
         return null;
     } else {
@@ -73,8 +72,8 @@ entry (arg) := {
     w := reserve w;
     w.x := 5;
     w.y := 7;
-    result := bar1(w);
+    (* result := bar1(w); *)
     result := bar2(5,7);
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/tests/sprint2/test/sp2_llnode_bad.alpha b/tests/sprint2/test/sp2_llnode_bad.alpha
new file mode 100644
index 0000000..4eab1ae
--- /dev/null
+++ b/tests/sprint2/test/sp2_llnode_bad.alpha
@@ -0,0 +1,80 @@
+type main: string -> integer
+function entry: main
+
+type rec: [integer: x; integer: y]
+type T1: integer -> integer
+type T2: rec -> integer
+
+type llnode: [llnode: prev; integer: val; llnode: next]
+type list: integer -> llnode
+
+function foo : T1
+function bar1 : T2
+function bar2 : T2
+function make_list : list
+
+make_list (a) := {
+    [integer:orig_a; llnode: ret; llnode: curr; llnode: temp]
+
+    if (a < 0 | a = 0) then {
+        return null;
+    } else {
+        ret := reserve ret;
+        ret.prev := null;
+        ret.next := null;
+        ret.val  := a;
+        while (0 < a) {
+            temp := reserve temp;
+            temp.prev := null;
+            temp.next := null;
+            temp.val  := ret.val;
+            if (a = orig_a) then {
+                ret.next := temp;
+                temp.prev := ret;
+                curr := temp;
+            } else {
+                curr.next := temp;
+                temp.prev := curr;
+                curr := temp;
+            }
+            a := a - 1;
+        }
+        return ret;
+    }
+}
+
+foo (x) := {
+    return x * x;
+}
+
+bar1(a,b) := {
+    return a * b;
+}
+
+bar2(r,s) := {
+    if (r < s) then {
+        while (!(r < s)) {
+            r := r + 1;
+        }
+    } else {
+        [integer: x]
+            x := 0;
+            while (x < 10) {
+                r := r + s;
+            }
+    }
+    return r * s;
+}
+
+entry (arg) := {
+    [ integer: result ; rec: w; llnode: li; boolean: b]
+    li := make_list(6, 7);
+    result := foo(5);
+    w := reserve w;
+    w.x := 5;
+    w.y := 7;
+    result := bar1(w);
+    result := bar2(5,7);
+
+    return 'a';
+}
diff --git a/tests/sprint3/test/sp3_if_else.alpha b/tests/sprint3/test/sp3_if_else.alpha
new file mode 100644
index 0000000..02c9525
--- /dev/null
+++ b/tests/sprint3/test/sp3_if_else.alpha
@@ -0,0 +1,25 @@
+type rec: [character: x; integer: y]
+
+type T2: rec -> integer
+
+type main: string -> integer
+function entry: main
+function bar: T2
+
+bar (r,s) := {
+    return 0;
+}
+
+entry (arg) := {
+ 	[ integer: result ; rec: w]
+        if ( result = result ) then {
+                 if ( result < w.y ) then {
+                        result := 8;
+                } else {
+                        result := 9;
+                }(*  *)
+        } else {
+                result :=  bar('c', 7);
+        }
+	return 0;
+}
diff --git a/tests/sprint3/test/sp3_if_while.alpha b/tests/sprint3/test/sp3_if_while.alpha
new file mode 100644
index 0000000..bb6a519
--- /dev/null
+++ b/tests/sprint3/test/sp3_if_while.alpha
@@ -0,0 +1,27 @@
+type rec: [character: x; integer: y]
+
+type T2: rec -> integer
+
+type main: string -> integer
+function entry: main
+function bar: T2
+
+bar (r,s) := {
+    return 0;
+}
+
+entry (arg) := {
+ 	[ integer: result ; rec: w]
+        while ( result = result ) {
+                result := result + 8;
+                if ( result < w.y ) then {
+                        while (true) {
+                                result := 8;
+                        }
+                } else {
+                        result := 9;
+                }
+                result := bar('c', 7);
+        }
+	return 0;
+}
diff --git a/tests/sprint3/test/sp3_multiple_args.alpha b/tests/sprint3/test/sp3_multiple_args.alpha
index 8475d92..f069230 100644
--- a/tests/sprint3/test/sp3_multiple_args.alpha
+++ b/tests/sprint3/test/sp3_multiple_args.alpha
@@ -12,7 +12,12 @@ bar (r,s) := {
 
 entry (arg) := {
  	[ integer: result ; rec: w]
-    result := bar(1,2);
+        while ( result = result ) {
+                while ( result < w.y ) {
+                        result := 8;
+                }
+                result := 9;
+        }
  	result := bar('c', 7);
 	return 0;
-}
\ No newline at end of file
+}