autoc 0.8

data/test/test_auto.h

@@ -0,0 +1,561 @@
+
+        /* AUTOMATICALLY GENERATED HEADER FILE. DO NOT MODIFY. */
+        #ifndef TEST_AUTO_H
+        #define TEST_AUTO_H
+      typedef struct Box Box;
+      #include <stddef.h>
+      #include <stdlib.h>
+      #include <malloc.h>
+      #include <assert.h>
+      #ifndef __DATA_STRUCT_INLINE
+        #if defined(_MSC_VER) || defined(__PGI)
+          #define __DATA_STRUCT_INLINE __inline static
+        #elif __STDC_VERSION__ >= 199901L && !defined(__DMC__)
+          #define __DATA_STRUCT_INLINE inline static
+        #else
+          #define __DATA_STRUCT_INLINE static
+        #endif
+      #endif
+      #ifndef __DATA_STRUCT_EXTERN
+        #if defined(__cplusplus)
+          #define __DATA_STRUCT_EXTERN extern "C"
+        #else
+          #define __DATA_STRUCT_EXTERN extern
+        #endif
+      #endif
+    
+      typedef struct IntSetListNode IntSetListNode;
+      typedef struct IntSetList IntSetList;
+      typedef struct IntSetListIt IntSetListIt;
+      struct IntSetList {
+        IntSetListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct IntSetListIt {
+        IntSetListNode* next_node;
+      };
+      struct IntSetListNode {
+        int element;
+        IntSetListNode* next_node;
+      };
+    
+      typedef struct IntSet IntSet;
+      typedef struct IntSetIt IntSetIt;
+      struct IntSet {
+        IntSetList* buckets;
+        size_t bucket_count, min_bucket_count;
+        size_t size, min_size, max_size;
+        unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+        size_t ref_count;
+      };
+      struct IntSetIt {
+        IntSet* set;
+        int bucket_index;
+        IntSetListIt it;
+      };
+    
+      __DATA_STRUCT_EXTERN void IntSetCtor(IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetDtor(IntSet*);
+      __DATA_STRUCT_EXTERN IntSet* IntSetNew(void);
+      __DATA_STRUCT_EXTERN void IntSetDestroy(IntSet*);
+      __DATA_STRUCT_EXTERN IntSet* IntSetAssign(IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetPurge(IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetRehash(IntSet*);
+      __DATA_STRUCT_EXTERN int IntSetContains(IntSet*, int);
+      __DATA_STRUCT_EXTERN int IntSetGet(IntSet*, int);
+      __DATA_STRUCT_EXTERN size_t IntSetSize(IntSet*);
+      __DATA_STRUCT_EXTERN int IntSetEmpty(IntSet*);
+      __DATA_STRUCT_EXTERN int IntSetPut(IntSet*, int);
+      __DATA_STRUCT_EXTERN void IntSetReplace(IntSet*, int);
+      __DATA_STRUCT_EXTERN int IntSetRemove(IntSet*, int);
+      __DATA_STRUCT_EXTERN void IntSetNot(IntSet*, IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetAnd(IntSet*, IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetOr(IntSet*, IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetXor(IntSet*, IntSet*);
+      __DATA_STRUCT_EXTERN void IntSetItCtor(IntSetIt*, IntSet*);
+      __DATA_STRUCT_EXTERN int IntSetItHasNext(IntSetIt*);
+      __DATA_STRUCT_EXTERN int IntSetItNext(IntSetIt*);
+    size_t PCharHash(const char*);int PCharEqual(const char*,const char*);
+      typedef struct PCharSetListNode PCharSetListNode;
+      typedef struct PCharSetList PCharSetList;
+      typedef struct PCharSetListIt PCharSetListIt;
+      struct PCharSetList {
+        PCharSetListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct PCharSetListIt {
+        PCharSetListNode* next_node;
+      };
+      struct PCharSetListNode {
+        const char* element;
+        PCharSetListNode* next_node;
+      };
+    
+      typedef struct PCharSet PCharSet;
+      typedef struct PCharSetIt PCharSetIt;
+      struct PCharSet {
+        PCharSetList* buckets;
+        size_t bucket_count, min_bucket_count;
+        size_t size, min_size, max_size;
+        unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+        size_t ref_count;
+      };
+      struct PCharSetIt {
+        PCharSet* set;
+        int bucket_index;
+        PCharSetListIt it;
+      };
+    
+      __DATA_STRUCT_EXTERN void PCharSetCtor(PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetDtor(PCharSet*);
+      __DATA_STRUCT_EXTERN PCharSet* PCharSetNew(void);
+      __DATA_STRUCT_EXTERN void PCharSetDestroy(PCharSet*);
+      __DATA_STRUCT_EXTERN PCharSet* PCharSetAssign(PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetPurge(PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetRehash(PCharSet*);
+      __DATA_STRUCT_EXTERN int PCharSetContains(PCharSet*, const char*);
+      __DATA_STRUCT_EXTERN const char* PCharSetGet(PCharSet*, const char*);
+      __DATA_STRUCT_EXTERN size_t PCharSetSize(PCharSet*);
+      __DATA_STRUCT_EXTERN int PCharSetEmpty(PCharSet*);
+      __DATA_STRUCT_EXTERN int PCharSetPut(PCharSet*, const char*);
+      __DATA_STRUCT_EXTERN void PCharSetReplace(PCharSet*, const char*);
+      __DATA_STRUCT_EXTERN int PCharSetRemove(PCharSet*, const char*);
+      __DATA_STRUCT_EXTERN void PCharSetNot(PCharSet*, PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetAnd(PCharSet*, PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetOr(PCharSet*, PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetXor(PCharSet*, PCharSet*);
+      __DATA_STRUCT_EXTERN void PCharSetItCtor(PCharSetIt*, PCharSet*);
+      __DATA_STRUCT_EXTERN int PCharSetItHasNext(PCharSetIt*);
+      __DATA_STRUCT_EXTERN const char* PCharSetItNext(PCharSetIt*);
+    Box* BoxAssign(Box*);void BoxDestroy(Box*);size_t BoxHash(Box*);int BoxEqual(Box*,Box*);Box* BoxAssign(Box*);void BoxDestroy(Box*);
+      typedef struct Box2BoxMapEntry Box2BoxMapEntry;
+      struct Box2BoxMapEntry {
+        Box* key;
+        Box* value;
+        int valid_value;
+      };
+    
+      typedef struct Box2BoxMapSetListNode Box2BoxMapSetListNode;
+      typedef struct Box2BoxMapSetList Box2BoxMapSetList;
+      typedef struct Box2BoxMapSetListIt Box2BoxMapSetListIt;
+      struct Box2BoxMapSetList {
+        Box2BoxMapSetListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct Box2BoxMapSetListIt {
+        Box2BoxMapSetListNode* next_node;
+      };
+      struct Box2BoxMapSetListNode {
+        Box2BoxMapEntry element;
+        Box2BoxMapSetListNode* next_node;
+      };
+    
+      typedef struct Box2BoxMapSet Box2BoxMapSet;
+      typedef struct Box2BoxMapSetIt Box2BoxMapSetIt;
+      struct Box2BoxMapSet {
+        Box2BoxMapSetList* buckets;
+        size_t bucket_count, min_bucket_count;
+        size_t size, min_size, max_size;
+        unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+        size_t ref_count;
+      };
+      struct Box2BoxMapSetIt {
+        Box2BoxMapSet* set;
+        int bucket_index;
+        Box2BoxMapSetListIt it;
+      };
+    
+      typedef struct Box2BoxMap Box2BoxMap;
+      typedef struct Box2BoxMapIt Box2BoxMapIt;
+      struct Box2BoxMap {
+        Box2BoxMapSet entries;
+        size_t ref_count;
+      };
+      struct Box2BoxMapIt {
+        Box2BoxMapSetIt it;
+      };
+    
+      __DATA_STRUCT_EXTERN void Box2BoxMapCtor(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN void Box2BoxMapDtor(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN Box2BoxMap* Box2BoxMapNew(void);
+      __DATA_STRUCT_EXTERN void Box2BoxMapDestroy(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN Box2BoxMap* Box2BoxMapAssign(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN void Box2BoxMapPurge(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN void Box2BoxMapRehash(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN size_t Box2BoxMapSize(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN int Box2BoxMapEmpty(Box2BoxMap*);
+      __DATA_STRUCT_EXTERN int Box2BoxMapContainsKey(Box2BoxMap*, Box*);
+      __DATA_STRUCT_EXTERN Box* Box2BoxMapGet(Box2BoxMap*, Box*);
+      __DATA_STRUCT_EXTERN int Box2BoxMapPut(Box2BoxMap*, Box*, Box*);
+      __DATA_STRUCT_EXTERN void Box2BoxMapReplace(Box2BoxMap*, Box*, Box*);
+      __DATA_STRUCT_EXTERN int Box2BoxMapRemove(Box2BoxMap*, Box*);
+      __DATA_STRUCT_EXTERN void Box2BoxMapItCtor(Box2BoxMapIt*, Box2BoxMap*);
+      __DATA_STRUCT_EXTERN int Box2BoxMapItHasNext(Box2BoxMapIt*);
+      __DATA_STRUCT_EXTERN Box* Box2BoxMapItNextKey(Box2BoxMapIt*);
+      __DATA_STRUCT_EXTERN Box* Box2BoxMapItNextValue(Box2BoxMapIt*);
+      __DATA_STRUCT_EXTERN Box2BoxMapEntry Box2BoxMapItNext(Box2BoxMapIt*);
+    size_t PCharHash(const char*);int PCharEqual(const char*,const char*);
+      typedef struct PChar2IntMapEntry PChar2IntMapEntry;
+      struct PChar2IntMapEntry {
+        const char* key;
+        int value;
+        int valid_value;
+      };
+    
+      typedef struct PChar2IntMapSetListNode PChar2IntMapSetListNode;
+      typedef struct PChar2IntMapSetList PChar2IntMapSetList;
+      typedef struct PChar2IntMapSetListIt PChar2IntMapSetListIt;
+      struct PChar2IntMapSetList {
+        PChar2IntMapSetListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct PChar2IntMapSetListIt {
+        PChar2IntMapSetListNode* next_node;
+      };
+      struct PChar2IntMapSetListNode {
+        PChar2IntMapEntry element;
+        PChar2IntMapSetListNode* next_node;
+      };
+    
+      typedef struct PChar2IntMapSet PChar2IntMapSet;
+      typedef struct PChar2IntMapSetIt PChar2IntMapSetIt;
+      struct PChar2IntMapSet {
+        PChar2IntMapSetList* buckets;
+        size_t bucket_count, min_bucket_count;
+        size_t size, min_size, max_size;
+        unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+        size_t ref_count;
+      };
+      struct PChar2IntMapSetIt {
+        PChar2IntMapSet* set;
+        int bucket_index;
+        PChar2IntMapSetListIt it;
+      };
+    
+      typedef struct PChar2IntMap PChar2IntMap;
+      typedef struct PChar2IntMapIt PChar2IntMapIt;
+      struct PChar2IntMap {
+        PChar2IntMapSet entries;
+        size_t ref_count;
+      };
+      struct PChar2IntMapIt {
+        PChar2IntMapSetIt it;
+      };
+    
+      __DATA_STRUCT_EXTERN void PChar2IntMapCtor(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN void PChar2IntMapDtor(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN PChar2IntMap* PChar2IntMapNew(void);
+      __DATA_STRUCT_EXTERN void PChar2IntMapDestroy(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN PChar2IntMap* PChar2IntMapAssign(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN void PChar2IntMapPurge(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN void PChar2IntMapRehash(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN size_t PChar2IntMapSize(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN int PChar2IntMapEmpty(PChar2IntMap*);
+      __DATA_STRUCT_EXTERN int PChar2IntMapContainsKey(PChar2IntMap*, const char*);
+      __DATA_STRUCT_EXTERN int PChar2IntMapGet(PChar2IntMap*, const char*);
+      __DATA_STRUCT_EXTERN int PChar2IntMapPut(PChar2IntMap*, const char*, int);
+      __DATA_STRUCT_EXTERN void PChar2IntMapReplace(PChar2IntMap*, const char*, int);
+      __DATA_STRUCT_EXTERN int PChar2IntMapRemove(PChar2IntMap*, const char*);
+      __DATA_STRUCT_EXTERN void PChar2IntMapItCtor(PChar2IntMapIt*, PChar2IntMap*);
+      __DATA_STRUCT_EXTERN int PChar2IntMapItHasNext(PChar2IntMapIt*);
+      __DATA_STRUCT_EXTERN const char* PChar2IntMapItNextKey(PChar2IntMapIt*);
+      __DATA_STRUCT_EXTERN int PChar2IntMapItNextValue(PChar2IntMapIt*);
+      __DATA_STRUCT_EXTERN PChar2IntMapEntry PChar2IntMapItNext(PChar2IntMapIt*);
+    int PCharEqual(const char*,const char*);
+      typedef struct PCharQueueNode PCharQueueNode;
+      typedef struct PCharQueue PCharQueue;
+      typedef struct PCharQueueIt PCharQueueIt;
+      struct PCharQueue {
+        PCharQueueNode* head_node;
+        PCharQueueNode* tail_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct PCharQueueIt {
+        PCharQueueNode* next_node;
+        int forward;
+      };
+      struct PCharQueueNode {
+        const char* element;
+        PCharQueueNode* prev_node;
+        PCharQueueNode* next_node;
+      };
+    
+      __DATA_STRUCT_EXTERN void PCharQueueCtor(PCharQueue*);
+      __DATA_STRUCT_EXTERN void PCharQueueDtor(PCharQueue*);
+      __DATA_STRUCT_EXTERN void PCharQueuePurge(PCharQueue*);
+      __DATA_STRUCT_EXTERN PCharQueue* PCharQueueNew(void);
+      __DATA_STRUCT_EXTERN void PCharQueueDestroy(PCharQueue*);
+      __DATA_STRUCT_EXTERN PCharQueue* PCharQueueAssign(PCharQueue*);
+      __DATA_STRUCT_EXTERN const char* PCharQueueHead(PCharQueue*);
+      __DATA_STRUCT_EXTERN const char* PCharQueueTail(PCharQueue*);
+      __DATA_STRUCT_EXTERN void PCharQueueAppend(PCharQueue*, const char*);
+      __DATA_STRUCT_EXTERN void PCharQueuePrepend(PCharQueue*, const char*);
+      __DATA_STRUCT_EXTERN void PCharQueueChopHead(PCharQueue*);
+      __DATA_STRUCT_EXTERN void PCharQueueChopTail(PCharQueue*);
+      __DATA_STRUCT_EXTERN int PCharQueueContains(PCharQueue*, const char*);
+      __DATA_STRUCT_EXTERN const char* PCharQueueFind(PCharQueue*, const char*);
+      __DATA_STRUCT_EXTERN int PCharQueueReplace(PCharQueue*, const char*, const char*);
+      __DATA_STRUCT_EXTERN int PCharQueueReplaceAll(PCharQueue*, const char*, const char*);
+      __DATA_STRUCT_EXTERN int PCharQueueRemove(PCharQueue*, const char*);
+      __DATA_STRUCT_EXTERN int PCharQueueRemoveAll(PCharQueue*, const char*);
+      __DATA_STRUCT_EXTERN size_t PCharQueueSize(PCharQueue*);
+      __DATA_STRUCT_EXTERN int PCharQueueEmpty(PCharQueue*);
+      __DATA_STRUCT_EXTERN void PCharQueueItCtor(PCharQueueIt*, PCharQueue*, int);
+      __DATA_STRUCT_EXTERN int PCharQueueItHasNext(PCharQueueIt*);
+      __DATA_STRUCT_EXTERN const char* PCharQueueItNext(PCharQueueIt*);
+    Box* BoxAssign(Box*);void BoxDestroy(Box*);int BoxEqual(Box*,Box*);
+      typedef struct BoxListNode BoxListNode;
+      typedef struct BoxList BoxList;
+      typedef struct BoxListIt BoxListIt;
+      struct BoxList {
+        BoxListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct BoxListIt {
+        BoxListNode* next_node;
+      };
+      struct BoxListNode {
+        Box* element;
+        BoxListNode* next_node;
+      };
+    
+      __DATA_STRUCT_EXTERN void BoxListCtor(BoxList*);
+      __DATA_STRUCT_EXTERN void BoxListDtor(BoxList*);
+      __DATA_STRUCT_EXTERN void BoxListPurge(BoxList*);
+      __DATA_STRUCT_EXTERN BoxList* BoxListNew(void);
+      __DATA_STRUCT_EXTERN void BoxListDestroy(BoxList*);
+      __DATA_STRUCT_EXTERN BoxList* BoxListAssign(BoxList*);
+      __DATA_STRUCT_EXTERN Box* BoxListGet(BoxList*);
+      __DATA_STRUCT_EXTERN void BoxListAdd(BoxList*, Box*);
+      __DATA_STRUCT_EXTERN void BoxListChop(BoxList*);
+      __DATA_STRUCT_EXTERN int BoxListContains(BoxList*, Box*);
+      __DATA_STRUCT_EXTERN Box* BoxListFind(BoxList*, Box*);
+      __DATA_STRUCT_EXTERN int BoxListReplace(BoxList*, Box*, Box*);
+      __DATA_STRUCT_EXTERN int BoxListReplaceAll(BoxList*, Box*, Box*);
+      __DATA_STRUCT_EXTERN int BoxListRemove(BoxList*, Box*);
+      __DATA_STRUCT_EXTERN int BoxListRemoveAll(BoxList*, Box*);
+      __DATA_STRUCT_EXTERN size_t BoxListSize(BoxList*);
+      __DATA_STRUCT_EXTERN int BoxListEmpty(BoxList*);
+      __DATA_STRUCT_EXTERN void BoxListItCtor(BoxListIt*, BoxList*);
+      __DATA_STRUCT_EXTERN int BoxListItHasNext(BoxListIt*);
+      __DATA_STRUCT_EXTERN Box* BoxListItNext(BoxListIt*);
+    
+      typedef struct IntVector IntVector;
+      typedef struct IntVectorIt IntVectorIt;
+      struct IntVector {
+        int* values;
+        size_t element_count;
+        size_t ref_count;
+      };
+      struct IntVectorIt {
+        IntVector* vector;
+        size_t index;
+      };
+    
+      __DATA_STRUCT_EXTERN void IntVectorCtor(IntVector*, size_t);
+      __DATA_STRUCT_EXTERN void IntVectorDtor(IntVector*);
+      __DATA_STRUCT_EXTERN IntVector* IntVectorNew(size_t);
+      __DATA_STRUCT_EXTERN void IntVectorDestroy(IntVector*);
+      __DATA_STRUCT_EXTERN IntVector* IntVectorAssign(IntVector*);
+      __DATA_STRUCT_EXTERN void IntVectorResize(IntVector*, size_t);
+      __DATA_STRUCT_EXTERN int IntVectorWithin(IntVector*, size_t);
+      __DATA_STRUCT_EXTERN void IntVectorItCtor(IntVectorIt*, IntVector*);
+      __DATA_STRUCT_EXTERN int IntVectorItHasNext(IntVectorIt*);
+      __DATA_STRUCT_EXTERN int IntVectorItNext(IntVectorIt*);
+      __DATA_STRUCT_INLINE int* IntVectorRef(IntVector* self, size_t index) {
+        assert(self);
+        assert(IntVectorWithin(self, index));
+        return &self->values[index];
+      }
+      __DATA_STRUCT_INLINE int IntVectorGet(IntVector* self, size_t index) {
+        assert(self);
+        assert(IntVectorWithin(self, index));
+        return *IntVectorRef(self, index);
+      }
+      __DATA_STRUCT_INLINE void IntVectorSet(IntVector* self, size_t index, int value) {
+        int* ref;
+        assert(self);
+        assert(IntVectorWithin(self, index));
+        ref = IntVectorRef(self, index);
+        ;
+        *ref = (value);
+      }
+      __DATA_STRUCT_INLINE size_t IntVectorSize(IntVector* self) {
+        assert(self);
+        return self->element_count;
+      }
+    __DATA_STRUCT_EXTERN void IntVectorSort(IntVector*);Box* BoxAssign(Box*);Box* BoxNew(void);void BoxDestroy(Box*);
+      typedef struct BoxVector BoxVector;
+      typedef struct BoxVectorIt BoxVectorIt;
+      struct BoxVector {
+        Box** values;
+        size_t element_count;
+        size_t ref_count;
+      };
+      struct BoxVectorIt {
+        BoxVector* vector;
+        size_t index;
+      };
+    
+      __DATA_STRUCT_EXTERN void BoxVectorCtor(BoxVector*, size_t);
+      __DATA_STRUCT_EXTERN void BoxVectorDtor(BoxVector*);
+      __DATA_STRUCT_EXTERN BoxVector* BoxVectorNew(size_t);
+      __DATA_STRUCT_EXTERN void BoxVectorDestroy(BoxVector*);
+      __DATA_STRUCT_EXTERN BoxVector* BoxVectorAssign(BoxVector*);
+      __DATA_STRUCT_EXTERN void BoxVectorResize(BoxVector*, size_t);
+      __DATA_STRUCT_EXTERN int BoxVectorWithin(BoxVector*, size_t);
+      __DATA_STRUCT_EXTERN void BoxVectorItCtor(BoxVectorIt*, BoxVector*);
+      __DATA_STRUCT_EXTERN int BoxVectorItHasNext(BoxVectorIt*);
+      __DATA_STRUCT_EXTERN Box* BoxVectorItNext(BoxVectorIt*);
+      __DATA_STRUCT_INLINE Box** BoxVectorRef(BoxVector* self, size_t index) {
+        assert(self);
+        assert(BoxVectorWithin(self, index));
+        return &self->values[index];
+      }
+      __DATA_STRUCT_INLINE Box* BoxVectorGet(BoxVector* self, size_t index) {
+        assert(self);
+        assert(BoxVectorWithin(self, index));
+        return *BoxVectorRef(self, index);
+      }
+      __DATA_STRUCT_INLINE void BoxVectorSet(BoxVector* self, size_t index, Box* value) {
+        Box** ref;
+        assert(self);
+        assert(BoxVectorWithin(self, index));
+        ref = BoxVectorRef(self, index);
+        BoxDestroy(*ref);
+        *ref = BoxAssign(value);
+      }
+      __DATA_STRUCT_INLINE size_t BoxVectorSize(BoxVector* self) {
+        assert(self);
+        return self->element_count;
+      }
+    Box* BoxAssign(Box*);void BoxDestroy(Box*);size_t BoxHash(Box*);int BoxEqual(Box*,Box*);
+      typedef struct BoxSetListNode BoxSetListNode;
+      typedef struct BoxSetList BoxSetList;
+      typedef struct BoxSetListIt BoxSetListIt;
+      struct BoxSetList {
+        BoxSetListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct BoxSetListIt {
+        BoxSetListNode* next_node;
+      };
+      struct BoxSetListNode {
+        Box* element;
+        BoxSetListNode* next_node;
+      };
+    
+      typedef struct BoxSet BoxSet;
+      typedef struct BoxSetIt BoxSetIt;
+      struct BoxSet {
+        BoxSetList* buckets;
+        size_t bucket_count, min_bucket_count;
+        size_t size, min_size, max_size;
+        unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+        size_t ref_count;
+      };
+      struct BoxSetIt {
+        BoxSet* set;
+        int bucket_index;
+        BoxSetListIt it;
+      };
+    
+      __DATA_STRUCT_EXTERN void BoxSetCtor(BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetDtor(BoxSet*);
+      __DATA_STRUCT_EXTERN BoxSet* BoxSetNew(void);
+      __DATA_STRUCT_EXTERN void BoxSetDestroy(BoxSet*);
+      __DATA_STRUCT_EXTERN BoxSet* BoxSetAssign(BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetPurge(BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetRehash(BoxSet*);
+      __DATA_STRUCT_EXTERN int BoxSetContains(BoxSet*, Box*);
+      __DATA_STRUCT_EXTERN Box* BoxSetGet(BoxSet*, Box*);
+      __DATA_STRUCT_EXTERN size_t BoxSetSize(BoxSet*);
+      __DATA_STRUCT_EXTERN int BoxSetEmpty(BoxSet*);
+      __DATA_STRUCT_EXTERN int BoxSetPut(BoxSet*, Box*);
+      __DATA_STRUCT_EXTERN void BoxSetReplace(BoxSet*, Box*);
+      __DATA_STRUCT_EXTERN int BoxSetRemove(BoxSet*, Box*);
+      __DATA_STRUCT_EXTERN void BoxSetNot(BoxSet*, BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetAnd(BoxSet*, BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetOr(BoxSet*, BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetXor(BoxSet*, BoxSet*);
+      __DATA_STRUCT_EXTERN void BoxSetItCtor(BoxSetIt*, BoxSet*);
+      __DATA_STRUCT_EXTERN int BoxSetItHasNext(BoxSetIt*);
+      __DATA_STRUCT_EXTERN Box* BoxSetItNext(BoxSetIt*);
+    size_t PCharHash(const char*);int PCharEqual(const char*,const char*);IntVector* IntVectorAssign(IntVector*);void IntVectorDestroy(IntVector*);
+      typedef struct PChar2IntVectorMapEntry PChar2IntVectorMapEntry;
+      struct PChar2IntVectorMapEntry {
+        const char* key;
+        IntVector* value;
+        int valid_value;
+      };
+    
+      typedef struct PChar2IntVectorMapSetListNode PChar2IntVectorMapSetListNode;
+      typedef struct PChar2IntVectorMapSetList PChar2IntVectorMapSetList;
+      typedef struct PChar2IntVectorMapSetListIt PChar2IntVectorMapSetListIt;
+      struct PChar2IntVectorMapSetList {
+        PChar2IntVectorMapSetListNode* head_node;
+        size_t node_count;
+        size_t ref_count;
+      };
+      struct PChar2IntVectorMapSetListIt {
+        PChar2IntVectorMapSetListNode* next_node;
+      };
+      struct PChar2IntVectorMapSetListNode {
+        PChar2IntVectorMapEntry element;
+        PChar2IntVectorMapSetListNode* next_node;
+      };
+    
+      typedef struct PChar2IntVectorMapSet PChar2IntVectorMapSet;
+      typedef struct PChar2IntVectorMapSetIt PChar2IntVectorMapSetIt;
+      struct PChar2IntVectorMapSet {
+        PChar2IntVectorMapSetList* buckets;
+        size_t bucket_count, min_bucket_count;
+        size_t size, min_size, max_size;
+        unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
+        size_t ref_count;
+      };
+      struct PChar2IntVectorMapSetIt {
+        PChar2IntVectorMapSet* set;
+        int bucket_index;
+        PChar2IntVectorMapSetListIt it;
+      };
+    
+      typedef struct PChar2IntVectorMap PChar2IntVectorMap;
+      typedef struct PChar2IntVectorMapIt PChar2IntVectorMapIt;
+      struct PChar2IntVectorMap {
+        PChar2IntVectorMapSet entries;
+        size_t ref_count;
+      };
+      struct PChar2IntVectorMapIt {
+        PChar2IntVectorMapSetIt it;
+      };
+    
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapCtor(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapDtor(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN PChar2IntVectorMap* PChar2IntVectorMapNew(void);
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapDestroy(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN PChar2IntVectorMap* PChar2IntVectorMapAssign(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapPurge(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapRehash(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN size_t PChar2IntVectorMapSize(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN int PChar2IntVectorMapEmpty(PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN int PChar2IntVectorMapContainsKey(PChar2IntVectorMap*, const char*);
+      __DATA_STRUCT_EXTERN IntVector* PChar2IntVectorMapGet(PChar2IntVectorMap*, const char*);
+      __DATA_STRUCT_EXTERN int PChar2IntVectorMapPut(PChar2IntVectorMap*, const char*, IntVector*);
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapReplace(PChar2IntVectorMap*, const char*, IntVector*);
+      __DATA_STRUCT_EXTERN int PChar2IntVectorMapRemove(PChar2IntVectorMap*, const char*);
+      __DATA_STRUCT_EXTERN void PChar2IntVectorMapItCtor(PChar2IntVectorMapIt*, PChar2IntVectorMap*);
+      __DATA_STRUCT_EXTERN int PChar2IntVectorMapItHasNext(PChar2IntVectorMapIt*);
+      __DATA_STRUCT_EXTERN const char* PChar2IntVectorMapItNextKey(PChar2IntVectorMapIt*);
+      __DATA_STRUCT_EXTERN IntVector* PChar2IntVectorMapItNextValue(PChar2IntVectorMapIt*);
+      __DATA_STRUCT_EXTERN PChar2IntVectorMapEntry PChar2IntVectorMapItNext(PChar2IntVectorMapIt*);
+    
+        #endif
+