uint lst_push(list_t *list) {
	list_e *elem = list->free;
	if(elem == NULL) {
		return 0xffffffff;
	}
	list->free = list->free->f_next ? list->free->f_next : list->free->f_prev;
	if(elem->f_prev) {
		elem->f_prev->f_next = elem->f_next;
	}
	if(elem->f_next) {
		elem->f_next->f_prev = elem->f_prev;
	}
	elem->f_next = elem->f_prev = NULL;
	if(list->used && list->used->u_prev) {
		list->used->u_prev->u_next = elem;
	}
	elem->u_prev = list->used ? list->used->u_prev : NULL; // unused
	elem->u_next = list->used;
	if(list->used) {
		list->used->u_prev = elem;
	}
	list->used = elem;
	
	list->stored += 1;
	return elem->id;
}

void lst_pop(list_t *list, uint id) {
	list_e *elem = &list->elems[id];
	if(elem == list->used) {
		list->used = list->used->u_next ? list->used->u_next : list->used->u_prev;
	}
	if(elem->u_prev) {
		elem->u_prev->u_next = elem->u_next;
	}
	if(elem->u_next) {
		elem->u_next->u_prev = elem->u_prev;
	}
	elem->u_next = elem->u_prev = NULL;
	if(list->free && list->free->f_prev) {
		list->free->f_prev->f_next = elem;
	}
	elem->f_prev = list->free ? list->free->f_prev : NULL;
	elem->f_next = list->free;
	if(list->free) {
		list->free->f_prev = elem;
	}
	list->free = elem;
	
	list->stored -= 1;
}

uint lst_iter(list_t *list, int *ptr) {
	list_e *elem = ((*ptr) < 0) ? NULL : (((*ptr) == 0) ? list->used : &list->elems[(*ptr)-1]);
	if(elem == NULL) {
		return 0xffffffff;
	}
	*ptr = elem->u_next ? (elem->u_next->id + 1) : -1;
	return elem->id;
}

void lst_clear(list_t *list) {
	list_e *elem;
	list->stored = 0;
	list->used = NULL;
	list->free = list->elems;
	for(int z = 0; z < list->size; z++) {
		elem = &list->elems[z];
		elem->f_prev = (z == 0) ? NULL : &list->elems[z-1];
		elem->f_next = (z == (list->size - 1)) ? NULL : &list->elems[z+1];
		elem->u_prev = elem->u_next = NULL;
		elem->id = z;
	}
}

void lst_init(list_t *list, uint size, byte cat) {
	list->size = size;
	list->elems = mem_alloc(list->size * sizeof(table_e), cat);
	lst_clear(list);
}

void lst_free(list_t *list) {
	mem_free(list->elems);
}