diff --git a/mm.c b/mm.c
index 1008be2..386a924 100644
--- a/mm.c
+++ b/mm.c
@@ -133,18 +133,18 @@ static void add_free(void* bp, size_t asize);
 ////////////////////////////////////////////////////////////////////////////////
 static void *extend_heap(size_t size)
 {
-  void *ptr;                   
-  size_t asize;                // Adjusted size 
-    
+  size_t asize;
   asize = ALIGN(size);
+  void *ptr;                   
     
   if ((ptr = mem_sbrk(asize)) == (void *)-1)
     return NULL;
     
-  // Set headers and footer 
+  /* Set Header and Footer*/
   PUTT(HDRP(ptr), PACK(asize, 0));  
   PUTT(FTRP(ptr), PACK(asize, 0));   
   PUTT(HDRP(NEXT_BLKP(ptr)), PACK(0, 1)); 
+
   add_free(ptr, asize);
 
   return coalesce(ptr);
@@ -152,77 +152,72 @@ static void *extend_heap(size_t size)
 
 static void add_free(void *ptr, size_t size) {
   int list = 0;
-  void *search_ptr = ptr;
-  void *insert_ptr = NULL;
+  void *searching_ptr = ptr;
+  void *in_ptr = NULL;
     
-  // Select segregated list 
+  /* Select List*/
   while ((list < LISTSIZE - 1) && (size > 1)) {
     size >>= 1;
     list++;
   }
     
-  // Keep size ascending order and search
-  search_ptr = seg_list[list];
-  while ((search_ptr != NULL) && (size > GET_SIZE(HDRP(search_ptr)))) {
-    insert_ptr = search_ptr;
-    search_ptr = PRV_BLK(search_ptr);
+  /* Search in size-ascending order*/
+  searching_ptr = seg_list[list];
+  while ((searching_ptr != NULL) && (size > GET_SIZE(HDRP(searching_ptr)))) {
+    in_ptr = searching_ptr;
+    searching_ptr = PRV_BLK(searching_ptr);
   }
     
-  // Set predecessor and successor 
-  if (search_ptr != NULL) {
-    if (insert_ptr != NULL) {
-      PUT_PTR(PRV_PTR(ptr), search_ptr);
-      PUT_PTR(NXT_PTR(search_ptr), ptr);
-      PUT_PTR(NXT_PTR(ptr), insert_ptr);
-      PUT_PTR(PRV_PTR(insert_ptr), ptr);
-    } else {
-      PUT_PTR(PRV_PTR(ptr), search_ptr);
-      PUT_PTR(NXT_PTR(search_ptr), ptr);
-      PUT_PTR(NXT_PTR(ptr), NULL);
-      seg_list[list] = ptr;
-    }
-  } else {
-    if (insert_ptr != NULL) {
-      PUT_PTR(PRV_PTR(ptr), NULL);
-      PUT_PTR(NXT_PTR(ptr), insert_ptr);
-      PUT_PTR(PRV_PTR(insert_ptr), ptr);
-    } else {
-      PUT_PTR(PRV_PTR(ptr), NULL);
-      PUT_PTR(NXT_PTR(ptr), NULL);
-      seg_list[list] = ptr;
-    }
+  /* Set previous and next*/
+  if (searching_ptr != NULL && in_ptr != NULL) {
+    PUT_PTR(NXT_PTR(searching_ptr), ptr);
+    PUT_PTR(NXT_PTR(ptr), in_ptr);
+    PUT_PTR(PRV_PTR(ptr), searching_ptr);
+    PUT_PTR(PRV_PTR(in_ptr), ptr);
+    } 
+  else if (searching_ptr != NULL && in_ptr == NULL) {
+    PUT_PTR(PRV_PTR(ptr), searching_ptr);
+    PUT_PTR(NXT_PTR(searching_ptr), ptr);
+    PUT_PTR(NXT_PTR(ptr), NULL);
+    seg_list[list] = ptr;
+  } 
+  else if(searching_ptr == NULL && in_ptr != NULL) {
+    PUT_PTR(NXT_PTR(ptr), in_ptr);
+    PUT_PTR(PRV_PTR(ptr), NULL);
+    PUT_PTR(PRV_PTR(in_ptr), ptr);
+  } 
+  else {
+    PUT_PTR(NXT_PTR(ptr), NULL);
+    PUT_PTR(PRV_PTR(ptr), NULL);
+    seg_list[list] = ptr;
   }
     
   return;
 }
 
 
-static void delete_node(void *ptr) {
+static void remove_free(void *ptr) {
   int list = 0;
   size_t size = GET_SIZE(HDRP(ptr));
     
-  // Select segregated list 
+  /* Select List*/
   while ((list < LISTSIZE - 1) && (size > 1)) {
     size >>= 1;
     list++;
   }
     
-  if (PRV_BLK(ptr) != NULL) {
-    if (NXT_BLK(ptr) != NULL) {
-      PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NXT_BLK(ptr));
-      PUT_PTR(PRV_PTR(NXT_BLK(ptr)), PRV_BLK(ptr));
-    } else {
-      PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NULL);
-      seg_list[list] = PRV_BLK(ptr);
-    }
+  if (PRV_BLK(ptr) != NULL && NXT_BLK(ptr) != NULL) {
+    PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NXT_BLK(ptr));
+    PUT_PTR(PRV_PTR(NXT_BLK(ptr)), PRV_BLK(ptr));
+  } else if(PRV_BLK(ptr) != NULL && NXT_BLK(ptr) == NULL) {
+    PUT_PTR(NXT_PTR(PRV_BLK(ptr)), NULL);
+    seg_list[list] = PRV_BLK(ptr);
+  } 
+  else if(PRV_BLK(ptr) == NULL && NXT_BLK(ptr) != NULL) {
+    PUT_PTR(PRV_PTR(NXT_BLK(ptr)), NULL);
   } else {
-    if (NXT_BLK(ptr) != NULL) {
-      PUT_PTR(PRV_PTR(NXT_BLK(ptr)), NULL);
-    } else {
-      seg_list[list] = NULL;
-    }
-  }
-    
+    seg_list[list] = NULL;
+  }  
   return;
 }
 
@@ -238,22 +233,22 @@ static void *coalesce(void *ptr)
     return ptr;
   }
   else if (prev_alloc && !next_alloc) {                   // Case 2
-    delete_node(ptr);
-    delete_node(NEXT_BLKP(ptr));
+    remove_free(ptr);
+    remove_free(NEXT_BLKP(ptr));
     size += GET_SIZE(HDRP(NEXT_BLKP(ptr)));
     PUT(HDRP(ptr), PACK(size, 0));
     PUT(FTRP(ptr), PACK(size, 0));
   } else if (!prev_alloc && next_alloc) {                 // Case 3 
-    delete_node(ptr);
-    delete_node(PREV_BLKP(ptr));
+    remove_free(ptr);
+    remove_free(PREV_BLKP(ptr));
     size += GET_SIZE(HDRP(PREV_BLKP(ptr)));
     PUT(FTRP(ptr), PACK(size, 0));
     PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0));
     ptr = PREV_BLKP(ptr);
   } else {                                                // Case 4
-    delete_node(ptr);
-    delete_node(PREV_BLKP(ptr));
-    delete_node(NEXT_BLKP(ptr));
+    remove_free(ptr);
+    remove_free(PREV_BLKP(ptr));
+    remove_free(NEXT_BLKP(ptr));
     size += GET_SIZE(HDRP(PREV_BLKP(ptr))) + GET_SIZE(HDRP(NEXT_BLKP(ptr)));
     PUT(HDRP(PREV_BLKP(ptr)), PACK(size, 0));
     PUT(FTRP(NEXT_BLKP(ptr)), PACK(size, 0));
@@ -270,7 +265,7 @@ static void *place(void *ptr, size_t asize)
   size_t ptr_size = GET_SIZE(HDRP(ptr));
   size_t remainder = ptr_size - asize;
     
-  delete_node(ptr);
+  remove_free(ptr);
     
     
   if (remainder <= DSIZE * 2) {