autoc 0.8

data/test/test_auto.c

@@ -0,0 +1,4042 @@
+
+        /* AUTOMATICALLY GENERATED SOURCE FILE. DO NOT MODIFY. */
+        #include "test_auto.h"
+      
+      static void IntSetListCtor(IntSetList*);
+      static void IntSetListDtor(IntSetList*);
+      static void IntSetListPurge(IntSetList*);
+      static IntSetList* IntSetListNew(void);
+      static void IntSetListDestroy(IntSetList*);
+      static IntSetList* IntSetListAssign(IntSetList*);
+      static int IntSetListGet(IntSetList*);
+      static void IntSetListAdd(IntSetList*, int);
+      static void IntSetListChop(IntSetList*);
+      static int IntSetListContains(IntSetList*, int);
+      static int IntSetListFind(IntSetList*, int);
+      static int IntSetListReplace(IntSetList*, int, int);
+      static int IntSetListReplaceAll(IntSetList*, int, int);
+      static int IntSetListRemove(IntSetList*, int);
+      static int IntSetListRemoveAll(IntSetList*, int);
+      static size_t IntSetListSize(IntSetList*);
+      static int IntSetListEmpty(IntSetList*);
+      static void IntSetListItCtor(IntSetListIt*, IntSetList*);
+      static int IntSetListItHasNext(IntSetListIt*);
+      static int IntSetListItNext(IntSetListIt*);
+    
+      static void IntSetListCtor(IntSetList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+      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);
+        }
+      }
+      static IntSetList* IntSetListNew(void) {
+        IntSetList* self = (IntSetList*)malloc(sizeof(IntSetList)); assert(self);
+        IntSetListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void IntSetListDestroy(IntSetList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          IntSetListDtor(self);
+          free(self);
+        }
+      }
+      static IntSetList* IntSetListAssign(IntSetList* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void IntSetListPurge(IntSetList* self) {
+        IntSetListDtor(self);
+        IntSetListCtor(self);
+      }
+      static int IntSetListGet(IntSetList* self) {
+        assert(self);
+        assert(!IntSetListEmpty(self));
+        return self->head_node->element;
+      }
+      static void IntSetListChop(IntSetList* self) {
+        IntSetListNode* node;
+        assert(self);
+        assert(!IntSetListEmpty(self));
+        node = self->head_node;
+        ;
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+      static void IntSetListAdd(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;
+      }
+      static int IntSetListContains(IntSetList* self, int what) {
+        IntSetListNode* node;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        while(node) {
+          if((node->element==what)) {
+            ;
+            return 1;
+          }
+          node = node->next_node;
+        }
+        ;
+        return 0;
+      }
+      static int IntSetListFind(IntSetList* self, int what) {
+        IntSetListNode* node;
+        assert(self);
+        what = (what);
+        assert(IntSetListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if((node->element==what)) {
+            ;
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+      static int IntSetListReplace(IntSetList* self, int what, int with) {
+        IntSetListNode* node;
+        assert(self);
+        what = (what);
+        with = (with);
+        node = self->head_node;
+        while(node) {
+          if((node->element==what)) {
+            ;
+            node->element = (with);
+            ;
+            ;
+            return 1;
+          }
+          node = node->next_node;
+        }
+        ;
+        ;
+        return 0;
+      }
+      static int IntSetListReplaceAll(IntSetList* self, int what, int with) {
+        IntSetListNode* node;
+        int count = 0;
+        assert(self);
+        what = (what);
+        with = (with);
+        node = self->head_node;
+        while(node) {
+          if((node->element==what)) {
+            ;
+            node->element = (with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        ;
+        ;
+        return count;
+      }
+      static int IntSetListRemove(IntSetList* self, int what) {
+        IntSetListNode* node;
+        IntSetListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if((node->element==what)) {
+            ;
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        ;
+        return found;
+      }
+      static int IntSetListRemoveAll(IntSetList* self, int what) {
+        IntSetListNode* node;
+        IntSetListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if((node->element==what)) {
+            ;
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        ;
+        return count;
+      }
+      static size_t IntSetListSize(IntSetList* self) {
+        assert(self);
+        return self->node_count;
+      }
+      static int IntSetListEmpty(IntSetList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+      static void IntSetListItCtor(IntSetListIt* self, IntSetList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+      static int IntSetListItHasNext(IntSetListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+      static int IntSetListItNext(IntSetListIt* self) {
+        IntSetListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+       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);
+      }
+       IntSet* IntSetNew(void) {
+        IntSet* self = (IntSet*)malloc(sizeof(IntSet)); assert(self);
+        IntSetCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void IntSetDestroy(IntSet* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          IntSetDtor(self);
+          free(self);
+        }
+      }
+       IntSet* IntSetAssign(IntSet* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void IntSetPurge(IntSet* self) {
+        assert(self);
+        IntSetDtor(self);
+        self->buckets = NULL;
+        IntSetRehash(self);
+      }
+       void IntSetRehash(IntSet* self) {
+        IntSetList* buckets;
+        size_t i, 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(i = 0; i < bucket_count; ++i) {
+          IntSetListCtor(&buckets[i]);
+        }
+        if(self->buckets) {
+          IntSetIt it;
+          IntSetItCtor(&it, self);
+          while(IntSetItHasNext(&it)) {
+            IntSetList* bucket;
+            int element = IntSetItNext(&it);
+            bucket = &buckets[((size_t)(element)) % bucket_count];
+            IntSetListAdd(bucket, element);
+          }
+          IntSetDtor(self);
+        }
+        self->buckets = buckets;
+        self->bucket_count = bucket_count;
+        self->size = size;
+      }
+       int IntSetContains(IntSet* self, int element) {
+        int result;
+        assert(self);
+        element = (element);
+        result = IntSetListContains(&self->buckets[((size_t)(element)) % self->bucket_count], element);
+        ;
+        return result;
+      }
+       int IntSetGet(IntSet* self, int element) {
+        int result;
+        assert(self);
+        element = (element);
+        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 IntSetEmpty(IntSet* self) {
+        assert(self);
+        return !self->size;
+      }
+       int IntSetPut(IntSet* self, int element) {
+        int contained = 1;
+        IntSetList* bucket;
+        assert(self);
+        element = (element);
+        bucket = &self->buckets[((size_t)(element)) % self->bucket_count];
+        if(!IntSetListContains(bucket, element)) {
+          IntSetListAdd(bucket, element);
+          ++self->size;
+          contained = 0;
+          IntSetRehash(self);
+        }
+        ;
+        return contained;
+      }
+       void IntSetReplace(IntSet* self, int element) {
+        IntSetList* bucket;
+        assert(self);
+        element = (element);
+        bucket = &self->buckets[((size_t)(element)) % self->bucket_count];
+        if(!IntSetListReplace(bucket, element, element)) {
+          IntSetListAdd(bucket, element);
+          ++self->size;
+          IntSetRehash(self);
+        }
+        ;
+      }
+       int IntSetRemove(IntSet* self, int what) {
+        int removed = 0;
+        IntSetList* bucket;
+        assert(self);
+        what = (what);
+        bucket = &self->buckets[((size_t)(what)) % self->bucket_count];
+        if(IntSetListRemove(bucket, what)) {
+          --self->size;
+          removed = 1;
+          IntSetRehash(self);
+        }
+        ;
+        return removed;
+      }
+       void IntSetNot(IntSet* self, IntSet* other) {
+        IntSetIt it;
+        assert(self);
+        assert(other);
+        IntSetItCtor(&it, other);
+        while(IntSetItHasNext(&it)) {
+          IntSetRemove(self, IntSetItNext(&it));
+        }
+        IntSetRehash(self);
+      }
+       void IntSetOr(IntSet* self, IntSet* other) {
+        IntSetIt it;
+        assert(self);
+        assert(other);
+        IntSetItCtor(&it, other);
+        while(IntSetItHasNext(&it)) {
+          IntSetPut(self, IntSetItNext(&it));
+        }
+        IntSetRehash(self);
+      }
+       void IntSetAnd(IntSet* self, IntSet* other) {
+        IntSetIt it;
+        IntSet set;
+        assert(self);
+        assert(other);
+        IntSetCtor(&set);
+        IntSetItCtor(&it, self);
+        while(IntSetItHasNext(&it)) {
+          int element = IntSetItNext(&it);
+          if(IntSetContains(other, element)) IntSetPut(&set, element);
+        }
+        IntSetItCtor(&it, other);
+        while(IntSetItHasNext(&it)) {
+          int element = IntSetItNext(&it);
+          if(IntSetContains(self, element)) IntSetPut(&set, element);
+        }
+        IntSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        IntSetRehash(self);
+        /*IntSetDtor(&set);*/
+      }
+       void IntSetXor(IntSet* self, IntSet* other) {
+        IntSetIt it;
+        IntSet set;
+        assert(self);
+        assert(other);
+        IntSetCtor(&set);
+        IntSetItCtor(&it, self);
+        while(IntSetItHasNext(&it)) {
+          int element = IntSetItNext(&it);
+          if(!IntSetContains(other, element)) IntSetPut(&set, element);
+        }
+        IntSetItCtor(&it, other);
+        while(IntSetItHasNext(&it)) {
+          int element = IntSetItNext(&it);
+          if(!IntSetContains(self, element)) IntSetPut(&set, element);
+        }
+        IntSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        IntSetRehash(self);
+        /*IntSetDtor(&set);*/
+      }
+       void IntSetItCtor(IntSetIt* self, IntSet* set) {
+        assert(self);
+        self->set = set;
+        self->bucket_index = 0;
+        IntSetListItCtor(&self->it, &set->buckets[0]);
+      }
+       int IntSetItHasNext(IntSetIt* self) {
+        assert(self);
+        if(IntSetListItHasNext(&self->it)) {
+          return 1;
+        } else {
+          size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!IntSetListEmpty(&self->set->buckets[i])) {
+              return 1;
+            }
+          }
+          return 0;
+        }
+      }
+       int IntSetItNext(IntSetIt* self) {
+        assert(self);
+        assert(IntSetItHasNext(self));
+          if(IntSetListItHasNext(&self->it)) {
+            return IntSetListItNext(&self->it);
+          } else {
+            size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!IntSetListEmpty(&self->set->buckets[i])) {
+            IntSetListItCtor(&self->it, &self->set->buckets[i]);
+              self->bucket_index = i;
+              return IntSetListItNext(&self->it);
+            }
+          }
+          abort();
+        }
+      }
+    
+      static void PCharSetListCtor(PCharSetList*);
+      static void PCharSetListDtor(PCharSetList*);
+      static void PCharSetListPurge(PCharSetList*);
+      static PCharSetList* PCharSetListNew(void);
+      static void PCharSetListDestroy(PCharSetList*);
+      static PCharSetList* PCharSetListAssign(PCharSetList*);
+      static const char* PCharSetListGet(PCharSetList*);
+      static void PCharSetListAdd(PCharSetList*, const char*);
+      static void PCharSetListChop(PCharSetList*);
+      static int PCharSetListContains(PCharSetList*, const char*);
+      static const char* PCharSetListFind(PCharSetList*, const char*);
+      static int PCharSetListReplace(PCharSetList*, const char*, const char*);
+      static int PCharSetListReplaceAll(PCharSetList*, const char*, const char*);
+      static int PCharSetListRemove(PCharSetList*, const char*);
+      static int PCharSetListRemoveAll(PCharSetList*, const char*);
+      static size_t PCharSetListSize(PCharSetList*);
+      static int PCharSetListEmpty(PCharSetList*);
+      static void PCharSetListItCtor(PCharSetListIt*, PCharSetList*);
+      static int PCharSetListItHasNext(PCharSetListIt*);
+      static const char* PCharSetListItNext(PCharSetListIt*);
+    
+      static void PCharSetListCtor(PCharSetList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+      static void PCharSetListDtor(PCharSetList* self) {
+        PCharSetListNode* node;
+        assert(self);
+        ;
+        node = self->head_node;
+        while(node) {
+          PCharSetListNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+      static PCharSetList* PCharSetListNew(void) {
+        PCharSetList* self = (PCharSetList*)malloc(sizeof(PCharSetList)); assert(self);
+        PCharSetListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void PCharSetListDestroy(PCharSetList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PCharSetListDtor(self);
+          free(self);
+        }
+      }
+      static PCharSetList* PCharSetListAssign(PCharSetList* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void PCharSetListPurge(PCharSetList* self) {
+        PCharSetListDtor(self);
+        PCharSetListCtor(self);
+      }
+      static const char* PCharSetListGet(PCharSetList* self) {
+        assert(self);
+        assert(!PCharSetListEmpty(self));
+        return self->head_node->element;
+      }
+      static void PCharSetListChop(PCharSetList* self) {
+        PCharSetListNode* node;
+        assert(self);
+        assert(!PCharSetListEmpty(self));
+        node = self->head_node;
+        ;
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+      static void PCharSetListAdd(PCharSetList* self, const char* element) {
+        PCharSetListNode* node;
+        assert(self);
+        node = (PCharSetListNode*)malloc(sizeof(PCharSetListNode)); assert(node);
+        node->element = (element);
+        node->next_node = self->head_node;
+        self->head_node = node;
+        ++self->node_count;
+      }
+      static int PCharSetListContains(PCharSetList* self, const char* what) {
+        PCharSetListNode* node;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            return 1;
+          }
+          node = node->next_node;
+        }
+        ;
+        return 0;
+      }
+      static const char* PCharSetListFind(PCharSetList* self, const char* what) {
+        PCharSetListNode* node;
+        assert(self);
+        what = (what);
+        assert(PCharSetListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+      static int PCharSetListReplace(PCharSetList* self, const char* what, const char* with) {
+        PCharSetListNode* node;
+        assert(self);
+        what = (what);
+        with = (with);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            node->element = (with);
+            ;
+            ;
+            return 1;
+          }
+          node = node->next_node;
+        }
+        ;
+        ;
+        return 0;
+      }
+      static int PCharSetListReplaceAll(PCharSetList* self, const char* what, const char* with) {
+        PCharSetListNode* node;
+        int count = 0;
+        assert(self);
+        what = (what);
+        with = (with);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            node->element = (with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        ;
+        ;
+        return count;
+      }
+      static int PCharSetListRemove(PCharSetList* self, const char* what) {
+        PCharSetListNode* node;
+        PCharSetListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        ;
+        return found;
+      }
+      static int PCharSetListRemoveAll(PCharSetList* self, const char* what) {
+        PCharSetListNode* node;
+        PCharSetListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        ;
+        return count;
+      }
+      static size_t PCharSetListSize(PCharSetList* self) {
+        assert(self);
+        return self->node_count;
+      }
+      static int PCharSetListEmpty(PCharSetList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+      static void PCharSetListItCtor(PCharSetListIt* self, PCharSetList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+      static int PCharSetListItHasNext(PCharSetListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+      static const char* PCharSetListItNext(PCharSetListIt* self) {
+        PCharSetListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+       void PCharSetCtor(PCharSet* 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;
+        PCharSetRehash(self);
+      }
+       void PCharSetDtor(PCharSet* self) {
+        size_t i;
+        assert(self);
+        for(i = 0; i < self->bucket_count; ++i) {
+          PCharSetListDtor(&self->buckets[i]);
+        }
+        free(self->buckets);
+      }
+       PCharSet* PCharSetNew(void) {
+        PCharSet* self = (PCharSet*)malloc(sizeof(PCharSet)); assert(self);
+        PCharSetCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void PCharSetDestroy(PCharSet* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PCharSetDtor(self);
+          free(self);
+        }
+      }
+       PCharSet* PCharSetAssign(PCharSet* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void PCharSetPurge(PCharSet* self) {
+        assert(self);
+        PCharSetDtor(self);
+        self->buckets = NULL;
+        PCharSetRehash(self);
+      }
+       void PCharSetRehash(PCharSet* self) {
+        PCharSetList* buckets;
+        size_t i, 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 = (PCharSetList*)malloc(bucket_count*sizeof(PCharSetList)); assert(buckets);
+        for(i = 0; i < bucket_count; ++i) {
+          PCharSetListCtor(&buckets[i]);
+        }
+        if(self->buckets) {
+          PCharSetIt it;
+          PCharSetItCtor(&it, self);
+          while(PCharSetItHasNext(&it)) {
+            PCharSetList* bucket;
+            const char* element = PCharSetItNext(&it);
+            bucket = &buckets[PCharHash(element) % bucket_count];
+            PCharSetListAdd(bucket, element);
+          }
+          PCharSetDtor(self);
+        }
+        self->buckets = buckets;
+        self->bucket_count = bucket_count;
+        self->size = size;
+      }
+       int PCharSetContains(PCharSet* self, const char* element) {
+        int result;
+        assert(self);
+        element = (element);
+        result = PCharSetListContains(&self->buckets[PCharHash(element) % self->bucket_count], element);
+        ;
+        return result;
+      }
+       const char* PCharSetGet(PCharSet* self, const char* element) {
+        const char* result;
+        assert(self);
+        element = (element);
+        assert(PCharSetContains(self, element));
+        result = PCharSetListFind(&self->buckets[PCharHash(element) % self->bucket_count], element);
+        ;
+        return result;
+      }
+       size_t PCharSetSize(PCharSet* self) {
+        assert(self);
+        return self->size;
+      }
+       int PCharSetEmpty(PCharSet* self) {
+        assert(self);
+        return !self->size;
+      }
+       int PCharSetPut(PCharSet* self, const char* element) {
+        int contained = 1;
+        PCharSetList* bucket;
+        assert(self);
+        element = (element);
+        bucket = &self->buckets[PCharHash(element) % self->bucket_count];
+        if(!PCharSetListContains(bucket, element)) {
+          PCharSetListAdd(bucket, element);
+          ++self->size;
+          contained = 0;
+          PCharSetRehash(self);
+        }
+        ;
+        return contained;
+      }
+       void PCharSetReplace(PCharSet* self, const char* element) {
+        PCharSetList* bucket;
+        assert(self);
+        element = (element);
+        bucket = &self->buckets[PCharHash(element) % self->bucket_count];
+        if(!PCharSetListReplace(bucket, element, element)) {
+          PCharSetListAdd(bucket, element);
+          ++self->size;
+          PCharSetRehash(self);
+        }
+        ;
+      }
+       int PCharSetRemove(PCharSet* self, const char* what) {
+        int removed = 0;
+        PCharSetList* bucket;
+        assert(self);
+        what = (what);
+        bucket = &self->buckets[PCharHash(what) % self->bucket_count];
+        if(PCharSetListRemove(bucket, what)) {
+          --self->size;
+          removed = 1;
+          PCharSetRehash(self);
+        }
+        ;
+        return removed;
+      }
+       void PCharSetNot(PCharSet* self, PCharSet* other) {
+        PCharSetIt it;
+        assert(self);
+        assert(other);
+        PCharSetItCtor(&it, other);
+        while(PCharSetItHasNext(&it)) {
+          PCharSetRemove(self, PCharSetItNext(&it));
+        }
+        PCharSetRehash(self);
+      }
+       void PCharSetOr(PCharSet* self, PCharSet* other) {
+        PCharSetIt it;
+        assert(self);
+        assert(other);
+        PCharSetItCtor(&it, other);
+        while(PCharSetItHasNext(&it)) {
+          PCharSetPut(self, PCharSetItNext(&it));
+        }
+        PCharSetRehash(self);
+      }
+       void PCharSetAnd(PCharSet* self, PCharSet* other) {
+        PCharSetIt it;
+        PCharSet set;
+        assert(self);
+        assert(other);
+        PCharSetCtor(&set);
+        PCharSetItCtor(&it, self);
+        while(PCharSetItHasNext(&it)) {
+          const char* element = PCharSetItNext(&it);
+          if(PCharSetContains(other, element)) PCharSetPut(&set, element);
+        }
+        PCharSetItCtor(&it, other);
+        while(PCharSetItHasNext(&it)) {
+          const char* element = PCharSetItNext(&it);
+          if(PCharSetContains(self, element)) PCharSetPut(&set, element);
+        }
+        PCharSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        PCharSetRehash(self);
+        /*PCharSetDtor(&set);*/
+      }
+       void PCharSetXor(PCharSet* self, PCharSet* other) {
+        PCharSetIt it;
+        PCharSet set;
+        assert(self);
+        assert(other);
+        PCharSetCtor(&set);
+        PCharSetItCtor(&it, self);
+        while(PCharSetItHasNext(&it)) {
+          const char* element = PCharSetItNext(&it);
+          if(!PCharSetContains(other, element)) PCharSetPut(&set, element);
+        }
+        PCharSetItCtor(&it, other);
+        while(PCharSetItHasNext(&it)) {
+          const char* element = PCharSetItNext(&it);
+          if(!PCharSetContains(self, element)) PCharSetPut(&set, element);
+        }
+        PCharSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        PCharSetRehash(self);
+        /*PCharSetDtor(&set);*/
+      }
+       void PCharSetItCtor(PCharSetIt* self, PCharSet* set) {
+        assert(self);
+        self->set = set;
+        self->bucket_index = 0;
+        PCharSetListItCtor(&self->it, &set->buckets[0]);
+      }
+       int PCharSetItHasNext(PCharSetIt* self) {
+        assert(self);
+        if(PCharSetListItHasNext(&self->it)) {
+          return 1;
+        } else {
+          size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!PCharSetListEmpty(&self->set->buckets[i])) {
+              return 1;
+            }
+          }
+          return 0;
+        }
+      }
+       const char* PCharSetItNext(PCharSetIt* self) {
+        assert(self);
+        assert(PCharSetItHasNext(self));
+          if(PCharSetListItHasNext(&self->it)) {
+            return PCharSetListItNext(&self->it);
+          } else {
+            size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!PCharSetListEmpty(&self->set->buckets[i])) {
+            PCharSetListItCtor(&self->it, &self->set->buckets[i]);
+              self->bucket_index = i;
+              return PCharSetListItNext(&self->it);
+            }
+          }
+          abort();
+        }
+      }
+    
+      static Box2BoxMapEntry Box2BoxMapEntryKeyOnly(Box* key) {
+        Box2BoxMapEntry entry;
+        entry.key = key;
+        entry.valid_value = 0;
+        return entry;
+      }
+      static Box2BoxMapEntry Box2BoxMapEntryKeyValue(Box* key, Box* value) {
+        Box2BoxMapEntry entry;
+        entry.key = key;
+        entry.value = value;
+        entry.valid_value = 1;
+        return entry;
+      }
+      static size_t Box2BoxMapEntryHash(Box2BoxMapEntry entry) {
+        return BoxHash(entry.key);
+      }
+      static int Box2BoxMapEntryEqual(Box2BoxMapEntry lt, Box2BoxMapEntry rt) {
+        return BoxEqual(lt.key,rt.key);
+      }
+      static Box2BoxMapEntry Box2BoxMapEntryAssign(Box2BoxMapEntry entry) {
+        entry.key = BoxAssign(entry.key);
+        if(entry.valid_value) entry.value = BoxAssign(entry.value);
+        return entry;
+      }
+      static void Box2BoxMapEntryDtor(Box2BoxMapEntry entry) {
+        BoxDestroy(entry.key);
+        if(entry.valid_value) BoxDestroy(entry.value);
+      }
+    
+      static void Box2BoxMapSetCtor(Box2BoxMapSet*);
+      static void Box2BoxMapSetDtor(Box2BoxMapSet*);
+      static Box2BoxMapSet* Box2BoxMapSetNew(void);
+      static void Box2BoxMapSetDestroy(Box2BoxMapSet*);
+      static Box2BoxMapSet* Box2BoxMapSetAssign(Box2BoxMapSet*);
+      static void Box2BoxMapSetPurge(Box2BoxMapSet*);
+      static void Box2BoxMapSetRehash(Box2BoxMapSet*);
+      static int Box2BoxMapSetContains(Box2BoxMapSet*, Box2BoxMapEntry);
+      static Box2BoxMapEntry Box2BoxMapSetGet(Box2BoxMapSet*, Box2BoxMapEntry);
+      static size_t Box2BoxMapSetSize(Box2BoxMapSet*);
+      static int Box2BoxMapSetEmpty(Box2BoxMapSet*);
+      static int Box2BoxMapSetPut(Box2BoxMapSet*, Box2BoxMapEntry);
+      static void Box2BoxMapSetReplace(Box2BoxMapSet*, Box2BoxMapEntry);
+      static int Box2BoxMapSetRemove(Box2BoxMapSet*, Box2BoxMapEntry);
+      static void Box2BoxMapSetNot(Box2BoxMapSet*, Box2BoxMapSet*);
+      static void Box2BoxMapSetAnd(Box2BoxMapSet*, Box2BoxMapSet*);
+      static void Box2BoxMapSetOr(Box2BoxMapSet*, Box2BoxMapSet*);
+      static void Box2BoxMapSetXor(Box2BoxMapSet*, Box2BoxMapSet*);
+      static void Box2BoxMapSetItCtor(Box2BoxMapSetIt*, Box2BoxMapSet*);
+      static int Box2BoxMapSetItHasNext(Box2BoxMapSetIt*);
+      static Box2BoxMapEntry Box2BoxMapSetItNext(Box2BoxMapSetIt*);
+    
+      static void Box2BoxMapSetListCtor(Box2BoxMapSetList*);
+      static void Box2BoxMapSetListDtor(Box2BoxMapSetList*);
+      static void Box2BoxMapSetListPurge(Box2BoxMapSetList*);
+      static Box2BoxMapSetList* Box2BoxMapSetListNew(void);
+      static void Box2BoxMapSetListDestroy(Box2BoxMapSetList*);
+      static Box2BoxMapSetList* Box2BoxMapSetListAssign(Box2BoxMapSetList*);
+      static Box2BoxMapEntry Box2BoxMapSetListGet(Box2BoxMapSetList*);
+      static void Box2BoxMapSetListAdd(Box2BoxMapSetList*, Box2BoxMapEntry);
+      static void Box2BoxMapSetListChop(Box2BoxMapSetList*);
+      static int Box2BoxMapSetListContains(Box2BoxMapSetList*, Box2BoxMapEntry);
+      static Box2BoxMapEntry Box2BoxMapSetListFind(Box2BoxMapSetList*, Box2BoxMapEntry);
+      static int Box2BoxMapSetListReplace(Box2BoxMapSetList*, Box2BoxMapEntry, Box2BoxMapEntry);
+      static int Box2BoxMapSetListReplaceAll(Box2BoxMapSetList*, Box2BoxMapEntry, Box2BoxMapEntry);
+      static int Box2BoxMapSetListRemove(Box2BoxMapSetList*, Box2BoxMapEntry);
+      static int Box2BoxMapSetListRemoveAll(Box2BoxMapSetList*, Box2BoxMapEntry);
+      static size_t Box2BoxMapSetListSize(Box2BoxMapSetList*);
+      static int Box2BoxMapSetListEmpty(Box2BoxMapSetList*);
+      static void Box2BoxMapSetListItCtor(Box2BoxMapSetListIt*, Box2BoxMapSetList*);
+      static int Box2BoxMapSetListItHasNext(Box2BoxMapSetListIt*);
+      static Box2BoxMapEntry Box2BoxMapSetListItNext(Box2BoxMapSetListIt*);
+    
+      static void Box2BoxMapSetListCtor(Box2BoxMapSetList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+      static void Box2BoxMapSetListDtor(Box2BoxMapSetList* self) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        {
+        Box2BoxMapSetListIt it;
+        Box2BoxMapSetListItCtor(&it, self);
+        while(Box2BoxMapSetListItHasNext(&it)) {
+          Box2BoxMapEntry e = Box2BoxMapSetListItNext(&it);
+          Box2BoxMapEntryDtor(e);
+        }
+      };
+        node = self->head_node;
+        while(node) {
+          Box2BoxMapSetListNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+      static Box2BoxMapSetList* Box2BoxMapSetListNew(void) {
+        Box2BoxMapSetList* self = (Box2BoxMapSetList*)malloc(sizeof(Box2BoxMapSetList)); assert(self);
+        Box2BoxMapSetListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void Box2BoxMapSetListDestroy(Box2BoxMapSetList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          Box2BoxMapSetListDtor(self);
+          free(self);
+        }
+      }
+      static Box2BoxMapSetList* Box2BoxMapSetListAssign(Box2BoxMapSetList* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void Box2BoxMapSetListPurge(Box2BoxMapSetList* self) {
+        Box2BoxMapSetListDtor(self);
+        Box2BoxMapSetListCtor(self);
+      }
+      static Box2BoxMapEntry Box2BoxMapSetListGet(Box2BoxMapSetList* self) {
+        assert(self);
+        assert(!Box2BoxMapSetListEmpty(self));
+        return self->head_node->element;
+      }
+      static void Box2BoxMapSetListChop(Box2BoxMapSetList* self) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        assert(!Box2BoxMapSetListEmpty(self));
+        node = self->head_node;
+        Box2BoxMapEntryDtor(node->element);
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+      static void Box2BoxMapSetListAdd(Box2BoxMapSetList* self, Box2BoxMapEntry element) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        node = (Box2BoxMapSetListNode*)malloc(sizeof(Box2BoxMapSetListNode)); assert(node);
+        node->element = Box2BoxMapEntryAssign(element);
+        node->next_node = self->head_node;
+        self->head_node = node;
+        ++self->node_count;
+      }
+      static int Box2BoxMapSetListContains(Box2BoxMapSetList* self, Box2BoxMapEntry what) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        node = self->head_node;
+        while(node) {
+          if(Box2BoxMapEntryEqual(node->element,what)) {
+            Box2BoxMapEntryDtor(what);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        Box2BoxMapEntryDtor(what);
+        return 0;
+      }
+      static Box2BoxMapEntry Box2BoxMapSetListFind(Box2BoxMapSetList* self, Box2BoxMapEntry what) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        assert(Box2BoxMapSetListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(Box2BoxMapEntryEqual(node->element,what)) {
+            Box2BoxMapEntryDtor(what);
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+      static int Box2BoxMapSetListReplace(Box2BoxMapSetList* self, Box2BoxMapEntry what, Box2BoxMapEntry with) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        with = Box2BoxMapEntryAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(Box2BoxMapEntryEqual(node->element,what)) {
+            Box2BoxMapEntryDtor(node->element);
+            node->element = Box2BoxMapEntryAssign(with);
+            Box2BoxMapEntryDtor(what);
+            Box2BoxMapEntryDtor(with);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        Box2BoxMapEntryDtor(what);
+        Box2BoxMapEntryDtor(with);
+        return 0;
+      }
+      static int Box2BoxMapSetListReplaceAll(Box2BoxMapSetList* self, Box2BoxMapEntry what, Box2BoxMapEntry with) {
+        Box2BoxMapSetListNode* node;
+        int count = 0;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        with = Box2BoxMapEntryAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(Box2BoxMapEntryEqual(node->element,what)) {
+            Box2BoxMapEntryDtor(node->element);
+            node->element = Box2BoxMapEntryAssign(with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        Box2BoxMapEntryDtor(what);
+        Box2BoxMapEntryDtor(with);
+        return count;
+      }
+      static int Box2BoxMapSetListRemove(Box2BoxMapSetList* self, Box2BoxMapEntry what) {
+        Box2BoxMapSetListNode* node;
+        Box2BoxMapSetListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(Box2BoxMapEntryEqual(node->element,what)) {
+            Box2BoxMapEntryDtor(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        Box2BoxMapEntryDtor(what);
+        return found;
+      }
+      static int Box2BoxMapSetListRemoveAll(Box2BoxMapSetList* self, Box2BoxMapEntry what) {
+        Box2BoxMapSetListNode* node;
+        Box2BoxMapSetListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(Box2BoxMapEntryEqual(node->element,what)) {
+            Box2BoxMapEntryDtor(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        Box2BoxMapEntryDtor(what);
+        return count;
+      }
+      static size_t Box2BoxMapSetListSize(Box2BoxMapSetList* self) {
+        assert(self);
+        return self->node_count;
+      }
+      static int Box2BoxMapSetListEmpty(Box2BoxMapSetList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+      static void Box2BoxMapSetListItCtor(Box2BoxMapSetListIt* self, Box2BoxMapSetList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+      static int Box2BoxMapSetListItHasNext(Box2BoxMapSetListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+      static Box2BoxMapEntry Box2BoxMapSetListItNext(Box2BoxMapSetListIt* self) {
+        Box2BoxMapSetListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+      static void Box2BoxMapSetCtor(Box2BoxMapSet* 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;
+        Box2BoxMapSetRehash(self);
+      }
+      static void Box2BoxMapSetDtor(Box2BoxMapSet* self) {
+        size_t i;
+        assert(self);
+        for(i = 0; i < self->bucket_count; ++i) {
+          Box2BoxMapSetListDtor(&self->buckets[i]);
+        }
+        free(self->buckets);
+      }
+      static Box2BoxMapSet* Box2BoxMapSetNew(void) {
+        Box2BoxMapSet* self = (Box2BoxMapSet*)malloc(sizeof(Box2BoxMapSet)); assert(self);
+        Box2BoxMapSetCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void Box2BoxMapSetDestroy(Box2BoxMapSet* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          Box2BoxMapSetDtor(self);
+          free(self);
+        }
+      }
+      static Box2BoxMapSet* Box2BoxMapSetAssign(Box2BoxMapSet* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void Box2BoxMapSetPurge(Box2BoxMapSet* self) {
+        assert(self);
+        Box2BoxMapSetDtor(self);
+        self->buckets = NULL;
+        Box2BoxMapSetRehash(self);
+      }
+      static void Box2BoxMapSetRehash(Box2BoxMapSet* self) {
+        Box2BoxMapSetList* buckets;
+        size_t i, 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 = (Box2BoxMapSetList*)malloc(bucket_count*sizeof(Box2BoxMapSetList)); assert(buckets);
+        for(i = 0; i < bucket_count; ++i) {
+          Box2BoxMapSetListCtor(&buckets[i]);
+        }
+        if(self->buckets) {
+          Box2BoxMapSetIt it;
+          Box2BoxMapSetItCtor(&it, self);
+          while(Box2BoxMapSetItHasNext(&it)) {
+            Box2BoxMapSetList* bucket;
+            Box2BoxMapEntry element = Box2BoxMapSetItNext(&it);
+            bucket = &buckets[Box2BoxMapEntryHash(element) % bucket_count];
+            Box2BoxMapSetListAdd(bucket, element);
+          }
+          Box2BoxMapSetDtor(self);
+        }
+        self->buckets = buckets;
+        self->bucket_count = bucket_count;
+        self->size = size;
+      }
+      static int Box2BoxMapSetContains(Box2BoxMapSet* self, Box2BoxMapEntry element) {
+        int result;
+        assert(self);
+        element = Box2BoxMapEntryAssign(element);
+        result = Box2BoxMapSetListContains(&self->buckets[Box2BoxMapEntryHash(element) % self->bucket_count], element);
+        Box2BoxMapEntryDtor(element);
+        return result;
+      }
+      static Box2BoxMapEntry Box2BoxMapSetGet(Box2BoxMapSet* self, Box2BoxMapEntry element) {
+        Box2BoxMapEntry result;
+        assert(self);
+        element = Box2BoxMapEntryAssign(element);
+        assert(Box2BoxMapSetContains(self, element));
+        result = Box2BoxMapSetListFind(&self->buckets[Box2BoxMapEntryHash(element) % self->bucket_count], element);
+        Box2BoxMapEntryDtor(element);
+        return result;
+      }
+      static size_t Box2BoxMapSetSize(Box2BoxMapSet* self) {
+        assert(self);
+        return self->size;
+      }
+      static int Box2BoxMapSetEmpty(Box2BoxMapSet* self) {
+        assert(self);
+        return !self->size;
+      }
+      static int Box2BoxMapSetPut(Box2BoxMapSet* self, Box2BoxMapEntry element) {
+        int contained = 1;
+        Box2BoxMapSetList* bucket;
+        assert(self);
+        element = Box2BoxMapEntryAssign(element);
+        bucket = &self->buckets[Box2BoxMapEntryHash(element) % self->bucket_count];
+        if(!Box2BoxMapSetListContains(bucket, element)) {
+          Box2BoxMapSetListAdd(bucket, element);
+          ++self->size;
+          contained = 0;
+          Box2BoxMapSetRehash(self);
+        }
+        Box2BoxMapEntryDtor(element);
+        return contained;
+      }
+      static void Box2BoxMapSetReplace(Box2BoxMapSet* self, Box2BoxMapEntry element) {
+        Box2BoxMapSetList* bucket;
+        assert(self);
+        element = Box2BoxMapEntryAssign(element);
+        bucket = &self->buckets[Box2BoxMapEntryHash(element) % self->bucket_count];
+        if(!Box2BoxMapSetListReplace(bucket, element, element)) {
+          Box2BoxMapSetListAdd(bucket, element);
+          ++self->size;
+          Box2BoxMapSetRehash(self);
+        }
+        Box2BoxMapEntryDtor(element);
+      }
+      static int Box2BoxMapSetRemove(Box2BoxMapSet* self, Box2BoxMapEntry what) {
+        int removed = 0;
+        Box2BoxMapSetList* bucket;
+        assert(self);
+        what = Box2BoxMapEntryAssign(what);
+        bucket = &self->buckets[Box2BoxMapEntryHash(what) % self->bucket_count];
+        if(Box2BoxMapSetListRemove(bucket, what)) {
+          --self->size;
+          removed = 1;
+          Box2BoxMapSetRehash(self);
+        }
+        Box2BoxMapEntryDtor(what);
+        return removed;
+      }
+      static void Box2BoxMapSetNot(Box2BoxMapSet* self, Box2BoxMapSet* other) {
+        Box2BoxMapSetIt it;
+        assert(self);
+        assert(other);
+        Box2BoxMapSetItCtor(&it, other);
+        while(Box2BoxMapSetItHasNext(&it)) {
+          Box2BoxMapSetRemove(self, Box2BoxMapSetItNext(&it));
+        }
+        Box2BoxMapSetRehash(self);
+      }
+      static void Box2BoxMapSetOr(Box2BoxMapSet* self, Box2BoxMapSet* other) {
+        Box2BoxMapSetIt it;
+        assert(self);
+        assert(other);
+        Box2BoxMapSetItCtor(&it, other);
+        while(Box2BoxMapSetItHasNext(&it)) {
+          Box2BoxMapSetPut(self, Box2BoxMapSetItNext(&it));
+        }
+        Box2BoxMapSetRehash(self);
+      }
+      static void Box2BoxMapSetAnd(Box2BoxMapSet* self, Box2BoxMapSet* other) {
+        Box2BoxMapSetIt it;
+        Box2BoxMapSet set;
+        assert(self);
+        assert(other);
+        Box2BoxMapSetCtor(&set);
+        Box2BoxMapSetItCtor(&it, self);
+        while(Box2BoxMapSetItHasNext(&it)) {
+          Box2BoxMapEntry element = Box2BoxMapSetItNext(&it);
+          if(Box2BoxMapSetContains(other, element)) Box2BoxMapSetPut(&set, element);
+        }
+        Box2BoxMapSetItCtor(&it, other);
+        while(Box2BoxMapSetItHasNext(&it)) {
+          Box2BoxMapEntry element = Box2BoxMapSetItNext(&it);
+          if(Box2BoxMapSetContains(self, element)) Box2BoxMapSetPut(&set, element);
+        }
+        Box2BoxMapSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        Box2BoxMapSetRehash(self);
+        /*Box2BoxMapSetDtor(&set);*/
+      }
+      static void Box2BoxMapSetXor(Box2BoxMapSet* self, Box2BoxMapSet* other) {
+        Box2BoxMapSetIt it;
+        Box2BoxMapSet set;
+        assert(self);
+        assert(other);
+        Box2BoxMapSetCtor(&set);
+        Box2BoxMapSetItCtor(&it, self);
+        while(Box2BoxMapSetItHasNext(&it)) {
+          Box2BoxMapEntry element = Box2BoxMapSetItNext(&it);
+          if(!Box2BoxMapSetContains(other, element)) Box2BoxMapSetPut(&set, element);
+        }
+        Box2BoxMapSetItCtor(&it, other);
+        while(Box2BoxMapSetItHasNext(&it)) {
+          Box2BoxMapEntry element = Box2BoxMapSetItNext(&it);
+          if(!Box2BoxMapSetContains(self, element)) Box2BoxMapSetPut(&set, element);
+        }
+        Box2BoxMapSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        Box2BoxMapSetRehash(self);
+        /*Box2BoxMapSetDtor(&set);*/
+      }
+      static void Box2BoxMapSetItCtor(Box2BoxMapSetIt* self, Box2BoxMapSet* set) {
+        assert(self);
+        self->set = set;
+        self->bucket_index = 0;
+        Box2BoxMapSetListItCtor(&self->it, &set->buckets[0]);
+      }
+      static int Box2BoxMapSetItHasNext(Box2BoxMapSetIt* self) {
+        assert(self);
+        if(Box2BoxMapSetListItHasNext(&self->it)) {
+          return 1;
+        } else {
+          size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!Box2BoxMapSetListEmpty(&self->set->buckets[i])) {
+              return 1;
+            }
+          }
+          return 0;
+        }
+      }
+      static Box2BoxMapEntry Box2BoxMapSetItNext(Box2BoxMapSetIt* self) {
+        assert(self);
+        assert(Box2BoxMapSetItHasNext(self));
+          if(Box2BoxMapSetListItHasNext(&self->it)) {
+            return Box2BoxMapSetListItNext(&self->it);
+          } else {
+            size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!Box2BoxMapSetListEmpty(&self->set->buckets[i])) {
+            Box2BoxMapSetListItCtor(&self->it, &self->set->buckets[i]);
+              self->bucket_index = i;
+              return Box2BoxMapSetListItNext(&self->it);
+            }
+          }
+          abort();
+        }
+      }
+    
+       void Box2BoxMapCtor(Box2BoxMap* self) {
+        assert(self);
+        Box2BoxMapSetCtor(&self->entries);
+      }
+       void Box2BoxMapDtor(Box2BoxMap* self) {
+        assert(self);
+        Box2BoxMapSetDtor(&self->entries);
+      }
+       Box2BoxMap* Box2BoxMapNew(void) {
+        Box2BoxMap* self = (Box2BoxMap*)malloc(sizeof(Box2BoxMap)); assert(self);
+        Box2BoxMapCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void Box2BoxMapDestroy(Box2BoxMap* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          Box2BoxMapDtor(self);
+          free(self);
+        }
+      }
+       void Box2BoxMapRehash(Box2BoxMap* self) {
+        assert(self);
+        Box2BoxMapSetRehash(&self->entries);
+      }
+       Box2BoxMap* Box2BoxMapAssign(Box2BoxMap* self) {
+        assert(self);
+        ++self->ref_count;
+        return self;
+      }
+       void Box2BoxMapPurge(Box2BoxMap* self) {
+        assert(self);
+        Box2BoxMapSetPurge(&self->entries);
+      }
+       size_t Box2BoxMapSize(Box2BoxMap* self) {
+        assert(self);
+        return Box2BoxMapSetSize(&self->entries);
+      }
+       int Box2BoxMapEmpty(Box2BoxMap* self) {
+        assert(self);
+        return Box2BoxMapSetEmpty(&self->entries);
+      }
+       int Box2BoxMapContainsKey(Box2BoxMap* self, Box* key) {
+        int result;
+        Box2BoxMapEntry entry;
+        assert(self);
+        entry = Box2BoxMapEntryAssign(Box2BoxMapEntryKeyOnly(key));
+        result = Box2BoxMapSetContains(&self->entries, entry);
+        Box2BoxMapEntryDtor(entry);
+        return result;
+      }
+       Box* Box2BoxMapGet(Box2BoxMap* self, Box* key) {
+        Box* result;
+        Box2BoxMapEntry entry;
+        assert(self);
+        entry = Box2BoxMapEntryAssign(Box2BoxMapEntryKeyOnly(key));
+        assert(Box2BoxMapContainsKey(self, key));
+        result = Box2BoxMapSetGet(&self->entries, entry).value;
+        Box2BoxMapEntryDtor(entry);
+        return result;
+      }
+       int Box2BoxMapPut(Box2BoxMap* self, Box* key, Box* value) {
+        Box2BoxMapEntry entry = Box2BoxMapEntryAssign(Box2BoxMapEntryKeyValue(key,value));
+        assert(self);
+        if(!Box2BoxMapContainsKey(self, key)) {
+          Box2BoxMapSetPut(&self->entries, entry);
+          Box2BoxMapEntryDtor(entry);
+          return 1;
+        } else {
+          Box2BoxMapEntryDtor(entry);
+          return 0;
+        }
+      }
+       void Box2BoxMapReplace(Box2BoxMap* self, Box* key, Box* value) {
+        Box2BoxMapEntry entry;
+        assert(self);
+        entry = Box2BoxMapEntryAssign(Box2BoxMapEntryKeyValue(key,value));
+        Box2BoxMapSetReplace(&self->entries, entry);
+        Box2BoxMapEntryDtor(entry);
+      }
+       int Box2BoxMapRemove(Box2BoxMap* self, Box* key) {
+        int removed;
+        Box2BoxMapEntry entry;
+        assert(self);
+        entry = Box2BoxMapEntryAssign(Box2BoxMapEntryKeyOnly(key));
+        removed = Box2BoxMapSetRemove(&self->entries, entry);
+        Box2BoxMapEntryDtor(entry);
+        return removed;
+      }
+       void Box2BoxMapItCtor(Box2BoxMapIt* self, Box2BoxMap* map) {
+        assert(self);
+        assert(map);
+        Box2BoxMapSetItCtor(&self->it, &map->entries);
+      }
+       int Box2BoxMapItHasNext(Box2BoxMapIt* self) {
+        assert(self);
+        return Box2BoxMapSetItHasNext(&self->it);
+      }
+       Box* Box2BoxMapItNextKey(Box2BoxMapIt* self) {
+        assert(self);
+        return Box2BoxMapSetItNext(&self->it).key;
+      }
+       Box* Box2BoxMapItNextValue(Box2BoxMapIt* self) {
+        assert(self);
+        return Box2BoxMapSetItNext(&self->it).value;
+      }
+       Box2BoxMapEntry Box2BoxMapItNext(Box2BoxMapIt* self) {
+        assert(self);
+        return Box2BoxMapSetItNext(&self->it);
+      }
+    
+      static PChar2IntMapEntry PChar2IntMapEntryKeyOnly(const char* key) {
+        PChar2IntMapEntry entry;
+        entry.key = key;
+        entry.valid_value = 0;
+        return entry;
+      }
+      static PChar2IntMapEntry PChar2IntMapEntryKeyValue(const char* key, int value) {
+        PChar2IntMapEntry entry;
+        entry.key = key;
+        entry.value = value;
+        entry.valid_value = 1;
+        return entry;
+      }
+      static size_t PChar2IntMapEntryHash(PChar2IntMapEntry entry) {
+        return PCharHash(entry.key);
+      }
+      static int PChar2IntMapEntryEqual(PChar2IntMapEntry lt, PChar2IntMapEntry rt) {
+        return PCharEqual(lt.key,rt.key);
+      }
+      static PChar2IntMapEntry PChar2IntMapEntryAssign(PChar2IntMapEntry entry) {
+        entry.key = (entry.key);
+        if(entry.valid_value) entry.value = (entry.value);
+        return entry;
+      }
+      static void PChar2IntMapEntryDtor(PChar2IntMapEntry entry) {
+        ;
+        if(entry.valid_value) ;
+      }
+    
+      static void PChar2IntMapSetCtor(PChar2IntMapSet*);
+      static void PChar2IntMapSetDtor(PChar2IntMapSet*);
+      static PChar2IntMapSet* PChar2IntMapSetNew(void);
+      static void PChar2IntMapSetDestroy(PChar2IntMapSet*);
+      static PChar2IntMapSet* PChar2IntMapSetAssign(PChar2IntMapSet*);
+      static void PChar2IntMapSetPurge(PChar2IntMapSet*);
+      static void PChar2IntMapSetRehash(PChar2IntMapSet*);
+      static int PChar2IntMapSetContains(PChar2IntMapSet*, PChar2IntMapEntry);
+      static PChar2IntMapEntry PChar2IntMapSetGet(PChar2IntMapSet*, PChar2IntMapEntry);
+      static size_t PChar2IntMapSetSize(PChar2IntMapSet*);
+      static int PChar2IntMapSetEmpty(PChar2IntMapSet*);
+      static int PChar2IntMapSetPut(PChar2IntMapSet*, PChar2IntMapEntry);
+      static void PChar2IntMapSetReplace(PChar2IntMapSet*, PChar2IntMapEntry);
+      static int PChar2IntMapSetRemove(PChar2IntMapSet*, PChar2IntMapEntry);
+      static void PChar2IntMapSetNot(PChar2IntMapSet*, PChar2IntMapSet*);
+      static void PChar2IntMapSetAnd(PChar2IntMapSet*, PChar2IntMapSet*);
+      static void PChar2IntMapSetOr(PChar2IntMapSet*, PChar2IntMapSet*);
+      static void PChar2IntMapSetXor(PChar2IntMapSet*, PChar2IntMapSet*);
+      static void PChar2IntMapSetItCtor(PChar2IntMapSetIt*, PChar2IntMapSet*);
+      static int PChar2IntMapSetItHasNext(PChar2IntMapSetIt*);
+      static PChar2IntMapEntry PChar2IntMapSetItNext(PChar2IntMapSetIt*);
+    
+      static void PChar2IntMapSetListCtor(PChar2IntMapSetList*);
+      static void PChar2IntMapSetListDtor(PChar2IntMapSetList*);
+      static void PChar2IntMapSetListPurge(PChar2IntMapSetList*);
+      static PChar2IntMapSetList* PChar2IntMapSetListNew(void);
+      static void PChar2IntMapSetListDestroy(PChar2IntMapSetList*);
+      static PChar2IntMapSetList* PChar2IntMapSetListAssign(PChar2IntMapSetList*);
+      static PChar2IntMapEntry PChar2IntMapSetListGet(PChar2IntMapSetList*);
+      static void PChar2IntMapSetListAdd(PChar2IntMapSetList*, PChar2IntMapEntry);
+      static void PChar2IntMapSetListChop(PChar2IntMapSetList*);
+      static int PChar2IntMapSetListContains(PChar2IntMapSetList*, PChar2IntMapEntry);
+      static PChar2IntMapEntry PChar2IntMapSetListFind(PChar2IntMapSetList*, PChar2IntMapEntry);
+      static int PChar2IntMapSetListReplace(PChar2IntMapSetList*, PChar2IntMapEntry, PChar2IntMapEntry);
+      static int PChar2IntMapSetListReplaceAll(PChar2IntMapSetList*, PChar2IntMapEntry, PChar2IntMapEntry);
+      static int PChar2IntMapSetListRemove(PChar2IntMapSetList*, PChar2IntMapEntry);
+      static int PChar2IntMapSetListRemoveAll(PChar2IntMapSetList*, PChar2IntMapEntry);
+      static size_t PChar2IntMapSetListSize(PChar2IntMapSetList*);
+      static int PChar2IntMapSetListEmpty(PChar2IntMapSetList*);
+      static void PChar2IntMapSetListItCtor(PChar2IntMapSetListIt*, PChar2IntMapSetList*);
+      static int PChar2IntMapSetListItHasNext(PChar2IntMapSetListIt*);
+      static PChar2IntMapEntry PChar2IntMapSetListItNext(PChar2IntMapSetListIt*);
+    
+      static void PChar2IntMapSetListCtor(PChar2IntMapSetList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+      static void PChar2IntMapSetListDtor(PChar2IntMapSetList* self) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        {
+        PChar2IntMapSetListIt it;
+        PChar2IntMapSetListItCtor(&it, self);
+        while(PChar2IntMapSetListItHasNext(&it)) {
+          PChar2IntMapEntry e = PChar2IntMapSetListItNext(&it);
+          PChar2IntMapEntryDtor(e);
+        }
+      };
+        node = self->head_node;
+        while(node) {
+          PChar2IntMapSetListNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+      static PChar2IntMapSetList* PChar2IntMapSetListNew(void) {
+        PChar2IntMapSetList* self = (PChar2IntMapSetList*)malloc(sizeof(PChar2IntMapSetList)); assert(self);
+        PChar2IntMapSetListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void PChar2IntMapSetListDestroy(PChar2IntMapSetList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PChar2IntMapSetListDtor(self);
+          free(self);
+        }
+      }
+      static PChar2IntMapSetList* PChar2IntMapSetListAssign(PChar2IntMapSetList* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void PChar2IntMapSetListPurge(PChar2IntMapSetList* self) {
+        PChar2IntMapSetListDtor(self);
+        PChar2IntMapSetListCtor(self);
+      }
+      static PChar2IntMapEntry PChar2IntMapSetListGet(PChar2IntMapSetList* self) {
+        assert(self);
+        assert(!PChar2IntMapSetListEmpty(self));
+        return self->head_node->element;
+      }
+      static void PChar2IntMapSetListChop(PChar2IntMapSetList* self) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        assert(!PChar2IntMapSetListEmpty(self));
+        node = self->head_node;
+        PChar2IntMapEntryDtor(node->element);
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+      static void PChar2IntMapSetListAdd(PChar2IntMapSetList* self, PChar2IntMapEntry element) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        node = (PChar2IntMapSetListNode*)malloc(sizeof(PChar2IntMapSetListNode)); assert(node);
+        node->element = PChar2IntMapEntryAssign(element);
+        node->next_node = self->head_node;
+        self->head_node = node;
+        ++self->node_count;
+      }
+      static int PChar2IntMapSetListContains(PChar2IntMapSetList* self, PChar2IntMapEntry what) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntMapEntryEqual(node->element,what)) {
+            PChar2IntMapEntryDtor(what);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        PChar2IntMapEntryDtor(what);
+        return 0;
+      }
+      static PChar2IntMapEntry PChar2IntMapSetListFind(PChar2IntMapSetList* self, PChar2IntMapEntry what) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        assert(PChar2IntMapSetListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntMapEntryEqual(node->element,what)) {
+            PChar2IntMapEntryDtor(what);
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+      static int PChar2IntMapSetListReplace(PChar2IntMapSetList* self, PChar2IntMapEntry what, PChar2IntMapEntry with) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        with = PChar2IntMapEntryAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntMapEntryEqual(node->element,what)) {
+            PChar2IntMapEntryDtor(node->element);
+            node->element = PChar2IntMapEntryAssign(with);
+            PChar2IntMapEntryDtor(what);
+            PChar2IntMapEntryDtor(with);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        PChar2IntMapEntryDtor(what);
+        PChar2IntMapEntryDtor(with);
+        return 0;
+      }
+      static int PChar2IntMapSetListReplaceAll(PChar2IntMapSetList* self, PChar2IntMapEntry what, PChar2IntMapEntry with) {
+        PChar2IntMapSetListNode* node;
+        int count = 0;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        with = PChar2IntMapEntryAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntMapEntryEqual(node->element,what)) {
+            PChar2IntMapEntryDtor(node->element);
+            node->element = PChar2IntMapEntryAssign(with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        PChar2IntMapEntryDtor(what);
+        PChar2IntMapEntryDtor(with);
+        return count;
+      }
+      static int PChar2IntMapSetListRemove(PChar2IntMapSetList* self, PChar2IntMapEntry what) {
+        PChar2IntMapSetListNode* node;
+        PChar2IntMapSetListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(PChar2IntMapEntryEqual(node->element,what)) {
+            PChar2IntMapEntryDtor(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        PChar2IntMapEntryDtor(what);
+        return found;
+      }
+      static int PChar2IntMapSetListRemoveAll(PChar2IntMapSetList* self, PChar2IntMapEntry what) {
+        PChar2IntMapSetListNode* node;
+        PChar2IntMapSetListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(PChar2IntMapEntryEqual(node->element,what)) {
+            PChar2IntMapEntryDtor(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        PChar2IntMapEntryDtor(what);
+        return count;
+      }
+      static size_t PChar2IntMapSetListSize(PChar2IntMapSetList* self) {
+        assert(self);
+        return self->node_count;
+      }
+      static int PChar2IntMapSetListEmpty(PChar2IntMapSetList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+      static void PChar2IntMapSetListItCtor(PChar2IntMapSetListIt* self, PChar2IntMapSetList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+      static int PChar2IntMapSetListItHasNext(PChar2IntMapSetListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+      static PChar2IntMapEntry PChar2IntMapSetListItNext(PChar2IntMapSetListIt* self) {
+        PChar2IntMapSetListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+      static void PChar2IntMapSetCtor(PChar2IntMapSet* 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;
+        PChar2IntMapSetRehash(self);
+      }
+      static void PChar2IntMapSetDtor(PChar2IntMapSet* self) {
+        size_t i;
+        assert(self);
+        for(i = 0; i < self->bucket_count; ++i) {
+          PChar2IntMapSetListDtor(&self->buckets[i]);
+        }
+        free(self->buckets);
+      }
+      static PChar2IntMapSet* PChar2IntMapSetNew(void) {
+        PChar2IntMapSet* self = (PChar2IntMapSet*)malloc(sizeof(PChar2IntMapSet)); assert(self);
+        PChar2IntMapSetCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void PChar2IntMapSetDestroy(PChar2IntMapSet* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PChar2IntMapSetDtor(self);
+          free(self);
+        }
+      }
+      static PChar2IntMapSet* PChar2IntMapSetAssign(PChar2IntMapSet* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void PChar2IntMapSetPurge(PChar2IntMapSet* self) {
+        assert(self);
+        PChar2IntMapSetDtor(self);
+        self->buckets = NULL;
+        PChar2IntMapSetRehash(self);
+      }
+      static void PChar2IntMapSetRehash(PChar2IntMapSet* self) {
+        PChar2IntMapSetList* buckets;
+        size_t i, 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 = (PChar2IntMapSetList*)malloc(bucket_count*sizeof(PChar2IntMapSetList)); assert(buckets);
+        for(i = 0; i < bucket_count; ++i) {
+          PChar2IntMapSetListCtor(&buckets[i]);
+        }
+        if(self->buckets) {
+          PChar2IntMapSetIt it;
+          PChar2IntMapSetItCtor(&it, self);
+          while(PChar2IntMapSetItHasNext(&it)) {
+            PChar2IntMapSetList* bucket;
+            PChar2IntMapEntry element = PChar2IntMapSetItNext(&it);
+            bucket = &buckets[PChar2IntMapEntryHash(element) % bucket_count];
+            PChar2IntMapSetListAdd(bucket, element);
+          }
+          PChar2IntMapSetDtor(self);
+        }
+        self->buckets = buckets;
+        self->bucket_count = bucket_count;
+        self->size = size;
+      }
+      static int PChar2IntMapSetContains(PChar2IntMapSet* self, PChar2IntMapEntry element) {
+        int result;
+        assert(self);
+        element = PChar2IntMapEntryAssign(element);
+        result = PChar2IntMapSetListContains(&self->buckets[PChar2IntMapEntryHash(element) % self->bucket_count], element);
+        PChar2IntMapEntryDtor(element);
+        return result;
+      }
+      static PChar2IntMapEntry PChar2IntMapSetGet(PChar2IntMapSet* self, PChar2IntMapEntry element) {
+        PChar2IntMapEntry result;
+        assert(self);
+        element = PChar2IntMapEntryAssign(element);
+        assert(PChar2IntMapSetContains(self, element));
+        result = PChar2IntMapSetListFind(&self->buckets[PChar2IntMapEntryHash(element) % self->bucket_count], element);
+        PChar2IntMapEntryDtor(element);
+        return result;
+      }
+      static size_t PChar2IntMapSetSize(PChar2IntMapSet* self) {
+        assert(self);
+        return self->size;
+      }
+      static int PChar2IntMapSetEmpty(PChar2IntMapSet* self) {
+        assert(self);
+        return !self->size;
+      }
+      static int PChar2IntMapSetPut(PChar2IntMapSet* self, PChar2IntMapEntry element) {
+        int contained = 1;
+        PChar2IntMapSetList* bucket;
+        assert(self);
+        element = PChar2IntMapEntryAssign(element);
+        bucket = &self->buckets[PChar2IntMapEntryHash(element) % self->bucket_count];
+        if(!PChar2IntMapSetListContains(bucket, element)) {
+          PChar2IntMapSetListAdd(bucket, element);
+          ++self->size;
+          contained = 0;
+          PChar2IntMapSetRehash(self);
+        }
+        PChar2IntMapEntryDtor(element);
+        return contained;
+      }
+      static void PChar2IntMapSetReplace(PChar2IntMapSet* self, PChar2IntMapEntry element) {
+        PChar2IntMapSetList* bucket;
+        assert(self);
+        element = PChar2IntMapEntryAssign(element);
+        bucket = &self->buckets[PChar2IntMapEntryHash(element) % self->bucket_count];
+        if(!PChar2IntMapSetListReplace(bucket, element, element)) {
+          PChar2IntMapSetListAdd(bucket, element);
+          ++self->size;
+          PChar2IntMapSetRehash(self);
+        }
+        PChar2IntMapEntryDtor(element);
+      }
+      static int PChar2IntMapSetRemove(PChar2IntMapSet* self, PChar2IntMapEntry what) {
+        int removed = 0;
+        PChar2IntMapSetList* bucket;
+        assert(self);
+        what = PChar2IntMapEntryAssign(what);
+        bucket = &self->buckets[PChar2IntMapEntryHash(what) % self->bucket_count];
+        if(PChar2IntMapSetListRemove(bucket, what)) {
+          --self->size;
+          removed = 1;
+          PChar2IntMapSetRehash(self);
+        }
+        PChar2IntMapEntryDtor(what);
+        return removed;
+      }
+      static void PChar2IntMapSetNot(PChar2IntMapSet* self, PChar2IntMapSet* other) {
+        PChar2IntMapSetIt it;
+        assert(self);
+        assert(other);
+        PChar2IntMapSetItCtor(&it, other);
+        while(PChar2IntMapSetItHasNext(&it)) {
+          PChar2IntMapSetRemove(self, PChar2IntMapSetItNext(&it));
+        }
+        PChar2IntMapSetRehash(self);
+      }
+      static void PChar2IntMapSetOr(PChar2IntMapSet* self, PChar2IntMapSet* other) {
+        PChar2IntMapSetIt it;
+        assert(self);
+        assert(other);
+        PChar2IntMapSetItCtor(&it, other);
+        while(PChar2IntMapSetItHasNext(&it)) {
+          PChar2IntMapSetPut(self, PChar2IntMapSetItNext(&it));
+        }
+        PChar2IntMapSetRehash(self);
+      }
+      static void PChar2IntMapSetAnd(PChar2IntMapSet* self, PChar2IntMapSet* other) {
+        PChar2IntMapSetIt it;
+        PChar2IntMapSet set;
+        assert(self);
+        assert(other);
+        PChar2IntMapSetCtor(&set);
+        PChar2IntMapSetItCtor(&it, self);
+        while(PChar2IntMapSetItHasNext(&it)) {
+          PChar2IntMapEntry element = PChar2IntMapSetItNext(&it);
+          if(PChar2IntMapSetContains(other, element)) PChar2IntMapSetPut(&set, element);
+        }
+        PChar2IntMapSetItCtor(&it, other);
+        while(PChar2IntMapSetItHasNext(&it)) {
+          PChar2IntMapEntry element = PChar2IntMapSetItNext(&it);
+          if(PChar2IntMapSetContains(self, element)) PChar2IntMapSetPut(&set, element);
+        }
+        PChar2IntMapSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        PChar2IntMapSetRehash(self);
+        /*PChar2IntMapSetDtor(&set);*/
+      }
+      static void PChar2IntMapSetXor(PChar2IntMapSet* self, PChar2IntMapSet* other) {
+        PChar2IntMapSetIt it;
+        PChar2IntMapSet set;
+        assert(self);
+        assert(other);
+        PChar2IntMapSetCtor(&set);
+        PChar2IntMapSetItCtor(&it, self);
+        while(PChar2IntMapSetItHasNext(&it)) {
+          PChar2IntMapEntry element = PChar2IntMapSetItNext(&it);
+          if(!PChar2IntMapSetContains(other, element)) PChar2IntMapSetPut(&set, element);
+        }
+        PChar2IntMapSetItCtor(&it, other);
+        while(PChar2IntMapSetItHasNext(&it)) {
+          PChar2IntMapEntry element = PChar2IntMapSetItNext(&it);
+          if(!PChar2IntMapSetContains(self, element)) PChar2IntMapSetPut(&set, element);
+        }
+        PChar2IntMapSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        PChar2IntMapSetRehash(self);
+        /*PChar2IntMapSetDtor(&set);*/
+      }
+      static void PChar2IntMapSetItCtor(PChar2IntMapSetIt* self, PChar2IntMapSet* set) {
+        assert(self);
+        self->set = set;
+        self->bucket_index = 0;
+        PChar2IntMapSetListItCtor(&self->it, &set->buckets[0]);
+      }
+      static int PChar2IntMapSetItHasNext(PChar2IntMapSetIt* self) {
+        assert(self);
+        if(PChar2IntMapSetListItHasNext(&self->it)) {
+          return 1;
+        } else {
+          size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!PChar2IntMapSetListEmpty(&self->set->buckets[i])) {
+              return 1;
+            }
+          }
+          return 0;
+        }
+      }
+      static PChar2IntMapEntry PChar2IntMapSetItNext(PChar2IntMapSetIt* self) {
+        assert(self);
+        assert(PChar2IntMapSetItHasNext(self));
+          if(PChar2IntMapSetListItHasNext(&self->it)) {
+            return PChar2IntMapSetListItNext(&self->it);
+          } else {
+            size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!PChar2IntMapSetListEmpty(&self->set->buckets[i])) {
+            PChar2IntMapSetListItCtor(&self->it, &self->set->buckets[i]);
+              self->bucket_index = i;
+              return PChar2IntMapSetListItNext(&self->it);
+            }
+          }
+          abort();
+        }
+      }
+    
+       void PChar2IntMapCtor(PChar2IntMap* self) {
+        assert(self);
+        PChar2IntMapSetCtor(&self->entries);
+      }
+       void PChar2IntMapDtor(PChar2IntMap* self) {
+        assert(self);
+        PChar2IntMapSetDtor(&self->entries);
+      }
+       PChar2IntMap* PChar2IntMapNew(void) {
+        PChar2IntMap* self = (PChar2IntMap*)malloc(sizeof(PChar2IntMap)); assert(self);
+        PChar2IntMapCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void PChar2IntMapDestroy(PChar2IntMap* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PChar2IntMapDtor(self);
+          free(self);
+        }
+      }
+       void PChar2IntMapRehash(PChar2IntMap* self) {
+        assert(self);
+        PChar2IntMapSetRehash(&self->entries);
+      }
+       PChar2IntMap* PChar2IntMapAssign(PChar2IntMap* self) {
+        assert(self);
+        ++self->ref_count;
+        return self;
+      }
+       void PChar2IntMapPurge(PChar2IntMap* self) {
+        assert(self);
+        PChar2IntMapSetPurge(&self->entries);
+      }
+       size_t PChar2IntMapSize(PChar2IntMap* self) {
+        assert(self);
+        return PChar2IntMapSetSize(&self->entries);
+      }
+       int PChar2IntMapEmpty(PChar2IntMap* self) {
+        assert(self);
+        return PChar2IntMapSetEmpty(&self->entries);
+      }
+       int PChar2IntMapContainsKey(PChar2IntMap* self, const char* key) {
+        int result;
+        PChar2IntMapEntry entry;
+        assert(self);
+        entry = PChar2IntMapEntryAssign(PChar2IntMapEntryKeyOnly(key));
+        result = PChar2IntMapSetContains(&self->entries, entry);
+        PChar2IntMapEntryDtor(entry);
+        return result;
+      }
+       int PChar2IntMapGet(PChar2IntMap* self, const char* key) {
+        int result;
+        PChar2IntMapEntry entry;
+        assert(self);
+        entry = PChar2IntMapEntryAssign(PChar2IntMapEntryKeyOnly(key));
+        assert(PChar2IntMapContainsKey(self, key));
+        result = PChar2IntMapSetGet(&self->entries, entry).value;
+        PChar2IntMapEntryDtor(entry);
+        return result;
+      }
+       int PChar2IntMapPut(PChar2IntMap* self, const char* key, int value) {
+        PChar2IntMapEntry entry = PChar2IntMapEntryAssign(PChar2IntMapEntryKeyValue(key,value));
+        assert(self);
+        if(!PChar2IntMapContainsKey(self, key)) {
+          PChar2IntMapSetPut(&self->entries, entry);
+          PChar2IntMapEntryDtor(entry);
+          return 1;
+        } else {
+          PChar2IntMapEntryDtor(entry);
+          return 0;
+        }
+      }
+       void PChar2IntMapReplace(PChar2IntMap* self, const char* key, int value) {
+        PChar2IntMapEntry entry;
+        assert(self);
+        entry = PChar2IntMapEntryAssign(PChar2IntMapEntryKeyValue(key,value));
+        PChar2IntMapSetReplace(&self->entries, entry);
+        PChar2IntMapEntryDtor(entry);
+      }
+       int PChar2IntMapRemove(PChar2IntMap* self, const char* key) {
+        int removed;
+        PChar2IntMapEntry entry;
+        assert(self);
+        entry = PChar2IntMapEntryAssign(PChar2IntMapEntryKeyOnly(key));
+        removed = PChar2IntMapSetRemove(&self->entries, entry);
+        PChar2IntMapEntryDtor(entry);
+        return removed;
+      }
+       void PChar2IntMapItCtor(PChar2IntMapIt* self, PChar2IntMap* map) {
+        assert(self);
+        assert(map);
+        PChar2IntMapSetItCtor(&self->it, &map->entries);
+      }
+       int PChar2IntMapItHasNext(PChar2IntMapIt* self) {
+        assert(self);
+        return PChar2IntMapSetItHasNext(&self->it);
+      }
+       const char* PChar2IntMapItNextKey(PChar2IntMapIt* self) {
+        assert(self);
+        return PChar2IntMapSetItNext(&self->it).key;
+      }
+       int PChar2IntMapItNextValue(PChar2IntMapIt* self) {
+        assert(self);
+        return PChar2IntMapSetItNext(&self->it).value;
+      }
+       PChar2IntMapEntry PChar2IntMapItNext(PChar2IntMapIt* self) {
+        assert(self);
+        return PChar2IntMapSetItNext(&self->it);
+      }
+    
+       void PCharQueueCtor(PCharQueue* self) {
+        assert(self);
+        self->head_node = self->tail_node = NULL;
+        self->node_count = 0;
+      }
+       void PCharQueueDtor(PCharQueue* self) {
+        PCharQueueNode* node;
+        assert(self);
+        ;
+        node = self->head_node;
+        while(node) {
+          PCharQueueNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+       PCharQueue* PCharQueueNew(void) {
+        PCharQueue* self = (PCharQueue*)malloc(sizeof(PCharQueue)); assert(self);
+        PCharQueueCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void PCharQueueDestroy(PCharQueue* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PCharQueueDtor(self);
+          free(self);
+        }
+      }
+       PCharQueue* PCharQueueAssign(PCharQueue* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void PCharQueuePurge(PCharQueue* self) {
+        PCharQueueDtor(self);
+        PCharQueueCtor(self);
+      }
+       const char* PCharQueueHead(PCharQueue* self) {
+        assert(self);
+        assert(!PCharQueueEmpty(self));
+        return self->head_node->element;
+      }
+       const char* PCharQueueTail(PCharQueue* self) {
+        assert(self);
+        assert(!PCharQueueEmpty(self));
+        return self->tail_node->element;
+      }
+       void PCharQueueChopHead(PCharQueue* self) {
+        PCharQueueNode* node;
+        assert(self);
+        assert(!PCharQueueEmpty(self));
+        node = self->head_node;
+        ;
+        self->head_node = self->head_node->next_node;
+        self->head_node->prev_node = NULL;
+        --self->node_count;
+        free(node);
+      }
+       void PCharQueueChopTail(PCharQueue* self) {
+        PCharQueueNode* node;
+        assert(self);
+        assert(!PCharQueueEmpty(self));
+        node = self->tail_node;
+        ;
+        self->tail_node = self->tail_node->prev_node;
+        self->tail_node->next_node = NULL;
+        --self->node_count;
+        free(node);
+      }
+       void PCharQueueAppend(PCharQueue* self, const char* element) {
+        PCharQueueNode* node;
+        assert(self);
+        node = (PCharQueueNode*)malloc(sizeof(PCharQueueNode)); assert(node);
+        node->element = (element);
+        if(PCharQueueEmpty(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 PCharQueuePrepend(PCharQueue* self, const char* element) {
+        PCharQueueNode* node;
+        assert(self);
+        node = (PCharQueueNode*)malloc(sizeof(PCharQueueNode)); assert(node);
+        node->element = (element);
+        if(PCharQueueEmpty(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 PCharQueueContains(PCharQueue* self, const char* what) {
+        PCharQueueNode* node;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            return 1;
+          }
+          node = node->next_node;
+        }
+        ;
+        return 0;
+      }
+       const char* PCharQueueFind(PCharQueue* self, const char* what) {
+        PCharQueueNode* node;
+        assert(self);
+        what = (what);
+        assert(PCharQueueContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+       int PCharQueueReplace(PCharQueue* self, const char* what, const char* with) {
+        PCharQueueNode* node;
+        assert(self);
+        what = (what);
+        with = (with);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            node->element = (with);
+            ;
+            ;
+            return 1;
+          }
+          node = node->next_node;
+        }
+        ;
+        ;
+        return 0;
+      }
+       int PCharQueueReplaceAll(PCharQueue* self, const char* what, const char* with) {
+        PCharQueueNode* node;
+        int count = 0;
+        assert(self);
+        what = (what);
+        with = (with);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            ;
+            node->element = (with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        ;
+        ;
+        return count;
+      }
+       int PCharQueueRemove(PCharQueue* self, const char* what) {
+        PCharQueueNode* node;
+        int found = 0;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            PCharQueueNode *prev = node->prev_node, *next = node->next_node;
+            ;
+            if(prev && next) {
+              prev->next_node = next;
+              next->prev_node = prev;
+            } else if(prev) {
+              prev->next_node = NULL;
+              self->tail_node = prev;
+            } else {
+              next->prev_node = NULL;
+              self->head_node = next;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          node = node->next_node;
+        }
+        ;
+        return found;
+      }
+       int PCharQueueRemoveAll(PCharQueue* self, const char* what) {
+        PCharQueueNode* node;
+        int count = 0;
+        assert(self);
+        what = (what);
+        node = self->head_node;
+        while(node) {
+          if(PCharEqual(node->element,what)) {
+            PCharQueueNode *prev = node->prev_node, *next = node->next_node;
+            ;
+            if(prev && next) {
+              prev->next_node = next;
+              next->prev_node = prev;
+            } else if(prev) {
+              prev->next_node = NULL;
+              self->tail_node = prev;
+            } else {
+              next->prev_node = NULL;
+              self->head_node = next;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        ;
+        return count;
+      }
+       size_t PCharQueueSize(PCharQueue* self) {
+        assert(self);
+        return self->node_count;
+      }
+       int PCharQueueEmpty(PCharQueue* self) {
+        assert(self);
+        return !self->node_count;
+      }
+       void PCharQueueItCtor(PCharQueueIt* self, PCharQueue* list, int forward) {
+        assert(self);
+        assert(list);
+        self->forward = forward;
+        self->next_node = forward ? list->head_node : list->tail_node;
+      }
+       int PCharQueueItHasNext(PCharQueueIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+       const char* PCharQueueItNext(PCharQueueIt* self) {
+        PCharQueueNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->forward ? self->next_node->next_node : self->next_node->prev_node;
+        return node->element;
+      }
+    
+       void BoxListCtor(BoxList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+       void BoxListDtor(BoxList* self) {
+        BoxListNode* node;
+        assert(self);
+        {
+        BoxListIt it;
+        BoxListItCtor(&it, self);
+        while(BoxListItHasNext(&it)) {
+          Box* e = BoxListItNext(&it);
+          BoxDestroy(e);
+        }
+      };
+        node = self->head_node;
+        while(node) {
+          BoxListNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+       BoxList* BoxListNew(void) {
+        BoxList* self = (BoxList*)malloc(sizeof(BoxList)); assert(self);
+        BoxListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void BoxListDestroy(BoxList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          BoxListDtor(self);
+          free(self);
+        }
+      }
+       BoxList* BoxListAssign(BoxList* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void BoxListPurge(BoxList* self) {
+        BoxListDtor(self);
+        BoxListCtor(self);
+      }
+       Box* BoxListGet(BoxList* self) {
+        assert(self);
+        assert(!BoxListEmpty(self));
+        return self->head_node->element;
+      }
+       void BoxListChop(BoxList* self) {
+        BoxListNode* node;
+        assert(self);
+        assert(!BoxListEmpty(self));
+        node = self->head_node;
+        BoxDestroy(node->element);
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+       void BoxListAdd(BoxList* self, Box* element) {
+        BoxListNode* node;
+        assert(self);
+        node = (BoxListNode*)malloc(sizeof(BoxListNode)); assert(node);
+        node->element = BoxAssign(element);
+        node->next_node = self->head_node;
+        self->head_node = node;
+        ++self->node_count;
+      }
+       int BoxListContains(BoxList* self, Box* what) {
+        BoxListNode* node;
+        assert(self);
+        what = BoxAssign(what);
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(what);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        return 0;
+      }
+       Box* BoxListFind(BoxList* self, Box* what) {
+        BoxListNode* node;
+        assert(self);
+        what = BoxAssign(what);
+        assert(BoxListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(what);
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+       int BoxListReplace(BoxList* self, Box* what, Box* with) {
+        BoxListNode* node;
+        assert(self);
+        what = BoxAssign(what);
+        with = BoxAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            node->element = BoxAssign(with);
+            BoxDestroy(what);
+            BoxDestroy(with);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        BoxDestroy(with);
+        return 0;
+      }
+       int BoxListReplaceAll(BoxList* self, Box* what, Box* with) {
+        BoxListNode* node;
+        int count = 0;
+        assert(self);
+        what = BoxAssign(what);
+        with = BoxAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            node->element = BoxAssign(with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        BoxDestroy(with);
+        return count;
+      }
+       int BoxListRemove(BoxList* self, Box* what) {
+        BoxListNode* node;
+        BoxListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = BoxAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        return found;
+      }
+       int BoxListRemoveAll(BoxList* self, Box* what) {
+        BoxListNode* node;
+        BoxListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = BoxAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        return count;
+      }
+       size_t BoxListSize(BoxList* self) {
+        assert(self);
+        return self->node_count;
+      }
+       int BoxListEmpty(BoxList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+       void BoxListItCtor(BoxListIt* self, BoxList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+       int BoxListItHasNext(BoxListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+       Box* BoxListItNext(BoxListIt* self) {
+        BoxListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+       void IntVectorCtor(IntVector* self, size_t element_count) {
+        assert(self);
+        assert(element_count > 0);
+        self->element_count = element_count;
+        self->values = (int*)calloc(element_count, sizeof(int)); assert(self->values);
+        ;
+      }
+       void IntVectorDtor(IntVector* self) {
+        assert(self);
+        ;
+        free(self->values);
+      }
+       IntVector* IntVectorNew(size_t element_count) {
+        IntVector* self = (IntVector*)malloc(sizeof(IntVector)); assert(self);
+        IntVectorCtor(self, element_count);
+        self->ref_count = 0;
+        return self;
+      }
+       void IntVectorDestroy(IntVector* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          IntVectorDtor(self);
+          free(self);
+        }
+      }
+       IntVector* IntVectorAssign(IntVector* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void IntVectorResize(IntVector* self, size_t element_count) {
+        assert(self);
+        if(self->element_count != element_count) {
+          size_t count;
+          int* values = (int*)calloc(element_count, sizeof(int)); assert(values);
+          if(self->element_count > element_count) {
+            ;
+            count = element_count;
+          } else {
+            ;
+            count = self->element_count;
+          }
+          {
+            size_t index;
+            for(index = 0; index < count; ++index) {
+              values[index] = self->values[index];
+            }
+          }
+          free(self->values);
+          self->element_count = element_count;
+          self->values = values;
+        }
+      }
+       int IntVectorWithin(IntVector* self, size_t index) {
+        assert(self);
+        return index < self->element_count;
+      }
+       void IntVectorItCtor(IntVectorIt* self, IntVector* vector) {
+        assert(self);
+        assert(vector);
+        self->vector = vector;
+        self->index = 0;
+      }
+       int IntVectorItHasNext(IntVectorIt* self) {
+        assert(self);
+        return self->index < IntVectorSize(self->vector);
+      }
+       int IntVectorItNext(IntVectorIt* self) {
+        assert(self);
+        return IntVectorGet(self->vector, self->index++);
+      }
+    
+      static int IntVectorComparator(const void* lp, const void* rp) {
+        return (*(int*)lp > *(int*)rp ? +1 : (*(int*)lp < *(int*)rp ? -1 : 0));
+      }
+       void IntVectorSort(IntVector* self) {
+        assert(self);
+        qsort(self->values, self->element_count, sizeof(int), IntVectorComparator);
+      }
+    
+       void BoxVectorCtor(BoxVector* self, size_t element_count) {
+        assert(self);
+        assert(element_count > 0);
+        self->element_count = element_count;
+        self->values = (Box**)calloc(element_count, sizeof(Box*)); assert(self->values);
+        {
+        size_t index;
+        for(index = 0; index <= self->element_count-1; ++index) self->values[index] = BoxAssign(BoxNew());
+      };
+      }
+       void BoxVectorDtor(BoxVector* self) {
+        assert(self);
+        {
+        size_t index;
+        for(index = 0; index <= self->element_count-1; ++index) BoxDestroy(self->values[index]);
+      };
+        free(self->values);
+      }
+       BoxVector* BoxVectorNew(size_t element_count) {
+        BoxVector* self = (BoxVector*)malloc(sizeof(BoxVector)); assert(self);
+        BoxVectorCtor(self, element_count);
+        self->ref_count = 0;
+        return self;
+      }
+       void BoxVectorDestroy(BoxVector* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          BoxVectorDtor(self);
+          free(self);
+        }
+      }
+       BoxVector* BoxVectorAssign(BoxVector* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void BoxVectorResize(BoxVector* self, size_t element_count) {
+        assert(self);
+        if(self->element_count != element_count) {
+          size_t count;
+          Box** values = (Box**)calloc(element_count, sizeof(Box*)); assert(values);
+          if(self->element_count > element_count) {
+            {
+        size_t index;
+        for(index = element_count; index <= self->element_count-1; ++index) BoxDestroy(self->values[index]);
+      };
+            count = element_count;
+          } else {
+            {
+        size_t index;
+        for(index = self->element_count; index <= element_count-1; ++index) values[index] = BoxAssign(BoxNew());
+      };
+            count = self->element_count;
+          }
+          {
+            size_t index;
+            for(index = 0; index < count; ++index) {
+              values[index] = self->values[index];
+            }
+          }
+          free(self->values);
+          self->element_count = element_count;
+          self->values = values;
+        }
+      }
+       int BoxVectorWithin(BoxVector* self, size_t index) {
+        assert(self);
+        return index < self->element_count;
+      }
+       void BoxVectorItCtor(BoxVectorIt* self, BoxVector* vector) {
+        assert(self);
+        assert(vector);
+        self->vector = vector;
+        self->index = 0;
+      }
+       int BoxVectorItHasNext(BoxVectorIt* self) {
+        assert(self);
+        return self->index < BoxVectorSize(self->vector);
+      }
+       Box* BoxVectorItNext(BoxVectorIt* self) {
+        assert(self);
+        return BoxVectorGet(self->vector, self->index++);
+      }
+    
+      static void BoxSetListCtor(BoxSetList*);
+      static void BoxSetListDtor(BoxSetList*);
+      static void BoxSetListPurge(BoxSetList*);
+      static BoxSetList* BoxSetListNew(void);
+      static void BoxSetListDestroy(BoxSetList*);
+      static BoxSetList* BoxSetListAssign(BoxSetList*);
+      static Box* BoxSetListGet(BoxSetList*);
+      static void BoxSetListAdd(BoxSetList*, Box*);
+      static void BoxSetListChop(BoxSetList*);
+      static int BoxSetListContains(BoxSetList*, Box*);
+      static Box* BoxSetListFind(BoxSetList*, Box*);
+      static int BoxSetListReplace(BoxSetList*, Box*, Box*);
+      static int BoxSetListReplaceAll(BoxSetList*, Box*, Box*);
+      static int BoxSetListRemove(BoxSetList*, Box*);
+      static int BoxSetListRemoveAll(BoxSetList*, Box*);
+      static size_t BoxSetListSize(BoxSetList*);
+      static int BoxSetListEmpty(BoxSetList*);
+      static void BoxSetListItCtor(BoxSetListIt*, BoxSetList*);
+      static int BoxSetListItHasNext(BoxSetListIt*);
+      static Box* BoxSetListItNext(BoxSetListIt*);
+    
+      static void BoxSetListCtor(BoxSetList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+      static void BoxSetListDtor(BoxSetList* self) {
+        BoxSetListNode* node;
+        assert(self);
+        {
+        BoxSetListIt it;
+        BoxSetListItCtor(&it, self);
+        while(BoxSetListItHasNext(&it)) {
+          Box* e = BoxSetListItNext(&it);
+          BoxDestroy(e);
+        }
+      };
+        node = self->head_node;
+        while(node) {
+          BoxSetListNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+      static BoxSetList* BoxSetListNew(void) {
+        BoxSetList* self = (BoxSetList*)malloc(sizeof(BoxSetList)); assert(self);
+        BoxSetListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void BoxSetListDestroy(BoxSetList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          BoxSetListDtor(self);
+          free(self);
+        }
+      }
+      static BoxSetList* BoxSetListAssign(BoxSetList* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void BoxSetListPurge(BoxSetList* self) {
+        BoxSetListDtor(self);
+        BoxSetListCtor(self);
+      }
+      static Box* BoxSetListGet(BoxSetList* self) {
+        assert(self);
+        assert(!BoxSetListEmpty(self));
+        return self->head_node->element;
+      }
+      static void BoxSetListChop(BoxSetList* self) {
+        BoxSetListNode* node;
+        assert(self);
+        assert(!BoxSetListEmpty(self));
+        node = self->head_node;
+        BoxDestroy(node->element);
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+      static void BoxSetListAdd(BoxSetList* self, Box* element) {
+        BoxSetListNode* node;
+        assert(self);
+        node = (BoxSetListNode*)malloc(sizeof(BoxSetListNode)); assert(node);
+        node->element = BoxAssign(element);
+        node->next_node = self->head_node;
+        self->head_node = node;
+        ++self->node_count;
+      }
+      static int BoxSetListContains(BoxSetList* self, Box* what) {
+        BoxSetListNode* node;
+        assert(self);
+        what = BoxAssign(what);
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(what);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        return 0;
+      }
+      static Box* BoxSetListFind(BoxSetList* self, Box* what) {
+        BoxSetListNode* node;
+        assert(self);
+        what = BoxAssign(what);
+        assert(BoxSetListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(what);
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+      static int BoxSetListReplace(BoxSetList* self, Box* what, Box* with) {
+        BoxSetListNode* node;
+        assert(self);
+        what = BoxAssign(what);
+        with = BoxAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            node->element = BoxAssign(with);
+            BoxDestroy(what);
+            BoxDestroy(with);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        BoxDestroy(with);
+        return 0;
+      }
+      static int BoxSetListReplaceAll(BoxSetList* self, Box* what, Box* with) {
+        BoxSetListNode* node;
+        int count = 0;
+        assert(self);
+        what = BoxAssign(what);
+        with = BoxAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            node->element = BoxAssign(with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        BoxDestroy(with);
+        return count;
+      }
+      static int BoxSetListRemove(BoxSetList* self, Box* what) {
+        BoxSetListNode* node;
+        BoxSetListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = BoxAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        return found;
+      }
+      static int BoxSetListRemoveAll(BoxSetList* self, Box* what) {
+        BoxSetListNode* node;
+        BoxSetListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = BoxAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(BoxEqual(node->element,what)) {
+            BoxDestroy(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        BoxDestroy(what);
+        return count;
+      }
+      static size_t BoxSetListSize(BoxSetList* self) {
+        assert(self);
+        return self->node_count;
+      }
+      static int BoxSetListEmpty(BoxSetList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+      static void BoxSetListItCtor(BoxSetListIt* self, BoxSetList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+      static int BoxSetListItHasNext(BoxSetListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+      static Box* BoxSetListItNext(BoxSetListIt* self) {
+        BoxSetListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+       void BoxSetCtor(BoxSet* 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;
+        BoxSetRehash(self);
+      }
+       void BoxSetDtor(BoxSet* self) {
+        size_t i;
+        assert(self);
+        for(i = 0; i < self->bucket_count; ++i) {
+          BoxSetListDtor(&self->buckets[i]);
+        }
+        free(self->buckets);
+      }
+       BoxSet* BoxSetNew(void) {
+        BoxSet* self = (BoxSet*)malloc(sizeof(BoxSet)); assert(self);
+        BoxSetCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void BoxSetDestroy(BoxSet* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          BoxSetDtor(self);
+          free(self);
+        }
+      }
+       BoxSet* BoxSetAssign(BoxSet* self) {
+        ++self->ref_count;
+        return self;
+      }
+       void BoxSetPurge(BoxSet* self) {
+        assert(self);
+        BoxSetDtor(self);
+        self->buckets = NULL;
+        BoxSetRehash(self);
+      }
+       void BoxSetRehash(BoxSet* self) {
+        BoxSetList* buckets;
+        size_t i, 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 = (BoxSetList*)malloc(bucket_count*sizeof(BoxSetList)); assert(buckets);
+        for(i = 0; i < bucket_count; ++i) {
+          BoxSetListCtor(&buckets[i]);
+        }
+        if(self->buckets) {
+          BoxSetIt it;
+          BoxSetItCtor(&it, self);
+          while(BoxSetItHasNext(&it)) {
+            BoxSetList* bucket;
+            Box* element = BoxSetItNext(&it);
+            bucket = &buckets[BoxHash(element) % bucket_count];
+            BoxSetListAdd(bucket, element);
+          }
+          BoxSetDtor(self);
+        }
+        self->buckets = buckets;
+        self->bucket_count = bucket_count;
+        self->size = size;
+      }
+       int BoxSetContains(BoxSet* self, Box* element) {
+        int result;
+        assert(self);
+        element = BoxAssign(element);
+        result = BoxSetListContains(&self->buckets[BoxHash(element) % self->bucket_count], element);
+        BoxDestroy(element);
+        return result;
+      }
+       Box* BoxSetGet(BoxSet* self, Box* element) {
+        Box* result;
+        assert(self);
+        element = BoxAssign(element);
+        assert(BoxSetContains(self, element));
+        result = BoxSetListFind(&self->buckets[BoxHash(element) % self->bucket_count], element);
+        BoxDestroy(element);
+        return result;
+      }
+       size_t BoxSetSize(BoxSet* self) {
+        assert(self);
+        return self->size;
+      }
+       int BoxSetEmpty(BoxSet* self) {
+        assert(self);
+        return !self->size;
+      }
+       int BoxSetPut(BoxSet* self, Box* element) {
+        int contained = 1;
+        BoxSetList* bucket;
+        assert(self);
+        element = BoxAssign(element);
+        bucket = &self->buckets[BoxHash(element) % self->bucket_count];
+        if(!BoxSetListContains(bucket, element)) {
+          BoxSetListAdd(bucket, element);
+          ++self->size;
+          contained = 0;
+          BoxSetRehash(self);
+        }
+        BoxDestroy(element);
+        return contained;
+      }
+       void BoxSetReplace(BoxSet* self, Box* element) {
+        BoxSetList* bucket;
+        assert(self);
+        element = BoxAssign(element);
+        bucket = &self->buckets[BoxHash(element) % self->bucket_count];
+        if(!BoxSetListReplace(bucket, element, element)) {
+          BoxSetListAdd(bucket, element);
+          ++self->size;
+          BoxSetRehash(self);
+        }
+        BoxDestroy(element);
+      }
+       int BoxSetRemove(BoxSet* self, Box* what) {
+        int removed = 0;
+        BoxSetList* bucket;
+        assert(self);
+        what = BoxAssign(what);
+        bucket = &self->buckets[BoxHash(what) % self->bucket_count];
+        if(BoxSetListRemove(bucket, what)) {
+          --self->size;
+          removed = 1;
+          BoxSetRehash(self);
+        }
+        BoxDestroy(what);
+        return removed;
+      }
+       void BoxSetNot(BoxSet* self, BoxSet* other) {
+        BoxSetIt it;
+        assert(self);
+        assert(other);
+        BoxSetItCtor(&it, other);
+        while(BoxSetItHasNext(&it)) {
+          BoxSetRemove(self, BoxSetItNext(&it));
+        }
+        BoxSetRehash(self);
+      }
+       void BoxSetOr(BoxSet* self, BoxSet* other) {
+        BoxSetIt it;
+        assert(self);
+        assert(other);
+        BoxSetItCtor(&it, other);
+        while(BoxSetItHasNext(&it)) {
+          BoxSetPut(self, BoxSetItNext(&it));
+        }
+        BoxSetRehash(self);
+      }
+       void BoxSetAnd(BoxSet* self, BoxSet* other) {
+        BoxSetIt it;
+        BoxSet set;
+        assert(self);
+        assert(other);
+        BoxSetCtor(&set);
+        BoxSetItCtor(&it, self);
+        while(BoxSetItHasNext(&it)) {
+          Box* element = BoxSetItNext(&it);
+          if(BoxSetContains(other, element)) BoxSetPut(&set, element);
+        }
+        BoxSetItCtor(&it, other);
+        while(BoxSetItHasNext(&it)) {
+          Box* element = BoxSetItNext(&it);
+          if(BoxSetContains(self, element)) BoxSetPut(&set, element);
+        }
+        BoxSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        BoxSetRehash(self);
+        /*BoxSetDtor(&set);*/
+      }
+       void BoxSetXor(BoxSet* self, BoxSet* other) {
+        BoxSetIt it;
+        BoxSet set;
+        assert(self);
+        assert(other);
+        BoxSetCtor(&set);
+        BoxSetItCtor(&it, self);
+        while(BoxSetItHasNext(&it)) {
+          Box* element = BoxSetItNext(&it);
+          if(!BoxSetContains(other, element)) BoxSetPut(&set, element);
+        }
+        BoxSetItCtor(&it, other);
+        while(BoxSetItHasNext(&it)) {
+          Box* element = BoxSetItNext(&it);
+          if(!BoxSetContains(self, element)) BoxSetPut(&set, element);
+        }
+        BoxSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        BoxSetRehash(self);
+        /*BoxSetDtor(&set);*/
+      }
+       void BoxSetItCtor(BoxSetIt* self, BoxSet* set) {
+        assert(self);
+        self->set = set;
+        self->bucket_index = 0;
+        BoxSetListItCtor(&self->it, &set->buckets[0]);
+      }
+       int BoxSetItHasNext(BoxSetIt* self) {
+        assert(self);
+        if(BoxSetListItHasNext(&self->it)) {
+          return 1;
+        } else {
+          size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!BoxSetListEmpty(&self->set->buckets[i])) {
+              return 1;
+            }
+          }
+          return 0;
+        }
+      }
+       Box* BoxSetItNext(BoxSetIt* self) {
+        assert(self);
+        assert(BoxSetItHasNext(self));
+          if(BoxSetListItHasNext(&self->it)) {
+            return BoxSetListItNext(&self->it);
+          } else {
+            size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!BoxSetListEmpty(&self->set->buckets[i])) {
+            BoxSetListItCtor(&self->it, &self->set->buckets[i]);
+              self->bucket_index = i;
+              return BoxSetListItNext(&self->it);
+            }
+          }
+          abort();
+        }
+      }
+    
+      static PChar2IntVectorMapEntry PChar2IntVectorMapEntryKeyOnly(const char* key) {
+        PChar2IntVectorMapEntry entry;
+        entry.key = key;
+        entry.valid_value = 0;
+        return entry;
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapEntryKeyValue(const char* key, IntVector* value) {
+        PChar2IntVectorMapEntry entry;
+        entry.key = key;
+        entry.value = value;
+        entry.valid_value = 1;
+        return entry;
+      }
+      static size_t PChar2IntVectorMapEntryHash(PChar2IntVectorMapEntry entry) {
+        return PCharHash(entry.key);
+      }
+      static int PChar2IntVectorMapEntryEqual(PChar2IntVectorMapEntry lt, PChar2IntVectorMapEntry rt) {
+        return PCharEqual(lt.key,rt.key);
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapEntryAssign(PChar2IntVectorMapEntry entry) {
+        entry.key = (entry.key);
+        if(entry.valid_value) entry.value = IntVectorAssign(entry.value);
+        return entry;
+      }
+      static void PChar2IntVectorMapEntryDtor(PChar2IntVectorMapEntry entry) {
+        ;
+        if(entry.valid_value) IntVectorDestroy(entry.value);
+      }
+    
+      static void PChar2IntVectorMapSetCtor(PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetDtor(PChar2IntVectorMapSet*);
+      static PChar2IntVectorMapSet* PChar2IntVectorMapSetNew(void);
+      static void PChar2IntVectorMapSetDestroy(PChar2IntVectorMapSet*);
+      static PChar2IntVectorMapSet* PChar2IntVectorMapSetAssign(PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetPurge(PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetRehash(PChar2IntVectorMapSet*);
+      static int PChar2IntVectorMapSetContains(PChar2IntVectorMapSet*, PChar2IntVectorMapEntry);
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetGet(PChar2IntVectorMapSet*, PChar2IntVectorMapEntry);
+      static size_t PChar2IntVectorMapSetSize(PChar2IntVectorMapSet*);
+      static int PChar2IntVectorMapSetEmpty(PChar2IntVectorMapSet*);
+      static int PChar2IntVectorMapSetPut(PChar2IntVectorMapSet*, PChar2IntVectorMapEntry);
+      static void PChar2IntVectorMapSetReplace(PChar2IntVectorMapSet*, PChar2IntVectorMapEntry);
+      static int PChar2IntVectorMapSetRemove(PChar2IntVectorMapSet*, PChar2IntVectorMapEntry);
+      static void PChar2IntVectorMapSetNot(PChar2IntVectorMapSet*, PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetAnd(PChar2IntVectorMapSet*, PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetOr(PChar2IntVectorMapSet*, PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetXor(PChar2IntVectorMapSet*, PChar2IntVectorMapSet*);
+      static void PChar2IntVectorMapSetItCtor(PChar2IntVectorMapSetIt*, PChar2IntVectorMapSet*);
+      static int PChar2IntVectorMapSetItHasNext(PChar2IntVectorMapSetIt*);
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetItNext(PChar2IntVectorMapSetIt*);
+    
+      static void PChar2IntVectorMapSetListCtor(PChar2IntVectorMapSetList*);
+      static void PChar2IntVectorMapSetListDtor(PChar2IntVectorMapSetList*);
+      static void PChar2IntVectorMapSetListPurge(PChar2IntVectorMapSetList*);
+      static PChar2IntVectorMapSetList* PChar2IntVectorMapSetListNew(void);
+      static void PChar2IntVectorMapSetListDestroy(PChar2IntVectorMapSetList*);
+      static PChar2IntVectorMapSetList* PChar2IntVectorMapSetListAssign(PChar2IntVectorMapSetList*);
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetListGet(PChar2IntVectorMapSetList*);
+      static void PChar2IntVectorMapSetListAdd(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry);
+      static void PChar2IntVectorMapSetListChop(PChar2IntVectorMapSetList*);
+      static int PChar2IntVectorMapSetListContains(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry);
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetListFind(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry);
+      static int PChar2IntVectorMapSetListReplace(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry, PChar2IntVectorMapEntry);
+      static int PChar2IntVectorMapSetListReplaceAll(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry, PChar2IntVectorMapEntry);
+      static int PChar2IntVectorMapSetListRemove(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry);
+      static int PChar2IntVectorMapSetListRemoveAll(PChar2IntVectorMapSetList*, PChar2IntVectorMapEntry);
+      static size_t PChar2IntVectorMapSetListSize(PChar2IntVectorMapSetList*);
+      static int PChar2IntVectorMapSetListEmpty(PChar2IntVectorMapSetList*);
+      static void PChar2IntVectorMapSetListItCtor(PChar2IntVectorMapSetListIt*, PChar2IntVectorMapSetList*);
+      static int PChar2IntVectorMapSetListItHasNext(PChar2IntVectorMapSetListIt*);
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetListItNext(PChar2IntVectorMapSetListIt*);
+    
+      static void PChar2IntVectorMapSetListCtor(PChar2IntVectorMapSetList* self) {
+        assert(self);
+        self->head_node = NULL;
+        self->node_count = 0;
+      }
+      static void PChar2IntVectorMapSetListDtor(PChar2IntVectorMapSetList* self) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        {
+        PChar2IntVectorMapSetListIt it;
+        PChar2IntVectorMapSetListItCtor(&it, self);
+        while(PChar2IntVectorMapSetListItHasNext(&it)) {
+          PChar2IntVectorMapEntry e = PChar2IntVectorMapSetListItNext(&it);
+          PChar2IntVectorMapEntryDtor(e);
+        }
+      };
+        node = self->head_node;
+        while(node) {
+          PChar2IntVectorMapSetListNode* this_node = node;
+          node = node->next_node;
+          free(this_node);
+        }
+      }
+      static PChar2IntVectorMapSetList* PChar2IntVectorMapSetListNew(void) {
+        PChar2IntVectorMapSetList* self = (PChar2IntVectorMapSetList*)malloc(sizeof(PChar2IntVectorMapSetList)); assert(self);
+        PChar2IntVectorMapSetListCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void PChar2IntVectorMapSetListDestroy(PChar2IntVectorMapSetList* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PChar2IntVectorMapSetListDtor(self);
+          free(self);
+        }
+      }
+      static PChar2IntVectorMapSetList* PChar2IntVectorMapSetListAssign(PChar2IntVectorMapSetList* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void PChar2IntVectorMapSetListPurge(PChar2IntVectorMapSetList* self) {
+        PChar2IntVectorMapSetListDtor(self);
+        PChar2IntVectorMapSetListCtor(self);
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetListGet(PChar2IntVectorMapSetList* self) {
+        assert(self);
+        assert(!PChar2IntVectorMapSetListEmpty(self));
+        return self->head_node->element;
+      }
+      static void PChar2IntVectorMapSetListChop(PChar2IntVectorMapSetList* self) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        assert(!PChar2IntVectorMapSetListEmpty(self));
+        node = self->head_node;
+        PChar2IntVectorMapEntryDtor(node->element);
+        self->head_node = self->head_node->next_node;
+        --self->node_count;
+        free(node);
+      }
+      static void PChar2IntVectorMapSetListAdd(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry element) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        node = (PChar2IntVectorMapSetListNode*)malloc(sizeof(PChar2IntVectorMapSetListNode)); assert(node);
+        node->element = PChar2IntVectorMapEntryAssign(element);
+        node->next_node = self->head_node;
+        self->head_node = node;
+        ++self->node_count;
+      }
+      static int PChar2IntVectorMapSetListContains(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry what) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntVectorMapEntryEqual(node->element,what)) {
+            PChar2IntVectorMapEntryDtor(what);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        PChar2IntVectorMapEntryDtor(what);
+        return 0;
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetListFind(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry what) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        assert(PChar2IntVectorMapSetListContains(self, what));
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntVectorMapEntryEqual(node->element,what)) {
+            PChar2IntVectorMapEntryDtor(what);
+            return node->element;
+          }
+          node = node->next_node;
+        }
+        abort();
+      }
+      static int PChar2IntVectorMapSetListReplace(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry what, PChar2IntVectorMapEntry with) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        with = PChar2IntVectorMapEntryAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntVectorMapEntryEqual(node->element,what)) {
+            PChar2IntVectorMapEntryDtor(node->element);
+            node->element = PChar2IntVectorMapEntryAssign(with);
+            PChar2IntVectorMapEntryDtor(what);
+            PChar2IntVectorMapEntryDtor(with);
+            return 1;
+          }
+          node = node->next_node;
+        }
+        PChar2IntVectorMapEntryDtor(what);
+        PChar2IntVectorMapEntryDtor(with);
+        return 0;
+      }
+      static int PChar2IntVectorMapSetListReplaceAll(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry what, PChar2IntVectorMapEntry with) {
+        PChar2IntVectorMapSetListNode* node;
+        int count = 0;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        with = PChar2IntVectorMapEntryAssign(with);
+        node = self->head_node;
+        while(node) {
+          if(PChar2IntVectorMapEntryEqual(node->element,what)) {
+            PChar2IntVectorMapEntryDtor(node->element);
+            node->element = PChar2IntVectorMapEntryAssign(with);
+            ++count;
+          }
+          node = node->next_node;
+        }
+        PChar2IntVectorMapEntryDtor(what);
+        PChar2IntVectorMapEntryDtor(with);
+        return count;
+      }
+      static int PChar2IntVectorMapSetListRemove(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry what) {
+        PChar2IntVectorMapSetListNode* node;
+        PChar2IntVectorMapSetListNode* prev_node;
+        int found = 0;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(PChar2IntVectorMapEntryEqual(node->element,what)) {
+            PChar2IntVectorMapEntryDtor(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            found = 1;
+            break;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        PChar2IntVectorMapEntryDtor(what);
+        return found;
+      }
+      static int PChar2IntVectorMapSetListRemoveAll(PChar2IntVectorMapSetList* self, PChar2IntVectorMapEntry what) {
+        PChar2IntVectorMapSetListNode* node;
+        PChar2IntVectorMapSetListNode* prev_node;
+        int count = 0;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        node = self->head_node;
+        prev_node = NULL;
+        while(node) {
+          if(PChar2IntVectorMapEntryEqual(node->element,what)) {
+            PChar2IntVectorMapEntryDtor(node->element);
+            if(prev_node) {
+              prev_node->next_node = node->next_node ? node->next_node : NULL;
+            } else {
+              self->head_node = node->next_node ? node->next_node : NULL;
+            }
+            --self->node_count;
+            free(node);
+            ++count;
+          }
+          prev_node = node;
+          node = node->next_node;
+        }
+        PChar2IntVectorMapEntryDtor(what);
+        return count;
+      }
+      static size_t PChar2IntVectorMapSetListSize(PChar2IntVectorMapSetList* self) {
+        assert(self);
+        return self->node_count;
+      }
+      static int PChar2IntVectorMapSetListEmpty(PChar2IntVectorMapSetList* self) {
+        assert(self);
+        return !self->node_count;
+      }
+      static void PChar2IntVectorMapSetListItCtor(PChar2IntVectorMapSetListIt* self, PChar2IntVectorMapSetList* list) {
+        assert(self);
+        assert(list);
+        self->next_node = list->head_node;
+      }
+      static int PChar2IntVectorMapSetListItHasNext(PChar2IntVectorMapSetListIt* self) {
+        assert(self);
+        return self->next_node != NULL;
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetListItNext(PChar2IntVectorMapSetListIt* self) {
+        PChar2IntVectorMapSetListNode* node;
+        assert(self);
+        node = self->next_node;
+        self->next_node = self->next_node->next_node;
+        return node->element;
+      }
+    
+      static void PChar2IntVectorMapSetCtor(PChar2IntVectorMapSet* 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;
+        PChar2IntVectorMapSetRehash(self);
+      }
+      static void PChar2IntVectorMapSetDtor(PChar2IntVectorMapSet* self) {
+        size_t i;
+        assert(self);
+        for(i = 0; i < self->bucket_count; ++i) {
+          PChar2IntVectorMapSetListDtor(&self->buckets[i]);
+        }
+        free(self->buckets);
+      }
+      static PChar2IntVectorMapSet* PChar2IntVectorMapSetNew(void) {
+        PChar2IntVectorMapSet* self = (PChar2IntVectorMapSet*)malloc(sizeof(PChar2IntVectorMapSet)); assert(self);
+        PChar2IntVectorMapSetCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+      static void PChar2IntVectorMapSetDestroy(PChar2IntVectorMapSet* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PChar2IntVectorMapSetDtor(self);
+          free(self);
+        }
+      }
+      static PChar2IntVectorMapSet* PChar2IntVectorMapSetAssign(PChar2IntVectorMapSet* self) {
+        ++self->ref_count;
+        return self;
+      }
+      static void PChar2IntVectorMapSetPurge(PChar2IntVectorMapSet* self) {
+        assert(self);
+        PChar2IntVectorMapSetDtor(self);
+        self->buckets = NULL;
+        PChar2IntVectorMapSetRehash(self);
+      }
+      static void PChar2IntVectorMapSetRehash(PChar2IntVectorMapSet* self) {
+        PChar2IntVectorMapSetList* buckets;
+        size_t i, 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 = (PChar2IntVectorMapSetList*)malloc(bucket_count*sizeof(PChar2IntVectorMapSetList)); assert(buckets);
+        for(i = 0; i < bucket_count; ++i) {
+          PChar2IntVectorMapSetListCtor(&buckets[i]);
+        }
+        if(self->buckets) {
+          PChar2IntVectorMapSetIt it;
+          PChar2IntVectorMapSetItCtor(&it, self);
+          while(PChar2IntVectorMapSetItHasNext(&it)) {
+            PChar2IntVectorMapSetList* bucket;
+            PChar2IntVectorMapEntry element = PChar2IntVectorMapSetItNext(&it);
+            bucket = &buckets[PChar2IntVectorMapEntryHash(element) % bucket_count];
+            PChar2IntVectorMapSetListAdd(bucket, element);
+          }
+          PChar2IntVectorMapSetDtor(self);
+        }
+        self->buckets = buckets;
+        self->bucket_count = bucket_count;
+        self->size = size;
+      }
+      static int PChar2IntVectorMapSetContains(PChar2IntVectorMapSet* self, PChar2IntVectorMapEntry element) {
+        int result;
+        assert(self);
+        element = PChar2IntVectorMapEntryAssign(element);
+        result = PChar2IntVectorMapSetListContains(&self->buckets[PChar2IntVectorMapEntryHash(element) % self->bucket_count], element);
+        PChar2IntVectorMapEntryDtor(element);
+        return result;
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetGet(PChar2IntVectorMapSet* self, PChar2IntVectorMapEntry element) {
+        PChar2IntVectorMapEntry result;
+        assert(self);
+        element = PChar2IntVectorMapEntryAssign(element);
+        assert(PChar2IntVectorMapSetContains(self, element));
+        result = PChar2IntVectorMapSetListFind(&self->buckets[PChar2IntVectorMapEntryHash(element) % self->bucket_count], element);
+        PChar2IntVectorMapEntryDtor(element);
+        return result;
+      }
+      static size_t PChar2IntVectorMapSetSize(PChar2IntVectorMapSet* self) {
+        assert(self);
+        return self->size;
+      }
+      static int PChar2IntVectorMapSetEmpty(PChar2IntVectorMapSet* self) {
+        assert(self);
+        return !self->size;
+      }
+      static int PChar2IntVectorMapSetPut(PChar2IntVectorMapSet* self, PChar2IntVectorMapEntry element) {
+        int contained = 1;
+        PChar2IntVectorMapSetList* bucket;
+        assert(self);
+        element = PChar2IntVectorMapEntryAssign(element);
+        bucket = &self->buckets[PChar2IntVectorMapEntryHash(element) % self->bucket_count];
+        if(!PChar2IntVectorMapSetListContains(bucket, element)) {
+          PChar2IntVectorMapSetListAdd(bucket, element);
+          ++self->size;
+          contained = 0;
+          PChar2IntVectorMapSetRehash(self);
+        }
+        PChar2IntVectorMapEntryDtor(element);
+        return contained;
+      }
+      static void PChar2IntVectorMapSetReplace(PChar2IntVectorMapSet* self, PChar2IntVectorMapEntry element) {
+        PChar2IntVectorMapSetList* bucket;
+        assert(self);
+        element = PChar2IntVectorMapEntryAssign(element);
+        bucket = &self->buckets[PChar2IntVectorMapEntryHash(element) % self->bucket_count];
+        if(!PChar2IntVectorMapSetListReplace(bucket, element, element)) {
+          PChar2IntVectorMapSetListAdd(bucket, element);
+          ++self->size;
+          PChar2IntVectorMapSetRehash(self);
+        }
+        PChar2IntVectorMapEntryDtor(element);
+      }
+      static int PChar2IntVectorMapSetRemove(PChar2IntVectorMapSet* self, PChar2IntVectorMapEntry what) {
+        int removed = 0;
+        PChar2IntVectorMapSetList* bucket;
+        assert(self);
+        what = PChar2IntVectorMapEntryAssign(what);
+        bucket = &self->buckets[PChar2IntVectorMapEntryHash(what) % self->bucket_count];
+        if(PChar2IntVectorMapSetListRemove(bucket, what)) {
+          --self->size;
+          removed = 1;
+          PChar2IntVectorMapSetRehash(self);
+        }
+        PChar2IntVectorMapEntryDtor(what);
+        return removed;
+      }
+      static void PChar2IntVectorMapSetNot(PChar2IntVectorMapSet* self, PChar2IntVectorMapSet* other) {
+        PChar2IntVectorMapSetIt it;
+        assert(self);
+        assert(other);
+        PChar2IntVectorMapSetItCtor(&it, other);
+        while(PChar2IntVectorMapSetItHasNext(&it)) {
+          PChar2IntVectorMapSetRemove(self, PChar2IntVectorMapSetItNext(&it));
+        }
+        PChar2IntVectorMapSetRehash(self);
+      }
+      static void PChar2IntVectorMapSetOr(PChar2IntVectorMapSet* self, PChar2IntVectorMapSet* other) {
+        PChar2IntVectorMapSetIt it;
+        assert(self);
+        assert(other);
+        PChar2IntVectorMapSetItCtor(&it, other);
+        while(PChar2IntVectorMapSetItHasNext(&it)) {
+          PChar2IntVectorMapSetPut(self, PChar2IntVectorMapSetItNext(&it));
+        }
+        PChar2IntVectorMapSetRehash(self);
+      }
+      static void PChar2IntVectorMapSetAnd(PChar2IntVectorMapSet* self, PChar2IntVectorMapSet* other) {
+        PChar2IntVectorMapSetIt it;
+        PChar2IntVectorMapSet set;
+        assert(self);
+        assert(other);
+        PChar2IntVectorMapSetCtor(&set);
+        PChar2IntVectorMapSetItCtor(&it, self);
+        while(PChar2IntVectorMapSetItHasNext(&it)) {
+          PChar2IntVectorMapEntry element = PChar2IntVectorMapSetItNext(&it);
+          if(PChar2IntVectorMapSetContains(other, element)) PChar2IntVectorMapSetPut(&set, element);
+        }
+        PChar2IntVectorMapSetItCtor(&it, other);
+        while(PChar2IntVectorMapSetItHasNext(&it)) {
+          PChar2IntVectorMapEntry element = PChar2IntVectorMapSetItNext(&it);
+          if(PChar2IntVectorMapSetContains(self, element)) PChar2IntVectorMapSetPut(&set, element);
+        }
+        PChar2IntVectorMapSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        PChar2IntVectorMapSetRehash(self);
+        /*PChar2IntVectorMapSetDtor(&set);*/
+      }
+      static void PChar2IntVectorMapSetXor(PChar2IntVectorMapSet* self, PChar2IntVectorMapSet* other) {
+        PChar2IntVectorMapSetIt it;
+        PChar2IntVectorMapSet set;
+        assert(self);
+        assert(other);
+        PChar2IntVectorMapSetCtor(&set);
+        PChar2IntVectorMapSetItCtor(&it, self);
+        while(PChar2IntVectorMapSetItHasNext(&it)) {
+          PChar2IntVectorMapEntry element = PChar2IntVectorMapSetItNext(&it);
+          if(!PChar2IntVectorMapSetContains(other, element)) PChar2IntVectorMapSetPut(&set, element);
+        }
+        PChar2IntVectorMapSetItCtor(&it, other);
+        while(PChar2IntVectorMapSetItHasNext(&it)) {
+          PChar2IntVectorMapEntry element = PChar2IntVectorMapSetItNext(&it);
+          if(!PChar2IntVectorMapSetContains(self, element)) PChar2IntVectorMapSetPut(&set, element);
+        }
+        PChar2IntVectorMapSetDtor(self);
+        self->buckets = set.buckets;
+        self->size = set.size;
+        PChar2IntVectorMapSetRehash(self);
+        /*PChar2IntVectorMapSetDtor(&set);*/
+      }
+      static void PChar2IntVectorMapSetItCtor(PChar2IntVectorMapSetIt* self, PChar2IntVectorMapSet* set) {
+        assert(self);
+        self->set = set;
+        self->bucket_index = 0;
+        PChar2IntVectorMapSetListItCtor(&self->it, &set->buckets[0]);
+      }
+      static int PChar2IntVectorMapSetItHasNext(PChar2IntVectorMapSetIt* self) {
+        assert(self);
+        if(PChar2IntVectorMapSetListItHasNext(&self->it)) {
+          return 1;
+        } else {
+          size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!PChar2IntVectorMapSetListEmpty(&self->set->buckets[i])) {
+              return 1;
+            }
+          }
+          return 0;
+        }
+      }
+      static PChar2IntVectorMapEntry PChar2IntVectorMapSetItNext(PChar2IntVectorMapSetIt* self) {
+        assert(self);
+        assert(PChar2IntVectorMapSetItHasNext(self));
+          if(PChar2IntVectorMapSetListItHasNext(&self->it)) {
+            return PChar2IntVectorMapSetListItNext(&self->it);
+          } else {
+            size_t i; for(i = self->bucket_index+1; i < self->set->bucket_count; ++i) {
+            if(!PChar2IntVectorMapSetListEmpty(&self->set->buckets[i])) {
+            PChar2IntVectorMapSetListItCtor(&self->it, &self->set->buckets[i]);
+              self->bucket_index = i;
+              return PChar2IntVectorMapSetListItNext(&self->it);
+            }
+          }
+          abort();
+        }
+      }
+    
+       void PChar2IntVectorMapCtor(PChar2IntVectorMap* self) {
+        assert(self);
+        PChar2IntVectorMapSetCtor(&self->entries);
+      }
+       void PChar2IntVectorMapDtor(PChar2IntVectorMap* self) {
+        assert(self);
+        PChar2IntVectorMapSetDtor(&self->entries);
+      }
+       PChar2IntVectorMap* PChar2IntVectorMapNew(void) {
+        PChar2IntVectorMap* self = (PChar2IntVectorMap*)malloc(sizeof(PChar2IntVectorMap)); assert(self);
+        PChar2IntVectorMapCtor(self);
+        self->ref_count = 0;
+        return self;
+      }
+       void PChar2IntVectorMapDestroy(PChar2IntVectorMap* self) {
+        assert(self);
+        if(!--self->ref_count) {
+          PChar2IntVectorMapDtor(self);
+          free(self);
+        }
+      }
+       void PChar2IntVectorMapRehash(PChar2IntVectorMap* self) {
+        assert(self);
+        PChar2IntVectorMapSetRehash(&self->entries);
+      }
+       PChar2IntVectorMap* PChar2IntVectorMapAssign(PChar2IntVectorMap* self) {
+        assert(self);
+        ++self->ref_count;
+        return self;
+      }
+       void PChar2IntVectorMapPurge(PChar2IntVectorMap* self) {
+        assert(self);
+        PChar2IntVectorMapSetPurge(&self->entries);
+      }
+       size_t PChar2IntVectorMapSize(PChar2IntVectorMap* self) {
+        assert(self);
+        return PChar2IntVectorMapSetSize(&self->entries);
+      }
+       int PChar2IntVectorMapEmpty(PChar2IntVectorMap* self) {
+        assert(self);
+        return PChar2IntVectorMapSetEmpty(&self->entries);
+      }
+       int PChar2IntVectorMapContainsKey(PChar2IntVectorMap* self, const char* key) {
+        int result;
+        PChar2IntVectorMapEntry entry;
+        assert(self);
+        entry = PChar2IntVectorMapEntryAssign(PChar2IntVectorMapEntryKeyOnly(key));
+        result = PChar2IntVectorMapSetContains(&self->entries, entry);
+        PChar2IntVectorMapEntryDtor(entry);
+        return result;
+      }
+       IntVector* PChar2IntVectorMapGet(PChar2IntVectorMap* self, const char* key) {
+        IntVector* result;
+        PChar2IntVectorMapEntry entry;
+        assert(self);
+        entry = PChar2IntVectorMapEntryAssign(PChar2IntVectorMapEntryKeyOnly(key));
+        assert(PChar2IntVectorMapContainsKey(self, key));
+        result = PChar2IntVectorMapSetGet(&self->entries, entry).value;
+        PChar2IntVectorMapEntryDtor(entry);
+        return result;
+      }
+       int PChar2IntVectorMapPut(PChar2IntVectorMap* self, const char* key, IntVector* value) {
+        PChar2IntVectorMapEntry entry = PChar2IntVectorMapEntryAssign(PChar2IntVectorMapEntryKeyValue(key,value));
+        assert(self);
+        if(!PChar2IntVectorMapContainsKey(self, key)) {
+          PChar2IntVectorMapSetPut(&self->entries, entry);
+          PChar2IntVectorMapEntryDtor(entry);
+          return 1;
+        } else {
+          PChar2IntVectorMapEntryDtor(entry);
+          return 0;
+        }
+      }
+       void PChar2IntVectorMapReplace(PChar2IntVectorMap* self, const char* key, IntVector* value) {
+        PChar2IntVectorMapEntry entry;
+        assert(self);
+        entry = PChar2IntVectorMapEntryAssign(PChar2IntVectorMapEntryKeyValue(key,value));
+        PChar2IntVectorMapSetReplace(&self->entries, entry);
+        PChar2IntVectorMapEntryDtor(entry);
+      }
+       int PChar2IntVectorMapRemove(PChar2IntVectorMap* self, const char* key) {
+        int removed;
+        PChar2IntVectorMapEntry entry;
+        assert(self);
+        entry = PChar2IntVectorMapEntryAssign(PChar2IntVectorMapEntryKeyOnly(key));
+        removed = PChar2IntVectorMapSetRemove(&self->entries, entry);
+        PChar2IntVectorMapEntryDtor(entry);
+        return removed;
+      }
+       void PChar2IntVectorMapItCtor(PChar2IntVectorMapIt* self, PChar2IntVectorMap* map) {
+        assert(self);
+        assert(map);
+        PChar2IntVectorMapSetItCtor(&self->it, &map->entries);
+      }
+       int PChar2IntVectorMapItHasNext(PChar2IntVectorMapIt* self) {
+        assert(self);
+        return PChar2IntVectorMapSetItHasNext(&self->it);
+      }
+       const char* PChar2IntVectorMapItNextKey(PChar2IntVectorMapIt* self) {
+        assert(self);
+        return PChar2IntVectorMapSetItNext(&self->it).key;
+      }
+       IntVector* PChar2IntVectorMapItNextValue(PChar2IntVectorMapIt* self) {
+        assert(self);
+        return PChar2IntVectorMapSetItNext(&self->it).value;
+      }
+       PChar2IntVectorMapEntry PChar2IntVectorMapItNext(PChar2IntVectorMapIt* self) {
+        assert(self);
+        return PChar2IntVectorMapSetItNext(&self->it);
+      }
+