void *vlad_malloc(u_int32_t n)
{

   /* For some reason there is a bug in this function where if you allocate to a
      different pointer the same size as a previous allocation,
      it will overwrite the original pointer.
      Changed code so program aborts if a header is overwritten.
      Why is this happening and how can I fix it?

      Also have a bug where in some cases max allocation I can make is to
      the Node space directly after my allocated spaces.
         Free
            1. 256 bytes
            2. 512 bytes
            3. 2048 bytes
      Can only allocate max 256 bytes.
      Why is this and how can I fix this?
       */

   int areaSize = HEADER_SIZE + n;
   int loop = 0;

   /* Negative n and Zero n case */
   if (n == 0) {
      return NULL;
   }

   if ((int)n < 0) {
      return NULL;
   }

   free_header_t * currHeader = iToP(free_list_ptr);

   //to traverse free list until find something it can fit in to.
   while (areaSize >= currHeader->size) {
      currHeader = iToP(currHeader->next);
      printf ("HELLO %p\n", currHeader);
      loop += 1;
      printf ("loop is now %d\n", loop);

      if (currHeader->next == free_list_ptr) {
         return NULL;
      }
   }



   //splitting

   if (currHeader->size >= areaSize) {
      while ((currHeader->size)/2 >= areaSize) {
         currHeader->size = (currHeader->size)/2;

         free_header_t *newHeader = iToP(currHeader->size);
         free_header_t *nextHeader = iToP(currHeader->next);

         newHeader->magic = MAGIC_FREE;
         newHeader->size = currHeader->size;
         newHeader->next = currHeader->next;
         newHeader->prev = nextHeader->prev;

         printf ("newHeader->next is at %d\n", newHeader->next);
         printf ("nextHeader->prev is at %d\n", nextHeader->prev);
         printf ("currHeader is at %d\n", newHeader->prev);

         assert (currHeader->magic == MAGIC_FREE);

         currHeader->next = newHeader->prev + currHeader->size; //curr->next = new;
         nextHeader->prev = currHeader->next; //nextHeader->prev = new;

      }

      if (currHeader->magic == MAGIC_ALLOC) {
         fprintf(stderr, "Memory corruption\n");
         abort();
      } else {
         currHeader->magic = MAGIC_ALLOC;
         free_header_t *next = iToP(currHeader->next);
         free_header_t *prev = iToP(currHeader->prev);

         next->prev = currHeader->prev;
         prev->next = currHeader->next;

      }

      //increment freelistptr here. Should only do it if the thing you just
      //allocated was the freelistptr
      if(loop != 1){
        free_list_ptr = currHeader->next;
      }

      printf ("free_list_ptr is at %d\n", free_list_ptr);

   }

   if ((currHeader->next == currHeader->prev) &&
        (currHeader->next == (byte*)currHeader - (byte*)memory)) {
       return NULL;
   } else {
      return ((void *)currHeader + HEADER_SIZE);
   }

}