autoc 1.1 → 1.2

data/test/test.c

@@ -905,6 +905,122 @@ static void type(Test)() {
 }
 
 
+#undef Type
+#define Type ListIntSet
+#undef TypeIt
+#define TypeIt ListIntSetIt
+#undef type
+#define type(x) ListIntSet##x
+#undef it
+#define it(x) ListIntSetIt##x
+#undef Element
+#define Element IntSet
+#undef element
+#define element(x) IntSet##x
+
+
+static void type(Test)() {
+    Type c1, c2;
+    Element e;
+    
+    type(Ctor)(&c1);
+    type(Ctor)(&c2);
+    
+    element(Ctor)(&e);
+    type(Push)(&c1, e);
+    element(Put)(&e, 3);
+    element(Put)(&e, 2);
+    element(Put)(&e, 1);
+    type(Push)(&c2, e);
+    element(Dtor)(&e);
+    
+    type(Dtor)(&c1);
+    type(Dtor)(&c2);
+}
+
+
+#undef Type
+#define Type Int
+#undef type
+#define type(x) Int##x
+
+
+static void PIntTest() {
+    int *c1, *c2;
+    c1 = type(New)(); *c1 = 1;
+    c2 = type(New)(); *c2 = 2;
+    assert(*c1 != *c2);
+    type(Free)(c2);
+    c2 = type(Ref)(c1);
+    assert(*c1 == *c2);
+    type(Free)(c1);
+    type(Free)(c2);
+}
+
+
+#undef Type
+#define Type ValueType
+#undef type
+#define type(x) ValueType##x
+
+
+static void PValueTypeTest() {
+    ValueType *c1, *c2;
+    c1 = type(New)();
+    c2 = type(New)();
+    type(Free)(c2);
+    c2 = type(Ref)(c1);
+    type(Free)(c1);
+    type(Free)(c2);
+}
+
+
+/* List<Vector<ValueType*>*> */
+#undef Type
+#define Type ListPVectorValue
+#undef TypeIt
+#define TypeIt ListPVectorValueIt
+#undef type
+#define type(x) ListPVectorValue##x
+#undef it
+#define it(x) ListPVectorValueIt##x
+#undef Element
+#define Element PVectorValue
+#undef element
+#define element(x) PVectorValue##x
+
+
+static void type(Test)() {
+    Type c1, c2;
+    Element *e1, *e2;
+    ValueType *v1, *v2;
+    
+    type(Ctor)(&c1);
+    type(Ctor)(&c2);
+    
+    e1 = element(New)(3);
+    
+    element(Set)(e1, 1, v1 = ValueTypeNew());
+    
+    e2 = element(Ref)(e1);
+    
+    assert(element(Equal)(e1, e2));
+    
+    element(Set)(e2, 0, v2 = ValueTypeRef(v1));
+    
+    type(Push)(&c1, e1);
+    
+    element(Free)(e1);
+    element(Free)(e2);
+    
+    type(Dtor)(&c1);
+    type(Dtor)(&c2);
+    
+    ValueTypeFree(v1);
+    ValueTypeFree(v2);
+}
+
+
 int main(int argc, char** argv) {
     ValueTypeVectorTest();
     ValueTypeListTest();
@@ -917,5 +1033,9 @@ int main(int argc, char** argv) {
     IntSetTestNot1();
     IntSetTestNot2();
     IntStrMapTest();
+    ListIntSetTest();
+    PIntTest();
+    PValueTypeTest();
+    ListPVectorValueTest();
     return 0;
 }

data/test/test.rb

@@ -11,12 +11,26 @@ ValueType = {
   :forward => %$#include "test.h"$,
 }
 
+PInt = AutoC::Reference.new(:type => "int", :prefix => "Int")
+
+PValueType = AutoC::Reference.new(ValueType)
+
+IntVector = AutoC::Vector.new(:IntVector, :int)
+
+IntSet = AutoC::HashSet.new(:IntSet, :int)
+
+ListIntSet = AutoC::List.new(:ListIntSet, IntSet)
+
 AutoC::Module.generate!(:Test) do |c|
   c << AutoC::Vector.new(:ValueTypeVector, ValueType)
   c << AutoC::List.new(:ValueTypeList, ValueType)
   c << AutoC::Queue.new(:ValueTypeQueue, ValueType)
   c << AutoC::HashSet.new(:ValueTypeSet, ValueType)
   c << AutoC::HashMap.new(:ValueTypeMap, ValueType, ValueType)
-  c << AutoC::HashSet.new(:IntSet, :int)
-  c << AutoC::HashMap.new(:IntStrMap, :int, "const char*")
+  c << AutoC::HashMap.new(:IntStrMap, "int", "const char *")
+  c << ListIntSet
+  c << IntSet
+  c << AutoC::Vector.new(:PIntVector, PInt)
+  c << PInt << PValueType
+  c << AutoC::List.new(:ListPVectorValue, AutoC::Reference.new(AutoC::Vector.new(:PVectorValue, PValueType)))
 end

data/test/test_auto.c

@@ -7,6 +7,28 @@
 #define AUTOC_MAX(a,b) ((a) > (b) ? (a) : (b))
 #define AUTOC_RCYCLE(x) (((x) << 1) | ((x) >> (sizeof(x)*CHAR_BIT - 1))) /* NOTE : valid for unsigned types only */
 
+#define AUTOC_COUNTER(p) (*(size_t*)((char*)(p) + sizeof(int)))
+int* IntNew() {
+    int* self = (int*)malloc(sizeof(int) + sizeof(size_t));
+    assert(self);
+    ((*self) = 0);
+    AUTOC_COUNTER(self) = 1;
+    return self;
+}
+int* IntRef(int* self) {
+    assert(self);
+    ++AUTOC_COUNTER(self);
+    return self;
+}
+void IntFree(int* self) {
+    assert(self);
+    if(--AUTOC_COUNTER(self) == 0) {
+        ;
+        free(self);
+    }
+}
+#undef AUTOC_COUNTER
+
 #define AUTOC_VALID_VALUE 1
 #define AUTOC_VALID_KEY 2
 #define AUTOC_OWNED_VALUE 4
@@ -17,7 +39,7 @@ static IntStrMapEntry IntStrMapEntryKeyOnlyRef(int* key) {
     entry.flags = AUTOC_VALID_KEY;
     return entry;
 }
-static IntStrMapEntry IntStrMapEntryKeyValueRef(int* key, const char** value) {
+static IntStrMapEntry IntStrMapEntryKeyValueRef(int* key, const char ** value) {
     IntStrMapEntry entry;
     entry.key = *key;
     entry.value = *value;
@@ -26,20 +48,20 @@ static IntStrMapEntry IntStrMapEntryKeyValueRef(int* key, const char** value) {
 }
 #define IntStrMapEntryIdentify(obj) IntStrMapEntryIdentifyRef(&obj)
 static size_t IntStrMapEntryIdentifyRef(IntStrMapEntry* entry) {
-    return (size_t)(entry->key);
+    return ((size_t)(entry->key));
 }
 #define IntStrMapEntryEqual(lt, rt) IntStrMapEntryEqualRef(&lt, &rt)
 static int IntStrMapEntryEqualRef(IntStrMapEntry* lt, IntStrMapEntry* rt) {
-    return (lt->key == rt->key);
+    return ((lt->key) == (rt->key));
 }
 #define IntStrMapEntryCopy(dst, src) IntStrMapEntryCopyRef(&dst, &src)
 static void IntStrMapEntryCopyRef(IntStrMapEntry* dst, IntStrMapEntry* src) {
     assert(src->flags & AUTOC_VALID_KEY);
     dst->flags = (AUTOC_VALID_KEY | AUTOC_OWNED_KEY);
-    (dst->key = src->key);
+    ((dst->key) = (src->key));
     if(src->flags & AUTOC_VALID_VALUE) {
         dst->flags |= (AUTOC_VALID_VALUE | AUTOC_OWNED_VALUE);
-        (dst->value = src->value);
+        ((dst->value) = (src->value));
     }
 }
 #define IntStrMapEntryDtor(obj) IntStrMapEntryDtorRef(&obj)
@@ -48,11 +70,34 @@ static void IntStrMapEntryDtorRef(IntStrMapEntry* entry) {
     if(entry->flags & AUTOC_OWNED_KEY) ;
     if(entry->flags & AUTOC_VALID_VALUE && entry->flags & AUTOC_OWNED_VALUE) ;
 }
+static IntStrMapEntry* IntStrMapItGetEntryRef(IntStrMapIt*);
+static int IntStrMapContainsAllOf(IntStrMap* self, IntStrMap* other) {
+    IntStrMapIt it;
+    IntStrMapItCtor(&it, self);
+    while(IntStrMapItMove(&it)) {
+        int found = 0;
+        IntStrMapEntry* e = IntStrMapItGetEntryRef(&it);
+        if(IntStrMapContainsKey(other, e->key)) {
+            const char * other_value = IntStrMapGet(other, e->key);
+            found = ((e->value) == (other_value));
+            ;
+        }
+        if(!found) return 0;
+    }
+    return 1;
+}
+
+#define _IntStrMapSetCtor(self) IntStrMapSetCtor(&self)
+#define _IntStrMapSetDtor(self) IntStrMapSetDtor(&self)
+#define _IntStrMapSetIdentify(self) IntStrMapSetIdentify(&self)
+#define _IntStrMapSetCopy(dst,src) IntStrMapSetCopy(&dst,&src)
+#define _IntStrMapSetEqual(lt,rt) IntStrMapSetEqual(&lt,&rt)
+#define _IntStrMapSetLess(lt,rt) IntStrMapSetLess(&lt,&rt)
 
 AUTOC_STATIC void IntStrMapSetCtor(IntStrMapSet*);
 AUTOC_STATIC void IntStrMapSetDtor(IntStrMapSet*);
-AUTOC_STATIC void IntStrMapSetCopy(IntStrMapSet*, IntStrMapSet*);
-AUTOC_STATIC int IntStrMapSetEqual(IntStrMapSet*, IntStrMapSet*);
+AUTOC_STATIC void IntStrMapSetCopy(IntStrMapSet*,IntStrMapSet*);
+AUTOC_STATIC int IntStrMapSetEqual(IntStrMapSet*,IntStrMapSet*);
 AUTOC_STATIC size_t IntStrMapSetIdentify(IntStrMapSet*);
 AUTOC_STATIC void IntStrMapSetPurge(IntStrMapSet*);
 AUTOC_STATIC int IntStrMapSetContains(IntStrMapSet*, IntStrMapEntry);
@@ -70,10 +115,17 @@ AUTOC_STATIC void IntStrMapSetItCtor(IntStrMapSetIt*, IntStrMapSet*);
 AUTOC_STATIC int IntStrMapSetItMove(IntStrMapSetIt*);
 AUTOC_STATIC IntStrMapEntry IntStrMapSetItGet(IntStrMapSetIt*);
 
+#define _IntStrMapSetListCtor(self) IntStrMapSetListCtor(&self)
+#define _IntStrMapSetListDtor(self) IntStrMapSetListDtor(&self)
+#define _IntStrMapSetListIdentify(self) IntStrMapSetListIdentify(&self)
+#define _IntStrMapSetListCopy(dst,src) IntStrMapSetListCopy(&dst,&src)
+#define _IntStrMapSetListEqual(lt,rt) IntStrMapSetListEqual(&lt,&rt)
+#define _IntStrMapSetListLess(lt,rt) IntStrMapSetListLess(&lt,&rt)
+
 AUTOC_STATIC void IntStrMapSetListCtor(IntStrMapSetList*);
 AUTOC_STATIC void IntStrMapSetListDtor(IntStrMapSetList*);
-AUTOC_STATIC void IntStrMapSetListCopy(IntStrMapSetList*, IntStrMapSetList*);
-AUTOC_STATIC int IntStrMapSetListEqual(IntStrMapSetList*, IntStrMapSetList*);
+AUTOC_STATIC void IntStrMapSetListCopy(IntStrMapSetList*,IntStrMapSetList*);
+AUTOC_STATIC int IntStrMapSetListEqual(IntStrMapSetList*,IntStrMapSetList*);
 AUTOC_STATIC size_t IntStrMapSetListIdentify(IntStrMapSetList*);
 AUTOC_STATIC void IntStrMapSetListPurge(IntStrMapSetList*);
 AUTOC_STATIC IntStrMapEntry IntStrMapSetListPeek(IntStrMapSetList*);
@@ -110,7 +162,7 @@ AUTOC_STATIC void IntStrMapSetListDtor(IntStrMapSetList* self) {
         free(this_node);
     }
 }
-AUTOC_STATIC void IntStrMapSetListCopy(IntStrMapSetList* dst, IntStrMapSetList* src) {
+AUTOC_STATIC void IntStrMapSetListCopy(IntStrMapSetList* dst,IntStrMapSetList* src) {
     IntStrMapSetListIt it;
     assert(src);
     assert(dst);
@@ -120,17 +172,18 @@ AUTOC_STATIC void IntStrMapSetListCopy(IntStrMapSetList* dst, IntStrMapSetList*
         IntStrMapSetListPush(dst, *IntStrMapSetListItGetRef(&it));
     }
 }
-AUTOC_STATIC int IntStrMapSetListEqual(IntStrMapSetList* lt, IntStrMapSetList* rt) {
+AUTOC_STATIC int IntStrMapSetListEqual(IntStrMapSetList* lt,IntStrMapSetList* rt) {
     if(IntStrMapSetListSize(lt) == IntStrMapSetListSize(rt)) {
         IntStrMapSetListIt lit, rit;
         IntStrMapSetListItCtor(&lit, lt);
         IntStrMapSetListItCtor(&rit, rt);
         while(IntStrMapSetListItMove(&lit) && IntStrMapSetListItMove(&rit)) {
             int equal;
-            IntStrMapEntry *le, *re;
+            IntStrMapEntry* le;
+            IntStrMapEntry* re;
             le = IntStrMapSetListItGetRef(&lit);
             re = IntStrMapSetListItGetRef(&rit);
-            equal = IntStrMapEntryEqual(*le, *re);
+            equal = IntStrMapEntryEqual(*le,*re);
             if(!equal) return 0;
         }
         return 1;
@@ -155,7 +208,7 @@ AUTOC_STATIC IntStrMapEntry IntStrMapSetListPeek(IntStrMapSetList* self) {
     IntStrMapEntry result;
     assert(self);
     assert(!IntStrMapSetListEmpty(self));
-    IntStrMapEntryCopy(result, self->head_node->element);
+    IntStrMapEntryCopy(result,self->head_node->element);
     return result;
 }
 AUTOC_STATIC IntStrMapEntry IntStrMapSetListPop(IntStrMapSetList* self) {
@@ -175,7 +228,7 @@ AUTOC_STATIC void IntStrMapSetListPush(IntStrMapSetList* self, IntStrMapEntry el
     assert(self);
     node = (IntStrMapSetListNode*)malloc(sizeof(IntStrMapSetListNode));
     assert(node);
-    IntStrMapEntryCopy(node->element, element);
+    IntStrMapEntryCopy(node->element,element);
     node->next_node = self->head_node;
     self->head_node = node;
     ++self->node_count;
@@ -186,7 +239,7 @@ AUTOC_STATIC int IntStrMapSetListContains(IntStrMapSetList* self, IntStrMapEntry
     assert(self);
     node = self->head_node;
     while(node) {
-        if(IntStrMapEntryEqual(node->element, what)) {
+        if(IntStrMapEntryEqual(node->element,what)) {
             found = 1;
             break;
         }
@@ -200,9 +253,9 @@ AUTOC_STATIC IntStrMapEntry IntStrMapSetListFind(IntStrMapSetList* self, IntStrM
     assert(IntStrMapSetListContains(self, what));
     node = self->head_node;
     while(node) {
-        if(IntStrMapEntryEqual(node->element, what)) {
+        if(IntStrMapEntryEqual(node->element,what)) {
             IntStrMapEntry result;
-            IntStrMapEntryCopy(result, node->element);
+            IntStrMapEntryCopy(result,node->element);
             return result;
         }
         node = node->next_node;
@@ -216,9 +269,9 @@ AUTOC_STATIC int IntStrMapSetListReplaceEx(IntStrMapSetList* self, IntStrMapEntr
     if(count == 0) return 0;
     node = self->head_node;
     while(node) {
-        if(IntStrMapEntryEqual(node->element, with)) {
+        if(IntStrMapEntryEqual(node->element,with)) {
             IntStrMapEntryDtor(node->element);
-            IntStrMapEntryCopy(node->element, with);
+            IntStrMapEntryCopy(node->element,with);
             ++replaced;
             if(count > 0 && replaced >= count) break;
         }
@@ -234,7 +287,7 @@ AUTOC_STATIC int IntStrMapSetListRemoveEx(IntStrMapSetList* self, IntStrMapEntry
     node = self->head_node;
     prev_node = NULL;
     while(node) {
-        if(IntStrMapEntryEqual(node->element, what)) {
+        if(IntStrMapEntryEqual(node->element,what)) {
             IntStrMapSetListNode* this_node;
             if(prev_node) {
                 this_node = prev_node->next_node = node->next_node;
@@ -278,7 +331,7 @@ AUTOC_STATIC IntStrMapEntry IntStrMapSetListItGet(IntStrMapSetListIt* self) {
     IntStrMapEntry result;
     assert(self);
     assert(self->this_node);
-    IntStrMapEntryCopy(result, self->this_node->element);
+    IntStrMapEntryCopy(result,self->this_node->element);
     return result;
 }
 AUTOC_STATIC IntStrMapEntry* IntStrMapSetListItGetRef(IntStrMapSetListIt* self) {
@@ -334,6 +387,16 @@ static void IntStrMapSetRehash(IntStrMapSet* self) {
     self->bucket_count = bucket_count;
     self->size = size;
 }
+static int IntStrMapSetContainsAllOf(IntStrMapSet* self, IntStrMapSet* other) {
+    IntStrMapSetIt it;
+    IntStrMapSetItCtor(&it, self);
+    while(IntStrMapSetItMove(&it)) {
+        int found = 0;
+        if(IntStrMapSetContains(other, *IntStrMapSetItGetRef(&it))) found = 1;
+        if(!found) return 0;
+    }
+    return 1;
+}
 AUTOC_STATIC void IntStrMapSetCtor(IntStrMapSet* self) {
     assert(self);
     self->min_bucket_count = 16;
@@ -353,7 +416,7 @@ AUTOC_STATIC void IntStrMapSetDtor(IntStrMapSet* self) {
     }
     free(self->buckets);
 }
-AUTOC_STATIC void IntStrMapSetCopy(IntStrMapSet* dst, IntStrMapSet* src) {
+AUTOC_STATIC void IntStrMapSetCopy(IntStrMapSet* dst,IntStrMapSet* src) {
     IntStrMapSetIt it;
     assert(src);
     assert(dst);
@@ -361,17 +424,7 @@ AUTOC_STATIC void IntStrMapSetCopy(IntStrMapSet* dst, IntStrMapSet* src) {
     IntStrMapSetItCtor(&it, src);
     while(IntStrMapSetItMove(&it)) IntStrMapSetPut(dst, *IntStrMapSetItGetRef(&it));
 }
-static int IntStrMapSetContainsAllOf(IntStrMapSet* self, IntStrMapSet* other) {
-    IntStrMapSetIt it;
-    IntStrMapSetItCtor(&it, self);
-    while(IntStrMapSetItMove(&it)) {
-        int found = 0;
-        if(IntStrMapSetContains(other, *IntStrMapSetItGetRef(&it))) found = 1;
-        if(!found) return 0;
-    }
-    return 1;
-}
-AUTOC_STATIC int IntStrMapSetEqual(IntStrMapSet* lt, IntStrMapSet* rt) {
+AUTOC_STATIC int IntStrMapSetEqual(IntStrMapSet* lt,IntStrMapSet* rt) {
     assert(lt);
     assert(rt);
     return IntStrMapSetSize(lt) == IntStrMapSetSize(rt) && IntStrMapSetContainsAllOf(lt, rt) && IntStrMapSetContainsAllOf(rt, lt);
@@ -509,7 +562,6 @@ AUTOC_STATIC IntStrMapEntry* IntStrMapSetItGetRef(IntStrMapSetIt* self) {
     return IntStrMapSetListItGetRef(&self->it);
 }
 
-static IntStrMapEntry* IntStrMapItGetEntryRef(IntStrMapIt*);
 void IntStrMapCtor(IntStrMap* self) {
     assert(self);
     IntStrMapSetCtor(&self->entries);
@@ -527,7 +579,7 @@ static int IntStrMapPutEntryRef(IntStrMap* self, IntStrMapEntry* entry) {
     }
     return absent;
 }
-void IntStrMapCopy(IntStrMap* dst, IntStrMap* src) {
+void IntStrMapCopy(IntStrMap* dst,IntStrMap* src) {
     IntStrMapIt it;
     assert(src);
     assert(dst);
@@ -538,22 +590,7 @@ void IntStrMapCopy(IntStrMap* dst, IntStrMap* src) {
         IntStrMapPutEntryRef(dst, e);
     }
 }
-static int IntStrMapContainsAllOf(IntStrMap* self, IntStrMap* other) {
-    IntStrMapIt it;
-    IntStrMapItCtor(&it, self);
-    while(IntStrMapItMove(&it)) {
-        int found = 0;
-        IntStrMapEntry* e = IntStrMapItGetEntryRef(&it);
-        if(IntStrMapContainsKey(other, e->key)) {
-            const char* other_value = IntStrMapGet(other, e->key);
-            found = (e->value == other_value);
-            ;
-        }
-        if(!found) return 0;
-    }
-    return 1;
-}
-int IntStrMapEqual(IntStrMap* lt, IntStrMap* rt) {
+int IntStrMapEqual(IntStrMap* lt,IntStrMap* rt) {
     assert(lt);
     assert(rt);
     return IntStrMapSize(lt) == IntStrMapSize(rt) && IntStrMapContainsAllOf(lt, rt) && IntStrMapContainsAllOf(rt, lt);
@@ -578,18 +615,18 @@ int IntStrMapContainsKey(IntStrMap* self, int key) {
     IntStrMapEntryDtor(entry);
     return result;
 }
-const char* IntStrMapGet(IntStrMap* self, int key) {
-    const char* result;
+const char * IntStrMapGet(IntStrMap* self, int key) {
+    const char * result;
     IntStrMapEntry entry, existing_entry;
     assert(self);
     assert(IntStrMapContainsKey(self, key));
     existing_entry = IntStrMapSetGet(&self->entries, entry = IntStrMapEntryKeyOnlyRef(&key));
-    (result = existing_entry.value);
+    ((result) = (existing_entry.value));
     IntStrMapEntryDtor(existing_entry);
     IntStrMapEntryDtor(entry);
     return result;
 }
-int IntStrMapPut(IntStrMap* self, int key, const char* value) {
+int IntStrMapPut(IntStrMap* self, int key, const char * value) {
     int result;
     IntStrMapEntry entry;
     assert(self);
@@ -598,7 +635,7 @@ int IntStrMapPut(IntStrMap* self, int key, const char* value) {
     IntStrMapEntryDtor(entry);
     return result;
 }
-int IntStrMapReplace(IntStrMap* self, int key, const char* value) {
+int IntStrMapReplace(IntStrMap* self, int key, const char * value) {
     int result;
     IntStrMapEntry entry;
     assert(self);
@@ -629,16 +666,16 @@ int IntStrMapItGetKey(IntStrMapIt* self) {
     int key;
     assert(self);
     e = IntStrMapItGetEntryRef(self);
-    (key = e->key);
+    ((key) = (e->key));
     return key;
 }
-const char* IntStrMapItGetElement(IntStrMapIt* self) {
+const char * IntStrMapItGetElement(IntStrMapIt* self) {
     IntStrMapEntry* e;
-    const char* value;
+    const char * value;
     assert(self);
     e = IntStrMapItGetEntryRef(self);
     assert(e->flags & AUTOC_VALID_VALUE);
-    (value = e->value);
+    ((value) = (e->value));
     return value;
 }
 static IntStrMapEntry* IntStrMapItGetEntryRef(IntStrMapIt* self) {
@@ -650,10 +687,17 @@ static IntStrMapEntry* IntStrMapItGetEntryRef(IntStrMapIt* self) {
 #undef AUTOC_OWNED_VALUE
 #undef AUTOC_OWNED_KEY
 
+#define _IntSetListCtor(self) IntSetListCtor(&self)
+#define _IntSetListDtor(self) IntSetListDtor(&self)
+#define _IntSetListIdentify(self) IntSetListIdentify(&self)
+#define _IntSetListCopy(dst,src) IntSetListCopy(&dst,&src)
+#define _IntSetListEqual(lt,rt) IntSetListEqual(&lt,&rt)
+#define _IntSetListLess(lt,rt) IntSetListLess(&lt,&rt)
+
 AUTOC_STATIC void IntSetListCtor(IntSetList*);
 AUTOC_STATIC void IntSetListDtor(IntSetList*);
-AUTOC_STATIC void IntSetListCopy(IntSetList*, IntSetList*);
-AUTOC_STATIC int IntSetListEqual(IntSetList*, IntSetList*);
+AUTOC_STATIC void IntSetListCopy(IntSetList*,IntSetList*);
+AUTOC_STATIC int IntSetListEqual(IntSetList*,IntSetList*);
 AUTOC_STATIC size_t IntSetListIdentify(IntSetList*);
 AUTOC_STATIC void IntSetListPurge(IntSetList*);
 AUTOC_STATIC int IntSetListPeek(IntSetList*);
@@ -690,7 +734,7 @@ AUTOC_STATIC void IntSetListDtor(IntSetList* self) {
         free(this_node);
     }
 }
-AUTOC_STATIC void IntSetListCopy(IntSetList* dst, IntSetList* src) {
+AUTOC_STATIC void IntSetListCopy(IntSetList* dst,IntSetList* src) {
     IntSetListIt it;
     assert(src);
     assert(dst);
@@ -700,17 +744,18 @@ AUTOC_STATIC void IntSetListCopy(IntSetList* dst, IntSetList* src) {
         IntSetListPush(dst, *IntSetListItGetRef(&it));
     }
 }
-AUTOC_STATIC int IntSetListEqual(IntSetList* lt, IntSetList* rt) {
+AUTOC_STATIC int IntSetListEqual(IntSetList* lt,IntSetList* rt) {
     if(IntSetListSize(lt) == IntSetListSize(rt)) {
         IntSetListIt lit, rit;
         IntSetListItCtor(&lit, lt);
         IntSetListItCtor(&rit, rt);
         while(IntSetListItMove(&lit) && IntSetListItMove(&rit)) {
             int equal;
-            int *le, *re;
+            int* le;
+            int* re;
             le = IntSetListItGetRef(&lit);
             re = IntSetListItGetRef(&rit);
-            equal = (*le == *re);
+            equal = ((*le) == (*re));
             if(!equal) return 0;
         }
         return 1;
@@ -722,7 +767,7 @@ AUTOC_STATIC size_t IntSetListIdentify(IntSetList* self) {
     size_t result = 0;
     assert(self);
     for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= (size_t)(node->element);
+        result ^= ((size_t)(node->element));
         result = AUTOC_RCYCLE(result);
     }
     return result;
@@ -735,7 +780,7 @@ AUTOC_STATIC int IntSetListPeek(IntSetList* self) {
     int result;
     assert(self);
     assert(!IntSetListEmpty(self));
-    (result = self->head_node->element);
+    ((result) = (self->head_node->element));
     return result;
 }
 AUTOC_STATIC int IntSetListPop(IntSetList* self) {
@@ -755,7 +800,7 @@ AUTOC_STATIC void IntSetListPush(IntSetList* self, int element) {
     assert(self);
     node = (IntSetListNode*)malloc(sizeof(IntSetListNode));
     assert(node);
-    (node->element = element);
+    ((node->element) = (element));
     node->next_node = self->head_node;
     self->head_node = node;
     ++self->node_count;
@@ -766,7 +811,7 @@ AUTOC_STATIC int IntSetListContains(IntSetList* self, int what) {
     assert(self);
     node = self->head_node;
     while(node) {
-        if((node->element == what)) {
+        if(((node->element) == (what))) {
             found = 1;
             break;
         }
@@ -780,9 +825,9 @@ AUTOC_STATIC int IntSetListFind(IntSetList* self, int what) {
     assert(IntSetListContains(self, what));
     node = self->head_node;
     while(node) {
-        if((node->element == what)) {
+        if(((node->element) == (what))) {
             int result;
-            (result = node->element);
+            ((result) = (node->element));
             return result;
         }
         node = node->next_node;
@@ -796,9 +841,9 @@ AUTOC_STATIC int IntSetListReplaceEx(IntSetList* self, int with, int count) {
     if(count == 0) return 0;
     node = self->head_node;
     while(node) {
-        if((node->element == with)) {
+        if(((node->element) == (with))) {
             ;
-            (node->element = with);
+            ((node->element) = (with));
             ++replaced;
             if(count > 0 && replaced >= count) break;
         }
@@ -814,7 +859,7 @@ AUTOC_STATIC int IntSetListRemoveEx(IntSetList* self, int what, int count) {
     node = self->head_node;
     prev_node = NULL;
     while(node) {
-        if((node->element == what)) {
+        if(((node->element) == (what))) {
             IntSetListNode* this_node;
             if(prev_node) {
                 this_node = prev_node->next_node = node->next_node;
@@ -858,7 +903,7 @@ AUTOC_STATIC int IntSetListItGet(IntSetListIt* self) {
     int result;
     assert(self);
     assert(self->this_node);
-    (result = self->this_node->element);
+    ((result) = (self->this_node->element));
     return result;
 }
 AUTOC_STATIC int* IntSetListItGetRef(IntSetListIt* self) {
@@ -904,7 +949,7 @@ static void IntSetRehash(IntSet* self) {
         while(IntSetItMove(&it)) {
             IntSetList* bucket;
             int element = IntSetItGet(&it);
-            bucket = &buckets[(size_t)(element) % bucket_count];
+            bucket = &buckets[((size_t)(element)) % bucket_count];
             IntSetListPush(bucket, element);
             ;
         }
@@ -914,6 +959,16 @@ static void IntSetRehash(IntSet* self) {
     self->bucket_count = bucket_count;
     self->size = size;
 }
+static int IntSetContainsAllOf(IntSet* self, IntSet* other) {
+    IntSetIt it;
+    IntSetItCtor(&it, self);
+    while(IntSetItMove(&it)) {
+        int found = 0;
+        if(IntSetContains(other, *IntSetItGetRef(&it))) found = 1;
+        if(!found) return 0;
+    }
+    return 1;
+}
 void IntSetCtor(IntSet* self) {
     assert(self);
     self->min_bucket_count = 16;
@@ -933,7 +988,7 @@ void IntSetDtor(IntSet* self) {
     }
     free(self->buckets);
 }
-void IntSetCopy(IntSet* dst, IntSet* src) {
+void IntSetCopy(IntSet* dst,IntSet* src) {
     IntSetIt it;
     assert(src);
     assert(dst);
@@ -941,17 +996,7 @@ void IntSetCopy(IntSet* dst, IntSet* src) {
     IntSetItCtor(&it, src);
     while(IntSetItMove(&it)) IntSetPut(dst, *IntSetItGetRef(&it));
 }
-static int IntSetContainsAllOf(IntSet* self, IntSet* other) {
-    IntSetIt it;
-    IntSetItCtor(&it, self);
-    while(IntSetItMove(&it)) {
-        int found = 0;
-        if(IntSetContains(other, *IntSetItGetRef(&it))) found = 1;
-        if(!found) return 0;
-    }
-    return 1;
-}
-int IntSetEqual(IntSet* lt, IntSet* rt) {
+int IntSetEqual(IntSet* lt,IntSet* rt) {
     assert(lt);
     assert(rt);
     return IntSetSize(lt) == IntSetSize(rt) && IntSetContainsAllOf(lt, rt) && IntSetContainsAllOf(rt, lt);
@@ -963,7 +1008,7 @@ size_t IntSetIdentify(IntSet* self) {
     IntSetItCtor(&it, self);
     while(IntSetItMove(&it)) {
         int* e = IntSetItGetRef(&it);
-        result ^= (size_t)(*e);
+        result ^= ((size_t)(*e));
         result = AUTOC_RCYCLE(result);
     }
     return result;
@@ -976,13 +1021,13 @@ void IntSetPurge(IntSet* self) {
 }
 int IntSetContains(IntSet* self, int element) {
     assert(self);
-    return IntSetListContains(&self->buckets[(size_t)(element) % self->bucket_count], element);
+    return IntSetListContains(&self->buckets[((size_t)(element)) % self->bucket_count], element);
 }
 int IntSetGet(IntSet* self, int element) {
     int result;
     assert(self);
     assert(IntSetContains(self, element));
-    result = IntSetListFind(&self->buckets[(size_t)(element) % self->bucket_count], element);
+    result = IntSetListFind(&self->buckets[((size_t)(element)) % self->bucket_count], element);
     return result;
 }
 size_t IntSetSize(IntSet* self) {
@@ -992,7 +1037,7 @@ size_t IntSetSize(IntSet* self) {
 int IntSetPut(IntSet* self, int element) {
     IntSetList* bucket;
     assert(self);
-    bucket = &self->buckets[(size_t)(element) % self->bucket_count];
+    bucket = &self->buckets[((size_t)(element)) % self->bucket_count];
     if(!IntSetListContains(bucket, element)) {
         IntSetListPush(bucket, element);
         ++self->size;
@@ -1004,13 +1049,13 @@ int IntSetPut(IntSet* self, int element) {
 int IntSetReplace(IntSet* self, int element) {
     IntSetList* bucket;
     assert(self);
-    bucket = &self->buckets[(size_t)(element) % self->bucket_count];
+    bucket = &self->buckets[((size_t)(element)) % self->bucket_count];
     return IntSetListReplace(bucket, element);
 }
 int IntSetRemove(IntSet* self, int element) {
     IntSetList* bucket;
     assert(self);
-    bucket = &self->buckets[(size_t)(element) % self->bucket_count];
+    bucket = &self->buckets[((size_t)(element)) % self->bucket_count];
     if(IntSetListRemove(bucket, element)) {
         --self->size;
         IntSetRehash(self);
@@ -1089,179 +1134,229 @@ int* IntSetItGetRef(IntSetIt* self) {
     return IntSetListItGetRef(&self->it);
 }
 
-ValueType* ValueTypeQueueItGetRef(ValueTypeQueueIt*);
-void ValueTypeQueueCtor(ValueTypeQueue* self) {
+static void ValueTypeVectorAllocate(ValueTypeVector* self, size_t element_count) {
     assert(self);
-    self->head_node = self->tail_node = NULL;
+    assert(element_count > 0);
+    self->element_count = element_count;
+    self->values = (ValueType*)malloc(element_count*sizeof(ValueType));
+    assert(self->values);
+}
+void ValueTypeVectorCtor(ValueTypeVector* self,size_t element_count) {
+    size_t index;
+    assert(self);
+    ValueTypeVectorAllocate(self, element_count);
+    for(index = 0; index < ValueTypeVectorSize(self); ++index) {
+        ValueTypeCtor(self->values[index]);
+    }
+}
+void ValueTypeVectorDtor(ValueTypeVector* self) {
+    size_t index;
+    assert(self);
+    for(index = 0; index < ValueTypeVectorSize(self); ++index) {
+        ValueTypeDtor(self->values[index]);
+    }
+    free(self->values);
+}
+void ValueTypeVectorCopy(ValueTypeVector* dst,ValueTypeVector* src) {
+    size_t index, size;
+    assert(src);
+    assert(dst);
+    ValueTypeVectorAllocate(dst, size = ValueTypeVectorSize(src));
+    for(index = 0; index < size; ++index) {
+        ValueTypeCopy(dst->values[index],src->values[index]);
+    }
+}
+int ValueTypeVectorEqual(ValueTypeVector* lt,ValueTypeVector* rt) {
+    size_t index, size;
+    assert(lt);
+    assert(rt);
+    if(ValueTypeVectorSize(lt) == (size = ValueTypeVectorSize(rt))) {
+        for(index = 0; index < size; ++index) {
+            if(!ValueTypeEqual(lt->values[index],rt->values[index])) return 0;
+        }
+        return 1;
+    } else
+        return 0;
+}
+size_t ValueTypeVectorIdentify(ValueTypeVector* self) {
+    size_t index, result = 0;
+    assert(self);
+    for(index = 0; index < self->element_count; ++index) {
+        result ^= ValueTypeIdentify(self->values[index]);
+        result = AUTOC_RCYCLE(result);
+    }
+    return result;
+}
+void ValueTypeVectorResize(ValueTypeVector* self, size_t new_element_count) {
+    size_t index, element_count, from, to;
+    assert(self);
+    if((element_count = ValueTypeVectorSize(self)) != new_element_count) {
+        ValueType* values = (ValueType*)malloc(new_element_count*sizeof(ValueType));
+        assert(values);
+        from = AUTOC_MIN(element_count, new_element_count);
+        to = AUTOC_MAX(element_count, new_element_count);
+        for(index = 0; index < from; ++index) {
+            values[index] = self->values[index];
+        }
+        if(element_count > new_element_count) {
+            for(index = from; index < to; ++index) {
+                ValueTypeDtor(self->values[index]);
+            }
+        } else {
+            for(index = from; index < to; ++index) {
+                ValueTypeCtor(values[index]);
+            }
+        }
+        free(self->values);
+        self->values = values;
+        self->element_count = new_element_count;
+    }
+}
+
+static int ValueTypeVectorComparator(void* lp_, void* rp_) {
+    ValueType* lp = (ValueType*)lp_;
+    ValueType* rp = (ValueType*)rp_;
+    if(ValueTypeEqual(*lp,*rp)) {
+        return 0;
+    } else if(ValueTypeLess(*lp,*rp)) {
+        return -1;
+    } else {
+        return +1;
+    }
+}
+void ValueTypeVectorSort(ValueTypeVector* self) {
+    typedef int (*F)(const void*, const void*);
+    assert(self);
+    qsort(self->values, ValueTypeVectorSize(self), sizeof(ValueType), (F)ValueTypeVectorComparator);
+}
+
+IntSet* ListIntSetItGetRef(ListIntSetIt*);
+void ListIntSetCtor(ListIntSet* self) {
+    assert(self);
+    self->head_node = NULL;
     self->node_count = 0;
 }
-void ValueTypeQueueDtor(ValueTypeQueue* self) {
-    ValueTypeQueueNode* node;
+void ListIntSetDtor(ListIntSet* self) {
+    ListIntSetNode* node;
     assert(self);
     node = self->head_node;
     while(node) {
-        ValueTypeQueueNode* this_node = node;
+        ListIntSetNode* this_node = node;
         node = node->next_node;
-        ValueTypeDtor(this_node->element);
+        _IntSetDtor(this_node->element);
         free(this_node);
     }
 }
-void ValueTypeQueueCopy(ValueTypeQueue* dst, ValueTypeQueue* src) {
-    ValueTypeQueueIt it;
+void ListIntSetCopy(ListIntSet* dst,ListIntSet* src) {
+    ListIntSetIt it;
     assert(src);
     assert(dst);
-    ValueTypeQueueCtor(dst);
-    ValueTypeQueueItCtor(&it, src);
-    while(ValueTypeQueueItMove(&it)) {
-        ValueType element;
-        ValueTypeQueuePushTail(dst, element = ValueTypeQueueItGet(&it));
-        ValueTypeDtor(element);
-    }
-}
-int ValueTypeQueueEqual(ValueTypeQueue* lt, ValueTypeQueue* rt) {
-    if(ValueTypeQueueSize(lt) == ValueTypeQueueSize(rt)) {
-        ValueTypeQueueIt lit, rit;
-        ValueTypeQueueItCtor(&lit, lt);
-        ValueTypeQueueItCtor(&rit, rt);
-        while(ValueTypeQueueItMove(&lit) && ValueTypeQueueItMove(&rit)) {
+    ListIntSetCtor(dst);
+    ListIntSetItCtor(&it, src);
+    while(ListIntSetItMove(&it)) {
+        ListIntSetPush(dst, *ListIntSetItGetRef(&it));
+    }
+}
+int ListIntSetEqual(ListIntSet* lt,ListIntSet* rt) {
+    if(ListIntSetSize(lt) == ListIntSetSize(rt)) {
+        ListIntSetIt lit, rit;
+        ListIntSetItCtor(&lit, lt);
+        ListIntSetItCtor(&rit, rt);
+        while(ListIntSetItMove(&lit) && ListIntSetItMove(&rit)) {
             int equal;
-            ValueType *le, *re;
-            le = ValueTypeQueueItGetRef(&lit);
-            re = ValueTypeQueueItGetRef(&rit);
-            equal = ValueTypeEqual(*le, *re);
+            IntSet* le;
+            IntSet* re;
+            le = ListIntSetItGetRef(&lit);
+            re = ListIntSetItGetRef(&rit);
+            equal = _IntSetEqual(*le,*re);
             if(!equal) return 0;
         }
         return 1;
     } else
         return 0;
 }
-size_t ValueTypeQueueIdentify(ValueTypeQueue* self) {
-    ValueTypeQueueNode* node;
+size_t ListIntSetIdentify(ListIntSet* self) {
+    ListIntSetNode* node;
     size_t result = 0;
     assert(self);
     for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= ValueTypeIdentify(node->element);
+        result ^= _IntSetIdentify(node->element);
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-void ValueTypeQueuePurge(ValueTypeQueue* self) {
-    ValueTypeQueueDtor(self);
-    ValueTypeQueueCtor(self);
-}
-ValueType ValueTypeQueuePeekHead(ValueTypeQueue* self) {
-    ValueType result;
-    assert(self);
-    assert(!ValueTypeQueueEmpty(self));
-    ValueTypeCopy(result, self->head_node->element);
-    return result;
+void ListIntSetPurge(ListIntSet* self) {
+    ListIntSetDtor(self);
+    ListIntSetCtor(self);
 }
-ValueType ValueTypeQueuePeekTail(ValueTypeQueue* self) {
-    ValueType result;
+IntSet ListIntSetPeek(ListIntSet* self) {
+    IntSet result;
     assert(self);
-    assert(!ValueTypeQueueEmpty(self));
-    ValueTypeCopy(result, self->tail_node->element);
+    assert(!ListIntSetEmpty(self));
+    _IntSetCopy(result,self->head_node->element);
     return result;
 }
-ValueType ValueTypeQueuePopHead(ValueTypeQueue* self) {
-    ValueTypeQueueNode* node;
-    ValueType result;
+IntSet ListIntSetPop(ListIntSet* self) {
+    ListIntSetNode* node;
+    IntSet result;
     assert(self);
-    assert(!ValueTypeQueueEmpty(self));
+    assert(!ListIntSetEmpty(self));
     node = self->head_node;
     result = node->element;
     self->head_node = self->head_node->next_node;
-    self->head_node->prev_node = NULL;
     --self->node_count;
     free(node);
     return result;
 }
-ValueType ValueTypeQueuePopTail(ValueTypeQueue* self) {
-    ValueTypeQueueNode* node;
-    ValueType result;
+void ListIntSetPush(ListIntSet* self, IntSet element) {
+    ListIntSetNode* node;
     assert(self);
-    assert(!ValueTypeQueueEmpty(self));
-    node = self->tail_node;
-    result = node->element;
-    self->tail_node = self->tail_node->prev_node;
-    self->tail_node->next_node = NULL;
-    --self->node_count;
-    free(node);
-    return result;
+    node = (ListIntSetNode*)malloc(sizeof(ListIntSetNode));
+    assert(node);
+    _IntSetCopy(node->element,element);
+    node->next_node = self->head_node;
+    self->head_node = node;
+    ++self->node_count;
 }
-void ValueTypeQueuePushTail(ValueTypeQueue* self, ValueType element) {
-    ValueTypeQueueNode* node;
+int ListIntSetContains(ListIntSet* self, IntSet what) {
+    ListIntSetNode* node;
+    int found = 0;
     assert(self);
-    node = (ValueTypeQueueNode*)malloc(sizeof(ValueTypeQueueNode));
-    assert(node);
-    ValueTypeCopy(node->element, element);
-    if(ValueTypeQueueEmpty(self)) {
-        node->prev_node = node->next_node = NULL;
-        self->tail_node = self->head_node = node;
-    } else {
-        node->next_node = NULL;
-        node->prev_node = self->tail_node;
-        self->tail_node->next_node = node;
-        self->tail_node = node;
+    node = self->head_node;
+    while(node) {
+        if(_IntSetEqual(node->element,what)) {
+            found = 1;
+            break;
+        }
+        node = node->next_node;
     }
-    ++self->node_count;
+    return found;
 }
-void ValueTypeQueuePushHead(ValueTypeQueue* self, ValueType element) {
-    ValueTypeQueueNode* node;
+IntSet ListIntSetFind(ListIntSet* self, IntSet what) {
+    ListIntSetNode* node;
     assert(self);
-    node = (ValueTypeQueueNode*)malloc(sizeof(ValueTypeQueueNode));
-    assert(node);
-    ValueTypeCopy(node->element, element);
-    if(ValueTypeQueueEmpty(self)) {
-        node->prev_node = node->next_node = NULL;
-        self->tail_node = self->head_node = node;
-    } else {
-        node->prev_node = NULL;
-        node->next_node = self->head_node;
-        self->head_node->prev_node = node;
-        self->head_node = node;
-    }
-    ++self->node_count;
-}
-int ValueTypeQueueContains(ValueTypeQueue* self, ValueType what) {
-    ValueTypeQueueNode* node;
-    int found = 0;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            found = 1;
-            break;
-        }
-        node = node->next_node;
-    }
-    return found;
-}
-ValueType ValueTypeQueueFind(ValueTypeQueue* self, ValueType what) {
-    ValueTypeQueueNode* node;
-    assert(self);
-    assert(ValueTypeQueueContains(self, what));
+    assert(ListIntSetContains(self, what));
     node = self->head_node;
     while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            ValueType result;
-            ValueTypeCopy(result, node->element);
+        if(_IntSetEqual(node->element,what)) {
+            IntSet result;
+            _IntSetCopy(result,node->element);
             return result;
         }
         node = node->next_node;
     }
     abort();
 }
-int ValueTypeQueueReplaceEx(ValueTypeQueue* self, ValueType with, int count) {
-    ValueTypeQueueNode* node;
+int ListIntSetReplaceEx(ListIntSet* self, IntSet with, int count) {
+    ListIntSetNode* node;
     int replaced = 0;
     assert(self);
     if(count == 0) return 0;
     node = self->head_node;
     while(node) {
-        if(ValueTypeEqual(node->element, with)) {
-            ValueTypeDtor(node->element);
-            ValueTypeCopy(node->element, with);
+        if(_IntSetEqual(node->element,with)) {
+            _IntSetDtor(node->element);
+            _IntSetCopy(node->element,with);
             ++replaced;
             if(count > 0 && replaced >= count) break;
         }
@@ -1269,363 +1364,350 @@ int ValueTypeQueueReplaceEx(ValueTypeQueue* self, ValueType with, int count) {
     }
     return replaced;
 }
-int ValueTypeQueueRemoveEx(ValueTypeQueue* self, ValueType what, int count) {
-    ValueTypeQueueNode* node;
+int ListIntSetRemoveEx(ListIntSet* self, IntSet what, int count) {
+    ListIntSetNode *node, *prev_node;
     int removed = 0;
     assert(self);
     if(count == 0) return 0;
     node = self->head_node;
+    prev_node = NULL;
     while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            ValueTypeQueueNode* this_node;
-            if(node == self->head_node) {
-                assert(!node->prev_node);
-                this_node = self->head_node = node->next_node;
-                if(self->head_node) self->head_node->prev_node = NULL;
-            } else if(node == self->tail_node) {
-                assert(!node->next_node);
-                self->tail_node = node->prev_node;
-                this_node = self->tail_node->next_node = NULL;
+        if(_IntSetEqual(node->element,what)) {
+            ListIntSetNode* this_node;
+            if(prev_node) {
+                this_node = prev_node->next_node = node->next_node;
             } else {
-                assert(node->prev_node);
-                assert(node->next_node);
-                this_node = node->next_node;
-                node->next_node->prev_node = node->prev_node;
-                node->prev_node->next_node = node->next_node;
+                this_node = self->head_node = node->next_node;
             }
             ++removed;
             --self->node_count;
-            ValueTypeDtor(node->element);
+            _IntSetDtor(node->element);
             free(node);
             node = this_node;
             if(count > 0 && removed >= count) break;
         } else {
+            prev_node = node;
             node = node->next_node;
         }
     }
     return removed;
 }
-size_t ValueTypeQueueSize(ValueTypeQueue* self) {
+size_t ListIntSetSize(ListIntSet* self) {
     assert(self);
     return self->node_count;
 }
-void ValueTypeQueueItCtorEx(ValueTypeQueueIt* self, ValueTypeQueue* queue, int forward) {
+void ListIntSetItCtor(ListIntSetIt* self, ListIntSet* list) {
     assert(self);
-    assert(queue);
+    assert(list);
     self->start = 1;
-    self->queue = queue;
-    self->forward = forward;
+    self->list = list;
 }
-int ValueTypeQueueItMove(ValueTypeQueueIt* self) {
+int ListIntSetItMove(ListIntSetIt* self) {
     assert(self);
     if(self->start) {
-        self->this_node = self->forward ? self->queue->head_node : self->queue->tail_node;
+        self->this_node = self->list->head_node;
         self->start = 0;
     } else {
-        self->this_node = self->forward ? self->this_node->next_node : self->this_node->prev_node;
+        self->this_node = self->this_node ? self->this_node->next_node : NULL;
     }
     return self->this_node != NULL;
 }
-ValueType ValueTypeQueueItGet(ValueTypeQueueIt* self) {
-    ValueType result;
+IntSet ListIntSetItGet(ListIntSetIt* self) {
+    IntSet result;
     assert(self);
     assert(self->this_node);
-    ValueTypeCopy(result, self->this_node->element);
+    _IntSetCopy(result,self->this_node->element);
     return result;
 }
-ValueType* ValueTypeQueueItGetRef(ValueTypeQueueIt* self) {
+IntSet* ListIntSetItGetRef(ListIntSetIt* self) {
     assert(self);
     assert(self->this_node);
     return &self->this_node->element;
 }
 
-ValueType* ValueTypeListItGetRef(ValueTypeListIt*);
-void ValueTypeListCtor(ValueTypeList* self) {
+static void PIntVectorAllocate(PIntVector* self, size_t element_count) {
     assert(self);
-    self->head_node = NULL;
-    self->node_count = 0;
+    assert(element_count > 0);
+    self->element_count = element_count;
+    self->values = (int**)malloc(element_count*sizeof(int*));
+    assert(self->values);
 }
-void ValueTypeListDtor(ValueTypeList* self) {
-    ValueTypeListNode* node;
+void PIntVectorCtor(PIntVector* self,size_t element_count) {
+    size_t index;
     assert(self);
-    node = self->head_node;
-    while(node) {
-        ValueTypeListNode* this_node = node;
-        node = node->next_node;
-        ValueTypeDtor(this_node->element);
-        free(this_node);
+    PIntVectorAllocate(self, element_count);
+    for(index = 0; index < PIntVectorSize(self); ++index) {
+        ((self->values[index]) = IntNew());
     }
 }
-void ValueTypeListCopy(ValueTypeList* dst, ValueTypeList* src) {
-    ValueTypeListIt it;
+void PIntVectorDtor(PIntVector* self) {
+    size_t index;
+    assert(self);
+    for(index = 0; index < PIntVectorSize(self); ++index) {
+        IntFree(self->values[index]);
+    }
+    free(self->values);
+}
+void PIntVectorCopy(PIntVector* dst,PIntVector* src) {
+    size_t index, size;
     assert(src);
     assert(dst);
-    ValueTypeListCtor(dst);
-    ValueTypeListItCtor(&it, src);
-    while(ValueTypeListItMove(&it)) {
-        ValueTypeListPush(dst, *ValueTypeListItGetRef(&it));
+    PIntVectorAllocate(dst, size = PIntVectorSize(src));
+    for(index = 0; index < size; ++index) {
+        ((dst->values[index]) = IntRef(src->values[index]));
     }
 }
-int ValueTypeListEqual(ValueTypeList* lt, ValueTypeList* rt) {
-    if(ValueTypeListSize(lt) == ValueTypeListSize(rt)) {
-        ValueTypeListIt lit, rit;
-        ValueTypeListItCtor(&lit, lt);
-        ValueTypeListItCtor(&rit, rt);
-        while(ValueTypeListItMove(&lit) && ValueTypeListItMove(&rit)) {
-            int equal;
-            ValueType *le, *re;
-            le = ValueTypeListItGetRef(&lit);
-            re = ValueTypeListItGetRef(&rit);
-            equal = ValueTypeEqual(*le, *re);
-            if(!equal) return 0;
+int PIntVectorEqual(PIntVector* lt,PIntVector* rt) {
+    size_t index, size;
+    assert(lt);
+    assert(rt);
+    if(PIntVectorSize(lt) == (size = PIntVectorSize(rt))) {
+        for(index = 0; index < size; ++index) {
+            if(!((*lt->values[index]) == (*rt->values[index]))) return 0;
         }
         return 1;
     } else
         return 0;
 }
-size_t ValueTypeListIdentify(ValueTypeList* self) {
-    ValueTypeListNode* node;
-    size_t result = 0;
+size_t PIntVectorIdentify(PIntVector* self) {
+    size_t index, result = 0;
     assert(self);
-    for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= ValueTypeIdentify(node->element);
+    for(index = 0; index < self->element_count; ++index) {
+        result ^= ((size_t)(*self->values[index]));
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-void ValueTypeListPurge(ValueTypeList* self) {
-    ValueTypeListDtor(self);
-    ValueTypeListCtor(self);
-}
-ValueType ValueTypeListPeek(ValueTypeList* self) {
-    ValueType result;
-    assert(self);
-    assert(!ValueTypeListEmpty(self));
-    ValueTypeCopy(result, self->head_node->element);
-    return result;
-}
-ValueType ValueTypeListPop(ValueTypeList* self) {
-    ValueTypeListNode* node;
-    ValueType result;
-    assert(self);
-    assert(!ValueTypeListEmpty(self));
-    node = self->head_node;
-    result = node->element;
-    self->head_node = self->head_node->next_node;
-    --self->node_count;
-    free(node);
-    return result;
-}
-void ValueTypeListPush(ValueTypeList* self, ValueType element) {
-    ValueTypeListNode* node;
-    assert(self);
-    node = (ValueTypeListNode*)malloc(sizeof(ValueTypeListNode));
-    assert(node);
-    ValueTypeCopy(node->element, element);
-    node->next_node = self->head_node;
-    self->head_node = node;
-    ++self->node_count;
-}
-int ValueTypeListContains(ValueTypeList* self, ValueType what) {
-    ValueTypeListNode* node;
-    int found = 0;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            found = 1;
-            break;
-        }
-        node = node->next_node;
-    }
-    return found;
-}
-ValueType ValueTypeListFind(ValueTypeList* self, ValueType what) {
-    ValueTypeListNode* node;
-    assert(self);
-    assert(ValueTypeListContains(self, what));
-    node = self->head_node;
-    while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            ValueType result;
-            ValueTypeCopy(result, node->element);
-            return result;
-        }
-        node = node->next_node;
-    }
-    abort();
-}
-int ValueTypeListReplaceEx(ValueTypeList* self, ValueType with, int count) {
-    ValueTypeListNode* node;
-    int replaced = 0;
+void PIntVectorResize(PIntVector* self, size_t new_element_count) {
+    size_t index, element_count, from, to;
     assert(self);
-    if(count == 0) return 0;
-    node = self->head_node;
-    while(node) {
-        if(ValueTypeEqual(node->element, with)) {
-            ValueTypeDtor(node->element);
-            ValueTypeCopy(node->element, with);
-            ++replaced;
-            if(count > 0 && replaced >= count) break;
+    if((element_count = PIntVectorSize(self)) != new_element_count) {
+        int** values = (int**)malloc(new_element_count*sizeof(int*));
+        assert(values);
+        from = AUTOC_MIN(element_count, new_element_count);
+        to = AUTOC_MAX(element_count, new_element_count);
+        for(index = 0; index < from; ++index) {
+            values[index] = self->values[index];
         }
-        node = node->next_node;
-    }
-    return replaced;
-}
-int ValueTypeListRemoveEx(ValueTypeList* self, ValueType what, int count) {
-    ValueTypeListNode *node, *prev_node;
-    int removed = 0;
-    assert(self);
-    if(count == 0) return 0;
-    node = self->head_node;
-    prev_node = NULL;
-    while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            ValueTypeListNode* this_node;
-            if(prev_node) {
-                this_node = prev_node->next_node = node->next_node;
-            } else {
-                this_node = self->head_node = node->next_node;
+        if(element_count > new_element_count) {
+            for(index = from; index < to; ++index) {
+                IntFree(self->values[index]);
             }
-            ++removed;
-            --self->node_count;
-            ValueTypeDtor(node->element);
-            free(node);
-            node = this_node;
-            if(count > 0 && removed >= count) break;
         } else {
-            prev_node = node;
-            node = node->next_node;
+            for(index = from; index < to; ++index) {
+                ((values[index]) = IntNew());
+            }
         }
+        free(self->values);
+        self->values = values;
+        self->element_count = new_element_count;
     }
-    return removed;
-}
-size_t ValueTypeListSize(ValueTypeList* self) {
-    assert(self);
-    return self->node_count;
-}
-void ValueTypeListItCtor(ValueTypeListIt* self, ValueTypeList* list) {
-    assert(self);
-    assert(list);
-    self->start = 1;
-    self->list = list;
 }
-int ValueTypeListItMove(ValueTypeListIt* self) {
-    assert(self);
-    if(self->start) {
-        self->this_node = self->list->head_node;
-        self->start = 0;
+
+static int PIntVectorComparator(void* lp_, void* rp_) {
+    int** lp = (int**)lp_;
+    int** rp = (int**)rp_;
+    if(((**lp) == (**rp))) {
+        return 0;
+    } else if(((**lp) < (**rp))) {
+        return -1;
     } else {
-        self->this_node = self->this_node ? self->this_node->next_node : NULL;
+        return +1;
     }
-    return self->this_node != NULL;
-}
-ValueType ValueTypeListItGet(ValueTypeListIt* self) {
-    ValueType result;
-    assert(self);
-    assert(self->this_node);
-    ValueTypeCopy(result, self->this_node->element);
-    return result;
 }
-ValueType* ValueTypeListItGetRef(ValueTypeListIt* self) {
+void PIntVectorSort(PIntVector* self) {
+    typedef int (*F)(const void*, const void*);
     assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
+    qsort(self->values, PIntVectorSize(self), sizeof(int*), (F)PIntVectorComparator);
 }
 
-AUTOC_STATIC void ValueTypeSetListCtor(ValueTypeSetList*);
-AUTOC_STATIC void ValueTypeSetListDtor(ValueTypeSetList*);
-AUTOC_STATIC void ValueTypeSetListCopy(ValueTypeSetList*, ValueTypeSetList*);
-AUTOC_STATIC int ValueTypeSetListEqual(ValueTypeSetList*, ValueTypeSetList*);
-AUTOC_STATIC size_t ValueTypeSetListIdentify(ValueTypeSetList*);
-AUTOC_STATIC void ValueTypeSetListPurge(ValueTypeSetList*);
-AUTOC_STATIC ValueType ValueTypeSetListPeek(ValueTypeSetList*);
-AUTOC_STATIC ValueType ValueTypeSetListPop(ValueTypeSetList*);
-AUTOC_STATIC void ValueTypeSetListPush(ValueTypeSetList*, ValueType);
-AUTOC_STATIC int ValueTypeSetListContains(ValueTypeSetList*, ValueType);
-AUTOC_STATIC ValueType ValueTypeSetListFind(ValueTypeSetList*, ValueType);
-#define ValueTypeSetListReplace(self, with) ValueTypeSetListReplaceEx(self, with, 1)
-#define ValueTypeSetListReplaceAll(self, with) ValueTypeSetListReplaceEx(self, with, -1)
-AUTOC_STATIC int ValueTypeSetListReplaceEx(ValueTypeSetList*, ValueType, int);
-#define ValueTypeSetListRemove(self, what) ValueTypeSetListRemoveEx(self, what, 1)
-#define ValueTypeSetListRemoveAll(self, what) ValueTypeSetListRemoveEx(self, what, -1)
-AUTOC_STATIC int ValueTypeSetListRemoveEx(ValueTypeSetList*, ValueType, int);
-AUTOC_STATIC size_t ValueTypeSetListSize(ValueTypeSetList*);
-#define ValueTypeSetListEmpty(self) (ValueTypeSetListSize(self) == 0)
-AUTOC_STATIC void ValueTypeSetListItCtor(ValueTypeSetListIt*, ValueTypeSetList*);
-AUTOC_STATIC int ValueTypeSetListItMove(ValueTypeSetListIt*);
-AUTOC_STATIC ValueType ValueTypeSetListItGet(ValueTypeSetListIt*);
+#define AUTOC_VALID_VALUE 1
+#define AUTOC_VALID_KEY 2
+#define AUTOC_OWNED_VALUE 4
+#define AUTOC_OWNED_KEY 8
+static ValueTypeMapEntry ValueTypeMapEntryKeyOnlyRef(ValueType* key) {
+    ValueTypeMapEntry entry;
+    entry.key = *key;
+    entry.flags = AUTOC_VALID_KEY;
+    return entry;
+}
+static ValueTypeMapEntry ValueTypeMapEntryKeyValueRef(ValueType* key, ValueType* value) {
+    ValueTypeMapEntry entry;
+    entry.key = *key;
+    entry.value = *value;
+    entry.flags = (AUTOC_VALID_KEY | AUTOC_VALID_VALUE);
+    return entry;
+}
+#define ValueTypeMapEntryIdentify(obj) ValueTypeMapEntryIdentifyRef(&obj)
+static size_t ValueTypeMapEntryIdentifyRef(ValueTypeMapEntry* entry) {
+    return ValueTypeIdentify(entry->key);
+}
+#define ValueTypeMapEntryEqual(lt, rt) ValueTypeMapEntryEqualRef(&lt, &rt)
+static int ValueTypeMapEntryEqualRef(ValueTypeMapEntry* lt, ValueTypeMapEntry* rt) {
+    return ValueTypeEqual(lt->key,rt->key);
+}
+#define ValueTypeMapEntryCopy(dst, src) ValueTypeMapEntryCopyRef(&dst, &src)
+static void ValueTypeMapEntryCopyRef(ValueTypeMapEntry* dst, ValueTypeMapEntry* src) {
+    assert(src->flags & AUTOC_VALID_KEY);
+    dst->flags = (AUTOC_VALID_KEY | AUTOC_OWNED_KEY);
+    ValueTypeCopy(dst->key,src->key);
+    if(src->flags & AUTOC_VALID_VALUE) {
+        dst->flags |= (AUTOC_VALID_VALUE | AUTOC_OWNED_VALUE);
+        ValueTypeCopy(dst->value,src->value);
+    }
+}
+#define ValueTypeMapEntryDtor(obj) ValueTypeMapEntryDtorRef(&obj)
+static void ValueTypeMapEntryDtorRef(ValueTypeMapEntry* entry) {
+    assert(entry->flags & AUTOC_VALID_KEY);
+    if(entry->flags & AUTOC_OWNED_KEY) ValueTypeDtor(entry->key);
+    if(entry->flags & AUTOC_VALID_VALUE && entry->flags & AUTOC_OWNED_VALUE) ValueTypeDtor(entry->value);
+}
+static ValueTypeMapEntry* ValueTypeMapItGetEntryRef(ValueTypeMapIt*);
+static int ValueTypeMapContainsAllOf(ValueTypeMap* self, ValueTypeMap* other) {
+    ValueTypeMapIt it;
+    ValueTypeMapItCtor(&it, self);
+    while(ValueTypeMapItMove(&it)) {
+        int found = 0;
+        ValueTypeMapEntry* e = ValueTypeMapItGetEntryRef(&it);
+        if(ValueTypeMapContainsKey(other, e->key)) {
+            ValueType other_value = ValueTypeMapGet(other, e->key);
+            found = ValueTypeEqual(e->value,other_value);
+            ValueTypeDtor(other_value);
+        }
+        if(!found) return 0;
+    }
+    return 1;
+}
 
-AUTOC_STATIC ValueType* ValueTypeSetListItGetRef(ValueTypeSetListIt*);
-AUTOC_STATIC void ValueTypeSetListCtor(ValueTypeSetList* self) {
+#define _ValueTypeMapSetCtor(self) ValueTypeMapSetCtor(&self)
+#define _ValueTypeMapSetDtor(self) ValueTypeMapSetDtor(&self)
+#define _ValueTypeMapSetIdentify(self) ValueTypeMapSetIdentify(&self)
+#define _ValueTypeMapSetCopy(dst,src) ValueTypeMapSetCopy(&dst,&src)
+#define _ValueTypeMapSetEqual(lt,rt) ValueTypeMapSetEqual(&lt,&rt)
+#define _ValueTypeMapSetLess(lt,rt) ValueTypeMapSetLess(&lt,&rt)
+
+AUTOC_STATIC void ValueTypeMapSetCtor(ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetDtor(ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetCopy(ValueTypeMapSet*,ValueTypeMapSet*);
+AUTOC_STATIC int ValueTypeMapSetEqual(ValueTypeMapSet*,ValueTypeMapSet*);
+AUTOC_STATIC size_t ValueTypeMapSetIdentify(ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetPurge(ValueTypeMapSet*);
+AUTOC_STATIC int ValueTypeMapSetContains(ValueTypeMapSet*, ValueTypeMapEntry);
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetGet(ValueTypeMapSet*, ValueTypeMapEntry);
+AUTOC_STATIC size_t ValueTypeMapSetSize(ValueTypeMapSet*);
+#define ValueTypeMapSetEmpty(self) (ValueTypeMapSetSize(self) == 0)
+AUTOC_STATIC int ValueTypeMapSetPut(ValueTypeMapSet*, ValueTypeMapEntry);
+AUTOC_STATIC int ValueTypeMapSetReplace(ValueTypeMapSet*, ValueTypeMapEntry);
+AUTOC_STATIC int ValueTypeMapSetRemove(ValueTypeMapSet*, ValueTypeMapEntry);
+AUTOC_STATIC void ValueTypeMapSetExclude(ValueTypeMapSet*, ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetRetain(ValueTypeMapSet*, ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetInclude(ValueTypeMapSet*, ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetInvert(ValueTypeMapSet*, ValueTypeMapSet*);
+AUTOC_STATIC void ValueTypeMapSetItCtor(ValueTypeMapSetIt*, ValueTypeMapSet*);
+AUTOC_STATIC int ValueTypeMapSetItMove(ValueTypeMapSetIt*);
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetItGet(ValueTypeMapSetIt*);
+
+#define _ValueTypeMapSetListCtor(self) ValueTypeMapSetListCtor(&self)
+#define _ValueTypeMapSetListDtor(self) ValueTypeMapSetListDtor(&self)
+#define _ValueTypeMapSetListIdentify(self) ValueTypeMapSetListIdentify(&self)
+#define _ValueTypeMapSetListCopy(dst,src) ValueTypeMapSetListCopy(&dst,&src)
+#define _ValueTypeMapSetListEqual(lt,rt) ValueTypeMapSetListEqual(&lt,&rt)
+#define _ValueTypeMapSetListLess(lt,rt) ValueTypeMapSetListLess(&lt,&rt)
+
+AUTOC_STATIC void ValueTypeMapSetListCtor(ValueTypeMapSetList*);
+AUTOC_STATIC void ValueTypeMapSetListDtor(ValueTypeMapSetList*);
+AUTOC_STATIC void ValueTypeMapSetListCopy(ValueTypeMapSetList*,ValueTypeMapSetList*);
+AUTOC_STATIC int ValueTypeMapSetListEqual(ValueTypeMapSetList*,ValueTypeMapSetList*);
+AUTOC_STATIC size_t ValueTypeMapSetListIdentify(ValueTypeMapSetList*);
+AUTOC_STATIC void ValueTypeMapSetListPurge(ValueTypeMapSetList*);
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPeek(ValueTypeMapSetList*);
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPop(ValueTypeMapSetList*);
+AUTOC_STATIC void ValueTypeMapSetListPush(ValueTypeMapSetList*, ValueTypeMapEntry);
+AUTOC_STATIC int ValueTypeMapSetListContains(ValueTypeMapSetList*, ValueTypeMapEntry);
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListFind(ValueTypeMapSetList*, ValueTypeMapEntry);
+#define ValueTypeMapSetListReplace(self, with) ValueTypeMapSetListReplaceEx(self, with, 1)
+#define ValueTypeMapSetListReplaceAll(self, with) ValueTypeMapSetListReplaceEx(self, with, -1)
+AUTOC_STATIC int ValueTypeMapSetListReplaceEx(ValueTypeMapSetList*, ValueTypeMapEntry, int);
+#define ValueTypeMapSetListRemove(self, what) ValueTypeMapSetListRemoveEx(self, what, 1)
+#define ValueTypeMapSetListRemoveAll(self, what) ValueTypeMapSetListRemoveEx(self, what, -1)
+AUTOC_STATIC int ValueTypeMapSetListRemoveEx(ValueTypeMapSetList*, ValueTypeMapEntry, int);
+AUTOC_STATIC size_t ValueTypeMapSetListSize(ValueTypeMapSetList*);
+#define ValueTypeMapSetListEmpty(self) (ValueTypeMapSetListSize(self) == 0)
+AUTOC_STATIC void ValueTypeMapSetListItCtor(ValueTypeMapSetListIt*, ValueTypeMapSetList*);
+AUTOC_STATIC int ValueTypeMapSetListItMove(ValueTypeMapSetListIt*);
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListItGet(ValueTypeMapSetListIt*);
+
+AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetListItGetRef(ValueTypeMapSetListIt*);
+AUTOC_STATIC void ValueTypeMapSetListCtor(ValueTypeMapSetList* self) {
     assert(self);
     self->head_node = NULL;
     self->node_count = 0;
 }
-AUTOC_STATIC void ValueTypeSetListDtor(ValueTypeSetList* self) {
-    ValueTypeSetListNode* node;
+AUTOC_STATIC void ValueTypeMapSetListDtor(ValueTypeMapSetList* self) {
+    ValueTypeMapSetListNode* node;
     assert(self);
     node = self->head_node;
     while(node) {
-        ValueTypeSetListNode* this_node = node;
+        ValueTypeMapSetListNode* this_node = node;
         node = node->next_node;
-        ValueTypeDtor(this_node->element);
+        ValueTypeMapEntryDtor(this_node->element);
         free(this_node);
     }
 }
-AUTOC_STATIC void ValueTypeSetListCopy(ValueTypeSetList* dst, ValueTypeSetList* src) {
-    ValueTypeSetListIt it;
+AUTOC_STATIC void ValueTypeMapSetListCopy(ValueTypeMapSetList* dst,ValueTypeMapSetList* src) {
+    ValueTypeMapSetListIt it;
     assert(src);
     assert(dst);
-    ValueTypeSetListCtor(dst);
-    ValueTypeSetListItCtor(&it, src);
-    while(ValueTypeSetListItMove(&it)) {
-        ValueTypeSetListPush(dst, *ValueTypeSetListItGetRef(&it));
+    ValueTypeMapSetListCtor(dst);
+    ValueTypeMapSetListItCtor(&it, src);
+    while(ValueTypeMapSetListItMove(&it)) {
+        ValueTypeMapSetListPush(dst, *ValueTypeMapSetListItGetRef(&it));
     }
 }
-AUTOC_STATIC int ValueTypeSetListEqual(ValueTypeSetList* lt, ValueTypeSetList* rt) {
-    if(ValueTypeSetListSize(lt) == ValueTypeSetListSize(rt)) {
-        ValueTypeSetListIt lit, rit;
-        ValueTypeSetListItCtor(&lit, lt);
-        ValueTypeSetListItCtor(&rit, rt);
-        while(ValueTypeSetListItMove(&lit) && ValueTypeSetListItMove(&rit)) {
+AUTOC_STATIC int ValueTypeMapSetListEqual(ValueTypeMapSetList* lt,ValueTypeMapSetList* rt) {
+    if(ValueTypeMapSetListSize(lt) == ValueTypeMapSetListSize(rt)) {
+        ValueTypeMapSetListIt lit, rit;
+        ValueTypeMapSetListItCtor(&lit, lt);
+        ValueTypeMapSetListItCtor(&rit, rt);
+        while(ValueTypeMapSetListItMove(&lit) && ValueTypeMapSetListItMove(&rit)) {
             int equal;
-            ValueType *le, *re;
-            le = ValueTypeSetListItGetRef(&lit);
-            re = ValueTypeSetListItGetRef(&rit);
-            equal = ValueTypeEqual(*le, *re);
+            ValueTypeMapEntry* le;
+            ValueTypeMapEntry* re;
+            le = ValueTypeMapSetListItGetRef(&lit);
+            re = ValueTypeMapSetListItGetRef(&rit);
+            equal = ValueTypeMapEntryEqual(*le,*re);
             if(!equal) return 0;
         }
         return 1;
     } else
         return 0;
 }
-AUTOC_STATIC size_t ValueTypeSetListIdentify(ValueTypeSetList* self) {
-    ValueTypeSetListNode* node;
+AUTOC_STATIC size_t ValueTypeMapSetListIdentify(ValueTypeMapSetList* self) {
+    ValueTypeMapSetListNode* node;
     size_t result = 0;
     assert(self);
     for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= ValueTypeIdentify(node->element);
+        result ^= ValueTypeMapEntryIdentify(node->element);
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-AUTOC_STATIC void ValueTypeSetListPurge(ValueTypeSetList* self) {
-    ValueTypeSetListDtor(self);
-    ValueTypeSetListCtor(self);
+AUTOC_STATIC void ValueTypeMapSetListPurge(ValueTypeMapSetList* self) {
+    ValueTypeMapSetListDtor(self);
+    ValueTypeMapSetListCtor(self);
 }
-AUTOC_STATIC ValueType ValueTypeSetListPeek(ValueTypeSetList* self) {
-    ValueType result;
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPeek(ValueTypeMapSetList* self) {
+    ValueTypeMapEntry result;
     assert(self);
-    assert(!ValueTypeSetListEmpty(self));
-    ValueTypeCopy(result, self->head_node->element);
+    assert(!ValueTypeMapSetListEmpty(self));
+    ValueTypeMapEntryCopy(result,self->head_node->element);
     return result;
 }
-AUTOC_STATIC ValueType ValueTypeSetListPop(ValueTypeSetList* self) {
-    ValueTypeSetListNode* node;
-    ValueType result;
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPop(ValueTypeMapSetList* self) {
+    ValueTypeMapSetListNode* node;
+    ValueTypeMapEntry result;
     assert(self);
-    assert(!ValueTypeSetListEmpty(self));
+    assert(!ValueTypeMapSetListEmpty(self));
     node = self->head_node;
     result = node->element;
     self->head_node = self->head_node->next_node;
@@ -1633,23 +1715,23 @@ AUTOC_STATIC ValueType ValueTypeSetListPop(ValueTypeSetList* self) {
     free(node);
     return result;
 }
-AUTOC_STATIC void ValueTypeSetListPush(ValueTypeSetList* self, ValueType element) {
-    ValueTypeSetListNode* node;
+AUTOC_STATIC void ValueTypeMapSetListPush(ValueTypeMapSetList* self, ValueTypeMapEntry element) {
+    ValueTypeMapSetListNode* node;
     assert(self);
-    node = (ValueTypeSetListNode*)malloc(sizeof(ValueTypeSetListNode));
+    node = (ValueTypeMapSetListNode*)malloc(sizeof(ValueTypeMapSetListNode));
     assert(node);
-    ValueTypeCopy(node->element, element);
+    ValueTypeMapEntryCopy(node->element,element);
     node->next_node = self->head_node;
     self->head_node = node;
     ++self->node_count;
 }
-AUTOC_STATIC int ValueTypeSetListContains(ValueTypeSetList* self, ValueType what) {
-    ValueTypeSetListNode* node;
+AUTOC_STATIC int ValueTypeMapSetListContains(ValueTypeMapSetList* self, ValueTypeMapEntry what) {
+    ValueTypeMapSetListNode* node;
     int found = 0;
     assert(self);
     node = self->head_node;
     while(node) {
-        if(ValueTypeEqual(node->element, what)) {
+        if(ValueTypeMapEntryEqual(node->element,what)) {
             found = 1;
             break;
         }
@@ -1657,31 +1739,31 @@ AUTOC_STATIC int ValueTypeSetListContains(ValueTypeSetList* self, ValueType what
     }
     return found;
 }
-AUTOC_STATIC ValueType ValueTypeSetListFind(ValueTypeSetList* self, ValueType what) {
-    ValueTypeSetListNode* node;
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListFind(ValueTypeMapSetList* self, ValueTypeMapEntry what) {
+    ValueTypeMapSetListNode* node;
     assert(self);
-    assert(ValueTypeSetListContains(self, what));
+    assert(ValueTypeMapSetListContains(self, what));
     node = self->head_node;
     while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            ValueType result;
-            ValueTypeCopy(result, node->element);
+        if(ValueTypeMapEntryEqual(node->element,what)) {
+            ValueTypeMapEntry result;
+            ValueTypeMapEntryCopy(result,node->element);
             return result;
         }
         node = node->next_node;
     }
     abort();
 }
-AUTOC_STATIC int ValueTypeSetListReplaceEx(ValueTypeSetList* self, ValueType with, int count) {
-    ValueTypeSetListNode* node;
+AUTOC_STATIC int ValueTypeMapSetListReplaceEx(ValueTypeMapSetList* self, ValueTypeMapEntry with, int count) {
+    ValueTypeMapSetListNode* node;
     int replaced = 0;
     assert(self);
     if(count == 0) return 0;
     node = self->head_node;
     while(node) {
-        if(ValueTypeEqual(node->element, with)) {
-            ValueTypeDtor(node->element);
-            ValueTypeCopy(node->element, with);
+        if(ValueTypeMapEntryEqual(node->element,with)) {
+            ValueTypeMapEntryDtor(node->element);
+            ValueTypeMapEntryCopy(node->element,with);
             ++replaced;
             if(count > 0 && replaced >= count) break;
         }
@@ -1689,16 +1771,16 @@ AUTOC_STATIC int ValueTypeSetListReplaceEx(ValueTypeSetList* self, ValueType wit
     }
     return replaced;
 }
-AUTOC_STATIC int ValueTypeSetListRemoveEx(ValueTypeSetList* self, ValueType what, int count) {
-    ValueTypeSetListNode *node, *prev_node;
+AUTOC_STATIC int ValueTypeMapSetListRemoveEx(ValueTypeMapSetList* self, ValueTypeMapEntry what, int count) {
+    ValueTypeMapSetListNode *node, *prev_node;
     int removed = 0;
     assert(self);
     if(count == 0) return 0;
     node = self->head_node;
     prev_node = NULL;
     while(node) {
-        if(ValueTypeEqual(node->element, what)) {
-            ValueTypeSetListNode* this_node;
+        if(ValueTypeMapEntryEqual(node->element,what)) {
+            ValueTypeMapSetListNode* this_node;
             if(prev_node) {
                 this_node = prev_node->next_node = node->next_node;
             } else {
@@ -1706,7 +1788,7 @@ AUTOC_STATIC int ValueTypeSetListRemoveEx(ValueTypeSetList* self, ValueType what
             }
             ++removed;
             --self->node_count;
-            ValueTypeDtor(node->element);
+            ValueTypeMapEntryDtor(node->element);
             free(node);
             node = this_node;
             if(count > 0 && removed >= count) break;
@@ -1717,17 +1799,17 @@ AUTOC_STATIC int ValueTypeSetListRemoveEx(ValueTypeSetList* self, ValueType what
     }
     return removed;
 }
-AUTOC_STATIC size_t ValueTypeSetListSize(ValueTypeSetList* self) {
+AUTOC_STATIC size_t ValueTypeMapSetListSize(ValueTypeMapSetList* self) {
     assert(self);
     return self->node_count;
 }
-AUTOC_STATIC void ValueTypeSetListItCtor(ValueTypeSetListIt* self, ValueTypeSetList* list) {
+AUTOC_STATIC void ValueTypeMapSetListItCtor(ValueTypeMapSetListIt* self, ValueTypeMapSetList* list) {
     assert(self);
     assert(list);
     self->start = 1;
     self->list = list;
 }
-AUTOC_STATIC int ValueTypeSetListItMove(ValueTypeSetListIt* self) {
+AUTOC_STATIC int ValueTypeMapSetListItMove(ValueTypeMapSetListIt* self) {
     assert(self);
     if(self->start) {
         self->this_node = self->list->head_node;
@@ -1737,22 +1819,22 @@ AUTOC_STATIC int ValueTypeSetListItMove(ValueTypeSetListIt* self) {
     }
     return self->this_node != NULL;
 }
-AUTOC_STATIC ValueType ValueTypeSetListItGet(ValueTypeSetListIt* self) {
-    ValueType result;
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListItGet(ValueTypeMapSetListIt* self) {
+    ValueTypeMapEntry result;
     assert(self);
     assert(self->this_node);
-    ValueTypeCopy(result, self->this_node->element);
+    ValueTypeMapEntryCopy(result,self->this_node->element);
     return result;
 }
-AUTOC_STATIC ValueType* ValueTypeSetListItGetRef(ValueTypeSetListIt* self) {
+AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetListItGetRef(ValueTypeMapSetListIt* self) {
     assert(self);
     assert(self->this_node);
     return &self->this_node->element;
 }
 
-ValueType* ValueTypeSetItGetRef(ValueTypeSetIt*);
-static void ValueTypeSetRehash(ValueTypeSet* self) {
-    ValueTypeSetList* buckets;
+AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetItGetRef(ValueTypeMapSetIt*);
+static void ValueTypeMapSetRehash(ValueTypeMapSet* self) {
+    ValueTypeMapSetList* buckets;
     size_t index, bucket_count, size, fill;
     assert(self);
     assert(self->min_fill > 0);
@@ -1776,358 +1858,428 @@ static void ValueTypeSetRehash(ValueTypeSet* self) {
         bucket_count = self->min_bucket_count;
         size = 0;
     }
-    buckets = (ValueTypeSetList*)malloc(bucket_count*sizeof(ValueTypeSetList));
+    buckets = (ValueTypeMapSetList*)malloc(bucket_count*sizeof(ValueTypeMapSetList));
     assert(buckets);
     for(index = 0; index < bucket_count; ++index) {
-        ValueTypeSetListCtor(&buckets[index]);
+        ValueTypeMapSetListCtor(&buckets[index]);
     }
     if(self->buckets) {
-        ValueTypeSetIt it;
-        ValueTypeSetItCtor(&it, self);
-        while(ValueTypeSetItMove(&it)) {
-            ValueTypeSetList* bucket;
-            ValueType element = ValueTypeSetItGet(&it);
-            bucket = &buckets[ValueTypeIdentify(element) % bucket_count];
-            ValueTypeSetListPush(bucket, element);
-            ValueTypeDtor(element);
+        ValueTypeMapSetIt it;
+        ValueTypeMapSetItCtor(&it, self);
+        while(ValueTypeMapSetItMove(&it)) {
+            ValueTypeMapSetList* bucket;
+            ValueTypeMapEntry element = ValueTypeMapSetItGet(&it);
+            bucket = &buckets[ValueTypeMapEntryIdentify(element) % bucket_count];
+            ValueTypeMapSetListPush(bucket, element);
+            ValueTypeMapEntryDtor(element);
         }
-        ValueTypeSetDtor(self);
+        ValueTypeMapSetDtor(self);
     }
     self->buckets = buckets;
     self->bucket_count = bucket_count;
     self->size = size;
 }
-void ValueTypeSetCtor(ValueTypeSet* self) {
-    assert(self);
-    self->min_bucket_count = 16;
-    self->min_fill = 20;
-    self->max_fill = 80;
-    self->min_size = (size_t)((float)self->min_fill/100*self->min_bucket_count);
-    self->max_size = (size_t)((float)self->max_fill/100*self->min_bucket_count);
-    self->capacity_multiplier = 200;
-    self->buckets = NULL;
-    ValueTypeSetRehash(self);
+static int ValueTypeMapSetContainsAllOf(ValueTypeMapSet* self, ValueTypeMapSet* other) {
+    ValueTypeMapSetIt it;
+    ValueTypeMapSetItCtor(&it, self);
+    while(ValueTypeMapSetItMove(&it)) {
+        int found = 0;
+        if(ValueTypeMapSetContains(other, *ValueTypeMapSetItGetRef(&it))) found = 1;
+        if(!found) return 0;
+    }
+    return 1;
 }
-void ValueTypeSetDtor(ValueTypeSet* self) {
+AUTOC_STATIC void ValueTypeMapSetCtor(ValueTypeMapSet* self) {
+    assert(self);
+    self->min_bucket_count = 16;
+    self->min_fill = 20;
+    self->max_fill = 80;
+    self->min_size = (size_t)((float)self->min_fill/100*self->min_bucket_count);
+    self->max_size = (size_t)((float)self->max_fill/100*self->min_bucket_count);
+    self->capacity_multiplier = 200;
+    self->buckets = NULL;
+    ValueTypeMapSetRehash(self);
+}
+AUTOC_STATIC void ValueTypeMapSetDtor(ValueTypeMapSet* self) {
     size_t i;
     assert(self);
     for(i = 0; i < self->bucket_count; ++i) {
-        ValueTypeSetListDtor(&self->buckets[i]);
+        ValueTypeMapSetListDtor(&self->buckets[i]);
     }
     free(self->buckets);
 }
-void ValueTypeSetCopy(ValueTypeSet* dst, ValueTypeSet* src) {
-    ValueTypeSetIt it;
+AUTOC_STATIC void ValueTypeMapSetCopy(ValueTypeMapSet* dst,ValueTypeMapSet* src) {
+    ValueTypeMapSetIt it;
     assert(src);
     assert(dst);
-    ValueTypeSetCtor(dst);
-    ValueTypeSetItCtor(&it, src);
-    while(ValueTypeSetItMove(&it)) ValueTypeSetPut(dst, *ValueTypeSetItGetRef(&it));
-}
-static int ValueTypeSetContainsAllOf(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        int found = 0;
-        if(ValueTypeSetContains(other, *ValueTypeSetItGetRef(&it))) found = 1;
-        if(!found) return 0;
-    }
-    return 1;
+    ValueTypeMapSetCtor(dst);
+    ValueTypeMapSetItCtor(&it, src);
+    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetPut(dst, *ValueTypeMapSetItGetRef(&it));
 }
-int ValueTypeSetEqual(ValueTypeSet* lt, ValueTypeSet* rt) {
+AUTOC_STATIC int ValueTypeMapSetEqual(ValueTypeMapSet* lt,ValueTypeMapSet* rt) {
     assert(lt);
     assert(rt);
-    return ValueTypeSetSize(lt) == ValueTypeSetSize(rt) && ValueTypeSetContainsAllOf(lt, rt) && ValueTypeSetContainsAllOf(rt, lt);
+    return ValueTypeMapSetSize(lt) == ValueTypeMapSetSize(rt) && ValueTypeMapSetContainsAllOf(lt, rt) && ValueTypeMapSetContainsAllOf(rt, lt);
 }
-size_t ValueTypeSetIdentify(ValueTypeSet* self) {
-    ValueTypeSetIt it;
+AUTOC_STATIC size_t ValueTypeMapSetIdentify(ValueTypeMapSet* self) {
+    ValueTypeMapSetIt it;
     size_t result = 0;
     assert(self);
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        result ^= ValueTypeIdentify(*e);
+    ValueTypeMapSetItCtor(&it, self);
+    while(ValueTypeMapSetItMove(&it)) {
+        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
+        result ^= ValueTypeMapEntryIdentify(*e);
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-void ValueTypeSetPurge(ValueTypeSet* self) {
+AUTOC_STATIC void ValueTypeMapSetPurge(ValueTypeMapSet* self) {
     assert(self);
-    ValueTypeSetDtor(self);
+    ValueTypeMapSetDtor(self);
     self->buckets = NULL;
-    ValueTypeSetRehash(self);
+    ValueTypeMapSetRehash(self);
 }
-int ValueTypeSetContains(ValueTypeSet* self, ValueType element) {
+AUTOC_STATIC int ValueTypeMapSetContains(ValueTypeMapSet* self, ValueTypeMapEntry element) {
     assert(self);
-    return ValueTypeSetListContains(&self->buckets[ValueTypeIdentify(element) % self->bucket_count], element);
+    return ValueTypeMapSetListContains(&self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count], element);
 }
-ValueType ValueTypeSetGet(ValueTypeSet* self, ValueType element) {
-    ValueType result;
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetGet(ValueTypeMapSet* self, ValueTypeMapEntry element) {
+    ValueTypeMapEntry result;
     assert(self);
-    assert(ValueTypeSetContains(self, element));
-    result = ValueTypeSetListFind(&self->buckets[ValueTypeIdentify(element) % self->bucket_count], element);
+    assert(ValueTypeMapSetContains(self, element));
+    result = ValueTypeMapSetListFind(&self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count], element);
     return result;
 }
-size_t ValueTypeSetSize(ValueTypeSet* self) {
+AUTOC_STATIC size_t ValueTypeMapSetSize(ValueTypeMapSet* self) {
     assert(self);
     return self->size;
 }
-int ValueTypeSetPut(ValueTypeSet* self, ValueType element) {
-    ValueTypeSetList* bucket;
+AUTOC_STATIC int ValueTypeMapSetPut(ValueTypeMapSet* self, ValueTypeMapEntry element) {
+    ValueTypeMapSetList* bucket;
     assert(self);
-    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
-    if(!ValueTypeSetListContains(bucket, element)) {
-        ValueTypeSetListPush(bucket, element);
+    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
+    if(!ValueTypeMapSetListContains(bucket, element)) {
+        ValueTypeMapSetListPush(bucket, element);
         ++self->size;
-        ValueTypeSetRehash(self);
+        ValueTypeMapSetRehash(self);
         return 1;
     }
     return 0;
 }
-int ValueTypeSetReplace(ValueTypeSet* self, ValueType element) {
-    ValueTypeSetList* bucket;
+AUTOC_STATIC int ValueTypeMapSetReplace(ValueTypeMapSet* self, ValueTypeMapEntry element) {
+    ValueTypeMapSetList* bucket;
     assert(self);
-    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
-    return ValueTypeSetListReplace(bucket, element);
+    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
+    return ValueTypeMapSetListReplace(bucket, element);
 }
-int ValueTypeSetRemove(ValueTypeSet* self, ValueType element) {
-    ValueTypeSetList* bucket;
+AUTOC_STATIC int ValueTypeMapSetRemove(ValueTypeMapSet* self, ValueTypeMapEntry element) {
+    ValueTypeMapSetList* bucket;
     assert(self);
-    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
-    if(ValueTypeSetListRemove(bucket, element)) {
+    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
+    if(ValueTypeMapSetListRemove(bucket, element)) {
         --self->size;
-        ValueTypeSetRehash(self);
+        ValueTypeMapSetRehash(self);
         return 1;
     }
     return 0;
 }
-void ValueTypeSetExclude(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
+AUTOC_STATIC void ValueTypeMapSetExclude(ValueTypeMapSet* self, ValueTypeMapSet* other) {
+    ValueTypeMapSetIt it;
     assert(self);
     assert(other);
-    ValueTypeSetItCtor(&it, other);
-    while(ValueTypeSetItMove(&it)) ValueTypeSetRemove(self, *ValueTypeSetItGetRef(&it));
+    ValueTypeMapSetItCtor(&it, other);
+    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetRemove(self, *ValueTypeMapSetItGetRef(&it));
 }
-void ValueTypeSetInclude(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
+AUTOC_STATIC void ValueTypeMapSetInclude(ValueTypeMapSet* self, ValueTypeMapSet* other) {
+    ValueTypeMapSetIt it;
     assert(self);
     assert(other);
-    ValueTypeSetItCtor(&it, other);
-    while(ValueTypeSetItMove(&it)) ValueTypeSetPut(self, *ValueTypeSetItGetRef(&it));
+    ValueTypeMapSetItCtor(&it, other);
+    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetPut(self, *ValueTypeMapSetItGetRef(&it));
 }
-void ValueTypeSetRetain(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    ValueTypeSet set;
+AUTOC_STATIC void ValueTypeMapSetRetain(ValueTypeMapSet* self, ValueTypeMapSet* other) {
+    ValueTypeMapSetIt it;
+    ValueTypeMapSet set;
     assert(self);
     assert(other);
-    ValueTypeSetCtor(&set);
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        if(ValueTypeSetContains(other, *e)) ValueTypeSetPut(&set, *e);
+    ValueTypeMapSetCtor(&set);
+    ValueTypeMapSetItCtor(&it, self);
+    while(ValueTypeMapSetItMove(&it)) {
+        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
+        if(ValueTypeMapSetContains(other, *e)) ValueTypeMapSetPut(&set, *e);
     }
-    ValueTypeSetDtor(self);
+    ValueTypeMapSetDtor(self);
     *self = set;
 }
-void ValueTypeSetInvert(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    ValueTypeSet set;
+AUTOC_STATIC void ValueTypeMapSetInvert(ValueTypeMapSet* self, ValueTypeMapSet* other) {
+    ValueTypeMapSetIt it;
+    ValueTypeMapSet set;
     assert(self);
     assert(other);
-    ValueTypeSetCtor(&set);
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        if(!ValueTypeSetContains(other, *e)) ValueTypeSetPut(&set, *e);
+    ValueTypeMapSetCtor(&set);
+    ValueTypeMapSetItCtor(&it, self);
+    while(ValueTypeMapSetItMove(&it)) {
+        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
+        if(!ValueTypeMapSetContains(other, *e)) ValueTypeMapSetPut(&set, *e);
     }
-    ValueTypeSetItCtor(&it, other);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        if(!ValueTypeSetContains(self, *e)) ValueTypeSetPut(&set, *e);
+    ValueTypeMapSetItCtor(&it, other);
+    while(ValueTypeMapSetItMove(&it)) {
+        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
+        if(!ValueTypeMapSetContains(self, *e)) ValueTypeMapSetPut(&set, *e);
     }
-    ValueTypeSetDtor(self);
+    ValueTypeMapSetDtor(self);
     *self = set;
 }
-void ValueTypeSetItCtor(ValueTypeSetIt* self, ValueTypeSet* set) {
+AUTOC_STATIC void ValueTypeMapSetItCtor(ValueTypeMapSetIt* self, ValueTypeMapSet* set) {
     assert(self);
     self->set = set;
     self->bucket_index = -1;
 }
-int ValueTypeSetItMove(ValueTypeSetIt* self) {
+AUTOC_STATIC int ValueTypeMapSetItMove(ValueTypeMapSetIt* self) {
     assert(self);
-    if(self->bucket_index < 0) ValueTypeSetListItCtor(&self->it, &self->set->buckets[self->bucket_index = 0]);
-    if(ValueTypeSetListItMove(&self->it)) return 1;
+    if(self->bucket_index < 0) ValueTypeMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index = 0]);
+    if(ValueTypeMapSetListItMove(&self->it)) return 1;
     while(++self->bucket_index < self->set->bucket_count) {
-        ValueTypeSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
-        if(ValueTypeSetListItMove(&self->it)) return 1;
+        ValueTypeMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
+        if(ValueTypeMapSetListItMove(&self->it)) return 1;
     }
     return 0;
 }
-ValueType ValueTypeSetItGet(ValueTypeSetIt* self) {
+AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetItGet(ValueTypeMapSetIt* self) {
     assert(self);
-    return ValueTypeSetListItGet(&self->it);
+    return ValueTypeMapSetListItGet(&self->it);
 }
-ValueType* ValueTypeSetItGetRef(ValueTypeSetIt* self) {
+AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetItGetRef(ValueTypeMapSetIt* self) {
     assert(self);
-    return ValueTypeSetListItGetRef(&self->it);
+    return ValueTypeMapSetListItGetRef(&self->it);
 }
 
-#define AUTOC_VALID_VALUE 1
-#define AUTOC_VALID_KEY 2
-#define AUTOC_OWNED_VALUE 4
-#define AUTOC_OWNED_KEY 8
-static ValueTypeMapEntry ValueTypeMapEntryKeyOnlyRef(ValueType* key) {
-    ValueTypeMapEntry entry;
-    entry.key = *key;
-    entry.flags = AUTOC_VALID_KEY;
-    return entry;
-}
-static ValueTypeMapEntry ValueTypeMapEntryKeyValueRef(ValueType* key, ValueType* value) {
-    ValueTypeMapEntry entry;
-    entry.key = *key;
-    entry.value = *value;
-    entry.flags = (AUTOC_VALID_KEY | AUTOC_VALID_VALUE);
-    return entry;
+void ValueTypeMapCtor(ValueTypeMap* self) {
+    assert(self);
+    ValueTypeMapSetCtor(&self->entries);
 }
-#define ValueTypeMapEntryIdentify(obj) ValueTypeMapEntryIdentifyRef(&obj)
-static size_t ValueTypeMapEntryIdentifyRef(ValueTypeMapEntry* entry) {
-    return ValueTypeIdentify(entry->key);
+void ValueTypeMapDtor(ValueTypeMap* self) {
+    assert(self);
+    ValueTypeMapSetDtor(&self->entries);
 }
-#define ValueTypeMapEntryEqual(lt, rt) ValueTypeMapEntryEqualRef(&lt, &rt)
-static int ValueTypeMapEntryEqualRef(ValueTypeMapEntry* lt, ValueTypeMapEntry* rt) {
-    return ValueTypeEqual(lt->key, rt->key);
+static int ValueTypeMapPutEntryRef(ValueTypeMap* self, ValueTypeMapEntry* entry) {
+    int absent;
+    assert(self);
+    assert(entry);
+    if((absent = !ValueTypeMapContainsKey(self, entry->key))) {
+        ValueTypeMapSetPut(&self->entries, *entry);
+    }
+    return absent;
 }
-#define ValueTypeMapEntryCopy(dst, src) ValueTypeMapEntryCopyRef(&dst, &src)
-static void ValueTypeMapEntryCopyRef(ValueTypeMapEntry* dst, ValueTypeMapEntry* src) {
-    assert(src->flags & AUTOC_VALID_KEY);
-    dst->flags = (AUTOC_VALID_KEY | AUTOC_OWNED_KEY);
-    ValueTypeCopy(dst->key, src->key);
-    if(src->flags & AUTOC_VALID_VALUE) {
-        dst->flags |= (AUTOC_VALID_VALUE | AUTOC_OWNED_VALUE);
-        ValueTypeCopy(dst->value, src->value);
+void ValueTypeMapCopy(ValueTypeMap* dst,ValueTypeMap* src) {
+    ValueTypeMapIt it;
+    assert(src);
+    assert(dst);
+    ValueTypeMapCtor(dst);
+    ValueTypeMapItCtor(&it, src);
+    while(ValueTypeMapItMove(&it)) {
+        ValueTypeMapEntry* e = ValueTypeMapItGetEntryRef(&it);
+        ValueTypeMapPutEntryRef(dst, e);
     }
 }
-#define ValueTypeMapEntryDtor(obj) ValueTypeMapEntryDtorRef(&obj)
-static void ValueTypeMapEntryDtorRef(ValueTypeMapEntry* entry) {
-    assert(entry->flags & AUTOC_VALID_KEY);
-    if(entry->flags & AUTOC_OWNED_KEY) ValueTypeDtor(entry->key);
-    if(entry->flags & AUTOC_VALID_VALUE && entry->flags & AUTOC_OWNED_VALUE) ValueTypeDtor(entry->value);
+int ValueTypeMapEqual(ValueTypeMap* lt,ValueTypeMap* rt) {
+    assert(lt);
+    assert(rt);
+    return ValueTypeMapSize(lt) == ValueTypeMapSize(rt) && ValueTypeMapContainsAllOf(lt, rt) && ValueTypeMapContainsAllOf(rt, lt);
 }
+size_t ValueTypeMapIdentify(ValueTypeMap* self) {
+    assert(self);
+    return ValueTypeMapSetIdentify(&self->entries); /* TODO : make use of the values' hashes */
+}
+void ValueTypeMapPurge(ValueTypeMap* self) {
+    assert(self);
+    ValueTypeMapSetPurge(&self->entries);
+}
+size_t ValueTypeMapSize(ValueTypeMap* self) {
+    assert(self);
+    return ValueTypeMapSetSize(&self->entries);
+}
+int ValueTypeMapContainsKey(ValueTypeMap* self, ValueType key) {
+    int result;
+    ValueTypeMapEntry entry;
+    assert(self);
+    result = ValueTypeMapSetContains(&self->entries, entry = ValueTypeMapEntryKeyOnlyRef(&key));
+    ValueTypeMapEntryDtor(entry);
+    return result;
+}
+ValueType ValueTypeMapGet(ValueTypeMap* self, ValueType key) {
+    ValueType result;
+    ValueTypeMapEntry entry, existing_entry;
+    assert(self);
+    assert(ValueTypeMapContainsKey(self, key));
+    existing_entry = ValueTypeMapSetGet(&self->entries, entry = ValueTypeMapEntryKeyOnlyRef(&key));
+    ValueTypeCopy(result,existing_entry.value);
+    ValueTypeMapEntryDtor(existing_entry);
+    ValueTypeMapEntryDtor(entry);
+    return result;
+}
+int ValueTypeMapPut(ValueTypeMap* self, ValueType key, ValueType value) {
+    int result;
+    ValueTypeMapEntry entry;
+    assert(self);
+    entry = ValueTypeMapEntryKeyValueRef(&key, &value);
+    result = ValueTypeMapPutEntryRef(self, &entry);
+    ValueTypeMapEntryDtor(entry);
+    return result;
+}
+int ValueTypeMapReplace(ValueTypeMap* self, ValueType key, ValueType value) {
+    int result;
+    ValueTypeMapEntry entry;
+    assert(self);
+    entry = ValueTypeMapEntryKeyValueRef(&key, &value);
+    result = ValueTypeMapSetReplace(&self->entries, entry);
+    ValueTypeMapEntryDtor(entry);
+    return result;
+}
+int ValueTypeMapRemove(ValueTypeMap* self, ValueType key) {
+    int result;
+    ValueTypeMapEntry entry;
+    assert(self);
+    result = ValueTypeMapSetRemove(&self->entries, entry = ValueTypeMapEntryKeyOnlyRef(&key));
+    ValueTypeMapEntryDtor(entry);
+    return result;
+}
+void ValueTypeMapItCtor(ValueTypeMapIt* self, ValueTypeMap* map) {
+    assert(self);
+    assert(map);
+    ValueTypeMapSetItCtor(&self->it, &map->entries);
+}
+int ValueTypeMapItMove(ValueTypeMapIt* self) {
+    assert(self);
+    return ValueTypeMapSetItMove(&self->it);
+}
+ValueType ValueTypeMapItGetKey(ValueTypeMapIt* self) {
+    ValueTypeMapEntry* e;
+    ValueType key;
+    assert(self);
+    e = ValueTypeMapItGetEntryRef(self);
+    ValueTypeCopy(key,e->key);
+    return key;
+}
+ValueType ValueTypeMapItGetElement(ValueTypeMapIt* self) {
+    ValueTypeMapEntry* e;
+    ValueType value;
+    assert(self);
+    e = ValueTypeMapItGetEntryRef(self);
+    assert(e->flags & AUTOC_VALID_VALUE);
+    ValueTypeCopy(value,e->value);
+    return value;
+}
+static ValueTypeMapEntry* ValueTypeMapItGetEntryRef(ValueTypeMapIt* self) {
+    assert(self);
+    return ValueTypeMapSetItGetRef(&self->it);
+}
+#undef AUTOC_VALID_VALUE
+#undef AUTOC_VALID_KEY
+#undef AUTOC_OWNED_VALUE
+#undef AUTOC_OWNED_KEY
 
-AUTOC_STATIC void ValueTypeMapSetCtor(ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetDtor(ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetCopy(ValueTypeMapSet*, ValueTypeMapSet*);
-AUTOC_STATIC int ValueTypeMapSetEqual(ValueTypeMapSet*, ValueTypeMapSet*);
-AUTOC_STATIC size_t ValueTypeMapSetIdentify(ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetPurge(ValueTypeMapSet*);
-AUTOC_STATIC int ValueTypeMapSetContains(ValueTypeMapSet*, ValueTypeMapEntry);
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetGet(ValueTypeMapSet*, ValueTypeMapEntry);
-AUTOC_STATIC size_t ValueTypeMapSetSize(ValueTypeMapSet*);
-#define ValueTypeMapSetEmpty(self) (ValueTypeMapSetSize(self) == 0)
-AUTOC_STATIC int ValueTypeMapSetPut(ValueTypeMapSet*, ValueTypeMapEntry);
-AUTOC_STATIC int ValueTypeMapSetReplace(ValueTypeMapSet*, ValueTypeMapEntry);
-AUTOC_STATIC int ValueTypeMapSetRemove(ValueTypeMapSet*, ValueTypeMapEntry);
-AUTOC_STATIC void ValueTypeMapSetExclude(ValueTypeMapSet*, ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetRetain(ValueTypeMapSet*, ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetInclude(ValueTypeMapSet*, ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetInvert(ValueTypeMapSet*, ValueTypeMapSet*);
-AUTOC_STATIC void ValueTypeMapSetItCtor(ValueTypeMapSetIt*, ValueTypeMapSet*);
-AUTOC_STATIC int ValueTypeMapSetItMove(ValueTypeMapSetIt*);
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetItGet(ValueTypeMapSetIt*);
-
-AUTOC_STATIC void ValueTypeMapSetListCtor(ValueTypeMapSetList*);
-AUTOC_STATIC void ValueTypeMapSetListDtor(ValueTypeMapSetList*);
-AUTOC_STATIC void ValueTypeMapSetListCopy(ValueTypeMapSetList*, ValueTypeMapSetList*);
-AUTOC_STATIC int ValueTypeMapSetListEqual(ValueTypeMapSetList*, ValueTypeMapSetList*);
-AUTOC_STATIC size_t ValueTypeMapSetListIdentify(ValueTypeMapSetList*);
-AUTOC_STATIC void ValueTypeMapSetListPurge(ValueTypeMapSetList*);
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPeek(ValueTypeMapSetList*);
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPop(ValueTypeMapSetList*);
-AUTOC_STATIC void ValueTypeMapSetListPush(ValueTypeMapSetList*, ValueTypeMapEntry);
-AUTOC_STATIC int ValueTypeMapSetListContains(ValueTypeMapSetList*, ValueTypeMapEntry);
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListFind(ValueTypeMapSetList*, ValueTypeMapEntry);
-#define ValueTypeMapSetListReplace(self, with) ValueTypeMapSetListReplaceEx(self, with, 1)
-#define ValueTypeMapSetListReplaceAll(self, with) ValueTypeMapSetListReplaceEx(self, with, -1)
-AUTOC_STATIC int ValueTypeMapSetListReplaceEx(ValueTypeMapSetList*, ValueTypeMapEntry, int);
-#define ValueTypeMapSetListRemove(self, what) ValueTypeMapSetListRemoveEx(self, what, 1)
-#define ValueTypeMapSetListRemoveAll(self, what) ValueTypeMapSetListRemoveEx(self, what, -1)
-AUTOC_STATIC int ValueTypeMapSetListRemoveEx(ValueTypeMapSetList*, ValueTypeMapEntry, int);
-AUTOC_STATIC size_t ValueTypeMapSetListSize(ValueTypeMapSetList*);
-#define ValueTypeMapSetListEmpty(self) (ValueTypeMapSetListSize(self) == 0)
-AUTOC_STATIC void ValueTypeMapSetListItCtor(ValueTypeMapSetListIt*, ValueTypeMapSetList*);
-AUTOC_STATIC int ValueTypeMapSetListItMove(ValueTypeMapSetListIt*);
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListItGet(ValueTypeMapSetListIt*);
+#define _ValueTypeSetListCtor(self) ValueTypeSetListCtor(&self)
+#define _ValueTypeSetListDtor(self) ValueTypeSetListDtor(&self)
+#define _ValueTypeSetListIdentify(self) ValueTypeSetListIdentify(&self)
+#define _ValueTypeSetListCopy(dst,src) ValueTypeSetListCopy(&dst,&src)
+#define _ValueTypeSetListEqual(lt,rt) ValueTypeSetListEqual(&lt,&rt)
+#define _ValueTypeSetListLess(lt,rt) ValueTypeSetListLess(&lt,&rt)
 
-AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetListItGetRef(ValueTypeMapSetListIt*);
-AUTOC_STATIC void ValueTypeMapSetListCtor(ValueTypeMapSetList* self) {
+AUTOC_STATIC void ValueTypeSetListCtor(ValueTypeSetList*);
+AUTOC_STATIC void ValueTypeSetListDtor(ValueTypeSetList*);
+AUTOC_STATIC void ValueTypeSetListCopy(ValueTypeSetList*,ValueTypeSetList*);
+AUTOC_STATIC int ValueTypeSetListEqual(ValueTypeSetList*,ValueTypeSetList*);
+AUTOC_STATIC size_t ValueTypeSetListIdentify(ValueTypeSetList*);
+AUTOC_STATIC void ValueTypeSetListPurge(ValueTypeSetList*);
+AUTOC_STATIC ValueType ValueTypeSetListPeek(ValueTypeSetList*);
+AUTOC_STATIC ValueType ValueTypeSetListPop(ValueTypeSetList*);
+AUTOC_STATIC void ValueTypeSetListPush(ValueTypeSetList*, ValueType);
+AUTOC_STATIC int ValueTypeSetListContains(ValueTypeSetList*, ValueType);
+AUTOC_STATIC ValueType ValueTypeSetListFind(ValueTypeSetList*, ValueType);
+#define ValueTypeSetListReplace(self, with) ValueTypeSetListReplaceEx(self, with, 1)
+#define ValueTypeSetListReplaceAll(self, with) ValueTypeSetListReplaceEx(self, with, -1)
+AUTOC_STATIC int ValueTypeSetListReplaceEx(ValueTypeSetList*, ValueType, int);
+#define ValueTypeSetListRemove(self, what) ValueTypeSetListRemoveEx(self, what, 1)
+#define ValueTypeSetListRemoveAll(self, what) ValueTypeSetListRemoveEx(self, what, -1)
+AUTOC_STATIC int ValueTypeSetListRemoveEx(ValueTypeSetList*, ValueType, int);
+AUTOC_STATIC size_t ValueTypeSetListSize(ValueTypeSetList*);
+#define ValueTypeSetListEmpty(self) (ValueTypeSetListSize(self) == 0)
+AUTOC_STATIC void ValueTypeSetListItCtor(ValueTypeSetListIt*, ValueTypeSetList*);
+AUTOC_STATIC int ValueTypeSetListItMove(ValueTypeSetListIt*);
+AUTOC_STATIC ValueType ValueTypeSetListItGet(ValueTypeSetListIt*);
+
+AUTOC_STATIC ValueType* ValueTypeSetListItGetRef(ValueTypeSetListIt*);
+AUTOC_STATIC void ValueTypeSetListCtor(ValueTypeSetList* self) {
     assert(self);
     self->head_node = NULL;
     self->node_count = 0;
 }
-AUTOC_STATIC void ValueTypeMapSetListDtor(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListNode* node;
+AUTOC_STATIC void ValueTypeSetListDtor(ValueTypeSetList* self) {
+    ValueTypeSetListNode* node;
     assert(self);
     node = self->head_node;
     while(node) {
-        ValueTypeMapSetListNode* this_node = node;
+        ValueTypeSetListNode* this_node = node;
         node = node->next_node;
-        ValueTypeMapEntryDtor(this_node->element);
+        ValueTypeDtor(this_node->element);
         free(this_node);
     }
 }
-AUTOC_STATIC void ValueTypeMapSetListCopy(ValueTypeMapSetList* dst, ValueTypeMapSetList* src) {
-    ValueTypeMapSetListIt it;
+AUTOC_STATIC void ValueTypeSetListCopy(ValueTypeSetList* dst,ValueTypeSetList* src) {
+    ValueTypeSetListIt it;
     assert(src);
     assert(dst);
-    ValueTypeMapSetListCtor(dst);
-    ValueTypeMapSetListItCtor(&it, src);
-    while(ValueTypeMapSetListItMove(&it)) {
-        ValueTypeMapSetListPush(dst, *ValueTypeMapSetListItGetRef(&it));
+    ValueTypeSetListCtor(dst);
+    ValueTypeSetListItCtor(&it, src);
+    while(ValueTypeSetListItMove(&it)) {
+        ValueTypeSetListPush(dst, *ValueTypeSetListItGetRef(&it));
     }
 }
-AUTOC_STATIC int ValueTypeMapSetListEqual(ValueTypeMapSetList* lt, ValueTypeMapSetList* rt) {
-    if(ValueTypeMapSetListSize(lt) == ValueTypeMapSetListSize(rt)) {
-        ValueTypeMapSetListIt lit, rit;
-        ValueTypeMapSetListItCtor(&lit, lt);
-        ValueTypeMapSetListItCtor(&rit, rt);
-        while(ValueTypeMapSetListItMove(&lit) && ValueTypeMapSetListItMove(&rit)) {
+AUTOC_STATIC int ValueTypeSetListEqual(ValueTypeSetList* lt,ValueTypeSetList* rt) {
+    if(ValueTypeSetListSize(lt) == ValueTypeSetListSize(rt)) {
+        ValueTypeSetListIt lit, rit;
+        ValueTypeSetListItCtor(&lit, lt);
+        ValueTypeSetListItCtor(&rit, rt);
+        while(ValueTypeSetListItMove(&lit) && ValueTypeSetListItMove(&rit)) {
             int equal;
-            ValueTypeMapEntry *le, *re;
-            le = ValueTypeMapSetListItGetRef(&lit);
-            re = ValueTypeMapSetListItGetRef(&rit);
-            equal = ValueTypeMapEntryEqual(*le, *re);
+            ValueType* le;
+            ValueType* re;
+            le = ValueTypeSetListItGetRef(&lit);
+            re = ValueTypeSetListItGetRef(&rit);
+            equal = ValueTypeEqual(*le,*re);
             if(!equal) return 0;
         }
         return 1;
     } else
         return 0;
 }
-AUTOC_STATIC size_t ValueTypeMapSetListIdentify(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListNode* node;
+AUTOC_STATIC size_t ValueTypeSetListIdentify(ValueTypeSetList* self) {
+    ValueTypeSetListNode* node;
     size_t result = 0;
     assert(self);
     for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= ValueTypeMapEntryIdentify(node->element);
+        result ^= ValueTypeIdentify(node->element);
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-AUTOC_STATIC void ValueTypeMapSetListPurge(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListDtor(self);
-    ValueTypeMapSetListCtor(self);
+AUTOC_STATIC void ValueTypeSetListPurge(ValueTypeSetList* self) {
+    ValueTypeSetListDtor(self);
+    ValueTypeSetListCtor(self);
 }
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPeek(ValueTypeMapSetList* self) {
-    ValueTypeMapEntry result;
+AUTOC_STATIC ValueType ValueTypeSetListPeek(ValueTypeSetList* self) {
+    ValueType result;
     assert(self);
-    assert(!ValueTypeMapSetListEmpty(self));
-    ValueTypeMapEntryCopy(result, self->head_node->element);
+    assert(!ValueTypeSetListEmpty(self));
+    ValueTypeCopy(result,self->head_node->element);
     return result;
 }
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPop(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListNode* node;
-    ValueTypeMapEntry result;
+AUTOC_STATIC ValueType ValueTypeSetListPop(ValueTypeSetList* self) {
+    ValueTypeSetListNode* node;
+    ValueType result;
     assert(self);
-    assert(!ValueTypeMapSetListEmpty(self));
+    assert(!ValueTypeSetListEmpty(self));
     node = self->head_node;
     result = node->element;
     self->head_node = self->head_node->next_node;
@@ -2135,23 +2287,23 @@ AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPop(ValueTypeMapSetList* self)
     free(node);
     return result;
 }
-AUTOC_STATIC void ValueTypeMapSetListPush(ValueTypeMapSetList* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetListNode* node;
+AUTOC_STATIC void ValueTypeSetListPush(ValueTypeSetList* self, ValueType element) {
+    ValueTypeSetListNode* node;
     assert(self);
-    node = (ValueTypeMapSetListNode*)malloc(sizeof(ValueTypeMapSetListNode));
+    node = (ValueTypeSetListNode*)malloc(sizeof(ValueTypeSetListNode));
     assert(node);
-    ValueTypeMapEntryCopy(node->element, element);
+    ValueTypeCopy(node->element,element);
     node->next_node = self->head_node;
     self->head_node = node;
     ++self->node_count;
 }
-AUTOC_STATIC int ValueTypeMapSetListContains(ValueTypeMapSetList* self, ValueTypeMapEntry what) {
-    ValueTypeMapSetListNode* node;
+AUTOC_STATIC int ValueTypeSetListContains(ValueTypeSetList* self, ValueType what) {
+    ValueTypeSetListNode* node;
     int found = 0;
     assert(self);
     node = self->head_node;
     while(node) {
-        if(ValueTypeMapEntryEqual(node->element, what)) {
+        if(ValueTypeEqual(node->element,what)) {
             found = 1;
             break;
         }
@@ -2159,31 +2311,31 @@ AUTOC_STATIC int ValueTypeMapSetListContains(ValueTypeMapSetList* self, ValueTyp
     }
     return found;
 }
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListFind(ValueTypeMapSetList* self, ValueTypeMapEntry what) {
-    ValueTypeMapSetListNode* node;
+AUTOC_STATIC ValueType ValueTypeSetListFind(ValueTypeSetList* self, ValueType what) {
+    ValueTypeSetListNode* node;
     assert(self);
-    assert(ValueTypeMapSetListContains(self, what));
+    assert(ValueTypeSetListContains(self, what));
     node = self->head_node;
     while(node) {
-        if(ValueTypeMapEntryEqual(node->element, what)) {
-            ValueTypeMapEntry result;
-            ValueTypeMapEntryCopy(result, node->element);
+        if(ValueTypeEqual(node->element,what)) {
+            ValueType result;
+            ValueTypeCopy(result,node->element);
             return result;
         }
         node = node->next_node;
     }
     abort();
 }
-AUTOC_STATIC int ValueTypeMapSetListReplaceEx(ValueTypeMapSetList* self, ValueTypeMapEntry with, int count) {
-    ValueTypeMapSetListNode* node;
+AUTOC_STATIC int ValueTypeSetListReplaceEx(ValueTypeSetList* self, ValueType with, int count) {
+    ValueTypeSetListNode* node;
     int replaced = 0;
     assert(self);
     if(count == 0) return 0;
     node = self->head_node;
     while(node) {
-        if(ValueTypeMapEntryEqual(node->element, with)) {
-            ValueTypeMapEntryDtor(node->element);
-            ValueTypeMapEntryCopy(node->element, with);
+        if(ValueTypeEqual(node->element,with)) {
+            ValueTypeDtor(node->element);
+            ValueTypeCopy(node->element,with);
             ++replaced;
             if(count > 0 && replaced >= count) break;
         }
@@ -2191,16 +2343,16 @@ AUTOC_STATIC int ValueTypeMapSetListReplaceEx(ValueTypeMapSetList* self, ValueTy
     }
     return replaced;
 }
-AUTOC_STATIC int ValueTypeMapSetListRemoveEx(ValueTypeMapSetList* self, ValueTypeMapEntry what, int count) {
-    ValueTypeMapSetListNode *node, *prev_node;
+AUTOC_STATIC int ValueTypeSetListRemoveEx(ValueTypeSetList* self, ValueType what, int count) {
+    ValueTypeSetListNode *node, *prev_node;
     int removed = 0;
     assert(self);
     if(count == 0) return 0;
     node = self->head_node;
     prev_node = NULL;
     while(node) {
-        if(ValueTypeMapEntryEqual(node->element, what)) {
-            ValueTypeMapSetListNode* this_node;
+        if(ValueTypeEqual(node->element,what)) {
+            ValueTypeSetListNode* this_node;
             if(prev_node) {
                 this_node = prev_node->next_node = node->next_node;
             } else {
@@ -2208,7 +2360,7 @@ AUTOC_STATIC int ValueTypeMapSetListRemoveEx(ValueTypeMapSetList* self, ValueTyp
             }
             ++removed;
             --self->node_count;
-            ValueTypeMapEntryDtor(node->element);
+            ValueTypeDtor(node->element);
             free(node);
             node = this_node;
             if(count > 0 && removed >= count) break;
@@ -2219,17 +2371,17 @@ AUTOC_STATIC int ValueTypeMapSetListRemoveEx(ValueTypeMapSetList* self, ValueTyp
     }
     return removed;
 }
-AUTOC_STATIC size_t ValueTypeMapSetListSize(ValueTypeMapSetList* self) {
+AUTOC_STATIC size_t ValueTypeSetListSize(ValueTypeSetList* self) {
     assert(self);
     return self->node_count;
 }
-AUTOC_STATIC void ValueTypeMapSetListItCtor(ValueTypeMapSetListIt* self, ValueTypeMapSetList* list) {
+AUTOC_STATIC void ValueTypeSetListItCtor(ValueTypeSetListIt* self, ValueTypeSetList* list) {
     assert(self);
     assert(list);
     self->start = 1;
     self->list = list;
 }
-AUTOC_STATIC int ValueTypeMapSetListItMove(ValueTypeMapSetListIt* self) {
+AUTOC_STATIC int ValueTypeSetListItMove(ValueTypeSetListIt* self) {
     assert(self);
     if(self->start) {
         self->this_node = self->list->head_node;
@@ -2239,22 +2391,22 @@ AUTOC_STATIC int ValueTypeMapSetListItMove(ValueTypeMapSetListIt* self) {
     }
     return self->this_node != NULL;
 }
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListItGet(ValueTypeMapSetListIt* self) {
-    ValueTypeMapEntry result;
+AUTOC_STATIC ValueType ValueTypeSetListItGet(ValueTypeSetListIt* self) {
+    ValueType result;
     assert(self);
     assert(self->this_node);
-    ValueTypeMapEntryCopy(result, self->this_node->element);
+    ValueTypeCopy(result,self->this_node->element);
     return result;
 }
-AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetListItGetRef(ValueTypeMapSetListIt* self) {
+AUTOC_STATIC ValueType* ValueTypeSetListItGetRef(ValueTypeSetListIt* self) {
     assert(self);
     assert(self->this_node);
     return &self->this_node->element;
 }
 
-AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetItGetRef(ValueTypeMapSetIt*);
-static void ValueTypeMapSetRehash(ValueTypeMapSet* self) {
-    ValueTypeMapSetList* buckets;
+ValueType* ValueTypeSetItGetRef(ValueTypeSetIt*);
+static void ValueTypeSetRehash(ValueTypeSet* self) {
+    ValueTypeSetList* buckets;
     size_t index, bucket_count, size, fill;
     assert(self);
     assert(self->min_fill > 0);
@@ -2278,28 +2430,38 @@ static void ValueTypeMapSetRehash(ValueTypeMapSet* self) {
         bucket_count = self->min_bucket_count;
         size = 0;
     }
-    buckets = (ValueTypeMapSetList*)malloc(bucket_count*sizeof(ValueTypeMapSetList));
+    buckets = (ValueTypeSetList*)malloc(bucket_count*sizeof(ValueTypeSetList));
     assert(buckets);
     for(index = 0; index < bucket_count; ++index) {
-        ValueTypeMapSetListCtor(&buckets[index]);
+        ValueTypeSetListCtor(&buckets[index]);
     }
     if(self->buckets) {
-        ValueTypeMapSetIt it;
-        ValueTypeMapSetItCtor(&it, self);
-        while(ValueTypeMapSetItMove(&it)) {
-            ValueTypeMapSetList* bucket;
-            ValueTypeMapEntry element = ValueTypeMapSetItGet(&it);
-            bucket = &buckets[ValueTypeMapEntryIdentify(element) % bucket_count];
-            ValueTypeMapSetListPush(bucket, element);
-            ValueTypeMapEntryDtor(element);
+        ValueTypeSetIt it;
+        ValueTypeSetItCtor(&it, self);
+        while(ValueTypeSetItMove(&it)) {
+            ValueTypeSetList* bucket;
+            ValueType element = ValueTypeSetItGet(&it);
+            bucket = &buckets[ValueTypeIdentify(element) % bucket_count];
+            ValueTypeSetListPush(bucket, element);
+            ValueTypeDtor(element);
         }
-        ValueTypeMapSetDtor(self);
+        ValueTypeSetDtor(self);
     }
     self->buckets = buckets;
     self->bucket_count = bucket_count;
     self->size = size;
 }
-AUTOC_STATIC void ValueTypeMapSetCtor(ValueTypeMapSet* self) {
+static int ValueTypeSetContainsAllOf(ValueTypeSet* self, ValueTypeSet* other) {
+    ValueTypeSetIt it;
+    ValueTypeSetItCtor(&it, self);
+    while(ValueTypeSetItMove(&it)) {
+        int found = 0;
+        if(ValueTypeSetContains(other, *ValueTypeSetItGetRef(&it))) found = 1;
+        if(!found) return 0;
+    }
+    return 1;
+}
+void ValueTypeSetCtor(ValueTypeSet* self) {
     assert(self);
     self->min_bucket_count = 16;
     self->min_fill = 20;
@@ -2308,362 +2470,687 @@ AUTOC_STATIC void ValueTypeMapSetCtor(ValueTypeMapSet* self) {
     self->max_size = (size_t)((float)self->max_fill/100*self->min_bucket_count);
     self->capacity_multiplier = 200;
     self->buckets = NULL;
-    ValueTypeMapSetRehash(self);
+    ValueTypeSetRehash(self);
 }
-AUTOC_STATIC void ValueTypeMapSetDtor(ValueTypeMapSet* self) {
+void ValueTypeSetDtor(ValueTypeSet* self) {
     size_t i;
     assert(self);
     for(i = 0; i < self->bucket_count; ++i) {
-        ValueTypeMapSetListDtor(&self->buckets[i]);
+        ValueTypeSetListDtor(&self->buckets[i]);
     }
     free(self->buckets);
 }
-AUTOC_STATIC void ValueTypeMapSetCopy(ValueTypeMapSet* dst, ValueTypeMapSet* src) {
-    ValueTypeMapSetIt it;
+void ValueTypeSetCopy(ValueTypeSet* dst,ValueTypeSet* src) {
+    ValueTypeSetIt it;
     assert(src);
     assert(dst);
-    ValueTypeMapSetCtor(dst);
-    ValueTypeMapSetItCtor(&it, src);
-    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetPut(dst, *ValueTypeMapSetItGetRef(&it));
-}
-static int ValueTypeMapSetContainsAllOf(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        int found = 0;
-        if(ValueTypeMapSetContains(other, *ValueTypeMapSetItGetRef(&it))) found = 1;
-        if(!found) return 0;
-    }
-    return 1;
+    ValueTypeSetCtor(dst);
+    ValueTypeSetItCtor(&it, src);
+    while(ValueTypeSetItMove(&it)) ValueTypeSetPut(dst, *ValueTypeSetItGetRef(&it));
 }
-AUTOC_STATIC int ValueTypeMapSetEqual(ValueTypeMapSet* lt, ValueTypeMapSet* rt) {
+int ValueTypeSetEqual(ValueTypeSet* lt,ValueTypeSet* rt) {
     assert(lt);
     assert(rt);
-    return ValueTypeMapSetSize(lt) == ValueTypeMapSetSize(rt) && ValueTypeMapSetContainsAllOf(lt, rt) && ValueTypeMapSetContainsAllOf(rt, lt);
+    return ValueTypeSetSize(lt) == ValueTypeSetSize(rt) && ValueTypeSetContainsAllOf(lt, rt) && ValueTypeSetContainsAllOf(rt, lt);
 }
-AUTOC_STATIC size_t ValueTypeMapSetIdentify(ValueTypeMapSet* self) {
-    ValueTypeMapSetIt it;
+size_t ValueTypeSetIdentify(ValueTypeSet* self) {
+    ValueTypeSetIt it;
     size_t result = 0;
     assert(self);
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        result ^= ValueTypeMapEntryIdentify(*e);
+    ValueTypeSetItCtor(&it, self);
+    while(ValueTypeSetItMove(&it)) {
+        ValueType* e = ValueTypeSetItGetRef(&it);
+        result ^= ValueTypeIdentify(*e);
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-AUTOC_STATIC void ValueTypeMapSetPurge(ValueTypeMapSet* self) {
+void ValueTypeSetPurge(ValueTypeSet* self) {
     assert(self);
-    ValueTypeMapSetDtor(self);
+    ValueTypeSetDtor(self);
     self->buckets = NULL;
-    ValueTypeMapSetRehash(self);
+    ValueTypeSetRehash(self);
 }
-AUTOC_STATIC int ValueTypeMapSetContains(ValueTypeMapSet* self, ValueTypeMapEntry element) {
+int ValueTypeSetContains(ValueTypeSet* self, ValueType element) {
     assert(self);
-    return ValueTypeMapSetListContains(&self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count], element);
+    return ValueTypeSetListContains(&self->buckets[ValueTypeIdentify(element) % self->bucket_count], element);
 }
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetGet(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapEntry result;
+ValueType ValueTypeSetGet(ValueTypeSet* self, ValueType element) {
+    ValueType result;
     assert(self);
-    assert(ValueTypeMapSetContains(self, element));
-    result = ValueTypeMapSetListFind(&self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count], element);
+    assert(ValueTypeSetContains(self, element));
+    result = ValueTypeSetListFind(&self->buckets[ValueTypeIdentify(element) % self->bucket_count], element);
     return result;
 }
-AUTOC_STATIC size_t ValueTypeMapSetSize(ValueTypeMapSet* self) {
+size_t ValueTypeSetSize(ValueTypeSet* self) {
     assert(self);
     return self->size;
 }
-AUTOC_STATIC int ValueTypeMapSetPut(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetList* bucket;
+int ValueTypeSetPut(ValueTypeSet* self, ValueType element) {
+    ValueTypeSetList* bucket;
     assert(self);
-    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
-    if(!ValueTypeMapSetListContains(bucket, element)) {
-        ValueTypeMapSetListPush(bucket, element);
+    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
+    if(!ValueTypeSetListContains(bucket, element)) {
+        ValueTypeSetListPush(bucket, element);
         ++self->size;
-        ValueTypeMapSetRehash(self);
+        ValueTypeSetRehash(self);
         return 1;
     }
     return 0;
 }
-AUTOC_STATIC int ValueTypeMapSetReplace(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetList* bucket;
+int ValueTypeSetReplace(ValueTypeSet* self, ValueType element) {
+    ValueTypeSetList* bucket;
     assert(self);
-    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
-    return ValueTypeMapSetListReplace(bucket, element);
+    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
+    return ValueTypeSetListReplace(bucket, element);
 }
-AUTOC_STATIC int ValueTypeMapSetRemove(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetList* bucket;
+int ValueTypeSetRemove(ValueTypeSet* self, ValueType element) {
+    ValueTypeSetList* bucket;
     assert(self);
-    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
-    if(ValueTypeMapSetListRemove(bucket, element)) {
+    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
+    if(ValueTypeSetListRemove(bucket, element)) {
         --self->size;
-        ValueTypeMapSetRehash(self);
+        ValueTypeSetRehash(self);
         return 1;
     }
     return 0;
 }
-AUTOC_STATIC void ValueTypeMapSetExclude(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
+void ValueTypeSetExclude(ValueTypeSet* self, ValueTypeSet* other) {
+    ValueTypeSetIt it;
     assert(self);
     assert(other);
-    ValueTypeMapSetItCtor(&it, other);
-    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetRemove(self, *ValueTypeMapSetItGetRef(&it));
+    ValueTypeSetItCtor(&it, other);
+    while(ValueTypeSetItMove(&it)) ValueTypeSetRemove(self, *ValueTypeSetItGetRef(&it));
 }
-AUTOC_STATIC void ValueTypeMapSetInclude(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
+void ValueTypeSetInclude(ValueTypeSet* self, ValueTypeSet* other) {
+    ValueTypeSetIt it;
     assert(self);
     assert(other);
-    ValueTypeMapSetItCtor(&it, other);
-    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetPut(self, *ValueTypeMapSetItGetRef(&it));
+    ValueTypeSetItCtor(&it, other);
+    while(ValueTypeSetItMove(&it)) ValueTypeSetPut(self, *ValueTypeSetItGetRef(&it));
 }
-AUTOC_STATIC void ValueTypeMapSetRetain(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    ValueTypeMapSet set;
+void ValueTypeSetRetain(ValueTypeSet* self, ValueTypeSet* other) {
+    ValueTypeSetIt it;
+    ValueTypeSet set;
     assert(self);
     assert(other);
-    ValueTypeMapSetCtor(&set);
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        if(ValueTypeMapSetContains(other, *e)) ValueTypeMapSetPut(&set, *e);
+    ValueTypeSetCtor(&set);
+    ValueTypeSetItCtor(&it, self);
+    while(ValueTypeSetItMove(&it)) {
+        ValueType* e = ValueTypeSetItGetRef(&it);
+        if(ValueTypeSetContains(other, *e)) ValueTypeSetPut(&set, *e);
     }
-    ValueTypeMapSetDtor(self);
+    ValueTypeSetDtor(self);
     *self = set;
 }
-AUTOC_STATIC void ValueTypeMapSetInvert(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    ValueTypeMapSet set;
+void ValueTypeSetInvert(ValueTypeSet* self, ValueTypeSet* other) {
+    ValueTypeSetIt it;
+    ValueTypeSet set;
     assert(self);
     assert(other);
-    ValueTypeMapSetCtor(&set);
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        if(!ValueTypeMapSetContains(other, *e)) ValueTypeMapSetPut(&set, *e);
+    ValueTypeSetCtor(&set);
+    ValueTypeSetItCtor(&it, self);
+    while(ValueTypeSetItMove(&it)) {
+        ValueType* e = ValueTypeSetItGetRef(&it);
+        if(!ValueTypeSetContains(other, *e)) ValueTypeSetPut(&set, *e);
     }
-    ValueTypeMapSetItCtor(&it, other);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        if(!ValueTypeMapSetContains(self, *e)) ValueTypeMapSetPut(&set, *e);
+    ValueTypeSetItCtor(&it, other);
+    while(ValueTypeSetItMove(&it)) {
+        ValueType* e = ValueTypeSetItGetRef(&it);
+        if(!ValueTypeSetContains(self, *e)) ValueTypeSetPut(&set, *e);
     }
-    ValueTypeMapSetDtor(self);
+    ValueTypeSetDtor(self);
     *self = set;
 }
-AUTOC_STATIC void ValueTypeMapSetItCtor(ValueTypeMapSetIt* self, ValueTypeMapSet* set) {
+void ValueTypeSetItCtor(ValueTypeSetIt* self, ValueTypeSet* set) {
     assert(self);
     self->set = set;
     self->bucket_index = -1;
 }
-AUTOC_STATIC int ValueTypeMapSetItMove(ValueTypeMapSetIt* self) {
+int ValueTypeSetItMove(ValueTypeSetIt* self) {
     assert(self);
-    if(self->bucket_index < 0) ValueTypeMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index = 0]);
-    if(ValueTypeMapSetListItMove(&self->it)) return 1;
+    if(self->bucket_index < 0) ValueTypeSetListItCtor(&self->it, &self->set->buckets[self->bucket_index = 0]);
+    if(ValueTypeSetListItMove(&self->it)) return 1;
     while(++self->bucket_index < self->set->bucket_count) {
-        ValueTypeMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
-        if(ValueTypeMapSetListItMove(&self->it)) return 1;
+        ValueTypeSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
+        if(ValueTypeSetListItMove(&self->it)) return 1;
     }
     return 0;
 }
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetItGet(ValueTypeMapSetIt* self) {
+ValueType ValueTypeSetItGet(ValueTypeSetIt* self) {
     assert(self);
-    return ValueTypeMapSetListItGet(&self->it);
+    return ValueTypeSetListItGet(&self->it);
 }
-AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetItGetRef(ValueTypeMapSetIt* self) {
+ValueType* ValueTypeSetItGetRef(ValueTypeSetIt* self) {
     assert(self);
-    return ValueTypeMapSetListItGetRef(&self->it);
+    return ValueTypeSetListItGetRef(&self->it);
 }
 
-static ValueTypeMapEntry* ValueTypeMapItGetEntryRef(ValueTypeMapIt*);
-void ValueTypeMapCtor(ValueTypeMap* self) {
+#define AUTOC_COUNTER(p) (*(size_t*)((char*)(p) + sizeof(ValueType)))
+ValueType* ValueTypeNew() {
+    ValueType* self = (ValueType*)malloc(sizeof(ValueType) + sizeof(size_t));
     assert(self);
-    ValueTypeMapSetCtor(&self->entries);
+    ValueTypeCtor(*self);
+    AUTOC_COUNTER(self) = 1;
+    return self;
 }
-void ValueTypeMapDtor(ValueTypeMap* self) {
+ValueType* ValueTypeRef(ValueType* self) {
     assert(self);
-    ValueTypeMapSetDtor(&self->entries);
+    ++AUTOC_COUNTER(self);
+    return self;
 }
-static int ValueTypeMapPutEntryRef(ValueTypeMap* self, ValueTypeMapEntry* entry) {
-    int absent;
+void ValueTypeFree(ValueType* self) {
     assert(self);
-    assert(entry);
-    if((absent = !ValueTypeMapContainsKey(self, entry->key))) {
-        ValueTypeMapSetPut(&self->entries, *entry);
+    if(--AUTOC_COUNTER(self) == 0) {
+        ValueTypeDtor(*self);
+        free(self);
     }
-    return absent;
 }
-void ValueTypeMapCopy(ValueTypeMap* dst, ValueTypeMap* src) {
-    ValueTypeMapIt it;
+#undef AUTOC_COUNTER
+
+ValueType* ValueTypeListItGetRef(ValueTypeListIt*);
+void ValueTypeListCtor(ValueTypeList* self) {
+    assert(self);
+    self->head_node = NULL;
+    self->node_count = 0;
+}
+void ValueTypeListDtor(ValueTypeList* self) {
+    ValueTypeListNode* node;
+    assert(self);
+    node = self->head_node;
+    while(node) {
+        ValueTypeListNode* this_node = node;
+        node = node->next_node;
+        ValueTypeDtor(this_node->element);
+        free(this_node);
+    }
+}
+void ValueTypeListCopy(ValueTypeList* dst,ValueTypeList* src) {
+    ValueTypeListIt it;
     assert(src);
     assert(dst);
-    ValueTypeMapCtor(dst);
-    ValueTypeMapItCtor(&it, src);
-    while(ValueTypeMapItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapItGetEntryRef(&it);
-        ValueTypeMapPutEntryRef(dst, e);
+    ValueTypeListCtor(dst);
+    ValueTypeListItCtor(&it, src);
+    while(ValueTypeListItMove(&it)) {
+        ValueTypeListPush(dst, *ValueTypeListItGetRef(&it));
     }
 }
-static int ValueTypeMapContainsAllOf(ValueTypeMap* self, ValueTypeMap* other) {
-    ValueTypeMapIt it;
-    ValueTypeMapItCtor(&it, self);
-    while(ValueTypeMapItMove(&it)) {
-        int found = 0;
-        ValueTypeMapEntry* e = ValueTypeMapItGetEntryRef(&it);
-        if(ValueTypeMapContainsKey(other, e->key)) {
-            ValueType other_value = ValueTypeMapGet(other, e->key);
-            found = ValueTypeEqual(e->value, other_value);
-            ValueTypeDtor(other_value);
+int ValueTypeListEqual(ValueTypeList* lt,ValueTypeList* rt) {
+    if(ValueTypeListSize(lt) == ValueTypeListSize(rt)) {
+        ValueTypeListIt lit, rit;
+        ValueTypeListItCtor(&lit, lt);
+        ValueTypeListItCtor(&rit, rt);
+        while(ValueTypeListItMove(&lit) && ValueTypeListItMove(&rit)) {
+            int equal;
+            ValueType* le;
+            ValueType* re;
+            le = ValueTypeListItGetRef(&lit);
+            re = ValueTypeListItGetRef(&rit);
+            equal = ValueTypeEqual(*le,*re);
+            if(!equal) return 0;
         }
-        if(!found) return 0;
-    }
-    return 1;
-}
-int ValueTypeMapEqual(ValueTypeMap* lt, ValueTypeMap* rt) {
-    assert(lt);
-    assert(rt);
-    return ValueTypeMapSize(lt) == ValueTypeMapSize(rt) && ValueTypeMapContainsAllOf(lt, rt) && ValueTypeMapContainsAllOf(rt, lt);
+        return 1;
+    } else
+        return 0;
 }
-size_t ValueTypeMapIdentify(ValueTypeMap* self) {
+size_t ValueTypeListIdentify(ValueTypeList* self) {
+    ValueTypeListNode* node;
+    size_t result = 0;
     assert(self);
-    return ValueTypeMapSetIdentify(&self->entries); /* TODO : make use of the values' hashes */
+    for(node = self->head_node; node != NULL; node = node->next_node) {
+        result ^= ValueTypeIdentify(node->element);
+        result = AUTOC_RCYCLE(result);
+    }
+    return result;
 }
-void ValueTypeMapPurge(ValueTypeMap* self) {
+void ValueTypeListPurge(ValueTypeList* self) {
+    ValueTypeListDtor(self);
+    ValueTypeListCtor(self);
+}
+ValueType ValueTypeListPeek(ValueTypeList* self) {
+    ValueType result;
     assert(self);
-    ValueTypeMapSetPurge(&self->entries);
+    assert(!ValueTypeListEmpty(self));
+    ValueTypeCopy(result,self->head_node->element);
+    return result;
 }
-size_t ValueTypeMapSize(ValueTypeMap* self) {
+ValueType ValueTypeListPop(ValueTypeList* self) {
+    ValueTypeListNode* node;
+    ValueType result;
     assert(self);
-    return ValueTypeMapSetSize(&self->entries);
+    assert(!ValueTypeListEmpty(self));
+    node = self->head_node;
+    result = node->element;
+    self->head_node = self->head_node->next_node;
+    --self->node_count;
+    free(node);
+    return result;
 }
-int ValueTypeMapContainsKey(ValueTypeMap* self, ValueType key) {
-    int result;
-    ValueTypeMapEntry entry;
+void ValueTypeListPush(ValueTypeList* self, ValueType element) {
+    ValueTypeListNode* node;
     assert(self);
-    result = ValueTypeMapSetContains(&self->entries, entry = ValueTypeMapEntryKeyOnlyRef(&key));
-    ValueTypeMapEntryDtor(entry);
+    node = (ValueTypeListNode*)malloc(sizeof(ValueTypeListNode));
+    assert(node);
+    ValueTypeCopy(node->element,element);
+    node->next_node = self->head_node;
+    self->head_node = node;
+    ++self->node_count;
+}
+int ValueTypeListContains(ValueTypeList* self, ValueType what) {
+    ValueTypeListNode* node;
+    int found = 0;
+    assert(self);
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,what)) {
+            found = 1;
+            break;
+        }
+        node = node->next_node;
+    }
+    return found;
+}
+ValueType ValueTypeListFind(ValueTypeList* self, ValueType what) {
+    ValueTypeListNode* node;
+    assert(self);
+    assert(ValueTypeListContains(self, what));
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,what)) {
+            ValueType result;
+            ValueTypeCopy(result,node->element);
+            return result;
+        }
+        node = node->next_node;
+    }
+    abort();
+}
+int ValueTypeListReplaceEx(ValueTypeList* self, ValueType with, int count) {
+    ValueTypeListNode* node;
+    int replaced = 0;
+    assert(self);
+    if(count == 0) return 0;
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,with)) {
+            ValueTypeDtor(node->element);
+            ValueTypeCopy(node->element,with);
+            ++replaced;
+            if(count > 0 && replaced >= count) break;
+        }
+        node = node->next_node;
+    }
+    return replaced;
+}
+int ValueTypeListRemoveEx(ValueTypeList* self, ValueType what, int count) {
+    ValueTypeListNode *node, *prev_node;
+    int removed = 0;
+    assert(self);
+    if(count == 0) return 0;
+    node = self->head_node;
+    prev_node = NULL;
+    while(node) {
+        if(ValueTypeEqual(node->element,what)) {
+            ValueTypeListNode* this_node;
+            if(prev_node) {
+                this_node = prev_node->next_node = node->next_node;
+            } else {
+                this_node = self->head_node = node->next_node;
+            }
+            ++removed;
+            --self->node_count;
+            ValueTypeDtor(node->element);
+            free(node);
+            node = this_node;
+            if(count > 0 && removed >= count) break;
+        } else {
+            prev_node = node;
+            node = node->next_node;
+        }
+    }
+    return removed;
+}
+size_t ValueTypeListSize(ValueTypeList* self) {
+    assert(self);
+    return self->node_count;
+}
+void ValueTypeListItCtor(ValueTypeListIt* self, ValueTypeList* list) {
+    assert(self);
+    assert(list);
+    self->start = 1;
+    self->list = list;
+}
+int ValueTypeListItMove(ValueTypeListIt* self) {
+    assert(self);
+    if(self->start) {
+        self->this_node = self->list->head_node;
+        self->start = 0;
+    } else {
+        self->this_node = self->this_node ? self->this_node->next_node : NULL;
+    }
+    return self->this_node != NULL;
+}
+ValueType ValueTypeListItGet(ValueTypeListIt* self) {
+    ValueType result;
+    assert(self);
+    assert(self->this_node);
+    ValueTypeCopy(result,self->this_node->element);
     return result;
 }
-ValueType ValueTypeMapGet(ValueTypeMap* self, ValueType key) {
+ValueType* ValueTypeListItGetRef(ValueTypeListIt* self) {
+    assert(self);
+    assert(self->this_node);
+    return &self->this_node->element;
+}
+
+ValueType* ValueTypeQueueItGetRef(ValueTypeQueueIt*);
+void ValueTypeQueueCtor(ValueTypeQueue* self) {
+    assert(self);
+    self->head_node = self->tail_node = NULL;
+    self->node_count = 0;
+}
+void ValueTypeQueueDtor(ValueTypeQueue* self) {
+    ValueTypeQueueNode* node;
+    assert(self);
+    node = self->head_node;
+    while(node) {
+        ValueTypeQueueNode* this_node = node;
+        node = node->next_node;
+        ValueTypeDtor(this_node->element);
+        free(this_node);
+    }
+}
+void ValueTypeQueueCopy(ValueTypeQueue* dst,ValueTypeQueue* src) {
+    ValueTypeQueueIt it;
+    assert(src);
+    assert(dst);
+    ValueTypeQueueCtor(dst);
+    ValueTypeQueueItCtor(&it, src);
+    while(ValueTypeQueueItMove(&it)) {
+        ValueType element;
+        ValueTypeQueuePushTail(dst, element = ValueTypeQueueItGet(&it));
+        ValueTypeDtor(element);
+    }
+}
+int ValueTypeQueueEqual(ValueTypeQueue* lt,ValueTypeQueue* rt) {
+    if(ValueTypeQueueSize(lt) == ValueTypeQueueSize(rt)) {
+        ValueTypeQueueIt lit, rit;
+        ValueTypeQueueItCtor(&lit, lt);
+        ValueTypeQueueItCtor(&rit, rt);
+        while(ValueTypeQueueItMove(&lit) && ValueTypeQueueItMove(&rit)) {
+            int equal;
+            ValueType *le, *re;
+            le = ValueTypeQueueItGetRef(&lit);
+            re = ValueTypeQueueItGetRef(&rit);
+            equal = ValueTypeEqual(*le,*re);
+            if(!equal) return 0;
+        }
+        return 1;
+    } else
+        return 0;
+}
+size_t ValueTypeQueueIdentify(ValueTypeQueue* self) {
+    ValueTypeQueueNode* node;
+    size_t result = 0;
+    assert(self);
+    for(node = self->head_node; node != NULL; node = node->next_node) {
+        result ^= ValueTypeIdentify(node->element);
+        result = AUTOC_RCYCLE(result);
+    }
+    return result;
+}
+void ValueTypeQueuePurge(ValueTypeQueue* self) {
+    ValueTypeQueueDtor(self);
+    ValueTypeQueueCtor(self);
+}
+ValueType ValueTypeQueuePeekHead(ValueTypeQueue* self) {
     ValueType result;
-    ValueTypeMapEntry entry, existing_entry;
     assert(self);
-    assert(ValueTypeMapContainsKey(self, key));
-    existing_entry = ValueTypeMapSetGet(&self->entries, entry = ValueTypeMapEntryKeyOnlyRef(&key));
-    ValueTypeCopy(result, existing_entry.value);
-    ValueTypeMapEntryDtor(existing_entry);
-    ValueTypeMapEntryDtor(entry);
+    assert(!ValueTypeQueueEmpty(self));
+    ValueTypeCopy(result,self->head_node->element);
     return result;
 }
-int ValueTypeMapPut(ValueTypeMap* self, ValueType key, ValueType value) {
-    int result;
-    ValueTypeMapEntry entry;
+ValueType ValueTypeQueuePeekTail(ValueTypeQueue* self) {
+    ValueType result;
     assert(self);
-    entry = ValueTypeMapEntryKeyValueRef(&key, &value);
-    result = ValueTypeMapPutEntryRef(self, &entry);
-    ValueTypeMapEntryDtor(entry);
+    assert(!ValueTypeQueueEmpty(self));
+    ValueTypeCopy(result,self->tail_node->element);
     return result;
 }
-int ValueTypeMapReplace(ValueTypeMap* self, ValueType key, ValueType value) {
-    int result;
-    ValueTypeMapEntry entry;
+ValueType ValueTypeQueuePopHead(ValueTypeQueue* self) {
+    ValueTypeQueueNode* node;
+    ValueType result;
     assert(self);
-    entry = ValueTypeMapEntryKeyValueRef(&key, &value);
-    result = ValueTypeMapSetReplace(&self->entries, entry);
-    ValueTypeMapEntryDtor(entry);
+    assert(!ValueTypeQueueEmpty(self));
+    node = self->head_node;
+    result = node->element;
+    self->head_node = self->head_node->next_node;
+    self->head_node->prev_node = NULL;
+    --self->node_count;
+    free(node);
+    return result;
+}
+ValueType ValueTypeQueuePopTail(ValueTypeQueue* self) {
+    ValueTypeQueueNode* node;
+    ValueType result;
+    assert(self);
+    assert(!ValueTypeQueueEmpty(self));
+    node = self->tail_node;
+    result = node->element;
+    self->tail_node = self->tail_node->prev_node;
+    self->tail_node->next_node = NULL;
+    --self->node_count;
+    free(node);
     return result;
 }
-int ValueTypeMapRemove(ValueTypeMap* self, ValueType key) {
-    int result;
-    ValueTypeMapEntry entry;
+void ValueTypeQueuePushTail(ValueTypeQueue* self, ValueType element) {
+    ValueTypeQueueNode* node;
+    assert(self);
+    node = (ValueTypeQueueNode*)malloc(sizeof(ValueTypeQueueNode));
+    assert(node);
+    ValueTypeCopy(node->element,element);
+    if(ValueTypeQueueEmpty(self)) {
+        node->prev_node = node->next_node = NULL;
+        self->tail_node = self->head_node = node;
+    } else {
+        node->next_node = NULL;
+        node->prev_node = self->tail_node;
+        self->tail_node->next_node = node;
+        self->tail_node = node;
+    }
+    ++self->node_count;
+}
+void ValueTypeQueuePushHead(ValueTypeQueue* self, ValueType element) {
+    ValueTypeQueueNode* node;
+    assert(self);
+    node = (ValueTypeQueueNode*)malloc(sizeof(ValueTypeQueueNode));
+    assert(node);
+    ValueTypeCopy(node->element,element);
+    if(ValueTypeQueueEmpty(self)) {
+        node->prev_node = node->next_node = NULL;
+        self->tail_node = self->head_node = node;
+    } else {
+        node->prev_node = NULL;
+        node->next_node = self->head_node;
+        self->head_node->prev_node = node;
+        self->head_node = node;
+    }
+    ++self->node_count;
+}
+int ValueTypeQueueContains(ValueTypeQueue* self, ValueType what) {
+    ValueTypeQueueNode* node;
+    int found = 0;
+    assert(self);
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,what)) {
+            found = 1;
+            break;
+        }
+        node = node->next_node;
+    }
+    return found;
+}
+ValueType ValueTypeQueueFind(ValueTypeQueue* self, ValueType what) {
+    ValueTypeQueueNode* node;
+    assert(self);
+    assert(ValueTypeQueueContains(self, what));
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,what)) {
+            ValueType result;
+            ValueTypeCopy(result,node->element);
+            return result;
+        }
+        node = node->next_node;
+    }
+    abort();
+}
+int ValueTypeQueueReplaceEx(ValueTypeQueue* self, ValueType with, int count) {
+    ValueTypeQueueNode* node;
+    int replaced = 0;
+    assert(self);
+    if(count == 0) return 0;
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,with)) {
+            ValueTypeDtor(node->element);
+            ValueTypeCopy(node->element,with);
+            ++replaced;
+            if(count > 0 && replaced >= count) break;
+        }
+        node = node->next_node;
+    }
+    return replaced;
+}
+int ValueTypeQueueRemoveEx(ValueTypeQueue* self, ValueType what, int count) {
+    ValueTypeQueueNode* node;
+    int removed = 0;
     assert(self);
-    result = ValueTypeMapSetRemove(&self->entries, entry = ValueTypeMapEntryKeyOnlyRef(&key));
-    ValueTypeMapEntryDtor(entry);
-    return result;
+    if(count == 0) return 0;
+    node = self->head_node;
+    while(node) {
+        if(ValueTypeEqual(node->element,what)) {
+            ValueTypeQueueNode* this_node;
+            if(node == self->head_node) {
+                assert(!node->prev_node);
+                this_node = self->head_node = node->next_node;
+                if(self->head_node) self->head_node->prev_node = NULL;
+            } else if(node == self->tail_node) {
+                assert(!node->next_node);
+                self->tail_node = node->prev_node;
+                this_node = self->tail_node->next_node = NULL;
+            } else {
+                assert(node->prev_node);
+                assert(node->next_node);
+                this_node = node->next_node;
+                node->next_node->prev_node = node->prev_node;
+                node->prev_node->next_node = node->next_node;
+            }
+            ++removed;
+            --self->node_count;
+            ValueTypeDtor(node->element);
+            free(node);
+            node = this_node;
+            if(count > 0 && removed >= count) break;
+        } else {
+            node = node->next_node;
+        }
+    }
+    return removed;
 }
-void ValueTypeMapItCtor(ValueTypeMapIt* self, ValueTypeMap* map) {
+size_t ValueTypeQueueSize(ValueTypeQueue* self) {
     assert(self);
-    assert(map);
-    ValueTypeMapSetItCtor(&self->it, &map->entries);
+    return self->node_count;
 }
-int ValueTypeMapItMove(ValueTypeMapIt* self) {
+void ValueTypeQueueItCtorEx(ValueTypeQueueIt* self, ValueTypeQueue* queue, int forward) {
     assert(self);
-    return ValueTypeMapSetItMove(&self->it);
+    assert(queue);
+    self->start = 1;
+    self->queue = queue;
+    self->forward = forward;
 }
-ValueType ValueTypeMapItGetKey(ValueTypeMapIt* self) {
-    ValueTypeMapEntry* e;
-    ValueType key;
+int ValueTypeQueueItMove(ValueTypeQueueIt* self) {
     assert(self);
-    e = ValueTypeMapItGetEntryRef(self);
-    ValueTypeCopy(key, e->key);
-    return key;
+    if(self->start) {
+        self->this_node = self->forward ? self->queue->head_node : self->queue->tail_node;
+        self->start = 0;
+    } else {
+        self->this_node = self->forward ? self->this_node->next_node : self->this_node->prev_node;
+    }
+    return self->this_node != NULL;
 }
-ValueType ValueTypeMapItGetElement(ValueTypeMapIt* self) {
-    ValueTypeMapEntry* e;
-    ValueType value;
+ValueType ValueTypeQueueItGet(ValueTypeQueueIt* self) {
+    ValueType result;
     assert(self);
-    e = ValueTypeMapItGetEntryRef(self);
-    assert(e->flags & AUTOC_VALID_VALUE);
-    ValueTypeCopy(value, e->value);
-    return value;
+    assert(self->this_node);
+    ValueTypeCopy(result,self->this_node->element);
+    return result;
 }
-static ValueTypeMapEntry* ValueTypeMapItGetEntryRef(ValueTypeMapIt* self) {
+ValueType* ValueTypeQueueItGetRef(ValueTypeQueueIt* self) {
     assert(self);
-    return ValueTypeMapSetItGetRef(&self->it);
+    assert(self->this_node);
+    return &self->this_node->element;
 }
-#undef AUTOC_VALID_VALUE
-#undef AUTOC_VALID_KEY
-#undef AUTOC_OWNED_VALUE
-#undef AUTOC_OWNED_KEY
 
-static void ValueTypeVectorAllocate(ValueTypeVector* self, size_t element_count) {
+static void PVectorValueAllocate(PVectorValue* self, size_t element_count) {
     assert(self);
     assert(element_count > 0);
     self->element_count = element_count;
-    self->values = (ValueType*)malloc(element_count*sizeof(ValueType));
+    self->values = (ValueType**)malloc(element_count*sizeof(ValueType*));
     assert(self->values);
 }
-void ValueTypeVectorCtor(ValueTypeVector* self, size_t element_count) {
+void PVectorValueCtor(PVectorValue* self,size_t element_count) {
     size_t index;
     assert(self);
-    ValueTypeVectorAllocate(self, element_count);
-    for(index = 0; index < ValueTypeVectorSize(self); ++index) {
-        ValueTypeCtor(self->values[index]);
+    PVectorValueAllocate(self, element_count);
+    for(index = 0; index < PVectorValueSize(self); ++index) {
+        ((self->values[index]) = ValueTypeNew());
     }
 }
-void ValueTypeVectorDtor(ValueTypeVector* self) {
+void PVectorValueDtor(PVectorValue* self) {
     size_t index;
     assert(self);
-    for(index = 0; index < ValueTypeVectorSize(self); ++index) {
-        ValueTypeDtor(self->values[index]);
+    for(index = 0; index < PVectorValueSize(self); ++index) {
+        ValueTypeFree(self->values[index]);
     }
     free(self->values);
 }
-void ValueTypeVectorCopy(ValueTypeVector* dst, ValueTypeVector* src) {
+void PVectorValueCopy(PVectorValue* dst,PVectorValue* src) {
     size_t index, size;
     assert(src);
     assert(dst);
-    ValueTypeVectorAllocate(dst, size = ValueTypeVectorSize(src));
+    PVectorValueAllocate(dst, size = PVectorValueSize(src));
     for(index = 0; index < size; ++index) {
-        ValueTypeCopy(dst->values[index], src->values[index]);
+        ((dst->values[index]) = ValueTypeRef(src->values[index]));
     }
 }
-int ValueTypeVectorEqual(ValueTypeVector* lt, ValueTypeVector* rt) {
+int PVectorValueEqual(PVectorValue* lt,PVectorValue* rt) {
     size_t index, size;
     assert(lt);
     assert(rt);
-    if(ValueTypeVectorSize(lt) == (size = ValueTypeVectorSize(rt))) {
+    if(PVectorValueSize(lt) == (size = PVectorValueSize(rt))) {
         for(index = 0; index < size; ++index) {
-            if(!ValueTypeEqual(lt->values[index], rt->values[index])) return 0;
+            if(!ValueTypeEqual(*lt->values[index],*rt->values[index])) return 0;
         }
         return 1;
     } else
         return 0;
 }
-void ValueTypeVectorResize(ValueTypeVector* self, size_t new_element_count) {
+size_t PVectorValueIdentify(PVectorValue* self) {
+    size_t index, result = 0;
+    assert(self);
+    for(index = 0; index < self->element_count; ++index) {
+        result ^= ValueTypeIdentify(*self->values[index]);
+        result = AUTOC_RCYCLE(result);
+    }
+    return result;
+}
+void PVectorValueResize(PVectorValue* self, size_t new_element_count) {
     size_t index, element_count, from, to;
     assert(self);
-    if((element_count = ValueTypeVectorSize(self)) != new_element_count) {
-        ValueType* values = (ValueType*)malloc(new_element_count*sizeof(ValueType));
+    if((element_count = PVectorValueSize(self)) != new_element_count) {
+        ValueType** values = (ValueType**)malloc(new_element_count*sizeof(ValueType*));
         assert(values);
         from = AUTOC_MIN(element_count, new_element_count);
         to = AUTOC_MAX(element_count, new_element_count);
@@ -2672,11 +3159,11 @@ void ValueTypeVectorResize(ValueTypeVector* self, size_t new_element_count) {
         }
         if(element_count > new_element_count) {
             for(index = from; index < to; ++index) {
-                ValueTypeDtor(self->values[index]);
+                ValueTypeFree(self->values[index]);
             }
         } else {
             for(index = from; index < to; ++index) {
-                ValueTypeCtor(values[index]);
+                ((values[index]) = ValueTypeNew());
             }
         }
         free(self->values);
@@ -2684,28 +3171,237 @@ void ValueTypeVectorResize(ValueTypeVector* self, size_t new_element_count) {
         self->element_count = new_element_count;
     }
 }
-size_t ValueTypeVectorIdentify(ValueTypeVector* self) {
-    size_t index, result = 0;
+
+static int PVectorValueComparator(void* lp_, void* rp_) {
+    ValueType** lp = (ValueType**)lp_;
+    ValueType** rp = (ValueType**)rp_;
+    if(ValueTypeEqual(**lp,**rp)) {
+        return 0;
+    } else if(ValueTypeLess(**lp,**rp)) {
+        return -1;
+    } else {
+        return +1;
+    }
+}
+void PVectorValueSort(PVectorValue* self) {
+    typedef int (*F)(const void*, const void*);
     assert(self);
-    for(index = 0; index < self->element_count; ++index) {
-        result ^= ValueTypeIdentify(self->values[index]);
+    qsort(self->values, PVectorValueSize(self), sizeof(ValueType*), (F)PVectorValueComparator);
+}
+
+#define AUTOC_COUNTER(p) (*(size_t*)((char*)(p) + sizeof(PVectorValue)))
+PVectorValue* PVectorValueNew(size_t element_count) {
+    PVectorValue* self = (PVectorValue*)malloc(sizeof(PVectorValue) + sizeof(size_t));
+    assert(self);
+    _PVectorValueCtor(*self,element_count);
+    AUTOC_COUNTER(self) = 1;
+    return self;
+}
+PVectorValue* PVectorValueRef(PVectorValue* self) {
+    assert(self);
+    ++AUTOC_COUNTER(self);
+    return self;
+}
+void PVectorValueFree(PVectorValue* self) {
+    assert(self);
+    if(--AUTOC_COUNTER(self) == 0) {
+        _PVectorValueDtor(*self);
+        free(self);
+    }
+}
+#undef AUTOC_COUNTER
+
+PVectorValue** ListPVectorValueItGetRef(ListPVectorValueIt*);
+void ListPVectorValueCtor(ListPVectorValue* self) {
+    assert(self);
+    self->head_node = NULL;
+    self->node_count = 0;
+}
+void ListPVectorValueDtor(ListPVectorValue* self) {
+    ListPVectorValueNode* node;
+    assert(self);
+    node = self->head_node;
+    while(node) {
+        ListPVectorValueNode* this_node = node;
+        node = node->next_node;
+        PVectorValueFree(this_node->element);
+        free(this_node);
+    }
+}
+void ListPVectorValueCopy(ListPVectorValue* dst,ListPVectorValue* src) {
+    ListPVectorValueIt it;
+    assert(src);
+    assert(dst);
+    ListPVectorValueCtor(dst);
+    ListPVectorValueItCtor(&it, src);
+    while(ListPVectorValueItMove(&it)) {
+        ListPVectorValuePush(dst, *ListPVectorValueItGetRef(&it));
+    }
+}
+int ListPVectorValueEqual(ListPVectorValue* lt,ListPVectorValue* rt) {
+    if(ListPVectorValueSize(lt) == ListPVectorValueSize(rt)) {
+        ListPVectorValueIt lit, rit;
+        ListPVectorValueItCtor(&lit, lt);
+        ListPVectorValueItCtor(&rit, rt);
+        while(ListPVectorValueItMove(&lit) && ListPVectorValueItMove(&rit)) {
+            int equal;
+            PVectorValue** le;
+            PVectorValue** re;
+            le = ListPVectorValueItGetRef(&lit);
+            re = ListPVectorValueItGetRef(&rit);
+            equal = _PVectorValueEqual(**le,**re);
+            if(!equal) return 0;
+        }
+        return 1;
+    } else
+        return 0;
+}
+size_t ListPVectorValueIdentify(ListPVectorValue* self) {
+    ListPVectorValueNode* node;
+    size_t result = 0;
+    assert(self);
+    for(node = self->head_node; node != NULL; node = node->next_node) {
+        result ^= _PVectorValueIdentify(*node->element);
         result = AUTOC_RCYCLE(result);
     }
     return result;
 }
-static int ValueTypeVectorComparator(void* lp_, void* rp_) {
-    ValueType* lp = (ValueType*)lp_;
-    ValueType* rp = (ValueType*)rp_;
-    if(ValueTypeEqual(*lp, *rp)) {
-        return 0;
-    } else if(ValueTypeLess(*lp, *rp)) {
-        return -1;
+void ListPVectorValuePurge(ListPVectorValue* self) {
+    ListPVectorValueDtor(self);
+    ListPVectorValueCtor(self);
+}
+PVectorValue* ListPVectorValuePeek(ListPVectorValue* self) {
+    PVectorValue* result;
+    assert(self);
+    assert(!ListPVectorValueEmpty(self));
+    ((result) = PVectorValueRef(self->head_node->element));
+    return result;
+}
+PVectorValue* ListPVectorValuePop(ListPVectorValue* self) {
+    ListPVectorValueNode* node;
+    PVectorValue* result;
+    assert(self);
+    assert(!ListPVectorValueEmpty(self));
+    node = self->head_node;
+    result = node->element;
+    self->head_node = self->head_node->next_node;
+    --self->node_count;
+    free(node);
+    return result;
+}
+void ListPVectorValuePush(ListPVectorValue* self, PVectorValue* element) {
+    ListPVectorValueNode* node;
+    assert(self);
+    node = (ListPVectorValueNode*)malloc(sizeof(ListPVectorValueNode));
+    assert(node);
+    ((node->element) = PVectorValueRef(element));
+    node->next_node = self->head_node;
+    self->head_node = node;
+    ++self->node_count;
+}
+int ListPVectorValueContains(ListPVectorValue* self, PVectorValue* what) {
+    ListPVectorValueNode* node;
+    int found = 0;
+    assert(self);
+    node = self->head_node;
+    while(node) {
+        if(_PVectorValueEqual(*node->element,*what)) {
+            found = 1;
+            break;
+        }
+        node = node->next_node;
+    }
+    return found;
+}
+PVectorValue* ListPVectorValueFind(ListPVectorValue* self, PVectorValue* what) {
+    ListPVectorValueNode* node;
+    assert(self);
+    assert(ListPVectorValueContains(self, what));
+    node = self->head_node;
+    while(node) {
+        if(_PVectorValueEqual(*node->element,*what)) {
+            PVectorValue* result;
+            ((result) = PVectorValueRef(node->element));
+            return result;
+        }
+        node = node->next_node;
+    }
+    abort();
+}
+int ListPVectorValueReplaceEx(ListPVectorValue* self, PVectorValue* with, int count) {
+    ListPVectorValueNode* node;
+    int replaced = 0;
+    assert(self);
+    if(count == 0) return 0;
+    node = self->head_node;
+    while(node) {
+        if(_PVectorValueEqual(*node->element,*with)) {
+            PVectorValueFree(node->element);
+            ((node->element) = PVectorValueRef(with));
+            ++replaced;
+            if(count > 0 && replaced >= count) break;
+        }
+        node = node->next_node;
+    }
+    return replaced;
+}
+int ListPVectorValueRemoveEx(ListPVectorValue* self, PVectorValue* what, int count) {
+    ListPVectorValueNode *node, *prev_node;
+    int removed = 0;
+    assert(self);
+    if(count == 0) return 0;
+    node = self->head_node;
+    prev_node = NULL;
+    while(node) {
+        if(_PVectorValueEqual(*node->element,*what)) {
+            ListPVectorValueNode* this_node;
+            if(prev_node) {
+                this_node = prev_node->next_node = node->next_node;
+            } else {
+                this_node = self->head_node = node->next_node;
+            }
+            ++removed;
+            --self->node_count;
+            PVectorValueFree(node->element);
+            free(node);
+            node = this_node;
+            if(count > 0 && removed >= count) break;
+        } else {
+            prev_node = node;
+            node = node->next_node;
+        }
+    }
+    return removed;
+}
+size_t ListPVectorValueSize(ListPVectorValue* self) {
+    assert(self);
+    return self->node_count;
+}
+void ListPVectorValueItCtor(ListPVectorValueIt* self, ListPVectorValue* list) {
+    assert(self);
+    assert(list);
+    self->start = 1;
+    self->list = list;
+}
+int ListPVectorValueItMove(ListPVectorValueIt* self) {
+    assert(self);
+    if(self->start) {
+        self->this_node = self->list->head_node;
+        self->start = 0;
     } else {
-        return +1;
+        self->this_node = self->this_node ? self->this_node->next_node : NULL;
     }
+    return self->this_node != NULL;
 }
-void ValueTypeVectorSort(ValueTypeVector* self) {
-    typedef int (*F)(const void*, const void*);
+PVectorValue* ListPVectorValueItGet(ListPVectorValueIt* self) {
+    PVectorValue* result;
     assert(self);
-    qsort(self->values, ValueTypeVectorSize(self), sizeof(ValueType), (F)ValueTypeVectorComparator);
+    assert(self->this_node);
+    ((result) = PVectorValueRef(self->this_node->element));
+    return result;
+}
+PVectorValue** ListPVectorValueItGetRef(ListPVectorValueIt* self) {
+    assert(self);
+    assert(self->this_node);
+    return &self->this_node->element;
 }