diff --git a/parser.c b/parser.c
index 02bae8e..06728d7 100644
--- a/parser.c
+++ b/parser.c
@@ -27,7 +27,7 @@ int* getFirsts(char * input){
     ssize_t read;
 
 
-    int firsts[25];
+    int *firsts = malloc(25*sizeof(int*));
 
     FILE *fp = fopen("firsts.txt", "r");
     if (fp == NULL){
@@ -64,7 +64,7 @@ int* getFirsts(char * input){
 
 // returns firsts set of given set of tokens
 int* first(char * input){
-    int firsts[1000];
+    int *firsts = malloc(100 * sizeof(int*)); 
     int* current;
     int count = 0;
     char * token;
@@ -111,7 +111,7 @@ int* getFollows(char * input){
     int count = 0;
     ssize_t read;
 
-    int follows[25];
+    int * follows = malloc(sizeof(int*)*25); 
 
     FILE *fp = fopen("follows.txt", "r");
     if (fp == NULL){
@@ -235,118 +235,227 @@ int getRowIndex(char* s)
 
 // returns token name for given id
 char* getCorrespondingToken(int f){
+	char * token = malloc(100);
     switch(f){
-        case 1: return "TK_ASSIGNOP";
-        case 2: return "TK_COMMENT";
-        case 3: return "TK_FIELDID";
-        case 4: return "TK_ID";
-        case 5: return "TK_NUM";
-        case 6: return "TK_RNUM";
-        case 7: return "TK_FUNID";
-        case 8: return "TK_RECORDID";
-        case 9: return "TK_WITH";
-        case 10: return "TK_PARAMETERS";
-        case 11: return "TK_END";
-        case 12: return "TK_WHILE";
-        case 13: return "TK_INT";
-        case 14: return "TK_REAL";
-        case 15: return "TK_TYPE";
-        case 16: return "TK_MAIN";
-        case 17: return "TK_GLOBAL";
-        case 18: return "TK_PARAMETER";
-        case 19: return "TK_LIST";
-        case 20: return "TK_SQL";
-        case 21: return "TK_SQR";
-        case 22: return "TK_INPUT";
-        case 23: return "TK_OUTPUT";
-        case 24: return "TK_INT";
-        case 25: return "TK_REAL";
-        case 26: return "TK_SEM";
-        case 27: return "TK_COLON";
-        case 28: return "TK_DOT";
-        case 29: return "TK_ENDWHILE";
-        case 30: return "TK_OP";
-        case 31: return "TK_CL";
-        case 32: return "TK_IF";
-        case 33: return "TK_THEN";
-        case 34: return "TK_ENDIF";
-        case 35: return "TK_READ";
-        case 36: return "TK_WRITE";
-        case 37: return "TK_RETURN";
-        case 38: return "TK_PLUS";
-        case 39: return "TK_MINUS";
-        case 40: return "TK_MUL";
-        case 41: return "TK_DIV";
-        case 42: return "TK_CALL";
-        case 43: return "TK_RECORD";
-        case 44: return "TK_ENDRECORD";
-        case 45: return "TK_ELSE";
-        case 46: return "TK_AND";
-        case 47: return "TK_OR";
-        case 48: return "TK_NOT";
-        case 49: return "TK_LT";
-        case 50: return "TK_LE";
-        case 51: return "TK_EQ";
-        case 52: return "TK_GT";
-        case 53: return "TK_GE";
-        case 54: return "TK_NE";
-        case 55: return "$";
-        case 56: return "TK_COMMA";
-        case 57: return "eps";
+        case 1: strcpy(token, "TK_ASSIGNOP");
+			break;
+        case 2: strcpy(token, "TK_COMMENT");
+			break;
+        case 3: strcpy(token, "TK_FIELDID");
+			break;
+        case 4: strcpy(token, "TK_ID");
+			break;
+        case 5: strcpy(token, "TK_NUM");
+			break;
+        case 6: strcpy(token, "TK_RNUM");
+			break;
+        case 7: strcpy(token, "TK_FUNID");
+			break;
+        case 8: strcpy(token, "TK_RECORDID");
+			break;
+        case 9: strcpy(token, "TK_WITH");
+			break;
+        case 10: strcpy(token, "TK_PARAMETERS");
+			break;
+        case 11: strcpy(token, "TK_END");
+			break;
+        case 12: strcpy(token, "TK_WHILE");
+			break;
+        case 13: strcpy(token, "TK_INT");
+			break;
+        case 14: strcpy(token, "TK_REAL");
+			break;
+        case 15: strcpy(token, "TK_TYPE");
+			break;
+        case 16: strcpy(token, "TK_MAIN");
+			break;
+        case 17: strcpy(token, "TK_GLOBAL");
+			break;
+        case 18: strcpy(token, "TK_PARAMETER");
+			break;
+        case 19: strcpy(token, "TK_LIST");
+			break;
+        case 20: strcpy(token, "TK_SQL");
+			break;
+        case 21: strcpy(token, "TK_SQR");
+			break;
+        case 22: strcpy(token, "TK_INPUT");
+			break;
+        case 23: strcpy(token, "TK_OUTPUT");
+			break;
+        case 24: strcpy(token, "TK_INT");
+			break;
+        case 25: strcpy(token, "TK_REAL");
+			break;
+        case 26: strcpy(token, "TK_SEM");
+			break;
+        case 27: strcpy(token, "TK_COLON");
+			break;
+        case 28: strcpy(token, "TK_DOT");
+			break;
+        case 29: strcpy(token, "TK_ENDWHILE");
+			break;
+        case 30: strcpy(token, "TK_OP");
+			break;
+        case 31: strcpy(token, "TK_CL");
+			break;
+        case 32: strcpy(token, "TK_IF");
+			break;
+        case 33: strcpy(token, "TK_THEN");
+			break;
+        case 34: strcpy(token, "TK_ENDIF");
+			break;
+        case 35: strcpy(token, "TK_READ");
+			break;
+        case 36: strcpy(token, "TK_WRITE");
+			break;
+        case 37: strcpy(token, "TK_RETURN");
+			break;
+        case 38: strcpy(token, "TK_PLUS");
+			break;
+        case 39: strcpy(token, "TK_MINUS");
+			break;
+        case 40: strcpy(token, "TK_MUL");
+			break;
+        case 41: strcpy(token, "TK_DIV");
+			break;
+        case 42: strcpy(token, "TK_CALL");
+			break;
+        case 43: strcpy(token, "TK_RECORD");
+			break;
+        case 44: strcpy(token, "TK_ENDRECORD");
+			break;
+        case 45: strcpy(token, "TK_ELSE");
+			break;
+        case 46: strcpy(token, "TK_AND");
+			break;
+        case 47: strcpy(token, "TK_OR");
+			break;
+        case 48: strcpy(token, "TK_NOT");
+			break;
+        case 49: strcpy(token, "TK_LT");
+			break;
+        case 50: strcpy(token, "TK_LE");
+			break;
+        case 51: strcpy(token, "TK_EQ");
+			break;
+        case 52: strcpy(token, "TK_GT");
+			break;
+        case 53: strcpy(token, "TK_GE");
+			break;
+        case 54: strcpy(token, "TK_NE");
+			break;
+        case 55: strcpy(token, "$");
+			break;
+        case 56: strcpy(token, "TK_COMMA");
+			break;
+        case 57: strcpy(token, "eps");
+			break;
 
         // non-terminals below!
 
-        case 100: return "program";
-        case 101: return "mainFunction";
-        case 102: return "otherFunctions";
-        case 103: return "function";
-        case 104: return "input_par";
-        case 105: return "output_par";
-        case 106: return "parameter_list";
-        case 107: return "dataType";
-        case 108: return "primitiveDatatype";
-        case 109: return "constructedDatatype";
-        case 110: return "remaining_list";
-        case 111: return "stmts";
-        case 112: return "typeDefinitions";
-        case 113: return "typeDefinition";
-        case 114: return "fieldDefinitions";
-        case 115: return "fieldDefinition";
-        case 116: return "moreFields";
-        case 117: return "declarations";
-        case 118: return "declaration";
-        case 119: return "global_or_not";
-        case 120: return "otherStmts";
-        case 121: return "stmt";
-        case 122: return "assignmentStmt";
-        case 123: return "singleOrRecId";
-        case 124: return "funCallStmt";
-        case 125: return "outputParameters";
-        case 126: return "inputParameters";
-        case 127: return "iterativeStmt";
-        case 128: return "conditionalStmt";
-        case 129: return "elsePart";
-        case 130: return "ioStmt";
-        case 131: return "allVar";
-        case 132: return "arithmeticExpression";
-        case 133: return "expPrime";
-        case 134: return "term";
-        case 135: return "termPrime";
-        case 136: return "factor";
-        case 137: return "highPrecedenceOperators";
-        case 138: return "lowPrecedenceOperators";
-        case 139: return "all";
-        case 140: return "temp";
-        case 141: return "booleanExpression";
-        case 142: return "var";
-        case 143: return "logicalOp";
-        case 144: return "relationalOp";
-        case 145: return "returnStmt";
-        case 146: return "optionalReturn";
-        case 147: return "idList";
-        case 148: return "more_ids";
-        case 149: return "new24";
-        case 150: return "newVar";
+        case 100: strcpy(token, "program");
+			break;
+        case 101: strcpy(token, "mainFunction");
+			break;
+        case 102: strcpy(token, "otherFunctions");
+			break;
+        case 103: strcpy(token, "function");
+			break;
+        case 104: strcpy(token, "input_par");
+			break;
+        case 105: strcpy(token, "output_par");
+			break;
+        case 106: strcpy(token, "parameter_list");
+			break;
+        case 107: strcpy(token, "dataType");
+			break;
+        case 108: strcpy(token, "primitiveDatatype");
+			break;
+        case 109: strcpy(token, "constructedDatatype");
+			break;
+        case 110: strcpy(token, "remaining_list");
+			break;
+        case 111: strcpy(token, "stmts");
+			break;
+        case 112: strcpy(token, "typeDefinitions");
+			break;
+        case 113: strcpy(token, "typeDefinition");
+			break;
+        case 114: strcpy(token, "fieldDefinitions");
+			break;
+        case 115: strcpy(token, "fieldDefinition");
+			break;
+        case 116: strcpy(token, "moreFields");
+			break;
+        case 117: strcpy(token, "declarations");
+			break;
+        case 118: strcpy(token, "declaration");
+			break;
+        case 119: strcpy(token, "global_or_not");
+			break;
+        case 120: strcpy(token, "otherStmts");
+			break;
+        case 121: strcpy(token, "stmt");
+			break;
+        case 122: strcpy(token, "assignmentStmt");
+			break;
+        case 123: strcpy(token, "singleOrRecId");
+			break;
+        case 124: strcpy(token, "funCallStmt");
+			break;
+        case 125: strcpy(token, "outputParameters");
+			break;
+        case 126: strcpy(token, "inputParameters");
+			break;
+        case 127: strcpy(token, "iterativeStmt");
+			break;
+        case 128: strcpy(token, "conditionalStmt");
+			break;
+        case 129: strcpy(token, "elsePart");
+			break;
+        case 130: strcpy(token, "ioStmt");
+			break;
+        case 131: strcpy(token, "allVar");
+			break;
+        case 132: strcpy(token, "arithmeticExpression");
+			break;
+        case 133: strcpy(token, "expPrime");
+			break;
+        case 134: strcpy(token, "term");
+			break;
+        case 135: strcpy(token, "termPrime");
+			break;
+        case 136: strcpy(token, "factor");
+			break;
+        case 137: strcpy(token, "highPrecedenceOperators");
+			break;
+        case 138: strcpy(token, "lowPrecedenceOperators");
+			break;
+        case 139: strcpy(token, "all");
+			break;
+        case 140: strcpy(token, "temp");
+			break;
+        case 141: strcpy(token, "booleanExpression");
+			break;
+        case 142: strcpy(token, "var");
+			break;
+        case 143: strcpy(token, "logicalOp");
+			break;
+        case 144: strcpy(token, "relationalOp");
+			break;
+        case 145: strcpy(token, "returnStmt");
+			break;
+        case 146: strcpy(token, "optionalReturn");
+			break;
+        case 147: strcpy(token, "idList");
+			break;
+        case 148: strcpy(token, "more_ids");
+			break;
+        case 149: strcpy(token, "new24");
+			break;
+        case 150: strcpy(token, "newVar");
+			break;
         default:
                 {
                     char buf[12];
@@ -354,6 +463,7 @@ char* getCorrespondingToken(int f){
                     return buf;
                 }
     }
+    return token;
 }
 // returns token id for terminals
 int getColumnIndex(char* s)
diff --git a/parser.h b/parser.h
index d1d8198..9fa85b7 100644
--- a/parser.h
+++ b/parser.h
@@ -28,6 +28,8 @@ void intializeTable(table T);
 
 int printParseTree_r(parseTree curr, FILE* f, int * size, int print);
 
+char* getCorrespondingToken(int f);
+
 int error_in_parsing;
 
 #endif