void *vlad_malloc(u_int32_t n)
{
        int required_mem_size = n + HEADER_SIZE;
    required_mem_size = makePow2(required_mem_size);
        if ((required_mem_size <= memory_size) && (n >= 8)) { //make sure there's enough memory
        free_header_t *curr = (free_header_t *)((byte *)memory + free_list_ptr); // "start" of list
        int i = 0;
        while ((curr != (free_header_t *)((byte *)memory + free_list_ptr)) || (i == 0)) {
            i = 1;
            if (curr->size == required_mem_size) {
                //remove the block from free list
                                if ((curr->prev == curr->next) && (curr->prev == ((byte *)curr - (byte *)memory)))
                    return NULL;
                else
                    ((free_header_t *)((curr->prev) + (byte *)memory))->next = curr->next;
                    ((free_header_t *)((curr->next) + (byte *)memory))->prev = curr->prev;
                    curr->magic = MAGIC_ALLOC;
                    if (curr == (free_header_t *)((byte *)memory + free_list_ptr)) {
                        free_list_ptr = curr->next;
                    }
                    return (void *)((byte *)curr + HEADER_SIZE);
                        }
            if (curr->next == free_list_ptr) {
                break;
            } else {
                curr = (free_header_t *)((byte *)memory + (curr->next));
            }

                }

        curr = (free_header_t *)((byte *)memory + free_list_ptr);
        i = 0;
        while ((curr != (free_header_t *)((byte *)memory + free_list_ptr)) || (i == 0)) { //CASE: there's a block of memory larger than reqd
            i = 1;
            if ((curr->size) > required_mem_size) {
                free_header_t *new;
                while (curr->size > required_mem_size) { //while size of curr space is bigger, half it
                    new = (free_header_t *)((byte *)curr + (curr->size)/2);
                    new->magic = MAGIC_FREE;
                    new->prev = (vlink_t)((byte *)curr - (byte *)memory);
                    new->next = curr->next;
                    if (curr->next == free_list_ptr) {
                        ((free_header_t *)(memory + free_list_ptr))->prev = (byte*)new - (byte *)memory;
                    } else {
                        ((free_header_t *)((byte *)memory + curr->next))->prev = (byte*)new - (byte *)memory;
                    }
                    curr->next = (vlink_t)((byte *)new - (byte*)memory);
                    curr->size = (curr->size)/2;
                    new->size = curr->size;
                    curr = new;
                }

                if ((new->prev == new->next) && (new->prev == ((byte *)new - (byte *)memory)))
                    return NULL;
                else
                    new->magic = MAGIC_ALLOC;
                    ((free_header_t *)((byte *)memory + ((new)->prev)))->next = new->next;
                    ((free_header_t *)((byte *)memory + ((new)->next)))->prev = new->prev;
                    if (curr == (free_header_t *)((byte *)memory + free_list_ptr)) {
                        free_list_ptr = curr->next;
                    }
                    return (void *)((byte *)new + HEADER_SIZE);
                        }
            if (curr->next == free_list_ptr) {
                curr = (free_header_t *)((byte *)memory + free_list_ptr);
            } else {
                //curr = (free_header_t *)((byte*)curr + curr->size);
                curr = (free_header_t *)((byte *)memory + curr->next);
            }
                }

        }
    return NULL;
}