Index: src/examples/gc_no_raii/bug-repro/field.c
===================================================================
--- src/examples/gc_no_raii/bug-repro/field.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/bug-repro/field.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -62,5 +62,5 @@
 {
 	struct gc_object_header* object;
-	#if _DEBUG
+	#ifndef NDEBUG
 		intptr_t lower_limit;
 		intptr_t upper_limit;
@@ -71,5 +71,5 @@
 		gc_pool_object_iterator* const this,
 		void* start_object
-		#if _DEBUG
+		#ifndef NDEBUG
 			, intptr_t pool_start
 			, intptr_t pool_end
Index: src/examples/gc_no_raii/bug-repro/oddtype.c
===================================================================
--- src/examples/gc_no_raii/bug-repro/oddtype.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
+++ src/examples/gc_no_raii/bug-repro/oddtype.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -0,0 +1,13 @@
+forall(dtype T)
+struct wrap {
+	int i;
+};
+
+forall(otype T) void ?{}(wrap(T)* this) {}
+forall(otype T) void ?=?(wrap(T)* this) {}
+forall(otype T) void ^?{}(wrap(T)* this) {}
+
+struct List_t {
+	int val;
+	wrap(List_t) next;
+};
Index: src/examples/gc_no_raii/src/gcpointers.c
===================================================================
--- src/examples/gc_no_raii/src/gcpointers.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/gcpointers.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -14,9 +14,9 @@
 		gc_object_header* obj = gc_get_object_for_ref(gc_get_state(), (void*)this);
 		check(obj);
-		check(gc_obj_is_valide(obj));
-		check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || obj->type_chain == NULL);
+		check(is_valid(obj));
+		check(gc_is_managed(this) == gc_is_managed(obj->type_chain) || !obj->type_chain);
 		this->next = obj->type_chain;
 		obj->type_chain = this;
-		check(obj->is_valide());
+		check(is_valid(obj));
 	}
 	else
@@ -24,9 +24,9 @@
 		gc_object_header* obj = gc_get_object_ptr((void*)this->ptr);
 		check(obj);
-		check(gc_obj_is_valide(obj));
-		check(gc_is_managed(this) == gc_is_managed(obj->root_chain) || obj->root_chain == NULL);
+		check(is_valid(obj));
+		check(gc_is_managed(this) == gc_is_managed(obj->root_chain) || !obj->root_chain);
 		this->next = obj->root_chain;
 		obj->root_chain = this;
-		check(gc_obj_is_valide(obj));
+		check(is_valid(obj));
 	}
 }
@@ -124,4 +124,7 @@
 //
 // //Logical operators
+forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
+	return this.internal.ptr != 0;
+}
 // forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
 // forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
Index: src/examples/gc_no_raii/src/gcpointers.h
===================================================================
--- src/examples/gc_no_raii/src/gcpointers.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/gcpointers.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -3,4 +3,7 @@
 #include <stdbool.h>
 #include <stdint.h>
+
+forall(dtype T)
+struct gcpointer;
 
 struct gcpointer_t
@@ -14,5 +17,5 @@
 void ?{}(gcpointer_t* this, gcpointer_t other);
 void ^?{}(gcpointer_t* this);
-gcpointer_t* ?=?(gcpointer_t this, gcpointer_t rhs);
+gcpointer_t ?=?(gcpointer_t* this, gcpointer_t rhs);
 
 //Logical operators
@@ -21,5 +24,5 @@
 bool gcpointer_null(gcpointer_t* this);
 
-forall(otype T)
+forall(dtype T)
 struct gcpointer
 {
@@ -32,11 +35,12 @@
 forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other);
 forall(otype T) void ^?{}(gcpointer(T)* this);
-forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
 
 
-forall(otype T) T *?(gcpointer(T) this);
+// forall(otype T) T *?(gcpointer(T) this);
 forall(otype T) T* get(gcpointer(T)* this);
 
 //Logical operators
+forall(otype T) int ?!=?(gcpointer(T) this, int zero);
 forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
 forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
Index: src/examples/gc_no_raii/src/internal/card_table.h
===================================================================
--- src/examples/gc_no_raii/src/internal/card_table.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/card_table.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -1,5 +1,3 @@
 #pragma once
-
-#include <stdlib>
 
 #include "globals.h"
@@ -19,10 +17,10 @@
 };
 
-static inline void ctor(card_table_t* const this)
+static inline void ctor_card(card_table_t* const this)
 {
 	this->count = 0;
 }
 
-static inline void dtor(card_table_t* const this)
+static inline void dtor_card(card_table_t* const this)
 {
 
@@ -48,5 +46,5 @@
 	else
 	{
-		check(card == count);
+		check(card == this->count);
 		this->count++;
 		this->cards_start[card] = object;
Index: src/examples/gc_no_raii/src/internal/collector.c
===================================================================
--- src/examples/gc_no_raii/src/internal/collector.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/collector.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -25,5 +25,5 @@
 	gc_object_header* obj = gc_get_object_ptr((void*)target->ptr);
 
-	check(gc_is_valide(obj));
+	check(is_valid(obj));
 
 	gcpointer_t** prev_next_ptr = managed ? &obj->type_chain : &obj->root_chain;
@@ -38,10 +38,10 @@
 void* gc_allocate(size_t target_size)
 {
-	sout | "Allocating " | target_size | " bytes" | endl;
+	// sout | "Allocating " | target_size | " bytes" | endl;
 
 	size_t size = gc_compute_size(target_size + sizeof(gc_object_header));
 
-	sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
-	sout | "Actual allocation size: " | size | " bytes" | endl;
+	// sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
+	// sout | "Actual allocation size: " | size | " bytes" | endl;
 
 	check(size < POOL_SIZE_BYTES);
@@ -60,5 +60,5 @@
 	if((intptr_t)(block = gc_try_allocate(gc, size))) return gc_finish_alloc_block(block, size, target_size);
 
-	checkf(false, "ERROR: allocation in new pool failed");
+	checkf( (int) 0, "ERROR: allocation in new pool failed");
 
 	return NULL;
@@ -67,20 +67,20 @@
 void* gc_finish_alloc_block(void* block, size_t actual_size, size_t target_size)
 {
-	void* data = (void*)(((intptr_t)block) + sizeof(gc_object_header));
+	intptr_t data = ((intptr_t)block) + sizeof(gc_object_header);
 	void* header = block;
 
-	check(((intptr_t)data) > ((intptr_t)block));
-	check(((intptr_t)data) >= ((intptr_t)header));
-	check(is_aligned(data));
-	check(((intptr_t)data) + target_size <= ((intptr_t)block) + actual_size);
+	check( data > ((intptr_t)block));
+	check( data >= ((intptr_t)header));
+	check( gc_is_aligned( (void*)data ) );
+	check( data + target_size <= ((intptr_t)block) + actual_size );
 
 	gc_object_header* obj = placement_ctor(header, actual_size);
 
 	(void)obj; //remove unsused warning since this is for debug
-	check(obj == get_object_ptr(data));
+	check(obj == gc_get_object_ptr( (void*)data ));
 
 	gc_register_allocation(gc_get_state(), actual_size);
 
-	return data;
+	return (void*)data;
 }
 
@@ -119,5 +119,5 @@
 	check(!ptr->forward);
 	check(!ptr->is_forwarded);
-	check(gc_is_from_space(gc_pool_of(ptr)));
+	check(gc_pool_is_from_space(gc_pool_of(ptr)));
 
 	gc_memory_pool* pool = gc_pool_of(ptr)->mirror;
@@ -143,5 +143,5 @@
 		check(((intptr_t)field) < ((intptr_t)((intptr_t)object) + object->size));
 
-		check(gc_is_in_to_space(gc_get_state(), &type->ptr));
+		check(gc_is_in_to_space(gc_get_state(), &field->ptr));
 
 		intptr_t* ref = &field->ptr;
Index: src/examples/gc_no_raii/src/internal/memory_pool.c
===================================================================
--- src/examples/gc_no_raii/src/internal/memory_pool.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/memory_pool.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -1,6 +1,10 @@
 #include "memory_pool.h"
 
-#include <stdlib>
+extern "C" {
+	#include <stdlib.h>
+	#include <string.h>
+}
 
+#include "collector.h"
 #include "object_header.h"
 
@@ -15,10 +19,10 @@
 	card_table_t* new = (card_table_t*)malloc(sizeof(card_table_t));
 	this->cards = new;
-	ctor(this->cards);
+	ctor_card(this->cards);
 
 	this->end_p = ((uint8_t*)this) + size;
 	this->free_p = this->start_p;
 
-	check(gc_pool_of(this) == this);
+	check( gc_pool_of( (void*)this ) == this);
 	check(this->cards);
 	gc_reset_pool(this);
@@ -27,5 +31,5 @@
 void dtor(gc_memory_pool *const this)
 {
-	dtor(this->cards);
+	dtor_card(this->cards);
 	free(this->cards);
 }
@@ -34,6 +38,6 @@
 {
 	this->free_p = this->start_p;
-	#if _DEBUG
-		memset(this->start_p, 0xCD, gc_pool_total_size(this));
+	#ifndef NDEBUG
+		memset(this->start_p, 0xCD, gc_pool_size_total(this));
 	#endif
 
@@ -41,5 +45,5 @@
 	reset(this->cards);
 
-	check(gc_pool_size_left(this) == gc_pool_total_size(this));
+	check(gc_pool_size_left(this) == gc_pool_size_total(this));
 }
 
@@ -58,8 +62,7 @@
 }
 
-void ctor(
-		gc_pool_object_iterator* const this,
+void ?{}(	gc_pool_object_iterator* this,
 		struct gc_object_header* start_object
-		#if _DEBUG
+		#ifndef NDEBUG
 			, intptr_t pool_start
 			, intptr_t pool_end
@@ -68,12 +71,14 @@
 {
 	this->object = start_object;
-	#if _DEBUG
+	#ifndef NDEBUG
 		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 );
+	check( ((intptr_t)start_object) >= this->lower_limit );
+	check( ((intptr_t)start_object) <= this->upper_limit );
 }
+
+void ^?{}( gc_pool_object_iterator* this ) {}
 
 gc_pool_object_iterator gc_pool_iterator_for(gc_memory_pool* const this, void* member)
@@ -81,5 +86,5 @@
 	size_t card = card_of(member);
 	intptr_t member_add = (intptr_t)member;
-	void* start_obj;
+	intptr_t start_obj;
 	intptr_t start_obj_add;
 
@@ -87,5 +92,5 @@
 	{
 		check(card < CARDS_COUNT);
-		start_obj = object_at(this->cards, card);
+		start_obj = (intptr_t)object_at(this->cards, card);
 		check(card != 0 || start_obj);
 		card--;
@@ -94,17 +99,15 @@
 	while(start_obj_add > member_add || start_obj_add != 0);
 
-	check(start_obj);
-	
+	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
+	return (gc_pool_object_iterator) {
+		start_obj_typed
+		#ifndef NDEBUG
 			, (intptr_t)this->start_p
 			, (intptr_t)this->free_p
 		#endif
-	);
-	return it;
+	};
 }
 
@@ -117,26 +120,22 @@
 {
 	struct gc_object_header* start_obj = (struct gc_object_header*)this->start_p;
-	gc_pool_object_iterator it;
-	ctor( &it,
-		start_obj,
-		#if _DEBUG
+	return (gc_pool_object_iterator) {
+		start_obj
+		#ifndef NDEBUG
 			, (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
+	return (gc_pool_object_iterator) {
+		(struct gc_object_header*)this->free_p
+		#ifndef NDEBUG
 			, (intptr_t)this->start_p
 			, (intptr_t)this->free_p
 		#endif
-	);
-	return it;
+	};
 }
 
@@ -145,9 +144,9 @@
 	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);
+	check(next_ptr > it->lower_limit);
+	check(next_ptr <= it->upper_limit);
 
 	struct gc_object_header* next_obj = ((struct gc_object_header*)next_ptr);
-	check(next_ptr == upper_limit || is_valide(next_obj));
+	check(next_ptr == it->upper_limit || is_valid(next_obj));
 
 	it->object = next_obj;
Index: src/examples/gc_no_raii/src/internal/memory_pool.h
===================================================================
--- src/examples/gc_no_raii/src/internal/memory_pool.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/memory_pool.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -39,5 +39,5 @@
 {
 	struct gc_object_header* object;
-	#if _DEBUG
+	#ifndef NDEBUG
 		intptr_t lower_limit;
 		intptr_t upper_limit;
@@ -46,12 +46,13 @@
 
 
-void ctor(
-		gc_pool_object_iterator* const this,
+void ?{}( 	gc_pool_object_iterator* this,
 		struct gc_object_header* start_object
-		#if _DEBUG
+		#ifndef NDEBUG
 			, intptr_t pool_start
 			, intptr_t pool_end
 		#endif
 	);
+
+void ^?{}( gc_pool_object_iterator* this );
 
 bool ?!=?(const gc_pool_object_iterator lhs, const gc_pool_object_iterator rhs);
Index: src/examples/gc_no_raii/src/internal/object_header.c
===================================================================
--- src/examples/gc_no_raii/src/internal/object_header.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/object_header.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -3,4 +3,5 @@
 #include <stdint.h>
 
+#include "collector.h"
 #include "globals.h"
 #include "gcpointers.h"
@@ -8,5 +9,5 @@
 void ctor(gc_object_header* const this, size_t inSize)
 {
-	#if _DEBUG
+	#ifndef NDEBUG
 		this->canary_start = CANARY_VALUE;
 	#endif
@@ -18,5 +19,5 @@
 	this->is_forwarded = false;
 
-	#if _DEBUG
+	#ifndef NDEBUG
 		this->canary_end = CANARY_VALUE;
 	#endif
@@ -25,5 +26,5 @@
 void copy_ctor(gc_object_header* const this, const gc_object_header* const other)
 {
-	#if _DEBUG
+	#ifndef NDEBUG
 		this->canary_start = CANARY_VALUE;
 	#endif
@@ -35,5 +36,5 @@
 	this->is_forwarded = false;
 
-	#if _DEBUG
+	#ifndef NDEBUG
 		this->canary_end = CANARY_VALUE;
 	#endif
@@ -42,8 +43,8 @@
 	while(root)
 	{
-		check(get_object_ptr(root->ptr) == other);
+		check(gc_get_object_ptr( (void*)root->ptr ) == other);
 		root->ptr = ((intptr_t)this) + sizeof(gc_object_header);
 
-		check(get_object_ptr(root->ptr) == this);
+		check(gc_get_object_ptr( (void*)root->ptr ) == this);
 		root = root->next;
 	}
@@ -56,5 +57,5 @@
 
 		size_t offset = (intptr_t)type - (intptr_t)other;
-		check(offset < size);
+		check(offset < this->size);
 
 		gcpointer_t* member_ptr = (gcpointer_t*)( (intptr_t)this + offset );
@@ -63,5 +64,5 @@
 
 		size_t next_offset = type->next ? (intptr_t)type->next - (intptr_t)other : 0;
-		check(next_offset < size);
+		check(next_offset < this->size);
 
 		gcpointer_t* next_ptr = type->next ? (gcpointer_t*)((intptr_t)this + next_offset) : NULL;
@@ -73,14 +74,14 @@
 	}
 
-	check(is_valide(this));
+	check(is_valid(this));
 }
 
-#if _DEBUG
-	bool is_valide(const gc_object_header* const this)
+#ifndef NDEBUG
+	bool is_valid(const gc_object_header* const this)
 	{
-		check(this->canary_start == CANARY_VALUE);
-		check(this->canary_end == CANARY_VALUE);
+		check((intptr_t)this->canary_start == (intptr_t)CANARY_VALUE);
+		check((intptr_t)this->canary_end == (intptr_t)CANARY_VALUE);
 
-		check(this->is_forwarded == (this->forward != nullptr));
+		check(this->is_forwarded == ( (intptr_t)this->forward != (intptr_t)NULL));
 
 		check(this->size < POOL_SIZE_BYTES);
@@ -89,14 +90,14 @@
 		while(root)
 		{
-			check(get_object_ptr(root->ptr) == this);
+			check(gc_get_object_ptr( (void*)root->ptr ) == this);
 
 			root = root->next;
 		}
 
-		gcpointer_t* type = type_chain;
+		gcpointer_t* type = this->type_chain;
 		while(type)
 		{
 			check((intptr_t)type > (intptr_t)this);
-			check((intptr_t)type < (intptr_t)((intptr_t)this + size));
+			check((intptr_t)type < (intptr_t)(((intptr_t)this) + this->size));
 
 			type = type->next;
Index: src/examples/gc_no_raii/src/internal/object_header.h
===================================================================
--- src/examples/gc_no_raii/src/internal/object_header.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/object_header.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -7,6 +7,6 @@
 #include "tools.h"
 
-#if DEBUG
-	static const long unsigned int CANARY_VALUE = 0xCAFEBABACAFEBABA;
+#ifndef NDEBUG
+	static void* const CANARY_VALUE = (void*)0xCAFEBABACAFEBABA;
 #endif
 
@@ -16,5 +16,5 @@
 struct gc_object_header
 {
-	#if DEBUG
+	#ifndef NDEBUG
 		void* canary_start;
 	#endif
@@ -26,5 +26,5 @@
 	bool			is_forwarded;
 
-	#if DEBUG
+	#ifndef NDEBUG
 		void* canary_end;
 	#endif
@@ -47,2 +47,6 @@
 	return this;
 }
+
+#ifndef NDEBUG
+	bool is_valid( struct gc_object_header* obj );
+#endif
Index: src/examples/gc_no_raii/src/internal/state.c
===================================================================
--- src/examples/gc_no_raii/src/internal/state.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/state.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -21,5 +21,5 @@
 void gc_state_calc_usage(gc_state *const this);
 
-#if DEBUG
+#ifndef NDEBUG
 	bool gc_state_roots_match(gc_state *const this);
 	bool gc_state_no_from_space_ref(gc_state *const this);
@@ -97,5 +97,5 @@
 	}
 
-	checkf(false, "is_in_heap() and iterator_for() return inconsistent data");
+	checkf( (int) 0, "is_in_heap() and iterator_for() return inconsistent data");
 	abort();
 	return NULL;
@@ -176,5 +176,5 @@
 	this->from_code = (~this->from_code) & 0x01;
 
-	#if _DEBUG
+	#ifndef NDEBUG
 		{
 			gc_memory_pool* pool = this->from_space;
@@ -251,5 +251,5 @@
 }
 
-#if _DEBUG
+#ifndef NDEBUG
 	bool gc_state_roots_match(gc_state* const this)
 	{
@@ -265,9 +265,9 @@
 				size += object->size;
 
-				gcpointer_base* ptr = object->root_chain;
+				gcpointer_t* ptr = object->root_chain;
 				while(ptr)
 				{
-					check(get_object_ptr(ptr->m_ptr) == object);
-					ptr = ptr->m_next;
+					check(gc_get_object_ptr( (void*)ptr->ptr ) == object);
+					ptr = ptr->next;
 				}
 			}
@@ -286,6 +286,6 @@
 		while(pool)
 		{
-			void** potential_ref = (void**)pool->m_start;
-			while(potential_ref < (void**)pool->m_free)
+			void** potential_ref = (void**)pool->start_p;
+			while(potential_ref < (void**)pool->free_p)
 			{
 				check(!gc_is_in_heap(this, *potential_ref));
Index: src/examples/gc_no_raii/src/internal/state.h
===================================================================
--- src/examples/gc_no_raii/src/internal/state.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/internal/state.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -38,5 +38,5 @@
 static inline bool gc_needs_collect(gc_state* state)
 {
-	sout | "Used Space: " | state->used_space | " bytes" | endl;
+	// sout | "Used Space: " | state->used_space | " bytes" | endl;
 	return state->used_space * 2 > state->total_space;
 }
Index: src/examples/gc_no_raii/src/tools/checks.h
===================================================================
--- src/examples/gc_no_raii/src/tools/checks.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/tools/checks.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -1,5 +1,13 @@
 #pragma once
 
-#if _DEBUG
+#ifdef NDEBUG
+
+#define check(x)
+
+#define checkf(x, format, ...)
+
+#warning no debug checks
+
+#else
 
 #include <stdlib.h>
@@ -10,5 +18,5 @@
 		printf("CHECK failed : %s at %s:%i\n", #x, __FILE__, __LINE__);\
 		abort();\
-	}}while(0)\
+	}}while( (int)0 )\
 
 #define checkf(x, ...) do {\
@@ -17,11 +25,5 @@
 		printf(__VA_ARGS__);\
 		abort();\
-	}}while(0)\
-
-#else
-
-#define check(x)
-
-#define checkf(x, format, ...)
+	}}while( (int)0 )\
 
 #endif //NO_CHECKS
Index: src/examples/gc_no_raii/src/tools/print.c
===================================================================
--- src/examples/gc_no_raii/src/tools/print.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/tools/print.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -1,5 +1,5 @@
 #include "tools.h"
 
-#if _DEBUG
-	ofstream *sout = ofstream_stdout();
+#ifndef NDEBUG
+	// ofstream *sout = ofstream_stdout();
 #endif
Index: src/examples/gc_no_raii/src/tools/print.h
===================================================================
--- src/examples/gc_no_raii/src/tools/print.h	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/src/tools/print.h	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -1,13 +1,13 @@
 #pragma once
 
-#if _DEBUG
-
-#include <fstream>
-
-#define DEBUG_OUT(x) sout | x | endl;
-
-#else
+// #ifndef NDEBUG
+//
+// #include <fstream>
+//
+// #define DEBUG_OUT(x) sout | x | endl;
+//
+// #else
 
 #define DEBUG_OUT(x)
 
-#endif //NO_CHECKS
+// #endif //NO_CHECKS
Index: src/examples/gc_no_raii/test/badlll.c
===================================================================
--- src/examples/gc_no_raii/test/badlll.c	(revision 60aa49a7be2cfe369ed612ced04b3e4327b9a1a1)
+++ src/examples/gc_no_raii/test/badlll.c	(revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab)
@@ -1,3 +1,5 @@
 #include "gc.h"
+
+#include <stdio.h>
 
 struct List_t
@@ -7,50 +9,51 @@
 };
 
-void ?{}(List_t* this);
-List_t* ?=?(List_t* this, List_t* rhs);
-
 typedef gcpointer(List_t) LLL;
 
 #define MAX (1024 * 1024)
 
-// LLL buildLLL(int sz)
-void bla()
+LLL buildLLL(int sz)
 {
-	int i;
-	// LLL ll0;//, lll, llc;
-//
-// 	ll0 = gcmalloc();
-// 	ll0->val = 0;
-// 	lll = ll0;
-//
-// 	for (i = 1; i < sz; i++)
-// 	{
-// 		llc = gcmalloc();
-// 		llc->val = i;
-// 		lll->next = llc;
-// 		lll = llc;
-// 	}
-//
-	// return ll0;
+	int i = 0;
+	LLL ll0, lll, llc;
+
+	gcmalloc( &ll0 );
+	List_t* ll0_ptr = get( &ll0 );
+	ll0_ptr->val = i;
+	lll = ll0;
+
+	for (i = 1; i < sz; i++)
+	{
+		gcmalloc( &llc );
+		List_t* llc_ptr = get( &llc );
+		llc_ptr->val = i;
+		List_t* lll_ptr = get( &lll );
+		lll_ptr->next = llc;
+
+		lll = llc;
+	}
+
+	return ll0;
 }
-//
-// void testLLL(LLL lll)
-// {
-// 	unsigned char *counted;
-//
-// 	counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
-// 	while (lll)
-// 	{
-// 		counted[lll->val]++;
-// 		if (counted[lll->val] > 1)
-// 		{
-// 			fprintf(stderr, "ERROR! Encountered %d twice!\n", lll->val);
-// 			exit(1);
-// 		}
-// 		lll = lll->next;
-// 	}
-//
-// 	return;
-// }
+
+void testLLL(LLL lll)
+{
+	unsigned char *counted;
+
+	counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
+	while (lll)
+	{
+		List_t* lll_ptr = get( &lll );
+		counted[lll_ptr->val]++;
+		if (counted[lll_ptr->val] > 1)
+		{
+			fprintf(stderr, "ERROR! Encountered %d twice!\n", lll_ptr->val);
+			exit(1);
+		}
+		lll = lll_ptr->next;
+	}
+
+	return;
+}
 
 int main(void)
@@ -58,7 +61,7 @@
 	LLL mylll;
 
-	// mylll = buildLLL(MAX);
-	//
-	// testLLL(mylll);
+	mylll = buildLLL(MAX);
+
+	testLLL(mylll);
 
 	return 0;