BitVecDeinit

Documentation

API Reference

BitVecDeinit

Description

Release all storage owned by bv and reset it to the zeroed state.

Parameters

Name	Direction	Description
`bv`	in,out	Bitvector to deinitialize. Must not be used until reinitialized.

Success

Backing buffer freed; bv left with NULL data, zero length, zero capacity.

Failure

Function cannot fail; aborts on a corrupted magic via the validator.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:90:

    }
    
    void BitVecDeinit(BitVec *bitvec) {
        ValidateBitVec(bitvec);
        if (bitvec->data) {

In BitVec.c:234:

    
        if (!BitVecReserve(out, bv->length) || !BitVecResize(out, bv->length)) {
            BitVecDeinit(out);
            *out = BitVecInit(bv->allocator);
            return false;

In BitVec.c:889:

            if (str[i] == '1') {
                if (!BitVecPush(out, true)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);
                    return false;

In BitVec.c:895:

            } else if (str[i] == '0') {
                if (!BitVecPush(out, false)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);
                    return false;

In BitVec.c:983:

    
        if (!BitVecReserve(out, bit_len) || !BitVecResize(out, bit_len)) {
            BitVecDeinit(out);
            *out = BitVecInit(alloc);
            return false;

In BitVec.c:1041:

    
        if (!BitVecReserve(out, bits) || !BitVecResize(out, bits)) {
            BitVecDeinit(out);
            *out = BitVecInit(alloc);
            return false;

In BitVec.c:1121:

        BitVec temp = BitVecClone(bv);
        if (temp.length != bv->length) {
            BitVecDeinit(&temp);
            return;
        }

In BitVec.c:1131:

        }
    
        BitVecDeinit(&temp);
    }

In BitVec.c:1147:

        BitVec temp = BitVecClone(bv);
        if (temp.length != bv->length) {
            BitVecDeinit(&temp);
            return;
        }

In BitVec.c:1157:

        }
    
        BitVecDeinit(&temp);
    }

In BitVec.Memory.c:58:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:98:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:145:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Memory.c:146:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:195:

    
        // Clean up
        BitVecDeinit(&original);
        BitVecDeinit(&clone);

In BitVec.Memory.c:196:

        // Clean up
        BitVecDeinit(&original);
        BitVecDeinit(&clone);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:232:

                      BitVecGet(&clone, 0) == true && BitVecGet(&clone, 1) == false && BitVecGet(&clone, 2) == true;
    
        BitVecDeinit(&original);
        BitVecDeinit(&clone);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:233:

    
        BitVecDeinit(&original);
        BitVecDeinit(&clone);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Memory.c:268:

        result = result && (BitVecLen(&bv) == 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Memory.c:303:

        result = result && (BitVecCapacity(&bv) >= 10000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Memory.c:346:

        result = result && (BitVecLen(&bv1) == 2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:347:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Memory.c:363:

        BitVec clone1 = BitVecClone(&bv);
        result        = result && (BitVecLen(&clone1) == 0);
        BitVecDeinit(&clone1);
    
        // Test clone single element

In BitVec.Memory.c:370:

        result        = result && (BitVecLen(&clone2) == 1);
        result        = result && (BitVecGet(&clone2, 0) == true);
        BitVecDeinit(&clone2);
    
        // Test clone large data

In BitVec.Memory.c:390:

        result = result && (BitVecGet(&clone3, 0) != BitVecGet(&bv, 0));
    
        BitVecDeinit(&clone3);
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Memory.c:391:

    
        BitVecDeinit(&clone3);
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Memory.c:426:

            }
    
            BitVecDeinit(&bv1);
            BitVecDeinit(&bv2);
            BitVecDeinit(&clone);

In BitVec.Memory.c:427:

    
            BitVecDeinit(&bv1);
            BitVecDeinit(&bv2);
            BitVecDeinit(&clone);
        }

In BitVec.Memory.c:428:

            BitVecDeinit(&bv1);
            BitVecDeinit(&bv2);
            BitVecDeinit(&clone);
        }

In BitVec.Memory.c:456:

        BitVecSwap(NULL, &bv);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.Simple.c:64:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:65:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:66:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:106:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:107:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:108:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:148:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:149:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:150:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:183:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:184:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:229:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:267:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:299:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:331:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:363:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:405:

        result = result && (BitVecLen(&bv) == 1000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.Simple.c:436:

        result = result && (BitVecLen(&bv) == 2);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.Simple.c:475:

        result = result && (BitVecGet(&result_bv, 0) == false);
    
        BitVecDeinit(&result_bv);
    
        BitVecDeinit(&bv1);

In BitVec.BitWise.Simple.c:477:

        BitVecDeinit(&result_bv);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:478:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.Simple.c:514:

        result = result && (BitVecGet(&bv, 1) == false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.Simple.c:581:

        }
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:582:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:583:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.Simple.c:651:

        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0
    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:652:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.Simple.c:716:

        result = result && (BitVecGet(&bv, 4) == false);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:717:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.Simple.c:812:

        test_result = test_result && or_ones;
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:813:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:814:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.Simple.c:876:

        test_result = test_result && xor_commutative;
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);

In BitVec.BitWise.Simple.c:877:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);

In BitVec.BitWise.Simple.c:878:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:879:

        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.Simple.c:941:

        }
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.Simple.c:942:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Simple.c:943:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.Foreach.Deadend.c:43:

        BitVecRunLengths(&bv, NULL, values, 5);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return true; // Should never reach here

In BitVec.Foreach.Deadend.c:60:

        BitVecRunLengths(&bv, runs, NULL, 5);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return true; // Should never reach here

In BitVec.Foreach.Deadend.c:78:

        BitVecRunLengths(&bv, runs, values, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return true; // Should never reach here

In BitVec.Insert.c:48:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Insert.c:87:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Insert.c:118:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Insert.c:155:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&source);

In BitVec.Insert.c:156:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&source);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Insert.c:204:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);

In BitVec.Insert.c:205:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Insert.c:239:

        result = result && (BitVecGet(&bv, 999) == true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Insert.c:273:

        result = result && (BitVecGet(&bv, 500) == false);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&empty);
        BitVecDeinit(&source);

In BitVec.Insert.c:274:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&empty);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Insert.c:275:

        BitVecDeinit(&bv);
        BitVecDeinit(&empty);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Insert.c:303:

        result = result && (BitVecGet(&bv, 1) == true);  // Second bit
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Insert.c:328:

        BitVecInsertRange(&bv, SIZE_MAX, 1, true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Type.c:29:

    
        // Clean up
        BitVecDeinit(&bitvec);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Type.c:48:

    
        // Clean up
        BitVecDeinit(&bitvec);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:88:

        result    = result && (index == 1); // Should find pattern at index 1 (101...)
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:89:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:138:

        // Depending on the exact source pattern, adjust this test
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:139:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:186:

        result = result && (index == 2); // Only occurrence at index 2
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:187:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:247:

        result = result && (count == 3); // Should find at 0, 3, 6
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:248:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:287:

    
        VecDeinit(&matches);
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:288:

        VecDeinit(&matches);
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:359:

        result    = result && (results[0] == 0);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:360:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:403:

        result     = result && (count > 0); // Should find at least some patterns
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:404:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:444:

        result = result && !BitVecStartsWith(&source, &prefix);
    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:445:

    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:478:

        result = result && BitVecStartsWith(&source, &prefix);
    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:479:

    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:517:

        result = result && !BitVecEndsWith(&source, &suffix);
    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:518:

    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:542:

        result = result && !BitVecEndsWith(&source, &suffix);
    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:543:

    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:582:

        result = result && (BitVecFindPattern(&source, &pattern) == SIZE_MAX);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:583:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:616:

        result = result && BitVecContainsAt(&source, &pattern, 3);  // Should match
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:617:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:642:

        result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:643:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:680:

        result = result && (count == 3);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:681:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:720:

        result = result && (pos == 3); // Should find at position 3
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:721:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:764:

        result = result && (BitVecGet(&source, 2) == true);
    
        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);

In BitVec.Pattern.Simple.c:765:

    
        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:766:

        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:804:

        result = result && (BitVecLen(&source) == 6); // 3 * 2 = 6
    
        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);

In BitVec.Pattern.Simple.c:805:

    
        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:806:

        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:842:

        result = result && BitVecMatches(&source, &pattern, &wildcard);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);

In BitVec.Pattern.Simple.c:843:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:844:

        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:882:

        result = result && (pos == 0); // Should match 110 with 1 error
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Simple.c:883:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:909:

        result = result && !BitVecRegexMatch(&source, "111");
    
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:921:

    
        BitVec  source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        bool    result   = true;

In BitVec.Pattern.Simple.c:961:

    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Simple.c:973:

    
        BitVec  source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        bool    result   = true;

In BitVec.Pattern.Simple.c:1013:

    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return result;

In Io.Read.c:829:

        );
        StrDeinit(&result1);
        BitVecDeinit(&bv1);
    
        BitVec bv2 = BitVecInit(alloc_base);

In Io.Read.c:837:

        success    = success && (value2 == 0xDEAD);
        WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");
        BitVecDeinit(&bv2);
    
        BitVec bv3 = BitVecInit(alloc_base);

In Io.Read.c:845:

        success    = success && (value3 == 0755);
        WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");
        BitVecDeinit(&bv3);
    
        BitVec bv4 = BitVecInit(alloc_base);

In Io.Read.c:858:

        );
        StrDeinit(&result4);
        BitVecDeinit(&bv4);
    
        BitVec bv5 = BitVecInit(alloc_base);

In Io.Read.c:871:

        );
        StrDeinit(&result5);
        BitVecDeinit(&bv5);
    
        WriteFmt("Overall BitVec reading success: {}\n", success ? "true" : "false");

In Io.Write.c:575:

        StrClear(&output);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv_empty);
        BitVecDeinit(&bv2);

In Io.Write.c:576:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv_empty);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In Io.Write.c:577:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv_empty);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&bv_zero);

In Io.Write.c:578:

        BitVecDeinit(&bv_empty);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&bv_zero);
        StrDeinit(&output);

In Io.Write.c:579:

        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&bv_zero);
        StrDeinit(&output);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:89:

        result   = result && (distance == 1);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:90:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:122:

        result   = result && (distance == 2); // Length of bv1
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:123:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:174:

        result     = result && (F64Abs(similarity - 0.5) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:175:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:203:

        result     = result && (F64Abs(similarity - 1.0) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:204:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:241:

        result     = result && (F64Abs(similarity - 0.0) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:242:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:274:

        result     = result && (similarity == 0.0);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:275:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:314:

        result  = result && (product == 0);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:315:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:344:

        result  = result && (product == 1); // Only first position counts
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:345:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:391:

        result   = result && (distance == 1);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:392:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:422:

        result   = result && (distance == 2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:423:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:461:

        result      = result && (F64Abs(correlation + 1.0) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:462:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:492:

        result      = result && (correlation == 0.0); // No variance
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:493:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:525:

        result  = result && (entropy == 0.0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:548:

        result  = result && (entropy == 0.0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:583:

        result = result && (score == -3); // 3 mismatches * -1
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:584:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:613:

        result = result && (score == 2); // 2 matches
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:614:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:646:

        result       = result && (best_pos == 0 || best_pos == 4);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:647:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:674:

        result   = result && (best_pos == 0);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:675:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:726:

        result = result && (edit_dist < 100);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&small1);

In BitVec.Math.c:727:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&small1);
        BitVecDeinit(&small2);

In BitVec.Math.c:728:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&small1);
        BitVecDeinit(&small2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Math.c:729:

        BitVecDeinit(&bv2);
        BitVecDeinit(&small1);
        BitVecDeinit(&small2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Math.c:743:

        BitVecPush(&bv2, true);
        BitVecHammingDistance(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:755:

        BitVecPush(&bv1, true);
        BitVecHammingDistance(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:767:

        BitVecPush(&bv2, true);
        BitVecJaccardSimilarity(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:779:

        BitVecPush(&bv1, true);
        BitVecJaccardSimilarity(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:791:

        BitVecPush(&bv2, true);
        BitVecCosineSimilarity(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:803:

        BitVecPush(&bv1, true);
        BitVecCosineSimilarity(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:815:

        BitVecPush(&bv2, true);
        BitVecDotProduct(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:827:

        BitVecPush(&bv1, true);
        BitVecDotProduct(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:839:

        BitVecPush(&bv2, true);
        BitVecEditDistance(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:851:

        BitVecPush(&bv1, true);
        BitVecEditDistance(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:863:

        BitVecPush(&bv2, true);
        BitVecCorrelation(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:875:

        BitVecPush(&bv1, true);
        BitVecCorrelation(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:893:

        BitVecPush(&bv2, true);
        BitVecAlignmentScore(NULL, &bv2, 1, -1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:905:

        BitVecPush(&bv1, true);
        BitVecAlignmentScore(&bv1, NULL, 1, -1);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:917:

        BitVecPush(&bv2, true);
        BitVecBestAlignment(NULL, &bv2);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Math.c:929:

        BitVecPush(&bv1, true);
        BitVecBestAlignment(&bv1, NULL);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Access.Deadend.c:92:

        BitVecGet(&bv, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Deadend.c:107:

        BitVecSet(&bv, 0, true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Deadend.c:122:

        BitVecFlip(&bv, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Deadend.c:141:

        BitVecGet(&bv, 1000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Deadend.c:158:

        BitVecSet(&bv, 500, true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Deadend.c:176:

        BitVecFlip(&bv, 10);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Deadend.c:201:

        BitVecGet(&bv, SIZE_MAX);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.Deadend.c:42:

        BitVecAnd(NULL, &bv, &bv2);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Deadend.c:43:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.Deadend.c:89:

        BitVecAnd(NULL, &bv1, &bv2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Deadend.c:90:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.Deadend.c:106:

        BitVecOr(&result, &bv1, NULL);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Deadend.c:107:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.Deadend.c:123:

        BitVecXor(&result, NULL, &bv1);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.Deadend.c:124:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.Deadend.c:139:

        BitVecNot(&result, NULL);
    
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.Simple.c:50:

                      (BitVecGet(&bv, 3) == false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:74:

                      (BitVecGet(&bv, 3) == false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:103:

                      (BitVecGet(&bv, 3) == false);   // unchanged
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:132:

        result = result && (BitVecCapacity(&bv) >= 100);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:155:

        bool result = (BitVecCountOnes(&bv) == 3) && (BitVecCountZeros(&bv) == 2);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:180:

        result = result && (BitVecGet(&bv, 63) == false); // 63 % 2 == 1, so i%2==0 is false for i=63
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:202:

        result = result && (BitVecGet(&bv, 0) == false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:224:

        result = result && (BitVecGet(&bv, 0) == false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:255:

        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:295:

        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:333:

        result = result && (BitVecCountZeros(&bv) == 500);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:366:

        result = result && (BitVecCountZeros(&bv) == 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:419:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:476:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:513:

        result = result && (BitVecFindLast(&bv, false) == SIZE_MAX);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:563:

        result = result && !BitVecNone(&bv, false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:603:

        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:638:

        result = result && (BitVecFindLast(&bv, true) == 999);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:681:

        result = result && BitVecAny(&bv, false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.Simple.c:717:

        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Init.c:38:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Init.c:49:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecDeinit\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:62:

    
        // Deinitialize
        BitVecDeinit(&bv);
    
        // After deinitialization, the bitvector should be in a safe state

In BitVec.Init.c:107:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Init.c:146:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Init.c:191:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Init.c:213:

    
        // Clean up all
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Init.c:214:

        // Clean up all
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Init.c:215:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Init.c:248:

        result = result && (BitVecCapacity(&bv) == cap_before);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Init.c:287:

        result = result && (BitVecLen(&bv) == 10);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Init.c:321:

        result = result && (BitVecLen(&bv) == 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Init.c:343:

    
            result = result && (BitVecLen(&bv) == (size)(cycle % 10));
            BitVecDeinit(&bv);
        }

In BitVec.Init.c:359:

    
        // Test NULL bitvec pointer - should abort
        BitVecDeinit(NULL);
    
        // If we reach here, validation didn't work as expected

In BitVec.Init.c:378:

    
        // If we reach here, validation didn't work as expected
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Init.c:396:

    
        // If we reach here, validation didn't work as expected
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Foreach.Simple.c:65:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:100:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:135:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:169:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:209:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:248:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:294:

        result = result && (count == 1000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:336:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:377:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:427:

        result = result && (count == 2); // Should iterate over indices 8,9
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:472:

            result = result && (count4 == sz);
    
            BitVecDeinit(&bv);
        }

In BitVec.Foreach.Simple.c:516:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:551:

    
        VecDeinit(&runs);
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:569:

        u64    count = BitVecRunLengths(&empty_bv, runs, values, 5);
        result       = result && (count == 0);
        BitVecDeinit(&empty_bv);
    
        // Test 2: Single bit (true)

In BitVec.Foreach.Simple.c:577:

        result = result && (count == 1);
        result = result && (runs[0] == 1 && values[0] == true);
        BitVecDeinit(&single_bv);
    
        // Test 3: Single bit (false)

In BitVec.Foreach.Simple.c:585:

        result = result && (count == 1);
        result = result && (runs[0] == 1 && values[0] == false);
        BitVecDeinit(&single_false_bv);
    
        // Test 4: All same bits (all true)

In BitVec.Foreach.Simple.c:595:

        result = result && (count == 1);
        result = result && (runs[0] == 10 && values[0] == true);
        BitVecDeinit(&all_true_bv);
    
        // Test 5: Alternating bits (0101010)

In BitVec.Foreach.Simple.c:611:

            result = result && (alt_values[i] == (i % 2 == 0));
        }
        BitVecDeinit(&alternating_bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.Simple.c:653:

        result = result && (count == 8);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.Simple.c:718:

        }
    
        BitVecDeinit(&large_bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Remove.c:57:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Remove.c:97:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Remove.c:130:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Remove.c:171:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Remove.c:213:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Remove.c:254:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Remove.c:285:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Remove.c:313:

        result  = result && (BitVecLen(&bv) == 999);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Remove.c:346:

        result = result && (BitVecLen(&bv) == 5); // Should have 5 elements left
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Remove.c:385:

        result = result && (found == true) && (BitVecLen(&bv) == 999);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Remove.c:423:

        result = result && (count == 500) && (BitVecLen(&bv) == 500);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Remove.c:457:

        BitVecRemoveRange(&bv, SIZE_MAX, 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Remove.c:472:

        BitVecPop(&bv);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Remove.c:487:

        BitVecRemove(&bv, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Remove.c:502:

        BitVecRemoveRange(&bv, 0, 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.c:64:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:65:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:66:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:106:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:107:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:108:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:148:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:149:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:150:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:183:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&result);

In BitVec.BitWise.c:184:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&result);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:229:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:267:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:299:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:331:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:363:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:405:

        result = result && (BitVecLen(&bv) == 1000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.c:436:

        result = result && (BitVecLen(&bv) == 2);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.c:475:

        result = result && (BitVecGet(&result_bv, 0) == false);
    
        BitVecDeinit(&result_bv);
    
        BitVecDeinit(&bv1);

In BitVec.BitWise.c:477:

        BitVecDeinit(&result_bv);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:478:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.c:514:

        result = result && (BitVecGet(&bv, 1) == false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.c:581:

        }
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:582:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:583:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.c:651:

        result = result && (BitVecGet(&bv, 2) == true);  // original bit 0
    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:652:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.c:716:

        result = result && (BitVecGet(&bv, 4) == false);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:717:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.BitWise.c:812:

        test_result = test_result && or_ones;
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:813:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:814:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.c:876:

        test_result = test_result && xor_commutative;
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);

In BitVec.BitWise.c:877:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);

In BitVec.BitWise.c:878:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:879:

        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.c:941:

        }
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);

In BitVec.BitWise.c:942:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:943:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return test_result;

In BitVec.BitWise.c:969:

        BitVecAnd(NULL, &bv, &bv2);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:970:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.c:1016:

        BitVecAnd(NULL, &bv1, &bv2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:1017:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.c:1033:

        BitVecOr(&result, &bv1, NULL);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:1034:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.c:1050:

        BitVecXor(&result, NULL, &bv1);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);

In BitVec.BitWise.c:1051:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.BitWise.c:1066:

        BitVecNot(&result, NULL);
    
        BitVecDeinit(&result);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Convert.c:60:

        // Clean up
        StrDeinit(&str);
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:90:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&empty_bv);

In BitVec.Convert.c:91:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&empty_bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:127:

            result = result && (bytes[0] == 0xCD || bytes[0] == 0xB3);
        }
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:165:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:203:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);

In BitVec.Convert.c:204:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:256:

    
        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&zero_bv);

In BitVec.Convert.c:257:

        // Clean up
        BitVecDeinit(&bv);
        BitVecDeinit(&zero_bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:284:

    
        StrDeinit(&str);
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Convert.c:319:

        StrDeinit(&str_obj);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Convert.c:334:

        BitVec bv1 = BitVecFromStr("", ALLOCATOR_OF(&alloc));
        result     = result && (BitVecLen(&bv1) == 0);
        BitVecDeinit(&bv1);
    
        // Test single character

In BitVec.Convert.c:340:

        result     = result && (BitVecLen(&bv2) == 1);
        result     = result && (BitVecGet(&bv2, 0) == true);
        BitVecDeinit(&bv2);
    
        // Test long string

In BitVec.Convert.c:353:

        result     = result && (BitVecGet(&bv3, 0) == true);
        result     = result && (BitVecGet(&bv3, 1) == false);
        BitVecDeinit(&bv3);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:377:

        BitVec bv2            = BitVecFromBytes(empty_bytes, 0, ALLOCATOR_OF(&alloc)); // 0 bits
        result                = result && (BitVecLen(&bv2) == 0);
        BitVecDeinit(&bv2);
    
        // Test single byte

In BitVec.Convert.c:383:

        BitVec bv3            = BitVecFromBytes(single_byte, 8, ALLOCATOR_OF(&alloc)); // 8 bits from 1 byte
        result                = result && (BitVecLen(&bv3) == 8);
        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);

In BitVec.Convert.c:385:

        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Convert.c:405:

        BitVec bv2 = BitVecFromInteger(0, 8, ALLOCATOR_OF(&alloc)); // 8 bits for zero
        result     = result && (BitVecLen(&bv2) == 8);              // Should be 8 bits
        BitVecDeinit(&bv2);
    
        // Test large integer

In BitVec.Convert.c:410:

        BitVec bv3 = BitVecFromInteger(UINT64_MAX, 64, ALLOCATOR_OF(&alloc)); // 64 bits for max value
        result     = result && (BitVecLen(&bv3) == 64);
        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);

In BitVec.Convert.c:412:

        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Convert.c:436:

    
            StrDeinit(&str);
            BitVecDeinit(&bv);
        }

In BitVec.Convert.c:457:

                result = result && (recovered == value);
    
                BitVecDeinit(&bv);
            }
        }

In BitVec.Convert.c:472:

            result = result && (recovered_byte == test_bytes[i]);
    
            BitVecDeinit(&bv);
        }

In BitVec.Convert.c:494:

        u64 large_value = BitVecToInteger(&large_bv);
        result          = result && (large_value == 0xFFFFFFFFFFFFFFFF);
        BitVecDeinit(&large_bv);
    
        // Test oversized bitvec to integer (should handle gracefully)

In BitVec.Convert.c:505:

        // Should return some value or 0, but not crash
        result = result && (oversized_value >= 0); // Always true for u64, but documents intent
        BitVecDeinit(&oversized);
    
        // Test zero-length conversions

In BitVec.Convert.c:522:

        result             = result && (empty_bytes[0] == 0xFF); // Should be unchanged
    
        BitVecDeinit(&empty);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:570:

            result       = result && (written == test_cases[i].byte_count);
    
            BitVecDeinit(&bv);
        }

In BitVec.Convert.c:592:

        StrDeinit(&str2);
        StrDeinit(&str3);
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Convert.c:593:

        StrDeinit(&str3);
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Convert.c:594:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:656:

        result = result && recovered_pattern_correct;
    
        BitVecDeinit(&large_bv);
        BitVecDeinit(&recovered_bv);

In BitVec.Convert.c:657:

    
        BitVecDeinit(&large_bv);
        BitVecDeinit(&recovered_bv);
    
        // Test string to bitvec with large patterns

In BitVec.Convert.c:681:

        result = result && large_pattern_correct;
    
        BitVecDeinit(&large_from_str);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Convert.c:703:

    
        // Should handle gracefully
        BitVecDeinit(&bv);
    
        // Test fromBytes with 0 bit length - should return empty bitvec

In BitVec.Convert.c:709:

        BitVec empty_bv       = BitVecFromBytes(dummy_bytes, 0, ALLOCATOR_OF(&alloc));
        bool   result         = (BitVecLen(&empty_bv) == 0);
        BitVecDeinit(&empty_bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:64:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:99:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:134:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:168:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:208:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:247:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:293:

        result = result && (count == 1000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:335:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:376:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:426:

        result = result && (count == 2); // Should iterate over indices 8,9
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:471:

            result = result && (count4 == sz);
    
            BitVecDeinit(&bv);
        }

In BitVec.Foreach.c:515:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:533:

        u64    count = BitVecRunLengths(&empty_bv, runs, values, 5);
        result       = result && (count == 0);
        BitVecDeinit(&empty_bv);
    
        // Test 2: Single bit (true)

In BitVec.Foreach.c:541:

        result = result && (count == 1);
        result = result && (runs[0] == 1 && values[0] == true);
        BitVecDeinit(&single_bv);
    
        // Test 3: Single bit (false)

In BitVec.Foreach.c:549:

        result = result && (count == 1);
        result = result && (runs[0] == 1 && values[0] == false);
        BitVecDeinit(&single_false_bv);
    
        // Test 4: All same bits (all true)

In BitVec.Foreach.c:559:

        result = result && (count == 1);
        result = result && (runs[0] == 10 && values[0] == true);
        BitVecDeinit(&all_true_bv);
    
        // Test 5: Alternating bits (0101010)

In BitVec.Foreach.c:575:

            result = result && (alt_values[i] == (i % 2 == 0));
        }
        BitVecDeinit(&alternating_bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Foreach.c:617:

        result = result && (count == 8);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:682:

        }
    
        BitVecDeinit(&large_bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Foreach.c:713:

        BitVecRunLengths(&bv, NULL, values, 5);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return true; // Should never reach here

In BitVec.Foreach.c:730:

        BitVecRunLengths(&bv, runs, NULL, 5);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return true; // Should never reach here

In BitVec.Foreach.c:748:

        BitVecRunLengths(&bv, runs, values, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return true; // Should never reach here

In BitVec.Compare.c:77:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:78:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:79:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:118:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:119:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:156:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:157:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:196:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:197:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:236:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:237:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:283:

    
        // Clean up
        BitVecDeinit(&subset);
        BitVecDeinit(&superset);

In BitVec.Compare.c:284:

        // Clean up
        BitVecDeinit(&subset);
        BitVecDeinit(&superset);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:329:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:330:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:331:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:377:

    
        // Clean up
        BitVecDeinit(&superset);
        BitVecDeinit(&subset);

In BitVec.Compare.c:378:

        // Clean up
        BitVecDeinit(&superset);
        BitVecDeinit(&subset);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:422:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:423:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:470:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:471:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:516:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:517:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:567:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);

In BitVec.Compare.c:568:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:610:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:611:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:612:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:660:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:701:

        result = result && BitVecIsSubset(&bv1, &bv2); // Empty is subset of empty
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:702:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Compare.c:735:

        result = result && BitVecOverlaps(&bv1, &bv2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:736:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Compare.c:805:

    
        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);

In BitVec.Compare.c:806:

        // Clean up
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&subset);

In BitVec.Compare.c:807:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&subset);
        BitVecDeinit(&superset);

In BitVec.Compare.c:808:

        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&subset);
        BitVecDeinit(&superset);

In BitVec.Compare.c:809:

        BitVecDeinit(&bv3);
        BitVecDeinit(&subset);
        BitVecDeinit(&superset);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:873:

    
        // Clean up
        BitVecDeinit(&large1);
        BitVecDeinit(&large2);
        BitVecDeinit(&pos);

In BitVec.Compare.c:874:

        // Clean up
        BitVecDeinit(&large1);
        BitVecDeinit(&large2);
        BitVecDeinit(&pos);
        BitVecDeinit(&neg);

In BitVec.Compare.c:875:

        BitVecDeinit(&large1);
        BitVecDeinit(&large2);
        BitVecDeinit(&pos);
        BitVecDeinit(&neg);

In BitVec.Compare.c:876:

        BitVecDeinit(&large2);
        BitVecDeinit(&pos);
        BitVecDeinit(&neg);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:894:

        BitVecEquals(NULL, &bv);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Compare.c:918:

        BitVecEqualsRange(NULL, 0, &bv, 0, 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Compare.c:940:

        BitVecEqualsRange(&bv1, 0, &bv2, 0, 5); // Range exceeds length
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:941:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Compare.c:975:

        result      = result && (bitvec_hash(&empty1, 0) == bitvec_hash(&empty2, 0));
    
        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&empty1);

In BitVec.Compare.c:976:

    
        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&empty1);
        BitVecDeinit(&empty2);

In BitVec.Compare.c:977:

        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&empty1);
        BitVecDeinit(&empty2);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:978:

        BitVecDeinit(&b);
        BitVecDeinit(&empty1);
        BitVecDeinit(&empty2);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Compare.c:1013:

        result      = result && (bitvec_hash(&a, 0) != bitvec_hash(&c, 0));
    
        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&c);

In BitVec.Compare.c:1014:

    
        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&c);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:1015:

        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&c);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Compare.c:1058:

        result      = result && (MapPairCount(&counts) == 2);
    
        BitVecDeinit(&k1);
        BitVecDeinit(&k2);
        BitVecDeinit(&probe);

In BitVec.Compare.c:1059:

    
        BitVecDeinit(&k1);
        BitVecDeinit(&k2);
        BitVecDeinit(&probe);
        BitVecDeinit(&missing);

In BitVec.Compare.c:1060:

        BitVecDeinit(&k1);
        BitVecDeinit(&k2);
        BitVecDeinit(&probe);
        BitVecDeinit(&missing);
        MapDeinit(&counts);

In BitVec.Compare.c:1061:

        BitVecDeinit(&k2);
        BitVecDeinit(&probe);
        BitVecDeinit(&missing);
        MapDeinit(&counts);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:1094:

        result      = result && (cmp(&a, &a) == 0);
    
        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&c);

In BitVec.Compare.c:1095:

    
        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&c);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Compare.c:1096:

        BitVecDeinit(&a);
        BitVecDeinit(&b);
        BitVecDeinit(&c);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:55:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Access.c:89:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Access.c:130:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Access.c:165:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Access.c:203:

    
        // Clean up
        BitVecDeinit(&bv);
    
        DefaultAllocatorDeinit(&alloc);

In BitVec.Access.c:232:

        result = result && (BitVecGet(&bv, 999) == (999 % 3 == 0)); // Last
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:255:

        result = result && (BitVecGet(&bv, 0) == true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:276:

        result = result && (BitVecGet(&bv, 0) == true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:311:

        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:339:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:379:

        result = result && (BitVecGet(&bv, BitVecLen(&bv) - 1) == true); // Last bit
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:418:

        result = result && (BitVecByteSize(&bv) >= 8); // At least 8 bytes for 64 bits
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:461:

        }
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:528:

        result = result && (BitVecGet(&bv, 4) == true);  // F(4) = 0 XOR 1 = 1
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:571:

        BitVecGet(&bv, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:586:

        BitVecSet(&bv, 0, true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:601:

        BitVecFlip(&bv, 0);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:620:

        BitVecGet(&bv, 1000);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:637:

        BitVecSet(&bv, 500, true);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:655:

        BitVecFlip(&bv, 10);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:680:

        BitVecGet(&bv, SIZE_MAX);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return false;

In BitVec.Access.c:727:

        result = result && (BitVecFindLast(&bv, false) == SIZE_MAX);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:779:

        result = result && !BitVecNone(&bv, false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:831:

        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:866:

        result = result && (BitVecFindLast(&bv, true) == 999);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:909:

        result = result && BitVecAny(&bv, false);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Access.c:945:

        result = result && (BitVecLongestRun(&bv, false) == 1);
    
        BitVecDeinit(&bv);
        DefaultAllocatorDeinit(&alloc);
        return result;

In BitVec.Pattern.Deadend.c:45:

        BitVecFindPattern(NULL, &pattern); // Should cause LOG_FATAL
    
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:62:

        BitVecFindPattern(&source, NULL); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:78:

        BitVecFindLastPattern(NULL, &pattern); // Should cause LOG_FATAL
    
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:95:

        BitVecFindLastPattern(&source, NULL); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:125:

        BitVecFindAllPattern(&source, NULL, results, 10); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:144:

        BitVecFindAllPattern(&source, &pattern, NULL, 10); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Deadend.c:145:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:165:

        BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Deadend.c:166:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:180:

        BitVecPush(&prefix, true);
        BitVecStartsWith(NULL, &prefix);
        BitVecDeinit(&prefix);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:192:

        BitVecPush(&source, true);
        BitVecStartsWith(&source, NULL);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:204:

        BitVecPush(&suffix, true);
        BitVecEndsWith(NULL, &suffix);
        BitVecDeinit(&suffix);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:216:

        BitVecPush(&source, true);
        BitVecEndsWith(&source, NULL);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:228:

        BitVecPush(&pattern, true);
        BitVecContainsAt(NULL, &pattern, 0);
        BitVecDeinit(&pattern);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:240:

        BitVecPush(&source, true);
        BitVecContainsAt(&source, NULL, 0);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:262:

        BitVecPush(&wildcard, false);
        BitVecMatches(NULL, &pattern, &wildcard);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        DefaultAllocatorDeinit(&alloc);

In BitVec.Pattern.Deadend.c:263:

        BitVecMatches(NULL, &pattern, &wildcard);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:281:

        BitVecPush(&source, true);
        BitVecRegexMatch(&source, (Zstr)NULL);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:289:

        DefaultAllocator alloc = DefaultAllocatorInit();
        WriteFmt("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
        BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecPrefixMatch(NULL, &vp);

In BitVec.Pattern.Deadend.c:304:

        BitVecPush(&source, true);
        BitVecPrefixMatch(&source, NULL);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In BitVec.Pattern.Deadend.c:312:

        DefaultAllocator alloc = DefaultAllocatorInit();
        WriteFmt("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
        BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecSuffixMatch(NULL, &vp);

In BitVec.Pattern.Deadend.c:327:

        BitVecPush(&source, true);
        BitVecSuffixMatch(&source, NULL);
        BitVecDeinit(&source);
        DefaultAllocatorDeinit(&alloc);
        return true;

In Init.h:47:

    static inline void IntDeinit(Int *value) {
        ValidateInt(value);
        BitVecDeinit(&value->bits);
    }

Last updated on June 4, 2026

BitVecData BitVecEmpty