BitVecInit

Documentation

API Reference

BitVecInit

Description

Initialize an empty BitVec. Inside a Scope block the allocator argument may be omitted; the internal MisraScope allocator is used. Otherwise pass a typed allocator handle or a raw Allocator *.

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:74:

    
    BitVec bitvec_init_with_capacity(u64 cap, Allocator *alloc) {
        BitVec result = BitVecInit(alloc);
    
        if (cap == 0) {

In BitVec.c:228:

        }
    
        *out = BitVecInit(bv->allocator);
        if (bv->length == 0) {
            return true;

In BitVec.c:235:

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

In BitVec.c:251:

    
        ValidateBitVec(bv);
        clone = BitVecInit(bv->allocator);
        (void)BitVecTryClone(&clone, bv);
        return clone;

In BitVec.c:877:

        }
    
        *out = BitVecInit(alloc);
    
        if (!BitVecReserve(out, str_len)) {

In BitVec.c:890:

                if (!BitVecPush(out, true)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);
                    return false;
                }

In BitVec.c:896:

                if (!BitVecPush(out, false)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);
                    return false;
                }

In BitVec.c:923:

    
        if (!bitvec_try_from_str_zstr(&result, str, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.c:933:

    
        if (!bitvec_try_from_str_str(&result, str, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.c:976:

        }
    
        *out = BitVecInit(alloc);
    
        if (bit_len == 0) {

In BitVec.c:984:

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

In BitVec.c:1002:

    
        if (!bitvec_try_from_bytes(&result, bytes, bit_len, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.c:1031:

        }
    
        *out = BitVecInit(alloc);
        if (bits == 0) {
            return true;

In BitVec.c:1042:

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

In BitVec.c:1058:

    
        if (!bitvec_try_from_integer(&result, value, bits, alloc)) {
            result = BitVecInit(alloc);
        }

In BitVec.Remove.c:39:

        WriteFmt("Testing BitVecPop\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits

In BitVec.Remove.c:77:

        WriteFmt("Testing BitVecRemove (single bit)\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits: true, false, true, false, true

In BitVec.Remove.c:117:

        WriteFmt("Testing BitVecRemoveRange\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits: true, false, true, true, false, true

In BitVec.Remove.c:150:

        WriteFmt("Testing BitVecRemoveFirst\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits: true, false, true, false, true

In BitVec.Remove.c:191:

        WriteFmt("Testing BitVecRemoveLast\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits: true, false, true, false, true

In BitVec.Remove.c:233:

        WriteFmt("Testing BitVecRemoveAll\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits: true, false, true, false, true, false

In BitVec.Remove.c:274:

        WriteFmt("Testing BitVecPop edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Remove.c:302:

        WriteFmt("Testing BitVecRemove edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Remove.c:330:

        WriteFmt("Testing BitVecRemoveRange edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Remove.c:363:

        WriteFmt("Testing BitVecRemoveFirst/Last edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Remove.c:402:

        WriteFmt("Testing BitVecRemoveAll edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Remove.c:459:

        WriteFmt("Testing BitVec remove invalid range handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test removing beyond capacity limit - should abort

In BitVec.Remove.c:474:

        WriteFmt("Testing BitVec pop bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test pop from empty bitvec - should abort

In BitVec.Remove.c:489:

        WriteFmt("Testing BitVec remove bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test remove from empty bitvec - should abort

In BitVec.Remove.c:504:

        WriteFmt("Testing BitVec remove range bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test remove range from empty bitvec - should abort

In BitVec.Remove.c:522:

        WriteFmt("Testing BitVecRemoveRange clamps oversized count\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Length 10, all true.

In BitVec.Remove.c:554:

        WriteFmt("Testing BitVecRemoveRange clamp gap count\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Length 10, all true.

In BitVec.Remove.c:581:

        WriteFmt("Testing BitVecRemoveRange shifts tail down\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Pattern: indices 0..9 = [1,0,1,0,0,1,0,1,1,0]

In BitVec.Remove.c:624:

        WriteFmt("Testing BitVecRemove rejects idx == length\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.Deadend.c:87:

        WriteFmt("Testing BitVec get bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test get from empty bitvec - should abort

In BitVec.Access.Deadend.c:102:

        WriteFmt("Testing BitVec set bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test set on empty bitvec - should abort

In BitVec.Access.Deadend.c:117:

        WriteFmt("Testing BitVec flip bounds checking\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test flip on empty bitvec - should abort

In BitVec.Access.Deadend.c:133:

        WriteFmt("Testing BitVec get with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.Deadend.c:151:

        WriteFmt("Testing BitVec set with large out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Access.Deadend.c:168:

        WriteFmt("Testing BitVec flip with edge case out-of-bounds index\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);

In BitVec.Access.Deadend.c:195:

        WriteFmt("Testing BitVec get with maximum index value\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);

In BitVec.Insert.c:33:

        WriteFmt("Testing BitVecPush\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Push some bits

In BitVec.Insert.c:66:

        WriteFmt("Testing BitVecInsert (single bit)\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Insert at index 0 (empty bitvector)

In BitVec.Insert.c:105:

        WriteFmt("Testing BitVecInsertRange\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create target bitvector

In BitVec.Insert.c:136:

        WriteFmt("Testing BitVecInsertMultiple\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:137:

    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Start with some bits

In BitVec.Insert.c:174:

        WriteFmt("Testing BitVecInsertPattern\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Start with some bits

In BitVec.Insert.c:195:

    
        // Test with different pattern - 0x05 (0101 in binary) using only 3 bits
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);

In BitVec.Insert.c:223:

        WriteFmt("Testing BitVecInsertRange edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Insert.c:254:

        WriteFmt("Testing BitVecInsertMultiple edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec empty  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:255:

    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec empty  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Insert.c:256:

        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec empty  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Insert.c:290:

        WriteFmt("Testing BitVecInsertPattern edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Insert.c:328:

        WriteFmt("Testing BitVec insert invalid range handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test inserting beyond capacity limit - should abort

In BitVec.Insert.c:355:

        WriteFmt("Testing BitVecInsertRange shifts existing tail bits\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Original: [1, 0, 1, 1]

In BitVec.Insert.c:386:

        WriteFmt("Testing BitVecInsertMultiple shifts existing tail bits\n");
    
        BitVec bv    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec other = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Insert.c:387:

    
        BitVec bv    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec other = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // bv: [1, 0, 1]

In BitVec.Insert.c:431:

        WriteFmt("Testing BitVecInsertMultiple NULL bv validation\n");
    
        BitVec other = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&other, true);

In BitVec.Insert.c:448:

        WriteFmt("Testing BitVecInsertMultiple NULL other validation\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);

In Io.Write.c:541:

        StrClear(&output);
    
        BitVec bv_empty = BitVecInit(alloc_base);
        StrAppendFmt(&output, "{}", bv_empty);
        success = success && (StrLen(&output) == 0);

In Io.Write.c:1412:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0x1";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:1430:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0xDEAD";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:1446:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0xDEAD";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:1465:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0o1";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:1484:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0o10";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:1501:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0o755";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:2489:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0x3ff";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:2508:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0xff";
        StrReadFmt(z, "{}", bv);

In Io.Write.c:2527:

        Allocator       *alloc_base = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(alloc_base);
        Zstr   z  = "0x10000";
        StrReadFmt(z, "{}", bv);

In BitVec.Blind.c:37:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec a = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 256; i++) {

In BitVec.Blind.c:38:

    
        BitVec a = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 256; i++) {
            BitVecPush(&a, false);

In BitVec.Blind.c:103:

    bool test_blind_rotate_right_exact(void) {
        DefaultAllocator alloc = DefaultAllocatorInit();
        BitVec           bv    = BitVecInit(ALLOCATOR_OF(&alloc));
    
        bool pat[5] = {true, false, false, true, true};

In BitVec.Access.Simple.c:38:

        WriteFmt("Testing BitVecGet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Push some bits

In BitVec.Access.Simple.c:61:

        WriteFmt("Testing BitVecSet\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Reserve space and set bits

In BitVec.Access.Simple.c:85:

        WriteFmt("Testing BitVecFlip\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Push some bits

In BitVec.Access.Simple.c:114:

        WriteFmt("Testing BitVecLength and BitVecCapacity\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Initially empty

In BitVec.Access.Simple.c:143:

        WriteFmt("Testing BitVecCount operations\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Push a pattern: true, false, true, false, true

In BitVec.Access.Simple.c:166:

        WriteFmt("Testing BitVecGet edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:191:

        WriteFmt("Testing BitVecSet edge cases\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set first bit

In BitVec.Access.Simple.c:213:

        WriteFmt("Testing BitVecFlip edge cases\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test flipping single bit

In BitVec.Access.Simple.c:235:

        WriteFmt("Testing BitVecCount edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:266:

        WriteFmt("Testing BitVec multiple access operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:306:

        WriteFmt("Testing BitVec access with large patterns\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:344:

        WriteFmt("Testing BitVec macro functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:377:

        WriteFmt("Testing BitVec access stress test\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:430:

        WriteFmt("Testing BitVec comprehensive bit patterns\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:487:

        WriteFmt("Testing BitVecFind functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:524:

        WriteFmt("Testing BitVec predicate functions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:574:

        WriteFmt("Testing BitVecLongestRun\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:614:

        WriteFmt("Testing BitVecFind edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:649:

        WriteFmt("Testing BitVec predicate edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Access.Simple.c:692:

        WriteFmt("Testing BitVecLongestRun edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:39:

        WriteFmt("Testing BitVecAnd\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:40:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:41:

        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up first bitvector: 1101

In BitVec.BitWise.Simple.c:81:

        WriteFmt("Testing BitVecOr\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:82:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:83:

        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up first bitvector: 1100

In BitVec.BitWise.Simple.c:123:

        WriteFmt("Testing BitVecXor\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:124:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:125:

        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up first bitvector: 1100

In BitVec.BitWise.Simple.c:165:

        WriteFmt("Testing BitVecNot\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:166:

    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up bitvector: 1010

In BitVec.BitWise.Simple.c:199:

        WriteFmt("Testing BitVecShiftLeft\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up bitvector: 1011 (indices 0,1,2,3)

In BitVec.BitWise.Simple.c:244:

        WriteFmt("Testing BitVecShiftRight\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:282:

        WriteFmt("Testing BitVecRotateLeft\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:314:

        WriteFmt("Testing BitVecRotateRight\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:346:

        WriteFmt("Testing BitVecReverse\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up bitvector: 1011

In BitVec.BitWise.Simple.c:378:

        WriteFmt("Testing BitVec shift edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:417:

        WriteFmt("Testing BitVec rotate edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:448:

        WriteFmt("Testing BitVec bitwise operations edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:449:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:453:

    
        // Test operations on empty bitvecs
        BitVec result_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecAnd(&result_bv, &bv1, &bv2);
        result = result && (BitVecLen(&result_bv) == 0);

In BitVec.BitWise.Simple.c:490:

        WriteFmt("Testing BitVecReverse edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:527:

        WriteFmt("Testing BitVec comprehensive bitwise operations\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:528:

    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:529:

        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:596:

        WriteFmt("Testing BitVec comprehensive shift operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:665:

        WriteFmt("Testing BitVec comprehensive rotate operations\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.BitWise.Simple.c:730:

        WriteFmt("Testing BitVec bitwise identity operations\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:731:

    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:732:

        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:827:

        WriteFmt("Testing BitVec bitwise commutative properties\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result1     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:828:

    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result1     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result2     = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:829:

        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result1     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result2     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:830:

        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result1     = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result2     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:892:

        WriteFmt("Testing BitVec bitwise operations with large patterns\n");
    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:893:

    
        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:894:

        BitVec bv1         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2         = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result      = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   test_result = true;

In BitVec.BitWise.Simple.c:967:

        WriteFmt("Testing BitVecOr widens past shorter operand a\n");
    
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:968:

    
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:969:

        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // a = 10 (len 2)

In BitVec.BitWise.Simple.c:1005:

        WriteFmt("Testing BitVecXor widens past shorter operand a\n");
    
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:1006:

    
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Simple.c:1007:

        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // a = 10 (len 2)

In BitVec.BitWise.Simple.c:1042:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv, true);

In BitVec.BitWise.Simple.c:1063:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, true);  // bit 1

In BitVec.Convert.c:43:

        WriteFmt("Testing BitVecToStr\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create pattern: 1011

In BitVec.Convert.c:108:

        WriteFmt("Testing BitVecToBytes\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create pattern: 10110011 (0xB3)

In BitVec.Convert.c:181:

        WriteFmt("Testing BitVecToInteger\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create pattern: 1011 (decimal 11 if MSB first, 13 if LSB first)

In BitVec.Convert.c:198:

    
        // Test with larger pattern
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv2, (i % 2 == 0)); // Alternating pattern

In BitVec.Convert.c:318:

        WriteFmt("Testing BitVec convert edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Convert.c:388:

        WriteFmt("Testing BitVec bytes conversion edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Convert.c:418:

        WriteFmt("Testing BitVec integer conversion edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Convert.c:520:

    
        // Test oversized bitvec to integer (should handle gracefully)
        BitVec oversized = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 100; i++) { // 100 bits > 64 bit limit
            BitVecPush(&oversized, i % 2 == 0);

In BitVec.Convert.c:531:

    
        // Test zero-length conversions
        BitVec empty = BitVecInit(ALLOCATOR_OF(&alloc));
    
        Str empty_str = BitVecToStr(&empty);

In BitVec.Convert.c:643:

    
        // Test with very large bitvectors
        BitVec large_bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create a 1000-bit pattern

In BitVec.Convert.c:727:

        WriteFmt("Testing BitVec bytes zero max_len handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);

In BitVec.Convert.c:823:

        WriteFmt("Testing BitVecToBytes 4-bit pack does not over-read\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        // 4-bit pattern 1011 -> LSB-first packing: bits 0,2,3 set -> 0x0D.
        BitVecPush(&bv, true);  // bit 0

In BitVec.Convert.c:856:

        WriteFmt("Testing BitVecToBytes truncation respects max_len\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        // 16 bits; ensure byte 1 has at least one set bit (bit 8 -> byte1 bit0).
        for (u64 i = 0; i < 16; i++) {

In BitVec.Type.c:21:

    
        // Create a bitvector
        BitVec bitvec = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Check initial state

In BitVec.Type.c:42:

    
        // Create a valid bitvector
        BitVec bitvec = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // This should not abort

In Io.Blind.c:1188:

    static bool test_read_bitvec_hex(void) {
        DebugAllocator dbg = DebugAllocatorInit();
        BitVec         bv  = BitVecInit(&dbg.base);
        Zstr           z   = "0x1";
        StrReadFmt(z, "{}", bv);

In Io.Blind.c:1201:

    static bool test_read_bitvec_hex_wide(void) {
        DefaultAllocator alloc = DefaultAllocatorInit();
        BitVec           bv    = BitVecInit(&alloc.base);
        Zstr             z     = "0xDEAD";
        StrReadFmt(z, "{}", bv);

In Io.Blind.c:1213:

    static bool test_read_bitvec_octal(void) {
        DebugAllocator dbg = DebugAllocatorInit();
        BitVec         bv  = BitVecInit(&dbg.base);
        Zstr           z   = "0o1";
        StrReadFmt(z, "{}", bv);

In Io.Blind.c:1226:

    static bool test_read_bitvec_binary(void) {
        DebugAllocator dbg = DebugAllocatorInit();
        BitVec         bv  = BitVecInit(&dbg.base);
        Zstr           z   = "10110";
        StrReadFmt(z, "{}", bv);

In BitVec.Memory.c:39:

        WriteFmt("Testing BitVecShrinkToFit\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits

In BitVec.Memory.c:79:

        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some bits

In BitVec.Memory.c:120:

        WriteFmt("Testing BitVecSwap\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:121:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up first bitvector

In BitVec.Memory.c:168:

        WriteFmt("Testing BitVecClone\n");
    
        BitVec original = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Set up original bitvector

In BitVec.Memory.c:222:

        alloc.base.retry_limit = 9;
    
        BitVec original = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecPush(&original, true);

In BitVec.Memory.c:253:

        WriteFmt("Testing BitVecShrinkToFit edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Memory.c:287:

        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Memory.c:322:

        WriteFmt("Testing BitVecSwap edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Memory.c:323:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Memory.c:366:

        WriteFmt("Testing BitVecClone edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Memory.c:413:

    
        for (int cycle = 0; cycle < 10; cycle++) {
            BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
            BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:414:

        for (int cycle = 0; cycle < 10; cycle++) {
            BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
            BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
            // Add random-sized data

In BitVec.Memory.c:460:

        WriteFmt("Testing BitVec swap NULL handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL pointer - should abort

In BitVec.Memory.c:493:

        WriteFmt("Testing resize-grow clears stale tail bits\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Fill a full byte with ones so bits 5,6,7 are set in the backing byte.

In BitVec.Memory.c:528:

        WriteFmt("Testing BitVecReserve with zero capacity returns true\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        bool result = (BitVecReserve(&bv, 0) == true);

In BitVec.Memory.c:571:

        WriteFmt("Testing BitVecShrinkToFit preserves bits on a large vector\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // 400 bits => doubling growth yields capacity 512, byte_size 64,

In BitVec.Memory.c:603:

        WriteFmt("Testing BitVecShrinkToFit keeps the vector structurally valid\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        for (int i = 0; i < 400; i++) {

In BitVec.Memory.c:631:

        WriteFmt("Testing BitVecSwap keeps a swapped-in large vector valid\n");
    
        BitVec small = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec large = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Memory.c:632:

    
        BitVec small = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec large = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecPush(&small, true);

In BitVec.Memory.c:666:

        WriteFmt("Testing BitVecSwap aborts on an invalid second argument\n");
    
        BitVec good = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&good, true);

In BitVec.Memory.c:686:

        WriteFmt("Testing BitVecTryClone aborts on an invalid source\n");
    
        BitVec out = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad = {0}; // magic 0 => invalid bitvec

In BitVec.Foreach.Simple.c:41:

        WriteFmt("Testing BitVecForeachIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add test pattern: true, false, true, false

In BitVec.Foreach.Simple.c:78:

        WriteFmt("Testing BitVecForeach macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add test pattern: true, false, true

In BitVec.Foreach.Simple.c:113:

        WriteFmt("Testing BitVecForeachReverseIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add test pattern: true, false, true, false

In BitVec.Foreach.Simple.c:148:

        WriteFmt("Testing BitVecForeachReverse macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add test pattern: true, false, true

In BitVec.Foreach.Simple.c:182:

        WriteFmt("Testing BitVecForeachInRangeIdx macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add test pattern: true, false, true, false, true

In BitVec.Foreach.Simple.c:222:

        WriteFmt("Testing BitVecForeachInRange macro\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add test pattern: false, true, true, false, true

In BitVec.Foreach.Simple.c:261:

        WriteFmt("Testing BitVec foreach edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;
        int    count  = 0;

In BitVec.Foreach.Simple.c:304:

        WriteFmt("Testing BitVec foreach idx edge cases\n");
    
        BitVec bv       = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result   = true;
        u64    last_idx = SIZE_MAX;

In BitVec.Foreach.Simple.c:346:

        WriteFmt("Testing BitVec foreach reverse edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Foreach.Simple.c:387:

        WriteFmt("Testing BitVec foreach range edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Foreach.Simple.c:440:

    
        for (int sz = 0; sz < 100; sz += 10) {
            BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
            // Create bitvec of varying sz

In BitVec.Foreach.Simple.c:487:

        WriteFmt("Testing BitVecRunLengths basic functionality\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Foreach.Simple.c:529:

        WriteFmt("Testing BitVecRunLengths Vec form\n");
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitVec.Foreach.Simple.c:564:

    
        // Test 1: Empty bitvector
        BitVec empty_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        u64    runs[5];
        bool   values[5];

In BitVec.Foreach.Simple.c:572:

    
        // Test 2: Single bit (true)
        BitVec single_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&single_bv, true);
        count  = BitVecRunLengths(&single_bv, runs, values, 5);

In BitVec.Foreach.Simple.c:580:

    
        // Test 3: Single bit (false)
        BitVec single_false_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&single_false_bv, false);
        count  = BitVecRunLengths(&single_false_bv, runs, values, 5);

In BitVec.Foreach.Simple.c:588:

    
        // Test 4: All same bits (all true)
        BitVec all_true_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 10; i++) {
            BitVecPush(&all_true_bv, true);

In BitVec.Foreach.Simple.c:598:

    
        // Test 5: Alternating bits (0101010)
        BitVec alternating_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 7; i++) {
            BitVecPush(&alternating_bv, i % 2 == 0);

In BitVec.Foreach.Simple.c:623:

        WriteFmt("Testing BitVecRunLengths boundary conditions\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Foreach.Simple.c:666:

    
        // Test with large bitvector
        BitVec large_bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create pattern that results in many runs

In BitVec.Compare.c:54:

        WriteFmt("Testing BitVecEquals\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:55:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:56:

        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test equal empty bitvectors

In BitVec.Compare.c:101:

        WriteFmt("Testing BitVecCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:102:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test equal bitvectors

In BitVec.Compare.c:141:

        WriteFmt("Testing BitVecLexCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:142:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test lexicographic comparison

In BitVec.Compare.c:179:

        WriteFmt("Testing BitVecNumericalCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:180:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create bitvectors representing different numbers

In BitVec.Compare.c:219:

        WriteFmt("Testing BitVecWeightCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:220:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // bv1: 111 (3 ones)

In BitVec.Compare.c:259:

        WriteFmt("Testing BitVecIsSubset\n");
    
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:260:

    
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create superset: 1111

In BitVec.Compare.c:306:

        WriteFmt("Testing BitVecSignedCompare\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:307:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test positive vs negative (MSB is sign bit)

In BitVec.Compare.c:353:

        WriteFmt("Testing BitVecIsSuperset\n");
    
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:354:

    
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create superset: 1111

In BitVec.Compare.c:400:

        WriteFmt("Testing BitVecOverlaps\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:401:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create overlapping bitvectors

In BitVec.Compare.c:445:

        WriteFmt("Testing BitVecDisjoint and BitVecIntersects\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:446:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create disjoint bitvectors

In BitVec.Compare.c:493:

        WriteFmt("Testing BitVecEqualsRange\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:494:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create test patterns

In BitVec.Compare.c:539:

        WriteFmt("Testing BitVecCompareRange\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:540:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create test patterns

In BitVec.Compare.c:590:

        WriteFmt("Testing BitVecIsLexicographicallyLess and BitVecIsNumericallyLess\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:591:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test lexicographic comparison

In BitVec.Compare.c:634:

        WriteFmt("Testing BitVecIsSorted\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test empty bitvector (should be sorted)

In BitVec.Compare.c:682:

        WriteFmt("Testing BitVec compare edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:683:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:721:

        WriteFmt("Testing BitVec set operations edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:722:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:756:

        WriteFmt("Testing BitVec comprehensive comparison operations\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:757:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:787:

    
        // Test transitivity: if A < B and B < C, then A < C
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));
        // bv3: larger than bv2
        for (int i = 0; i < 8; i++) {

In BitVec.Compare.c:798:

    
        // Test subset/superset consistency
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:799:

        // Test subset/superset consistency
        BitVec subset   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec superset = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create actual subset/superset relationship

In BitVec.Compare.c:831:

        WriteFmt("Testing BitVec large-scale comparison operations\n");
    
        BitVec large1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec large2 = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:832:

    
        BitVec large1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec large2 = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Compare.c:859:

    
        // Verify signed vs unsigned comparison differences
        BitVec pos = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec neg = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:860:

        // Verify signed vs unsigned comparison differences
        BitVec pos = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec neg = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Positive number (MSB = 0): 01111111

In BitVec.Compare.c:898:

        WriteFmt("Testing BitVec compare NULL pointer handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL pointer - should abort

In BitVec.Compare.c:922:

        WriteFmt("Testing BitVec range operations NULL handling\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL pointer in range operations - should abort

In BitVec.Compare.c:937:

        WriteFmt("Testing BitVec range operations bounds checking\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Compare.c:938:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Create small bitvectors

In BitVec.Compare.c:971:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
        for (int i = 0; i < 11; i++) {

In BitVec.Compare.c:972:

    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
        for (int i = 0; i < 11; i++) {
            BitVecPush(&a, (i % 2) == 0);

In BitVec.Compare.c:978:

        }
    
        BitVec empty1 = BitVecInit(base);
        BitVec empty2 = BitVecInit(base);

In BitVec.Compare.c:979:

    
        BitVec empty1 = BitVecInit(base);
        BitVec empty2 = BitVecInit(base);
    
        bool result = (bitvec_hash(&a, 0) == bitvec_hash(&b, 0));

In BitVec.Compare.c:1000:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
        BitVec c = BitVecInit(base);

In BitVec.Compare.c:1001:

    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
        BitVec c = BitVecInit(base);

In BitVec.Compare.c:1002:

        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
        BitVec c = BitVecInit(base);
    
        BitVecPush(&a, true);

In BitVec.Compare.c:1039:

        Map(BitVec, u64) counts = MapInit(bitvec_hash, bitvec_compare, &alloc);
    
        BitVec k1 = BitVecInit(base);
        BitVecPush(&k1, true);
        BitVecPush(&k1, false);

In BitVec.Compare.c:1044:

        BitVecPush(&k1, true);
    
        BitVec k2 = BitVecInit(base);
        BitVecPush(&k2, false);
        BitVecPush(&k2, true);

In BitVec.Compare.c:1051:

        MapInsertR(&counts, k2, 2u);
    
        BitVec probe = BitVecInit(base);
        BitVecPush(&probe, true);
        BitVecPush(&probe, false);

In BitVec.Compare.c:1058:

        u64 *got = MapGetFirstPtr(&counts, probe);
    
        BitVec missing = BitVecInit(base);
        BitVecPush(&missing, true);
        BitVecPush(&missing, true);

In BitVec.Compare.c:1084:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base);
        BitVecPush(&a, false);
        BitVecPush(&a, true);

In BitVec.Compare.c:1088:

        BitVecPush(&a, true);
    
        BitVec b = BitVecInit(base);
        BitVecPush(&b, false);
        BitVecPush(&b, true);

In BitVec.Compare.c:1092:

        BitVecPush(&b, true);
    
        BitVec c = BitVecInit(base);
        BitVecPush(&c, true);
        BitVecPush(&c, false);

In BitVec.Compare.c:1120:

        WriteFmt("Testing BitVecEquals rejects bad second operand\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad = {0};

In BitVec.Compare.c:1140:

        WriteFmt("Testing BitVecEqualsRange rejects bad second operand\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad = {0};

In BitVec.Compare.c:1158:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base); // byte 0x00
        BitVec b = BitVecInit(base); // byte 0x01

In BitVec.Compare.c:1159:

    
        BitVec a = BitVecInit(base); // byte 0x00
        BitVec b = BitVecInit(base); // byte 0x01
    
        // a: 8 zero bits -> byte 0x00.

In BitVec.Compare.c:1186:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base); // 10101010
        BitVec b = BitVecInit(base); // 01010101

In BitVec.Compare.c:1187:

    
        BitVec a = BitVecInit(base); // 10101010
        BitVec b = BitVecInit(base); // 01010101
    
        for (int i = 0; i < 8; i++) {

In BitVec.Compare.c:1211:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base); // byte0 = 0xFF, byte1 = 0x00
        BitVec b = BitVecInit(base); // byte0 = 0xFF, byte1 = 0xFF

In BitVec.Compare.c:1212:

    
        BitVec a = BitVecInit(base); // byte0 = 0xFF, byte1 = 0x00
        BitVec b = BitVecInit(base); // byte0 = 0xFF, byte1 = 0xFF
    
        // a: first 8 bits set, next 8 clear.

In BitVec.Compare.c:1243:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1258:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1273:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1288:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1304:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1323:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv1 = BitVecInit(base);
        BitVec bv2 = BitVecInit(base);

In BitVec.Compare.c:1324:

    
        BitVec bv1 = BitVecInit(base);
        BitVec bv2 = BitVecInit(base);
    
        for (u64 i = 0; i < 50; i++) {

In BitVec.Compare.c:1348:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec neg   = BitVecInit(base);
        BitVec empty = BitVecInit(base);

In BitVec.Compare.c:1349:

    
        BitVec neg   = BitVecInit(base);
        BitVec empty = BitVecInit(base);
    
        BitVecPush(&neg, true); // single bit set -> MSB set -> negative

In BitVec.Compare.c:1368:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec empty = BitVecInit(base);
        BitVec neg   = BitVecInit(base);

In BitVec.Compare.c:1369:

    
        BitVec empty = BitVecInit(base);
        BitVec neg   = BitVecInit(base);
    
        BitVecPush(&neg, true); // negative

In BitVec.Compare.c:1388:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec neg = BitVecInit(base);
        BitVec pos = BitVecInit(base);

In BitVec.Compare.c:1389:

    
        BitVec neg = BitVecInit(base);
        BitVec pos = BitVecInit(base);
    
        BitVecPush(&neg, true);  // length 1, MSB set -> negative

In BitVec.Compare.c:1411:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec empty = BitVecInit(base);
        BitVec neg   = BitVecInit(base);

In BitVec.Compare.c:1412:

    
        BitVec empty = BitVecInit(base);
        BitVec neg   = BitVecInit(base);
    
        BitVecPush(&neg, true); // negative

In BitVec.Compare.c:1432:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec neg   = BitVecInit(base);
        BitVec empty = BitVecInit(base);

In BitVec.Compare.c:1433:

    
        BitVec neg   = BitVecInit(base);
        BitVec empty = BitVecInit(base);
    
        BitVecPush(&neg, true); // negative

In BitVec.Compare.c:1452:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);

In BitVec.Compare.c:1453:

    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
    
        // [1,1]: MSB (index 1) set -> both negative, identical magnitude.

In BitVec.Compare.c:1477:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);

In BitVec.Compare.c:1478:

    
        BitVec a = BitVecInit(base);
        BitVec b = BitVecInit(base);
    
        // a = [1,1]: index1 (MSB) set -> negative, magnitude 3.

In BitVec.Compare.c:1503:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1519:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1535:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1551:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);

In BitVec.Compare.c:1571:

        WriteFmt("Testing BitVecIsSubset scans past index 42\n");
    
        BitVec bv1 = BitVecInit(base);
        BitVec bv2 = BitVecInit(base);

In BitVec.Compare.c:1572:

    
        BitVec bv1 = BitVecInit(base);
        BitVec bv2 = BitVecInit(base);
    
        for (u64 i = 0; i < 50; i++) {

In BitVec.Compare.c:1598:

        WriteFmt("Testing BitVecIsSubset with shorter bv1 stays in bounds\n");
    
        BitVec bv1 = BitVecInit(base); // length 2
        BitVec bv2 = BitVecInit(base); // length 5

In BitVec.Compare.c:1599:

    
        BitVec bv1 = BitVecInit(base); // length 2
        BitVec bv2 = BitVecInit(base); // length 5
    
        BitVecPush(&bv1, true);

In BitVec.Compare.c:1629:

        WriteFmt("Testing BitVecIsSubset with shorter bv2 stays in bounds\n");
    
        BitVec bv1 = BitVecInit(base); // length 5
        BitVec bv2 = BitVecInit(base); // length 2

In BitVec.Compare.c:1630:

    
        BitVec bv1 = BitVecInit(base); // length 5
        BitVec bv2 = BitVecInit(base); // length 2
    
        BitVecPush(&bv1, true);

In BitVec.Compare.c:1660:

        WriteFmt("Testing BitVecDisjoint scans beyond position 0\n");
    
        BitVec bv1 = BitVecInit(base);
        BitVec bv2 = BitVecInit(base);

In BitVec.Compare.c:1661:

    
        BitVec bv1 = BitVecInit(base);
        BitVec bv2 = BitVecInit(base);
    
        // Both: 0 1 1 -- no shared 1 at position 0, shared 1s at 1 and 2.

In BitVec.Compare.c:1689:

        WriteFmt("Testing BitVecIsSubset rejects NULL bv2\n");
    
        BitVec bv1 = BitVecInit(base);
        BitVecPush(&bv1, true);

In BitVec.Compare.c:1708:

        WriteFmt("Testing BitVecDisjoint rejects NULL bv1\n");
    
        BitVec bv2 = BitVecInit(base);
        BitVecPush(&bv2, true);

In BitVec.Compare.c:1727:

        WriteFmt("Testing BitVecDisjoint rejects NULL bv2\n");
    
        BitVec bv1 = BitVecInit(base);
        BitVecPush(&bv1, true);

In BitVec.Leak.c:28:

        Allocator     *adbg = ALLOCATOR_OF(&dbg);
    
        BitVec bv = BitVecInit(adbg);
    
        // 1011 -- length > 1 and positions % length != 0 so the rotate body

In BitVec.BitWise.Deadend.c:40:

        WriteFmt("Testing BitVec bitwise operations NULL handling\n");
    
        BitVec bv  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:41:

    
        BitVec bv  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL pointer - should abort

In BitVec.BitWise.Deadend.c:85:

        WriteFmt("Testing BitVec AND with NULL result handling\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);

In BitVec.BitWise.Deadend.c:86:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);

In BitVec.BitWise.Deadend.c:104:

        WriteFmt("Testing BitVec OR with NULL operand handling\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:105:

    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL operand - should abort

In BitVec.BitWise.Deadend.c:121:

        WriteFmt("Testing BitVec XOR with NULL second operand handling\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.BitWise.Deadend.c:122:

    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL second operand - should abort

In BitVec.BitWise.Deadend.c:138:

        WriteFmt("Testing BitVec NOT with NULL handling\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Test NULL operand - should abort

In BitVec.BitWise.Deadend.c:156:

        WriteFmt("Testing BitVecAnd rejects bad third operand\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:157:

    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:174:

        WriteFmt("Testing BitVecAnd rejects bad second operand\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:175:

    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:192:

        WriteFmt("Testing BitVecOr rejects bad second operand\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:193:

    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec b      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:210:

        WriteFmt("Testing BitVecXor rejects bad third operand\n");
    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.BitWise.Deadend.c:211:

    
        BitVec result = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec a      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad    = {0};

In BitVec.Mut.c:32:

        Allocator     *adbg = ALLOCATOR_OF(&dbg);
    
        BitVec bv = BitVecInit(adbg);
    
        // length > 1 and positions % length != 0 so the rotate body

In BitVec.Mut.c:72:

        Allocator     *adbg = ALLOCATOR_OF(&dbg);
    
        BitVec bv = BitVecInit(adbg);
    
        // 101010 so the render is a non-empty Str that must be freed.

In BitVec.Mut.c:110:

        Allocator       *pbase  = ALLOCATOR_OF(&palloc);
    
        BitVec bv = BitVecInit(adbg);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitVec.Math.c:81:

        WriteFmt("Testing BitVecHammingDistance basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:82:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:126:

        WriteFmt("Testing BitVecHammingDistance edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:127:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:159:

        WriteFmt("Testing BitVecJaccardSimilarity basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:160:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:211:

        WriteFmt("Testing BitVecJaccardSimilarity edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:212:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:240:

        WriteFmt("Testing BitVecCosineSimilarity basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:241:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:278:

        WriteFmt("Testing BitVecCosineSimilarity edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:279:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:311:

        WriteFmt("Testing BitVecDotProduct basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:312:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:351:

        WriteFmt("Testing BitVecDotProduct edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:352:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:381:

        WriteFmt("Testing BitVecEditDistance basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:382:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:428:

        WriteFmt("Testing BitVecEditDistance edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:429:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:459:

        WriteFmt("Testing BitVecCorrelation basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:460:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:498:

        WriteFmt("Testing BitVecCorrelation edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:499:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:529:

        WriteFmt("Testing BitVecEntropy basic functionality\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:561:

        WriteFmt("Testing BitVecEntropy edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:584:

        WriteFmt("Testing BitVecAlignmentScore basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:585:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:620:

        WriteFmt("Testing BitVecAlignmentScore edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:621:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:650:

        WriteFmt("Testing BitVecBestAlignment basic functionality\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:651:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:683:

        WriteFmt("Testing BitVecBestAlignment edge cases\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:684:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:711:

        WriteFmt("Testing BitVec Math stress tests\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:712:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:732:

    
        // Test edit distance with smaller vectors (expensive operation)
        BitVec small1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec small2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 50; i++) {

In BitVec.Math.c:733:

        // Test edit distance with smaller vectors (expensive operation)
        BitVec small1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec small2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 50; i++) {
            BitVecPush(&small1, i % 2 == 0);

In BitVec.Math.c:768:

    
        WriteFmt("Testing BitVecHammingDistance(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecHammingDistance(NULL, &bv2);

In BitVec.Math.c:780:

    
        WriteFmt("Testing BitVecHammingDistance(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecHammingDistance(&bv1, NULL);

In BitVec.Math.c:792:

    
        WriteFmt("Testing BitVecJaccardSimilarity(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecJaccardSimilarity(NULL, &bv2);

In BitVec.Math.c:804:

    
        WriteFmt("Testing BitVecJaccardSimilarity(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecJaccardSimilarity(&bv1, NULL);

In BitVec.Math.c:816:

    
        WriteFmt("Testing BitVecCosineSimilarity(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecCosineSimilarity(NULL, &bv2);

In BitVec.Math.c:828:

    
        WriteFmt("Testing BitVecCosineSimilarity(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecCosineSimilarity(&bv1, NULL);

In BitVec.Math.c:840:

    
        WriteFmt("Testing BitVecDotProduct(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecDotProduct(NULL, &bv2);

In BitVec.Math.c:852:

    
        WriteFmt("Testing BitVecDotProduct(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecDotProduct(&bv1, NULL);

In BitVec.Math.c:864:

    
        WriteFmt("Testing BitVecEditDistance(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecEditDistance(NULL, &bv2);

In BitVec.Math.c:876:

    
        WriteFmt("Testing BitVecEditDistance(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecEditDistance(&bv1, NULL);

In BitVec.Math.c:888:

    
        WriteFmt("Testing BitVecCorrelation(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecCorrelation(NULL, &bv2);

In BitVec.Math.c:900:

    
        WriteFmt("Testing BitVecCorrelation(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecCorrelation(&bv1, NULL);

In BitVec.Math.c:918:

    
        WriteFmt("Testing BitVecAlignmentScore(NULL, bv2, 1, -1) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecAlignmentScore(NULL, &bv2, 1, -1);

In BitVec.Math.c:930:

    
        WriteFmt("Testing BitVecAlignmentScore(bv1, NULL, 1, -1) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecAlignmentScore(&bv1, NULL, 1, -1);

In BitVec.Math.c:942:

    
        WriteFmt("Testing BitVecBestAlignment(NULL, bv2) - should fatal\n");
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv2, true);
        BitVecBestAlignment(NULL, &bv2);

In BitVec.Math.c:954:

    
        WriteFmt("Testing BitVecBestAlignment(bv1, NULL) - should fatal\n");
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecBestAlignment(&bv1, NULL);

In BitVec.Math.c:972:

        WriteFmt("Testing BitVecJaccardSimilarity guard only fires when both empty\n");
    
        BitVec empty = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec one   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&one, true);

In BitVec.Math.c:973:

    
        BitVec empty = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec one   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&one, true);

In BitVec.Math.c:1001:

        WriteFmt("Testing BitVecJaccardSimilarity with bv1 shorter than bv2\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:1002:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // bv1 = {1}, bv2 = {1, 0}. Intersection 1 (pos 0), union 1 -> 1.0.

In BitVec.Math.c:1027:

        WriteFmt("Testing BitVecJaccardSimilarity with bv2 shorter than bv1\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:1028:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // bv1 = {1, 0}, bv2 = {1}. Intersection 1 (pos 0), union 1 -> 1.0.

In BitVec.Math.c:1054:

        WriteFmt("Testing BitVecJaccardSimilarity reads bv2 bits in valid region\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:1055:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // bv1 = {0, 0}, bv2 = {1, 1}. Intersection 0, union 2 -> 0.0.

In BitVec.Math.c:1081:

        WriteFmt("Testing BitVecEditDistance column-0 base case\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:1082:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecPush(&bv1, false);

In BitVec.Math.c:1106:

        WriteFmt("Testing BitVecEditDistance deletion term\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:1107:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecPush(&bv1, false);

In BitVec.Math.c:1140:

        // exact size the empty->5 distance will recycle, guaranteeing the stale
        // (large) values land in prev_row[len2].
        BitVec warm_a = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec warm_b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 5; i++) {

In BitVec.Math.c:1141:

        // (large) values land in prev_row[len2].
        BitVec warm_a = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec warm_b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 5; i++) {
            BitVecPush(&warm_a, (i % 2) == 0);

In BitVec.Math.c:1150:

        BitVecDeinit(&warm_b);
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 5; i++) {

In BitVec.Math.c:1151:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv2, true);

In BitVec.Math.c:1178:

        // the empty->4 distance recycles, so the unfilled prev_row[len2] holds a
        // stale large value rather than a coincidental 4.
        BitVec warm_a = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec warm_b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 4; i++) {

In BitVec.Math.c:1179:

        // stale large value rather than a coincidental 4.
        BitVec warm_a = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec warm_b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 4; i++) {
            BitVecPush(&warm_a, (i % 2) == 1);

In BitVec.Math.c:1188:

        BitVecDeinit(&warm_b);
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 4; i++) {

In BitVec.Math.c:1189:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 4; i++) {
            BitVecPush(&bv2, false);

In BitVec.Math.c:1214:

        WriteFmt("Testing BitVecEditDistance insertion term\n");
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Math.c:1215:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecPush(&bv1, true);

In BitVec.Math.c:1241:

        WriteFmt("Testing BitVecJaccardSimilarity rejects bad second operand\n");
    
        BitVec empty = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bad   = {0};

In BitVec.Math.c:1261:

        WriteFmt("Testing BitVecCorrelation with bv1 shorter than bv2 (no OOB)\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1262:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1291:

        WriteFmt("Testing BitVecCorrelation with bv2 shorter than bv1 (no OOB)\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1292:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1323:

        WriteFmt("Testing BitVecEntropy on an unbalanced (3 ones, 1 zero) vector\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1357:

        WriteFmt("Testing BitVecBestAlignment all-mismatch best offset == 3\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1358:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1388:

        WriteFmt("Testing BitVecCosineSimilarity of identical vectors == 1.0\n");
    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1389:

    
        BitVec bv1    = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2    = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1417:

        WriteFmt("Testing BitVecEntropy of a 3:1 distribution\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Math.c:1444:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec bv     = BitVecInit(base);
        bool   result = true;

In BitVec.Math.c:1473:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "1011");

In BitVec.Math.c:1474:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "1011");
        push_bits(&bv2, "11");

In BitVec.Math.c:1494:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "11");

In BitVec.Math.c:1495:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "11");
        push_bits(&bv2, "000");

In BitVec.Math.c:1513:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "1010");

In BitVec.Math.c:1514:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "1010");
        push_bits(&bv2, "10");

In BitVec.Math.c:1534:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "0011");

In BitVec.Math.c:1535:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "0011");
        push_bits(&bv2, "11");

In BitVec.Math.c:1554:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "0011");

In BitVec.Math.c:1555:

    
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&bv1, "0011");
        push_bits(&bv2, "11");

In Io.Read.c:845:

        bool success = true;
    
        BitVec bv1 = BitVecInit(alloc_base);
        z          = "10110";
        StrReadFmt(z, "{}", bv1);

In Io.Read.c:858:

        BitVecDeinit(&bv1);
    
        BitVec bv2 = BitVecInit(alloc_base);
        z          = "0xDEAD";
        StrReadFmt(z, "{}", bv2);

In Io.Read.c:866:

        BitVecDeinit(&bv2);
    
        BitVec bv3 = BitVecInit(alloc_base);
        z          = "0o755";
        StrReadFmt(z, "{}", bv3);

In Io.Read.c:874:

        BitVecDeinit(&bv3);
    
        BitVec bv4 = BitVecInit(alloc_base);
        z          = "   1101";
        StrReadFmt(z, "{}", bv4);

In Io.Read.c:887:

        BitVecDeinit(&bv4);
    
        BitVec bv5 = BitVecInit(alloc_base);
        z          = "0";
        StrReadFmt(z, "{}", bv5);

In BitVec.Pattern.Simple.c:75:

        WriteFmt("Testing basic BitVec pattern functions\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:76:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:113:

        WriteFmt("Testing BitVecFindPattern function\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:114:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:163:

        WriteFmt("Testing BitVecFindLastPattern function\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:164:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:211:

        WriteFmt("Testing BitVecFindAllPattern function\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:212:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:276:

        WriteFmt("Testing BitVecFindAllPattern Vec form\n");
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:277:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:312:

        WriteFmt("Testing BitVec pattern edge cases\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:313:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:384:

        WriteFmt("Testing BitVec pattern stress tests\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:385:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:438:

        WriteFmt("Testing BitVecStartsWith basic functionality\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec prefix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:439:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec prefix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:476:

        WriteFmt("Testing BitVecStartsWith edge cases\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec prefix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:477:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec prefix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:511:

        WriteFmt("Testing BitVecEndsWith basic functionality\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:512:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:549:

        WriteFmt("Testing BitVecEndsWith edge cases\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:550:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:575:

        WriteFmt("Testing BitVecFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:576:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:615:

        WriteFmt("Testing BitVecContainsAt basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:616:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:648:

        WriteFmt("Testing BitVecContainsAt edge cases\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:649:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:675:

        WriteFmt("Testing BitVecCountPattern basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:676:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:713:

        WriteFmt("Testing BitVecRFindPattern basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:714:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:753:

        WriteFmt("Testing BitVecReplace basic functionality\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:754:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:755:

        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:798:

        WriteFmt("Testing BitVecReplaceAll basic functionality\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:799:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:800:

        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:838:

        WriteFmt("Testing BitVecMatches basic functionality\n");
    
        BitVec source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:839:

    
        BitVec source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result   = true;

In BitVec.Pattern.Simple.c:840:

        BitVec source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result   = true;

In BitVec.Pattern.Simple.c:876:

        WriteFmt("Testing BitVecFuzzyMatch basic functionality\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:877:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:915:

        WriteFmt("Testing BitVecRegexMatch basic functionality\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Pattern.Simple.c:941:

        WriteFmt("Testing BitVecPrefixMatch basic functionality\n");
    
        BitVec  source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        bool    result   = true;

In BitVec.Pattern.Simple.c:959:

        BitVec *p2 = VecPtrAt(&patterns, 2);
    
        *p0 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p1 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:960:

    
        *p0 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p1 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:961:

        *p0 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p1 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Pattern 0: 111 (should not match)

In BitVec.Pattern.Simple.c:993:

        WriteFmt("Testing BitVecSuffixMatch basic functionality\n");
    
        BitVec  source   = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecs patterns = VecInitWithDeepCopy(NULL, BitVecDeinit, ALLOCATOR_OF(&alloc));
        bool    result   = true;

In BitVec.Pattern.Simple.c:1011:

        BitVec *p2 = VecPtrAt(&patterns, 2);
    
        *p0 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p1 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:1012:

    
        *p0 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p1 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p2 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:1013:

        *p0 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p1 = BitVecInit(ALLOCATOR_OF(&alloc));
        *p2 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Pattern 0: 111 (should not match)

In BitVec.Pattern.Simple.c:1048:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1049:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1080:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1081:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1113:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "101");

In BitVec.Pattern.Simple.c:1114:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "101");
        push_bits(&suffix, "101");

In BitVec.Pattern.Simple.c:1131:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "101");

In BitVec.Pattern.Simple.c:1132:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "101");
        push_bits(&pattern, "101");

In BitVec.Pattern.Simple.c:1149:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "101");

In BitVec.Pattern.Simple.c:1150:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "101");
        push_bits(&pattern, "101");

In BitVec.Pattern.Simple.c:1172:

        WriteFmt("Testing BitVecRFindPattern window-condition (ge_to_lt)\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1173:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1199:

        WriteFmt("Testing BitVecRFindPattern window-condition (add_to_sub)\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1200:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1226:

        WriteFmt("Testing BitVecRFindPattern window-value (add_to_sub)\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1227:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1252:

        WriteFmt("Testing BitVecRFindPattern loop-seed (add_to_sub)\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1253:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1278:

        WriteFmt("Testing BitVecRFindPattern loop-guard (gt_to_ge)\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1279:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result  = true;

In BitVec.Pattern.Simple.c:1306:

        WriteFmt("Testing BitVecReplaceAll found-flag init\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:1307:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:1308:

        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:1338:

        WriteFmt("Testing BitVecReplaceAll forward-scan direction\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Pattern.Simple.c:1339:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:1340:

        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result      = true;

In BitVec.Pattern.Simple.c:1366:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source = BitVecInit(base);
        BitVec old    = BitVecInit(base);
        BitVec neww   = BitVecInit(base);

In BitVec.Pattern.Simple.c:1367:

    
        BitVec source = BitVecInit(base);
        BitVec old    = BitVecInit(base);
        BitVec neww   = BitVecInit(base);
        bool   result = true;

In BitVec.Pattern.Simple.c:1368:

        BitVec source = BitVecInit(base);
        BitVec old    = BitVecInit(base);
        BitVec neww   = BitVecInit(base);
        bool   result = true;

In BitVec.Pattern.Simple.c:1401:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source = BitVecInit(base);
        BitVec old    = BitVecInit(base);
        BitVec neww   = BitVecInit(base);

In BitVec.Pattern.Simple.c:1402:

    
        BitVec source = BitVecInit(base);
        BitVec old    = BitVecInit(base);
        BitVec neww   = BitVecInit(base);
        bool   result = true;

In BitVec.Pattern.Simple.c:1403:

        BitVec source = BitVecInit(base);
        BitVec old    = BitVecInit(base);
        BitVec neww   = BitVecInit(base);
        bool   result = true;

In BitVec.Pattern.Simple.c:1443:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source   = BitVecInit(base);
        BitVec pattern  = BitVecInit(base);
        BitVec wildcard = BitVecInit(base);

In BitVec.Pattern.Simple.c:1444:

    
        BitVec source   = BitVecInit(base);
        BitVec pattern  = BitVecInit(base);
        BitVec wildcard = BitVecInit(base);
        bool   result   = true;

In BitVec.Pattern.Simple.c:1445:

        BitVec source   = BitVecInit(base);
        BitVec pattern  = BitVecInit(base);
        BitVec wildcard = BitVecInit(base);
        bool   result   = true;

In BitVec.Pattern.Simple.c:1464:

        // Sanity: an all-wildcard mask must still match (proves we did not just
        // wire the function to always return false).
        BitVec wild_all = BitVecInit(base);
        for (int i = 0; i < 4; i++)
            BitVecPush(&wild_all, true);

In BitVec.Pattern.Simple.c:1484:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1485:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1511:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1512:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        bool   result  = true;

In BitVec.Pattern.Simple.c:1549:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);

In BitVec.Pattern.Simple.c:1550:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
    
        // source: 4096 zero bits; pattern: a single 1. No window ever matches with

In BitVec.Pattern.Simple.c:1575:

        WriteFmt("Testing bitvec_regex_match_str returns false on non-match\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Init.c:26:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInit\n");
    
        // Test basic initialization

In BitVec.Init.c:29:

    
        // Test basic initialization
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Check initial state

In BitVec.Init.c:51:

        WriteFmt("Testing BitVecDeinit\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some data to make sure deinitialization works with allocated memory

In BitVec.Init.c:83:

        WriteFmt("Testing BitVecReserve\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Reserve space for 50 bits

In BitVec.Init.c:120:

        WriteFmt("Testing BitVecClear\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some data

In BitVec.Init.c:159:

        WriteFmt("Testing BitVecResize\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        // Add some initial data

In BitVec.Init.c:202:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        WriteFmt("Testing BitVecInit edge cases\n");
    
        // Test multiple initializations

In BitVec.Init.c:205:

    
        // Test multiple initializations
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:206:

        // Test multiple initializations
        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));

In BitVec.Init.c:207:

        BitVec bv1 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec bv3 = BitVecInit(ALLOCATOR_OF(&alloc));
    
        bool result = (BitVecLen(&bv1) == 0) && (BitVecLen(&bv2) == 0) && (BitVecLen(&bv3) == 0);

In BitVec.Init.c:227:

        WriteFmt("Testing BitVecReserve edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Init.c:258:

        WriteFmt("Testing BitVecReu64 edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Init.c:297:

        WriteFmt("Testing BitVecClear edge cases\n");
    
        BitVec bv     = BitVecInit(ALLOCATOR_OF(&alloc));
        bool   result = true;

In BitVec.Init.c:335:

        // Test multiple init/deinit cycles
        for (int cycle = 0; cycle < 100; cycle++) {
            BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
            // Add some data

In BitVec.Init.c:373:

        // failure rather than aborting. The Must variant aborts, so use it here
        // to validate the deadend abort path.
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecMustReserve(&bv, SIZE_MAX);

In BitVec.Init.c:391:

        // failure rather than aborting. The Must variant aborts, so use it here
        // to validate the deadend abort path.
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
    
        BitVecMustResize(&bv, SIZE_MAX);

In Io.Leak.c:338:

    bool test_leak_write_bitvec_freed(void) {
        HeapAllocator va = HeapAllocatorInit();
        BitVec        v  = BitVecInit(ALLOCATOR_OF(&va));
        BitVecResize(&v, 12);
        LEAK_WRITE_PRELUDE();

In Io.Leak.c:444:

    static bool leak_bitvec_overflow(Zstr input) {
        DebugAllocator dbg = DebugAllocatorInitWith(LEAK_CFG);
        BitVec         bv  = BitVecInit(ALLOCATOR_OF(&dbg));
        Zstr           p   = input;
        StrReadFmt(p, "{}", bv);

In BitVec.Foreach.Deadend.c:37:

        WriteFmt("Testing BitVecRunLengths with NULL runs array\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        bool values[5];

In BitVec.Foreach.Deadend.c:54:

        WriteFmt("Testing BitVecRunLengths with NULL values array\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        u64 runs[5];

In BitVec.Foreach.Deadend.c:71:

        WriteFmt("Testing BitVecRunLengths with zero max_runs\n");
    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        u64  runs[5];

In BitVec.Foreach.Deadend.c:97:

        // no public setter exists -- the whole point of this test is to plant
        // length>0 with data==NULL so ValidateBitVec aborts in the foreach prologue.
        BitVec bv   = BitVecInit(ALLOCATOR_OF(&alloc));
        bv.length   = 5;
        bv.capacity = 10;

In BitVec.Pattern.Deadend.c:59:

        WriteFmt("Testing BitVecFindPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:75:

        WriteFmt("Testing BitVecFindPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.Deadend.c:92:

        WriteFmt("Testing BitVecFindLastPattern(NULL, pattern) - should fatal\n");
    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:108:

        WriteFmt("Testing BitVecFindLastPattern(source, NULL) - should fatal\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.Deadend.c:137:

        WriteFmt("Testing BitVecFindAllPattern(source, NULL, results, 10) - should fatal\n");
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        size   results[10];
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:155:

        WriteFmt("Testing BitVecFindAllPattern(source, pattern, NULL, 10) - should fatal\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:156:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In BitVec.Pattern.Deadend.c:175:

        WriteFmt("Testing BitVecFindAllPattern(source, pattern, results, 0) - should fatal\n");
    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        size   results[10];

In BitVec.Pattern.Deadend.c:176:

    
        BitVec source  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        size   results[10];
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:196:

    
        WriteFmt("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
        BitVec prefix = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&prefix, true);
        BitVecStartsWith(NULL, &prefix);

In BitVec.Pattern.Deadend.c:208:

    
        WriteFmt("Testing BitVecStartsWith(source, NULL) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecStartsWith(&source, NULL);

In BitVec.Pattern.Deadend.c:220:

    
        WriteFmt("Testing BitVecEndsWith(NULL, suffix) - should fatal\n");
        BitVec suffix = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&suffix, true);
        BitVecEndsWith(NULL, &suffix);

In BitVec.Pattern.Deadend.c:232:

    
        WriteFmt("Testing BitVecEndsWith(source, NULL) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecEndsWith(&source, NULL);

In BitVec.Pattern.Deadend.c:244:

    
        WriteFmt("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
        BitVecContainsAt(NULL, &pattern, 0);

In BitVec.Pattern.Deadend.c:256:

    
        WriteFmt("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecContainsAt(&source, NULL, 0);

In BitVec.Pattern.Deadend.c:276:

    
        WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:277:

        WriteFmt("Testing BitVecMatches(NULL, pattern, wildcard) - should fatal\n");
        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
        BitVecPush(&wildcard, false);

In BitVec.Pattern.Deadend.c:297:

    
        WriteFmt("Testing BitVecRegexMatch(source, NULL) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecRegexMatch(&source, (Zstr)NULL);

In BitVec.Pattern.Deadend.c:320:

    
        WriteFmt("Testing BitVecPrefixMatch(source, NULL, 1) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecPrefixMatch(&source, NULL);

In BitVec.Pattern.Deadend.c:343:

    
        WriteFmt("Testing BitVecSuffixMatch(source, NULL, 1) - should fatal\n");
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecSuffixMatch(&source, NULL);

In BitVec.Pattern.Deadend.c:368:

        WriteFmt("Testing BitVecFindAllPattern (vec) with NULL bitvector\n");
    
        BitVec pattern = BitVecInit(base);
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:384:

        WriteFmt("Testing BitVecFindAllPattern (vec) with NULL pattern\n");
    
        BitVec source = BitVecInit(base);
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:396:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:410:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:424:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:438:

        DefaultAllocator alloc = DefaultAllocatorInit();
    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:457:

        WriteFmt("Testing BitVecReplace(src, old, NULL) with old absent - should fatal\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "0000");

In BitVec.Pattern.Deadend.c:458:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&source, "0000");
        push_bits(&old_pattern, "111");             // not present in source

In BitVec.Pattern.Deadend.c:480:

    
        BitVec bad         = {0}; // magic mismatch -> ValidateBitVec aborts
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&old_pattern, "1");

In BitVec.Pattern.Deadend.c:481:

        BitVec bad         = {0}; // magic mismatch -> ValidateBitVec aborts
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&old_pattern, "1");
        push_bits(&new_pattern, "0");

In BitVec.Pattern.Deadend.c:502:

        WriteFmt("Testing BitVecReplaceAll(empty, NULL, new) - should fatal\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&new_pattern, "0");

In BitVec.Pattern.Deadend.c:503:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec new_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&new_pattern, "0");

In BitVec.Pattern.Deadend.c:523:

        WriteFmt("Testing BitVecReplaceAll(empty, old, NULL) - should fatal\n");
    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&old_pattern, "1");

In BitVec.Pattern.Deadend.c:524:

    
        BitVec source      = BitVecInit(ALLOCATOR_OF(&alloc)); // empty
        BitVec old_pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        push_bits(&old_pattern, "1");

In BitVec.Pattern.Deadend.c:541:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source   = BitVecInit(base);
        BitVec wildcard = BitVecInit(base);
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:542:

    
        BitVec source   = BitVecInit(base);
        BitVec wildcard = BitVecInit(base);
        BitVecPush(&source, true);
        BitVecPush(&wildcard, false);

In BitVec.Pattern.Deadend.c:559:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        BitVecPush(&source, true);

In BitVec.Pattern.Deadend.c:560:

    
        BitVec source  = BitVecInit(base);
        BitVec pattern = BitVecInit(base);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:577:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec pattern = BitVecInit(base);
        BitVecPush(&pattern, true);

In BitVec.Pattern.Deadend.c:593:

        Allocator       *base  = ALLOCATOR_OF(&alloc);
    
        BitVec source = BitVecInit(base);
        BitVecPush(&source, true);

Last updated on June 28, 2026

BitVecFuzzyMatch BitVecInitWithCapacity