diff --git a/symbol_table.c b/symbol_table.c
index 1a2e375..48a7a42 100644
--- a/symbol_table.c
+++ b/symbol_table.c
@@ -1,156 +1,143 @@
+#include "symbol_table.h"
+
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "symbol_table.h"
-
-SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column){
-        SymbolTable* table = (SymbolTable*)malloc(sizeof(SymbolTable));
-        table->Line_Number = Line;
-        table->Column_Number = Column;
-        table->Parent_Scope = ParentScope;
-        table->Children_Scope = NULL;
-        table->entries = NULL;
-        if(ParentScope != NULL){
-        if(ParentScope->Children_Scope == NULL){
-               ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
-               newEntry->next = NULL;
-               //newEntry->prev = NULL;
-               newEntry->table = table;
-               ParentScope->Children_Scope = newEntry;
-               } else{
-                    ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
-                    //newEntry->prev = NULL;
-                    newEntry->table= table;
-                    ListOfTable* oldEntry = ParentScope->Children_Scope;
-                    ParentScope->Children_Scope = newEntry;
-                    newEntry->next = oldEntry;
-                }
-          }
-            return table;
-          }
-
-
-TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id){
-         TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode));
-         newEntry->theType = typeOf;
-         newEntry->theName = id;
-        if(table->entries == NULL){
-                table->entries = newEntry;
-                return newEntry;
-        } else{
-                TableNode* oldEntry = table->entries;
-                table->entries = newEntry;
-                newEntry->next = oldEntry;
-                return newEntry;
-        }
-}
-TableNode * table_lookup(SymbolTable * table, char * x){
-        TableNode * entrie = table->entries;
-        for(; entrie != NULL; entrie = entrie->next){
-                if (!strcmp(entrie->theName, x)){
-                        return entrie;
-                }
-        }
-        return NULL;
-}
-TableNode * look_up(SymbolTable * table, char * x){
-        if(table == NULL){
-                return NULL;
-        }
-        TableNode * ret = table_lookup(table, x);
-        if (ret != NULL){
-                return ret;
-        }
-        return look_up(table->Parent_Scope, x);
+SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column) {
+  SymbolTable* table = (SymbolTable*)malloc(sizeof(SymbolTable));
+  table->Line_Number = Line;
+  table->Column_Number = Column;
+  table->Parent_Scope = ParentScope;
+  table->Children_Scope = NULL;
+  table->entries = NULL;
+  if (ParentScope != NULL) {
+    if (ParentScope->Children_Scope == NULL) {
+      ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
+      newEntry->next = NULL;
+      // newEntry->prev = NULL;
+      newEntry->table = table;
+      ParentScope->Children_Scope = newEntry;
+    } else {
+      ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
+      // newEntry->prev = NULL;
+      newEntry->table = table;
+      ListOfTable* oldEntry = ParentScope->Children_Scope;
+      ParentScope->Children_Scope = newEntry;
+      newEntry->next = oldEntry;
+    }
+  }
+  return table;
 }
 
-SymbolTable * getAncestor(SymbolTable * table){
-	if(table->Parent_Scope == NULL){
-		//if table has no parent, return itself
-		return table;
-	} else {
-		//call function recursively to grab ancestor
-		return getAncestor(table->Parent_Scope);
-	}
+TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id) {
+  TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode));
+  newEntry->theType = typeOf;
+  newEntry->theName = id;
+  if (table->entries == NULL) {
+    table->entries = newEntry;
+    return newEntry;
+  } else {
+    TableNode* oldEntry = table->entries;
+    table->entries = newEntry;
+    newEntry->next = oldEntry;
+    return newEntry;
+  }
 }
-void print_symbol_table(SymbolTable *table, FILE *file_ptr){
-        if(table->Parent_Scope == NULL){
-                fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE", "PARENT", "TYPE", "Extra annotation");
-        }
-        TableNode * entrie = table->entries;
-        fprintf(file_ptr, "-----------------:--------:--------:----------------------:-----------------------------\n");
-        int parant_scope = 0;
-        int current_scope = 0;
-        if(table->Parent_Scope != NULL){
-                parant_scope = table->Parent_Scope->Line_Number*1000 + table->Parent_Scope->Column_Number;
-                current_scope = table->Line_Number*1000 + table->Column_Number;
-        } else {
-                current_scope = 1001;
-        }
-
-        for(; entrie != NULL; entrie = entrie->next){
-                if (parant_scope == 0){
-                        fprintf(file_ptr, "%-17s: %06d :        : %-21s: %-28s\n",
-                                        entrie->theName, current_scope,
-                                        entrie->theType, "Extra annotation");
-                } else {
-                        fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n",
-                                        entrie->theName, current_scope, parant_scope,
-                                        entrie->theType, "Extra annotation");
-                }
-        }
-        if (table->Children_Scope != NULL){
-                ListOfTable* node = table->Children_Scope;
-                for(; node != NULL; node = node->next){
-                        print_symbol_table(node->table, file_ptr);
-                }
-        }
-        if (table->Parent_Scope == NULL) {
-                fprintf(file_ptr, "-----------------:--------:--------:----------------------:-----------------------------\n");
-        }
+TableNode* table_lookup(SymbolTable* table, char* x) {
+  TableNode* entrie = table->entries;
+  for (; entrie != NULL; entrie = entrie->next) {
+    if (!strcmp(entrie->theName, x)) {
+      return entrie;
+    }
+  }
+  return NULL;
+}
+TableNode* look_up(SymbolTable* table, char* x) {
+  if (table == NULL) {
+    return NULL;
+  }
+  TableNode* ret = table_lookup(table, x);
+  if (ret != NULL) {
+    return ret;
+  }
+  return look_up(table->Parent_Scope, x);
 }
 
-SymbolTable * getParent(SymbolTable* st){
-	return st->Parent_Scope;
-	}
+void print_symbol_table(SymbolTable* table, FILE* file_ptr) {
+  if (table->Parent_Scope == NULL) {
+    fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE",
+            "PARENT", "TYPE", "Extra annotation");
+  }
+  TableNode* entrie = table->entries;
+  fprintf(file_ptr,
+          "-----------------:--------:--------:----------------------:---------"
+          "--------------------\n");
+  int parant_scope = 0;
+  int current_scope = 0;
+  if (table->Parent_Scope != NULL) {
+    parant_scope = table->Parent_Scope->Line_Number * 1000 +
+                   table->Parent_Scope->Column_Number;
+    current_scope = table->Line_Number * 1000 + table->Column_Number;
+  } else {
+    current_scope = 1001;
+  }
 
-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 * getNextEntry(TableNode * tn){
-	return tn->next;
-	}
-char * getType(TableNode * tn){
-	return tn->theType;
-	}
-char * getName(TableNode * tn){
-        return tn->theName;
-        }
-int getLine(SymbolTable * st){
-	return st->Line_Number;
-	}
-int getColumn(SymbolTable *st){
-	return st->Column_Number;
-	}
-//uncomment the below main function along with the headers above for a simple standalone test of table and entry creation
+  for (; entrie != NULL; entrie = entrie->next) {
+    if (parant_scope == 0) {
+      fprintf(file_ptr, "%-17s: %06d :        : %-21s: %-28s\n",
+              entrie->theName, current_scope, entrie->theType,
+              "Extra annotation");
+    } else {
+      fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", entrie->theName,
+              current_scope, parant_scope, entrie->theType, "Extra annotation");
+    }
+  }
+  if (table->Children_Scope != NULL) {
+    ListOfTable* node = table->Children_Scope;
+    for (; node != NULL; node = node->next) {
+      print_symbol_table(node->table, file_ptr);
+    }
+  }
+  if (table->Parent_Scope == NULL) {
+    fprintf(file_ptr,
+            "-----------------:--------:--------:----------------------:-------"
+            "----------------------\n");
+  }
+}
+
+SymbolTable* getAncestor(SymbolTable* table) {
+  if (table->Parent_Scope == NULL) {
+    // if table has no parent, return itself
+    return table;
+  } else {
+    // call function recursively to grab ancestor
+    return getAncestor(table->Parent_Scope);
+  }
+}
+
+SymbolTable* getParent(SymbolTable* st) { return st->Parent_Scope; }
+
+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* getNextEntry(TableNode* tn) { return tn->next; }
+char* getType(TableNode* tn) { return tn->theType; }
+char* getName(TableNode* tn) { return tn->theName; }
+int getLine(SymbolTable* st) { return st->Line_Number; }
+int getColumn(SymbolTable* st) { return st->Column_Number; }
+// uncomment the below main function along with the headers above for a simple
+// standalone test of table and entry creation
 
 /*
 int main(){
         char* String = "STRING";
         char* X = "X";
         SymbolTable* Second = CreateScope(NULL, 2,2);
-        printf("Line number is %d, Column number of scope is %d\n",Second->Line_Number,Second->Column_Number);
-        TableNode* First_Entry = CreateEntry(Second,String,X);
+        printf("Line number is %d, Column number of scope is
+%d\n",Second->Line_Number,Second->Column_Number); TableNode* First_Entry =
+CreateEntry(Second,String,X);
 
         printf("The type of the first entry is %s\n",First_Entry->theType);
         return 0;
diff --git a/symbol_table.h b/symbol_table.h
index 0d30f59..0ef5c8a 100644
--- a/symbol_table.h
+++ b/symbol_table.h
@@ -3,30 +3,41 @@
 #include <stdlib.h>
 #include <string.h>
 
-typedef struct ListOfTable{
-        struct SymbolTable* table;
-        //struct ListOfTable* prev;
-        struct ListOfTable* next;
+typedef struct ListOfTable {
+  struct SymbolTable* table;
+  // struct ListOfTable* prev;
+  struct ListOfTable* next;
 
-}ListOfTable;
+} ListOfTable;
 
-typedef struct TableNode{
-        char* theType;
-        char* theName;
-        struct TableNode* next;
-}TableNode;
+typedef struct TableNode {
+  char* theType;
+  char* theName;
+  struct TableNode* next;
+} TableNode;
 
-typedef struct SymbolTable{
-       TableNode* entries;
-       struct SymbolTable* Parent_Scope;
-       struct ListOfTable* Children_Scope;
-       int Line_Number;
-       int Column_Number;
-}SymbolTable;
+typedef struct SymbolTable {
+  TableNode* entries;
+  struct SymbolTable* Parent_Scope;
+  struct ListOfTable* Children_Scope;
+  int Line_Number;
+  int Column_Number;
+} SymbolTable;
 
-
-TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id);
 SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column);
-TableNode * table_lookup(SymbolTable * table, char * x);
-TableNode * look_up(SymbolTable * table, char * x);
-void print_symbol_table(SymbolTable *table, FILE *file_ptr);
+TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id);
+TableNode* table_lookup(SymbolTable* table, char* x);
+TableNode* look_up(SymbolTable* table, char* x);
+void print_symbol_table(SymbolTable* table, FILE* file_ptr);
+
+SymbolTable* getAncestor(SymbolTable* table);
+SymbolTable* getParent(SymbolTable* st);
+ListOfTable* getChildren(SymbolTable* st);
+SymbolTable* getFirstChild(ListOfTable* lt);
+ListOfTable* getRestOfChildren(ListOfTable* lt);
+TableNode* getFirstEntry(SymbolTable* st);
+TableNode* getNextEntry(TableNode* tn);
+char* getType(TableNode* tn);
+char* getName(TableNode* tn);
+int getLine(SymbolTable* st);
+int getColumn(SymbolTable* st);
\ No newline at end of file