Index: src/examples/gc_no_raii/src/internal/memory_pool.c
===================================================================
--- src/examples/gc_no_raii/src/internal/memory_pool.c	(revision 8a7408140e74358927b5ee78b1bf0633a4a81cbf)
+++ src/examples/gc_no_raii/src/internal/memory_pool.c	(revision 4ef8fb38d3b42ac4dcb9c6ad316497c6f321c4fd)
@@ -3,5 +3,7 @@
 #include <stdlib>
 
-// const size_t gc_pool_header_size = (size_t)(  &(((gc_memory_pool*)NULL)->start_p) );
+#include "object_header.h"
+
+const size_t gc_pool_header_size = (size_t)(  &(((gc_memory_pool*)NULL)->start_p) );
 
 void ctor(gc_memory_pool *const this, size_t size, gc_memory_pool* next, gc_memory_pool* mirror, uint8_t type)
@@ -11,5 +13,5 @@
 	this->type_code = type;
 
-	card_table_t* new = malloc();
+	card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
 	this->cards = new;
 	ctor(this->cards);
@@ -18,142 +20,146 @@
 	this->free_p = this->start_p;
 
-	// check(gc_pool_of(this) == this);
-	// check(this->cards);
-	// gc_reset_pool(this);
+	check(gc_pool_of(this) == this);
+	check(this->cards);
+	gc_reset_pool(this);
 }
 
-// void dtor(gc_memory_pool *const this)
-// {
-// 	dtor(this->cards);
-// 	free(this->cards);
-// }
-//
-// void gc_reset_pool(gc_memory_pool *const this)
-// {
-// 	this->free_p = this->start_p;
-// 	#if _DEBUG
-// 		memset(this->start_p, 0xCD, gc_pool_total_size(this));
-// 	#endif
-//
-// 	check(this->cards);
-// 	reset(this->cards);
-//
-// 	check(gc_pool_size_left(this) == gc_pool_total_size(this));
-// }
-//
-// void* gc_pool_allocate(gc_memory_pool *const this, size_t size, bool zero)
-// {
-// 	void* ret = this->free_p;
-//
-// 	this->free_p += size;
-//
-// 	if (zero) memset(ret, 0x00, size);
-//
-// 	check(this->cards);
-// 	register_object(this->cards, ret);
-//
-// 	return ret;
-// }
-//
-// gc_pool_object_iterator gc_pool_iterator_for(gc_memory_pool* const this, void* member)
-// {
-// 	size_t card = card_of(member);
-// 	intptr_t member_add = (intptr_t)member;
-// 	void* start_obj;
-// 	intptr_t start_obj_add;
-//
-// 	do
-// 	{
-// 		check(card < CARDS_COUNT);
-// 		start_obj = object_at(this->cards, card);
-// 		check(card != 0 || start_obj);
-// 		card--;
-// 		start_obj_add = (intptr_t)start_obj;
-// 	}
-// 	while(start_obj_add > member_add || start_obj_add != 0);
-//
-// 	check(start_obj);
-//
-// 	gc_pool_object_iterator it;
-// 	ctor( &it,
-// 		(gc_object_header*)start_obj
-// 		#if _DEBUG
-// 			, (intptr_t)this->start_p
-// 			, (intptr_t)this->free_p
-// 		#endif
-// 	);
-// 	return it;
-// }
-//
-// void ctor(
-// 		gc_pool_object_iterator* const this,
-// 		struct gc_object_header* start_object
-// 		#if _DEBUG
-// 			, intptr_t pool_start
-// 			, intptr_t pool_end
-// 		#endif
-// 	)
-// {
-// 	this->object = start_object;
-// 	#if _DEBUG
-// 		this->lower_limit = pool_start;
-// 		this->upper_limit = pool_end;
-// 	#endif
-//
-// 	check( ((intptr_t)start_object) >= lower_limit );
-// 	check( ((intptr_t)start_object) <= upper_limit );
-// }
-//
-// bool ?!=?(const gc_pool_object_iterator lhs, const gc_pool_object_iterator rhs)
-// {
-// 	return lhs.object != rhs.object;
-// }
-//
-// gc_pool_object_iterator begin(gc_memory_pool* const this)
-// {
-// 	gc_pool_object_iterator it;
-// 	ctor( &it,
-// 		(gc_object_header*)this->start_p,
-// 		#if _DEBUG
-// 			, (intptr_t)this->start_p
-// 			, (intptr_t)this->free_p
-// 		#endif
-// 	);
-// 	return it;
-// }
-//
-// gc_pool_object_iterator end(gc_memory_pool* const this)
-// {
-// 	gc_pool_object_iterator it;
-// 	ctor( &it,
-// 		(gc_object_header*)this->free_p,
-// 		#if _DEBUG
-// 			, (intptr_t)this->start_p
-// 			, (intptr_t)this->free_p
-// 		#endif
-// 	);
-// 	return it;
-// }
-//
-// gc_pool_object_iterator* ++?(gc_pool_object_iterator* it)
-// {
-// 	intptr_t next_ptr = ((intptr_t)it->object) + it->object->size;
-// 	check(next_ptr > lower_limit);
-// 	check(next_ptr <= upper_limit);
-//
-// 	gc_object_header* next_obj = ((gc_object_header*)next_ptr);
-// 	check(next_ptr == upper_limit || is_valide(next_obj));
-//
-// 	it->object = next_obj;
-// 	return it;
-// }
-//
-// const struct gc_object_header* *?(const gc_pool_object_iterator it)
-// {
-// 	return it.object;
-// }
-//
-// struct gc_object_header* *?(gc_pool_object_iterator it)
-// {
-// 	return it.object;
-// }
+void dtor(gc_memory_pool *const this)
+{
+	dtor(this->cards);
+	free(this->cards);
+}
+
+void gc_reset_pool(gc_memory_pool *const this)
+{
+	this->free_p = this->start_p;
+	#if _DEBUG
+		memset(this->start_p, 0xCD, gc_pool_total_size(this));
+	#endif
+
+	check(this->cards);
+	reset(this->cards);
+
+	check(gc_pool_size_left(this) == gc_pool_total_size(this));
+}
+
+void* gc_pool_allocate(gc_memory_pool *const this, size_t size, bool zero)
+{
+	void* ret = this->free_p;
+
+	this->free_p += size;
+
+	if (zero) memset(ret, 0x00, size);
+
+	check(this->cards);
+	register_object(this->cards, ret);
+
+	return ret;
+}
+
+void ctor(
+		gc_pool_object_iterator* const this,
+		struct gc_object_header* start_object
+		#if _DEBUG
+			, intptr_t pool_start
+			, intptr_t pool_end
+		#endif
+	)
+{
+	this->object = start_object;
+	#if _DEBUG
+		this->lower_limit = pool_start;
+		this->upper_limit = pool_end;
+	#endif
+
+	check( ((intptr_t)start_object) >= lower_limit );
+	check( ((intptr_t)start_object) <= upper_limit );
+}
+
+gc_pool_object_iterator gc_pool_iterator_for(gc_memory_pool* const this, void* member)
+{
+	size_t card = card_of(member);
+	intptr_t member_add = (intptr_t)member;
+	void* start_obj;
+	intptr_t start_obj_add;
+
+	do
+	{
+		check(card < CARDS_COUNT);
+		start_obj = object_at(this->cards, card);
+		check(card != 0 || start_obj);
+		card--;
+		start_obj_add = (intptr_t)start_obj;
+	}
+	while(start_obj_add > member_add || start_obj_add != 0);
+
+	check(start_obj);
+	
+	struct gc_object_header* start_obj_typed = (struct gc_object_header*)start_obj;
+
+	gc_pool_object_iterator it;
+	ctor( &it,
+		start_obj_typed,
+		#if _DEBUG
+			, (intptr_t)this->start_p
+			, (intptr_t)this->free_p
+		#endif
+	);
+	return it;
+}
+
+bool ?!=?(const gc_pool_object_iterator lhs, const gc_pool_object_iterator rhs)
+{
+	return lhs.object != rhs.object;
+}
+
+gc_pool_object_iterator begin(gc_memory_pool* const this)
+{
+	struct gc_object_header* start_obj = (struct gc_object_header*)this->start_p;
+	gc_pool_object_iterator it;
+	ctor( &it,
+		start_obj,
+		#if _DEBUG
+			, (intptr_t)this->start_p
+			, (intptr_t)this->free_p
+		#endif
+	);
+	return it;
+}
+
+gc_pool_object_iterator end(gc_memory_pool* const this)
+{
+	gc_pool_object_iterator it;
+	ctor( &it,
+		(struct gc_object_header*)this->free_p,
+		#if _DEBUG
+			, (intptr_t)this->start_p
+			, (intptr_t)this->free_p
+		#endif
+	);
+	return it;
+}
+
+gc_pool_object_iterator* ++?(gc_pool_object_iterator* it)
+{
+	struct gc_object_header* object = it->object;
+	intptr_t next_ptr = ((intptr_t)object) + object->size;
+	check(next_ptr > lower_limit);
+	check(next_ptr <= upper_limit);
+
+	struct gc_object_header* next_obj = ((struct gc_object_header*)next_ptr);
+	check(next_ptr == upper_limit || is_valide(next_obj));
+
+	it->object = next_obj;
+	return it;
+}
+
+const struct gc_object_header* *?(const gc_pool_object_iterator it)
+{
+	return it.object;
+}
+
+struct gc_object_header* *?(gc_pool_object_iterator it)
+{
+	return it.object;
+}
Index: src/examples/gc_no_raii/src/internal/state.c
===================================================================
--- src/examples/gc_no_raii/src/internal/state.c	(revision 8a7408140e74358927b5ee78b1bf0633a4a81cbf)
+++ src/examples/gc_no_raii/src/internal/state.c	(revision 4ef8fb38d3b42ac4dcb9c6ad316497c6f321c4fd)
@@ -10,7 +10,9 @@
 
 //gc internal includes
+#include "collector.h"
 #include "globals.h"
 #include "memory_pool.h"
 #include "object_header.h"
+#include "tools/worklist.h"
 
 void gc_state_swap(gc_state *const this);
Index: src/examples/gc_no_raii/src/internal/state.h
===================================================================
--- src/examples/gc_no_raii/src/internal/state.h	(revision 8a7408140e74358927b5ee78b1bf0633a4a81cbf)
+++ src/examples/gc_no_raii/src/internal/state.h	(revision 4ef8fb38d3b42ac4dcb9c6ad316497c6f321c4fd)
@@ -7,5 +7,5 @@
 #include "vector.h"
 
-// typedef vector(struct gc_memory_pool*, heap_allocator(struct gc_memory_pool*)) pools_table_t;
+typedef vector(struct gc_memory_pool*, heap_allocator(struct gc_memory_pool*)) pools_table_t;
 
 struct gc_state
@@ -19,5 +19,5 @@
 	size_t used_space;
 
-	// pools_table_t 	pools_table;
+	pools_table_t 	pools_table;
 	size_t 		pools_table_count;
 };
Index: src/examples/gc_no_raii/src/tools/worklist.h
===================================================================
--- src/examples/gc_no_raii/src/tools/worklist.h	(revision 8a7408140e74358927b5ee78b1bf0633a4a81cbf)
+++ src/examples/gc_no_raii/src/tools/worklist.h	(revision 4ef8fb38d3b42ac4dcb9c6ad316497c6f321c4fd)
@@ -1,6 +1,12 @@
 #pragma once
 
+#ifdef __cforall
+extern "C" {
+#endif
 #include <stddef.h>
 #include <stdint.h>
+#ifdef __cforall
+}
+#endif
 
 #include "vector.h"
Index: src/examples/gc_no_raii/src/vector.h
===================================================================
--- src/examples/gc_no_raii/src/vector.h	(revision 8a7408140e74358927b5ee78b1bf0633a4a81cbf)
+++ src/examples/gc_no_raii/src/vector.h	(revision 4ef8fb38d3b42ac4dcb9c6ad316497c6f321c4fd)
@@ -21,117 +21,117 @@
 	size_t size;
 };
-//
-// //------------------------------------------------------------------------------
-// //Initialization
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// void ctor(vector(T, allocator_t) *const this);
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// void dtor(vector(T, allocator_t) *const this);
-//
-// //------------------------------------------------------------------------------
-// //Capacity
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline bool empty(vector(T, allocator_t) *const this)
-// {
-// 	return this->size == 0;
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline bool size(vector(T, allocator_t) *const this)
-// {
-// 	return this->size;
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline void reserve(vector(T, allocator_t) *const this, size_t size)
-// {
-// 	realloc(&this->storage, this->size+1);
-// }
-//
-// //------------------------------------------------------------------------------
-// //Element access
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline T at(vector(T, allocator_t) *const this, size_t index)
-// {
-// 	return data(&this->storage)[index];
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline T ?[?](vector(T, allocator_t) *const this, size_t index)
-// {
-// 	return data(&this->storage)[index];
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline T front(vector(T, allocator_t) *const this)
-// {
-// 	return data(&this->storage)[0];
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline T back(vector(T, allocator_t) *const this)
-// {
-// 	return data(&this->storage)[this->size - 1];
-// }
-//
-// //------------------------------------------------------------------------------
-// //Modifiers
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// void push_back(vector(T, allocator_t) *const this, T value);
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// void pop_back(vector(T, allocator_t) *const this);
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// void clear(vector(T, allocator_t) *const this);
-//
-// //------------------------------------------------------------------------------
-// //Iterators
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline T* begin(vector(T, allocator_t) *const this)
-// {
-// 	return data(&this->storage);
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline const T* cbegin(const vector(T, allocator_t) *const this)
-// {
-// 	return data(&this->storage);
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline T* end(vector(T, allocator_t) *const this)
-// {
-// 	return data(&this->storage) + this->size;
-// }
-//
-// forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
-// static inline const T* cend(const vector(T, allocator_t) *const this)
-// {
-// 	return data(&this->storage) + this->size;
-// }
-//
-// //------------------------------------------------------------------------------
-// //Allocator
-// forall(otype T)
-// struct heap_allocator
-// {
-// 	T* storage;
-// 	size_t capacity;
-// };
-//
-// forall(otype T)
-// void ctor(heap_allocator(T) *const this);
-//
-// forall(otype T)
-// void dtor(heap_allocator(T) *const this);
-//
-// forall(otype T)
-// void realloc(heap_allocator(T) *const this, size_t size);
-//
-// forall(otype T)
-// static inline T* data(heap_allocator(T) *const this)
-// {
-// 	return this->storage;
-// }
+
+//------------------------------------------------------------------------------
+//Initialization
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void ctor(vector(T, allocator_t) *const this);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void dtor(vector(T, allocator_t) *const this);
+
+//------------------------------------------------------------------------------
+//Capacity
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline bool empty(vector(T, allocator_t) *const this)
+{
+	return this->size == 0;
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline bool size(vector(T, allocator_t) *const this)
+{
+	return this->size;
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline void reserve(vector(T, allocator_t) *const this, size_t size)
+{
+	realloc(&this->storage, this->size+1);
+}
+
+//------------------------------------------------------------------------------
+//Element access
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline T at(vector(T, allocator_t) *const this, size_t index)
+{
+	return data(&this->storage)[index];
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline T ?[?](vector(T, allocator_t) *const this, size_t index)
+{
+	return data(&this->storage)[index];
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline T front(vector(T, allocator_t) *const this)
+{
+	return data(&this->storage)[0];
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline T back(vector(T, allocator_t) *const this)
+{
+	return data(&this->storage)[this->size - 1];
+}
+
+//------------------------------------------------------------------------------
+//Modifiers
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void push_back(vector(T, allocator_t) *const this, T value);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void pop_back(vector(T, allocator_t) *const this);
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+void clear(vector(T, allocator_t) *const this);
+
+//------------------------------------------------------------------------------
+//Iterators
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline T* begin(vector(T, allocator_t) *const this)
+{
+	return data(&this->storage);
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline const T* cbegin(const vector(T, allocator_t) *const this)
+{
+	return data(&this->storage);
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline T* end(vector(T, allocator_t) *const this)
+{
+	return data(&this->storage) + this->size;
+}
+
+forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+static inline const T* cend(const vector(T, allocator_t) *const this)
+{
+	return data(&this->storage) + this->size;
+}
+
+//------------------------------------------------------------------------------
+//Allocator
+forall(otype T)
+struct heap_allocator
+{
+	T* storage;
+	size_t capacity;
+};
+
+forall(otype T)
+void ctor(heap_allocator(T) *const this);
+
+forall(otype T)
+void dtor(heap_allocator(T) *const this);
+
+forall(otype T)
+void realloc(heap_allocator(T) *const this, size_t size);
+
+forall(otype T)
+static inline T* data(heap_allocator(T) *const this)
+{
+	return this->storage;
+}