diff --git a/genx.sh b/genx.sh
index 3534a7d..8da7039 100755
--- a/genx.sh
+++ b/genx.sh
@@ -44,17 +44,57 @@ if [ ! -d "binaries" ]; then
     mkdir -p binaries
 fi
 
+
+appendStd() {
+    if [ ! -f "$1" ]; then
+        echo "File not found: $1"
+        return 1
+    fi
+
+    backup_file="${1}.bak"
+    cp "$1" "$backup_file"
+
+    temp_file=$(mktemp)
+
+    while IFS= read -r line || [ -n "$line" ]; do
+        echo "$line" >> "$temp_file"
+        if [[ $line =~ ^#include\ \"[^\"]+\" ]]; then
+            include_file=$(echo "$line" | sed -n 's/.*"\([^"]*\)".*/\1/p')
+            if [[ $include_file == "std.alpha" ]]; then
+                echo -e "${GREEN}[GenX] ${WHITE}Including ${BLUE}std.alpha${WHITE}..."
+                if [ -f "library/std.alpha" ]; then
+                    cat library/std.alpha >> "$temp_file"
+                else
+                    echo -e "${RED}[GenX] ${YELLOW}File library/std.alpha not found!${WHITE}"
+                    rm "$temp_file"
+                    return 1
+                fi
+            fi
+        fi
+    done < "$1"
+
+    mv "$temp_file" "$1"
+}
+
+
 if [ $# -eq 1 ]; then
     if [ -f "$1" ]; then
         if [[ "$1" == *.alpha ]]; then
+            appendStd "$1"
             ./alpha -cg "$1"
+            backup_file="${1}.bak"
+            if [ -f "$backup_file" ]; then
+                mv "$backup_file" "$1"
+                echo -e "${GREEN}[GenX] ${WHITE}Reverted $1 to its original state."
+            fi
+
             filename=$(basename -- "$1")
             filename="${filename:0:${#filename}-6}"
             s_name="out/${filename}.s"
-            echo -e "${GREEN}[GenX] ${WHITE}Generated .s file..."
+            echo -e "${GREEN}[GenX] ${WHITE}Generated .s file."
             gcc ${s_name} library/alpha_lib_reg.s library/alpha_driver.s -no-pie -o binaries/${filename}
             if [ $? -eq 0 ]; then
-                echo -e "${GREEN}[GenX] ${WHITE}Generated executable file..."
+                echo -e "${GREEN}[GenX] ${WHITE}Generated executable file."
                 echo -e "${GREEN}[GenX] ${WHITE}Executable file: binaries/${filename}"
                 echo -e "${GREEN}[GenX] ${WHITE}Done!"
             else
diff --git a/library/Makefile b/library/Makefile
deleted file mode 100644
index c02f4cd..0000000
--- a/library/Makefile
+++ /dev/null
@@ -1,61 +0,0 @@
-# Makefile to make executables from alpha source code files
-# and also make executables from some sample assembly files execising the alpha library
-#
-# Carl Alphonce
-# April 20, 2024
-
-# The alpha compiler and flags (adjust the flags as needed)
-AC := ./alpha
-AFLAGS := -tok -asc -tc -st -ir -cg
-
-# The preprocessor and flags (you should not adjust these)
-CPP := cpp
-CPPFLAGS := -P -x c
-
-# Adjust for the library your team is using (register-based or stack-based parameter passing)
-
-ALPHA_LIB = alpha_lib_reg.s   ## Register-based parameter passing
-#ALPHA_LIB = alpha_lib_st.s     ## Stack-based parameter passing
-
-# Adjust for the parameter passing approach your compiler uses:
-#   alpha_driver_reg.s for register-based parameter passing
-#   alpha_driver_st.s for stack-based parameter passing
-# This file provides a main function that packages up argv[1] (or "") as an alpha string
-# (type 1->character) and calls entry with that argument
-
-ALPHA_DRIVER = alpha_driver_reg.s   ## Register-based parameter passing
-#ALPHA_DRIVER = alpha_driver_st.s     ## Stack-based parameter passing
-
-
-# Create an assembly (.s) file from an alpha source file
-# This involves several steps:
-%.s : %.alpha
-	@mv $< $<._temporary_			# 1. rename input file so we can us it as 
-	@$(CPP) $(CPPFLAGS) $<._temporary_ > $< # 2. input to CPP, writing output to original filename
-	@$(AC) $(AFLAGS) $<			# 3. run the alpha compiler on the pre-processed file
-	@mv $<._temporary_ $<			# 4. restore the original input file
-
-
-
-# Examples of assembly code using the alpha library files
-# In these examples the calling code is in assembly, and defines main (so the driver is not included here)
-
-# Example #1: calling the printBoolean function
-printBoolean : printBoolean_reg.s
-	@gcc $< $(ALPHA_LIB) -no-pie -o $@
-
-# Example #2: calling the printInt function
-printInt : printInt_reg.s
-	@gcc $< $(ALPHA_LIB) -no-pie -o $@
-
-# Example #3: calling the reserve and release functions
-reserve_release : reserve_release_reg.s
-	@gcc $< $(ALPHA_LIB) -no-pie -o $@
-
-
-# The rule for assembling .s files and linking them together (using the gcc compiler driver)
-# to produce an executable (assuming no earlier make rule triggers first)
-
-% : %.s $(ALPHA_LIB) $(ALPHA_DRIVER) 
-	@gcc $< $(ALPHA_LIB) $(ALPHA_DRIVER) -no-pie -o $@
-
diff --git a/library/printBoolean_reg.s b/library/printBoolean_reg.s
deleted file mode 100644
index dd1eb84..0000000
--- a/library/printBoolean_reg.s
+++ /dev/null
@@ -1,26 +0,0 @@
-	.file	"printBoolean.c"
-	.text
-	.globl	main
-	.type	main, @function
-main:
-.LFB0:
-	pushq	%rbp
-	movq	%rsp, %rbp
-	
-	movb	$1, %dil	# the representation of 'true'
-	call	printBoolean
-	movb	$10, %dil
-	call	printCharacter
-
-	movb	$0, %dil	# the representation of 'false'
-	call	printBoolean
-	movb	$10, %dil
-	call	printCharacter
-
-	movl	$0, %eax
-	popq	%rbp
-	ret
-.LFE0:
-	.size	main, .-main
-	.ident	"GCC: (GNU) 6.4.0"
-	.section	.note.GNU-stack,"",@progbits
diff --git a/library/printInt_reg.s b/library/printInt_reg.s
deleted file mode 100644
index 512c576..0000000
--- a/library/printInt_reg.s
+++ /dev/null
@@ -1,22 +0,0 @@
-	.file	"printInt.c"
-	.text
-	.globl	main
-	.type	main, @function
-main:
-.LFB0:
-	pushq	%rbp
-	movq	%rsp, %rbp
-	
-	movl	$10, %edi	# Move the immediate value 10 to %edi 
-	call	printInteger	# call the alpha_lib function printInteger
-	
-	movl	$10, %edi	# Put the \n character (decimal 10) into %edi	 
-	call	printCharacter	# then call the alpha_lib function printCharacter
-	
-	movl	$0, %eax
-	popq	%rbp
-	ret
-.LFE0:
-	.size	main, .-main
-	.ident	"GCC: (GNU) 6.4.0"
-	.section	.note.GNU-stack,"",@progbits
diff --git a/library/reserve_release_reg.s b/library/reserve_release_reg.s
deleted file mode 100644
index 827436a..0000000
--- a/library/reserve_release_reg.s
+++ /dev/null
@@ -1,37 +0,0 @@
-	.file	"reserve_release.c"
-	.text
-	.globl	main
-	.type	main, @function
-main:
-.LFB0:
-	pushq	%rbp
-	movq	%rsp, %rbp
-	subq	$16, %rsp
-
-	movl	$8, %edi	# move sizeof(*a) into %edi
-	call	reserve		# call alpha_lib_reg function reserve
-
-	movq	%rax, -8(%rbp)	# put the returned pointer on the stack at offset -8
-
-	movq	-8(%rbp), %rax	# put base pointer of struct (a) into %rax 
-	movl	$20, (%rax)	# put value 20 into location pointed at by %rax --> (*a).x
-	movq	-8(%rbp), %rax	# put base pointer of struct (a) into %rax 
-	movl	$45, 4(%rax)	# put value 45 into location 4(%rax) --> (*a).y
-	movq	-8(%rbp), %rax	# put base pointer of struct (a) into %rax 
-	movl	4(%rax), %eax	# move (*a).y into %eax
-	movl	%eax, %edi	# and then into %edi
-	call	printInteger	# call alpha_lib_reg function printInteger
-	movl	$10, %edi	# move '\n' into %edi
-	call	printCharacter	# call alpha_lib_reg function printCharacter
-
-	movq	-8(%rbp), %rax	# put base pointer of struct (a) into %rax
-	movq	%rax, %rdi	# and then into %rdi
-	call	release		# call alpha_lib_reg function reserve
-
-	movl	$0, %eax
-	leave
-	ret
-.LFE0:
-	.size	main, .-main
-	.ident	"GCC: (GNU) 6.4.0"
-	.section	.note.GNU-stack,"",@progbits
diff --git a/library/std.alpha b/library/std.alpha
new file mode 100644
index 0000000..a2fc025
--- /dev/null
+++ b/library/std.alpha
@@ -0,0 +1,24 @@
+(* Standard Alpha Library - Provided by Carl *)
+
+type string: 1 -> character
+type BooleanXBoolean: [Boolean: x; Boolean: y]
+type characterXcharacter: [character: x; character: y]
+type integerXinteger: [integer: x; integer: y]
+
+type Boolean2Boolean: Boolean -> Boolean
+type integer2integer: integer -> integer
+type character2integer: character -> integer
+type Boolean2integer: Boolean -> integer
+type string2integer: string -> integer
+type integerXinteger2integer: integerXinteger -> integer
+type integerXinteger2Boolean: integerXinteger -> Boolean
+type characterXcharacter2Boolean: characterXcharacter -> Boolean
+type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
+type integer2address: integer -> address
+type address2integer: address -> integer
+
+external function printInteger: integer2integer
+external function printCharacter: character2integer
+external function printBoolean: Boolean2integer
+
+function entry: string2integer
diff --git a/src/codegen.c b/src/codegen.c
index 9512929..6da4ddf 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -3,87 +3,86 @@
 
 #include "codegen.h"
 
-int generate(){
+int generate() {
     offset = 0;
     currentsp = 0;
     Instruction *i = begin;
-    
+
     // temporary
     fprintf(cg_flag, ".globl entry\n");
 
     while (i != NULL) {
-        switch(getOp(i)) {
-        case E_LABEL:
-            generateLabel(i);
-            break;
-        case E_ADD:
-            generateAdd(i);
-            break;
-        case E_SUB:
-            generateSub(i);
-            break;
-        case E_MUL:
-            generateMult(i);
-            break;
-        case E_DIV:
-            generateDiv(i);
-            break;
-        case E_MOD:
-            generateMod(i);
-            break;
-        case E_OR:
-            generateOr(i);
-            break;
-        case E_AND:
-            generateAnd(i);
-            break;
-        case E_NEG:
-            generateNeg(i);
-            break;
-        case E_NOT:
-            generateNot(i);
-            break;
-        case E_ASSIGN:
-            generateAssign(i);
-            break;
-        case E_GOTO:
-            generateGoto(i);
-            break;
-        case E_IF_X_TRUE:
-            generateIfTrue(i);
-            break;
-        case E_IF_X_FALSE:
-            generateIfFalse(i);
-            break;
-        case E_LESS_THAN:
-            generateLessThan(i);
-            break;
-        case E_EQUAL_TO:
-            generateEqualTo(i);
-            break;
-        case E_CALL:
-            generateCall(i);
-            break;
-        case E_PARAM:
-            generateParam(i);
-            break;
-        case E_RETURN:
-            generateReturn(i);
-            break;
-        case E_INDEX_COPY_RIGHT:
-            generateCopyRight(i);
-            break;
-        case E_INDEX_COPY_LEFT:
-            generateCopyLeft(i);
-            break;
-        case E_ADDRESS_OF:
-            generateAddressOf(i);
-            break;
-        case E_FUNC_START:
-            generateFunctionStart(i);
-            break;
-        default:
-            ;
+        switch (getOp(i)) {
+            case E_LABEL:
+                generateLabel(i);
+                break;
+            case E_ADD:
+                generateAdd(i);
+                break;
+            case E_SUB:
+                generateSub(i);
+                break;
+            case E_MUL:
+                generateMult(i);
+                break;
+            case E_DIV:
+                generateDiv(i);
+                break;
+            case E_MOD:
+                generateMod(i);
+                break;
+            case E_OR:
+                generateOr(i);
+                break;
+            case E_AND:
+                generateAnd(i);
+                break;
+            case E_NEG:
+                generateNeg(i);
+                break;
+            case E_NOT:
+                generateNot(i);
+                break;
+            case E_ASSIGN:
+                generateAssign(i);
+                break;
+            case E_GOTO:
+                generateGoto(i);
+                break;
+            case E_IF_X_TRUE:
+                generateIfTrue(i);
+                break;
+            case E_IF_X_FALSE:
+                generateIfFalse(i);
+                break;
+            case E_LESS_THAN:
+                generateLessThan(i);
+                break;
+            case E_EQUAL_TO:
+                generateEqualTo(i);
+                break;
+            case E_CALL:
+                generateCall(i);
+                break;
+            case E_PARAM:
+                generateParam(i);
+                break;
+            case E_RETURN:
+                generateReturn(i);
+                break;
+            case E_INDEX_COPY_RIGHT:
+                generateCopyRight(i);
+                break;
+            case E_INDEX_COPY_LEFT:
+                generateCopyLeft(i);
+                break;
+            case E_ADDRESS_OF:
+                generateAddressOf(i);
+                break;
+            case E_FUNC_START:
+                generateFunctionStart(i);
+                break;
+            default:;
         }
         i = i->next;
     }
@@ -133,14 +132,13 @@ CGNode *addCG(TableNode *tn, int sp) {
     return cg;
 }
 
-
 int generateLabel(Instruction *inst) {
     if (inst == NULL) {
         return -1;
     }
 
     fprintf(cg_flag, ".L%d:\n", getLabel(inst));
-    
+
     return 0;
 }
 int generateAdd(Instruction *inst) {
@@ -162,7 +160,6 @@ int generateAdd(Instruction *inst) {
         cg = addCG(getResult(inst), offset);
     }
 
-
     CGNode *op1CG = findCG(getTN(op1));
     CGNode *op2CG = findCG(getTN(op2));
     if (op1CG == NULL) {
@@ -181,7 +178,7 @@ int generateAdd(Instruction *inst) {
 }
 
 int generateSub(Instruction *instruction) {
-        /*
+    /*
       Both immediate:
       One immediate:
       Neither immediate:
@@ -217,8 +214,8 @@ int generateSub(Instruction *instruction) {
     return 0;
 }
 
-int generateMult(Instruction *inst){
-            /*
+int generateMult(Instruction *inst) {
+    /*
       Both immediate:
       One immediate:
       Neither immediate:
@@ -254,7 +251,7 @@ int generateMult(Instruction *inst){
 }
 
 int generateDiv(Instruction *inst) {
-            /*
+    /*
       Both immediate:
       One immediate:
       Neither immediate:
@@ -284,10 +281,10 @@ int generateDiv(Instruction *inst) {
         return -1;
     }
 
-    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%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
     return 0;
 }
 
@@ -321,15 +318,15 @@ int generateMod(Instruction *inst) {
         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
-    fprintf(cg_flag, "\tmovl\t%%edx, %d(%%rbp)\t#mod end\n", getAddress(cg)); //stores result from edx (remainder)
+    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
+    fprintf(cg_flag, "\tmovl\t%%edx, %d(%%rbp)\t#mod end\n", getAddress(cg));       //stores result from edx (remainder)
     return 0;
 }
 
 int generateOr(Instruction *inst) {
-                /*
+    /*
       Both immediate:
       One immediate:
       Neither immediate:
@@ -376,7 +373,7 @@ int generateOr(Instruction *inst) {
 
     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;
 }
 
@@ -410,7 +407,7 @@ int generateAnd(Instruction *inst) {
         printdebug("generateAnd failed, %s is not initialized/in CG", getName(getTN(op2)));
         return -1;
     }
-     int label = label_gen();
+    int label = label_gen();
 
     fprintf(cg_flag, "\tcmpl\t$0, %d(%%rbp)\t#start and\n", getAddress(op1CG));
     fprintf(cg_flag, "\tje\t.L%dor2\n", label);
@@ -426,7 +423,7 @@ int generateAnd(Instruction *inst) {
 
     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) {
@@ -486,7 +483,6 @@ int generateAssign(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     CGNode *cg = findCG(getResult(inst));
 
-
     if (op1 == NULL) {
         printdebug("generateAssign failed, NULL operand");
         return -1;
@@ -514,7 +510,7 @@ int generateAssign(Instruction *inst) {
     return 0;
 }
 
-int generateGoto(Instruction *inst){
+int generateGoto(Instruction *inst) {
     return -1;
 }
 
@@ -522,17 +518,17 @@ int generateCondGoto(Instruction *inst) {
     return -1;
 }
 
-int generateIfTrue(Instruction *inst){
+int generateIfTrue(Instruction *inst) {
     return -1;
     // might just be a goto for where to go if something is true, or returning if something is true, or checking if true and writing goto if thats the case
 }
 
-int generateIfFalse(Instruction *inst){
+int generateIfFalse(Instruction *inst) {
     return -1;
 }
 
-int generateLessThan(Instruction *inst){
-        /*
+int generateLessThan(Instruction *inst) {
+    /*
       Both immediate:
       One immediate:
       Neither immediate:
@@ -569,8 +565,8 @@ int generateLessThan(Instruction *inst){
     return 0;
 }
 
-int generateEqualTo(Instruction *inst){
-            /*
+int generateEqualTo(Instruction *inst) {
+    /*
       Both immediate:
       One immediate:
       Neither immediate:
@@ -606,8 +602,7 @@ int generateEqualTo(Instruction *inst){
     fprintf(cg_flag, "\tmovb\t%%al, %d(%%rbp)\t#equal to end\n", getAddress(cg));
     return 0;
 }
-int generateCall(Instruction *inst){
-    
+int generateCall(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     TNodeOrConst *op2 = getOperand2(inst);
     if (op1 == NULL) {
@@ -630,7 +625,6 @@ int generateCall(Instruction *inst){
     //  return -1;
     //}
 
-
     fprintf(cg_flag, "\tcall %s\n", getName(getTN(op1)));
 
     //now for the return
@@ -643,22 +637,20 @@ int generateCall(Instruction *inst){
     fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#store return from call\n", getAddress(cg));
 
     return 0;
-    
 }
-int generateReturn(Instruction *inst){
+int generateReturn(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
     CGNode *cg;
 
-
     if (op1 == NULL) {
         printdebug("generateReturn failed, NULL operand");
         return -1;
     }
-    
+
     cg = findCG(getTN(op1));
     if (cg == NULL) {
         printdebug("generateReturn failed, trying to return %s not in CGList", getName(getTN(op1)));
-        return -1; 
+        return -1;
     }
 
     fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#return %s\n", getAddress(cg), getName(getTN(op1)));
@@ -666,38 +658,38 @@ int generateReturn(Instruction *inst){
     fprintf(cg_flag, "\tret\n");
     return 0;
 }
-int generateCopyRight(Instruction *inst){
+int generateCopyRight(Instruction *inst) {
     return -1;
 }
-int generateCopyLeft(Instruction *inst){
+int generateCopyLeft(Instruction *inst) {
     return -1;
 }
-int generateAddressOf(Instruction *inst){
+int generateAddressOf(Instruction *inst) {
     return -1;
 }
 
-int generateParam(Instruction *inst){
+int generateParam(Instruction *inst) {
     TNodeOrConst *op1 = getOperand1(inst);
-        
+
     if (op1 == NULL) {
         printdebug("generateParam failed, NULL operand");
         return -1;
     }
-    
+
     CGNode *op1CG = findCG(getTN(op1));
     if (op1CG == NULL) {
         printdebug("generateParam failed, %s is not in CGlist", getName(getTN(op1)));
         return -1;
     }
-    
-    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%edi\t#adding param start\n", getAddress(op1CG)); 
+
+    fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%edi\t#adding param start\n", getAddress(op1CG));
     return 0;
 }
 
 int generateFunctionStart(Instruction *inst) {
     currentsp = offset;
     TableNode *funDecTN = getResult(inst);
-        
+
     if (funDecTN == NULL) {
         printdebug("generateFunctionStart failed, NULL tablenode");
         return -1;
@@ -707,27 +699,27 @@ int generateFunctionStart(Instruction *inst) {
     fprintf(cg_flag, "%s:\n", getName(funDecTN));
     fprintf(cg_flag, "\tpushq\t%%rbp\n");
     fprintf(cg_flag, "\tmovq\t%%rsp, %%rbp\n");
-    fprintf(cg_flag, "\tsubq\t$%d, %%rsp\n", 128); // [CHANGE ME] 128 is a placeholder for the stack size
+    fprintf(cg_flag, "\tsubq\t$%d, %%rsp\n", 128);  // [CHANGE ME] 128 is a placeholder for the stack size
 
     //now we need to add the CGs of nodes to the CG list by doing assign from the
     // have function declararation node
     //declaration ->getType: if record, go through each element and load param from stack and store to correct tn cg
     //                       if not, go get one element of type of param
     //declaration ->getType->getDefinitionScope?: go through first n entries to get table nodes for params
-    
+
     TableNode *paramTN = getParameter(getTypeEntry(funDecTN));
     SymbolTable *st = getFunScope(funDecTN);
     int paramOffset = 16;
     TableNode *tnToAdd = getFirstEntry(st);
     if (getAdInfoType(paramTN) != TYPE_RECORD_TYPE) {
         CGNode *paramCG = addCG(tnToAdd, offset);
-        fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset); 
+        fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
         fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#FunctionStart1param end\n", getAddress(paramCG));
     } else {
         int numParams = getRecLength(paramTN);
         for (int i = 0; i < numParams; i++) {
-            CGNode *paramCG = addCG(tnToAdd, offset);    
-            fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset); 
+            CGNode *paramCG = addCG(tnToAdd, offset);
+            fprintf(cg_flag, "\tmovl\t%d(%%rbp), %%eax\t#FunctionStart1Param start\n", paramOffset);
             fprintf(cg_flag, "\tmovl\t%%eax, %d(%%rbp)\t#FunctionStart1param end\n", getAddress(paramCG));
             paramOffset = getPrimSize(getTypeEntry(tnToAdd));
             tnToAdd = getNextEntry(tnToAdd);
diff --git a/src/grammar.h b/src/grammar.h
index 86300f4..ec850a2 100644
--- a/src/grammar.h
+++ b/src/grammar.h
@@ -8,7 +8,7 @@
 #include "../src/symbol_table.h"
 extern FILE *asc_flag;
 extern bool tc_flag;
-extern void insert_code_line(char * error_message, int line_number);
+extern void insert_code_line(char *error_message, int line_number);
 extern bool contains_errors;
 
 typedef enum {
@@ -32,6 +32,6 @@ int offset;
 int currentsp;
 CGNode *cgList;
 
-Stack* stack;
-Stack* TrueList;
-Stack* FalseList;
+Stack *stack;
+Stack *TrueList;
+Stack *FalseList;
diff --git a/src/grammar.y b/src/grammar.y
index 80141e6..e20fcab 100644
--- a/src/grammar.y
+++ b/src/grammar.y
@@ -138,7 +138,7 @@ include_list:
 
 
 include_statement:
-        INCLUDE C_STRING
+        INCLUDE C_STRING 
     ;
 
 
diff --git a/src/intermediate_code.c b/src/intermediate_code.c
index 957accb..73d43df 100644
--- a/src/intermediate_code.c
+++ b/src/intermediate_code.c
@@ -3,20 +3,20 @@
 
 #include "intermediate_code.h"
 
-Stack * S_Init(){
-    Stack * s = calloc(1, sizeof(*s));
+Stack *S_Init() {
+    Stack *s = calloc(1, sizeof(*s));
     return s;
 }
 
-void S_Free(Stack *s){
+void S_Free(Stack *s) {
     // since we are not responsible for the values we can just pop until
     // NULL
-    for (void * p = S_Pop(s); p != NULL; p = S_Pop(s));
+    for (void *p = S_Pop(s); p != NULL; p = S_Pop(s));
     free(s);
 }
 
-void S_Push(Stack * s, void *v, int i) {
-    __Node * n = calloc(1, sizeof(*n));
+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;
@@ -24,338 +24,336 @@ void S_Push(Stack * s, void *v, int i) {
     s->size = s->size + 1;
 }
 
-void * S_Pop(Stack *s) {
+void *S_Pop(Stack *s) {
     if (s == NULL || S_IsEmpty(s)) {
-            return NULL;
+        return NULL;
     }
-    __Node * node = s->n;
+    __Node *node = s->n;
     s->n = node->next;
     s->size = s->size - 1;
-    void * r = node->v;
+    void *r = node->v;
     free(node);
     return r;
 }
 
-
-void * S_Peek(Stack *s){
+void *S_Peek(Stack *s) {
     if (s == NULL || S_IsEmpty(s)) {
-            return NULL;
+        return NULL;
     }
     return s->n->v;
 }
 
-bool S_IsEmpty(Stack *s){
-    if(s == NULL || s->size == 0) {
-            return true;
+bool S_IsEmpty(Stack *s) {
+    if (s == NULL || s->size == 0) {
+        return true;
     }
     return false;
 }
 
-int S_Size(Stack *s){
+int S_Size(Stack *s) {
     if (s == NULL || S_IsEmpty(s)) {
-            return 0;
+        return 0;
     }
     return s->size;
 }
 
-void S_Merge(Stack *list){
-        Stack* s1 = S_Pop(list);
-        Stack* s2 = S_Peek(list);
-        if(s1 == NULL){
-                return;
-        }
-        if(s2 == NULL){
-                S_Push(list, s1, 0);
-                return;
-        }
-        for (Instruction * i = S_Pop(s1); i; i = S_Pop(s1)){
-                S_Push(s2, i, 1);
-        }
+void S_Merge(Stack *list) {
+    Stack *s1 = S_Pop(list);
+    Stack *s2 = S_Peek(list);
+    if (s1 == NULL) {
+        return;
+    }
+    if (s2 == NULL) {
+        S_Push(list, s1, 0);
+        return;
+    }
+    for (Instruction *i = S_Pop(s1); i; i = S_Pop(s1)) {
+        S_Push(s2, i, 1);
+    }
 }
-void emit_backpatch(Stack * s, int l){
-        for (Instruction * i = S_Pop(s); i; i = S_Pop(s)){
-                i->label = l;
-        }
+void emit_backpatch(Stack *s, int l) {
+    for (Instruction *i = S_Pop(s); i; i = S_Pop(s)) {
+        i->label = l;
+    }
 }
 //_______________________________________________________________________
 
-char * temp = NULL;
+char *temp = NULL;
 
-
-       /*
+/*
         TODO: this is here to bring your attention to the comment bellow.
         check if start is NULL if it is assign it to the start globle variable
         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;
+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 backpatch(Stack *s, int l){
-        while (!S_IsEmpty(s)){
-                Instruction * i = S_Pop(s);
-                set_label(i, l);
-        }
+void emit_detach() {
+    current = current->prev;
+    current->next = NULL;
 }
 
-TNodeOrConst * getOperand1(Instruction * i){
-        return i->operand1;
+void backpatch(Stack *s, int l) {
+    while (!S_IsEmpty(s)) {
+        Instruction *i = S_Pop(s);
+        set_label(i, l);
+    }
 }
 
-TNodeOrConst * getOperand2(Instruction * i){
-        return i->operand2;
+TNodeOrConst *getOperand1(Instruction *i) {
+    return i->operand1;
 }
 
-TableNode * getResult(Instruction * i){
-        return i->result;
+TNodeOrConst *getOperand2(Instruction *i) {
+    return i->operand2;
 }
 
-Op getOp(Instruction * i){
-        return i->opcode;
+TableNode *getResult(Instruction *i) {
+    return i->result;
 }
 
-int getLabel(Instruction * i){
-        return i->label;
+Op getOp(Instruction *i) {
+    return i->opcode;
 }
 
-int get_index(Instruction * i){
-        return i->index;
+int getLabel(Instruction *i) {
+    return i->label;
 }
 
-void set_label(Instruction * i, int label){
-        i->label = label;
+int get_index(Instruction *i) {
+    return i->index;
 }
 
-bool isConst(TNodeOrConst * tnc) {
-        return tnc->d != NODE;
+void set_label(Instruction *i, int label) {
+    i->label = label;
 }
 
-TNodeOrConst * tn_or_const(Discriminant d, void * tnc) {
-        TNodeOrConst * count = calloc(1, sizeof(*count));
-        count->d = d;
-        count->tnc_union = calloc(1, sizeof(*count->tnc_union));
-        switch (d) {
-                case NODE:
-                        count->tnc_union->node = tnc;
-                        break;
-                case ADDRESS:
-                        count->tnc_union->address = tnc;
-                        break;
-                case STRING:
-                        count->tnc_union->string = tnc;
-                        break;
-                case INTEGER:
-                        count->tnc_union->integer = *(int*)tnc;
-                        break;
-                case CHARACTER:
-                        count->tnc_union->character = *(char*)tnc;
-                        break;
-                case BOOLEAN:
-                        count->tnc_union->Boolean = *(uint_least8_t*)tnc;
-                        break;
-        }
-        return count;
+bool isConst(TNodeOrConst *tnc) {
+    return tnc->d != NODE;
 }
 
-static void emit_helper(void){
-        Instruction * inst = calloc(1, sizeof(*inst));
-        if(begin == NULL){
-                begin = current = inst;
-                current->index = 1;
-        } else {
-                current->next = inst;
-                inst->prev = current;
-                inst->index = current->index + 1;
-                current = inst;
-        }
+TNodeOrConst *tn_or_const(Discriminant d, void *tnc) {
+    TNodeOrConst *count = calloc(1, sizeof(*count));
+    count->d = d;
+    count->tnc_union = calloc(1, sizeof(*count->tnc_union));
+    switch (d) {
+        case NODE:
+            count->tnc_union->node = tnc;
+            break;
+        case ADDRESS:
+            count->tnc_union->address = tnc;
+            break;
+        case STRING:
+            count->tnc_union->string = tnc;
+            break;
+        case INTEGER:
+            count->tnc_union->integer = *(int *)tnc;
+            break;
+        case CHARACTER:
+            count->tnc_union->character = *(char *)tnc;
+            break;
+        case BOOLEAN:
+            count->tnc_union->Boolean = *(uint_least8_t *)tnc;
+            break;
+    }
+    return count;
+}
+
+static void emit_helper(void) {
+    Instruction *inst = calloc(1, sizeof(*inst));
+    if (begin == NULL) {
+        begin = current = inst;
+        current->index = 1;
+    } else {
+        current->next = inst;
+        inst->prev = current;
+        inst->index = current->index + 1;
+        current = inst;
+    }
 }
 
 void emit_binary_op(
-                Op op,
-                TableNode * result,
-                TNodeOrConst * arg1,
-                TNodeOrConst * arg2
-                ){
-        emit_helper();
-        current->opcode = op;
-        // TODO: create temp and remove result from param list
-        current->result = result;
-        current->operand1 = arg1;
-        current->operand2 = arg2;
- }
-
-void emit_goto(int i){
-        emit_helper();
-        current->opcode = E_GOTO;
-        current->label = i;
+    Op op,
+    TableNode *result,
+    TNodeOrConst *arg1,
+    TNodeOrConst *arg2) {
+    emit_helper();
+    current->opcode = op;
+    // TODO: create temp and remove result from param list
+    current->result = result;
+    current->operand1 = arg1;
+    current->operand2 = arg2;
 }
 
-void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg){
-        emit_helper();
-        current->opcode = op;
-        current->result = result;
-        current->operand1 = arg;
- }
-
-void emit_assignment(TableNode * target, TNodeOrConst * source){
-        emit_helper();
-        current->opcode = E_ASSIGN;
-        current->result = target;
-        current->operand1 = source;
- }
-
-char * get_string(TNodeOrConst * tc){
-        char * s;
-        switch (tc->d) {
-                case NODE:
-                        return getName(tc->tnc_union->node);
-                case ADDRESS:
-                        return strdup("null");
-                case STRING:
-                        return tc->tnc_union->string;
-                case INTEGER:
-                        s = calloc(10, sizeof(char));
-                        sprintf(s, "%d", tc->tnc_union->integer);
-                        return s;
-                case CHARACTER:
-                        s = calloc(2, sizeof(char));
-                        sprintf(s, "%c", tc->tnc_union->character);
-                        return s;
-                case BOOLEAN:
-                        if(tc->tnc_union->Boolean){
-                                return strdup("true");
-                        }
-                        return strdup("false");
-        }
+void emit_goto(int i) {
+    emit_helper();
+    current->opcode = E_GOTO;
+    current->label = i;
 }
 
-void emit_label(int label){
-        emit_helper();
-        current->opcode = E_LABEL;
-        current->label = label;
+void emit_unary_op(Op op, TableNode *result, TNodeOrConst *arg) {
+    emit_helper();
+    current->opcode = op;
+    current->result = result;
+    current->operand1 = arg;
 }
 
-void emit_jump(int label){
-        emit_helper();
-        current->opcode = E_GOTO;
-        current->label = label;
+void emit_assignment(TableNode *target, TNodeOrConst *source) {
+    emit_helper();
+    current->opcode = E_ASSIGN;
+    current->result = target;
+    current->operand1 = source;
 }
 
-void emit_conditional_jump(Op condition, int label, ...){
-        // when this instruction is a conditional jump then the imput looks like (Op, int, TNodeOrConst *).
-        // when the inst is a cond with a Relational operation then the input looks like (Op, int, TNodeOrConst *, TNodeOrConst *)
-        emit_helper();
-        va_list argptr;
-        va_start(argptr, label);
-        current->opcode = condition;
-        current->label = label;
-        TNodeOrConst * n1;
-        TNodeOrConst * n2;
-        switch (condition) {
-                case E_IF_X_TRUE: case E_IF_X_FALSE:
-                        n1 = va_arg(argptr, TNodeOrConst *);
-                        current->operand1 = n1;
-                        break;
-                case E_LESS_THAN: case E_EQUAL_TO:
-                        n1 = va_arg(argptr, TNodeOrConst *);
-                        n2 = va_arg(argptr, TNodeOrConst *);
-                        current->operand1 = n1;
-                        current->operand2 = n2;
-                        break;
-        }
-        va_end(argptr);
+char *get_string(TNodeOrConst *tc) {
+    char *s;
+    switch (tc->d) {
+        case NODE:
+            return getName(tc->tnc_union->node);
+        case ADDRESS:
+            return strdup("null");
+        case STRING:
+            return tc->tnc_union->string;
+        case INTEGER:
+            s = calloc(10, sizeof(char));
+            sprintf(s, "%d", tc->tnc_union->integer);
+            return s;
+        case CHARACTER:
+            s = calloc(2, sizeof(char));
+            sprintf(s, "%c", tc->tnc_union->character);
+            return s;
+        case BOOLEAN:
+            if (tc->tnc_union->Boolean) {
+                return strdup("true");
+            }
+            return strdup("false");
+    }
 }
 
-void emit_function_start(TableNode * name){
-        emit_helper();
-        current->opcode = E_FUNC_START;
-        current->result = name;
+void emit_label(int label) {
+    emit_helper();
+    current->opcode = E_LABEL;
+    current->label = label;
 }
 
-void emit_parameter(TNodeOrConst * param){
-        emit_helper();
-        current->opcode = E_PARAM;
-        current->operand1 = param;
+void emit_jump(int label) {
+    emit_helper();
+    current->opcode = E_GOTO;
+    current->label = label;
+}
+
+void emit_conditional_jump(Op condition, int label, ...) {
+    // when this instruction is a conditional jump then the imput looks like (Op, int, TNodeOrConst *).
+    // when the inst is a cond with a Relational operation then the input looks like (Op, int, TNodeOrConst *, TNodeOrConst *)
+    emit_helper();
+    va_list argptr;
+    va_start(argptr, label);
+    current->opcode = condition;
+    current->label = label;
+    TNodeOrConst *n1;
+    TNodeOrConst *n2;
+    switch (condition) {
+        case E_IF_X_TRUE:
+        case E_IF_X_FALSE:
+            n1 = va_arg(argptr, TNodeOrConst *);
+            current->operand1 = n1;
+            break;
+        case E_LESS_THAN:
+        case E_EQUAL_TO:
+            n1 = va_arg(argptr, TNodeOrConst *);
+            n2 = va_arg(argptr, TNodeOrConst *);
+            current->operand1 = n1;
+            current->operand2 = n2;
+            break;
+    }
+    va_end(argptr);
+}
+
+void emit_function_start(TableNode *name) {
+    emit_helper();
+    current->opcode = E_FUNC_START;
+    current->result = name;
+}
+
+void emit_parameter(TNodeOrConst *param) {
+    emit_helper();
+    current->opcode = E_PARAM;
+    current->operand1 = param;
 }
 
 void emit_function_call(
-                TableNode * result,
-                int param_count,
-                TNodeOrConst * name
-                ){
-        emit_helper();
-        current->opcode = E_CALL;
-        current->operand1 = name;
-        current->operand2 = tn_or_const(INTEGER, &param_count);
-        current->result = result;
+    TableNode *result,
+    int param_count,
+    TNodeOrConst *name) {
+    emit_helper();
+    current->opcode = E_CALL;
+    current->operand1 = name;
+    current->operand2 = tn_or_const(INTEGER, &param_count);
+    current->result = result;
 }
 
-void emit_return(TNodeOrConst * value){
-        emit_helper();
-        current->opcode = E_RETURN;
-        current->operand1 = value;
+void emit_return(TNodeOrConst *value) {
+    emit_helper();
+    current->opcode = E_RETURN;
+    current->operand1 = value;
 }
 
-void emit_reserve(TableNode * result, TNodeOrConst * size){
-        // this needs to change
-        // we need to take a int
-        emit_parameter(size);
-        emit_function_call(result, 1, tn_or_const(NODE, look_up(cur, "reserve")));
+void emit_reserve(TableNode *result, TNodeOrConst *size) {
+    // this needs to change
+    // we need to take a int
+    emit_parameter(size);
+    emit_function_call(result, 1, tn_or_const(NODE, look_up(cur, "reserve")));
 }
 
-void emit_release(TableNode * pointer){
-        emit_parameter(tn_or_const(NODE, pointer));
-        emit_function_call(pointer, 1, tn_or_const(NODE, look_up(cur, "release")));
+void emit_release(TableNode *pointer) {
+    emit_parameter(tn_or_const(NODE, pointer));
+    emit_function_call(pointer, 1, tn_or_const(NODE, look_up(cur, "release")));
 }
 
-void emit_deref_right(TableNode * x, TNodeOrConst * y){
-        emit_helper();
-        current->opcode = E_DEREF_RIGHT;
-        current->result = x;
-        current->operand1 = y;
+void emit_deref_right(TableNode *x, TNodeOrConst *y) {
+    emit_helper();
+    current->opcode = E_DEREF_RIGHT;
+    current->result = x;
+    current->operand1 = y;
 }
 
-void emit_deref_left(TableNode * x, TNodeOrConst * y){
-        emit_helper();
-        current->opcode = E_DEREF_LEFT;
-        current->result = x;
-        current->operand1 = y;
+void emit_deref_left(TableNode *x, TNodeOrConst *y) {
+    emit_helper();
+    current->opcode = E_DEREF_LEFT;
+    current->result = x;
+    current->operand1 = y;
 }
 
-void emit_address_of(TableNode * x, TNodeOrConst * y){
-        emit_helper();
-        current->opcode = E_ADDRESS_OF;
-        current->result = x;
-        current->operand1 = y;
+void emit_address_of(TableNode *x, TNodeOrConst *y) {
+    emit_helper();
+    current->opcode = E_ADDRESS_OF;
+    current->result = x;
+    current->operand1 = y;
 }
 
-void emit_field_access(char* result, char* record, char* field){
-        emit_helper();
+void emit_field_access(char *result, char *record, char *field) {
+    emit_helper();
 }
 
-void emit_array_access(Op op, TableNode * result, TNodeOrConst * array, TNodeOrConst * index){
-        emit_helper();
-        current->opcode = op;
-        current->result = result;
-        current->operand1 = array;
-        current->operand2 = index;
-        // TODO: Still don't know what to do with the dimentions
+void emit_array_access(Op op, TableNode *result, TNodeOrConst *array, TNodeOrConst *index) {
+    emit_helper();
+    current->opcode = op;
+    current->result = result;
+    current->operand1 = array;
+    current->operand2 = index;
+    // TODO: Still don't know what to do with the dimentions
 }
 
-void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr){
-        /*
+void emit_bounds_check(TNodeOrConst *index, TNodeOrConst *arr) {
+    /*
            {[string: 5]
                 .
                 .
@@ -383,7 +381,7 @@ void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr){
             if t_0 < s._1 GOTO access array
             GOTO ERROR
            */
-        /* We need a label ERROR to jump to
+    /* We need a label ERROR to jump to
         emit_conditional_jump(E_LESS_THAN, );
         emit_conditional_jump(E_LESS_THAN, );
         emit_jump();
@@ -392,245 +390,218 @@ void emit_bounds_check(TNodeOrConst * index, TNodeOrConst * arr){
 
 // * Implement temp variable generator function that produces unique names (t1, t2, etc.)
 
-int label_gen(){
-        label_count++;
-        return label_count;
+int label_gen() {
+    label_count++;
+    return label_count;
 }
 
-void emit_as_file(FILE * out_file, Instruction * i){
-        if (out_file == NULL){
-                fprintf(stderr, "Error: output file is NULL\n");
-                return;
-        }
+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;
-        }
-        switch(i->opcode){
-                case E_FUNC_START:
-                        fprintf(out_file,
-                                "%4.d:  func : %s\n",
-                                i->index,
-                                getName(i->result)
-                                );
-                        break;
-                case E_LABEL:
-                        fprintf(out_file,
-                                "%4.d:  Label : %d\n",
-                                i->index,
-                                i->label
-                                );
-                        break;
-                case E_ADD:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s + %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_SUB:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s - %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_MUL:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s * %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_DIV:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s / %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_MOD:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s %% %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_OR:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s | %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_AND:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s & %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_NEG:
-                        fprintf(out_file,
-                                "%4.d:  %s = -%s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1)
-                                );
-                        break;
-                case E_NOT:
-                        fprintf(out_file,
-                                "%4.d:  %s = !%s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1)
-                                );
-                        break;
-                case E_ASSIGN:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1)
-                                );
-                        break;
-                case E_GOTO:
-                        fprintf(out_file,
-                                "%4.d:  GOTO : %d\n",
-                                i->index,
-                                i->label
-                                );
-                        break;
-                case E_IF_X_TRUE:
-                        fprintf(out_file,
-                                "%4.d:  if %s True GOTO %d\n",
-                                i->index,
-                                get_string(i->operand1),
-                                i->label
-                                );
-                        break;
-                case E_IF_X_FALSE:
-                        fprintf(out_file,
-                                "%4.d:  if %s False GOTO %d\n",
-                                i->index,
-                                get_string(i->operand1),
-                                i->label
-                                );
-                        break;
-               case E_LESS_THAN:
-                        // this feels wrong I need to TODO: this
-                        fprintf(out_file,
-                                "%4.d:  %s = %s < %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_EQUAL_TO:
-                        // this feels wrong I need to TODO: this
-                        fprintf(out_file,
-                                "%4.d:  %s = %s == %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_CALL:
-                        fprintf(out_file,
-                                "%4.d:  call : %s %s\n",
-                                i->index,
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_PARAM:
-                        fprintf(out_file,
-                                "%4.d:  param %s \n",
-                                i->index,
-                                get_string(i->operand1)
-                                );
-                        break;
-                case E_RETURN:
-                        fprintf(out_file,
-                                "%4.d:  return : %s\n",
-                                i->index,
-                                get_string(i->operand1)
-                                );
-                        break;
-                case E_INDEX_COPY_RIGHT:
-                        fprintf(out_file,
-                                "%4.d:  %s = %s[ %s ]\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1),
-                                get_string(i->operand2)
-                                );
-                        break;
-                case E_INDEX_COPY_LEFT:
-                        fprintf(out_file,
-                                "%4.d:  %s[ %s ] = %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand2),
-                                        get_string(i->operand1));
-                        break;
-                case E_ADDRESS_OF:
-                        fprintf(out_file,
-                                "%4.d:  %s = &%s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1)
-                                );
-                        break;
+    if (i == NULL) {
+        return;
+    }
+    switch (i->opcode) {
+        case E_FUNC_START:
+            fprintf(out_file,
+                    "%4.d:  func : %s\n",
+                    i->index,
+                    getName(i->result));
+            break;
+        case E_LABEL:
+            fprintf(out_file,
+                    "%4.d:  Label : %d\n",
+                    i->index,
+                    i->label);
+            break;
+        case E_ADD:
+            fprintf(out_file,
+                    "%4.d:  %s = %s + %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_SUB:
+            fprintf(out_file,
+                    "%4.d:  %s = %s - %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_MUL:
+            fprintf(out_file,
+                    "%4.d:  %s = %s * %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_DIV:
+            fprintf(out_file,
+                    "%4.d:  %s = %s / %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_MOD:
+            fprintf(out_file,
+                    "%4.d:  %s = %s %% %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_OR:
+            fprintf(out_file,
+                    "%4.d:  %s = %s | %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_AND:
+            fprintf(out_file,
+                    "%4.d:  %s = %s & %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_NEG:
+            fprintf(out_file,
+                    "%4.d:  %s = -%s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1));
+            break;
+        case E_NOT:
+            fprintf(out_file,
+                    "%4.d:  %s = !%s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1));
+            break;
+        case E_ASSIGN:
+            fprintf(out_file,
+                    "%4.d:  %s = %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1));
+            break;
+        case E_GOTO:
+            fprintf(out_file,
+                    "%4.d:  GOTO : %d\n",
+                    i->index,
+                    i->label);
+            break;
+        case E_IF_X_TRUE:
+            fprintf(out_file,
+                    "%4.d:  if %s True GOTO %d\n",
+                    i->index,
+                    get_string(i->operand1),
+                    i->label);
+            break;
+        case E_IF_X_FALSE:
+            fprintf(out_file,
+                    "%4.d:  if %s False GOTO %d\n",
+                    i->index,
+                    get_string(i->operand1),
+                    i->label);
+            break;
+        case E_LESS_THAN:
+            // this feels wrong I need to TODO: this
+            fprintf(out_file,
+                    "%4.d:  %s = %s < %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_EQUAL_TO:
+            // this feels wrong I need to TODO: this
+            fprintf(out_file,
+                    "%4.d:  %s = %s == %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_CALL:
+            fprintf(out_file,
+                    "%4.d:  call : %s %s\n",
+                    i->index,
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_PARAM:
+            fprintf(out_file,
+                    "%4.d:  param %s \n",
+                    i->index,
+                    get_string(i->operand1));
+            break;
+        case E_RETURN:
+            fprintf(out_file,
+                    "%4.d:  return : %s\n",
+                    i->index,
+                    get_string(i->operand1));
+            break;
+        case E_INDEX_COPY_RIGHT:
+            fprintf(out_file,
+                    "%4.d:  %s = %s[ %s ]\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1),
+                    get_string(i->operand2));
+            break;
+        case E_INDEX_COPY_LEFT:
+            fprintf(out_file,
+                    "%4.d:  %s[ %s ] = %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand2),
+                    get_string(i->operand1));
+            break;
+        case E_ADDRESS_OF:
+            fprintf(out_file,
+                    "%4.d:  %s = &%s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1));
+            break;
 
+        case E_DEREF_RIGHT:
+            fprintf(out_file,
+                    "%4.d:  %s = *%s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1));
+        case E_DEREF_LEFT:
+            fprintf(out_file,
+                    "%4.d:  *%s = %s\n",
+                    i->index,
+                    getName(i->result),
+                    get_string(i->operand1));
+    }
 
-                case E_DEREF_RIGHT:
-                        fprintf(out_file,
-                                "%4.d:  %s = *%s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1)
-                                );
-                case E_DEREF_LEFT:
-                        fprintf(out_file,
-                                "%4.d:  *%s = %s\n",
-                                i->index,
-                                getName(i->result),
-                                get_string(i->operand1)
-                                );
-        }
-
-        emit_as_file(out_file, i->next);
+    emit_as_file(out_file, i->next);
 }
 
+TableNode *getTN(TNodeOrConst *tnc) {
+    if (tnc->d == NODE) {
+        return tnc->tnc_union->node;
+    }
+    return NULL;
+}
 
-
-TableNode* getTN(TNodeOrConst* tnc) {
-     if (tnc->d == NODE) {
-         return tnc->tnc_union->node;
-     }
-     return NULL;
- }
-
- int getConst(TNodeOrConst* tnc) {
-     if (tnc->d == INTEGER) {
-         return tnc->tnc_union->integer;
-     }
-     return -1;
- }
+int getConst(TNodeOrConst *tnc) {
+    if (tnc->d == INTEGER) {
+        return tnc->tnc_union->integer;
+    }
+    return -1;
+}
diff --git a/src/intermediate_code.h b/src/intermediate_code.h
index f362874..1e60a91 100644
--- a/src/intermediate_code.h
+++ b/src/intermediate_code.h
@@ -16,20 +16,20 @@ typedef struct Stack Stack;
 typedef struct __Node __Node;
 
 typedef struct __Node {
-        void * v;
-        __Node * next;
+    void *v;
+    __Node *next;
 } __Node;
 
 typedef struct Stack {
-        __Node * n;
-        int w;
-        int size;
+    __Node *n;
+    int w;
+    int size;
 } Stack;
-Stack * S_Init();
+Stack *S_Init();
 void S_Free(Stack *s);
-void S_Push(Stack * s, void *v, int i);
-void * S_Pop(Stack *s);
-void * S_Peek(Stack *s);
+void S_Push(Stack *s, void *v, int i);
+void *S_Pop(Stack *s);
+void *S_Peek(Stack *s);
 bool S_IsEmpty(Stack *s);
 int S_Size(Stack *s);
 void S_Merge(Stack *list);
@@ -39,137 +39,130 @@ typedef union TNConstUnion TNConstUnion;
 typedef struct Instruction Instruction;
 typedef struct TNodeOrConst TNodeOrConst;
 
-
 // these are from page 364
 
-typedef enum {              // these are from page 364
-        E_LABEL = 10000,    // this is not in the book
-        E_FUNC_START,
-        E_ADD,              // 1 from the list
-        E_SUB,              // 1
-        E_MUL,              // 1
-        E_DIV,              // 1
-        E_MOD,              // 1 TODO: Please change to REM
-        E_OR,               // 1
-        E_AND,              // 1
-        E_NEG,              // 2
-        E_NOT,              // 2
-        E_ASSIGN,           // 3
-        E_GOTO,             // 4
-        E_COND_GOTO,        // 5 I don't thik I need this because we could just follow the < or the = and just assume that it's a cond got
-        E_IF_X_TRUE,        // 5
-        E_IF_X_FALSE,       // 5
-        E_LESS_THAN,         // 6 rule 1 + 5
-        E_EQUAL_TO,          // 6 rule 1 + 5
-        E_CALL,             // 7
-        E_PARAM,            // 7
-        E_RETURN,           // 7
-        E_INDEX_COPY_RIGHT, // 8   this is x = y[i]
-        E_INDEX_COPY_LEFT,  // 8           x[i] = y
-        E_ADDRESS_OF,       // 9           x = &y
-        E_DEREF_RIGHT,      // 9           x = *y
-        E_DEREF_LEFT        // 9           x* = y
+typedef enum {        // these are from page 364
+    E_LABEL = 10000,  // this is not in the book
+    E_FUNC_START,
+    E_ADD,               // 1 from the list
+    E_SUB,               // 1
+    E_MUL,               // 1
+    E_DIV,               // 1
+    E_MOD,               // 1 TODO: Please change to REM
+    E_OR,                // 1
+    E_AND,               // 1
+    E_NEG,               // 2
+    E_NOT,               // 2
+    E_ASSIGN,            // 3
+    E_GOTO,              // 4
+    E_COND_GOTO,         // 5 I don't thik I need this because we could just follow the < or the = and just assume that it's a cond got
+    E_IF_X_TRUE,         // 5
+    E_IF_X_FALSE,        // 5
+    E_LESS_THAN,         // 6 rule 1 + 5
+    E_EQUAL_TO,          // 6 rule 1 + 5
+    E_CALL,              // 7
+    E_PARAM,             // 7
+    E_RETURN,            // 7
+    E_INDEX_COPY_RIGHT,  // 8   this is x = y[i]
+    E_INDEX_COPY_LEFT,   // 8           x[i] = y
+    E_ADDRESS_OF,        // 9           x = &y
+    E_DEREF_RIGHT,       // 9           x = *y
+    E_DEREF_LEFT         // 9           x* = y
 } Op;
 
 typedef enum {
-        NODE = 11000,               // TableNode
-        INTEGER,            // int
-        STRING,             // char *
-        CHARACTER,          // char
-        ADDRESS,            // void *
-        BOOLEAN             // bool
+    NODE = 11000,  // TableNode
+    INTEGER,       // int
+    STRING,        // char *
+    CHARACTER,     // char
+    ADDRESS,       // void *
+    BOOLEAN        // bool
 } Discriminant;
 
 typedef union TNConstUnion {
-        TableNode    * node;
-        int            integer;
-        char         * string;
-        char           character;
-        void         * address;
-        bool           Boolean;
+    TableNode *node;
+    int integer;
+    char *string;
+    char character;
+    void *address;
+    bool Boolean;
 } TNConstUnion;
 
 typedef struct TNodeOrConst {
-        Discriminant d;
-        TNConstUnion * tnc_union;
+    Discriminant d;
+    TNConstUnion *tnc_union;
 } TNodeOrConst;
 
 typedef struct Instruction {
-        Op opcode;
-        TableNode    * result;
-        TNodeOrConst * operand1;
-        TNodeOrConst * operand2;
-        int            label;
-        int            index;
+    Op opcode;
+    TableNode *result;
+    TNodeOrConst *operand1;
+    TNodeOrConst *operand2;
+    int label;
+    int index;
 
-        Instruction  * prev;
-        Instruction  * next;
+    Instruction *prev;
+    Instruction *next;
 } Instruction;
 
-
 // NOTE We are not using this We are using the Stack api
 typedef struct TFList {
-        Instruction  * i;
-        TFList       * next;
+    Instruction *i;
+    TFList *next;
 } TFList;
 
 // TFList * make_list(Instruction * i);
-  // - makelist(i) function to create instruction lists
+// - makelist(i) function to create instruction lists
 // void merge(TFList * l1, TFList * l2);
-  // - merge(p1,p2) function to concatenate lists
+// - merge(p1,p2) function to concatenate lists
 // void backpatch(TFList * l, int label);
-  // - backpatch(p,i) function to fill in jump targets
+// - backpatch(p,i) function to fill in jump targets
 // void bp_temp(int n);
 
-
-extern Instruction   * begin;
-extern Instruction   * current;
+extern Instruction *begin;
+extern Instruction *current;
 extern int label_count;
 extern bool code_gen;
-extern FILE * ir_flag;
+extern FILE *ir_flag;
 
-
-TNodeOrConst * tn_or_const(Discriminant , void * );
-void emit_binary_op(Op op, TableNode * result, TNodeOrConst * arg1, TNodeOrConst * arg2);
-void emit_unary_op(Op op, TableNode * result, TNodeOrConst * arg);
-void emit_assignment(TableNode * target, TNodeOrConst * source);
-void emit_as_file(FILE * out_file, Instruction * instr_arr);
+TNodeOrConst *tn_or_const(Discriminant, void *);
+void emit_binary_op(Op op, TableNode *result, TNodeOrConst *arg1, TNodeOrConst *arg2);
+void emit_unary_op(Op op, TableNode *result, TNodeOrConst *arg);
+void emit_assignment(TableNode *target, TNodeOrConst *source);
+void emit_as_file(FILE *out_file, Instruction *instr_arr);
 void emit_label(int label);
 void emit_jump(int label);
 
 void emit_conditional_jump(Op condition, int label, ...);
 
-void emit_function_start(TableNode* name);
-void emit_parameter(TNodeOrConst * param);
-void emit_function_call(TableNode * result, int param_count, TNodeOrConst * name);
-void emit_return(TNodeOrConst * value);
-void emit_reserve(TableNode * result, TNodeOrConst * size);
-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_function_start(TableNode *name);
+void emit_parameter(TNodeOrConst *param);
+void emit_function_call(TableNode *result, int param_count, TNodeOrConst *name);
+void emit_return(TNodeOrConst *value);
+void emit_reserve(TableNode *result, TNodeOrConst *size);
+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);
+void emit_push_all(Stack *s);
 
+int getLabel(Instruction *i);
+TableNode *getTN(TNodeOrConst *tnc);
+int getConst(TNodeOrConst *tnc);
 
-int getLabel(Instruction * i);
-TableNode* getTN(TNodeOrConst* tnc);
-int getConst(TNodeOrConst* tnc);
-
-
-
-TNodeOrConst * getOperand1(Instruction * i);
-TNodeOrConst * getOperand2(Instruction * i);
-TableNode * getResult(Instruction * i);
-Op getOp(Instruction * i);
-int getLabel(Instruction * i);
-int get_index(Instruction * i);
-void set_label(Instruction * i, int label);
-bool isConst(TNodeOrConst * tnc);
+TNodeOrConst *getOperand1(Instruction *i);
+TNodeOrConst *getOperand2(Instruction *i);
+TableNode *getResult(Instruction *i);
+Op getOp(Instruction *i);
+int getLabel(Instruction *i);
+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);
 extern int offset;
 extern int currentsp;
-extern CGNode* cgList;
+extern CGNode *cgList;
diff --git a/src/lexicalStructure.h b/src/lexicalStructure.h
index bdd0db7..d9f23d8 100644
--- a/src/lexicalStructure.h
+++ b/src/lexicalStructure.h
@@ -25,10 +25,11 @@ int line_number = 1;
 int column_number = 1;
 int yycolumn = 1;
 
-#define YY_USER_ACTION {                            \
+#define YY_USER_ACTION                              \
+    {                                               \
         yylloc.first_line = yylineno;               \
         yylloc.last_line = yylineno;                \
         yylloc.first_column = yycolumn;             \
         yylloc.last_column = yycolumn + yyleng - 1; \
         yycolumn += yyleng;                         \
-}
+    }
diff --git a/src/runner.c b/src/runner.c
index ab2754a..4aa6a84 100644
--- a/src/runner.c
+++ b/src/runner.c
@@ -103,7 +103,6 @@ int run(FILE *alpha) {
     int token;
     top = cur = init(CreateScope(NULL, 1, 1));
 
-
     // If file is not found
     if (alpha == NULL) {
         fprintf(stderr, "INPUT FILE NOT FOUND\n");
diff --git a/src/runner.h b/src/runner.h
index c423a36..37c7bad 100644
--- a/src/runner.h
+++ b/src/runner.h
@@ -59,8 +59,8 @@ bool DEBUG = false;
 int no_flag = 0;
 int arg;
 bool contains_errors = false;
-char * cg_name;
-char * ir_name;
+char *cg_name;
+char *ir_name;
 
 TableNode *funprime;
 TableNode *arrayprim;
@@ -73,9 +73,9 @@ TableNode *recprime;
 TableNode *funtypeprime;
 TableNode *undefined;
 extern Instruction *begin;
-extern Stack* stack;
-extern Stack* TrueList;
-extern Stack* FalseList;
+extern Stack *stack;
+extern Stack *TrueList;
+extern Stack *FalseList;
 
 int main(int argc, char *argv[]);
 int check_flag(char *arg, char *alpha);
@@ -112,6 +112,6 @@ typedef struct CodeLine {
 CodeLine *code_head;
 
 char *file_read_line(FILE *fp);
-void insert_code_line(char * error_message, int line_number);
+void insert_code_line(char *error_message, int line_number);
 void append_code_line(CodeLine *code_line);
 void print_code_lines();
diff --git a/src/symbol_table.c b/src/symbol_table.c
index 000fbc1..3809128 100644
--- a/src/symbol_table.c
+++ b/src/symbol_table.c
@@ -116,15 +116,15 @@ int getPrimSize(TableNode *definition) {
             "Invalid.");
         return -1;
     }
-    if(getAdInfoType(definition) == TYPE_ARRAY_TYPE){
+    if (getAdInfoType(definition) == TYPE_ARRAY_TYPE) {
         //special case to return size for reference to an array
         return 8;
     }
-    if(getAdInfoType(definition) == TYPE_FUNCTION_TYPE){
+    if (getAdInfoType(definition) == TYPE_FUNCTION_TYPE) {
         //special case to return size for reference to a function
         return 8;
     }
-    if(getAdInfoType(definition) == TYPE_RECORD_TYPE){
+    if (getAdInfoType(definition) == TYPE_RECORD_TYPE) {
         //special case to return size for reference to a record
         return getRecTotal(definition);
     }
@@ -469,7 +469,7 @@ int getRecSize(SymbolTable *tn) {
 // multiple inputs Below function also has the line number where the function is
 // first defined
 AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular, SymbolTable *scope) {
-    AdInfo *info = (AdInfo *)calloc(1,sizeof(AdInfo));
+    AdInfo *info = (AdInfo *)calloc(1, sizeof(AdInfo));
     info->FunDecAdInfo = (function_declaration_info *)malloc(
         sizeof(function_declaration_info));
     info->FunDecAdInfo->startlinenumber = line;
@@ -561,12 +561,12 @@ SymbolTable *getFunScope(TableNode *definition) {
             "node has NULL additionalinfo. Invalid.");
         return NULL;
     }
-    if(definition->additionalinfo->FunDecAdInfo == NULL) {
+    if (definition->additionalinfo->FunDecAdInfo == NULL) {
         printdebug(
             "node has NULL additionalinfo. Invalid.");
         return NULL;
     }
-    if(definition->additionalinfo->FunDecAdInfo->scope == NULL) {
+    if (definition->additionalinfo->FunDecAdInfo->scope == NULL) {
         printdebug(
             "node has no scope initialized.");
         return NULL;
@@ -587,17 +587,17 @@ TableNode *setFunScope(TableNode *tn, SymbolTable *scope) {
             "invalid");
         return undefined;
     }
-    if(tn->additionalinfo == NULL) {
+    if (tn->additionalinfo == NULL) {
         printdebug(
             "node has NULL additionalinfo. Invalid.");
         return undefined;
     }
-    if(tn->additionalinfo->FunDecAdInfo == NULL) {
+    if (tn->additionalinfo->FunDecAdInfo == NULL) {
         printdebug(
             "node has NULL additionalinfo. Invalid.");
         return undefined;
     }
-    if(scope == NULL) {
+    if (scope == NULL) {
         printdebug(
             "passed in an empty scope.");
         return undefined;
@@ -705,7 +705,7 @@ TableNode *getReturn(TableNode *definition) {
             "node has NULL additionalinfo. Invalid.");
         return undefined;
     }
-    printdebug("function:%s with return type %s\n",getName(definition),getName(definition->additionalinfo->FunTypeAdInfo->returntype));
+    printdebug("function:%s with return type %s\n", getName(definition), getName(definition->additionalinfo->FunTypeAdInfo->returntype));
     return definition->additionalinfo->FunTypeAdInfo->returntype;
 }
 
@@ -862,10 +862,10 @@ SymbolTable *init(SymbolTable *start) {
     chara->additionalinfo = CreatePrimitiveInfo(SIZE_CHAR);
     stri->additionalinfo = CreateArrayInfo(1, chara);
     boo->additionalinfo = CreatePrimitiveInfo(SIZE_BOOL);
-    reserve->additionalinfo = CreateFunctionDeclarationInfo(0, false,NULL);
+    reserve->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
     reservetype->additionalinfo = CreateFunctionTypeInfo(integ, addr);
     releasetype->additionalinfo = CreateFunctionTypeInfo(addr, integ);
-    release->additionalinfo = CreateFunctionDeclarationInfo(0, false,NULL);
+    release->additionalinfo = CreateFunctionDeclarationInfo(0, false, NULL);
 
     integ->tag = TYPE_PRIMITIVE_TYPE;  // explicitly set the type for integ
     addr->tag = TYPE_PRIMITIVE_TYPE;   // explicitly set the type for addr
@@ -1031,7 +1031,7 @@ TableNode *CreateEntry(SymbolTable *table, int tag, TableNode *typeOf, char *id,
                 return NULL;
         }
         */
-    if((id != NULL) && table_lookup(cur,id)!=undefined){
+    if ((id != NULL) && table_lookup(cur, id) != undefined) {
         printdebug("This name is already defined in the current scope");
         //throw_error(ERROR_TYPE, "Already defined.");
         return undefined;
@@ -1062,7 +1062,7 @@ TableNode *CreateEntry(SymbolTable *table, int tag, TableNode *typeOf, char *id,
         printdebug("[CreateEntry] Adding %s to the symbol table", id);
         return newEntry;
     } else {
-        TableNode*oldEntry = table->entries;
+        TableNode *oldEntry = table->entries;
         while (oldEntry->next != NULL) {
             oldEntry = oldEntry->next;
         }
@@ -1309,7 +1309,7 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
     }
 
     for (; entry != NULL; entry = getNextEntry(entry)) {
-        if((getName(entry)[0] == '$' || getName(entry)[0] == '&') && ir_flag == NULL){
+        if ((getName(entry)[0] == '$' || getName(entry)[0] == '&') && ir_flag == NULL) {
             continue;
         }
         if (getAdInfoType(entry) == TYPE_ARRAY_TYPE) {
@@ -1391,11 +1391,11 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
         if (getAdInfoType(entry) == TYPE_FUNCTION_DECLARATION) {
             char *functiontype = (char *)malloc(100);
             sprintf(functiontype, " %s", getName(getTypeEntry(entry)));
-            char* functionScope = (char *)malloc(100);
-            if(getLine(getFunScope(entry)) < 1){
+            char *functionScope = (char *)malloc(100);
+            if (getLine(getFunScope(entry)) < 1) {
                 sprintf(functionScope, " Function not defined before runtime");
-            }else{
-            sprintf(functionScope, " Function Definition that starts at line %d",getLine(getFunScope(entry)));
+            } else {
+                sprintf(functionScope, " Function Definition that starts at line %d", getLine(getFunScope(entry)));
             }
             if (parentScopeNum == 0) {
                 st_fprint(file_ptr, getName(entry), currentScopeNum, -100, functiontype, functionScope);
@@ -1545,7 +1545,13 @@ SymbolTable *getParent(SymbolTable *st) {
 ListOfTable *getChildren(SymbolTable *st) { return st->Children_Scope; }
 SymbolTable *getFirstChild(ListOfTable *lt) { return lt->table; }
 ListOfTable *getRestOfChildren(ListOfTable *lt) { return lt->next; }
-TableNode *getFirstEntry(SymbolTable *st) { return st->entries; }
+TableNode *getFirstEntry(SymbolTable *st) {
+    if (st == NULL || st->entries == NULL) {
+        printdebug("passed a NULL symbol table to getFirstEntry");
+        return undefined;
+    }
+    return st->entries;
+}
 
 // Segfaults when passed an invalid table node!
 TableNode *getNextEntry(TableNode *tn) {
diff --git a/src/symbol_table.h b/src/symbol_table.h
index f838314..2a8abb5 100644
--- a/src/symbol_table.h
+++ b/src/symbol_table.h
@@ -48,7 +48,7 @@ typedef struct {
 typedef struct {
     int startlinenumber;
     bool regularoras;
-    SymbolTable* scope;
+    SymbolTable *scope;
 } function_declaration_info;
 
 typedef struct {
@@ -122,7 +122,7 @@ int getRecLength(TableNode *definition);
 SymbolTable *getRecList(TableNode *definition);
 TableNode *setRecSize(TableNode *tn, int n);
 int getRecSize(SymbolTable *tn);
-AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular,SymbolTable *scope);
+AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular, SymbolTable *scope);
 TableNode *setFunScope(TableNode *tn, SymbolTable *scope);
 SymbolTable *getFunScope(TableNode *definition);
 int getStartLine(TableNode *definition);
diff --git a/tests/programs/test/fib.alpha b/tests/programs/test/fib.alpha
new file mode 100644
index 0000000..2f33e06
--- /dev/null
+++ b/tests/programs/test/fib.alpha
@@ -0,0 +1 @@
+(* TODO: Prints out fib sequence. *)
\ No newline at end of file
diff --git a/tests/programs/test/ll.alpha b/tests/programs/test/ll.alpha
new file mode 100644
index 0000000..4178a08
--- /dev/null
+++ b/tests/programs/test/ll.alpha
@@ -0,0 +1 @@
+(* TODO: creates a linked list and prints out the chain. *)
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_add.alpha b/tests/sprint4/test/sp4_cg_add.alpha
index e3da55e..0d5fb5a 100644
--- a/tests/sprint4/test/sp4_cg_add.alpha
+++ b/tests/sprint4/test/sp4_cg_add.alpha
@@ -1,35 +1,14 @@
 (* TEST: [-asc -tc -cg -ir] *)
 
-type string: 1 -> character
-type BooleanXBoolean: [Boolean: x; Boolean: y]
-type characterXcharacter: [character: x; character: y]
-type integerXinteger: [integer: x; integer: y]
-
-type Boolean2Boolean: Boolean -> Boolean
-type integer2integer: integer -> integer
-type character2integer: character -> integer
-type Boolean2integer0: Boolean -> integer
-type string2integer: string -> integer
-type integerXinteger2integer: integerXinteger -> integer
-type integerXinteger2Boolean: integerXinteger -> Boolean
-type characterXcharacter2Boolean: characterXcharacter -> Boolean
-type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean
-type integer2address: integer -> address
-type address2integer: address -> integer
-
-external function printInteger: integer2integer
-external function printCharacter: character2integer
-external function printBoolean: Boolean2integer
-
-function entry: string2integer
+#include "std.alpha"
 	
 entry (arg) := {
 	[integer:x; integer:y; integer: result]
+
 	y := 1;
 	x := 3;
 	y := x + y;
 
     result := printInteger(y);
-
 	return y;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_and.alpha b/tests/sprint4/test/sp4_cg_and.alpha
index 97adf47..5d5590b 100644
--- a/tests/sprint4/test/sp4_cg_and.alpha
+++ b/tests/sprint4/test/sp4_cg_and.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [Boolean:b; Boolean: c; Boolean: d]
-        c := true;
-        d := false;
-        d := c & d;
-        return 1;
+#include "std.alpha"
+
+entry (arg) := {
+    [Boolean:b; Boolean: c; Boolean: d]
+
+    z := true;
+    d := false;
+    d := c & d;
+    
+    return 1;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_demo.alpha b/tests/sprint4/test/sp4_cg_demo.alpha
deleted file mode 100644
index e74c5ad..0000000
--- a/tests/sprint4/test/sp4_cg_demo.alpha
+++ /dev/null
@@ -1,8 +0,0 @@
-type main: string -> integer
-function entry: main
-
-entry(arg) := {
-	  [integer:x]
- 	  x := 3 + 2 * 8;
-	  return x;
- }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_demo.cg b/tests/sprint4/test/sp4_cg_demo.cg
deleted file mode 100644
index 32d366c..0000000
--- a/tests/sprint4/test/sp4_cg_demo.cg
+++ /dev/null
@@ -1,9 +0,0 @@
-type main: string -> integer
-function entry: main
-
-entry(arg) := {
-	  [integer:x; Boolean b]
- 	  x := 3 + 2 * 8;
-	  b := x < 1;
-	  return 0;
- }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_div.alpha b/tests/sprint4/test/sp4_cg_div.alpha
index e6f9cbd..4e27b37 100644
--- a/tests/sprint4/test/sp4_cg_div.alpha
+++ b/tests/sprint4/test/sp4_cg_div.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [integer:x; integer:y]
-        y := 1;
-        x := 3;
-        y := x / y;
-        return y;
+#include "std.alpha"
+
+entry (arg) := {
+    [integer:x; integer:y]
+
+    y := 1;
+    x := 3;
+    y := x / y;
+    
+    return y;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_equal_to.alpha b/tests/sprint4/test/sp4_cg_equal_to.alpha
index 23ecf91..d7011a0 100644
--- a/tests/sprint4/test/sp4_cg_equal_to.alpha
+++ b/tests/sprint4/test/sp4_cg_equal_to.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [Boolean: b; integer: x; integer: y]
-        x := 1;
+#include "std.alpha"
+
+entry (arg) := {
+    [Boolean: b; integer: x; integer: y]
+
+    x := 1;
 	y := 2;
 	b := x = y;
-        return 1;
+    
+    return 1;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_fib.alpha b/tests/sprint4/test/sp4_cg_fib.alpha
deleted file mode 100644
index 64b1239..0000000
--- a/tests/sprint4/test/sp4_cg_fib.alpha
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/tests/sprint4/test/sp4_cg_less_than.alpha b/tests/sprint4/test/sp4_cg_less_than.alpha
index 8b9cbc7..6b13385 100644
--- a/tests/sprint4/test/sp4_cg_less_than.alpha
+++ b/tests/sprint4/test/sp4_cg_less_than.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [Boolean: b; integer: x; integer: y]
-character        x := 1;
+#include "std.alpha"
+
+entry (arg) := {
+    [Boolean: b; integer: x; integer: y]
+
+    x := 1;
 	y := 2;
 	b := x < y;
-        return 1;
+    
+    return 1;
 }
diff --git a/tests/sprint4/test/sp4_cg_mod.alpha b/tests/sprint4/test/sp4_cg_mod.alpha
index ccf0b85..ad6530a 100644
--- a/tests/sprint4/test/sp4_cg_mod.alpha
+++ b/tests/sprint4/test/sp4_cg_mod.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [integer:x; integer:y]
-        y := 1;
-        x := 3;
-        y := x % y;
-        return y;
+#include "std.alpha"
+
+entry (arg) := {
+    [integer:x; integer:y]
+
+    y := 1;
+    x := 3;
+    y := x % y;
+    
+    return y;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_mult.alpha b/tests/sprint4/test/sp4_cg_mult.alpha
index 630fa14..dfa8fce 100644
--- a/tests/sprint4/test/sp4_cg_mult.alpha
+++ b/tests/sprint4/test/sp4_cg_mult.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [integer:x; integer:y]
-        y := 1;
-        x := 3;
-        y := x * x;
-        return y;
+#include "std.alpha"
+
+entry (arg) := {
+    [integer:x; integer:y]
+
+    y := 1;
+    x := 3;
+    y := x * x;
+    
+    return y;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_neg.alpha b/tests/sprint4/test/sp4_cg_neg.alpha
index 58683a4..4b7fda8 100644
--- a/tests/sprint4/test/sp4_cg_neg.alpha
+++ b/tests/sprint4/test/sp4_cg_neg.alpha
@@ -1,10 +1,12 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [integer:x; integer:y]
-        x := 3;
-        y := -x;
-        return y;
+#include "std.alpha"
+
+entry (arg) := {
+    [integer:x; integer:y]
+    
+    x := 3;
+    y := -x;
+    
+    return y;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_not.alpha b/tests/sprint4/test/sp4_cg_not.alpha
index f7ad95c..803b3de 100644
--- a/tests/sprint4/test/sp4_cg_not.alpha
+++ b/tests/sprint4/test/sp4_cg_not.alpha
@@ -1,10 +1,12 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [Boolean: c; Boolean: d]
-        c := true;
-        d := !c;
-        return 1;
+#include "std.alpha"
+
+entry (arg) := {
+    [Boolean: c; Boolean: d]
+
+    c := true;
+    d := !c;
+    
+    return 1;
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_or.alpha b/tests/sprint4/test/sp4_cg_or.alpha
index 0ce14f3..6788796 100644
--- a/tests/sprint4/test/sp4_cg_or.alpha
+++ b/tests/sprint4/test/sp4_cg_or.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [Boolean:b; Boolean: c; Boolean: d]
-        c := true;
-        d := false;
-        d := c | d;
-        return 1;
+#include "std.alpha"
+
+entry (arg) := {
+    [Boolean:b; Boolean: c; Boolean: d]
+
+    c := true;
+    d := false;
+    d := c | d;
+    return 1;
+    
 }
\ No newline at end of file
diff --git a/tests/sprint4/test/sp4_cg_sub.alpha b/tests/sprint4/test/sp4_cg_sub.alpha
index abf6608..9ab6b68 100644
--- a/tests/sprint4/test/sp4_cg_sub.alpha
+++ b/tests/sprint4/test/sp4_cg_sub.alpha
@@ -1,11 +1,13 @@
 (* TEST: [-asc -tc -cg -ir] *)
-type main: integer -> integer
-function test: main
 
-test (a) := {
-        [integer:x; integer:y]
-        y := 1;
-        x := 3;
-        y := x - y;
-        return y;
+#include "std.alpha"
+
+entry (arg) := {
+    [integer:x; integer:y]
+    
+    y := 1;
+    x := 3;
+    y := x - y;
+    
+    return y;
 }
\ No newline at end of file