ValidateBitVec

Function
August 22, 2025

Table of Contents

`ValidateBitVec`

Description

Validate whether a given BitVec object is valid. Not foolproof but will work most of the time. Aborts if provided BitVec is not valid.

Parameters

Name	Direction	Description
`bv`	in	Pointer to `BitVec` object to validate.

Success

Continue execution, meaning given BitVec object is most probably valid.

Failure

abort

Usage example (Cross-references)

In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In
In rogrammer/MisraStdC/blob/master/Include/Misra/Std/Container/BitVec/Foreach.h#L33 target=_blank>Foreach.h:33:
#define BitVecForeachIdx(bv, var, idx, body) \ style=color:#75715e> do { \ style=color:#75715e> ValidateBitVec(bv); \ style=color:#75715e> u64 idx = 0; \ style=color:#75715e> if ((bv)->length > 0) { \ Foreach.h:59:
#define BitVecForeachReverseIdx(bv, var, idx, body) \ style=color:#75715e> do { \ style=color:#75715e> ValidateBitVec(bv); \ style=color:#75715e> u64 idx = 0; \ style=color:#75715e> if ((bv)->length > 0) { \ Foreach.h:131:
#define BitVecForeachInRangeIdx(bv, var, idx, start, end, body) \ style=color:#75715e> do { \ style=color:#75715e> ValidateBitVec(bv); \ style=color:#75715e> u64 idx = 0; \ style=color:#75715e> u64 _s = start; \ Io.c:2238:
ValidateStr(o); ValidateBitVec(bv); // Store original length to calculate content size later Io.c:2294:
} ValidateBitVec(bv); // Skip leading whitespace BitVec.c:39:
void BitVecDeinit(BitVec *bitvec) { ValidateBitVec(bitvec); if (bitvec->data) { free(bitvec->data); BitVec.c:50:
void BitVecClear(BitVec *bitvec) { ValidateBitVec(bitvec); bitvec->length = 0; if (bitvec->data && bitvec->byte_size > 0) { BitVec.c:58:
void BitVecResize(BitVec *bitvec, u64 new_size) { ValidateBitVec(bitvec); if (new_size > bitvec->capacity) { BitVecReserve(bitvec, new_size); BitVec.c:87:
void BitVecReserve(BitVec *bitvec, u64 n) { ValidateBitVec(bitvec); if (n <= bitvec->capacity) return; BitVec.c:109:
void BitVecShrinkToFit(BitVec *bv) { ValidateBitVec(bv); if (bv->length == 0) { // Free all memory if empty BitVec.c:144:
void BitVecSwap(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:145:
void BitVecSwap(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); // Swap all fields BitVec.c:166:
BitVec BitVecClone(BitVec *bv) { ValidateBitVec(bv); BitVec clone = BitVecInit(); BitVec.c:187:
bool BitVecGet(BitVec *bitvec, u64 idx) { ValidateBitVec(bitvec); if (idx >= bitvec->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length); BitVec.c:198:
void BitVecSet(BitVec *bitvec, u64 idx, bool value) { ValidateBitVec(bitvec); if (idx >= bitvec->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length); BitVec.c:213:
void BitVecFlip(BitVec *bitvec, u64 idx) { ValidateBitVec(bitvec); if (idx >= bitvec->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length); BitVec.c:224:
void BitVecPush(BitVec *bitvec, bool value) { ValidateBitVec(bitvec); if (bitvec->length >= bitvec->capacity) { u64 new_capacity = bitvec->capacity == 0 ? 8 : bitvec->capacity * 2; BitVec.c:235:
bool BitVecPop(BitVec *bitvec) { ValidateBitVec(bitvec); if (bitvec->length == 0) { LOG_FATAL("Cannot pop from empty bitvector"); BitVec.c:245:
void BitVecInsert(BitVec *bitvec, u64 idx, bool value) { ValidateBitVec(bitvec); if (idx > bitvec->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length); BitVec.c:262:
void BitVecInsertRange(BitVec *bv, u64 idx, u64 count, bool value) { ValidateBitVec(bv); if (idx > bv->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length); BitVec.c:288:
void BitVecInsertMultiple(BitVec *bv, u64 idx, BitVec *other) { ValidateBitVec(bv); ValidateBitVec(other); if (idx > bv->length) { BitVec.c:289:
void BitVecInsertMultiple(BitVec *bv, u64 idx, BitVec *other) { ValidateBitVec(bv); ValidateBitVec(other); if (idx > bv->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length); BitVec.c:316:
void BitVecInsertPattern(BitVec *bv, u64 idx, u8 pattern, u64 pattern_bits) { ValidateBitVec(bv); if (idx > bv->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length); BitVec.c:343:
bool BitVecRemove(BitVec *bv, u64 idx) { ValidateBitVec(bv); if (idx >= bv->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length); BitVec.c:362:
void BitVecRemoveRange(BitVec *bv, u64 idx, u64 count) { ValidateBitVec(bv); if (idx >= bv->length) { LOG_FATAL("Index {} exceeds bitvector length {}", idx, bv->length); BitVec.c:386:
bool BitVecRemoveFirst(BitVec *bv, bool value) { ValidateBitVec(bv); u64 pos = BitVecFind(bv, value); BitVec.c:398:
bool BitVecRemoveLast(BitVec *bv, bool value) { ValidateBitVec(bv); u64 pos = BitVecFindLast(bv, value); BitVec.c:410:
u64 BitVecRemoveAll(BitVec *bv, bool value) { ValidateBitVec(bv); u64 removed_count = 0; BitVec.c:437:
u64 BitVecCountOnes(BitVec *bitvec) { ValidateBitVec(bitvec); if (!bitvec->data) return 0; BitVec.c:450:
u64 BitVecCountZeros(BitVec *bitvec) { ValidateBitVec(bitvec); return bitvec->length - BitVecCountOnes(bitvec); } BitVec.c:455:
void BitVecAnd(BitVec *result, BitVec *a, BitVec *b) { ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); BitVec.c:456:
void BitVecAnd(BitVec *result, BitVec *a, BitVec *b) { ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); BitVec.c:457:
ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); u64 min_len = MIN2(a->length, b->length); BitVec.c:470:
void BitVecOr(BitVec *result, BitVec *a, BitVec *b) { ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); BitVec.c:471:
void BitVecOr(BitVec *result, BitVec *a, BitVec *b) { ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); BitVec.c:472:
ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); u64 max_len = MAX2(a->length, b->length); BitVec.c:485:
void BitVecXor(BitVec *result, BitVec *a, BitVec *b) { ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); BitVec.c:486:
void BitVecXor(BitVec *result, BitVec *a, BitVec *b) { ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); BitVec.c:487:
ValidateBitVec(result); ValidateBitVec(a); ValidateBitVec(b); u64 max_len = MAX2(a->length, b->length); BitVec.c:500:
void BitVecNot(BitVec *result, BitVec *bitvec) { ValidateBitVec(result); ValidateBitVec(bitvec); BitVec.c:501:
void BitVecNot(BitVec *result, BitVec *bitvec) { ValidateBitVec(result); ValidateBitVec(bitvec); BitVecResize(result, bitvec->length); BitVec.c:513:
// Comparison functions style=color:#75715e> bool BitVecEquals(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:514:
bool BitVecEquals(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); if (bv1->length != bv2->length) { BitVec.c:524:
bool BitVecEqualsRange(BitVec *bv1, u64 start1, BitVec *bv2, u64 start2, u64 len) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:525:
bool BitVecEqualsRange(BitVec *bv1, u64 start1, BitVec *bv2, u64 start2, u64 len) { ValidateBitVec(bv1); ValidateBitVec(bv2); if (start1 + len > bv1->length) { BitVec.c:544:
int BitVecCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:545:
int BitVecCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 min_len = MIN2(bv1->length, bv2->length); BitVec.c:566:
int BitVecCompareRange(BitVec *bv1, u64 start1, BitVec *bv2, u64 start2, u64 len) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:567:
int BitVecCompareRange(BitVec *bv1, u64 start1, BitVec *bv2, u64 start2, u64 len) { ValidateBitVec(bv1); ValidateBitVec(bv2); if (start1 + len > bv1->length) { BitVec.c:592:
int BitVecNumericalCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:593:
int BitVecNumericalCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); // Compare as unsigned integers (LSB first) BitVec.c:613:
int BitVecWeightCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:614:
int BitVecWeightCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 weight1 = BitVecCountOnes(bv1); BitVec.c:629:
int BitVecSignedCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:630:
int BitVecSignedCompare(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); if (bv1->length == 0 && bv2->length == 0) { BitVec.c:657:
bool BitVecIsSubset(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:658:
bool BitVecIsSubset(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); // bv1 is subset of bv2 if all 1-bits in bv1 are also 1-bits in bv2 BitVec.c:681:
bool BitVecDisjoint(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:682:
bool BitVecDisjoint(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); // Disjoint if no common 1-bits BitVec.c:704:
bool BitVecIsSorted(BitVec *bv) { ValidateBitVec(bv); // Sorted means all 0s come before all 1s BitVec.c:725:
// Conversion functions style=color:#75715e> Str BitVecToStr(BitVec *bv) { ValidateBitVec(bv); Str result = StrInit(); BitVec.c:767:
u64 BitVecToBytes(BitVec *bv, u8 *bytes, u64 max_len) { ValidateBitVec(bv); if (!bytes) { LOG_FATAL("bytes is NULL"); BitVec.c:823:
u64 BitVecToInteger(BitVec *bv) { ValidateBitVec(bv); if (bv->length == 0) { return 0; BitVec.c:866:
// Shift operations style=color:#75715e> void BitVecShiftLeft(BitVec *bv, u64 positions) { ValidateBitVec(bv); if (positions == 0 || bv->length == 0) { return; BitVec.c:890:
void BitVecShiftRight(BitVec *bv, u64 positions) { ValidateBitVec(bv); if (positions == 0 || bv->length == 0) { return; BitVec.c:914:
void BitVecRotateLeft(BitVec *bv, u64 positions) { ValidateBitVec(bv); if (positions == 0 || bv->length == 0) { return; BitVec.c:938:
void BitVecRotateRight(BitVec *bv, u64 positions) { ValidateBitVec(bv); if (positions == 0 || bv->length == 0) { return; BitVec.c:962:
void BitVecReverse(BitVec *bv) { ValidateBitVec(bv); if (bv->length <= 1) { return; BitVec.c:980:
u64 BitVecFind(BitVec *bv, bool value) { ValidateBitVec(bv); for (u64 i = 0; i < bv->length; i++) { BitVec.c:991:
u64 BitVecFindLast(BitVec *bv, bool value) { ValidateBitVec(bv); if (bv->length == 0) { BitVec.c:1008:
bool BitVecAll(BitVec *bv, bool value) { ValidateBitVec(bv); for (u64 i = 0; i < bv->length; i++) { BitVec.c:1019:
bool BitVecAny(BitVec *bv, bool value) { ValidateBitVec(bv); return BitVecFind(bv, value) != SIZE_MAX; } BitVec.c:1028:
u64 BitVecLongestRun(BitVec *bv, bool value) { ValidateBitVec(bv); if (bv->length == 0) { BitVec.c:1055:
// Pattern search functions style=color:#75715e> u64 BitVecFindPattern(BitVec *bv, BitVec *pattern) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1056:
u64 BitVecFindPattern(BitVec *bv, BitVec *pattern) { ValidateBitVec(bv); ValidateBitVec(pattern); if (pattern->length == 0 || pattern->length > bv->length) { BitVec.c:1071:
u64 BitVecFindLastPattern(BitVec *bv, BitVec *pattern) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1072:
u64 BitVecFindLastPattern(BitVec *bv, BitVec *pattern) { ValidateBitVec(bv); ValidateBitVec(pattern); if (pattern->length == 0 || pattern->length > bv->length) { BitVec.c:1089:
u64 BitVecFindAllPattern(BitVec *bv, BitVec *pattern, size *results, u64 max_results) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1090:
u64 BitVecFindAllPattern(BitVec *bv, BitVec *pattern, size *results, u64 max_results) { ValidateBitVec(bv); ValidateBitVec(pattern); if (!results || max_results == 0) { BitVec.c:1115:
u64 BitVecRunLengths(BitVec *bv, u64 *runs, bool *values, u64 max_runs) { ValidateBitVec(bv); if (!runs || !values || max_runs == 0) { LOG_FATAL("invalid arguments"); BitVec.c:1162:
u64 BitVecHammingDistance(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1163:
u64 BitVecHammingDistance(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 min_length = MIN2(bv1->length, bv2->length); BitVec.c:1183:
double BitVecJaccardSimilarity(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1184:
double BitVecJaccardSimilarity(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); if (bv1->length == 0 && bv2->length == 0) { BitVec.c:1210:
double BitVecCosineSimilarity(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1211:
double BitVecCosineSimilarity(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 dot_product = BitVecDotProduct(bv1, bv2); BitVec.c:1228:
u64 BitVecDotProduct(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1229:
u64 BitVecDotProduct(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 min_length = MIN2(bv1->length, bv2->length); BitVec.c:1244:
u64 BitVecEditDistance(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1245:
u64 BitVecEditDistance(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 len1 = bv1->length; BitVec.c:1300:
double BitVecCorrelation(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1301:
double BitVecCorrelation(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 max_length = MAX2(bv1->length, bv2->length); BitVec.c:1328:
double BitVecEntropy(BitVec *bv) { ValidateBitVec(bv); if (bv->length == 0) BitVec.c:1346:
int BitVecAlignmentScore(BitVec *bv1, BitVec *bv2, int match, int mismatch) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1347:
int BitVecAlignmentScore(BitVec *bv1, BitVec *bv2, int match, int mismatch) { ValidateBitVec(bv1); ValidateBitVec(bv2); u64 min_length = MIN2(bv1->length, bv2->length); BitVec.c:1364:
u64 BitVecBestAlignment(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); BitVec.c:1365:
u64 BitVecBestAlignment(BitVec *bv1, BitVec *bv2) { ValidateBitVec(bv1); ValidateBitVec(bv2); if (bv1->length == 0 || bv2->length == 0) { BitVec.c:1400:
bool BitVecStartsWith(BitVec *bv, BitVec *prefix) { ValidateBitVec(bv); ValidateBitVec(prefix); BitVec.c:1401:
bool BitVecStartsWith(BitVec *bv, BitVec *prefix) { ValidateBitVec(bv); ValidateBitVec(prefix); if (prefix->length > bv->length) { BitVec.c:1411:
bool BitVecEndsWith(BitVec *bv, BitVec *suffix) { ValidateBitVec(bv); ValidateBitVec(suffix); BitVec.c:1412:
bool BitVecEndsWith(BitVec *bv, BitVec *suffix) { ValidateBitVec(bv); ValidateBitVec(suffix); if (suffix->length > bv->length) { BitVec.c:1425:
bool BitVecContainsAt(BitVec *bv, BitVec *pattern, u64 idx) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1426:
bool BitVecContainsAt(BitVec *bv, BitVec *pattern, u64 idx) { ValidateBitVec(bv); ValidateBitVec(pattern); if (idx + pattern->length > bv->length) { BitVec.c:1442:
u64 BitVecCountPattern(BitVec *bv, BitVec *pattern) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1443:
u64 BitVecCountPattern(BitVec *bv, BitVec *pattern) { ValidateBitVec(bv); ValidateBitVec(pattern); if (pattern->length == 0 || pattern->length > bv->length) { BitVec.c:1460:
u64 BitVecRFindPattern(BitVec *bv, BitVec *pattern, u64 start) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1461:
u64 BitVecRFindPattern(BitVec *bv, BitVec *pattern, u64 start) { ValidateBitVec(bv); ValidateBitVec(pattern); if (pattern->length == 0 || pattern->length > bv->length || start >= bv->length) { BitVec.c:1480:
bool BitVecReplace(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) { ValidateBitVec(bv); ValidateBitVec(old_pattern); ValidateBitVec(new_pattern); BitVec.c:1481:
bool BitVecReplace(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) { ValidateBitVec(bv); ValidateBitVec(old_pattern); ValidateBitVec(new_pattern); BitVec.c:1482:
ValidateBitVec(bv); ValidateBitVec(old_pattern); ValidateBitVec(new_pattern); u64 pos = BitVecFindPattern(bv, old_pattern); BitVec.c:1501:
u64 BitVecReplaceAll(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) { ValidateBitVec(bv); ValidateBitVec(old_pattern); ValidateBitVec(new_pattern); BitVec.c:1502:
u64 BitVecReplaceAll(BitVec *bv, BitVec *old_pattern, BitVec *new_pattern) { ValidateBitVec(bv); ValidateBitVec(old_pattern); ValidateBitVec(new_pattern); BitVec.c:1503:
ValidateBitVec(bv); ValidateBitVec(old_pattern); ValidateBitVec(new_pattern); u64 replacements = 0; BitVec.c:1542:
bool BitVecMatches(BitVec *bv, BitVec *pattern, BitVec *wildcard) { ValidateBitVec(bv); ValidateBitVec(pattern); ValidateBitVec(wildcard); BitVec.c:1543:
bool BitVecMatches(BitVec *bv, BitVec *pattern, BitVec *wildcard) { ValidateBitVec(bv); ValidateBitVec(pattern); ValidateBitVec(wildcard); BitVec.c:1544:
ValidateBitVec(bv); ValidateBitVec(pattern); ValidateBitVec(wildcard); if (bv->length != pattern->length || pattern->length != wildcard->length) { BitVec.c:1562:
u64 BitVecFuzzyMatch(BitVec *bv, BitVec *pattern, u64 max_errors) { ValidateBitVec(bv); ValidateBitVec(pattern); BitVec.c:1563:

    u64 BitVecFuzzyMatch(BitVec *bv, BitVec *pattern, u64 max_errors) { ValidateBitVec(bv); ValidateBitVec(pattern);

if (pattern->length > bv->length) { BitVec.c:1588:

 bool BitVecRegexMatch(BitVec *bv, const char *pattern) { ValidateBitVec(bv); if (!pattern) { LOG_FATAL("pattern is NULL"); BitVec.c:1611: u64 BitVecPrefixMatch(BitVec *bv, BitVecs *patterns) { ValidateBitVec(bv); if (!patterns) { LOG_FATAL("invalid BitVecs object provided"); BitVec.c:1626: u64 BitVecSuffixMatch(BitVec *bv, BitVecs *patterns) { ValidateBitVec(bv); if (!patterns) { LOG_FATAL("invalid arguments"); BitVec.c:1640:    }

void ValidateBitVec(const BitVec *bv) { if (!(bv)) { LOG_FATAL("Invalid bitvec object: NULL."); BitVec.Type.c:32:    // Test ValidateBitVec macro style=color:#75715e>    bool test_bitvec_validate(void) { printf("Testing ValidateBitVec macro\n");

// Create a valid bitvector BitVec.Type.c:38: // This should not abort style=color:#75715e>    ValidateBitVec(&bitvec);

// Clean up
Share :