autoc 1.2 → 1.3

data/test/test.h

@@ -1,41 +0,0 @@
-#ifndef test_h
-#define test_h
-
-
-typedef struct ValueType ValueType;
-
-
-struct ValueType {
-  int value;
-  void* block;
-};
-
-
-void ValueTypeCtorEx(ValueType*, int);
-
-
-#define ValueTypeCtor(obj) ValueTypeCtorRef(&obj)
-void ValueTypeCtorRef(ValueType*);
-
-
-#define ValueTypeDtor(obj) ValueTypeDtorRef(&obj)
-void ValueTypeDtorRef(ValueType*);
-
-
-#define ValueTypeCopy(dst, src) ValueTypeCopyRef(&dst, &src)
-void ValueTypeCopyRef(ValueType*, ValueType*);
-
-
-#define ValueTypeEqual(lt, rt) ValueTypeEqualRef(&lt, &rt)
-int ValueTypeEqualRef(ValueType*, ValueType*);
-
-
-#define ValueTypeLess(lt, rt) ValueTypeLessRef(&lt, &rt)
-int ValueTypeLessRef(ValueType*, ValueType*);
-
-
-#define ValueTypeIdentify(obj) ValueTypeIdentifyRef(&obj)
-size_t ValueTypeIdentifyRef(ValueType*);
-
-
-#endif

data/test/test_auto.c

@@ -1,3407 +0,0 @@
-
-/* AUTOMATICALLY GENERATED SOURCE FILE. DO NOT MODIFY. */
-#include "test_auto.h"
-
-#include <limits.h>
-#define AUTOC_MIN(a,b) ((a) > (b) ? (b) : (a))
-#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
-#define AUTOC_OWNED_KEY 8
-static IntStrMapEntry IntStrMapEntryKeyOnlyRef(int* key) {
-    IntStrMapEntry entry;
-    entry.key = *key;
-    entry.flags = AUTOC_VALID_KEY;
-    return entry;
-}
-static IntStrMapEntry IntStrMapEntryKeyValueRef(int* key, const char ** value) {
-    IntStrMapEntry entry;
-    entry.key = *key;
-    entry.value = *value;
-    entry.flags = (AUTOC_VALID_KEY | AUTOC_VALID_VALUE);
-    return entry;
-}
-#define IntStrMapEntryIdentify(obj) IntStrMapEntryIdentifyRef(&obj)
-static size_t IntStrMapEntryIdentifyRef(IntStrMapEntry* entry) {
-    return ((size_t)(entry->key));
-}
-#define IntStrMapEntryEqual(lt, rt) IntStrMapEntryEqualRef(&lt, &rt)
-static int IntStrMapEntryEqualRef(IntStrMapEntry* lt, IntStrMapEntry* rt) {
-    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));
-    if(src->flags & AUTOC_VALID_VALUE) {
-        dst->flags |= (AUTOC_VALID_VALUE | AUTOC_OWNED_VALUE);
-        ((dst->value) = (src->value));
-    }
-}
-#define IntStrMapEntryDtor(obj) IntStrMapEntryDtorRef(&obj)
-static void IntStrMapEntryDtorRef(IntStrMapEntry* entry) {
-    assert(entry->flags & AUTOC_VALID_KEY);
-    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 size_t IntStrMapSetIdentify(IntStrMapSet*);
-AUTOC_STATIC void IntStrMapSetPurge(IntStrMapSet*);
-AUTOC_STATIC int IntStrMapSetContains(IntStrMapSet*, IntStrMapEntry);
-AUTOC_STATIC IntStrMapEntry IntStrMapSetGet(IntStrMapSet*, IntStrMapEntry);
-AUTOC_STATIC size_t IntStrMapSetSize(IntStrMapSet*);
-#define IntStrMapSetEmpty(self) (IntStrMapSetSize(self) == 0)
-AUTOC_STATIC int IntStrMapSetPut(IntStrMapSet*, IntStrMapEntry);
-AUTOC_STATIC int IntStrMapSetReplace(IntStrMapSet*, IntStrMapEntry);
-AUTOC_STATIC int IntStrMapSetRemove(IntStrMapSet*, IntStrMapEntry);
-AUTOC_STATIC void IntStrMapSetExclude(IntStrMapSet*, IntStrMapSet*);
-AUTOC_STATIC void IntStrMapSetRetain(IntStrMapSet*, IntStrMapSet*);
-AUTOC_STATIC void IntStrMapSetInclude(IntStrMapSet*, IntStrMapSet*);
-AUTOC_STATIC void IntStrMapSetInvert(IntStrMapSet*, IntStrMapSet*);
-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 size_t IntStrMapSetListIdentify(IntStrMapSetList*);
-AUTOC_STATIC void IntStrMapSetListPurge(IntStrMapSetList*);
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListPeek(IntStrMapSetList*);
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListPop(IntStrMapSetList*);
-AUTOC_STATIC void IntStrMapSetListPush(IntStrMapSetList*, IntStrMapEntry);
-AUTOC_STATIC int IntStrMapSetListContains(IntStrMapSetList*, IntStrMapEntry);
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListFind(IntStrMapSetList*, IntStrMapEntry);
-#define IntStrMapSetListReplace(self, with) IntStrMapSetListReplaceEx(self, with, 1)
-#define IntStrMapSetListReplaceAll(self, with) IntStrMapSetListReplaceEx(self, with, -1)
-AUTOC_STATIC int IntStrMapSetListReplaceEx(IntStrMapSetList*, IntStrMapEntry, int);
-#define IntStrMapSetListRemove(self, what) IntStrMapSetListRemoveEx(self, what, 1)
-#define IntStrMapSetListRemoveAll(self, what) IntStrMapSetListRemoveEx(self, what, -1)
-AUTOC_STATIC int IntStrMapSetListRemoveEx(IntStrMapSetList*, IntStrMapEntry, int);
-AUTOC_STATIC size_t IntStrMapSetListSize(IntStrMapSetList*);
-#define IntStrMapSetListEmpty(self) (IntStrMapSetListSize(self) == 0)
-AUTOC_STATIC void IntStrMapSetListItCtor(IntStrMapSetListIt*, IntStrMapSetList*);
-AUTOC_STATIC int IntStrMapSetListItMove(IntStrMapSetListIt*);
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListItGet(IntStrMapSetListIt*);
-
-AUTOC_STATIC IntStrMapEntry* IntStrMapSetListItGetRef(IntStrMapSetListIt*);
-AUTOC_STATIC void IntStrMapSetListCtor(IntStrMapSetList* self) {
-    assert(self);
-    self->head_node = NULL;
-    self->node_count = 0;
-}
-AUTOC_STATIC void IntStrMapSetListDtor(IntStrMapSetList* self) {
-    IntStrMapSetListNode* node;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        IntStrMapSetListNode* this_node = node;
-        node = node->next_node;
-        IntStrMapEntryDtor(this_node->element);
-        free(this_node);
-    }
-}
-AUTOC_STATIC void IntStrMapSetListCopy(IntStrMapSetList* dst,IntStrMapSetList* src) {
-    IntStrMapSetListIt it;
-    assert(src);
-    assert(dst);
-    IntStrMapSetListCtor(dst);
-    IntStrMapSetListItCtor(&it, src);
-    while(IntStrMapSetListItMove(&it)) {
-        IntStrMapSetListPush(dst, *IntStrMapSetListItGetRef(&it));
-    }
-}
-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;
-            IntStrMapEntry* re;
-            le = IntStrMapSetListItGetRef(&lit);
-            re = IntStrMapSetListItGetRef(&rit);
-            equal = IntStrMapEntryEqual(*le,*re);
-            if(!equal) return 0;
-        }
-        return 1;
-    } else
-        return 0;
-}
-AUTOC_STATIC size_t IntStrMapSetListIdentify(IntStrMapSetList* self) {
-    IntStrMapSetListNode* node;
-    size_t result = 0;
-    assert(self);
-    for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= IntStrMapEntryIdentify(node->element);
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-AUTOC_STATIC void IntStrMapSetListPurge(IntStrMapSetList* self) {
-    IntStrMapSetListDtor(self);
-    IntStrMapSetListCtor(self);
-}
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListPeek(IntStrMapSetList* self) {
-    IntStrMapEntry result;
-    assert(self);
-    assert(!IntStrMapSetListEmpty(self));
-    IntStrMapEntryCopy(result,self->head_node->element);
-    return result;
-}
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListPop(IntStrMapSetList* self) {
-    IntStrMapSetListNode* node;
-    IntStrMapEntry result;
-    assert(self);
-    assert(!IntStrMapSetListEmpty(self));
-    node = self->head_node;
-    result = node->element;
-    self->head_node = self->head_node->next_node;
-    --self->node_count;
-    free(node);
-    return result;
-}
-AUTOC_STATIC void IntStrMapSetListPush(IntStrMapSetList* self, IntStrMapEntry element) {
-    IntStrMapSetListNode* node;
-    assert(self);
-    node = (IntStrMapSetListNode*)malloc(sizeof(IntStrMapSetListNode));
-    assert(node);
-    IntStrMapEntryCopy(node->element,element);
-    node->next_node = self->head_node;
-    self->head_node = node;
-    ++self->node_count;
-}
-AUTOC_STATIC int IntStrMapSetListContains(IntStrMapSetList* self, IntStrMapEntry what) {
-    IntStrMapSetListNode* node;
-    int found = 0;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        if(IntStrMapEntryEqual(node->element,what)) {
-            found = 1;
-            break;
-        }
-        node = node->next_node;
-    }
-    return found;
-}
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListFind(IntStrMapSetList* self, IntStrMapEntry what) {
-    IntStrMapSetListNode* node;
-    assert(self);
-    assert(IntStrMapSetListContains(self, what));
-    node = self->head_node;
-    while(node) {
-        if(IntStrMapEntryEqual(node->element,what)) {
-            IntStrMapEntry result;
-            IntStrMapEntryCopy(result,node->element);
-            return result;
-        }
-        node = node->next_node;
-    }
-    abort();
-}
-AUTOC_STATIC int IntStrMapSetListReplaceEx(IntStrMapSetList* self, IntStrMapEntry with, int count) {
-    IntStrMapSetListNode* node;
-    int replaced = 0;
-    assert(self);
-    if(count == 0) return 0;
-    node = self->head_node;
-    while(node) {
-        if(IntStrMapEntryEqual(node->element,with)) {
-            IntStrMapEntryDtor(node->element);
-            IntStrMapEntryCopy(node->element,with);
-            ++replaced;
-            if(count > 0 && replaced >= count) break;
-        }
-        node = node->next_node;
-    }
-    return replaced;
-}
-AUTOC_STATIC int IntStrMapSetListRemoveEx(IntStrMapSetList* self, IntStrMapEntry what, int count) {
-    IntStrMapSetListNode *node, *prev_node;
-    int removed = 0;
-    assert(self);
-    if(count == 0) return 0;
-    node = self->head_node;
-    prev_node = NULL;
-    while(node) {
-        if(IntStrMapEntryEqual(node->element,what)) {
-            IntStrMapSetListNode* 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;
-            IntStrMapEntryDtor(node->element);
-            free(node);
-            node = this_node;
-            if(count > 0 && removed >= count) break;
-        } else {
-            prev_node = node;
-            node = node->next_node;
-        }
-    }
-    return removed;
-}
-AUTOC_STATIC size_t IntStrMapSetListSize(IntStrMapSetList* self) {
-    assert(self);
-    return self->node_count;
-}
-AUTOC_STATIC void IntStrMapSetListItCtor(IntStrMapSetListIt* self, IntStrMapSetList* list) {
-    assert(self);
-    assert(list);
-    self->start = 1;
-    self->list = list;
-}
-AUTOC_STATIC int IntStrMapSetListItMove(IntStrMapSetListIt* 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;
-}
-AUTOC_STATIC IntStrMapEntry IntStrMapSetListItGet(IntStrMapSetListIt* self) {
-    IntStrMapEntry result;
-    assert(self);
-    assert(self->this_node);
-    IntStrMapEntryCopy(result,self->this_node->element);
-    return result;
-}
-AUTOC_STATIC IntStrMapEntry* IntStrMapSetListItGetRef(IntStrMapSetListIt* self) {
-    assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
-}
-
-AUTOC_STATIC IntStrMapEntry* IntStrMapSetItGetRef(IntStrMapSetIt*);
-static void IntStrMapSetRehash(IntStrMapSet* self) {
-    IntStrMapSetList* buckets;
-    size_t index, bucket_count, size, fill;
-    assert(self);
-    assert(self->min_fill > 0);
-    assert(self->max_fill > 0);
-    assert(self->min_fill < self->max_fill);
-    assert(self->min_bucket_count > 0);
-    if(self->buckets) {
-        if(self->min_size < self->size && self->size < self->max_size) return;
-        fill = (size_t)((float)self->size/self->bucket_count*100);
-        if(fill > self->max_fill) {
-            bucket_count = (size_t)((float)self->bucket_count/100*self->capacity_multiplier);
-        } else if(fill < self->min_fill && self->bucket_count > self->min_bucket_count) {
-            bucket_count = (size_t)((float)self->bucket_count/self->capacity_multiplier*100);
-            if(bucket_count < self->min_bucket_count) bucket_count = self->min_bucket_count;
-        } else
-            return;
-        size = self->size;
-        self->min_size = (size_t)((float)self->min_fill/100*size);
-        self->max_size = (size_t)((float)self->max_fill/100*size);
-    } else {
-        bucket_count = self->min_bucket_count;
-        size = 0;
-    }
-    buckets = (IntStrMapSetList*)malloc(bucket_count*sizeof(IntStrMapSetList));
-    assert(buckets);
-    for(index = 0; index < bucket_count; ++index) {
-        IntStrMapSetListCtor(&buckets[index]);
-    }
-    if(self->buckets) {
-        IntStrMapSetIt it;
-        IntStrMapSetItCtor(&it, self);
-        while(IntStrMapSetItMove(&it)) {
-            IntStrMapSetList* bucket;
-            IntStrMapEntry element = IntStrMapSetItGet(&it);
-            bucket = &buckets[IntStrMapEntryIdentify(element) % bucket_count];
-            IntStrMapSetListPush(bucket, element);
-            IntStrMapEntryDtor(element);
-        }
-        IntStrMapSetDtor(self);
-    }
-    self->buckets = buckets;
-    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;
-    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;
-    IntStrMapSetRehash(self);
-}
-AUTOC_STATIC void IntStrMapSetDtor(IntStrMapSet* self) {
-    size_t i;
-    assert(self);
-    for(i = 0; i < self->bucket_count; ++i) {
-        IntStrMapSetListDtor(&self->buckets[i]);
-    }
-    free(self->buckets);
-}
-AUTOC_STATIC void IntStrMapSetCopy(IntStrMapSet* dst,IntStrMapSet* src) {
-    IntStrMapSetIt it;
-    assert(src);
-    assert(dst);
-    IntStrMapSetCtor(dst);
-    IntStrMapSetItCtor(&it, src);
-    while(IntStrMapSetItMove(&it)) IntStrMapSetPut(dst, *IntStrMapSetItGetRef(&it));
-}
-AUTOC_STATIC int IntStrMapSetEqual(IntStrMapSet* lt,IntStrMapSet* rt) {
-    assert(lt);
-    assert(rt);
-    return IntStrMapSetSize(lt) == IntStrMapSetSize(rt) && IntStrMapSetContainsAllOf(lt, rt) && IntStrMapSetContainsAllOf(rt, lt);
-}
-AUTOC_STATIC size_t IntStrMapSetIdentify(IntStrMapSet* self) {
-    IntStrMapSetIt it;
-    size_t result = 0;
-    assert(self);
-    IntStrMapSetItCtor(&it, self);
-    while(IntStrMapSetItMove(&it)) {
-        IntStrMapEntry* e = IntStrMapSetItGetRef(&it);
-        result ^= IntStrMapEntryIdentify(*e);
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-AUTOC_STATIC void IntStrMapSetPurge(IntStrMapSet* self) {
-    assert(self);
-    IntStrMapSetDtor(self);
-    self->buckets = NULL;
-    IntStrMapSetRehash(self);
-}
-AUTOC_STATIC int IntStrMapSetContains(IntStrMapSet* self, IntStrMapEntry element) {
-    assert(self);
-    return IntStrMapSetListContains(&self->buckets[IntStrMapEntryIdentify(element) % self->bucket_count], element);
-}
-AUTOC_STATIC IntStrMapEntry IntStrMapSetGet(IntStrMapSet* self, IntStrMapEntry element) {
-    IntStrMapEntry result;
-    assert(self);
-    assert(IntStrMapSetContains(self, element));
-    result = IntStrMapSetListFind(&self->buckets[IntStrMapEntryIdentify(element) % self->bucket_count], element);
-    return result;
-}
-AUTOC_STATIC size_t IntStrMapSetSize(IntStrMapSet* self) {
-    assert(self);
-    return self->size;
-}
-AUTOC_STATIC int IntStrMapSetPut(IntStrMapSet* self, IntStrMapEntry element) {
-    IntStrMapSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[IntStrMapEntryIdentify(element) % self->bucket_count];
-    if(!IntStrMapSetListContains(bucket, element)) {
-        IntStrMapSetListPush(bucket, element);
-        ++self->size;
-        IntStrMapSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-AUTOC_STATIC int IntStrMapSetReplace(IntStrMapSet* self, IntStrMapEntry element) {
-    IntStrMapSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[IntStrMapEntryIdentify(element) % self->bucket_count];
-    return IntStrMapSetListReplace(bucket, element);
-}
-AUTOC_STATIC int IntStrMapSetRemove(IntStrMapSet* self, IntStrMapEntry element) {
-    IntStrMapSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[IntStrMapEntryIdentify(element) % self->bucket_count];
-    if(IntStrMapSetListRemove(bucket, element)) {
-        --self->size;
-        IntStrMapSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-AUTOC_STATIC void IntStrMapSetExclude(IntStrMapSet* self, IntStrMapSet* other) {
-    IntStrMapSetIt it;
-    assert(self);
-    assert(other);
-    IntStrMapSetItCtor(&it, other);
-    while(IntStrMapSetItMove(&it)) IntStrMapSetRemove(self, *IntStrMapSetItGetRef(&it));
-}
-AUTOC_STATIC void IntStrMapSetInclude(IntStrMapSet* self, IntStrMapSet* other) {
-    IntStrMapSetIt it;
-    assert(self);
-    assert(other);
-    IntStrMapSetItCtor(&it, other);
-    while(IntStrMapSetItMove(&it)) IntStrMapSetPut(self, *IntStrMapSetItGetRef(&it));
-}
-AUTOC_STATIC void IntStrMapSetRetain(IntStrMapSet* self, IntStrMapSet* other) {
-    IntStrMapSetIt it;
-    IntStrMapSet set;
-    assert(self);
-    assert(other);
-    IntStrMapSetCtor(&set);
-    IntStrMapSetItCtor(&it, self);
-    while(IntStrMapSetItMove(&it)) {
-        IntStrMapEntry* e = IntStrMapSetItGetRef(&it);
-        if(IntStrMapSetContains(other, *e)) IntStrMapSetPut(&set, *e);
-    }
-    IntStrMapSetDtor(self);
-    *self = set;
-}
-AUTOC_STATIC void IntStrMapSetInvert(IntStrMapSet* self, IntStrMapSet* other) {
-    IntStrMapSetIt it;
-    IntStrMapSet set;
-    assert(self);
-    assert(other);
-    IntStrMapSetCtor(&set);
-    IntStrMapSetItCtor(&it, self);
-    while(IntStrMapSetItMove(&it)) {
-        IntStrMapEntry* e = IntStrMapSetItGetRef(&it);
-        if(!IntStrMapSetContains(other, *e)) IntStrMapSetPut(&set, *e);
-    }
-    IntStrMapSetItCtor(&it, other);
-    while(IntStrMapSetItMove(&it)) {
-        IntStrMapEntry* e = IntStrMapSetItGetRef(&it);
-        if(!IntStrMapSetContains(self, *e)) IntStrMapSetPut(&set, *e);
-    }
-    IntStrMapSetDtor(self);
-    *self = set;
-}
-AUTOC_STATIC void IntStrMapSetItCtor(IntStrMapSetIt* self, IntStrMapSet* set) {
-    assert(self);
-    self->set = set;
-    self->bucket_index = -1;
-}
-AUTOC_STATIC int IntStrMapSetItMove(IntStrMapSetIt* self) {
-    assert(self);
-    if(self->bucket_index < 0) IntStrMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index = 0]);
-    if(IntStrMapSetListItMove(&self->it)) return 1;
-    while(++self->bucket_index < self->set->bucket_count) {
-        IntStrMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
-        if(IntStrMapSetListItMove(&self->it)) return 1;
-    }
-    return 0;
-}
-AUTOC_STATIC IntStrMapEntry IntStrMapSetItGet(IntStrMapSetIt* self) {
-    assert(self);
-    return IntStrMapSetListItGet(&self->it);
-}
-AUTOC_STATIC IntStrMapEntry* IntStrMapSetItGetRef(IntStrMapSetIt* self) {
-    assert(self);
-    return IntStrMapSetListItGetRef(&self->it);
-}
-
-void IntStrMapCtor(IntStrMap* self) {
-    assert(self);
-    IntStrMapSetCtor(&self->entries);
-}
-void IntStrMapDtor(IntStrMap* self) {
-    assert(self);
-    IntStrMapSetDtor(&self->entries);
-}
-static int IntStrMapPutEntryRef(IntStrMap* self, IntStrMapEntry* entry) {
-    int absent;
-    assert(self);
-    assert(entry);
-    if((absent = !IntStrMapContainsKey(self, entry->key))) {
-        IntStrMapSetPut(&self->entries, *entry);
-    }
-    return absent;
-}
-void IntStrMapCopy(IntStrMap* dst,IntStrMap* src) {
-    IntStrMapIt it;
-    assert(src);
-    assert(dst);
-    IntStrMapCtor(dst);
-    IntStrMapItCtor(&it, src);
-    while(IntStrMapItMove(&it)) {
-        IntStrMapEntry* e = IntStrMapItGetEntryRef(&it);
-        IntStrMapPutEntryRef(dst, e);
-    }
-}
-int IntStrMapEqual(IntStrMap* lt,IntStrMap* rt) {
-    assert(lt);
-    assert(rt);
-    return IntStrMapSize(lt) == IntStrMapSize(rt) && IntStrMapContainsAllOf(lt, rt) && IntStrMapContainsAllOf(rt, lt);
-}
-size_t IntStrMapIdentify(IntStrMap* self) {
-    assert(self);
-    return IntStrMapSetIdentify(&self->entries); /* TODO : make use of the values' hashes */
-}
-void IntStrMapPurge(IntStrMap* self) {
-    assert(self);
-    IntStrMapSetPurge(&self->entries);
-}
-size_t IntStrMapSize(IntStrMap* self) {
-    assert(self);
-    return IntStrMapSetSize(&self->entries);
-}
-int IntStrMapContainsKey(IntStrMap* self, int key) {
-    int result;
-    IntStrMapEntry entry;
-    assert(self);
-    result = IntStrMapSetContains(&self->entries, entry = IntStrMapEntryKeyOnlyRef(&key));
-    IntStrMapEntryDtor(entry);
-    return 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));
-    IntStrMapEntryDtor(existing_entry);
-    IntStrMapEntryDtor(entry);
-    return result;
-}
-int IntStrMapPut(IntStrMap* self, int key, const char * value) {
-    int result;
-    IntStrMapEntry entry;
-    assert(self);
-    entry = IntStrMapEntryKeyValueRef(&key, &value);
-    result = IntStrMapPutEntryRef(self, &entry);
-    IntStrMapEntryDtor(entry);
-    return result;
-}
-int IntStrMapReplace(IntStrMap* self, int key, const char * value) {
-    int result;
-    IntStrMapEntry entry;
-    assert(self);
-    entry = IntStrMapEntryKeyValueRef(&key, &value);
-    result = IntStrMapSetReplace(&self->entries, entry);
-    IntStrMapEntryDtor(entry);
-    return result;
-}
-int IntStrMapRemove(IntStrMap* self, int key) {
-    int result;
-    IntStrMapEntry entry;
-    assert(self);
-    result = IntStrMapSetRemove(&self->entries, entry = IntStrMapEntryKeyOnlyRef(&key));
-    IntStrMapEntryDtor(entry);
-    return result;
-}
-void IntStrMapItCtor(IntStrMapIt* self, IntStrMap* map) {
-    assert(self);
-    assert(map);
-    IntStrMapSetItCtor(&self->it, &map->entries);
-}
-int IntStrMapItMove(IntStrMapIt* self) {
-    assert(self);
-    return IntStrMapSetItMove(&self->it);
-}
-int IntStrMapItGetKey(IntStrMapIt* self) {
-    IntStrMapEntry* e;
-    int key;
-    assert(self);
-    e = IntStrMapItGetEntryRef(self);
-    ((key) = (e->key));
-    return key;
-}
-const char * IntStrMapItGetElement(IntStrMapIt* self) {
-    IntStrMapEntry* e;
-    const char * value;
-    assert(self);
-    e = IntStrMapItGetEntryRef(self);
-    assert(e->flags & AUTOC_VALID_VALUE);
-    ((value) = (e->value));
-    return value;
-}
-static IntStrMapEntry* IntStrMapItGetEntryRef(IntStrMapIt* self) {
-    assert(self);
-    return IntStrMapSetItGetRef(&self->it);
-}
-#undef AUTOC_VALID_VALUE
-#undef AUTOC_VALID_KEY
-#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 size_t IntSetListIdentify(IntSetList*);
-AUTOC_STATIC void IntSetListPurge(IntSetList*);
-AUTOC_STATIC int IntSetListPeek(IntSetList*);
-AUTOC_STATIC int IntSetListPop(IntSetList*);
-AUTOC_STATIC void IntSetListPush(IntSetList*, int);
-AUTOC_STATIC int IntSetListContains(IntSetList*, int);
-AUTOC_STATIC int IntSetListFind(IntSetList*, int);
-#define IntSetListReplace(self, with) IntSetListReplaceEx(self, with, 1)
-#define IntSetListReplaceAll(self, with) IntSetListReplaceEx(self, with, -1)
-AUTOC_STATIC int IntSetListReplaceEx(IntSetList*, int, int);
-#define IntSetListRemove(self, what) IntSetListRemoveEx(self, what, 1)
-#define IntSetListRemoveAll(self, what) IntSetListRemoveEx(self, what, -1)
-AUTOC_STATIC int IntSetListRemoveEx(IntSetList*, int, int);
-AUTOC_STATIC size_t IntSetListSize(IntSetList*);
-#define IntSetListEmpty(self) (IntSetListSize(self) == 0)
-AUTOC_STATIC void IntSetListItCtor(IntSetListIt*, IntSetList*);
-AUTOC_STATIC int IntSetListItMove(IntSetListIt*);
-AUTOC_STATIC int IntSetListItGet(IntSetListIt*);
-
-AUTOC_STATIC int* IntSetListItGetRef(IntSetListIt*);
-AUTOC_STATIC void IntSetListCtor(IntSetList* self) {
-    assert(self);
-    self->head_node = NULL;
-    self->node_count = 0;
-}
-AUTOC_STATIC void IntSetListDtor(IntSetList* self) {
-    IntSetListNode* node;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        IntSetListNode* this_node = node;
-        node = node->next_node;
-        ;
-        free(this_node);
-    }
-}
-AUTOC_STATIC void IntSetListCopy(IntSetList* dst,IntSetList* src) {
-    IntSetListIt it;
-    assert(src);
-    assert(dst);
-    IntSetListCtor(dst);
-    IntSetListItCtor(&it, src);
-    while(IntSetListItMove(&it)) {
-        IntSetListPush(dst, *IntSetListItGetRef(&it));
-    }
-}
-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;
-            int* re;
-            le = IntSetListItGetRef(&lit);
-            re = IntSetListItGetRef(&rit);
-            equal = ((*le) == (*re));
-            if(!equal) return 0;
-        }
-        return 1;
-    } else
-        return 0;
-}
-AUTOC_STATIC size_t IntSetListIdentify(IntSetList* self) {
-    IntSetListNode* node;
-    size_t result = 0;
-    assert(self);
-    for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= ((size_t)(node->element));
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-AUTOC_STATIC void IntSetListPurge(IntSetList* self) {
-    IntSetListDtor(self);
-    IntSetListCtor(self);
-}
-AUTOC_STATIC int IntSetListPeek(IntSetList* self) {
-    int result;
-    assert(self);
-    assert(!IntSetListEmpty(self));
-    ((result) = (self->head_node->element));
-    return result;
-}
-AUTOC_STATIC int IntSetListPop(IntSetList* self) {
-    IntSetListNode* node;
-    int result;
-    assert(self);
-    assert(!IntSetListEmpty(self));
-    node = self->head_node;
-    result = node->element;
-    self->head_node = self->head_node->next_node;
-    --self->node_count;
-    free(node);
-    return result;
-}
-AUTOC_STATIC void IntSetListPush(IntSetList* self, int element) {
-    IntSetListNode* node;
-    assert(self);
-    node = (IntSetListNode*)malloc(sizeof(IntSetListNode));
-    assert(node);
-    ((node->element) = (element));
-    node->next_node = self->head_node;
-    self->head_node = node;
-    ++self->node_count;
-}
-AUTOC_STATIC int IntSetListContains(IntSetList* self, int what) {
-    IntSetListNode* node;
-    int found = 0;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        if(((node->element) == (what))) {
-            found = 1;
-            break;
-        }
-        node = node->next_node;
-    }
-    return found;
-}
-AUTOC_STATIC int IntSetListFind(IntSetList* self, int what) {
-    IntSetListNode* node;
-    assert(self);
-    assert(IntSetListContains(self, what));
-    node = self->head_node;
-    while(node) {
-        if(((node->element) == (what))) {
-            int result;
-            ((result) = (node->element));
-            return result;
-        }
-        node = node->next_node;
-    }
-    abort();
-}
-AUTOC_STATIC int IntSetListReplaceEx(IntSetList* self, int with, int count) {
-    IntSetListNode* node;
-    int replaced = 0;
-    assert(self);
-    if(count == 0) return 0;
-    node = self->head_node;
-    while(node) {
-        if(((node->element) == (with))) {
-            ;
-            ((node->element) = (with));
-            ++replaced;
-            if(count > 0 && replaced >= count) break;
-        }
-        node = node->next_node;
-    }
-    return replaced;
-}
-AUTOC_STATIC int IntSetListRemoveEx(IntSetList* self, int what, int count) {
-    IntSetListNode *node, *prev_node;
-    int removed = 0;
-    assert(self);
-    if(count == 0) return 0;
-    node = self->head_node;
-    prev_node = NULL;
-    while(node) {
-        if(((node->element) == (what))) {
-            IntSetListNode* 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;
-            ;
-            free(node);
-            node = this_node;
-            if(count > 0 && removed >= count) break;
-        } else {
-            prev_node = node;
-            node = node->next_node;
-        }
-    }
-    return removed;
-}
-AUTOC_STATIC size_t IntSetListSize(IntSetList* self) {
-    assert(self);
-    return self->node_count;
-}
-AUTOC_STATIC void IntSetListItCtor(IntSetListIt* self, IntSetList* list) {
-    assert(self);
-    assert(list);
-    self->start = 1;
-    self->list = list;
-}
-AUTOC_STATIC int IntSetListItMove(IntSetListIt* 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;
-}
-AUTOC_STATIC int IntSetListItGet(IntSetListIt* self) {
-    int result;
-    assert(self);
-    assert(self->this_node);
-    ((result) = (self->this_node->element));
-    return result;
-}
-AUTOC_STATIC int* IntSetListItGetRef(IntSetListIt* self) {
-    assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
-}
-
-int* IntSetItGetRef(IntSetIt*);
-static void IntSetRehash(IntSet* self) {
-    IntSetList* buckets;
-    size_t index, bucket_count, size, fill;
-    assert(self);
-    assert(self->min_fill > 0);
-    assert(self->max_fill > 0);
-    assert(self->min_fill < self->max_fill);
-    assert(self->min_bucket_count > 0);
-    if(self->buckets) {
-        if(self->min_size < self->size && self->size < self->max_size) return;
-        fill = (size_t)((float)self->size/self->bucket_count*100);
-        if(fill > self->max_fill) {
-            bucket_count = (size_t)((float)self->bucket_count/100*self->capacity_multiplier);
-        } else if(fill < self->min_fill && self->bucket_count > self->min_bucket_count) {
-            bucket_count = (size_t)((float)self->bucket_count/self->capacity_multiplier*100);
-            if(bucket_count < self->min_bucket_count) bucket_count = self->min_bucket_count;
-        } else
-            return;
-        size = self->size;
-        self->min_size = (size_t)((float)self->min_fill/100*size);
-        self->max_size = (size_t)((float)self->max_fill/100*size);
-    } else {
-        bucket_count = self->min_bucket_count;
-        size = 0;
-    }
-    buckets = (IntSetList*)malloc(bucket_count*sizeof(IntSetList));
-    assert(buckets);
-    for(index = 0; index < bucket_count; ++index) {
-        IntSetListCtor(&buckets[index]);
-    }
-    if(self->buckets) {
-        IntSetIt it;
-        IntSetItCtor(&it, self);
-        while(IntSetItMove(&it)) {
-            IntSetList* bucket;
-            int element = IntSetItGet(&it);
-            bucket = &buckets[((size_t)(element)) % bucket_count];
-            IntSetListPush(bucket, element);
-            ;
-        }
-        IntSetDtor(self);
-    }
-    self->buckets = buckets;
-    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;
-    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;
-    IntSetRehash(self);
-}
-void IntSetDtor(IntSet* self) {
-    size_t i;
-    assert(self);
-    for(i = 0; i < self->bucket_count; ++i) {
-        IntSetListDtor(&self->buckets[i]);
-    }
-    free(self->buckets);
-}
-void IntSetCopy(IntSet* dst,IntSet* src) {
-    IntSetIt it;
-    assert(src);
-    assert(dst);
-    IntSetCtor(dst);
-    IntSetItCtor(&it, src);
-    while(IntSetItMove(&it)) IntSetPut(dst, *IntSetItGetRef(&it));
-}
-int IntSetEqual(IntSet* lt,IntSet* rt) {
-    assert(lt);
-    assert(rt);
-    return IntSetSize(lt) == IntSetSize(rt) && IntSetContainsAllOf(lt, rt) && IntSetContainsAllOf(rt, lt);
-}
-size_t IntSetIdentify(IntSet* self) {
-    IntSetIt it;
-    size_t result = 0;
-    assert(self);
-    IntSetItCtor(&it, self);
-    while(IntSetItMove(&it)) {
-        int* e = IntSetItGetRef(&it);
-        result ^= ((size_t)(*e));
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-void IntSetPurge(IntSet* self) {
-    assert(self);
-    IntSetDtor(self);
-    self->buckets = NULL;
-    IntSetRehash(self);
-}
-int IntSetContains(IntSet* self, int element) {
-    assert(self);
-    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);
-    return result;
-}
-size_t IntSetSize(IntSet* self) {
-    assert(self);
-    return self->size;
-}
-int IntSetPut(IntSet* self, int element) {
-    IntSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[((size_t)(element)) % self->bucket_count];
-    if(!IntSetListContains(bucket, element)) {
-        IntSetListPush(bucket, element);
-        ++self->size;
-        IntSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-int IntSetReplace(IntSet* self, int element) {
-    IntSetList* bucket;
-    assert(self);
-    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];
-    if(IntSetListRemove(bucket, element)) {
-        --self->size;
-        IntSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-void IntSetExclude(IntSet* self, IntSet* other) {
-    IntSetIt it;
-    assert(self);
-    assert(other);
-    IntSetItCtor(&it, other);
-    while(IntSetItMove(&it)) IntSetRemove(self, *IntSetItGetRef(&it));
-}
-void IntSetInclude(IntSet* self, IntSet* other) {
-    IntSetIt it;
-    assert(self);
-    assert(other);
-    IntSetItCtor(&it, other);
-    while(IntSetItMove(&it)) IntSetPut(self, *IntSetItGetRef(&it));
-}
-void IntSetRetain(IntSet* self, IntSet* other) {
-    IntSetIt it;
-    IntSet set;
-    assert(self);
-    assert(other);
-    IntSetCtor(&set);
-    IntSetItCtor(&it, self);
-    while(IntSetItMove(&it)) {
-        int* e = IntSetItGetRef(&it);
-        if(IntSetContains(other, *e)) IntSetPut(&set, *e);
-    }
-    IntSetDtor(self);
-    *self = set;
-}
-void IntSetInvert(IntSet* self, IntSet* other) {
-    IntSetIt it;
-    IntSet set;
-    assert(self);
-    assert(other);
-    IntSetCtor(&set);
-    IntSetItCtor(&it, self);
-    while(IntSetItMove(&it)) {
-        int* e = IntSetItGetRef(&it);
-        if(!IntSetContains(other, *e)) IntSetPut(&set, *e);
-    }
-    IntSetItCtor(&it, other);
-    while(IntSetItMove(&it)) {
-        int* e = IntSetItGetRef(&it);
-        if(!IntSetContains(self, *e)) IntSetPut(&set, *e);
-    }
-    IntSetDtor(self);
-    *self = set;
-}
-void IntSetItCtor(IntSetIt* self, IntSet* set) {
-    assert(self);
-    self->set = set;
-    self->bucket_index = -1;
-}
-int IntSetItMove(IntSetIt* self) {
-    assert(self);
-    if(self->bucket_index < 0) IntSetListItCtor(&self->it, &self->set->buckets[self->bucket_index = 0]);
-    if(IntSetListItMove(&self->it)) return 1;
-    while(++self->bucket_index < self->set->bucket_count) {
-        IntSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
-        if(IntSetListItMove(&self->it)) return 1;
-    }
-    return 0;
-}
-int IntSetItGet(IntSetIt* self) {
-    assert(self);
-    return IntSetListItGet(&self->it);
-}
-int* IntSetItGetRef(IntSetIt* self) {
-    assert(self);
-    return IntSetListItGetRef(&self->it);
-}
-
-static void ValueTypeVectorAllocate(ValueTypeVector* self, size_t element_count) {
-    assert(self);
-    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 ListIntSetDtor(ListIntSet* self) {
-    ListIntSetNode* node;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        ListIntSetNode* this_node = node;
-        node = node->next_node;
-        _IntSetDtor(this_node->element);
-        free(this_node);
-    }
-}
-void ListIntSetCopy(ListIntSet* dst,ListIntSet* src) {
-    ListIntSetIt it;
-    assert(src);
-    assert(dst);
-    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;
-            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 ListIntSetIdentify(ListIntSet* self) {
-    ListIntSetNode* node;
-    size_t result = 0;
-    assert(self);
-    for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= _IntSetIdentify(node->element);
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-void ListIntSetPurge(ListIntSet* self) {
-    ListIntSetDtor(self);
-    ListIntSetCtor(self);
-}
-IntSet ListIntSetPeek(ListIntSet* self) {
-    IntSet result;
-    assert(self);
-    assert(!ListIntSetEmpty(self));
-    _IntSetCopy(result,self->head_node->element);
-    return result;
-}
-IntSet ListIntSetPop(ListIntSet* self) {
-    ListIntSetNode* node;
-    IntSet result;
-    assert(self);
-    assert(!ListIntSetEmpty(self));
-    node = self->head_node;
-    result = node->element;
-    self->head_node = self->head_node->next_node;
-    --self->node_count;
-    free(node);
-    return result;
-}
-void ListIntSetPush(ListIntSet* self, IntSet element) {
-    ListIntSetNode* node;
-    assert(self);
-    node = (ListIntSetNode*)malloc(sizeof(ListIntSetNode));
-    assert(node);
-    _IntSetCopy(node->element,element);
-    node->next_node = self->head_node;
-    self->head_node = node;
-    ++self->node_count;
-}
-int ListIntSetContains(ListIntSet* self, IntSet what) {
-    ListIntSetNode* node;
-    int found = 0;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        if(_IntSetEqual(node->element,what)) {
-            found = 1;
-            break;
-        }
-        node = node->next_node;
-    }
-    return found;
-}
-IntSet ListIntSetFind(ListIntSet* self, IntSet what) {
-    ListIntSetNode* node;
-    assert(self);
-    assert(ListIntSetContains(self, what));
-    node = self->head_node;
-    while(node) {
-        if(_IntSetEqual(node->element,what)) {
-            IntSet result;
-            _IntSetCopy(result,node->element);
-            return result;
-        }
-        node = node->next_node;
-    }
-    abort();
-}
-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(_IntSetEqual(node->element,with)) {
-            _IntSetDtor(node->element);
-            _IntSetCopy(node->element,with);
-            ++replaced;
-            if(count > 0 && replaced >= count) break;
-        }
-        node = node->next_node;
-    }
-    return replaced;
-}
-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(_IntSetEqual(node->element,what)) {
-            ListIntSetNode* 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;
-            _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 ListIntSetSize(ListIntSet* self) {
-    assert(self);
-    return self->node_count;
-}
-void ListIntSetItCtor(ListIntSetIt* self, ListIntSet* list) {
-    assert(self);
-    assert(list);
-    self->start = 1;
-    self->list = list;
-}
-int ListIntSetItMove(ListIntSetIt* 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;
-}
-IntSet ListIntSetItGet(ListIntSetIt* self) {
-    IntSet result;
-    assert(self);
-    assert(self->this_node);
-    _IntSetCopy(result,self->this_node->element);
-    return result;
-}
-IntSet* ListIntSetItGetRef(ListIntSetIt* self) {
-    assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
-}
-
-static void PIntVectorAllocate(PIntVector* self, size_t element_count) {
-    assert(self);
-    assert(element_count > 0);
-    self->element_count = element_count;
-    self->values = (int**)malloc(element_count*sizeof(int*));
-    assert(self->values);
-}
-void PIntVectorCtor(PIntVector* self,size_t element_count) {
-    size_t index;
-    assert(self);
-    PIntVectorAllocate(self, element_count);
-    for(index = 0; index < PIntVectorSize(self); ++index) {
-        ((self->values[index]) = IntNew());
-    }
-}
-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);
-    PIntVectorAllocate(dst, size = PIntVectorSize(src));
-    for(index = 0; index < size; ++index) {
-        ((dst->values[index]) = IntRef(src->values[index]));
-    }
-}
-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 PIntVectorIdentify(PIntVector* self) {
-    size_t index, result = 0;
-    assert(self);
-    for(index = 0; index < self->element_count; ++index) {
-        result ^= ((size_t)(*self->values[index]));
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-void PIntVectorResize(PIntVector* self, size_t new_element_count) {
-    size_t index, element_count, from, to;
-    assert(self);
-    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];
-        }
-        if(element_count > new_element_count) {
-            for(index = from; index < to; ++index) {
-                IntFree(self->values[index]);
-            }
-        } else {
-            for(index = from; index < to; ++index) {
-                ((values[index]) = IntNew());
-            }
-        }
-        free(self->values);
-        self->values = values;
-        self->element_count = new_element_count;
-    }
-}
-
-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 {
-        return +1;
-    }
-}
-void PIntVectorSort(PIntVector* self) {
-    typedef int (*F)(const void*, const void*);
-    assert(self);
-    qsort(self->values, PIntVectorSize(self), sizeof(int*), (F)PIntVectorComparator);
-}
-
-#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;
-}
-
-#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 ValueTypeMapSetListDtor(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListNode* node;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        ValueTypeMapSetListNode* this_node = node;
-        node = node->next_node;
-        ValueTypeMapEntryDtor(this_node->element);
-        free(this_node);
-    }
-}
-AUTOC_STATIC void ValueTypeMapSetListCopy(ValueTypeMapSetList* dst,ValueTypeMapSetList* src) {
-    ValueTypeMapSetListIt it;
-    assert(src);
-    assert(dst);
-    ValueTypeMapSetListCtor(dst);
-    ValueTypeMapSetListItCtor(&it, src);
-    while(ValueTypeMapSetListItMove(&it)) {
-        ValueTypeMapSetListPush(dst, *ValueTypeMapSetListItGetRef(&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)) {
-            int equal;
-            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 ValueTypeMapSetListIdentify(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListNode* node;
-    size_t result = 0;
-    assert(self);
-    for(node = self->head_node; node != NULL; node = node->next_node) {
-        result ^= ValueTypeMapEntryIdentify(node->element);
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-AUTOC_STATIC void ValueTypeMapSetListPurge(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListDtor(self);
-    ValueTypeMapSetListCtor(self);
-}
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPeek(ValueTypeMapSetList* self) {
-    ValueTypeMapEntry result;
-    assert(self);
-    assert(!ValueTypeMapSetListEmpty(self));
-    ValueTypeMapEntryCopy(result,self->head_node->element);
-    return result;
-}
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListPop(ValueTypeMapSetList* self) {
-    ValueTypeMapSetListNode* node;
-    ValueTypeMapEntry result;
-    assert(self);
-    assert(!ValueTypeMapSetListEmpty(self));
-    node = self->head_node;
-    result = node->element;
-    self->head_node = self->head_node->next_node;
-    --self->node_count;
-    free(node);
-    return result;
-}
-AUTOC_STATIC void ValueTypeMapSetListPush(ValueTypeMapSetList* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetListNode* node;
-    assert(self);
-    node = (ValueTypeMapSetListNode*)malloc(sizeof(ValueTypeMapSetListNode));
-    assert(node);
-    ValueTypeMapEntryCopy(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;
-    int found = 0;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        if(ValueTypeMapEntryEqual(node->element,what)) {
-            found = 1;
-            break;
-        }
-        node = node->next_node;
-    }
-    return found;
-}
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListFind(ValueTypeMapSetList* self, ValueTypeMapEntry what) {
-    ValueTypeMapSetListNode* node;
-    assert(self);
-    assert(ValueTypeMapSetListContains(self, what));
-    node = self->head_node;
-    while(node) {
-        if(ValueTypeMapEntryEqual(node->element,what)) {
-            ValueTypeMapEntry result;
-            ValueTypeMapEntryCopy(result,node->element);
-            return result;
-        }
-        node = node->next_node;
-    }
-    abort();
-}
-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(ValueTypeMapEntryEqual(node->element,with)) {
-            ValueTypeMapEntryDtor(node->element);
-            ValueTypeMapEntryCopy(node->element,with);
-            ++replaced;
-            if(count > 0 && replaced >= count) break;
-        }
-        node = node->next_node;
-    }
-    return replaced;
-}
-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(ValueTypeMapEntryEqual(node->element,what)) {
-            ValueTypeMapSetListNode* 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;
-            ValueTypeMapEntryDtor(node->element);
-            free(node);
-            node = this_node;
-            if(count > 0 && removed >= count) break;
-        } else {
-            prev_node = node;
-            node = node->next_node;
-        }
-    }
-    return removed;
-}
-AUTOC_STATIC size_t ValueTypeMapSetListSize(ValueTypeMapSetList* self) {
-    assert(self);
-    return self->node_count;
-}
-AUTOC_STATIC void ValueTypeMapSetListItCtor(ValueTypeMapSetListIt* self, ValueTypeMapSetList* list) {
-    assert(self);
-    assert(list);
-    self->start = 1;
-    self->list = list;
-}
-AUTOC_STATIC int ValueTypeMapSetListItMove(ValueTypeMapSetListIt* 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;
-}
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetListItGet(ValueTypeMapSetListIt* self) {
-    ValueTypeMapEntry result;
-    assert(self);
-    assert(self->this_node);
-    ValueTypeMapEntryCopy(result,self->this_node->element);
-    return result;
-}
-AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetListItGetRef(ValueTypeMapSetListIt* self) {
-    assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
-}
-
-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);
-    assert(self->max_fill > 0);
-    assert(self->min_fill < self->max_fill);
-    assert(self->min_bucket_count > 0);
-    if(self->buckets) {
-        if(self->min_size < self->size && self->size < self->max_size) return;
-        fill = (size_t)((float)self->size/self->bucket_count*100);
-        if(fill > self->max_fill) {
-            bucket_count = (size_t)((float)self->bucket_count/100*self->capacity_multiplier);
-        } else if(fill < self->min_fill && self->bucket_count > self->min_bucket_count) {
-            bucket_count = (size_t)((float)self->bucket_count/self->capacity_multiplier*100);
-            if(bucket_count < self->min_bucket_count) bucket_count = self->min_bucket_count;
-        } else
-            return;
-        size = self->size;
-        self->min_size = (size_t)((float)self->min_fill/100*size);
-        self->max_size = (size_t)((float)self->max_fill/100*size);
-    } else {
-        bucket_count = self->min_bucket_count;
-        size = 0;
-    }
-    buckets = (ValueTypeMapSetList*)malloc(bucket_count*sizeof(ValueTypeMapSetList));
-    assert(buckets);
-    for(index = 0; index < bucket_count; ++index) {
-        ValueTypeMapSetListCtor(&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);
-        }
-        ValueTypeMapSetDtor(self);
-    }
-    self->buckets = buckets;
-    self->bucket_count = bucket_count;
-    self->size = size;
-}
-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;
-}
-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) {
-        ValueTypeMapSetListDtor(&self->buckets[i]);
-    }
-    free(self->buckets);
-}
-AUTOC_STATIC void ValueTypeMapSetCopy(ValueTypeMapSet* dst,ValueTypeMapSet* src) {
-    ValueTypeMapSetIt it;
-    assert(src);
-    assert(dst);
-    ValueTypeMapSetCtor(dst);
-    ValueTypeMapSetItCtor(&it, src);
-    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetPut(dst, *ValueTypeMapSetItGetRef(&it));
-}
-AUTOC_STATIC int ValueTypeMapSetEqual(ValueTypeMapSet* lt,ValueTypeMapSet* rt) {
-    assert(lt);
-    assert(rt);
-    return ValueTypeMapSetSize(lt) == ValueTypeMapSetSize(rt) && ValueTypeMapSetContainsAllOf(lt, rt) && ValueTypeMapSetContainsAllOf(rt, lt);
-}
-AUTOC_STATIC size_t ValueTypeMapSetIdentify(ValueTypeMapSet* self) {
-    ValueTypeMapSetIt it;
-    size_t result = 0;
-    assert(self);
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        result ^= ValueTypeMapEntryIdentify(*e);
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-AUTOC_STATIC void ValueTypeMapSetPurge(ValueTypeMapSet* self) {
-    assert(self);
-    ValueTypeMapSetDtor(self);
-    self->buckets = NULL;
-    ValueTypeMapSetRehash(self);
-}
-AUTOC_STATIC int ValueTypeMapSetContains(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    assert(self);
-    return ValueTypeMapSetListContains(&self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count], element);
-}
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetGet(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapEntry result;
-    assert(self);
-    assert(ValueTypeMapSetContains(self, element));
-    result = ValueTypeMapSetListFind(&self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count], element);
-    return result;
-}
-AUTOC_STATIC size_t ValueTypeMapSetSize(ValueTypeMapSet* self) {
-    assert(self);
-    return self->size;
-}
-AUTOC_STATIC int ValueTypeMapSetPut(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
-    if(!ValueTypeMapSetListContains(bucket, element)) {
-        ValueTypeMapSetListPush(bucket, element);
-        ++self->size;
-        ValueTypeMapSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-AUTOC_STATIC int ValueTypeMapSetReplace(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
-    return ValueTypeMapSetListReplace(bucket, element);
-}
-AUTOC_STATIC int ValueTypeMapSetRemove(ValueTypeMapSet* self, ValueTypeMapEntry element) {
-    ValueTypeMapSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[ValueTypeMapEntryIdentify(element) % self->bucket_count];
-    if(ValueTypeMapSetListRemove(bucket, element)) {
-        --self->size;
-        ValueTypeMapSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-AUTOC_STATIC void ValueTypeMapSetExclude(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    assert(self);
-    assert(other);
-    ValueTypeMapSetItCtor(&it, other);
-    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetRemove(self, *ValueTypeMapSetItGetRef(&it));
-}
-AUTOC_STATIC void ValueTypeMapSetInclude(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    assert(self);
-    assert(other);
-    ValueTypeMapSetItCtor(&it, other);
-    while(ValueTypeMapSetItMove(&it)) ValueTypeMapSetPut(self, *ValueTypeMapSetItGetRef(&it));
-}
-AUTOC_STATIC void ValueTypeMapSetRetain(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    ValueTypeMapSet set;
-    assert(self);
-    assert(other);
-    ValueTypeMapSetCtor(&set);
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        if(ValueTypeMapSetContains(other, *e)) ValueTypeMapSetPut(&set, *e);
-    }
-    ValueTypeMapSetDtor(self);
-    *self = set;
-}
-AUTOC_STATIC void ValueTypeMapSetInvert(ValueTypeMapSet* self, ValueTypeMapSet* other) {
-    ValueTypeMapSetIt it;
-    ValueTypeMapSet set;
-    assert(self);
-    assert(other);
-    ValueTypeMapSetCtor(&set);
-    ValueTypeMapSetItCtor(&it, self);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        if(!ValueTypeMapSetContains(other, *e)) ValueTypeMapSetPut(&set, *e);
-    }
-    ValueTypeMapSetItCtor(&it, other);
-    while(ValueTypeMapSetItMove(&it)) {
-        ValueTypeMapEntry* e = ValueTypeMapSetItGetRef(&it);
-        if(!ValueTypeMapSetContains(self, *e)) ValueTypeMapSetPut(&set, *e);
-    }
-    ValueTypeMapSetDtor(self);
-    *self = set;
-}
-AUTOC_STATIC void ValueTypeMapSetItCtor(ValueTypeMapSetIt* self, ValueTypeMapSet* set) {
-    assert(self);
-    self->set = set;
-    self->bucket_index = -1;
-}
-AUTOC_STATIC int ValueTypeMapSetItMove(ValueTypeMapSetIt* self) {
-    assert(self);
-    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) {
-        ValueTypeMapSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
-        if(ValueTypeMapSetListItMove(&self->it)) return 1;
-    }
-    return 0;
-}
-AUTOC_STATIC ValueTypeMapEntry ValueTypeMapSetItGet(ValueTypeMapSetIt* self) {
-    assert(self);
-    return ValueTypeMapSetListItGet(&self->it);
-}
-AUTOC_STATIC ValueTypeMapEntry* ValueTypeMapSetItGetRef(ValueTypeMapSetIt* self) {
-    assert(self);
-    return ValueTypeMapSetListItGetRef(&self->it);
-}
-
-void ValueTypeMapCtor(ValueTypeMap* self) {
-    assert(self);
-    ValueTypeMapSetCtor(&self->entries);
-}
-void ValueTypeMapDtor(ValueTypeMap* self) {
-    assert(self);
-    ValueTypeMapSetDtor(&self->entries);
-}
-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;
-}
-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);
-    }
-}
-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
-
-#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 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 ValueTypeSetListDtor(ValueTypeSetList* self) {
-    ValueTypeSetListNode* node;
-    assert(self);
-    node = self->head_node;
-    while(node) {
-        ValueTypeSetListNode* this_node = node;
-        node = node->next_node;
-        ValueTypeDtor(this_node->element);
-        free(this_node);
-    }
-}
-AUTOC_STATIC void ValueTypeSetListCopy(ValueTypeSetList* dst,ValueTypeSetList* src) {
-    ValueTypeSetListIt it;
-    assert(src);
-    assert(dst);
-    ValueTypeSetListCtor(dst);
-    ValueTypeSetListItCtor(&it, src);
-    while(ValueTypeSetListItMove(&it)) {
-        ValueTypeSetListPush(dst, *ValueTypeSetListItGetRef(&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)) {
-            int equal;
-            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 ValueTypeSetListIdentify(ValueTypeSetList* self) {
-    ValueTypeSetListNode* 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;
-}
-AUTOC_STATIC void ValueTypeSetListPurge(ValueTypeSetList* self) {
-    ValueTypeSetListDtor(self);
-    ValueTypeSetListCtor(self);
-}
-AUTOC_STATIC ValueType ValueTypeSetListPeek(ValueTypeSetList* self) {
-    ValueType result;
-    assert(self);
-    assert(!ValueTypeSetListEmpty(self));
-    ValueTypeCopy(result,self->head_node->element);
-    return result;
-}
-AUTOC_STATIC ValueType ValueTypeSetListPop(ValueTypeSetList* self) {
-    ValueTypeSetListNode* node;
-    ValueType result;
-    assert(self);
-    assert(!ValueTypeSetListEmpty(self));
-    node = self->head_node;
-    result = node->element;
-    self->head_node = self->head_node->next_node;
-    --self->node_count;
-    free(node);
-    return result;
-}
-AUTOC_STATIC void ValueTypeSetListPush(ValueTypeSetList* self, ValueType element) {
-    ValueTypeSetListNode* node;
-    assert(self);
-    node = (ValueTypeSetListNode*)malloc(sizeof(ValueTypeSetListNode));
-    assert(node);
-    ValueTypeCopy(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;
-    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;
-}
-AUTOC_STATIC ValueType ValueTypeSetListFind(ValueTypeSetList* self, ValueType what) {
-    ValueTypeSetListNode* node;
-    assert(self);
-    assert(ValueTypeSetListContains(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();
-}
-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(ValueTypeEqual(node->element,with)) {
-            ValueTypeDtor(node->element);
-            ValueTypeCopy(node->element,with);
-            ++replaced;
-            if(count > 0 && replaced >= count) break;
-        }
-        node = node->next_node;
-    }
-    return replaced;
-}
-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(ValueTypeEqual(node->element,what)) {
-            ValueTypeSetListNode* 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;
-}
-AUTOC_STATIC size_t ValueTypeSetListSize(ValueTypeSetList* self) {
-    assert(self);
-    return self->node_count;
-}
-AUTOC_STATIC void ValueTypeSetListItCtor(ValueTypeSetListIt* self, ValueTypeSetList* list) {
-    assert(self);
-    assert(list);
-    self->start = 1;
-    self->list = list;
-}
-AUTOC_STATIC int ValueTypeSetListItMove(ValueTypeSetListIt* 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;
-}
-AUTOC_STATIC ValueType ValueTypeSetListItGet(ValueTypeSetListIt* self) {
-    ValueType result;
-    assert(self);
-    assert(self->this_node);
-    ValueTypeCopy(result,self->this_node->element);
-    return result;
-}
-AUTOC_STATIC ValueType* ValueTypeSetListItGetRef(ValueTypeSetListIt* self) {
-    assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
-}
-
-ValueType* ValueTypeSetItGetRef(ValueTypeSetIt*);
-static void ValueTypeSetRehash(ValueTypeSet* self) {
-    ValueTypeSetList* buckets;
-    size_t index, bucket_count, size, fill;
-    assert(self);
-    assert(self->min_fill > 0);
-    assert(self->max_fill > 0);
-    assert(self->min_fill < self->max_fill);
-    assert(self->min_bucket_count > 0);
-    if(self->buckets) {
-        if(self->min_size < self->size && self->size < self->max_size) return;
-        fill = (size_t)((float)self->size/self->bucket_count*100);
-        if(fill > self->max_fill) {
-            bucket_count = (size_t)((float)self->bucket_count/100*self->capacity_multiplier);
-        } else if(fill < self->min_fill && self->bucket_count > self->min_bucket_count) {
-            bucket_count = (size_t)((float)self->bucket_count/self->capacity_multiplier*100);
-            if(bucket_count < self->min_bucket_count) bucket_count = self->min_bucket_count;
-        } else
-            return;
-        size = self->size;
-        self->min_size = (size_t)((float)self->min_fill/100*size);
-        self->max_size = (size_t)((float)self->max_fill/100*size);
-    } else {
-        bucket_count = self->min_bucket_count;
-        size = 0;
-    }
-    buckets = (ValueTypeSetList*)malloc(bucket_count*sizeof(ValueTypeSetList));
-    assert(buckets);
-    for(index = 0; index < bucket_count; ++index) {
-        ValueTypeSetListCtor(&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);
-        }
-        ValueTypeSetDtor(self);
-    }
-    self->buckets = buckets;
-    self->bucket_count = bucket_count;
-    self->size = size;
-}
-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;
-    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);
-}
-void ValueTypeSetDtor(ValueTypeSet* self) {
-    size_t i;
-    assert(self);
-    for(i = 0; i < self->bucket_count; ++i) {
-        ValueTypeSetListDtor(&self->buckets[i]);
-    }
-    free(self->buckets);
-}
-void ValueTypeSetCopy(ValueTypeSet* dst,ValueTypeSet* src) {
-    ValueTypeSetIt it;
-    assert(src);
-    assert(dst);
-    ValueTypeSetCtor(dst);
-    ValueTypeSetItCtor(&it, src);
-    while(ValueTypeSetItMove(&it)) ValueTypeSetPut(dst, *ValueTypeSetItGetRef(&it));
-}
-int ValueTypeSetEqual(ValueTypeSet* lt,ValueTypeSet* rt) {
-    assert(lt);
-    assert(rt);
-    return ValueTypeSetSize(lt) == ValueTypeSetSize(rt) && ValueTypeSetContainsAllOf(lt, rt) && ValueTypeSetContainsAllOf(rt, lt);
-}
-size_t ValueTypeSetIdentify(ValueTypeSet* self) {
-    ValueTypeSetIt it;
-    size_t result = 0;
-    assert(self);
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        result ^= ValueTypeIdentify(*e);
-        result = AUTOC_RCYCLE(result);
-    }
-    return result;
-}
-void ValueTypeSetPurge(ValueTypeSet* self) {
-    assert(self);
-    ValueTypeSetDtor(self);
-    self->buckets = NULL;
-    ValueTypeSetRehash(self);
-}
-int ValueTypeSetContains(ValueTypeSet* self, ValueType element) {
-    assert(self);
-    return ValueTypeSetListContains(&self->buckets[ValueTypeIdentify(element) % self->bucket_count], element);
-}
-ValueType ValueTypeSetGet(ValueTypeSet* self, ValueType element) {
-    ValueType result;
-    assert(self);
-    assert(ValueTypeSetContains(self, element));
-    result = ValueTypeSetListFind(&self->buckets[ValueTypeIdentify(element) % self->bucket_count], element);
-    return result;
-}
-size_t ValueTypeSetSize(ValueTypeSet* self) {
-    assert(self);
-    return self->size;
-}
-int ValueTypeSetPut(ValueTypeSet* self, ValueType element) {
-    ValueTypeSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
-    if(!ValueTypeSetListContains(bucket, element)) {
-        ValueTypeSetListPush(bucket, element);
-        ++self->size;
-        ValueTypeSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-int ValueTypeSetReplace(ValueTypeSet* self, ValueType element) {
-    ValueTypeSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
-    return ValueTypeSetListReplace(bucket, element);
-}
-int ValueTypeSetRemove(ValueTypeSet* self, ValueType element) {
-    ValueTypeSetList* bucket;
-    assert(self);
-    bucket = &self->buckets[ValueTypeIdentify(element) % self->bucket_count];
-    if(ValueTypeSetListRemove(bucket, element)) {
-        --self->size;
-        ValueTypeSetRehash(self);
-        return 1;
-    }
-    return 0;
-}
-void ValueTypeSetExclude(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    assert(self);
-    assert(other);
-    ValueTypeSetItCtor(&it, other);
-    while(ValueTypeSetItMove(&it)) ValueTypeSetRemove(self, *ValueTypeSetItGetRef(&it));
-}
-void ValueTypeSetInclude(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    assert(self);
-    assert(other);
-    ValueTypeSetItCtor(&it, other);
-    while(ValueTypeSetItMove(&it)) ValueTypeSetPut(self, *ValueTypeSetItGetRef(&it));
-}
-void ValueTypeSetRetain(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    ValueTypeSet set;
-    assert(self);
-    assert(other);
-    ValueTypeSetCtor(&set);
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        if(ValueTypeSetContains(other, *e)) ValueTypeSetPut(&set, *e);
-    }
-    ValueTypeSetDtor(self);
-    *self = set;
-}
-void ValueTypeSetInvert(ValueTypeSet* self, ValueTypeSet* other) {
-    ValueTypeSetIt it;
-    ValueTypeSet set;
-    assert(self);
-    assert(other);
-    ValueTypeSetCtor(&set);
-    ValueTypeSetItCtor(&it, self);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        if(!ValueTypeSetContains(other, *e)) ValueTypeSetPut(&set, *e);
-    }
-    ValueTypeSetItCtor(&it, other);
-    while(ValueTypeSetItMove(&it)) {
-        ValueType* e = ValueTypeSetItGetRef(&it);
-        if(!ValueTypeSetContains(self, *e)) ValueTypeSetPut(&set, *e);
-    }
-    ValueTypeSetDtor(self);
-    *self = set;
-}
-void ValueTypeSetItCtor(ValueTypeSetIt* self, ValueTypeSet* set) {
-    assert(self);
-    self->set = set;
-    self->bucket_index = -1;
-}
-int ValueTypeSetItMove(ValueTypeSetIt* self) {
-    assert(self);
-    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) {
-        ValueTypeSetListItCtor(&self->it, &self->set->buckets[self->bucket_index]);
-        if(ValueTypeSetListItMove(&self->it)) return 1;
-    }
-    return 0;
-}
-ValueType ValueTypeSetItGet(ValueTypeSetIt* self) {
-    assert(self);
-    return ValueTypeSetListItGet(&self->it);
-}
-ValueType* ValueTypeSetItGetRef(ValueTypeSetIt* self) {
-    assert(self);
-    return ValueTypeSetListItGetRef(&self->it);
-}
-
-#define AUTOC_COUNTER(p) (*(size_t*)((char*)(p) + sizeof(ValueType)))
-ValueType* ValueTypeNew() {
-    ValueType* self = (ValueType*)malloc(sizeof(ValueType) + sizeof(size_t));
-    assert(self);
-    ValueTypeCtor(*self);
-    AUTOC_COUNTER(self) = 1;
-    return self;
-}
-ValueType* ValueTypeRef(ValueType* self) {
-    assert(self);
-    ++AUTOC_COUNTER(self);
-    return self;
-}
-void ValueTypeFree(ValueType* self) {
-    assert(self);
-    if(--AUTOC_COUNTER(self) == 0) {
-        ValueTypeDtor(*self);
-        free(self);
-    }
-}
-#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);
-    ValueTypeListCtor(dst);
-    ValueTypeListItCtor(&it, src);
-    while(ValueTypeListItMove(&it)) {
-        ValueTypeListPush(dst, *ValueTypeListItGetRef(&it));
-    }
-}
-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;
-        }
-        return 1;
-    } else
-        return 0;
-}
-size_t ValueTypeListIdentify(ValueTypeList* self) {
-    ValueTypeListNode* 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 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;
-    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* 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;
-    assert(self);
-    assert(!ValueTypeQueueEmpty(self));
-    ValueTypeCopy(result,self->head_node->element);
-    return result;
-}
-ValueType ValueTypeQueuePeekTail(ValueTypeQueue* self) {
-    ValueType result;
-    assert(self);
-    assert(!ValueTypeQueueEmpty(self));
-    ValueTypeCopy(result,self->tail_node->element);
-    return result;
-}
-ValueType ValueTypeQueuePopHead(ValueTypeQueue* self) {
-    ValueTypeQueueNode* node;
-    ValueType result;
-    assert(self);
-    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;
-}
-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);
-    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;
-}
-size_t ValueTypeQueueSize(ValueTypeQueue* self) {
-    assert(self);
-    return self->node_count;
-}
-void ValueTypeQueueItCtorEx(ValueTypeQueueIt* self, ValueTypeQueue* queue, int forward) {
-    assert(self);
-    assert(queue);
-    self->start = 1;
-    self->queue = queue;
-    self->forward = forward;
-}
-int ValueTypeQueueItMove(ValueTypeQueueIt* self) {
-    assert(self);
-    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 ValueTypeQueueItGet(ValueTypeQueueIt* self) {
-    ValueType result;
-    assert(self);
-    assert(self->this_node);
-    ValueTypeCopy(result,self->this_node->element);
-    return result;
-}
-ValueType* ValueTypeQueueItGetRef(ValueTypeQueueIt* self) {
-    assert(self);
-    assert(self->this_node);
-    return &self->this_node->element;
-}
-
-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*));
-    assert(self->values);
-}
-void PVectorValueCtor(PVectorValue* self,size_t element_count) {
-    size_t index;
-    assert(self);
-    PVectorValueAllocate(self, element_count);
-    for(index = 0; index < PVectorValueSize(self); ++index) {
-        ((self->values[index]) = ValueTypeNew());
-    }
-}
-void PVectorValueDtor(PVectorValue* self) {
-    size_t index;
-    assert(self);
-    for(index = 0; index < PVectorValueSize(self); ++index) {
-        ValueTypeFree(self->values[index]);
-    }
-    free(self->values);
-}
-void PVectorValueCopy(PVectorValue* dst,PVectorValue* src) {
-    size_t index, size;
-    assert(src);
-    assert(dst);
-    PVectorValueAllocate(dst, size = PVectorValueSize(src));
-    for(index = 0; index < size; ++index) {
-        ((dst->values[index]) = ValueTypeRef(src->values[index]));
-    }
-}
-int PVectorValueEqual(PVectorValue* lt,PVectorValue* rt) {
-    size_t index, size;
-    assert(lt);
-    assert(rt);
-    if(PVectorValueSize(lt) == (size = PVectorValueSize(rt))) {
-        for(index = 0; index < size; ++index) {
-            if(!ValueTypeEqual(*lt->values[index],*rt->values[index])) return 0;
-        }
-        return 1;
-    } else
-        return 0;
-}
-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 = 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);
-        for(index = 0; index < from; ++index) {
-            values[index] = self->values[index];
-        }
-        if(element_count > new_element_count) {
-            for(index = from; index < to; ++index) {
-                ValueTypeFree(self->values[index]);
-            }
-        } else {
-            for(index = from; index < to; ++index) {
-                ((values[index]) = ValueTypeNew());
-            }
-        }
-        free(self->values);
-        self->values = values;
-        self->element_count = new_element_count;
-    }
-}
-
-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);
-    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;
-}
-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 {
-        self->this_node = self->this_node ? self->this_node->next_node : NULL;
-    }
-    return self->this_node != NULL;
-}
-PVectorValue* ListPVectorValueItGet(ListPVectorValueIt* self) {
-    PVectorValue* result;
-    assert(self);
-    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;
-}