diff --git a/src/grammar.y b/src/grammar.y
index a7d173e..110ffb4 100644
--- a/src/grammar.y
+++ b/src/grammar.y
@@ -29,6 +29,7 @@
 %union {
     int integ;
     char* words;
+    char letter;
     void* tn;
 }
 
@@ -538,30 +539,22 @@ WHILE L_PAREN expression R_PAREN sblock {
 
 simple_statement:
         assignable ASSIGN expression 
-         {   
+         {  printdebug("simple statement");   
             TableNode* node;
-            if((getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE_TYPE||
-                getAdInfoType((TableNode*)$1) == TYPE_ARRAY_TYPE||
-                getAdInfoType((TableNode*)$1) == TYPE_RECORD_TYPE||
-                getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_TYPE)){
-                    node = (TableNode*)$1;
-                }else if((getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION)||
+            if((getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION)||
                 (getAdInfoType((TableNode*)$1) == TYPE_ARRAY)||
                 (getAdInfoType((TableNode*)$1) == TYPE_RECORD)||
                 (getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE)){
-
-                    node = getTypeEntry((TableNode*)$1);
+            
+                    node = ((TableNode*)$1);
                 } else{
                     error_type(undefined, undefined, "Invalid type passed to assignable.");
                     node = undefined;
                 }
 
-            if((getAdInfoType(node) == TYPE_ARRAY_TYPE||
-                getAdInfoType(node) == TYPE_RECORD_TYPE) &&
-                (strcmp(getName((TableNode*)$3),"address") == 0)){
-                printdebug("%s[☺] Passed array/record type check; %s = %s", COLOR_GREEN, getName(node), getName((TableNode*)$3));
-                } 
-            else if(getAdInfoType(node) == getAdInfoType((TableNode*)$3)){
+
+            if(getAdInfoType(node) == getAdInfoType((TableNode*)$3)){
+                //EMIT ASSIGN INSTRUCTION HERE
                 printdebug("%s[☺] Passed type check; %s = %s", COLOR_GREEN, getName(node), getName((TableNode*)$3));
             } else {
                 error_type(node, (TableNode*)$3, "");
@@ -571,7 +564,7 @@ simple_statement:
         }
 
 
-|   RETURN expression {$$ = $2;}
+|   RETURN expression {$$ = getTypeEntry((TableNode*)$2);}
     ;
 
 
@@ -592,6 +585,7 @@ ablock:
 
 
 argument_list:
+        //NEED TO EMIT PARAMETERS HERE. MAYBE USE STACK STRUCTURE
         expression COMMA argument_list
         {
             CreateEntry(cur,getAdInfoType((TableNode*)$1), (TableNode*)$1, getName((TableNode*)$1), NULL);
@@ -618,160 +612,188 @@ expression:
     |   SUB_OR_NEG expression %prec UMINUS
         {
             printdebug("negative expression");
-            if((TableNode*)$2 != integ) {
-                printdebug("cant negate something not an integer at line %d and column %d",@2.first_line,@2.first_column);
-                $$=undefined;
+            if(getTypeEntry((TableNode*)$2) == integ) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of unary operation
+                $$ = node;
             } else {
-                $$=(TableNode*)$2;
+                $$=undefined;
+                error_type(getTypeEntry((TableNode*)$2), integ, "");
             }
         }
 
     |   NOT expression
         {
             printdebug("not expression");
-            if((TableNode*)$2 == boo) {
-                $$=(TableNode*)$2;
+            if(getTypeEntry((TableNode*)$2) == boo) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of unary operation
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$2, boo, "");
+                error_type(getTypeEntry((TableNode*)$2), boo, "");
             }
         }
 
     |   expression ADD expression
 		{
             printdebug("add expression");
-            if((TableNode*)$1 == (TableNode*)$3 && (TableNode*)$1 == integ) {
-                $$=(TableNode*)$1; 
+            if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of binary operation
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression SUB_OR_NEG expression
         {
             printdebug("sub or neg expression");
-            if((TableNode*)$1 == (TableNode*)$3 && (TableNode*)$1 == integ) {
-                $$=(TableNode*)$1;
+            if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of binary operation
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression MUL expression
         {
             printdebug("multiply expression");
-            if((TableNode*)$1 == (TableNode*)$3 && (TableNode*)$1 == integ) {
-                $$=(TableNode*)$1;
-            } else{
+            if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of binary operation
+                $$ = node;
+            } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression DIV expression
         {
             printdebug("divide expression");
-            if((strcmp(getName((TableNode*)$1),getName((TableNode*)$3))==0) && ((TableNode*)$1 == integ)) {
-                $$=(TableNode*)$1;
+            if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of binary operation
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression REM expression
         {
             printdebug("remainder expression");
-            if($1 == $3 && $1 == integ) {
-                $$=$1;
+            if((getTypeEntry((TableNode*)$1) == getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == integ) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of binary operation
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression AND expression
         {
-            printdebug("AND expression");
-            if($1 == $3 && $1 == boo){
-                $$=$1;
-            } else{
+            printdebug("AND");
+            if((getTypeEntry((TableNode*)$1)==getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == boo) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of comparison
+                $$ = node;
+            } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression OR expression
 		{
             printdebug("OR");
-            if((strcmp(getName((TableNode*)$1),getName((TableNode*)$3))==0) && $1 == boo) {
-                $$=$1;
+            if((getTypeEntry((TableNode*)$1)==getTypeEntry((TableNode*)$3)) && getTypeEntry((TableNode*)$1) == boo) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of comparison
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
                     
     |   expression LESS_THAN expression 
 		{
             printdebug("less than expression");
-            if($1 == $3 && $1==integ) {
-                $$=boo;
+            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);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of comparison
+                $$ = node;
             } else {
                 $$=undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   expression EQUAL_TO expression
         {
             printdebug("equals check expression");
-            if($1 == $3 && $1 != undefined) {
-                $$=boo;
+            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);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                //result of compariosn
+                $$ = node;
+                
             } else {
                 $$ = undefined;
-                error_type((TableNode*)$1, (TableNode*)$3, "");
+                error_type(getTypeEntry((TableNode*)$1), getTypeEntry((TableNode*)$3), "");
             }
         }
 
     |   assignable
         {
-            printdebug("assignable expression. current type is %s",getName((TableNode*)$1));
-            if(getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE||
-                getAdInfoType((TableNode*)$1) == TYPE_ARRAY ||
-                getAdInfoType((TableNode*)$1) == TYPE_RECORD){
-                printdebug("assignable passing up to expression is primitive, array instance, or record instance. Passing up its type");
-                $$= getTypeEntry((TableNode*)$1);
-                }
-
-            else if(getAdInfoType((TableNode*)$1) == TYPE_ARRAY_TYPE||
-                getAdInfoType((TableNode*)$1) == TYPE_RECORD_TYPE||
-                getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_TYPE||
-                    getAdInfoType((TableNode*)$1) == TYPE_PRIMITIVE_TYPE ||
-                getAdInfoType((TableNode*)$1) == TYPE_FUNCTION_DECLARATION){
-                printdebug("assignable passing up to expression is array type, record type, function type, or function declaration");
-                $$= ((TableNode*)$1);
-                }
-            else {
-                error_type(undefined, undefined, "Invalid type passed to expression.");
-                $$= ((TableNode*)$1);
-            }
-    
+            $$ = $1;
         }
     
     |   L_PAREN expression R_PAREN
         {
-            printdebug("paren expression. current type is %s",getName((TableNode*)$2));
+            printdebug("paren expression. current type is %s",getType((TableNode*)$2));
             $$=$2;
         }
 
     |   memOp assignable
         {
             int d = getAdInfoType((TableNode*)$2);
-            if(d == TYPE_ARRAY_TYPE || d == TYPE_ARRAY || d == TYPE_RECORD_TYPE || d == TYPE_RECORD) {
-                $$ = addr;
+            if(d == TYPE_ARRAY ||d == TYPE_RECORD) {
+                char* temp = temp_var_gen();
+                TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, addr, temp, NULL);
+                //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+                $$ = node;
             } else {
                 error_type(undefined, undefined, "Invalid memOp expression (%s).", getName((TableNode*)$2));
                 $$=undefined;
@@ -788,8 +810,9 @@ expression:
 assignable:
         ID 
         {
-            $$ = getTypeEntry(look_up(cur,$1)); 
-            printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getName((TableNode*)$$), $1);
+            TableNode* pass = look_up(cur,$1);
+            $$ = pass; 
+            printdebug("[ASSIGNABLE - RULE 1] assignable = type: %s | ID = %s", getType(pass), getName(pass));
         }
 
     |   assignable 
@@ -797,22 +820,24 @@ assignable:
             printdebug("%sBeginning rule 2 of assignable.", COLOR_CYAN);
             cur = CreateScope(cur, -1,-1);
         }
+        //we have to consider emmissions in ablocks
         ablock 
         {
-            int type = getAdInfoType(look_up(getParent(cur), getName((TableNode*)$1)));
+            //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);
-                if (look_up(getParent(cur), getName((TableNode*)$1))->additionalinfo->FunDecAdInfo->regularoras) {
+                if (look_up(getParent(cur), getType((TableNode*)$1))->additionalinfo->FunDecAdInfo->regularoras) {
                     printdebug("as function");
                     //char *funtype = getType(look_up(cur, $1));
-//                    printdebug("%s", getType(look_up(cur, getName((TableNode*)$1))));
+                    //printdebug("%s", getType(look_up(cur, getName((TableNode*)$1))));
 
 
 
-                    TableNode * typeNode = $1;
+                    TableNode * typeNode = getTypeEntry((TableNode*)$1);
                     TableNode *param = getParameter(typeNode);
                     printTableNode(param);
 
@@ -853,7 +878,7 @@ assignable:
                         }
                     }
                 } else {
-                    char *expected = getName(getParameter(look_up(getParent(cur), getName((TableNode*)$1))));
+                    char *expected = getName(getParameter(look_up(getParent(cur), getType((TableNode*)$1))));
                     char *actual = getType(getFirstEntry(cur));
                     if (strcmp(expected, actual) != 0) {
                         printdebug("expected %s expression in function call but got %s at line %d and column %d",expected, actual, @3.first_line, @3.first_column);
@@ -862,29 +887,99 @@ assignable:
                         printdebug("expected 1 argument but got %d", $3);
                     }
                 }
-                printTableNode(getReturn($1));
-                $$ = getReturn($1);
-                printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName((TableNode*)$$), getName((TableNode*)$1));
+                printTableNode(getReturn(getTypeEntry((TableNode*)$1)));
+                //
+                char* temp = temp_var_gen();
+                TableNode* typeNode2 = getReturn(getTypeEntry($1));
+                int t = -1;
+                if(getAdInfoType(typeNode2) == TYPE_PRIMITIVE_TYPE){
+                    t = TYPE_PRIMITIVE;
+                }
+                else if(getAdInfoType(typeNode2) == TYPE_ARRAY_TYPE){
+                    t = TYPE_ARRAY;
+                }
+                else if(getAdInfoType(typeNode2) == TYPE_RECORD_TYPE){
+                    t = TYPE_RECORD;
+                }
+                else if(getAdInfoType(typeNode2) == TYPE_FUNCTION_TYPE){
+                    t = TYPE_FUNCTION_DECLARATION;
+                }else{
+                    t= TYPE_UNDEFINED;
+                    printdebug("CHANGE ME [TYPE CHECK] Undefined type stored in record. improper.");
+                }
+                TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
+                $$ = 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));
             
             } else if (type == TYPE_ARRAY_TYPE) {
                 printdebug("%sEntering array call", COLOR_LIGHTGREEN);
-                if (getNumArrDim(look_up(getParent(cur), getName((TableNode*)$1))) != $<integ>2) {
+                if (getNumArrDim(look_up(getParent(cur), getType((TableNode*)$1))) != $<integ>2) {
                     printdebug("expected %d arguments but had %d at line %d and column %d\n", getNumArrDim(look_up(cur, getName((TableNode*)$1))), $<integ>2, @2.first_line, @2.first_column);
                 }
-                $$ = getArrType(look_up(cur, getName((TableNode*)$1)));
-                printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName((TableNode*)$$), getName((TableNode*)$1));
-                printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getName((TableNode*)$$), getName((TableNode*)$1));
+
+                char* temp = temp_var_gen();
+                TableNode* typeNode2 = getArrType(look_up(getAncestor(cur), getType((TableNode*)$1)));
+                int t = -1;
+                if(getAdInfoType(typeNode2) == TYPE_PRIMITIVE_TYPE){
+                    t = TYPE_PRIMITIVE;
+                }
+                else if(getAdInfoType(typeNode2) == TYPE_ARRAY_TYPE){
+                    t = TYPE_ARRAY;
+                }
+                else if(getAdInfoType(typeNode2) == TYPE_RECORD_TYPE){
+                    t = TYPE_RECORD;
+                }
+                else if(getAdInfoType(typeNode2) == TYPE_FUNCTION_TYPE){
+                    t = TYPE_FUNCTION_DECLARATION;
+                }else{
+                    t= TYPE_UNDEFINED;
+                    printdebug("CHANGE ME [TYPE CHECK] Undefined type stored in record. improper.");
+                }
+                TableNode* node = CreateEntry(cur,t, typeNode2, temp, NULL);
+                //emit assign here
+                //emit_array_access(char* node, char* array, ...)
+                $$ = node;
+                printdebug("[ASSIGNABLE - RULE 2] assignable = type: %s | name_func = %s", getType((TableNode*)$1), getName((TableNode*)$1));
             }
             cur = getParent(cur);
         }
 
     |   assignable rec_op ID 
-        {
-            if(undefined != table_lookup(getRecList(table_lookup(getAncestor(cur), getName((TableNode*)$1))), $3)) {
+        {   
+            if(getAdInfoType((TableNode*)$1) != TYPE_RECORD_TYPE){
+                printdebug("CHANGE ME [TYPE CHECK]Invalid type passed to record access");
+            }
+            else if(undefined != table_lookup(getRecList(table_lookup(getAncestor(cur), getName(getTypeEntry((TableNode*)$1)))), $3)) {
 
-                $$ = table_lookup(getRecList(table_lookup(getAncestor(cur), getName((TableNode*)$1))), $3);
+                TableNode* type = table_lookup(getRecList(table_lookup(getAncestor(cur), getName(getTypeEntry((TableNode*)$1)))), $3);
+                char* temp = temp_var_gen();
+                int t = -1;
+                if(getAdInfoType(type) == TYPE_PRIMITIVE_TYPE){
+                    t = TYPE_PRIMITIVE;
+                }
+                else if(getAdInfoType(type) == TYPE_ARRAY_TYPE){
+                    t = TYPE_ARRAY;
+                }
+                else if(getAdInfoType(type) == TYPE_RECORD_TYPE){
+                    t = TYPE_RECORD;
+                }
+                else if(getAdInfoType(type) == TYPE_FUNCTION_TYPE){
+                    t = TYPE_FUNCTION_DECLARATION;
+                }else{
+                    t= TYPE_UNDEFINED;
+                    printdebug("CHANGE ME [TYPE CHECK] Undefined type stored in record. improper.");
+                }
+
+                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)  
+                $$=node;
+            }else{
+                printdebug("CHANGE ME [TYPE CHECK] undefined type (Field Access Lookup failed)");
+                $$=undefined;
             } 
-            printdebug("[ASSIGNABLE - RULE 3] assignable = type: %s | ID = %s", getName((TableNode*)($$)), getName($1));
+            printdebug("[ASSIGNABLE - RULE 3] record = name: %s | field = %s", getName((TableNode*)($1)), getName((TableNode*)$3));
         }
 
     ;
@@ -908,38 +1003,56 @@ memOp:
 constant:
         C_STRING
         {
-            $$ = $1;
-            printdebug("string of C_STRING in constant is %s",getName((TableNode*)$1));
+            char* temp = temp_var_gen();
+            TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, stri, temp, NULL);
+            //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+            printdebug("string of C_STRING in constant is %s", $1);
+            $$ = node;
         }
 
     |   C_INTEGER
         {
-            $$ = integ;
-            printdebug("string of C_INTEGER in constant is integer");
+            char* temp = temp_var_gen();
+            TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, integ, temp, NULL);
+            //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+            printdebug("number of C_INTEGER in constant is %d", $1);
+            $$ = node;
         }
     
     |   C_NULL
         {
-            $$ = $1;
-            printdebug("string of C_NULL in constant is %s",getName((TableNode*)$1));
+            char* temp = temp_var_gen();
+            TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, addr, temp, NULL);
+            //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+            printdebug("string of C_NULL in constant is NULL");
+            $$ = node;
         }
     
     |   C_CHARACTER
         {
-            $$ = $1;
-            printdebug("string of C_CHARACTER in constant is %s",getName((TableNode*)$1));
+            char* temp = temp_var_gen();
+            TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, chara, temp, NULL);
+            //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+            printdebug("string of C_CHARACTER in constant is %s",$1);
+            $$ = node;
         }
     
     |   C_TRUE
         {
-            $$ = $1;
-            printdebug("string of C_TRUE in constant is %s",getName((TableNode*)$1));
+            char* temp = temp_var_gen();
+            TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
+            //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+            printdebug("string of C_TRUE in constant is true");
+            $$ = node;
         }
     
     |   C_FALSE
         {
-            $$ = $1;
-            printdebug("string of C_FALSE in constant is %s",getName((TableNode*)$1));
+            char* temp = temp_var_gen();
+            TableNode* node = CreateEntry(cur,TYPE_PRIMITIVE, boo, temp, NULL);
+            //NOTE ADD ASSIGNMENT EMIT HERE (MIGHT NEED TO PUSH TO STACK)
+            printdebug("string of C_FALSE in constant is false");
+            $$ = node;
         }
     
     ;
diff --git a/src/lexicalStructure.lex b/src/lexicalStructure.lex
index e11ef39..5e54f55 100644
--- a/src/lexicalStructure.lex
+++ b/src/lexicalStructure.lex
@@ -83,8 +83,8 @@ SCHAR \\n|\\t|\\\"|[^\"\n\\]
 "->"             {if(DEBUG) {printf( "ARROW:        %s  (%d)\n", yytext, ARROW);}           else {if(tok_flag != NULL){print_tok(ARROW);}incr(line_number,column_number,ARROW);return ARROW;}}
 
 {DIGIT}+         {if(DEBUG) {printf( "C_INTEGER:    %s  (%d)\n", yytext, C_INTEGER);}       else {if(tok_flag != NULL){print_tok(C_INTEGER);}incr(line_number,column_number,C_INTEGER);yylval.integ = atoi(yytext)/*words = strdup("integer")*/;return C_INTEGER;}}
-'{CHAR}'         {if(DEBUG) {printf( "C_CHARACTER:  %s  (%d)\n", yytext, C_CHARACTER);}     else {if(tok_flag != NULL){print_tok(C_CHARACTER);}incr(line_number,column_number,C_CHARACTER);yylval.tn = chara;return C_CHARACTER;}}
-\"{SCHAR}*\"     {if(DEBUG) {printf( "C_STRING:     %s  (%d)\n", yytext, C_STRING);}        else {if(tok_flag != NULL){print_tok(C_STRING);}incr(line_number,column_number,C_STRING);yylval.tn = stri;return C_STRING;}}
+'{CHAR}'         {if(DEBUG) {printf( "C_CHARACTER:  %s  (%d)\n", yytext, C_CHARACTER);}     else {if(tok_flag != NULL){print_tok(C_CHARACTER);}incr(line_number,column_number,C_CHARACTER);char* token = strdup(yytext)/*yylval.tn = chara*/;yylval.letter = token[1];return C_CHARACTER;}}
+\"{SCHAR}*\"     {if(DEBUG) {printf( "C_STRING:     %s  (%d)\n", yytext, C_STRING);}        else {if(tok_flag != NULL){print_tok(C_STRING);}incr(line_number,column_number,C_STRING);int k = strlen(yytext);yytext[k-1] = '\0';yylval.words = strdup(&yytext[1]);return C_STRING;}}
 {COMMENT}        {if(DEBUG) {printf( "COMMENT:      %s  (%d)\n", yytext, COMMENT);}         else {if(tok_flag != NULL){print_tok(COMMENT);}incr(line_number,column_number,COMMENT);/*return COMMENT;*/}}
 
 "("              {if(DEBUG) {printf( "L_PAREN:      %s  (%d)\n", yytext, L_PAREN);}         else {if(tok_flag != NULL){print_tok(L_PAREN);}incr(line_number,column_number,L_PAREN);return L_PAREN;}}
diff --git a/src/symbol_table.c b/src/symbol_table.c
index 21669b5..de7d3f6 100644
--- a/src/symbol_table.c
+++ b/src/symbol_table.c
@@ -3,6 +3,9 @@
 
 #include "symbol_table.h"
 
+Constant_Stack* head = NULL;
+int temp2_count = 0;
+
 void printdebug_impl(char *file, int line, const char *format, ...) {
     if (DEBUG) {
         printf("%s<%s> [%d]%s ", COLOR_DARKGRAY, file, line,
@@ -15,6 +18,76 @@ void printdebug_impl(char *file, int line, const char *format, ...) {
     }
 }
 
+char * temp_var_gen(){
+    char * ret = calloc(9, sizeof(*ret));
+    sprintf(ret, "$t%d", temp2_count);
+    temp2_count++;
+    return ret;
+}
+
+Constant_Stack *Push(TableNode *type, void *value, bool isConst) {
+    if (type == NULL || type == undefined) {
+        printdebug(
+            "passed a NULL reference/undefined reference to "
+            "CreateConstantStack. Invalid.");
+        return NULL;
+    }
+    Constant_Stack *cs = (Constant_Stack *)malloc(sizeof(Constant_Stack));
+    cs->theType = type;
+    cs->theValue = value;
+    cs->isConst = isConst;
+    if(head == NULL){
+        head = cs;
+        cs->next = NULL;
+    }else{
+        cs->next = head;
+        head = cs;
+    }
+    return cs;
+}
+
+Constant_Stack *Pop() {
+    if (head == NULL) {
+        printf("cannot pop from an empty stack. Invalid.\n");
+        return NULL;
+    }
+    Constant_Stack *cs = head;
+    head = head->next;
+    printf("Popped something of type %s\n", getName(cs->theType));
+    return cs;
+}
+
+Constant_Stack* Print_Stack(){
+    if (head == NULL) {
+        printdebug("cannot print an empty stack. Invalid.");
+        return NULL;
+    }
+    Constant_Stack *cs = head;
+    while (cs != NULL) {
+        if(cs->theValue == NULL){
+            printf("Type: %s, Value: NULL", getName(cs->theType));
+        }
+        if(cs->theType == stri){
+            printf("Type: %s, Value: %s\n", getName(cs->theType), *(char*)(cs->theValue));
+        }
+        if(cs->theType == integ){
+            printf("Type: %s, Value: %d\n", getName(cs->theType), (int *)(cs->theValue));
+        }
+        if(cs->theType == chara){
+            printf("Type: %s, Value: %c\n", getName(cs->theType), *(char *)cs->theValue);
+        }
+        if(cs->theType == boo){
+            if(*(bool *)cs->theValue == true){
+                printf("Type: %s, Value: true\n", getName(cs->theType));}
+            else{
+                printf("Type: %s, Value: false\n", getName(cs->theType));
+            }
+        }
+        cs = cs->next;
+    }
+    return cs;
+    }
+
 // primitive additional info only stores the size of that type
 AdInfo *CreatePrimitiveInfo(int size) {
     AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));
diff --git a/src/symbol_table.h b/src/symbol_table.h
index 01d4458..6a41551 100644
--- a/src/symbol_table.h
+++ b/src/symbol_table.h
@@ -11,6 +11,13 @@
 
 struct TableNode;
 
+typedef struct Constant_Stack {
+    struct TableNode *theType;
+    void *theValue;
+    struct Constant_Stack *next;
+    bool isConst;
+} Constant_Stack;
+
 typedef struct {
     int size;
 } primitive_info;
@@ -141,7 +148,7 @@ extern int line_number;
 extern int column_number;
 extern FILE *yyin;
 extern bool DEBUG;
-
+extern int temp2_count;
 extern TableNode *funprime;
 extern TableNode *arrayprim;
 extern TableNode *integ;
@@ -152,6 +159,7 @@ extern TableNode *boo;
 extern TableNode *recprime;
 extern TableNode *funtypeprime;
 extern TableNode *undefined;
+extern Constant_Stack *head;
 
 extern char *COLOR_RED;
 extern char *COLOR_GREEN;
diff --git a/tests/sprint2/test/sp2_simple.alpha b/tests/sprint2/test/sp2_simple.alpha
index 58934e6..4042a5a 100644
--- a/tests/sprint2/test/sp2_simple.alpha
+++ b/tests/sprint2/test/sp2_simple.alpha
@@ -3,5 +3,5 @@ function entry: main
 
 entry(arg) := {
 	[integer : x]
-    return 0;
+    return 2;
 }
\ No newline at end of file