MRBitSet.h

Go to the documentation of this file.

#pragma once
 
#include <MRCMesh/MRId.h>
#include <MRCMisc/common.h>
#include <MRCMisc/exports.h>
 
#include <stdbool.h>
#include <stddef.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct MR_BMap_MR_GraphEdgeId_MR_GraphEdgeId MR_BMap_MR_GraphEdgeId_MR_GraphEdgeId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_GraphVertId_MR_GraphVertId MR_BMap_MR_GraphVertId_MR_GraphVertId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag MR_BMap_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_NodeId_MR_NodeId MR_BMap_MR_NodeId_MR_NodeId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_ObjId_MR_ObjId MR_BMap_MR_ObjId_MR_ObjId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_PixelId_MR_PixelId MR_BMap_MR_PixelId_MR_PixelId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_RegionId_MR_RegionId MR_BMap_MR_RegionId_MR_RegionId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_TextureId_MR_TextureId MR_BMap_MR_TextureId_MR_TextureId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_BMap_MR_VoxelId_MR_VoxelId MR_BMap_MR_VoxelId_MR_VoxelId; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_EdgeBMap MR_EdgeBMap; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_EdgeMap MR_EdgeMap; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_FaceBMap MR_FaceBMap; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_FaceMap MR_FaceMap; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Id_MR_ICPElemtTag MR_Id_MR_ICPElemtTag; // Defined in `#include <MRCMesh/MRId.h>`.
typedef struct MR_ObjMap MR_ObjMap; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_UndirectedEdgeBMap MR_UndirectedEdgeBMap; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_UndirectedEdgeMap MR_UndirectedEdgeMap; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_GraphEdgeId_MR_GraphEdgeId MR_Vector_MR_GraphEdgeId_MR_GraphEdgeId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_GraphVertId_MR_GraphVertId MR_Vector_MR_GraphVertId_MR_GraphVertId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag MR_Vector_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_NodeId_MR_NodeId MR_Vector_MR_NodeId_MR_NodeId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_PixelId_MR_PixelId MR_Vector_MR_PixelId_MR_PixelId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_RegionId_MR_RegionId MR_Vector_MR_RegionId_MR_RegionId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_TextureId_MR_TextureId MR_Vector_MR_TextureId_MR_TextureId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_Vector_MR_VoxelId_MR_VoxelId MR_Vector_MR_VoxelId_MR_VoxelId; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_VertBMap MR_VertBMap; // Defined in `#include <MRCMesh/MRBuffer.h>`.
typedef struct MR_VertMap MR_VertMap; // Defined in `#include <MRCMesh/MRVector.h>`.
typedef struct MR_phmap_flat_hash_map_MR_EdgeId_MR_EdgeId MR_phmap_flat_hash_map_MR_EdgeId_MR_EdgeId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_EdgeId_MR_EdgeId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_FaceId_MR_FaceId MR_phmap_flat_hash_map_MR_FaceId_MR_FaceId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_FaceId_MR_FaceId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId MR_phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId MR_phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag MR_phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag.h>`.
typedef struct MR_phmap_flat_hash_map_MR_NodeId_MR_NodeId MR_phmap_flat_hash_map_MR_NodeId_MR_NodeId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_NodeId_MR_NodeId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_ObjId_MR_ObjId MR_phmap_flat_hash_map_MR_ObjId_MR_ObjId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_ObjId_MR_ObjId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_PixelId_MR_PixelId MR_phmap_flat_hash_map_MR_PixelId_MR_PixelId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_PixelId_MR_PixelId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_RegionId_MR_RegionId MR_phmap_flat_hash_map_MR_RegionId_MR_RegionId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_RegionId_MR_RegionId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_TextureId_MR_TextureId MR_phmap_flat_hash_map_MR_TextureId_MR_TextureId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_TextureId_MR_TextureId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId MR_phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_VertId_MR_VertId MR_phmap_flat_hash_map_MR_VertId_MR_VertId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_VertId_MR_VertId.h>`.
typedef struct MR_phmap_flat_hash_map_MR_VoxelId_MR_VoxelId MR_phmap_flat_hash_map_MR_VoxelId_MR_VoxelId; // Defined in `#include <MRCMisc/phmap_flat_hash_map_MR_VoxelId_MR_VoxelId.h>`.
typedef struct MR_phmap_flat_hash_map_size_t_size_t MR_phmap_flat_hash_map_size_t_size_t; // Defined in `#include <MRCMisc/phmap_flat_hash_map_size_t_size_t.h>`.
typedef struct MR_std_istream MR_std_istream; // Defined in `#include <MRCMisc/iostream.h>`.
typedef struct MR_std_ostream MR_std_ostream; // Defined in `#include <MRCMisc/iostream.h>`.
typedef struct MR_std_vector_uint64_t MR_std_vector_uint64_t; // Defined in `#include <MRCMisc/std_vector_uint64_t.h>`.
 

typedef struct MR_FaceBitSet MR_FaceBitSet;

typedef struct MR_VertBitSet MR_VertBitSet;

typedef struct MR_EdgeBitSet MR_EdgeBitSet;

typedef struct MR_UndirectedEdgeBitSet MR_UndirectedEdgeBitSet;

typedef struct MR_PixelBitSet MR_PixelBitSet;

typedef struct MR_VoxelBitSet MR_VoxelBitSet;

typedef struct MR_RegionBitSet MR_RegionBitSet;

typedef struct MR_NodeBitSet MR_NodeBitSet;

typedef struct MR_ObjBitSet MR_ObjBitSet;

typedef struct MR_TextureBitSet MR_TextureBitSet;

typedef struct MR_GraphVertBitSet MR_GraphVertBitSet;

typedef struct MR_GraphEdgeBitSet MR_GraphEdgeBitSet;

typedef struct MR_TypedBitSet_MR_Id_MR_ICPElemtTag MR_TypedBitSet_MR_Id_MR_ICPElemtTag;

typedef struct MR_SetBitIterator MR_SetBitIterator;

typedef struct MR_FaceSetBitIterator MR_FaceSetBitIterator;

typedef struct MR_VertSetBitIterator MR_VertSetBitIterator;

typedef struct MR_EdgeSetBitIterator MR_EdgeSetBitIterator;

typedef struct MR_UndirectedEdgeSetBitIterator MR_UndirectedEdgeSetBitIterator;

typedef struct MR_SetBitIteratorT_MR_PixelBitSet MR_SetBitIteratorT_MR_PixelBitSet;

typedef struct MR_SetBitIteratorT_MR_VoxelBitSet MR_SetBitIteratorT_MR_VoxelBitSet;

typedef struct MR_SetBitIteratorT_MR_RegionBitSet MR_SetBitIteratorT_MR_RegionBitSet;

typedef struct MR_SetBitIteratorT_MR_NodeBitSet MR_SetBitIteratorT_MR_NodeBitSet;

typedef struct MR_SetBitIteratorT_MR_ObjBitSet MR_SetBitIteratorT_MR_ObjBitSet;

typedef struct MR_SetBitIteratorT_MR_TextureBitSet MR_SetBitIteratorT_MR_TextureBitSet;

typedef struct MR_SetBitIteratorT_MR_GraphVertBitSet MR_SetBitIteratorT_MR_GraphVertBitSet;

typedef struct MR_SetBitIteratorT_MR_GraphEdgeBitSet MR_SetBitIteratorT_MR_GraphEdgeBitSet;

typedef struct MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag;

typedef struct MR_BitSet MR_BitSet;

MRC_API const size_t *MR_FaceBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_FaceBitSet_Get_npos(void);

MRC_API MR_FaceBitSet *MR_FaceBitSet_DefaultConstruct(void);

MRC_API MR_FaceBitSet *MR_FaceBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_FaceBitSet *MR_FaceBitSet_OffsetPtr(const MR_FaceBitSet *ptr, ptrdiff_t i);

MRC_API MR_FaceBitSet *MR_FaceBitSet_OffsetMutablePtr(MR_FaceBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_FaceBitSet_UpcastTo_MR_BitSet(const MR_FaceBitSet *object);

MRC_API MR_BitSet *MR_FaceBitSet_MutableUpcastTo_MR_BitSet(MR_FaceBitSet *object);

MRC_API const MR_FaceBitSet *MR_FaceBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_FaceBitSet *MR_FaceBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_FaceBitSet *MR_FaceBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_FaceBitSet *_other);

MRC_API MR_FaceBitSet *MR_FaceBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_FaceBitSet *MR_FaceBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_FaceBitSet *MR_FaceBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_FaceBitSet_Destroy(const MR_FaceBitSet *_this);

MRC_API void MR_FaceBitSet_DestroyArray(const MR_FaceBitSet *_this);

MRC_API MR_FaceBitSet *MR_FaceBitSet_AssignFromAnother(MR_FaceBitSet *_this, MR_PassBy _other_pass_by, MR_FaceBitSet *_other);

MRC_API MR_FaceBitSet *MR_FaceBitSet_set_3(MR_FaceBitSet *_this, MR_FaceId n, size_t len, bool val);

MRC_API MR_FaceBitSet *MR_FaceBitSet_set_2(MR_FaceBitSet *_this, MR_FaceId n, bool val);

MRC_API MR_FaceBitSet *MR_FaceBitSet_set_1(MR_FaceBitSet *_this, MR_FaceId n);

MRC_API MR_FaceBitSet *MR_FaceBitSet_set_0(MR_FaceBitSet *_this);

MRC_API MR_FaceBitSet *MR_FaceBitSet_reset_2(MR_FaceBitSet *_this, MR_FaceId n, size_t len);

MRC_API MR_FaceBitSet *MR_FaceBitSet_reset_1(MR_FaceBitSet *_this, MR_FaceId n);

MRC_API MR_FaceBitSet *MR_FaceBitSet_reset_0(MR_FaceBitSet *_this);

MRC_API MR_FaceBitSet *MR_FaceBitSet_flip_2(MR_FaceBitSet *_this, MR_FaceId n, size_t len);

MRC_API MR_FaceBitSet *MR_FaceBitSet_flip_1(MR_FaceBitSet *_this, MR_FaceId n);

MRC_API MR_FaceBitSet *MR_FaceBitSet_flip_0(MR_FaceBitSet *_this);

MRC_API bool MR_FaceBitSet_test(const MR_FaceBitSet *_this, MR_FaceId n);

MRC_API bool MR_FaceBitSet_test_set(MR_FaceBitSet *_this, MR_FaceId n, const bool *val);

MRC_API MR_FaceId MR_FaceBitSet_find_first(const MR_FaceBitSet *_this);

MRC_API MR_FaceId MR_FaceBitSet_find_next(const MR_FaceBitSet *_this, MR_FaceId pos);

MRC_API MR_FaceId MR_FaceBitSet_find_last(const MR_FaceBitSet *_this);

MRC_API MR_FaceId MR_FaceBitSet_find_first_not_set(const MR_FaceBitSet *_this);

MRC_API MR_FaceId MR_FaceBitSet_find_next_not_set(const MR_FaceBitSet *_this, MR_FaceId pos);

MRC_API MR_FaceId MR_FaceBitSet_find_last_not_set(const MR_FaceBitSet *_this);

MRC_API MR_FaceId MR_FaceBitSet_nthSetBit(const MR_FaceBitSet *_this, size_t n);

MRC_API MR_FaceBitSet *MR_FaceBitSet_bitand_assign(MR_FaceBitSet *_this, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_FaceBitSet_bitor_assign(MR_FaceBitSet *_this, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_FaceBitSet_xor_assign(MR_FaceBitSet *_this, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_FaceBitSet_sub_assign(MR_FaceBitSet *_this, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_FaceBitSet_subtract(MR_FaceBitSet *_this, const MR_FaceBitSet *b, int bShiftInBlocks);

MRC_API bool MR_FaceBitSet_is_subset_of(const MR_FaceBitSet *_this, const MR_FaceBitSet *a);

MRC_API bool MR_FaceBitSet_intersects(const MR_FaceBitSet *_this, const MR_FaceBitSet *a);

MRC_API void MR_FaceBitSet_autoResizeSet_3(MR_FaceBitSet *_this, MR_FaceId pos, size_t len, const bool *val);

MRC_API void MR_FaceBitSet_autoResizeSet_2(MR_FaceBitSet *_this, MR_FaceId pos, const bool *val);

MRC_API bool MR_FaceBitSet_autoResizeTestSet(MR_FaceBitSet *_this, MR_FaceId pos, const bool *val);

MRC_API MR_FaceBitSet *MR_FaceBitSet_getMapping_1_MR_FaceMap(const MR_FaceBitSet *_this, const MR_FaceMap *map);

MRC_API MR_FaceBitSet *MR_FaceBitSet_getMapping_1_MR_FaceBMap(const MR_FaceBitSet *_this, const MR_FaceBMap *map);

MRC_API MR_FaceBitSet *MR_FaceBitSet_getMapping_1_phmap_flat_hash_map_MR_FaceId_MR_FaceId(const MR_FaceBitSet *_this, const MR_phmap_flat_hash_map_MR_FaceId_MR_FaceId *map);

MRC_API MR_FaceBitSet *MR_FaceBitSet_getMapping_2_MR_FaceMap(const MR_FaceBitSet *_this, const MR_FaceMap *map, size_t resSize);

MRC_API MR_FaceBitSet *MR_FaceBitSet_getMapping_2_phmap_flat_hash_map_MR_FaceId_MR_FaceId(const MR_FaceBitSet *_this, const MR_phmap_flat_hash_map_MR_FaceId_MR_FaceId *map, size_t resSize);

MRC_API MR_FaceId MR_FaceBitSet_backId(const MR_FaceBitSet *_this);

MRC_API MR_FaceId MR_FaceBitSet_beginId(void);

MRC_API MR_FaceId MR_FaceBitSet_endId(const MR_FaceBitSet *_this);

MRC_API MR_BitSet *MR_FaceBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_FaceBitSet_reserve(MR_FaceBitSet *_this, size_t numBits);

MRC_API void MR_FaceBitSet_resize(MR_FaceBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_FaceBitSet_clear(MR_FaceBitSet *_this);

MRC_API void MR_FaceBitSet_shrink_to_fit(MR_FaceBitSet *_this);

MRC_API bool MR_FaceBitSet_empty(const MR_FaceBitSet *_this);

MRC_API size_t MR_FaceBitSet_size(const MR_FaceBitSet *_this);

MRC_API size_t MR_FaceBitSet_num_blocks(const MR_FaceBitSet *_this);

MRC_API size_t MR_FaceBitSet_capacity(const MR_FaceBitSet *_this);

MRC_API bool MR_FaceBitSet_uncheckedTest(const MR_FaceBitSet *_this, size_t n);

MRC_API bool MR_FaceBitSet_uncheckedTestSet(MR_FaceBitSet *_this, size_t n, const bool *val);

MRC_API void MR_FaceBitSet_reverse(MR_FaceBitSet *_this);

MRC_API void MR_FaceBitSet_push_back(MR_FaceBitSet *_this, bool val);

MRC_API void MR_FaceBitSet_pop_back(MR_FaceBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_FaceBitSet_bits(const MR_FaceBitSet *_this);

MRC_API bool MR_FaceBitSet_all(const MR_FaceBitSet *_this);

MRC_API bool MR_FaceBitSet_any(const MR_FaceBitSet *_this);

MRC_API bool MR_FaceBitSet_none(const MR_FaceBitSet *_this);

MRC_API size_t MR_FaceBitSet_count(const MR_FaceBitSet *_this);

MRC_API void MR_FaceBitSet_resizeWithReserve(MR_FaceBitSet *_this, size_t newSize);

MRC_API size_t MR_FaceBitSet_heapBytes(const MR_FaceBitSet *_this);

MRC_API MR_FaceBitSet *MR_bitand_MR_FaceBitSet(const MR_FaceBitSet *a, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_bitor_MR_FaceBitSet(const MR_FaceBitSet *a, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_xor_MR_FaceBitSet(const MR_FaceBitSet *a, const MR_FaceBitSet *b);

MRC_API MR_FaceBitSet *MR_sub_MR_FaceBitSet(const MR_FaceBitSet *a, const MR_FaceBitSet *b);

MRC_API MR_FaceSetBitIterator *MR_begin_const_MR_FaceBitSet_ref(const MR_FaceBitSet *a);

MRC_API MR_FaceSetBitIterator *MR_end_const_MR_FaceBitSet_ref(const MR_FaceBitSet *_1);

MRC_API const size_t *MR_VertBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_VertBitSet_Get_npos(void);

MRC_API MR_VertBitSet *MR_VertBitSet_DefaultConstruct(void);

MRC_API MR_VertBitSet *MR_VertBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_VertBitSet *MR_VertBitSet_OffsetPtr(const MR_VertBitSet *ptr, ptrdiff_t i);

MRC_API MR_VertBitSet *MR_VertBitSet_OffsetMutablePtr(MR_VertBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_VertBitSet_UpcastTo_MR_BitSet(const MR_VertBitSet *object);

MRC_API MR_BitSet *MR_VertBitSet_MutableUpcastTo_MR_BitSet(MR_VertBitSet *object);

MRC_API const MR_VertBitSet *MR_VertBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_VertBitSet *MR_VertBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_VertBitSet *MR_VertBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_VertBitSet *_other);

MRC_API MR_VertBitSet *MR_VertBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_VertBitSet *MR_VertBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_VertBitSet *MR_VertBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_VertBitSet_Destroy(const MR_VertBitSet *_this);

MRC_API void MR_VertBitSet_DestroyArray(const MR_VertBitSet *_this);

MRC_API MR_VertBitSet *MR_VertBitSet_AssignFromAnother(MR_VertBitSet *_this, MR_PassBy _other_pass_by, MR_VertBitSet *_other);

MRC_API MR_VertBitSet *MR_VertBitSet_set_3(MR_VertBitSet *_this, MR_VertId n, size_t len, bool val);

MRC_API MR_VertBitSet *MR_VertBitSet_set_2(MR_VertBitSet *_this, MR_VertId n, bool val);

MRC_API MR_VertBitSet *MR_VertBitSet_set_1(MR_VertBitSet *_this, MR_VertId n);

MRC_API MR_VertBitSet *MR_VertBitSet_set_0(MR_VertBitSet *_this);

MRC_API MR_VertBitSet *MR_VertBitSet_reset_2(MR_VertBitSet *_this, MR_VertId n, size_t len);

MRC_API MR_VertBitSet *MR_VertBitSet_reset_1(MR_VertBitSet *_this, MR_VertId n);

MRC_API MR_VertBitSet *MR_VertBitSet_reset_0(MR_VertBitSet *_this);

MRC_API MR_VertBitSet *MR_VertBitSet_flip_2(MR_VertBitSet *_this, MR_VertId n, size_t len);

MRC_API MR_VertBitSet *MR_VertBitSet_flip_1(MR_VertBitSet *_this, MR_VertId n);

MRC_API MR_VertBitSet *MR_VertBitSet_flip_0(MR_VertBitSet *_this);

MRC_API bool MR_VertBitSet_test(const MR_VertBitSet *_this, MR_VertId n);

MRC_API bool MR_VertBitSet_test_set(MR_VertBitSet *_this, MR_VertId n, const bool *val);

MRC_API MR_VertId MR_VertBitSet_find_first(const MR_VertBitSet *_this);

MRC_API MR_VertId MR_VertBitSet_find_next(const MR_VertBitSet *_this, MR_VertId pos);

MRC_API MR_VertId MR_VertBitSet_find_last(const MR_VertBitSet *_this);

MRC_API MR_VertId MR_VertBitSet_find_first_not_set(const MR_VertBitSet *_this);

MRC_API MR_VertId MR_VertBitSet_find_next_not_set(const MR_VertBitSet *_this, MR_VertId pos);

MRC_API MR_VertId MR_VertBitSet_find_last_not_set(const MR_VertBitSet *_this);

MRC_API MR_VertId MR_VertBitSet_nthSetBit(const MR_VertBitSet *_this, size_t n);

MRC_API MR_VertBitSet *MR_VertBitSet_bitand_assign(MR_VertBitSet *_this, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_VertBitSet_bitor_assign(MR_VertBitSet *_this, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_VertBitSet_xor_assign(MR_VertBitSet *_this, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_VertBitSet_sub_assign(MR_VertBitSet *_this, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_VertBitSet_subtract(MR_VertBitSet *_this, const MR_VertBitSet *b, int bShiftInBlocks);

MRC_API bool MR_VertBitSet_is_subset_of(const MR_VertBitSet *_this, const MR_VertBitSet *a);

MRC_API bool MR_VertBitSet_intersects(const MR_VertBitSet *_this, const MR_VertBitSet *a);

MRC_API void MR_VertBitSet_autoResizeSet_3(MR_VertBitSet *_this, MR_VertId pos, size_t len, const bool *val);

MRC_API void MR_VertBitSet_autoResizeSet_2(MR_VertBitSet *_this, MR_VertId pos, const bool *val);

MRC_API bool MR_VertBitSet_autoResizeTestSet(MR_VertBitSet *_this, MR_VertId pos, const bool *val);

MRC_API MR_VertBitSet *MR_VertBitSet_getMapping_1_MR_VertMap(const MR_VertBitSet *_this, const MR_VertMap *map);

MRC_API MR_VertBitSet *MR_VertBitSet_getMapping_1_MR_VertBMap(const MR_VertBitSet *_this, const MR_VertBMap *map);

MRC_API MR_VertBitSet *MR_VertBitSet_getMapping_1_phmap_flat_hash_map_MR_VertId_MR_VertId(const MR_VertBitSet *_this, const MR_phmap_flat_hash_map_MR_VertId_MR_VertId *map);

MRC_API MR_VertBitSet *MR_VertBitSet_getMapping_2_MR_VertMap(const MR_VertBitSet *_this, const MR_VertMap *map, size_t resSize);

MRC_API MR_VertBitSet *MR_VertBitSet_getMapping_2_phmap_flat_hash_map_MR_VertId_MR_VertId(const MR_VertBitSet *_this, const MR_phmap_flat_hash_map_MR_VertId_MR_VertId *map, size_t resSize);

MRC_API MR_VertId MR_VertBitSet_backId(const MR_VertBitSet *_this);

MRC_API MR_VertId MR_VertBitSet_beginId(void);

MRC_API MR_VertId MR_VertBitSet_endId(const MR_VertBitSet *_this);

MRC_API MR_BitSet *MR_VertBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_VertBitSet_reserve(MR_VertBitSet *_this, size_t numBits);

MRC_API void MR_VertBitSet_resize(MR_VertBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_VertBitSet_clear(MR_VertBitSet *_this);

MRC_API void MR_VertBitSet_shrink_to_fit(MR_VertBitSet *_this);

MRC_API bool MR_VertBitSet_empty(const MR_VertBitSet *_this);

MRC_API size_t MR_VertBitSet_size(const MR_VertBitSet *_this);

MRC_API size_t MR_VertBitSet_num_blocks(const MR_VertBitSet *_this);

MRC_API size_t MR_VertBitSet_capacity(const MR_VertBitSet *_this);

MRC_API bool MR_VertBitSet_uncheckedTest(const MR_VertBitSet *_this, size_t n);

MRC_API bool MR_VertBitSet_uncheckedTestSet(MR_VertBitSet *_this, size_t n, const bool *val);

MRC_API void MR_VertBitSet_reverse(MR_VertBitSet *_this);

MRC_API void MR_VertBitSet_push_back(MR_VertBitSet *_this, bool val);

MRC_API void MR_VertBitSet_pop_back(MR_VertBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_VertBitSet_bits(const MR_VertBitSet *_this);

MRC_API bool MR_VertBitSet_all(const MR_VertBitSet *_this);

MRC_API bool MR_VertBitSet_any(const MR_VertBitSet *_this);

MRC_API bool MR_VertBitSet_none(const MR_VertBitSet *_this);

MRC_API size_t MR_VertBitSet_count(const MR_VertBitSet *_this);

MRC_API void MR_VertBitSet_resizeWithReserve(MR_VertBitSet *_this, size_t newSize);

MRC_API size_t MR_VertBitSet_heapBytes(const MR_VertBitSet *_this);

MRC_API MR_VertBitSet *MR_bitand_MR_VertBitSet(const MR_VertBitSet *a, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_bitor_MR_VertBitSet(const MR_VertBitSet *a, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_xor_MR_VertBitSet(const MR_VertBitSet *a, const MR_VertBitSet *b);

MRC_API MR_VertBitSet *MR_sub_MR_VertBitSet(const MR_VertBitSet *a, const MR_VertBitSet *b);

MRC_API MR_VertSetBitIterator *MR_begin_const_MR_VertBitSet_ref(const MR_VertBitSet *a);

MRC_API MR_VertSetBitIterator *MR_end_const_MR_VertBitSet_ref(const MR_VertBitSet *_1);

MRC_API const size_t *MR_EdgeBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_EdgeBitSet_Get_npos(void);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_DefaultConstruct(void);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_EdgeBitSet *MR_EdgeBitSet_OffsetPtr(const MR_EdgeBitSet *ptr, ptrdiff_t i);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_OffsetMutablePtr(MR_EdgeBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_EdgeBitSet_UpcastTo_MR_BitSet(const MR_EdgeBitSet *object);

MRC_API MR_BitSet *MR_EdgeBitSet_MutableUpcastTo_MR_BitSet(MR_EdgeBitSet *object);

MRC_API const MR_EdgeBitSet *MR_EdgeBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_EdgeBitSet *_other);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_EdgeBitSet_Destroy(const MR_EdgeBitSet *_this);

MRC_API void MR_EdgeBitSet_DestroyArray(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_AssignFromAnother(MR_EdgeBitSet *_this, MR_PassBy _other_pass_by, MR_EdgeBitSet *_other);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_set_3(MR_EdgeBitSet *_this, MR_EdgeId n, size_t len, bool val);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_set_2(MR_EdgeBitSet *_this, MR_EdgeId n, bool val);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_set_1(MR_EdgeBitSet *_this, MR_EdgeId n);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_set_0(MR_EdgeBitSet *_this);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_reset_2(MR_EdgeBitSet *_this, MR_EdgeId n, size_t len);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_reset_1(MR_EdgeBitSet *_this, MR_EdgeId n);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_reset_0(MR_EdgeBitSet *_this);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_flip_2(MR_EdgeBitSet *_this, MR_EdgeId n, size_t len);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_flip_1(MR_EdgeBitSet *_this, MR_EdgeId n);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_flip_0(MR_EdgeBitSet *_this);

MRC_API bool MR_EdgeBitSet_test(const MR_EdgeBitSet *_this, MR_EdgeId n);

MRC_API bool MR_EdgeBitSet_test_set(MR_EdgeBitSet *_this, MR_EdgeId n, const bool *val);

MRC_API MR_EdgeId MR_EdgeBitSet_find_first(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeId MR_EdgeBitSet_find_next(const MR_EdgeBitSet *_this, MR_EdgeId pos);

MRC_API MR_EdgeId MR_EdgeBitSet_find_last(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeId MR_EdgeBitSet_find_first_not_set(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeId MR_EdgeBitSet_find_next_not_set(const MR_EdgeBitSet *_this, MR_EdgeId pos);

MRC_API MR_EdgeId MR_EdgeBitSet_find_last_not_set(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeId MR_EdgeBitSet_nthSetBit(const MR_EdgeBitSet *_this, size_t n);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_bitand_assign(MR_EdgeBitSet *_this, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_bitor_assign(MR_EdgeBitSet *_this, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_xor_assign(MR_EdgeBitSet *_this, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_sub_assign(MR_EdgeBitSet *_this, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_subtract(MR_EdgeBitSet *_this, const MR_EdgeBitSet *b, int bShiftInBlocks);

MRC_API bool MR_EdgeBitSet_is_subset_of(const MR_EdgeBitSet *_this, const MR_EdgeBitSet *a);

MRC_API bool MR_EdgeBitSet_intersects(const MR_EdgeBitSet *_this, const MR_EdgeBitSet *a);

MRC_API void MR_EdgeBitSet_autoResizeSet_3(MR_EdgeBitSet *_this, MR_EdgeId pos, size_t len, const bool *val);

MRC_API void MR_EdgeBitSet_autoResizeSet_2(MR_EdgeBitSet *_this, MR_EdgeId pos, const bool *val);

MRC_API bool MR_EdgeBitSet_autoResizeTestSet(MR_EdgeBitSet *_this, MR_EdgeId pos, const bool *val);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_getMapping_1_MR_EdgeMap(const MR_EdgeBitSet *_this, const MR_EdgeMap *map);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_getMapping_1_MR_EdgeBMap(const MR_EdgeBitSet *_this, const MR_EdgeBMap *map);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_getMapping_1_phmap_flat_hash_map_MR_EdgeId_MR_EdgeId(const MR_EdgeBitSet *_this, const MR_phmap_flat_hash_map_MR_EdgeId_MR_EdgeId *map);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_getMapping_2_MR_EdgeMap(const MR_EdgeBitSet *_this, const MR_EdgeMap *map, size_t resSize);

MRC_API MR_EdgeBitSet *MR_EdgeBitSet_getMapping_2_phmap_flat_hash_map_MR_EdgeId_MR_EdgeId(const MR_EdgeBitSet *_this, const MR_phmap_flat_hash_map_MR_EdgeId_MR_EdgeId *map, size_t resSize);

MRC_API MR_EdgeId MR_EdgeBitSet_backId(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeId MR_EdgeBitSet_beginId(void);

MRC_API MR_EdgeId MR_EdgeBitSet_endId(const MR_EdgeBitSet *_this);

MRC_API MR_BitSet *MR_EdgeBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_EdgeBitSet_reserve(MR_EdgeBitSet *_this, size_t numBits);

MRC_API void MR_EdgeBitSet_resize(MR_EdgeBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_EdgeBitSet_clear(MR_EdgeBitSet *_this);

MRC_API void MR_EdgeBitSet_shrink_to_fit(MR_EdgeBitSet *_this);

MRC_API bool MR_EdgeBitSet_empty(const MR_EdgeBitSet *_this);

MRC_API size_t MR_EdgeBitSet_size(const MR_EdgeBitSet *_this);

MRC_API size_t MR_EdgeBitSet_num_blocks(const MR_EdgeBitSet *_this);

MRC_API size_t MR_EdgeBitSet_capacity(const MR_EdgeBitSet *_this);

MRC_API bool MR_EdgeBitSet_uncheckedTest(const MR_EdgeBitSet *_this, size_t n);

MRC_API bool MR_EdgeBitSet_uncheckedTestSet(MR_EdgeBitSet *_this, size_t n, const bool *val);

MRC_API void MR_EdgeBitSet_reverse(MR_EdgeBitSet *_this);

MRC_API void MR_EdgeBitSet_push_back(MR_EdgeBitSet *_this, bool val);

MRC_API void MR_EdgeBitSet_pop_back(MR_EdgeBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_EdgeBitSet_bits(const MR_EdgeBitSet *_this);

MRC_API bool MR_EdgeBitSet_all(const MR_EdgeBitSet *_this);

MRC_API bool MR_EdgeBitSet_any(const MR_EdgeBitSet *_this);

MRC_API bool MR_EdgeBitSet_none(const MR_EdgeBitSet *_this);

MRC_API size_t MR_EdgeBitSet_count(const MR_EdgeBitSet *_this);

MRC_API void MR_EdgeBitSet_resizeWithReserve(MR_EdgeBitSet *_this, size_t newSize);

MRC_API size_t MR_EdgeBitSet_heapBytes(const MR_EdgeBitSet *_this);

MRC_API MR_EdgeBitSet *MR_bitand_MR_EdgeBitSet(const MR_EdgeBitSet *a, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_bitor_MR_EdgeBitSet(const MR_EdgeBitSet *a, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_xor_MR_EdgeBitSet(const MR_EdgeBitSet *a, const MR_EdgeBitSet *b);

MRC_API MR_EdgeBitSet *MR_sub_MR_EdgeBitSet(const MR_EdgeBitSet *a, const MR_EdgeBitSet *b);

MRC_API MR_EdgeSetBitIterator *MR_begin_const_MR_EdgeBitSet_ref(const MR_EdgeBitSet *a);

MRC_API MR_EdgeSetBitIterator *MR_end_const_MR_EdgeBitSet_ref(const MR_EdgeBitSet *_1);

MRC_API const size_t *MR_UndirectedEdgeBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_UndirectedEdgeBitSet_Get_npos(void);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_DefaultConstruct(void);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_OffsetPtr(const MR_UndirectedEdgeBitSet *ptr, ptrdiff_t i);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_OffsetMutablePtr(MR_UndirectedEdgeBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_UndirectedEdgeBitSet_UpcastTo_MR_BitSet(const MR_UndirectedEdgeBitSet *object);

MRC_API MR_BitSet *MR_UndirectedEdgeBitSet_MutableUpcastTo_MR_BitSet(MR_UndirectedEdgeBitSet *object);

MRC_API const MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_UndirectedEdgeBitSet *_other);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_UndirectedEdgeBitSet_Destroy(const MR_UndirectedEdgeBitSet *_this);

MRC_API void MR_UndirectedEdgeBitSet_DestroyArray(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_AssignFromAnother(MR_UndirectedEdgeBitSet *_this, MR_PassBy _other_pass_by, MR_UndirectedEdgeBitSet *_other);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_set_3(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n, size_t len, bool val);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_set_2(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n, bool val);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_set_1(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_set_0(MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_reset_2(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n, size_t len);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_reset_1(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_reset_0(MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_flip_2(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n, size_t len);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_flip_1(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_flip_0(MR_UndirectedEdgeBitSet *_this);

MRC_API bool MR_UndirectedEdgeBitSet_test(const MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n);

MRC_API bool MR_UndirectedEdgeBitSet_test_set(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId n, const bool *val);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_find_first(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_find_next(const MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId pos);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_find_last(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_find_first_not_set(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_find_next_not_set(const MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId pos);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_find_last_not_set(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_nthSetBit(const MR_UndirectedEdgeBitSet *_this, size_t n);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_bitand_assign(MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_bitor_assign(MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_xor_assign(MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_sub_assign(MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_subtract(MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *b, int bShiftInBlocks);

MRC_API bool MR_UndirectedEdgeBitSet_is_subset_of(const MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *a);

MRC_API bool MR_UndirectedEdgeBitSet_intersects(const MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBitSet *a);

MRC_API void MR_UndirectedEdgeBitSet_autoResizeSet_3(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId pos, size_t len, const bool *val);

MRC_API void MR_UndirectedEdgeBitSet_autoResizeSet_2(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId pos, const bool *val);

MRC_API bool MR_UndirectedEdgeBitSet_autoResizeTestSet(MR_UndirectedEdgeBitSet *_this, MR_UndirectedEdgeId pos, const bool *val);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_getMapping_1_MR_UndirectedEdgeMap(const MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeMap *map);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_getMapping_1_MR_UndirectedEdgeBMap(const MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeBMap *map);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_getMapping_1_phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId(const MR_UndirectedEdgeBitSet *_this, const MR_phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId *map);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_getMapping_2_MR_UndirectedEdgeMap(const MR_UndirectedEdgeBitSet *_this, const MR_UndirectedEdgeMap *map, size_t resSize);

MRC_API MR_UndirectedEdgeBitSet *MR_UndirectedEdgeBitSet_getMapping_2_phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId(const MR_UndirectedEdgeBitSet *_this, const MR_phmap_flat_hash_map_MR_UndirectedEdgeId_MR_UndirectedEdgeId *map, size_t resSize);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_backId(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_beginId(void);

MRC_API MR_UndirectedEdgeId MR_UndirectedEdgeBitSet_endId(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_BitSet *MR_UndirectedEdgeBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_UndirectedEdgeBitSet_reserve(MR_UndirectedEdgeBitSet *_this, size_t numBits);

MRC_API void MR_UndirectedEdgeBitSet_resize(MR_UndirectedEdgeBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_UndirectedEdgeBitSet_clear(MR_UndirectedEdgeBitSet *_this);

MRC_API void MR_UndirectedEdgeBitSet_shrink_to_fit(MR_UndirectedEdgeBitSet *_this);

MRC_API bool MR_UndirectedEdgeBitSet_empty(const MR_UndirectedEdgeBitSet *_this);

MRC_API size_t MR_UndirectedEdgeBitSet_size(const MR_UndirectedEdgeBitSet *_this);

MRC_API size_t MR_UndirectedEdgeBitSet_num_blocks(const MR_UndirectedEdgeBitSet *_this);

MRC_API size_t MR_UndirectedEdgeBitSet_capacity(const MR_UndirectedEdgeBitSet *_this);

MRC_API bool MR_UndirectedEdgeBitSet_uncheckedTest(const MR_UndirectedEdgeBitSet *_this, size_t n);

MRC_API bool MR_UndirectedEdgeBitSet_uncheckedTestSet(MR_UndirectedEdgeBitSet *_this, size_t n, const bool *val);

MRC_API void MR_UndirectedEdgeBitSet_reverse(MR_UndirectedEdgeBitSet *_this);

MRC_API void MR_UndirectedEdgeBitSet_push_back(MR_UndirectedEdgeBitSet *_this, bool val);

MRC_API void MR_UndirectedEdgeBitSet_pop_back(MR_UndirectedEdgeBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_UndirectedEdgeBitSet_bits(const MR_UndirectedEdgeBitSet *_this);

MRC_API bool MR_UndirectedEdgeBitSet_all(const MR_UndirectedEdgeBitSet *_this);

MRC_API bool MR_UndirectedEdgeBitSet_any(const MR_UndirectedEdgeBitSet *_this);

MRC_API bool MR_UndirectedEdgeBitSet_none(const MR_UndirectedEdgeBitSet *_this);

MRC_API size_t MR_UndirectedEdgeBitSet_count(const MR_UndirectedEdgeBitSet *_this);

MRC_API void MR_UndirectedEdgeBitSet_resizeWithReserve(MR_UndirectedEdgeBitSet *_this, size_t newSize);

MRC_API size_t MR_UndirectedEdgeBitSet_heapBytes(const MR_UndirectedEdgeBitSet *_this);

MRC_API MR_UndirectedEdgeBitSet *MR_bitand_MR_UndirectedEdgeBitSet(const MR_UndirectedEdgeBitSet *a, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_bitor_MR_UndirectedEdgeBitSet(const MR_UndirectedEdgeBitSet *a, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_xor_MR_UndirectedEdgeBitSet(const MR_UndirectedEdgeBitSet *a, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeBitSet *MR_sub_MR_UndirectedEdgeBitSet(const MR_UndirectedEdgeBitSet *a, const MR_UndirectedEdgeBitSet *b);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_begin_const_MR_UndirectedEdgeBitSet_ref(const MR_UndirectedEdgeBitSet *a);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_end_const_MR_UndirectedEdgeBitSet_ref(const MR_UndirectedEdgeBitSet *_1);

MRC_API const size_t *MR_PixelBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_PixelBitSet_Get_npos(void);

MRC_API MR_PixelBitSet *MR_PixelBitSet_DefaultConstruct(void);

MRC_API MR_PixelBitSet *MR_PixelBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_PixelBitSet *MR_PixelBitSet_OffsetPtr(const MR_PixelBitSet *ptr, ptrdiff_t i);

MRC_API MR_PixelBitSet *MR_PixelBitSet_OffsetMutablePtr(MR_PixelBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_PixelBitSet_UpcastTo_MR_BitSet(const MR_PixelBitSet *object);

MRC_API MR_BitSet *MR_PixelBitSet_MutableUpcastTo_MR_BitSet(MR_PixelBitSet *object);

MRC_API const MR_PixelBitSet *MR_PixelBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_PixelBitSet *MR_PixelBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_PixelBitSet *MR_PixelBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_PixelBitSet *_other);

MRC_API MR_PixelBitSet *MR_PixelBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_PixelBitSet *MR_PixelBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_PixelBitSet *MR_PixelBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_PixelBitSet_Destroy(const MR_PixelBitSet *_this);

MRC_API void MR_PixelBitSet_DestroyArray(const MR_PixelBitSet *_this);

MRC_API MR_PixelBitSet *MR_PixelBitSet_AssignFromAnother(MR_PixelBitSet *_this, MR_PassBy _other_pass_by, MR_PixelBitSet *_other);

MRC_API MR_PixelBitSet *MR_PixelBitSet_set_3(MR_PixelBitSet *_this, MR_PixelId n, size_t len, bool val);

MRC_API MR_PixelBitSet *MR_PixelBitSet_set_2(MR_PixelBitSet *_this, MR_PixelId n, bool val);

MRC_API MR_PixelBitSet *MR_PixelBitSet_set_1(MR_PixelBitSet *_this, MR_PixelId n);

MRC_API MR_PixelBitSet *MR_PixelBitSet_set_0(MR_PixelBitSet *_this);

MRC_API MR_PixelBitSet *MR_PixelBitSet_reset_2(MR_PixelBitSet *_this, MR_PixelId n, size_t len);

MRC_API MR_PixelBitSet *MR_PixelBitSet_reset_1(MR_PixelBitSet *_this, MR_PixelId n);

MRC_API MR_PixelBitSet *MR_PixelBitSet_reset_0(MR_PixelBitSet *_this);

MRC_API MR_PixelBitSet *MR_PixelBitSet_flip_2(MR_PixelBitSet *_this, MR_PixelId n, size_t len);

MRC_API MR_PixelBitSet *MR_PixelBitSet_flip_1(MR_PixelBitSet *_this, MR_PixelId n);

MRC_API MR_PixelBitSet *MR_PixelBitSet_flip_0(MR_PixelBitSet *_this);

MRC_API bool MR_PixelBitSet_test(const MR_PixelBitSet *_this, MR_PixelId n);

MRC_API bool MR_PixelBitSet_test_set(MR_PixelBitSet *_this, MR_PixelId n, const bool *val);

MRC_API MR_PixelId MR_PixelBitSet_find_first(const MR_PixelBitSet *_this);

MRC_API MR_PixelId MR_PixelBitSet_find_next(const MR_PixelBitSet *_this, MR_PixelId pos);

MRC_API MR_PixelId MR_PixelBitSet_find_last(const MR_PixelBitSet *_this);

MRC_API MR_PixelId MR_PixelBitSet_find_first_not_set(const MR_PixelBitSet *_this);

MRC_API MR_PixelId MR_PixelBitSet_find_next_not_set(const MR_PixelBitSet *_this, MR_PixelId pos);

MRC_API MR_PixelId MR_PixelBitSet_find_last_not_set(const MR_PixelBitSet *_this);

MRC_API MR_PixelId MR_PixelBitSet_nthSetBit(const MR_PixelBitSet *_this, size_t n);

MRC_API MR_PixelBitSet *MR_PixelBitSet_bitand_assign(MR_PixelBitSet *_this, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_PixelBitSet_bitor_assign(MR_PixelBitSet *_this, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_PixelBitSet_xor_assign(MR_PixelBitSet *_this, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_PixelBitSet_sub_assign(MR_PixelBitSet *_this, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_PixelBitSet_subtract(MR_PixelBitSet *_this, const MR_PixelBitSet *b, int bShiftInBlocks);

MRC_API bool MR_PixelBitSet_is_subset_of(const MR_PixelBitSet *_this, const MR_PixelBitSet *a);

MRC_API bool MR_PixelBitSet_intersects(const MR_PixelBitSet *_this, const MR_PixelBitSet *a);

MRC_API void MR_PixelBitSet_autoResizeSet_3(MR_PixelBitSet *_this, MR_PixelId pos, size_t len, const bool *val);

MRC_API void MR_PixelBitSet_autoResizeSet_2(MR_PixelBitSet *_this, MR_PixelId pos, const bool *val);

MRC_API bool MR_PixelBitSet_autoResizeTestSet(MR_PixelBitSet *_this, MR_PixelId pos, const bool *val);

MRC_API MR_PixelBitSet *MR_PixelBitSet_getMapping_1_MR_Vector_MR_PixelId_MR_PixelId(const MR_PixelBitSet *_this, const MR_Vector_MR_PixelId_MR_PixelId *map);

MRC_API MR_PixelBitSet *MR_PixelBitSet_getMapping_1_MR_BMap_MR_PixelId_MR_PixelId(const MR_PixelBitSet *_this, const MR_BMap_MR_PixelId_MR_PixelId *map);

MRC_API MR_PixelBitSet *MR_PixelBitSet_getMapping_1_phmap_flat_hash_map_MR_PixelId_MR_PixelId(const MR_PixelBitSet *_this, const MR_phmap_flat_hash_map_MR_PixelId_MR_PixelId *map);

MRC_API MR_PixelBitSet *MR_PixelBitSet_getMapping_2_MR_Vector_MR_PixelId_MR_PixelId(const MR_PixelBitSet *_this, const MR_Vector_MR_PixelId_MR_PixelId *map, size_t resSize);

MRC_API MR_PixelBitSet *MR_PixelBitSet_getMapping_2_phmap_flat_hash_map_MR_PixelId_MR_PixelId(const MR_PixelBitSet *_this, const MR_phmap_flat_hash_map_MR_PixelId_MR_PixelId *map, size_t resSize);

MRC_API MR_PixelId MR_PixelBitSet_backId(const MR_PixelBitSet *_this);

MRC_API MR_PixelId MR_PixelBitSet_beginId(void);

MRC_API MR_PixelId MR_PixelBitSet_endId(const MR_PixelBitSet *_this);

MRC_API MR_BitSet *MR_PixelBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_PixelBitSet_reserve(MR_PixelBitSet *_this, size_t numBits);

MRC_API void MR_PixelBitSet_resize(MR_PixelBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_PixelBitSet_clear(MR_PixelBitSet *_this);

MRC_API void MR_PixelBitSet_shrink_to_fit(MR_PixelBitSet *_this);

MRC_API bool MR_PixelBitSet_empty(const MR_PixelBitSet *_this);

MRC_API size_t MR_PixelBitSet_size(const MR_PixelBitSet *_this);

MRC_API size_t MR_PixelBitSet_num_blocks(const MR_PixelBitSet *_this);

MRC_API size_t MR_PixelBitSet_capacity(const MR_PixelBitSet *_this);

MRC_API bool MR_PixelBitSet_uncheckedTest(const MR_PixelBitSet *_this, size_t n);

MRC_API bool MR_PixelBitSet_uncheckedTestSet(MR_PixelBitSet *_this, size_t n, const bool *val);

MRC_API void MR_PixelBitSet_reverse(MR_PixelBitSet *_this);

MRC_API void MR_PixelBitSet_push_back(MR_PixelBitSet *_this, bool val);

MRC_API void MR_PixelBitSet_pop_back(MR_PixelBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_PixelBitSet_bits(const MR_PixelBitSet *_this);

MRC_API bool MR_PixelBitSet_all(const MR_PixelBitSet *_this);

MRC_API bool MR_PixelBitSet_any(const MR_PixelBitSet *_this);

MRC_API bool MR_PixelBitSet_none(const MR_PixelBitSet *_this);

MRC_API size_t MR_PixelBitSet_count(const MR_PixelBitSet *_this);

MRC_API void MR_PixelBitSet_resizeWithReserve(MR_PixelBitSet *_this, size_t newSize);

MRC_API size_t MR_PixelBitSet_heapBytes(const MR_PixelBitSet *_this);

MRC_API MR_PixelBitSet *MR_bitand_MR_PixelBitSet(const MR_PixelBitSet *a, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_bitor_MR_PixelBitSet(const MR_PixelBitSet *a, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_xor_MR_PixelBitSet(const MR_PixelBitSet *a, const MR_PixelBitSet *b);

MRC_API MR_PixelBitSet *MR_sub_MR_PixelBitSet(const MR_PixelBitSet *a, const MR_PixelBitSet *b);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_begin_const_MR_PixelBitSet_ref(const MR_PixelBitSet *a);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_end_const_MR_PixelBitSet_ref(const MR_PixelBitSet *_1);

MRC_API const size_t *MR_VoxelBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_VoxelBitSet_Get_npos(void);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_DefaultConstruct(void);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_VoxelBitSet *MR_VoxelBitSet_OffsetPtr(const MR_VoxelBitSet *ptr, ptrdiff_t i);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_OffsetMutablePtr(MR_VoxelBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_VoxelBitSet_UpcastTo_MR_BitSet(const MR_VoxelBitSet *object);

MRC_API MR_BitSet *MR_VoxelBitSet_MutableUpcastTo_MR_BitSet(MR_VoxelBitSet *object);

MRC_API const MR_VoxelBitSet *MR_VoxelBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_VoxelBitSet *_other);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_VoxelBitSet_Destroy(const MR_VoxelBitSet *_this);

MRC_API void MR_VoxelBitSet_DestroyArray(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_AssignFromAnother(MR_VoxelBitSet *_this, MR_PassBy _other_pass_by, MR_VoxelBitSet *_other);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_set_3(MR_VoxelBitSet *_this, MR_VoxelId n, size_t len, bool val);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_set_2(MR_VoxelBitSet *_this, MR_VoxelId n, bool val);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_set_1(MR_VoxelBitSet *_this, MR_VoxelId n);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_set_0(MR_VoxelBitSet *_this);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_reset_2(MR_VoxelBitSet *_this, MR_VoxelId n, size_t len);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_reset_1(MR_VoxelBitSet *_this, MR_VoxelId n);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_reset_0(MR_VoxelBitSet *_this);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_flip_2(MR_VoxelBitSet *_this, MR_VoxelId n, size_t len);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_flip_1(MR_VoxelBitSet *_this, MR_VoxelId n);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_flip_0(MR_VoxelBitSet *_this);

MRC_API bool MR_VoxelBitSet_test(const MR_VoxelBitSet *_this, MR_VoxelId n);

MRC_API bool MR_VoxelBitSet_test_set(MR_VoxelBitSet *_this, MR_VoxelId n, const bool *val);

MRC_API MR_VoxelId MR_VoxelBitSet_find_first(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelId MR_VoxelBitSet_find_next(const MR_VoxelBitSet *_this, MR_VoxelId pos);

MRC_API MR_VoxelId MR_VoxelBitSet_find_last(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelId MR_VoxelBitSet_find_first_not_set(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelId MR_VoxelBitSet_find_next_not_set(const MR_VoxelBitSet *_this, MR_VoxelId pos);

MRC_API MR_VoxelId MR_VoxelBitSet_find_last_not_set(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelId MR_VoxelBitSet_nthSetBit(const MR_VoxelBitSet *_this, size_t n);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_bitand_assign(MR_VoxelBitSet *_this, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_bitor_assign(MR_VoxelBitSet *_this, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_xor_assign(MR_VoxelBitSet *_this, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_sub_assign(MR_VoxelBitSet *_this, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_subtract(MR_VoxelBitSet *_this, const MR_VoxelBitSet *b, int bShiftInBlocks);

MRC_API bool MR_VoxelBitSet_is_subset_of(const MR_VoxelBitSet *_this, const MR_VoxelBitSet *a);

MRC_API bool MR_VoxelBitSet_intersects(const MR_VoxelBitSet *_this, const MR_VoxelBitSet *a);

MRC_API void MR_VoxelBitSet_autoResizeSet_3(MR_VoxelBitSet *_this, MR_VoxelId pos, size_t len, const bool *val);

MRC_API void MR_VoxelBitSet_autoResizeSet_2(MR_VoxelBitSet *_this, MR_VoxelId pos, const bool *val);

MRC_API bool MR_VoxelBitSet_autoResizeTestSet(MR_VoxelBitSet *_this, MR_VoxelId pos, const bool *val);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_getMapping_1_MR_Vector_MR_VoxelId_MR_VoxelId(const MR_VoxelBitSet *_this, const MR_Vector_MR_VoxelId_MR_VoxelId *map);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_getMapping_1_MR_BMap_MR_VoxelId_MR_VoxelId(const MR_VoxelBitSet *_this, const MR_BMap_MR_VoxelId_MR_VoxelId *map);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_getMapping_1_phmap_flat_hash_map_MR_VoxelId_MR_VoxelId(const MR_VoxelBitSet *_this, const MR_phmap_flat_hash_map_MR_VoxelId_MR_VoxelId *map);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_getMapping_2_MR_Vector_MR_VoxelId_MR_VoxelId(const MR_VoxelBitSet *_this, const MR_Vector_MR_VoxelId_MR_VoxelId *map, size_t resSize);

MRC_API MR_VoxelBitSet *MR_VoxelBitSet_getMapping_2_phmap_flat_hash_map_MR_VoxelId_MR_VoxelId(const MR_VoxelBitSet *_this, const MR_phmap_flat_hash_map_MR_VoxelId_MR_VoxelId *map, size_t resSize);

MRC_API MR_VoxelId MR_VoxelBitSet_backId(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelId MR_VoxelBitSet_beginId(void);

MRC_API MR_VoxelId MR_VoxelBitSet_endId(const MR_VoxelBitSet *_this);

MRC_API MR_BitSet *MR_VoxelBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_VoxelBitSet_reserve(MR_VoxelBitSet *_this, size_t numBits);

MRC_API void MR_VoxelBitSet_resize(MR_VoxelBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_VoxelBitSet_clear(MR_VoxelBitSet *_this);

MRC_API void MR_VoxelBitSet_shrink_to_fit(MR_VoxelBitSet *_this);

MRC_API bool MR_VoxelBitSet_empty(const MR_VoxelBitSet *_this);

MRC_API size_t MR_VoxelBitSet_size(const MR_VoxelBitSet *_this);

MRC_API size_t MR_VoxelBitSet_num_blocks(const MR_VoxelBitSet *_this);

MRC_API size_t MR_VoxelBitSet_capacity(const MR_VoxelBitSet *_this);

MRC_API bool MR_VoxelBitSet_uncheckedTest(const MR_VoxelBitSet *_this, size_t n);

MRC_API bool MR_VoxelBitSet_uncheckedTestSet(MR_VoxelBitSet *_this, size_t n, const bool *val);

MRC_API void MR_VoxelBitSet_reverse(MR_VoxelBitSet *_this);

MRC_API void MR_VoxelBitSet_push_back(MR_VoxelBitSet *_this, bool val);

MRC_API void MR_VoxelBitSet_pop_back(MR_VoxelBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_VoxelBitSet_bits(const MR_VoxelBitSet *_this);

MRC_API bool MR_VoxelBitSet_all(const MR_VoxelBitSet *_this);

MRC_API bool MR_VoxelBitSet_any(const MR_VoxelBitSet *_this);

MRC_API bool MR_VoxelBitSet_none(const MR_VoxelBitSet *_this);

MRC_API size_t MR_VoxelBitSet_count(const MR_VoxelBitSet *_this);

MRC_API void MR_VoxelBitSet_resizeWithReserve(MR_VoxelBitSet *_this, size_t newSize);

MRC_API size_t MR_VoxelBitSet_heapBytes(const MR_VoxelBitSet *_this);

MRC_API MR_VoxelBitSet *MR_bitand_MR_VoxelBitSet(const MR_VoxelBitSet *a, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_bitor_MR_VoxelBitSet(const MR_VoxelBitSet *a, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_xor_MR_VoxelBitSet(const MR_VoxelBitSet *a, const MR_VoxelBitSet *b);

MRC_API MR_VoxelBitSet *MR_sub_MR_VoxelBitSet(const MR_VoxelBitSet *a, const MR_VoxelBitSet *b);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_begin_const_MR_VoxelBitSet_ref(const MR_VoxelBitSet *a);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_end_const_MR_VoxelBitSet_ref(const MR_VoxelBitSet *_1);

MRC_API const size_t *MR_RegionBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_RegionBitSet_Get_npos(void);

MRC_API MR_RegionBitSet *MR_RegionBitSet_DefaultConstruct(void);

MRC_API MR_RegionBitSet *MR_RegionBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_RegionBitSet *MR_RegionBitSet_OffsetPtr(const MR_RegionBitSet *ptr, ptrdiff_t i);

MRC_API MR_RegionBitSet *MR_RegionBitSet_OffsetMutablePtr(MR_RegionBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_RegionBitSet_UpcastTo_MR_BitSet(const MR_RegionBitSet *object);

MRC_API MR_BitSet *MR_RegionBitSet_MutableUpcastTo_MR_BitSet(MR_RegionBitSet *object);

MRC_API const MR_RegionBitSet *MR_RegionBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_RegionBitSet *MR_RegionBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_RegionBitSet *MR_RegionBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_RegionBitSet *_other);

MRC_API MR_RegionBitSet *MR_RegionBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_RegionBitSet *MR_RegionBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_RegionBitSet *MR_RegionBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_RegionBitSet_Destroy(const MR_RegionBitSet *_this);

MRC_API void MR_RegionBitSet_DestroyArray(const MR_RegionBitSet *_this);

MRC_API MR_RegionBitSet *MR_RegionBitSet_AssignFromAnother(MR_RegionBitSet *_this, MR_PassBy _other_pass_by, MR_RegionBitSet *_other);

MRC_API MR_RegionBitSet *MR_RegionBitSet_set_3(MR_RegionBitSet *_this, MR_RegionId n, size_t len, bool val);

MRC_API MR_RegionBitSet *MR_RegionBitSet_set_2(MR_RegionBitSet *_this, MR_RegionId n, bool val);

MRC_API MR_RegionBitSet *MR_RegionBitSet_set_1(MR_RegionBitSet *_this, MR_RegionId n);

MRC_API MR_RegionBitSet *MR_RegionBitSet_set_0(MR_RegionBitSet *_this);

MRC_API MR_RegionBitSet *MR_RegionBitSet_reset_2(MR_RegionBitSet *_this, MR_RegionId n, size_t len);

MRC_API MR_RegionBitSet *MR_RegionBitSet_reset_1(MR_RegionBitSet *_this, MR_RegionId n);

MRC_API MR_RegionBitSet *MR_RegionBitSet_reset_0(MR_RegionBitSet *_this);

MRC_API MR_RegionBitSet *MR_RegionBitSet_flip_2(MR_RegionBitSet *_this, MR_RegionId n, size_t len);

MRC_API MR_RegionBitSet *MR_RegionBitSet_flip_1(MR_RegionBitSet *_this, MR_RegionId n);

MRC_API MR_RegionBitSet *MR_RegionBitSet_flip_0(MR_RegionBitSet *_this);

MRC_API bool MR_RegionBitSet_test(const MR_RegionBitSet *_this, MR_RegionId n);

MRC_API bool MR_RegionBitSet_test_set(MR_RegionBitSet *_this, MR_RegionId n, const bool *val);

MRC_API MR_RegionId MR_RegionBitSet_find_first(const MR_RegionBitSet *_this);

MRC_API MR_RegionId MR_RegionBitSet_find_next(const MR_RegionBitSet *_this, MR_RegionId pos);

MRC_API MR_RegionId MR_RegionBitSet_find_last(const MR_RegionBitSet *_this);

MRC_API MR_RegionId MR_RegionBitSet_find_first_not_set(const MR_RegionBitSet *_this);

MRC_API MR_RegionId MR_RegionBitSet_find_next_not_set(const MR_RegionBitSet *_this, MR_RegionId pos);

MRC_API MR_RegionId MR_RegionBitSet_find_last_not_set(const MR_RegionBitSet *_this);

MRC_API MR_RegionId MR_RegionBitSet_nthSetBit(const MR_RegionBitSet *_this, size_t n);

MRC_API MR_RegionBitSet *MR_RegionBitSet_bitand_assign(MR_RegionBitSet *_this, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_RegionBitSet_bitor_assign(MR_RegionBitSet *_this, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_RegionBitSet_xor_assign(MR_RegionBitSet *_this, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_RegionBitSet_sub_assign(MR_RegionBitSet *_this, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_RegionBitSet_subtract(MR_RegionBitSet *_this, const MR_RegionBitSet *b, int bShiftInBlocks);

MRC_API bool MR_RegionBitSet_is_subset_of(const MR_RegionBitSet *_this, const MR_RegionBitSet *a);

MRC_API bool MR_RegionBitSet_intersects(const MR_RegionBitSet *_this, const MR_RegionBitSet *a);

MRC_API void MR_RegionBitSet_autoResizeSet_3(MR_RegionBitSet *_this, MR_RegionId pos, size_t len, const bool *val);

MRC_API void MR_RegionBitSet_autoResizeSet_2(MR_RegionBitSet *_this, MR_RegionId pos, const bool *val);

MRC_API bool MR_RegionBitSet_autoResizeTestSet(MR_RegionBitSet *_this, MR_RegionId pos, const bool *val);

MRC_API MR_RegionBitSet *MR_RegionBitSet_getMapping_1_MR_Vector_MR_RegionId_MR_RegionId(const MR_RegionBitSet *_this, const MR_Vector_MR_RegionId_MR_RegionId *map);

MRC_API MR_RegionBitSet *MR_RegionBitSet_getMapping_1_MR_BMap_MR_RegionId_MR_RegionId(const MR_RegionBitSet *_this, const MR_BMap_MR_RegionId_MR_RegionId *map);

MRC_API MR_RegionBitSet *MR_RegionBitSet_getMapping_1_phmap_flat_hash_map_MR_RegionId_MR_RegionId(const MR_RegionBitSet *_this, const MR_phmap_flat_hash_map_MR_RegionId_MR_RegionId *map);

MRC_API MR_RegionBitSet *MR_RegionBitSet_getMapping_2_MR_Vector_MR_RegionId_MR_RegionId(const MR_RegionBitSet *_this, const MR_Vector_MR_RegionId_MR_RegionId *map, size_t resSize);

MRC_API MR_RegionBitSet *MR_RegionBitSet_getMapping_2_phmap_flat_hash_map_MR_RegionId_MR_RegionId(const MR_RegionBitSet *_this, const MR_phmap_flat_hash_map_MR_RegionId_MR_RegionId *map, size_t resSize);

MRC_API MR_RegionId MR_RegionBitSet_backId(const MR_RegionBitSet *_this);

MRC_API MR_RegionId MR_RegionBitSet_beginId(void);

MRC_API MR_RegionId MR_RegionBitSet_endId(const MR_RegionBitSet *_this);

MRC_API MR_BitSet *MR_RegionBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_RegionBitSet_reserve(MR_RegionBitSet *_this, size_t numBits);

MRC_API void MR_RegionBitSet_resize(MR_RegionBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_RegionBitSet_clear(MR_RegionBitSet *_this);

MRC_API void MR_RegionBitSet_shrink_to_fit(MR_RegionBitSet *_this);

MRC_API bool MR_RegionBitSet_empty(const MR_RegionBitSet *_this);

MRC_API size_t MR_RegionBitSet_size(const MR_RegionBitSet *_this);

MRC_API size_t MR_RegionBitSet_num_blocks(const MR_RegionBitSet *_this);

MRC_API size_t MR_RegionBitSet_capacity(const MR_RegionBitSet *_this);

MRC_API bool MR_RegionBitSet_uncheckedTest(const MR_RegionBitSet *_this, size_t n);

MRC_API bool MR_RegionBitSet_uncheckedTestSet(MR_RegionBitSet *_this, size_t n, const bool *val);

MRC_API void MR_RegionBitSet_reverse(MR_RegionBitSet *_this);

MRC_API void MR_RegionBitSet_push_back(MR_RegionBitSet *_this, bool val);

MRC_API void MR_RegionBitSet_pop_back(MR_RegionBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_RegionBitSet_bits(const MR_RegionBitSet *_this);

MRC_API bool MR_RegionBitSet_all(const MR_RegionBitSet *_this);

MRC_API bool MR_RegionBitSet_any(const MR_RegionBitSet *_this);

MRC_API bool MR_RegionBitSet_none(const MR_RegionBitSet *_this);

MRC_API size_t MR_RegionBitSet_count(const MR_RegionBitSet *_this);

MRC_API void MR_RegionBitSet_resizeWithReserve(MR_RegionBitSet *_this, size_t newSize);

MRC_API size_t MR_RegionBitSet_heapBytes(const MR_RegionBitSet *_this);

MRC_API MR_RegionBitSet *MR_bitand_MR_RegionBitSet(const MR_RegionBitSet *a, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_bitor_MR_RegionBitSet(const MR_RegionBitSet *a, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_xor_MR_RegionBitSet(const MR_RegionBitSet *a, const MR_RegionBitSet *b);

MRC_API MR_RegionBitSet *MR_sub_MR_RegionBitSet(const MR_RegionBitSet *a, const MR_RegionBitSet *b);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_begin_const_MR_RegionBitSet_ref(const MR_RegionBitSet *a);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_end_const_MR_RegionBitSet_ref(const MR_RegionBitSet *_1);

MRC_API const size_t *MR_NodeBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_NodeBitSet_Get_npos(void);

MRC_API MR_NodeBitSet *MR_NodeBitSet_DefaultConstruct(void);

MRC_API MR_NodeBitSet *MR_NodeBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_NodeBitSet *MR_NodeBitSet_OffsetPtr(const MR_NodeBitSet *ptr, ptrdiff_t i);

MRC_API MR_NodeBitSet *MR_NodeBitSet_OffsetMutablePtr(MR_NodeBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_NodeBitSet_UpcastTo_MR_BitSet(const MR_NodeBitSet *object);

MRC_API MR_BitSet *MR_NodeBitSet_MutableUpcastTo_MR_BitSet(MR_NodeBitSet *object);

MRC_API const MR_NodeBitSet *MR_NodeBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_NodeBitSet *MR_NodeBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_NodeBitSet *MR_NodeBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_NodeBitSet *_other);

MRC_API MR_NodeBitSet *MR_NodeBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_NodeBitSet *MR_NodeBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_NodeBitSet *MR_NodeBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_NodeBitSet_Destroy(const MR_NodeBitSet *_this);

MRC_API void MR_NodeBitSet_DestroyArray(const MR_NodeBitSet *_this);

MRC_API MR_NodeBitSet *MR_NodeBitSet_AssignFromAnother(MR_NodeBitSet *_this, MR_PassBy _other_pass_by, MR_NodeBitSet *_other);

MRC_API MR_NodeBitSet *MR_NodeBitSet_set_3(MR_NodeBitSet *_this, MR_NodeId n, size_t len, bool val);

MRC_API MR_NodeBitSet *MR_NodeBitSet_set_2(MR_NodeBitSet *_this, MR_NodeId n, bool val);

MRC_API MR_NodeBitSet *MR_NodeBitSet_set_1(MR_NodeBitSet *_this, MR_NodeId n);

MRC_API MR_NodeBitSet *MR_NodeBitSet_set_0(MR_NodeBitSet *_this);

MRC_API MR_NodeBitSet *MR_NodeBitSet_reset_2(MR_NodeBitSet *_this, MR_NodeId n, size_t len);

MRC_API MR_NodeBitSet *MR_NodeBitSet_reset_1(MR_NodeBitSet *_this, MR_NodeId n);

MRC_API MR_NodeBitSet *MR_NodeBitSet_reset_0(MR_NodeBitSet *_this);

MRC_API MR_NodeBitSet *MR_NodeBitSet_flip_2(MR_NodeBitSet *_this, MR_NodeId n, size_t len);

MRC_API MR_NodeBitSet *MR_NodeBitSet_flip_1(MR_NodeBitSet *_this, MR_NodeId n);

MRC_API MR_NodeBitSet *MR_NodeBitSet_flip_0(MR_NodeBitSet *_this);

MRC_API bool MR_NodeBitSet_test(const MR_NodeBitSet *_this, MR_NodeId n);

MRC_API bool MR_NodeBitSet_test_set(MR_NodeBitSet *_this, MR_NodeId n, const bool *val);

MRC_API MR_NodeId MR_NodeBitSet_find_first(const MR_NodeBitSet *_this);

MRC_API MR_NodeId MR_NodeBitSet_find_next(const MR_NodeBitSet *_this, MR_NodeId pos);

MRC_API MR_NodeId MR_NodeBitSet_find_last(const MR_NodeBitSet *_this);

MRC_API MR_NodeId MR_NodeBitSet_find_first_not_set(const MR_NodeBitSet *_this);

MRC_API MR_NodeId MR_NodeBitSet_find_next_not_set(const MR_NodeBitSet *_this, MR_NodeId pos);

MRC_API MR_NodeId MR_NodeBitSet_find_last_not_set(const MR_NodeBitSet *_this);

MRC_API MR_NodeId MR_NodeBitSet_nthSetBit(const MR_NodeBitSet *_this, size_t n);

MRC_API MR_NodeBitSet *MR_NodeBitSet_bitand_assign(MR_NodeBitSet *_this, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_NodeBitSet_bitor_assign(MR_NodeBitSet *_this, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_NodeBitSet_xor_assign(MR_NodeBitSet *_this, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_NodeBitSet_sub_assign(MR_NodeBitSet *_this, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_NodeBitSet_subtract(MR_NodeBitSet *_this, const MR_NodeBitSet *b, int bShiftInBlocks);

MRC_API bool MR_NodeBitSet_is_subset_of(const MR_NodeBitSet *_this, const MR_NodeBitSet *a);

MRC_API bool MR_NodeBitSet_intersects(const MR_NodeBitSet *_this, const MR_NodeBitSet *a);

MRC_API void MR_NodeBitSet_autoResizeSet_3(MR_NodeBitSet *_this, MR_NodeId pos, size_t len, const bool *val);

MRC_API void MR_NodeBitSet_autoResizeSet_2(MR_NodeBitSet *_this, MR_NodeId pos, const bool *val);

MRC_API bool MR_NodeBitSet_autoResizeTestSet(MR_NodeBitSet *_this, MR_NodeId pos, const bool *val);

MRC_API MR_NodeBitSet *MR_NodeBitSet_getMapping_1_MR_Vector_MR_NodeId_MR_NodeId(const MR_NodeBitSet *_this, const MR_Vector_MR_NodeId_MR_NodeId *map);

MRC_API MR_NodeBitSet *MR_NodeBitSet_getMapping_1_MR_BMap_MR_NodeId_MR_NodeId(const MR_NodeBitSet *_this, const MR_BMap_MR_NodeId_MR_NodeId *map);

MRC_API MR_NodeBitSet *MR_NodeBitSet_getMapping_1_phmap_flat_hash_map_MR_NodeId_MR_NodeId(const MR_NodeBitSet *_this, const MR_phmap_flat_hash_map_MR_NodeId_MR_NodeId *map);

MRC_API MR_NodeBitSet *MR_NodeBitSet_getMapping_2_MR_Vector_MR_NodeId_MR_NodeId(const MR_NodeBitSet *_this, const MR_Vector_MR_NodeId_MR_NodeId *map, size_t resSize);

MRC_API MR_NodeBitSet *MR_NodeBitSet_getMapping_2_phmap_flat_hash_map_MR_NodeId_MR_NodeId(const MR_NodeBitSet *_this, const MR_phmap_flat_hash_map_MR_NodeId_MR_NodeId *map, size_t resSize);

MRC_API MR_NodeId MR_NodeBitSet_backId(const MR_NodeBitSet *_this);

MRC_API MR_NodeId MR_NodeBitSet_beginId(void);

MRC_API MR_NodeId MR_NodeBitSet_endId(const MR_NodeBitSet *_this);

MRC_API MR_BitSet *MR_NodeBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_NodeBitSet_reserve(MR_NodeBitSet *_this, size_t numBits);

MRC_API void MR_NodeBitSet_resize(MR_NodeBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_NodeBitSet_clear(MR_NodeBitSet *_this);

MRC_API void MR_NodeBitSet_shrink_to_fit(MR_NodeBitSet *_this);

MRC_API bool MR_NodeBitSet_empty(const MR_NodeBitSet *_this);

MRC_API size_t MR_NodeBitSet_size(const MR_NodeBitSet *_this);

MRC_API size_t MR_NodeBitSet_num_blocks(const MR_NodeBitSet *_this);

MRC_API size_t MR_NodeBitSet_capacity(const MR_NodeBitSet *_this);

MRC_API bool MR_NodeBitSet_uncheckedTest(const MR_NodeBitSet *_this, size_t n);

MRC_API bool MR_NodeBitSet_uncheckedTestSet(MR_NodeBitSet *_this, size_t n, const bool *val);

MRC_API void MR_NodeBitSet_reverse(MR_NodeBitSet *_this);

MRC_API void MR_NodeBitSet_push_back(MR_NodeBitSet *_this, bool val);

MRC_API void MR_NodeBitSet_pop_back(MR_NodeBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_NodeBitSet_bits(const MR_NodeBitSet *_this);

MRC_API bool MR_NodeBitSet_all(const MR_NodeBitSet *_this);

MRC_API bool MR_NodeBitSet_any(const MR_NodeBitSet *_this);

MRC_API bool MR_NodeBitSet_none(const MR_NodeBitSet *_this);

MRC_API size_t MR_NodeBitSet_count(const MR_NodeBitSet *_this);

MRC_API void MR_NodeBitSet_resizeWithReserve(MR_NodeBitSet *_this, size_t newSize);

MRC_API size_t MR_NodeBitSet_heapBytes(const MR_NodeBitSet *_this);

MRC_API MR_NodeBitSet *MR_bitand_MR_NodeBitSet(const MR_NodeBitSet *a, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_bitor_MR_NodeBitSet(const MR_NodeBitSet *a, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_xor_MR_NodeBitSet(const MR_NodeBitSet *a, const MR_NodeBitSet *b);

MRC_API MR_NodeBitSet *MR_sub_MR_NodeBitSet(const MR_NodeBitSet *a, const MR_NodeBitSet *b);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_begin_const_MR_NodeBitSet_ref(const MR_NodeBitSet *a);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_end_const_MR_NodeBitSet_ref(const MR_NodeBitSet *_1);

MRC_API const size_t *MR_ObjBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_ObjBitSet_Get_npos(void);

MRC_API MR_ObjBitSet *MR_ObjBitSet_DefaultConstruct(void);

MRC_API MR_ObjBitSet *MR_ObjBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_ObjBitSet *MR_ObjBitSet_OffsetPtr(const MR_ObjBitSet *ptr, ptrdiff_t i);

MRC_API MR_ObjBitSet *MR_ObjBitSet_OffsetMutablePtr(MR_ObjBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_ObjBitSet_UpcastTo_MR_BitSet(const MR_ObjBitSet *object);

MRC_API MR_BitSet *MR_ObjBitSet_MutableUpcastTo_MR_BitSet(MR_ObjBitSet *object);

MRC_API const MR_ObjBitSet *MR_ObjBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_ObjBitSet *MR_ObjBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_ObjBitSet *MR_ObjBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_ObjBitSet *_other);

MRC_API MR_ObjBitSet *MR_ObjBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_ObjBitSet *MR_ObjBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_ObjBitSet *MR_ObjBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_ObjBitSet_Destroy(const MR_ObjBitSet *_this);

MRC_API void MR_ObjBitSet_DestroyArray(const MR_ObjBitSet *_this);

MRC_API MR_ObjBitSet *MR_ObjBitSet_AssignFromAnother(MR_ObjBitSet *_this, MR_PassBy _other_pass_by, MR_ObjBitSet *_other);

MRC_API MR_ObjBitSet *MR_ObjBitSet_set_3(MR_ObjBitSet *_this, MR_ObjId n, size_t len, bool val);

MRC_API MR_ObjBitSet *MR_ObjBitSet_set_2(MR_ObjBitSet *_this, MR_ObjId n, bool val);

MRC_API MR_ObjBitSet *MR_ObjBitSet_set_1(MR_ObjBitSet *_this, MR_ObjId n);

MRC_API MR_ObjBitSet *MR_ObjBitSet_set_0(MR_ObjBitSet *_this);

MRC_API MR_ObjBitSet *MR_ObjBitSet_reset_2(MR_ObjBitSet *_this, MR_ObjId n, size_t len);

MRC_API MR_ObjBitSet *MR_ObjBitSet_reset_1(MR_ObjBitSet *_this, MR_ObjId n);

MRC_API MR_ObjBitSet *MR_ObjBitSet_reset_0(MR_ObjBitSet *_this);

MRC_API MR_ObjBitSet *MR_ObjBitSet_flip_2(MR_ObjBitSet *_this, MR_ObjId n, size_t len);

MRC_API MR_ObjBitSet *MR_ObjBitSet_flip_1(MR_ObjBitSet *_this, MR_ObjId n);

MRC_API MR_ObjBitSet *MR_ObjBitSet_flip_0(MR_ObjBitSet *_this);

MRC_API bool MR_ObjBitSet_test(const MR_ObjBitSet *_this, MR_ObjId n);

MRC_API bool MR_ObjBitSet_test_set(MR_ObjBitSet *_this, MR_ObjId n, const bool *val);

MRC_API MR_ObjId MR_ObjBitSet_find_first(const MR_ObjBitSet *_this);

MRC_API MR_ObjId MR_ObjBitSet_find_next(const MR_ObjBitSet *_this, MR_ObjId pos);

MRC_API MR_ObjId MR_ObjBitSet_find_last(const MR_ObjBitSet *_this);

MRC_API MR_ObjId MR_ObjBitSet_find_first_not_set(const MR_ObjBitSet *_this);

MRC_API MR_ObjId MR_ObjBitSet_find_next_not_set(const MR_ObjBitSet *_this, MR_ObjId pos);

MRC_API MR_ObjId MR_ObjBitSet_find_last_not_set(const MR_ObjBitSet *_this);

MRC_API MR_ObjId MR_ObjBitSet_nthSetBit(const MR_ObjBitSet *_this, size_t n);

MRC_API MR_ObjBitSet *MR_ObjBitSet_bitand_assign(MR_ObjBitSet *_this, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_ObjBitSet_bitor_assign(MR_ObjBitSet *_this, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_ObjBitSet_xor_assign(MR_ObjBitSet *_this, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_ObjBitSet_sub_assign(MR_ObjBitSet *_this, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_ObjBitSet_subtract(MR_ObjBitSet *_this, const MR_ObjBitSet *b, int bShiftInBlocks);

MRC_API bool MR_ObjBitSet_is_subset_of(const MR_ObjBitSet *_this, const MR_ObjBitSet *a);

MRC_API bool MR_ObjBitSet_intersects(const MR_ObjBitSet *_this, const MR_ObjBitSet *a);

MRC_API void MR_ObjBitSet_autoResizeSet_3(MR_ObjBitSet *_this, MR_ObjId pos, size_t len, const bool *val);

MRC_API void MR_ObjBitSet_autoResizeSet_2(MR_ObjBitSet *_this, MR_ObjId pos, const bool *val);

MRC_API bool MR_ObjBitSet_autoResizeTestSet(MR_ObjBitSet *_this, MR_ObjId pos, const bool *val);

MRC_API MR_ObjBitSet *MR_ObjBitSet_getMapping_1_MR_ObjMap(const MR_ObjBitSet *_this, const MR_ObjMap *map);

MRC_API MR_ObjBitSet *MR_ObjBitSet_getMapping_1_MR_BMap_MR_ObjId_MR_ObjId(const MR_ObjBitSet *_this, const MR_BMap_MR_ObjId_MR_ObjId *map);

MRC_API MR_ObjBitSet *MR_ObjBitSet_getMapping_1_phmap_flat_hash_map_MR_ObjId_MR_ObjId(const MR_ObjBitSet *_this, const MR_phmap_flat_hash_map_MR_ObjId_MR_ObjId *map);

MRC_API MR_ObjBitSet *MR_ObjBitSet_getMapping_2_MR_ObjMap(const MR_ObjBitSet *_this, const MR_ObjMap *map, size_t resSize);

MRC_API MR_ObjBitSet *MR_ObjBitSet_getMapping_2_phmap_flat_hash_map_MR_ObjId_MR_ObjId(const MR_ObjBitSet *_this, const MR_phmap_flat_hash_map_MR_ObjId_MR_ObjId *map, size_t resSize);

MRC_API MR_ObjId MR_ObjBitSet_backId(const MR_ObjBitSet *_this);

MRC_API MR_ObjId MR_ObjBitSet_beginId(void);

MRC_API MR_ObjId MR_ObjBitSet_endId(const MR_ObjBitSet *_this);

MRC_API MR_BitSet *MR_ObjBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_ObjBitSet_reserve(MR_ObjBitSet *_this, size_t numBits);

MRC_API void MR_ObjBitSet_resize(MR_ObjBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_ObjBitSet_clear(MR_ObjBitSet *_this);

MRC_API void MR_ObjBitSet_shrink_to_fit(MR_ObjBitSet *_this);

MRC_API bool MR_ObjBitSet_empty(const MR_ObjBitSet *_this);

MRC_API size_t MR_ObjBitSet_size(const MR_ObjBitSet *_this);

MRC_API size_t MR_ObjBitSet_num_blocks(const MR_ObjBitSet *_this);

MRC_API size_t MR_ObjBitSet_capacity(const MR_ObjBitSet *_this);

MRC_API bool MR_ObjBitSet_uncheckedTest(const MR_ObjBitSet *_this, size_t n);

MRC_API bool MR_ObjBitSet_uncheckedTestSet(MR_ObjBitSet *_this, size_t n, const bool *val);

MRC_API void MR_ObjBitSet_reverse(MR_ObjBitSet *_this);

MRC_API void MR_ObjBitSet_push_back(MR_ObjBitSet *_this, bool val);

MRC_API void MR_ObjBitSet_pop_back(MR_ObjBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_ObjBitSet_bits(const MR_ObjBitSet *_this);

MRC_API bool MR_ObjBitSet_all(const MR_ObjBitSet *_this);

MRC_API bool MR_ObjBitSet_any(const MR_ObjBitSet *_this);

MRC_API bool MR_ObjBitSet_none(const MR_ObjBitSet *_this);

MRC_API size_t MR_ObjBitSet_count(const MR_ObjBitSet *_this);

MRC_API void MR_ObjBitSet_resizeWithReserve(MR_ObjBitSet *_this, size_t newSize);

MRC_API size_t MR_ObjBitSet_heapBytes(const MR_ObjBitSet *_this);

MRC_API MR_ObjBitSet *MR_bitand_MR_ObjBitSet(const MR_ObjBitSet *a, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_bitor_MR_ObjBitSet(const MR_ObjBitSet *a, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_xor_MR_ObjBitSet(const MR_ObjBitSet *a, const MR_ObjBitSet *b);

MRC_API MR_ObjBitSet *MR_sub_MR_ObjBitSet(const MR_ObjBitSet *a, const MR_ObjBitSet *b);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_begin_const_MR_ObjBitSet_ref(const MR_ObjBitSet *a);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_end_const_MR_ObjBitSet_ref(const MR_ObjBitSet *_1);

MRC_API const size_t *MR_TextureBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_TextureBitSet_Get_npos(void);

MRC_API MR_TextureBitSet *MR_TextureBitSet_DefaultConstruct(void);

MRC_API MR_TextureBitSet *MR_TextureBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_TextureBitSet *MR_TextureBitSet_OffsetPtr(const MR_TextureBitSet *ptr, ptrdiff_t i);

MRC_API MR_TextureBitSet *MR_TextureBitSet_OffsetMutablePtr(MR_TextureBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_TextureBitSet_UpcastTo_MR_BitSet(const MR_TextureBitSet *object);

MRC_API MR_BitSet *MR_TextureBitSet_MutableUpcastTo_MR_BitSet(MR_TextureBitSet *object);

MRC_API const MR_TextureBitSet *MR_TextureBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_TextureBitSet *MR_TextureBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_TextureBitSet *MR_TextureBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_TextureBitSet *_other);

MRC_API MR_TextureBitSet *MR_TextureBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_TextureBitSet *MR_TextureBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_TextureBitSet *MR_TextureBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_TextureBitSet_Destroy(const MR_TextureBitSet *_this);

MRC_API void MR_TextureBitSet_DestroyArray(const MR_TextureBitSet *_this);

MRC_API MR_TextureBitSet *MR_TextureBitSet_AssignFromAnother(MR_TextureBitSet *_this, MR_PassBy _other_pass_by, MR_TextureBitSet *_other);

MRC_API MR_TextureBitSet *MR_TextureBitSet_set_3(MR_TextureBitSet *_this, MR_TextureId n, size_t len, bool val);

MRC_API MR_TextureBitSet *MR_TextureBitSet_set_2(MR_TextureBitSet *_this, MR_TextureId n, bool val);

MRC_API MR_TextureBitSet *MR_TextureBitSet_set_1(MR_TextureBitSet *_this, MR_TextureId n);

MRC_API MR_TextureBitSet *MR_TextureBitSet_set_0(MR_TextureBitSet *_this);

MRC_API MR_TextureBitSet *MR_TextureBitSet_reset_2(MR_TextureBitSet *_this, MR_TextureId n, size_t len);

MRC_API MR_TextureBitSet *MR_TextureBitSet_reset_1(MR_TextureBitSet *_this, MR_TextureId n);

MRC_API MR_TextureBitSet *MR_TextureBitSet_reset_0(MR_TextureBitSet *_this);

MRC_API MR_TextureBitSet *MR_TextureBitSet_flip_2(MR_TextureBitSet *_this, MR_TextureId n, size_t len);

MRC_API MR_TextureBitSet *MR_TextureBitSet_flip_1(MR_TextureBitSet *_this, MR_TextureId n);

MRC_API MR_TextureBitSet *MR_TextureBitSet_flip_0(MR_TextureBitSet *_this);

MRC_API bool MR_TextureBitSet_test(const MR_TextureBitSet *_this, MR_TextureId n);

MRC_API bool MR_TextureBitSet_test_set(MR_TextureBitSet *_this, MR_TextureId n, const bool *val);

MRC_API MR_TextureId MR_TextureBitSet_find_first(const MR_TextureBitSet *_this);

MRC_API MR_TextureId MR_TextureBitSet_find_next(const MR_TextureBitSet *_this, MR_TextureId pos);

MRC_API MR_TextureId MR_TextureBitSet_find_last(const MR_TextureBitSet *_this);

MRC_API MR_TextureId MR_TextureBitSet_find_first_not_set(const MR_TextureBitSet *_this);

MRC_API MR_TextureId MR_TextureBitSet_find_next_not_set(const MR_TextureBitSet *_this, MR_TextureId pos);

MRC_API MR_TextureId MR_TextureBitSet_find_last_not_set(const MR_TextureBitSet *_this);

MRC_API MR_TextureId MR_TextureBitSet_nthSetBit(const MR_TextureBitSet *_this, size_t n);

MRC_API MR_TextureBitSet *MR_TextureBitSet_bitand_assign(MR_TextureBitSet *_this, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_TextureBitSet_bitor_assign(MR_TextureBitSet *_this, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_TextureBitSet_xor_assign(MR_TextureBitSet *_this, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_TextureBitSet_sub_assign(MR_TextureBitSet *_this, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_TextureBitSet_subtract(MR_TextureBitSet *_this, const MR_TextureBitSet *b, int bShiftInBlocks);

MRC_API bool MR_TextureBitSet_is_subset_of(const MR_TextureBitSet *_this, const MR_TextureBitSet *a);

MRC_API bool MR_TextureBitSet_intersects(const MR_TextureBitSet *_this, const MR_TextureBitSet *a);

MRC_API void MR_TextureBitSet_autoResizeSet_3(MR_TextureBitSet *_this, MR_TextureId pos, size_t len, const bool *val);

MRC_API void MR_TextureBitSet_autoResizeSet_2(MR_TextureBitSet *_this, MR_TextureId pos, const bool *val);

MRC_API bool MR_TextureBitSet_autoResizeTestSet(MR_TextureBitSet *_this, MR_TextureId pos, const bool *val);

MRC_API MR_TextureBitSet *MR_TextureBitSet_getMapping_1_MR_Vector_MR_TextureId_MR_TextureId(const MR_TextureBitSet *_this, const MR_Vector_MR_TextureId_MR_TextureId *map);

MRC_API MR_TextureBitSet *MR_TextureBitSet_getMapping_1_MR_BMap_MR_TextureId_MR_TextureId(const MR_TextureBitSet *_this, const MR_BMap_MR_TextureId_MR_TextureId *map);

MRC_API MR_TextureBitSet *MR_TextureBitSet_getMapping_1_phmap_flat_hash_map_MR_TextureId_MR_TextureId(const MR_TextureBitSet *_this, const MR_phmap_flat_hash_map_MR_TextureId_MR_TextureId *map);

MRC_API MR_TextureBitSet *MR_TextureBitSet_getMapping_2_MR_Vector_MR_TextureId_MR_TextureId(const MR_TextureBitSet *_this, const MR_Vector_MR_TextureId_MR_TextureId *map, size_t resSize);

MRC_API MR_TextureBitSet *MR_TextureBitSet_getMapping_2_phmap_flat_hash_map_MR_TextureId_MR_TextureId(const MR_TextureBitSet *_this, const MR_phmap_flat_hash_map_MR_TextureId_MR_TextureId *map, size_t resSize);

MRC_API MR_TextureId MR_TextureBitSet_backId(const MR_TextureBitSet *_this);

MRC_API MR_TextureId MR_TextureBitSet_beginId(void);

MRC_API MR_TextureId MR_TextureBitSet_endId(const MR_TextureBitSet *_this);

MRC_API MR_BitSet *MR_TextureBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_TextureBitSet_reserve(MR_TextureBitSet *_this, size_t numBits);

MRC_API void MR_TextureBitSet_resize(MR_TextureBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_TextureBitSet_clear(MR_TextureBitSet *_this);

MRC_API void MR_TextureBitSet_shrink_to_fit(MR_TextureBitSet *_this);

MRC_API bool MR_TextureBitSet_empty(const MR_TextureBitSet *_this);

MRC_API size_t MR_TextureBitSet_size(const MR_TextureBitSet *_this);

MRC_API size_t MR_TextureBitSet_num_blocks(const MR_TextureBitSet *_this);

MRC_API size_t MR_TextureBitSet_capacity(const MR_TextureBitSet *_this);

MRC_API bool MR_TextureBitSet_uncheckedTest(const MR_TextureBitSet *_this, size_t n);

MRC_API bool MR_TextureBitSet_uncheckedTestSet(MR_TextureBitSet *_this, size_t n, const bool *val);

MRC_API void MR_TextureBitSet_reverse(MR_TextureBitSet *_this);

MRC_API void MR_TextureBitSet_push_back(MR_TextureBitSet *_this, bool val);

MRC_API void MR_TextureBitSet_pop_back(MR_TextureBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_TextureBitSet_bits(const MR_TextureBitSet *_this);

MRC_API bool MR_TextureBitSet_all(const MR_TextureBitSet *_this);

MRC_API bool MR_TextureBitSet_any(const MR_TextureBitSet *_this);

MRC_API bool MR_TextureBitSet_none(const MR_TextureBitSet *_this);

MRC_API size_t MR_TextureBitSet_count(const MR_TextureBitSet *_this);

MRC_API void MR_TextureBitSet_resizeWithReserve(MR_TextureBitSet *_this, size_t newSize);

MRC_API size_t MR_TextureBitSet_heapBytes(const MR_TextureBitSet *_this);

MRC_API MR_TextureBitSet *MR_bitand_MR_TextureBitSet(const MR_TextureBitSet *a, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_bitor_MR_TextureBitSet(const MR_TextureBitSet *a, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_xor_MR_TextureBitSet(const MR_TextureBitSet *a, const MR_TextureBitSet *b);

MRC_API MR_TextureBitSet *MR_sub_MR_TextureBitSet(const MR_TextureBitSet *a, const MR_TextureBitSet *b);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_begin_const_MR_TextureBitSet_ref(const MR_TextureBitSet *a);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_end_const_MR_TextureBitSet_ref(const MR_TextureBitSet *_1);

MRC_API const size_t *MR_GraphVertBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_GraphVertBitSet_Get_npos(void);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_DefaultConstruct(void);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_GraphVertBitSet *MR_GraphVertBitSet_OffsetPtr(const MR_GraphVertBitSet *ptr, ptrdiff_t i);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_OffsetMutablePtr(MR_GraphVertBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_GraphVertBitSet_UpcastTo_MR_BitSet(const MR_GraphVertBitSet *object);

MRC_API MR_BitSet *MR_GraphVertBitSet_MutableUpcastTo_MR_BitSet(MR_GraphVertBitSet *object);

MRC_API const MR_GraphVertBitSet *MR_GraphVertBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_GraphVertBitSet *_other);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_GraphVertBitSet_Destroy(const MR_GraphVertBitSet *_this);

MRC_API void MR_GraphVertBitSet_DestroyArray(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_AssignFromAnother(MR_GraphVertBitSet *_this, MR_PassBy _other_pass_by, MR_GraphVertBitSet *_other);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_set_3(MR_GraphVertBitSet *_this, MR_GraphVertId n, size_t len, bool val);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_set_2(MR_GraphVertBitSet *_this, MR_GraphVertId n, bool val);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_set_1(MR_GraphVertBitSet *_this, MR_GraphVertId n);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_set_0(MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_reset_2(MR_GraphVertBitSet *_this, MR_GraphVertId n, size_t len);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_reset_1(MR_GraphVertBitSet *_this, MR_GraphVertId n);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_reset_0(MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_flip_2(MR_GraphVertBitSet *_this, MR_GraphVertId n, size_t len);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_flip_1(MR_GraphVertBitSet *_this, MR_GraphVertId n);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_flip_0(MR_GraphVertBitSet *_this);

MRC_API bool MR_GraphVertBitSet_test(const MR_GraphVertBitSet *_this, MR_GraphVertId n);

MRC_API bool MR_GraphVertBitSet_test_set(MR_GraphVertBitSet *_this, MR_GraphVertId n, const bool *val);

MRC_API MR_GraphVertId MR_GraphVertBitSet_find_first(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertId MR_GraphVertBitSet_find_next(const MR_GraphVertBitSet *_this, MR_GraphVertId pos);

MRC_API MR_GraphVertId MR_GraphVertBitSet_find_last(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertId MR_GraphVertBitSet_find_first_not_set(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertId MR_GraphVertBitSet_find_next_not_set(const MR_GraphVertBitSet *_this, MR_GraphVertId pos);

MRC_API MR_GraphVertId MR_GraphVertBitSet_find_last_not_set(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertId MR_GraphVertBitSet_nthSetBit(const MR_GraphVertBitSet *_this, size_t n);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_bitand_assign(MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_bitor_assign(MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_xor_assign(MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_sub_assign(MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_subtract(MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *b, int bShiftInBlocks);

MRC_API bool MR_GraphVertBitSet_is_subset_of(const MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *a);

MRC_API bool MR_GraphVertBitSet_intersects(const MR_GraphVertBitSet *_this, const MR_GraphVertBitSet *a);

MRC_API void MR_GraphVertBitSet_autoResizeSet_3(MR_GraphVertBitSet *_this, MR_GraphVertId pos, size_t len, const bool *val);

MRC_API void MR_GraphVertBitSet_autoResizeSet_2(MR_GraphVertBitSet *_this, MR_GraphVertId pos, const bool *val);

MRC_API bool MR_GraphVertBitSet_autoResizeTestSet(MR_GraphVertBitSet *_this, MR_GraphVertId pos, const bool *val);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_getMapping_1_MR_Vector_MR_GraphVertId_MR_GraphVertId(const MR_GraphVertBitSet *_this, const MR_Vector_MR_GraphVertId_MR_GraphVertId *map);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_getMapping_1_MR_BMap_MR_GraphVertId_MR_GraphVertId(const MR_GraphVertBitSet *_this, const MR_BMap_MR_GraphVertId_MR_GraphVertId *map);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_getMapping_1_phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId(const MR_GraphVertBitSet *_this, const MR_phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId *map);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_getMapping_2_MR_Vector_MR_GraphVertId_MR_GraphVertId(const MR_GraphVertBitSet *_this, const MR_Vector_MR_GraphVertId_MR_GraphVertId *map, size_t resSize);

MRC_API MR_GraphVertBitSet *MR_GraphVertBitSet_getMapping_2_phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId(const MR_GraphVertBitSet *_this, const MR_phmap_flat_hash_map_MR_GraphVertId_MR_GraphVertId *map, size_t resSize);

MRC_API MR_GraphVertId MR_GraphVertBitSet_backId(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertId MR_GraphVertBitSet_beginId(void);

MRC_API MR_GraphVertId MR_GraphVertBitSet_endId(const MR_GraphVertBitSet *_this);

MRC_API MR_BitSet *MR_GraphVertBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_GraphVertBitSet_reserve(MR_GraphVertBitSet *_this, size_t numBits);

MRC_API void MR_GraphVertBitSet_resize(MR_GraphVertBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_GraphVertBitSet_clear(MR_GraphVertBitSet *_this);

MRC_API void MR_GraphVertBitSet_shrink_to_fit(MR_GraphVertBitSet *_this);

MRC_API bool MR_GraphVertBitSet_empty(const MR_GraphVertBitSet *_this);

MRC_API size_t MR_GraphVertBitSet_size(const MR_GraphVertBitSet *_this);

MRC_API size_t MR_GraphVertBitSet_num_blocks(const MR_GraphVertBitSet *_this);

MRC_API size_t MR_GraphVertBitSet_capacity(const MR_GraphVertBitSet *_this);

MRC_API bool MR_GraphVertBitSet_uncheckedTest(const MR_GraphVertBitSet *_this, size_t n);

MRC_API bool MR_GraphVertBitSet_uncheckedTestSet(MR_GraphVertBitSet *_this, size_t n, const bool *val);

MRC_API void MR_GraphVertBitSet_reverse(MR_GraphVertBitSet *_this);

MRC_API void MR_GraphVertBitSet_push_back(MR_GraphVertBitSet *_this, bool val);

MRC_API void MR_GraphVertBitSet_pop_back(MR_GraphVertBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_GraphVertBitSet_bits(const MR_GraphVertBitSet *_this);

MRC_API bool MR_GraphVertBitSet_all(const MR_GraphVertBitSet *_this);

MRC_API bool MR_GraphVertBitSet_any(const MR_GraphVertBitSet *_this);

MRC_API bool MR_GraphVertBitSet_none(const MR_GraphVertBitSet *_this);

MRC_API size_t MR_GraphVertBitSet_count(const MR_GraphVertBitSet *_this);

MRC_API void MR_GraphVertBitSet_resizeWithReserve(MR_GraphVertBitSet *_this, size_t newSize);

MRC_API size_t MR_GraphVertBitSet_heapBytes(const MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertBitSet *MR_bitand_MR_GraphVertBitSet(const MR_GraphVertBitSet *a, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_bitor_MR_GraphVertBitSet(const MR_GraphVertBitSet *a, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_xor_MR_GraphVertBitSet(const MR_GraphVertBitSet *a, const MR_GraphVertBitSet *b);

MRC_API MR_GraphVertBitSet *MR_sub_MR_GraphVertBitSet(const MR_GraphVertBitSet *a, const MR_GraphVertBitSet *b);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_begin_const_MR_GraphVertBitSet_ref(const MR_GraphVertBitSet *a);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_end_const_MR_GraphVertBitSet_ref(const MR_GraphVertBitSet *_1);

MRC_API const size_t *MR_GraphEdgeBitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_GraphEdgeBitSet_Get_npos(void);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_DefaultConstruct(void);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_OffsetPtr(const MR_GraphEdgeBitSet *ptr, ptrdiff_t i);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_OffsetMutablePtr(MR_GraphEdgeBitSet *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_GraphEdgeBitSet_UpcastTo_MR_BitSet(const MR_GraphEdgeBitSet *object);

MRC_API MR_BitSet *MR_GraphEdgeBitSet_MutableUpcastTo_MR_BitSet(MR_GraphEdgeBitSet *object);

MRC_API const MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_GraphEdgeBitSet *_other);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_GraphEdgeBitSet_Destroy(const MR_GraphEdgeBitSet *_this);

MRC_API void MR_GraphEdgeBitSet_DestroyArray(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_AssignFromAnother(MR_GraphEdgeBitSet *_this, MR_PassBy _other_pass_by, MR_GraphEdgeBitSet *_other);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_set_3(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n, size_t len, bool val);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_set_2(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n, bool val);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_set_1(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_set_0(MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_reset_2(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n, size_t len);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_reset_1(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_reset_0(MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_flip_2(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n, size_t len);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_flip_1(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_flip_0(MR_GraphEdgeBitSet *_this);

MRC_API bool MR_GraphEdgeBitSet_test(const MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n);

MRC_API bool MR_GraphEdgeBitSet_test_set(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId n, const bool *val);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_find_first(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_find_next(const MR_GraphEdgeBitSet *_this, MR_GraphEdgeId pos);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_find_last(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_find_first_not_set(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_find_next_not_set(const MR_GraphEdgeBitSet *_this, MR_GraphEdgeId pos);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_find_last_not_set(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_nthSetBit(const MR_GraphEdgeBitSet *_this, size_t n);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_bitand_assign(MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_bitor_assign(MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_xor_assign(MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_sub_assign(MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_subtract(MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *b, int bShiftInBlocks);

MRC_API bool MR_GraphEdgeBitSet_is_subset_of(const MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *a);

MRC_API bool MR_GraphEdgeBitSet_intersects(const MR_GraphEdgeBitSet *_this, const MR_GraphEdgeBitSet *a);

MRC_API void MR_GraphEdgeBitSet_autoResizeSet_3(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId pos, size_t len, const bool *val);

MRC_API void MR_GraphEdgeBitSet_autoResizeSet_2(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId pos, const bool *val);

MRC_API bool MR_GraphEdgeBitSet_autoResizeTestSet(MR_GraphEdgeBitSet *_this, MR_GraphEdgeId pos, const bool *val);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_getMapping_1_MR_Vector_MR_GraphEdgeId_MR_GraphEdgeId(const MR_GraphEdgeBitSet *_this, const MR_Vector_MR_GraphEdgeId_MR_GraphEdgeId *map);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_getMapping_1_MR_BMap_MR_GraphEdgeId_MR_GraphEdgeId(const MR_GraphEdgeBitSet *_this, const MR_BMap_MR_GraphEdgeId_MR_GraphEdgeId *map);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_getMapping_1_phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId(const MR_GraphEdgeBitSet *_this, const MR_phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId *map);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_getMapping_2_MR_Vector_MR_GraphEdgeId_MR_GraphEdgeId(const MR_GraphEdgeBitSet *_this, const MR_Vector_MR_GraphEdgeId_MR_GraphEdgeId *map, size_t resSize);

MRC_API MR_GraphEdgeBitSet *MR_GraphEdgeBitSet_getMapping_2_phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId(const MR_GraphEdgeBitSet *_this, const MR_phmap_flat_hash_map_MR_GraphEdgeId_MR_GraphEdgeId *map, size_t resSize);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_backId(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_beginId(void);

MRC_API MR_GraphEdgeId MR_GraphEdgeBitSet_endId(const MR_GraphEdgeBitSet *_this);

MRC_API MR_BitSet *MR_GraphEdgeBitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_GraphEdgeBitSet_reserve(MR_GraphEdgeBitSet *_this, size_t numBits);

MRC_API void MR_GraphEdgeBitSet_resize(MR_GraphEdgeBitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_GraphEdgeBitSet_clear(MR_GraphEdgeBitSet *_this);

MRC_API void MR_GraphEdgeBitSet_shrink_to_fit(MR_GraphEdgeBitSet *_this);

MRC_API bool MR_GraphEdgeBitSet_empty(const MR_GraphEdgeBitSet *_this);

MRC_API size_t MR_GraphEdgeBitSet_size(const MR_GraphEdgeBitSet *_this);

MRC_API size_t MR_GraphEdgeBitSet_num_blocks(const MR_GraphEdgeBitSet *_this);

MRC_API size_t MR_GraphEdgeBitSet_capacity(const MR_GraphEdgeBitSet *_this);

MRC_API bool MR_GraphEdgeBitSet_uncheckedTest(const MR_GraphEdgeBitSet *_this, size_t n);

MRC_API bool MR_GraphEdgeBitSet_uncheckedTestSet(MR_GraphEdgeBitSet *_this, size_t n, const bool *val);

MRC_API void MR_GraphEdgeBitSet_reverse(MR_GraphEdgeBitSet *_this);

MRC_API void MR_GraphEdgeBitSet_push_back(MR_GraphEdgeBitSet *_this, bool val);

MRC_API void MR_GraphEdgeBitSet_pop_back(MR_GraphEdgeBitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_GraphEdgeBitSet_bits(const MR_GraphEdgeBitSet *_this);

MRC_API bool MR_GraphEdgeBitSet_all(const MR_GraphEdgeBitSet *_this);

MRC_API bool MR_GraphEdgeBitSet_any(const MR_GraphEdgeBitSet *_this);

MRC_API bool MR_GraphEdgeBitSet_none(const MR_GraphEdgeBitSet *_this);

MRC_API size_t MR_GraphEdgeBitSet_count(const MR_GraphEdgeBitSet *_this);

MRC_API void MR_GraphEdgeBitSet_resizeWithReserve(MR_GraphEdgeBitSet *_this, size_t newSize);

MRC_API size_t MR_GraphEdgeBitSet_heapBytes(const MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeBitSet *MR_bitand_MR_GraphEdgeBitSet(const MR_GraphEdgeBitSet *a, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_bitor_MR_GraphEdgeBitSet(const MR_GraphEdgeBitSet *a, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_xor_MR_GraphEdgeBitSet(const MR_GraphEdgeBitSet *a, const MR_GraphEdgeBitSet *b);

MRC_API MR_GraphEdgeBitSet *MR_sub_MR_GraphEdgeBitSet(const MR_GraphEdgeBitSet *a, const MR_GraphEdgeBitSet *b);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_begin_const_MR_GraphEdgeBitSet_ref(const MR_GraphEdgeBitSet *a);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_end_const_MR_GraphEdgeBitSet_ref(const MR_GraphEdgeBitSet *_1);

MRC_API const size_t *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Get_bits_per_block(void);

MRC_API const size_t *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Get_npos(void);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_DefaultConstruct(void);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_DefaultConstructArray(size_t num_elems);

MRC_API const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_OffsetPtr(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *ptr, ptrdiff_t i);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_OffsetMutablePtr(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *ptr, ptrdiff_t i);

MRC_API const MR_BitSet *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_UpcastTo_MR_BitSet(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *object);

MRC_API MR_BitSet *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_MutableUpcastTo_MR_BitSet(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *object);

MRC_API const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_StaticDowncastFrom_MR_BitSet(const MR_BitSet *object);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_MutableStaticDowncastFrom_MR_BitSet(MR_BitSet *object);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_ConstructFromAnother(MR_PassBy _other_pass_by, MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_other);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Construct_2(size_t numBits, const bool *fillValue);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Construct_1_const_MR_BitSet_ref(const MR_BitSet *src);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Construct_1_MR_BitSet_rvalue_ref(MR_BitSet *src);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Destroy(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_DestroyArray(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_AssignFromAnother(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, MR_PassBy _other_pass_by, MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_other);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_set_3(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n, size_t len, bool val);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_set_2(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n, bool val);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_set_1(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_set_0(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_reset_2(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n, size_t len);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_reset_1(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_reset_0(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_flip_2(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n, size_t len);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_flip_1(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_flip_0(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_test(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_test_set(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *n, const bool *val);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_find_first(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_find_next(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *pos);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_find_last(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_find_first_not_set(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_find_next_not_set(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *pos);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_find_last_not_set(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_nthSetBit(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, size_t n);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_bitand_assign(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_bitor_assign(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_xor_assign(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_sub_assign(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_subtract(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b, int bShiftInBlocks);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_is_subset_of(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_intersects(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_autoResizeSet_3(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *pos, size_t len, const bool *val);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_autoResizeSet_2(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *pos, const bool *val);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_autoResizeTestSet(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Id_MR_ICPElemtTag *pos, const bool *val);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_getMapping_1_MR_Vector_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Vector_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag *map);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_getMapping_1_MR_BMap_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_BMap_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag *map);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_getMapping_1_phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag *map);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_getMapping_2_MR_Vector_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_Vector_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag *map, size_t resSize);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_getMapping_2_phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_phmap_flat_hash_map_MR_Id_MR_ICPElemtTag_MR_Id_MR_ICPElemtTag *map, size_t resSize);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_backId(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_beginId(void);

MRC_API MR_Id_MR_ICPElemtTag *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_endId(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_BitSet *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_reserve(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, size_t numBits);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_resize(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_clear(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_shrink_to_fit(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_empty(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API size_t MR_TypedBitSet_MR_Id_MR_ICPElemtTag_size(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API size_t MR_TypedBitSet_MR_Id_MR_ICPElemtTag_num_blocks(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API size_t MR_TypedBitSet_MR_Id_MR_ICPElemtTag_capacity(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_uncheckedTest(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, size_t n);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_uncheckedTestSet(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, size_t n, const bool *val);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_reverse(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_push_back(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, bool val);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_pop_back(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API const MR_std_vector_uint64_t *MR_TypedBitSet_MR_Id_MR_ICPElemtTag_bits(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_all(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_any(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_TypedBitSet_MR_Id_MR_ICPElemtTag_none(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API size_t MR_TypedBitSet_MR_Id_MR_ICPElemtTag_count(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_TypedBitSet_MR_Id_MR_ICPElemtTag_resizeWithReserve(MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, size_t newSize);

MRC_API size_t MR_TypedBitSet_MR_Id_MR_ICPElemtTag_heapBytes(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_bitand_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_bitor_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_xor_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_sub_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a, const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_begin_const_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_ref(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_end_const_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_ref(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_1);

MRC_API MR_SetBitIterator *MR_SetBitIterator_DefaultConstruct(void);

MRC_API MR_SetBitIterator *MR_SetBitIterator_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIterator *MR_SetBitIterator_OffsetPtr(const MR_SetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_SetBitIterator *MR_SetBitIterator_OffsetMutablePtr(MR_SetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_SetBitIterator *MR_SetBitIterator_ConstructFromAnother(const MR_SetBitIterator *_other);

MRC_API MR_SetBitIterator *MR_SetBitIterator_Construct(const MR_BitSet *bitset);

MRC_API void MR_SetBitIterator_Destroy(const MR_SetBitIterator *_this);

MRC_API void MR_SetBitIterator_DestroyArray(const MR_SetBitIterator *_this);

MRC_API MR_SetBitIterator *MR_SetBitIterator_AssignFromAnother(MR_SetBitIterator *_this, const MR_SetBitIterator *_other);

MRC_API MR_SetBitIterator *MR_incr_MR_SetBitIterator(MR_SetBitIterator *_this);

MRC_API MR_SetBitIterator *MR_post_incr_MR_SetBitIterator(MR_SetBitIterator *_this);

MRC_API const MR_BitSet *MR_SetBitIterator_bitset(const MR_SetBitIterator *_this);

MRC_API size_t MR_deref_MR_SetBitIterator(const MR_SetBitIterator *_this);

MRC_API bool MR_equal_MR_SetBitIterator(const MR_SetBitIterator *a, const MR_SetBitIterator *b);

MRC_API MR_FaceSetBitIterator *MR_FaceSetBitIterator_DefaultConstruct(void);

MRC_API MR_FaceSetBitIterator *MR_FaceSetBitIterator_DefaultConstructArray(size_t num_elems);

MRC_API const MR_FaceSetBitIterator *MR_FaceSetBitIterator_OffsetPtr(const MR_FaceSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_FaceSetBitIterator *MR_FaceSetBitIterator_OffsetMutablePtr(MR_FaceSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_FaceSetBitIterator *MR_FaceSetBitIterator_ConstructFromAnother(const MR_FaceSetBitIterator *_other);

MRC_API MR_FaceSetBitIterator *MR_FaceSetBitIterator_Construct(const MR_FaceBitSet *bitset);

MRC_API void MR_FaceSetBitIterator_Destroy(const MR_FaceSetBitIterator *_this);

MRC_API void MR_FaceSetBitIterator_DestroyArray(const MR_FaceSetBitIterator *_this);

MRC_API MR_FaceSetBitIterator *MR_FaceSetBitIterator_AssignFromAnother(MR_FaceSetBitIterator *_this, const MR_FaceSetBitIterator *_other);

MRC_API MR_FaceSetBitIterator *MR_incr_MR_FaceSetBitIterator(MR_FaceSetBitIterator *_this);

MRC_API MR_FaceSetBitIterator *MR_post_incr_MR_FaceSetBitIterator(MR_FaceSetBitIterator *_this);

MRC_API const MR_FaceBitSet *MR_FaceSetBitIterator_bitset(const MR_FaceSetBitIterator *_this);

MRC_API MR_FaceId MR_deref_MR_FaceSetBitIterator(const MR_FaceSetBitIterator *_this);

MRC_API bool MR_equal_MR_FaceSetBitIterator(const MR_FaceSetBitIterator *a, const MR_FaceSetBitIterator *b);

MRC_API MR_VertSetBitIterator *MR_VertSetBitIterator_DefaultConstruct(void);

MRC_API MR_VertSetBitIterator *MR_VertSetBitIterator_DefaultConstructArray(size_t num_elems);

MRC_API const MR_VertSetBitIterator *MR_VertSetBitIterator_OffsetPtr(const MR_VertSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_VertSetBitIterator *MR_VertSetBitIterator_OffsetMutablePtr(MR_VertSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_VertSetBitIterator *MR_VertSetBitIterator_ConstructFromAnother(const MR_VertSetBitIterator *_other);

MRC_API MR_VertSetBitIterator *MR_VertSetBitIterator_Construct(const MR_VertBitSet *bitset);

MRC_API void MR_VertSetBitIterator_Destroy(const MR_VertSetBitIterator *_this);

MRC_API void MR_VertSetBitIterator_DestroyArray(const MR_VertSetBitIterator *_this);

MRC_API MR_VertSetBitIterator *MR_VertSetBitIterator_AssignFromAnother(MR_VertSetBitIterator *_this, const MR_VertSetBitIterator *_other);

MRC_API MR_VertSetBitIterator *MR_incr_MR_VertSetBitIterator(MR_VertSetBitIterator *_this);

MRC_API MR_VertSetBitIterator *MR_post_incr_MR_VertSetBitIterator(MR_VertSetBitIterator *_this);

MRC_API const MR_VertBitSet *MR_VertSetBitIterator_bitset(const MR_VertSetBitIterator *_this);

MRC_API MR_VertId MR_deref_MR_VertSetBitIterator(const MR_VertSetBitIterator *_this);

MRC_API bool MR_equal_MR_VertSetBitIterator(const MR_VertSetBitIterator *a, const MR_VertSetBitIterator *b);

MRC_API MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_DefaultConstruct(void);

MRC_API MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_DefaultConstructArray(size_t num_elems);

MRC_API const MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_OffsetPtr(const MR_EdgeSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_OffsetMutablePtr(MR_EdgeSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_ConstructFromAnother(const MR_EdgeSetBitIterator *_other);

MRC_API MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_Construct(const MR_EdgeBitSet *bitset);

MRC_API void MR_EdgeSetBitIterator_Destroy(const MR_EdgeSetBitIterator *_this);

MRC_API void MR_EdgeSetBitIterator_DestroyArray(const MR_EdgeSetBitIterator *_this);

MRC_API MR_EdgeSetBitIterator *MR_EdgeSetBitIterator_AssignFromAnother(MR_EdgeSetBitIterator *_this, const MR_EdgeSetBitIterator *_other);

MRC_API MR_EdgeSetBitIterator *MR_incr_MR_EdgeSetBitIterator(MR_EdgeSetBitIterator *_this);

MRC_API MR_EdgeSetBitIterator *MR_post_incr_MR_EdgeSetBitIterator(MR_EdgeSetBitIterator *_this);

MRC_API const MR_EdgeBitSet *MR_EdgeSetBitIterator_bitset(const MR_EdgeSetBitIterator *_this);

MRC_API MR_EdgeId MR_deref_MR_EdgeSetBitIterator(const MR_EdgeSetBitIterator *_this);

MRC_API bool MR_equal_MR_EdgeSetBitIterator(const MR_EdgeSetBitIterator *a, const MR_EdgeSetBitIterator *b);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_DefaultConstruct(void);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_DefaultConstructArray(size_t num_elems);

MRC_API const MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_OffsetPtr(const MR_UndirectedEdgeSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_OffsetMutablePtr(MR_UndirectedEdgeSetBitIterator *ptr, ptrdiff_t i);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_ConstructFromAnother(const MR_UndirectedEdgeSetBitIterator *_other);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_Construct(const MR_UndirectedEdgeBitSet *bitset);

MRC_API void MR_UndirectedEdgeSetBitIterator_Destroy(const MR_UndirectedEdgeSetBitIterator *_this);

MRC_API void MR_UndirectedEdgeSetBitIterator_DestroyArray(const MR_UndirectedEdgeSetBitIterator *_this);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_UndirectedEdgeSetBitIterator_AssignFromAnother(MR_UndirectedEdgeSetBitIterator *_this, const MR_UndirectedEdgeSetBitIterator *_other);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_incr_MR_UndirectedEdgeSetBitIterator(MR_UndirectedEdgeSetBitIterator *_this);

MRC_API MR_UndirectedEdgeSetBitIterator *MR_post_incr_MR_UndirectedEdgeSetBitIterator(MR_UndirectedEdgeSetBitIterator *_this);

MRC_API const MR_UndirectedEdgeBitSet *MR_UndirectedEdgeSetBitIterator_bitset(const MR_UndirectedEdgeSetBitIterator *_this);

MRC_API MR_UndirectedEdgeId MR_deref_MR_UndirectedEdgeSetBitIterator(const MR_UndirectedEdgeSetBitIterator *_this);

MRC_API bool MR_equal_MR_UndirectedEdgeSetBitIterator(const MR_UndirectedEdgeSetBitIterator *a, const MR_UndirectedEdgeSetBitIterator *b);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_PixelBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_PixelBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_PixelBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_Construct(const MR_PixelBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_PixelBitSet_Destroy(const MR_SetBitIteratorT_MR_PixelBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_PixelBitSet_DestroyArray(const MR_SetBitIteratorT_MR_PixelBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_PixelBitSet *_this, const MR_SetBitIteratorT_MR_PixelBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_incr_MR_SetBitIteratorT_MR_PixelBitSet(MR_SetBitIteratorT_MR_PixelBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_PixelBitSet *MR_post_incr_MR_SetBitIteratorT_MR_PixelBitSet(MR_SetBitIteratorT_MR_PixelBitSet *_this);

MRC_API const MR_PixelBitSet *MR_SetBitIteratorT_MR_PixelBitSet_bitset(const MR_SetBitIteratorT_MR_PixelBitSet *_this);

MRC_API MR_PixelId MR_deref_MR_SetBitIteratorT_MR_PixelBitSet(const MR_SetBitIteratorT_MR_PixelBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_PixelBitSet(const MR_SetBitIteratorT_MR_PixelBitSet *a, const MR_SetBitIteratorT_MR_PixelBitSet *b);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_VoxelBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_VoxelBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_VoxelBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_Construct(const MR_VoxelBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_VoxelBitSet_Destroy(const MR_SetBitIteratorT_MR_VoxelBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_VoxelBitSet_DestroyArray(const MR_SetBitIteratorT_MR_VoxelBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_VoxelBitSet *_this, const MR_SetBitIteratorT_MR_VoxelBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_incr_MR_SetBitIteratorT_MR_VoxelBitSet(MR_SetBitIteratorT_MR_VoxelBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_VoxelBitSet *MR_post_incr_MR_SetBitIteratorT_MR_VoxelBitSet(MR_SetBitIteratorT_MR_VoxelBitSet *_this);

MRC_API const MR_VoxelBitSet *MR_SetBitIteratorT_MR_VoxelBitSet_bitset(const MR_SetBitIteratorT_MR_VoxelBitSet *_this);

MRC_API MR_VoxelId MR_deref_MR_SetBitIteratorT_MR_VoxelBitSet(const MR_SetBitIteratorT_MR_VoxelBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_VoxelBitSet(const MR_SetBitIteratorT_MR_VoxelBitSet *a, const MR_SetBitIteratorT_MR_VoxelBitSet *b);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_RegionBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_RegionBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_RegionBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_Construct(const MR_RegionBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_RegionBitSet_Destroy(const MR_SetBitIteratorT_MR_RegionBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_RegionBitSet_DestroyArray(const MR_SetBitIteratorT_MR_RegionBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_RegionBitSet *_this, const MR_SetBitIteratorT_MR_RegionBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_incr_MR_SetBitIteratorT_MR_RegionBitSet(MR_SetBitIteratorT_MR_RegionBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_RegionBitSet *MR_post_incr_MR_SetBitIteratorT_MR_RegionBitSet(MR_SetBitIteratorT_MR_RegionBitSet *_this);

MRC_API const MR_RegionBitSet *MR_SetBitIteratorT_MR_RegionBitSet_bitset(const MR_SetBitIteratorT_MR_RegionBitSet *_this);

MRC_API MR_RegionId MR_deref_MR_SetBitIteratorT_MR_RegionBitSet(const MR_SetBitIteratorT_MR_RegionBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_RegionBitSet(const MR_SetBitIteratorT_MR_RegionBitSet *a, const MR_SetBitIteratorT_MR_RegionBitSet *b);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_NodeBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_NodeBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_NodeBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_Construct(const MR_NodeBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_NodeBitSet_Destroy(const MR_SetBitIteratorT_MR_NodeBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_NodeBitSet_DestroyArray(const MR_SetBitIteratorT_MR_NodeBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_NodeBitSet *_this, const MR_SetBitIteratorT_MR_NodeBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_incr_MR_SetBitIteratorT_MR_NodeBitSet(MR_SetBitIteratorT_MR_NodeBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_NodeBitSet *MR_post_incr_MR_SetBitIteratorT_MR_NodeBitSet(MR_SetBitIteratorT_MR_NodeBitSet *_this);

MRC_API const MR_NodeBitSet *MR_SetBitIteratorT_MR_NodeBitSet_bitset(const MR_SetBitIteratorT_MR_NodeBitSet *_this);

MRC_API MR_NodeId MR_deref_MR_SetBitIteratorT_MR_NodeBitSet(const MR_SetBitIteratorT_MR_NodeBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_NodeBitSet(const MR_SetBitIteratorT_MR_NodeBitSet *a, const MR_SetBitIteratorT_MR_NodeBitSet *b);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_ObjBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_ObjBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_ObjBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_Construct(const MR_ObjBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_ObjBitSet_Destroy(const MR_SetBitIteratorT_MR_ObjBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_ObjBitSet_DestroyArray(const MR_SetBitIteratorT_MR_ObjBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_ObjBitSet *_this, const MR_SetBitIteratorT_MR_ObjBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_incr_MR_SetBitIteratorT_MR_ObjBitSet(MR_SetBitIteratorT_MR_ObjBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_ObjBitSet *MR_post_incr_MR_SetBitIteratorT_MR_ObjBitSet(MR_SetBitIteratorT_MR_ObjBitSet *_this);

MRC_API const MR_ObjBitSet *MR_SetBitIteratorT_MR_ObjBitSet_bitset(const MR_SetBitIteratorT_MR_ObjBitSet *_this);

MRC_API MR_ObjId MR_deref_MR_SetBitIteratorT_MR_ObjBitSet(const MR_SetBitIteratorT_MR_ObjBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_ObjBitSet(const MR_SetBitIteratorT_MR_ObjBitSet *a, const MR_SetBitIteratorT_MR_ObjBitSet *b);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_TextureBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_TextureBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_TextureBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_Construct(const MR_TextureBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_TextureBitSet_Destroy(const MR_SetBitIteratorT_MR_TextureBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_TextureBitSet_DestroyArray(const MR_SetBitIteratorT_MR_TextureBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_TextureBitSet *_this, const MR_SetBitIteratorT_MR_TextureBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_incr_MR_SetBitIteratorT_MR_TextureBitSet(MR_SetBitIteratorT_MR_TextureBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_TextureBitSet *MR_post_incr_MR_SetBitIteratorT_MR_TextureBitSet(MR_SetBitIteratorT_MR_TextureBitSet *_this);

MRC_API const MR_TextureBitSet *MR_SetBitIteratorT_MR_TextureBitSet_bitset(const MR_SetBitIteratorT_MR_TextureBitSet *_this);

MRC_API MR_TextureId MR_deref_MR_SetBitIteratorT_MR_TextureBitSet(const MR_SetBitIteratorT_MR_TextureBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_TextureBitSet(const MR_SetBitIteratorT_MR_TextureBitSet *a, const MR_SetBitIteratorT_MR_TextureBitSet *b);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_GraphVertBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_GraphVertBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_GraphVertBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_Construct(const MR_GraphVertBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_GraphVertBitSet_Destroy(const MR_SetBitIteratorT_MR_GraphVertBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_GraphVertBitSet_DestroyArray(const MR_SetBitIteratorT_MR_GraphVertBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_GraphVertBitSet *_this, const MR_SetBitIteratorT_MR_GraphVertBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_incr_MR_SetBitIteratorT_MR_GraphVertBitSet(MR_SetBitIteratorT_MR_GraphVertBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_GraphVertBitSet *MR_post_incr_MR_SetBitIteratorT_MR_GraphVertBitSet(MR_SetBitIteratorT_MR_GraphVertBitSet *_this);

MRC_API const MR_GraphVertBitSet *MR_SetBitIteratorT_MR_GraphVertBitSet_bitset(const MR_SetBitIteratorT_MR_GraphVertBitSet *_this);

MRC_API MR_GraphVertId MR_deref_MR_SetBitIteratorT_MR_GraphVertBitSet(const MR_SetBitIteratorT_MR_GraphVertBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_GraphVertBitSet(const MR_SetBitIteratorT_MR_GraphVertBitSet *a, const MR_SetBitIteratorT_MR_GraphVertBitSet *b);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_OffsetPtr(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_OffsetMutablePtr(MR_SetBitIteratorT_MR_GraphEdgeBitSet *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_ConstructFromAnother(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_Construct(const MR_GraphEdgeBitSet *bitset);

MRC_API void MR_SetBitIteratorT_MR_GraphEdgeBitSet_Destroy(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this);

MRC_API void MR_SetBitIteratorT_MR_GraphEdgeBitSet_DestroyArray(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_AssignFromAnother(MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this, const MR_SetBitIteratorT_MR_GraphEdgeBitSet *_other);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_incr_MR_SetBitIteratorT_MR_GraphEdgeBitSet(MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this);

MRC_API MR_SetBitIteratorT_MR_GraphEdgeBitSet *MR_post_incr_MR_SetBitIteratorT_MR_GraphEdgeBitSet(MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this);

MRC_API const MR_GraphEdgeBitSet *MR_SetBitIteratorT_MR_GraphEdgeBitSet_bitset(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this);

MRC_API MR_GraphEdgeId MR_deref_MR_SetBitIteratorT_MR_GraphEdgeBitSet(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_GraphEdgeBitSet(const MR_SetBitIteratorT_MR_GraphEdgeBitSet *a, const MR_SetBitIteratorT_MR_GraphEdgeBitSet *b);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_DefaultConstruct(void);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_DefaultConstructArray(size_t num_elems);

MRC_API const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_OffsetPtr(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_OffsetMutablePtr(MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *ptr, ptrdiff_t i);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_ConstructFromAnother(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_other);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Construct(const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *bitset);

MRC_API void MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_Destroy(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API void MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_DestroyArray(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_AssignFromAnother(MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this, const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_other);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_incr_MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_post_incr_MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API const MR_TypedBitSet_MR_Id_MR_ICPElemtTag *MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag_bitset(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API MR_Id_MR_ICPElemtTag *MR_deref_MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *_this);

MRC_API bool MR_equal_MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag(const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *a, const MR_SetBitIteratorT_MR_TypedBitSet_MR_Id_MR_ICPElemtTag *b);

MRC_API const size_t *MR_BitSet_Get_bits_per_block(void);

MRC_API const size_t *MR_BitSet_Get_npos(void);

MRC_API MR_BitSet *MR_BitSet_DefaultConstruct(void);

MRC_API MR_BitSet *MR_BitSet_DefaultConstructArray(size_t num_elems);

MRC_API const MR_BitSet *MR_BitSet_OffsetPtr(const MR_BitSet *ptr, ptrdiff_t i);

MRC_API MR_BitSet *MR_BitSet_OffsetMutablePtr(MR_BitSet *ptr, ptrdiff_t i);

MRC_API MR_BitSet *MR_BitSet_ConstructFromAnother(MR_PassBy _other_pass_by, MR_BitSet *_other);

MRC_API MR_BitSet *MR_BitSet_Construct(size_t numBits, const bool *fillValue);

MRC_API void MR_BitSet_Destroy(const MR_BitSet *_this);

MRC_API void MR_BitSet_DestroyArray(const MR_BitSet *_this);

MRC_API MR_BitSet *MR_BitSet_AssignFromAnother(MR_BitSet *_this, MR_PassBy _other_pass_by, MR_BitSet *_other);

MRC_API MR_BitSet *MR_BitSet_fromBlocks(MR_std_vector_uint64_t *blocks);

MRC_API void MR_BitSet_reserve(MR_BitSet *_this, size_t numBits);

MRC_API void MR_BitSet_resize(MR_BitSet *_this, size_t numBits, const bool *fillValue);

MRC_API void MR_BitSet_clear(MR_BitSet *_this);

MRC_API void MR_BitSet_shrink_to_fit(MR_BitSet *_this);

MRC_API bool MR_BitSet_empty(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_size(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_num_blocks(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_capacity(const MR_BitSet *_this);

MRC_API bool MR_BitSet_uncheckedTest(const MR_BitSet *_this, size_t n);

MRC_API bool MR_BitSet_uncheckedTestSet(MR_BitSet *_this, size_t n, const bool *val);
 
// all bits after size() we silently consider as not-set
MRC_API bool MR_BitSet_test(const MR_BitSet *_this, size_t n);

MRC_API bool MR_BitSet_test_set(MR_BitSet *_this, size_t n, const bool *val);

MRC_API MR_BitSet *MR_BitSet_set_3(MR_BitSet *_this, size_t n, size_t len, bool val);

MRC_API MR_BitSet *MR_BitSet_set_2(MR_BitSet *_this, size_t n, bool val);

MRC_API MR_BitSet *MR_BitSet_set_1(MR_BitSet *_this, size_t n);

MRC_API MR_BitSet *MR_BitSet_set_0(MR_BitSet *_this);

MRC_API MR_BitSet *MR_BitSet_reset_2(MR_BitSet *_this, size_t n, size_t len);

MRC_API MR_BitSet *MR_BitSet_reset_1(MR_BitSet *_this, size_t n);

MRC_API MR_BitSet *MR_BitSet_reset_0(MR_BitSet *_this);

MRC_API MR_BitSet *MR_BitSet_flip_2(MR_BitSet *_this, size_t n, size_t len);

MRC_API MR_BitSet *MR_BitSet_flip_1(MR_BitSet *_this, size_t n);

MRC_API MR_BitSet *MR_BitSet_flip_0(MR_BitSet *_this);

MRC_API void MR_BitSet_reverse(MR_BitSet *_this);

MRC_API void MR_BitSet_push_back(MR_BitSet *_this, bool val);

MRC_API void MR_BitSet_pop_back(MR_BitSet *_this);

MRC_API const MR_std_vector_uint64_t *MR_BitSet_bits(const MR_BitSet *_this);

MRC_API MR_BitSet *MR_BitSet_bitand_assign(MR_BitSet *_this, const MR_BitSet *b);

MRC_API MR_BitSet *MR_BitSet_bitor_assign(MR_BitSet *_this, const MR_BitSet *b);

MRC_API MR_BitSet *MR_BitSet_xor_assign(MR_BitSet *_this, const MR_BitSet *b);

MRC_API MR_BitSet *MR_BitSet_sub_assign(MR_BitSet *_this, const MR_BitSet *b);

MRC_API MR_BitSet *MR_BitSet_subtract(MR_BitSet *_this, const MR_BitSet *b, int bShiftInBlocks);

MRC_API bool MR_BitSet_all(const MR_BitSet *_this);

MRC_API bool MR_BitSet_any(const MR_BitSet *_this);

MRC_API bool MR_BitSet_none(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_count(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_find_first(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_find_next(const MR_BitSet *_this, size_t n);

MRC_API size_t MR_BitSet_find_last(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_find_first_not_set(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_find_next_not_set(const MR_BitSet *_this, size_t n);

MRC_API size_t MR_BitSet_find_last_not_set(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_nthSetBit(const MR_BitSet *_this, size_t n);

MRC_API bool MR_BitSet_is_subset_of(const MR_BitSet *_this, const MR_BitSet *a);

MRC_API bool MR_BitSet_intersects(const MR_BitSet *_this, const MR_BitSet *a);

MRC_API void MR_BitSet_resizeWithReserve(MR_BitSet *_this, size_t newSize);

MRC_API void MR_BitSet_autoResizeSet_3(MR_BitSet *_this, size_t pos, size_t len, const bool *val);

MRC_API void MR_BitSet_autoResizeSet_2(MR_BitSet *_this, size_t pos, const bool *val);

MRC_API bool MR_BitSet_autoResizeTestSet(MR_BitSet *_this, size_t pos, const bool *val);

MRC_API size_t MR_BitSet_heapBytes(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_backId(const MR_BitSet *_this);

MRC_API size_t MR_BitSet_beginId(void);

MRC_API size_t MR_BitSet_endId(const MR_BitSet *_this);

MRC_API MR_std_ostream *MR_print_MR_BitSet(MR_std_ostream *s, const MR_BitSet *bs);

MRC_API MR_std_istream *MR_input_MR_BitSet(MR_std_istream *s, MR_BitSet *bs);

MRC_API MR_SetBitIterator *MR_begin_const_MR_BitSet_ref(const MR_BitSet *a);

MRC_API MR_SetBitIterator *MR_end_const_MR_BitSet_ref(const MR_BitSet *_1);

MRC_API size_t MR_heapBytes_MR_BitSet(const MR_BitSet *bs);

MRC_API bool MR_equal_MR_BitSet(const MR_BitSet *a, const MR_BitSet *b);

MRC_API bool MR_equal_MR_VertBitSet(const MR_VertBitSet *a, const MR_VertBitSet *b);

MRC_API bool MR_equal_MR_FaceBitSet(const MR_FaceBitSet *a, const MR_FaceBitSet *b);

MRC_API bool MR_contains(const MR_FaceBitSet *bitset, MR_FaceId id);

MRC_API MR_phmap_flat_hash_map_size_t_size_t *MR_makeHashMapWithSeqNums(const MR_BitSet *bs);

MRC_API MR_BitSet *MR_bitand_MR_BitSet(const MR_BitSet *a, const MR_BitSet *b);

MRC_API MR_BitSet *MR_bitor_MR_BitSet(const MR_BitSet *a, const MR_BitSet *b);

MRC_API MR_BitSet *MR_xor_MR_BitSet(const MR_BitSet *a, const MR_BitSet *b);

MRC_API MR_BitSet *MR_sub_MR_BitSet(const MR_BitSet *a, const MR_BitSet *b);
 
#ifdef __cplusplus
} // extern "C"
#endif