BitVecPush

Documentation

API Reference

BitVecPush

Description

Push a bit to the end of bitvector. Grows the bitvector if necessary.

Parameters

Name	Direction	Description
`bv`	in,out	Bitvector to push bit to.
`value`	in	Bit value to push (true/false).

Usage example (from documentation)

  BitVecPush(&flags, true);
  BitVecPush(&flags, false);

Success

Returns true. Bitvector length grows by one; bit at index old_length is now value. The byte buffer may have grown.

Failure

Returns false on allocation failure when capacity must grow. The bitvector is unchanged.

Usage example (Cross-references)

Usage examples (Cross-references)

In Insert.h:81:

    #define BitVecMustPush(bv, value)                                                                                      \
        do {                                                                                                               \
            if (!BitVecPush((bv), (value))) {                                                                              \
                LOG_FATAL("BitVecMustPush failed");                                                                        \
            }                                                                                                              \

In BitVec.c:321:

    }
    
    bool BitVecPush(BitVec *bitvec, bool value) {
        ValidateBitVec(bitvec);
        if (bitvec->length >= bitvec->capacity) {

In BitVec.c:352:

            LOG_FATAL("Index {} exceeds bitvector length {}", idx, bitvec->length);
        }
        if (!BitVecPush(bitvec, false)) {
            return false;
        }

In BitVec.c:943:

        for (u64 i = 0; i < str_len; i++) {
            if (str[i] == '1') {
                if (!BitVecPush(out, true)) {
                    BitVecDeinit(out);
                    *out = BitVecInit(alloc);

In BitVec.c:949:

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

In Memory.c:44:

    
        // Add some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Memory.c:45:

        // Add some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Memory.c:46:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Force capacity to be larger than needed by reserving space

In Memory.c:84:

    
        // Add some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Memory.c:85:

        // Add some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Set capacity to a specific value

In Memory.c:156:

    
        // Set up first bitvector
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Memory.c:157:

        // Set up first bitvector
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Memory.c:158:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
    
        // Set up second bitvector

In Memory.c:161:

    
        // Set up second bitvector
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Memory.c:162:

        // Set up second bitvector
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
    
        // Store original states

In Memory.c:203:

    
        // Set up original bitvector
        BitVecPush(&original, true);
        BitVecPush(&original, false);
        BitVecPush(&original, true);

In Memory.c:204:

        // Set up original bitvector
        BitVecPush(&original, true);
        BitVecPush(&original, false);
        BitVecPush(&original, true);
        BitVecPush(&original, false);

In Memory.c:205:

        BitVecPush(&original, true);
        BitVecPush(&original, false);
        BitVecPush(&original, true);
        BitVecPush(&original, false);

In Memory.c:206:

        BitVecPush(&original, false);
        BitVecPush(&original, true);
        BitVecPush(&original, false);
    
        // Clone the bitvector

In Memory.c:219:

    
        // Verify they are independent by modifying original
        BitVecPush(&original, true);
    
        // Clone should remain unchanged

In Memory.c:256:

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

In Memory.c:257:

    
        BitVecPush(&original, true);
        BitVecPush(&original, false);
        BitVecPush(&original, true);

In Memory.c:258:

        BitVecPush(&original, true);
        BitVecPush(&original, false);
        BitVecPush(&original, true);
    
        BitVec clone = BitVecClone(&original);

In Memory.c:293:

    
        // Test shrink on single element
        BitVecPush(&bv, true);
        BitVecShrinkToFit(&bv);
        result = result && (BitVecLen(&bv) == 1) && (BitVecCapacity(&bv) >= 1);

In Memory.c:331:

    
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        u64 original_length = BitVecLen(&bv);

In Memory.c:363:

    
        // Test swap with one empty, one non-empty
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecSwap(&bv1, &bv2);

In Memory.c:364:

        // Test swap with one empty, one non-empty
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecSwap(&bv1, &bv2);

In Memory.c:375:

        BitVecClear(&bv1);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 3 == 0);
        }

In Memory.c:407:

    
        // Test clone single element
        BitVecPush(&bv, true);
        BitVec clone2 = BitVecClone(&bv);
        result        = result && (BitVecLen(&clone2) == 1);

In Memory.c:416:

        BitVecClear(&bv);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Memory.c:450:

            // Add random-sized data
            for (int i = 0; i < cycle * 10; i++) {
                BitVecPush(&bv1, i % 2 == 0);
                BitVecPush(&bv2, i % 3 == 0);
            }

In Memory.c:451:

            for (int i = 0; i < cycle * 10; i++) {
                BitVecPush(&bv1, i % 2 == 0);
                BitVecPush(&bv2, i % 3 == 0);
            }

In Memory.c:529:

        // Fill a full byte with ones so bits 5,6,7 are set in the backing byte.
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv, true);
        }

In Memory.c:609:

        // shrink takes the realloc path (50 != 64) and capacity (512) > length.
        for (int i = 0; i < 400; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Memory.c:638:

    
        for (int i = 0; i < 400; i++) {
            BitVecPush(&bv, i % 3 == 0);
        }

In Memory.c:666:

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

In Memory.c:667:

    
        BitVecPush(&small, true);
        BitVecPush(&small, false);
    
        // Large enough that 42*8 == 336 < capacity once swapped in.

In Memory.c:671:

        // Large enough that 42*8 == 336 < capacity once swapped in.
        for (int i = 0; i < 400; i++) {
            BitVecPush(&large, i % 2 == 0);
        }

In Memory.c:699:

    
        BitVec good = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&good, true);
    
        BitVec bad = {0}; // magic 0 => invalid bitvec

In Init.c:54:

    
        // Add some data to make sure deinitialization works with allocated memory
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Init.c:55:

        // Add some data to make sure deinitialization works with allocated memory
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Init.c:56:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Check that data was allocated

In Init.c:95:

        // Add some bits to make sure the reserved space works
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, (i % 2 == 0));
        }

In Init.c:123:

    
        // Add some data
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Init.c:124:

        // Add some data
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Init.c:125:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Init.c:126:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Check initial state

In Init.c:141:

    
        // Test that we can still add data after clearing
        BitVecPush(&bv, true);
        result = result && (BitVecLen(&bv) == 1);
        result = result && (BitVecGet(&bv, 0) == true);

In Init.c:162:

    
        // Add some initial data
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Init.c:163:

        // Add some initial data
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Init.c:164:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Test resizing to larger size

In Init.c:262:

    
        // Test reu64 to 0 (should clear but keep memory)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecResize(&bv, 0);

In Init.c:263:

        // Test reu64 to 0 (should clear but keep memory)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecResize(&bv, 0);
        result = result && (BitVecLen(&bv) == 0);

In Init.c:305:

    
        // Test clear after single bit
        BitVecPush(&bv, true);
        BitVecClear(&bv);
        result = result && (BitVecLen(&bv) == 0);

In Init.c:316:

        // Test clear after large data
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2);
        }
        BitVecClear(&bv);

In Init.c:339:

            // Add some data
            for (int i = 0; i < cycle % 10; i++) {
                BitVecPush(&bv, i % 2);
            }

In Access.Deadend.c:134:

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

In Access.Deadend.c:135:

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

In Access.Deadend.c:136:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Test with index way beyond length (3) - should abort

In Access.Deadend.c:152:

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

In Access.Deadend.c:153:

        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Test with index way beyond length (2) - should abort

In Access.Deadend.c:170:

        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Access.Deadend.c:196:

    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
    
        // Test with maximum possible index value - should abort

In Compare.c:62:

    
        // Add same pattern to both
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:63:

        // Add same pattern to both
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:64:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
    
        BitVecPush(&bv2, true);

In Compare.c:66:

        BitVecPush(&bv1, true);
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:67:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:68:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        // Should be equal

In Compare.c:74:

    
        // Add different pattern to third
        BitVecPush(&bv3, true);
        BitVecPush(&bv3, false);
        BitVecPush(&bv3, false); // Different bit

In Compare.c:75:

        // Add different pattern to third
        BitVecPush(&bv3, true);
        BitVecPush(&bv3, false);
        BitVecPush(&bv3, false); // Different bit

In Compare.c:76:

        BitVecPush(&bv3, true);
        BitVecPush(&bv3, false);
        BitVecPush(&bv3, false); // Different bit
    
        // Should not be equal

In Compare.c:82:

    
        // Test different lengths
        BitVecPush(&bv3, true);
        result = result && !BitVecEquals(&bv1, &bv3);

In Compare.c:105:

    
        // Test equal bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:106:

        // Test equal bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);

In Compare.c:108:

        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:109:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        bool result = (BitVecCompare(&bv1, &bv2) == 0);

In Compare.c:117:

        BitVecClear(&bv2);
    
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);  // 11

In Compare.c:118:

    
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);  // 11
    
        BitVecPush(&bv2, true);

In Compare.c:120:

        BitVecPush(&bv1, true);  // 11
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false); // 10

In Compare.c:121:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false); // 10
    
        result = result && (BitVecCompare(&bv1, &bv2) > 0);

In Compare.c:145:

    
        // Test lexicographic comparison
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true); // 101

In Compare.c:146:

        // Test lexicographic comparison
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true); // 101

In Compare.c:147:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true); // 101
    
        BitVecPush(&bv2, true);

In Compare.c:149:

        BitVecPush(&bv1, true); // 101
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // 11 (shorter)

In Compare.c:150:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // 11 (shorter)
    
        // Lexicographic comparison considers position-by-position

In Compare.c:158:

        // Test equal bitvectors
        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true); // 101

In Compare.c:159:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true); // 101

In Compare.c:160:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true); // 101
    
        result = result && (BitVecCompare(&bv1, &bv2) == 0);

In Compare.c:184:

        // Create bitvectors representing different numbers
        // bv1: 101 (binary) = 5 (decimal)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:185:

        // bv1: 101 (binary) = 5 (decimal)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:186:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
    
        // bv2: 11 (binary) = 3 (decimal)

In Compare.c:189:

    
        // bv2: 11 (binary) = 3 (decimal)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:190:

        // bv2: 11 (binary) = 3 (decimal)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        // Numerical comparison should compare the integer values

In Compare.c:198:

        // Test equal values
        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true); // Also 101

In Compare.c:199:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true); // Also 101

In Compare.c:200:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true); // Also 101
    
        result = result && (BitVecNumericalCompare(&bv1, &bv2) == 0);

In Compare.c:223:

    
        // bv1: 111 (3 ones)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Compare.c:224:

        // bv1: 111 (3 ones)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Compare.c:225:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
    
        // bv2: 101 (2 ones)

In Compare.c:228:

    
        // bv2: 101 (2 ones)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:229:

        // bv2: 101 (2 ones)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:230:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        // Weight comparison should compare number of set bits

In Compare.c:238:

        // Test equal weights
        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // Also 3 ones

In Compare.c:239:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // Also 3 ones

In Compare.c:240:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // Also 3 ones
    
        result = result && (BitVecWeightCompare(&bv1, &bv2) == 0);

In Compare.c:263:

    
        // Create superset: 1111
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:264:

        // Create superset: 1111
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:265:

        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:266:

        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
    
        // Create subset: 1010

In Compare.c:269:

    
        // Create subset: 1010
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);

In Compare.c:270:

        // Create subset: 1010
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);

In Compare.c:271:

        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);

In Compare.c:272:

        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
    
        // subset should be a subset of superset (all 1s in subset are also 1s in superset)

In Compare.c:284:

        // Test equal sets (should be subset)
        BitVecClear(&superset);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
        BitVecPush(&superset, true);

In Compare.c:285:

        BitVecClear(&superset);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);

In Compare.c:286:

        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);

In Compare.c:287:

        BitVecPush(&superset, false);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
    
        result = result && BitVecIsSubset(&subset, &superset);

In Compare.c:311:

        // Test positive vs negative (MSB is sign bit)
        // bv1: 011 (positive 3)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:312:

        // bv1: 011 (positive 3)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:313:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        // bv2: 111 (negative, MSB=1)

In Compare.c:316:

    
        // bv2: 111 (negative, MSB=1)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:317:

        // bv2: 111 (negative, MSB=1)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:318:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        // Positive should be greater than negative

In Compare.c:326:

        BitVecClear(&bv2);
        // bv2: 001 (positive 1)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:327:

        // bv2: 001 (positive 1)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:328:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
    
        // 3 > 1

In Compare.c:357:

    
        // Create superset: 1111
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:358:

        // Create superset: 1111
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:359:

        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:360:

        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
    
        // Create subset: 1010

In Compare.c:363:

    
        // Create subset: 1010
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);

In Compare.c:364:

        // Create subset: 1010
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);

In Compare.c:365:

        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);

In Compare.c:366:

        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
    
        // superset should be a superset of subset

In Compare.c:378:

        // Test equal sets (should be superset)
        BitVecClear(&superset);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
        BitVecPush(&superset, true);

In Compare.c:379:

        BitVecClear(&superset);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);

In Compare.c:380:

        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);

In Compare.c:381:

        BitVecPush(&superset, false);
        BitVecPush(&superset, true);
        BitVecPush(&superset, false);
    
        result = result && BitVecIsSuperset(&superset, &subset);

In Compare.c:405:

        // Create overlapping bitvectors
        // bv1: 1010
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:406:

        // bv1: 1010
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:407:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:408:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        // bv2: 1100

In Compare.c:411:

    
        // bv2: 1100
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:412:

        // bv2: 1100
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:413:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:414:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
    
        // They overlap at position 0 (both have 1)

In Compare.c:422:

        BitVecClear(&bv2);
        // bv2: 0101 (complement of bv1)
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:423:

        // bv2: 0101 (complement of bv1)
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:424:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:425:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        // They should not overlap (no position where both have 1)

In Compare.c:450:

        // Create disjoint bitvectors
        // bv1: 1010
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:451:

        // bv1: 1010
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:452:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:453:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        // bv2: 0101 (disjoint with bv1)

In Compare.c:456:

    
        // bv2: 0101 (disjoint with bv1)
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:457:

        // bv2: 0101 (disjoint with bv1)
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:458:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:459:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        // Should be disjoint and not intersect

In Compare.c:499:

        // bv1: 11100111
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv1, (i >= 3 && i <= 5) ? false : true);
        }

In Compare.c:504:

        // bv2: 00100100
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv2, (i == 2 || i == 5) ? true : false);
        }

In Compare.c:544:

        // Create test patterns
        // bv1: 11010110
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:545:

        // bv1: 11010110
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:546:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:547:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Compare.c:548:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Compare.c:549:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:550:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:551:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        // bv2: 01101011

In Compare.c:554:

    
        // bv2: 01101011
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:555:

        // bv2: 01101011
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:556:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:557:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:558:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:559:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:560:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:561:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        // Test range comparisons

In Compare.c:595:

        // Test lexicographic comparison
        // bv1: 10 (shorter)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Compare.c:596:

        // bv1: 10 (shorter)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        // bv2: 101 (longer)

In Compare.c:599:

    
        // bv2: 101 (longer)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:600:

        // bv2: 101 (longer)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Compare.c:601:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        // Lexicographically, shorter comes first

In Compare.c:640:

    
        // Test sorted pattern: 0001111
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Compare.c:641:

        // Test sorted pattern: 0001111
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Compare.c:642:

        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Compare.c:643:

        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Compare.c:644:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Compare.c:645:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Compare.c:646:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        result = result && BitVecIsSorted(&bv);

In Compare.c:651:

    
        // Test unsorted pattern (add 0 after 1s)
        BitVecPush(&bv, false);
        result = result && !BitVecIsSorted(&bv);

In Compare.c:657:

        BitVecClear(&bv);
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, false);
        }
        result = result && BitVecIsSorted(&bv);

In Compare.c:664:

        BitVecClear(&bv);
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, true);
        }
        result = result && BitVecIsSorted(&bv);

In Compare.c:691:

    
        // Test compare empty vs non-empty
        BitVecPush(&bv1, true);
        result = result && !BitVecEquals(&bv1, &bv2);
        result = result && (BitVecCompare(&bv1, &bv2) != 0);

In Compare.c:700:

        for (int i = 0; i < 1000; i++) {
            bool bit = i % 3 == 0;
            BitVecPush(&bv1, bit);
            BitVecPush(&bv2, bit);
        }

In Compare.c:701:

            bool bit = i % 3 == 0;
            BitVecPush(&bv1, bit);
            BitVecPush(&bv2, bit);
        }
        result = result && BitVecEquals(&bv1, &bv2);

In Compare.c:730:

    
        // Test single bit sets
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);
        result = result && !BitVecOverlaps(&bv1, &bv2);

In Compare.c:731:

        // Test single bit sets
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);
        result = result && !BitVecOverlaps(&bv1, &bv2);

In Compare.c:738:

        BitVecClear(&bv2);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 3 == 0);
        }

In Compare.c:739:

        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 3 == 0);
        }
        // Should have some overlap since both contain position 0 (true)

In Compare.c:764:

        int pattern1[] = {1, 0, 1, 0, 1, 1, 0};
        for (int i = 0; i < 7; i++) {
            BitVecPush(&bv1, pattern1[i]);
        }

In Compare.c:770:

        int pattern2[] = {1, 1, 0, 0, 1, 0, 1};
        for (int i = 0; i < 7; i++) {
            BitVecPush(&bv2, pattern2[i]);
        }

In Compare.c:790:

        // bv3: larger than bv2
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv3, true);
        }

In Compare.c:802:

    
        // Create actual subset/superset relationship
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);

In Compare.c:803:

        // Create actual subset/superset relationship
        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);

In Compare.c:804:

        BitVecPush(&subset, true);
        BitVecPush(&subset, false);
        BitVecPush(&subset, true);
    
        BitVecPush(&superset, true);

In Compare.c:806:

        BitVecPush(&subset, true);
    
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:807:

    
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);

In Compare.c:808:

        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
        BitVecPush(&superset, true);
    
        result = result && BitVecIsSubset(&subset, &superset);

In Compare.c:839:

            // Pattern 1: Fibonacci-like XOR pattern
            bool bit1 = (i % 3 == 0) ^ (i % 5 == 0);
            BitVecPush(&large1, bit1);
    
            // Pattern 2: Prime-like pattern

In Compare.c:843:

            // Pattern 2: Prime-like pattern
            bool bit2 = (i % 7 == 0) || (i % 11 == 0);
            BitVecPush(&large2, bit2);
        }

In Compare.c:864:

        // Positive number (MSB = 0): 01111111
        for (int i = 0; i < 7; i++) {
            BitVecPush(&pos, true);
        }
        BitVecPush(&pos, false);

In Compare.c:866:

            BitVecPush(&pos, true);
        }
        BitVecPush(&pos, false);
    
        // Negative number (MSB = 1): 10000001

In Compare.c:869:

    
        // Negative number (MSB = 1): 10000001
        BitVecPush(&neg, true);
        for (int i = 1; i < 7; i++) {
            BitVecPush(&neg, false);

In Compare.c:871:

        BitVecPush(&neg, true);
        for (int i = 1; i < 7; i++) {
            BitVecPush(&neg, false);
        }
        BitVecPush(&neg, true);

In Compare.c:873:

            BitVecPush(&neg, false);
        }
        BitVecPush(&neg, true);
    
        // Unsigned: 01111111 (127) < 10000001 (129)

In Compare.c:942:

        // Create small bitvectors
        for (int i = 0; i < 3; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 2 == 1);
        }

In Compare.c:943:

        for (int i = 0; i < 3; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 2 == 1);
        }

In Compare.c:974:

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

In Compare.c:975:

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

In Compare.c:1004:

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

In Compare.c:1005:

    
        BitVecPush(&a, true);
        BitVecPush(&a, false);
        BitVecPush(&a, true);

In Compare.c:1006:

        BitVecPush(&a, true);
        BitVecPush(&a, false);
        BitVecPush(&a, true);
    
        BitVecPush(&b, true);

In Compare.c:1008:

        BitVecPush(&a, true);
    
        BitVecPush(&b, true);
        BitVecPush(&b, false);
        BitVecPush(&b, false);

In Compare.c:1009:

    
        BitVecPush(&b, true);
        BitVecPush(&b, false);
        BitVecPush(&b, false);

In Compare.c:1010:

        BitVecPush(&b, true);
        BitVecPush(&b, false);
        BitVecPush(&b, false);
    
        // c shares the byte-prefix with a but is longer.

In Compare.c:1013:

    
        // c shares the byte-prefix with a but is longer.
        BitVecPush(&c, true);
        BitVecPush(&c, false);
        BitVecPush(&c, true);

In Compare.c:1014:

        // c shares the byte-prefix with a but is longer.
        BitVecPush(&c, true);
        BitVecPush(&c, false);
        BitVecPush(&c, true);
        BitVecPush(&c, false);

In Compare.c:1015:

        BitVecPush(&c, true);
        BitVecPush(&c, false);
        BitVecPush(&c, true);
        BitVecPush(&c, false);
        BitVecPush(&c, false);

In Compare.c:1016:

        BitVecPush(&c, false);
        BitVecPush(&c, true);
        BitVecPush(&c, false);
        BitVecPush(&c, false);

In Compare.c:1017:

        BitVecPush(&c, true);
        BitVecPush(&c, false);
        BitVecPush(&c, false);
    
        bool result = (bitvec_hash(&a, 0) != bitvec_hash(&b, 0));

In Compare.c:1040:

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

In Compare.c:1041:

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

In Compare.c:1042:

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

In Compare.c:1045:

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

In Compare.c:1046:

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

In Compare.c:1052:

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

In Compare.c:1053:

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

In Compare.c:1054:

        BitVecPush(&probe, true);
        BitVecPush(&probe, false);
        BitVecPush(&probe, true);
    
        u64 *got = MapGetFirstPtr(&counts, probe);

In Compare.c:1059:

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

In Compare.c:1060:

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

In Compare.c:1085:

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

In Compare.c:1086:

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

In Compare.c:1089:

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

In Compare.c:1090:

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

In Compare.c:1093:

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

In Compare.c:1094:

        BitVec c = BitVecInit(base);
        BitVecPush(&c, true);
        BitVecPush(&c, false);
    
        GenericCompare cmp = bitvec_compare;

In Compare.c:1123:

        BitVec bad = {0};
    
        BitVecPush(&bv1, true);
    
        BitVecEquals(&bv1, &bad);

In Compare.c:1163:

        // a: 8 zero bits -> byte 0x00.
        for (int i = 0; i < 8; i++)
            BitVecPush(&a, false);
        // b: bit 0 set, rest clear -> byte 0x01 (same length 8).
        BitVecPush(&b, true);

In Compare.c:1165:

            BitVecPush(&a, false);
        // b: bit 0 set, rest clear -> byte 0x01 (same length 8).
        BitVecPush(&b, true);
        for (int i = 0; i < 7; i++)
            BitVecPush(&b, false);

In Compare.c:1167:

        BitVecPush(&b, true);
        for (int i = 0; i < 7; i++)
            BitVecPush(&b, false);
    
        bool result = (bitvec_hash(&a, 0) != bitvec_hash(&b, 0));

In Compare.c:1190:

    
        for (int i = 0; i < 8; i++) {
            BitVecPush(&a, (i % 2) == 0);
            BitVecPush(&b, (i % 2) == 1);
        }

In Compare.c:1191:

        for (int i = 0; i < 8; i++) {
            BitVecPush(&a, (i % 2) == 0);
            BitVecPush(&b, (i % 2) == 1);
        }

In Compare.c:1216:

        // a: first 8 bits set, next 8 clear.
        for (int i = 0; i < 8; i++)
            BitVecPush(&a, true);
        for (int i = 0; i < 8; i++)
            BitVecPush(&a, false);

In Compare.c:1218:

            BitVecPush(&a, true);
        for (int i = 0; i < 8; i++)
            BitVecPush(&a, false);
        // b: all 16 bits set.
        for (int i = 0; i < 16; i++)

In Compare.c:1221:

        // b: all 16 bits set.
        for (int i = 0; i < 16; i++)
            BitVecPush(&b, true);
    
        bool result = (bitvec_hash(&a, 0) != bitvec_hash(&b, 0));

In Compare.c:1244:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecCompare(NULL, &bv); // must abort

In Compare.c:1259:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecCompare(&bv, NULL); // must abort

In Compare.c:1274:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecCompareRange(NULL, 0, &bv, 0, 1); // must abort

In Compare.c:1289:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecCompareRange(&bv, 0, NULL, 0, 1); // must abort

In Compare.c:1305:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecNumericalCompare(NULL, &bv); // must abort

In Compare.c:1327:

    
        for (u64 i = 0; i < 50; i++) {
            BitVecPush(&bv1, i == 49);
            BitVecPush(&bv2, false);
        }

In Compare.c:1328:

        for (u64 i = 0; i < 50; i++) {
            BitVecPush(&bv1, i == 49);
            BitVecPush(&bv2, false);
        }

In Compare.c:1351:

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

In Compare.c:1371:

        BitVec neg   = BitVecInit(base);
    
        BitVecPush(&neg, true); // negative
    
        bool result = (BitVecSignedCompare(&empty, &neg) > 0);

In Compare.c:1391:

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

In Compare.c:1392:

    
        BitVecPush(&neg, true);  // length 1, MSB set -> negative
        BitVecPush(&pos, false); // length 1, MSB clear -> non-negative (zero)
    
        // negative < zero

In Compare.c:1414:

        BitVec neg   = BitVecInit(base);
    
        BitVecPush(&neg, true); // negative
    
        bool result = (BitVecSignedCompare(&empty, &neg) > 0);

In Compare.c:1435:

        BitVec empty = BitVecInit(base);
    
        BitVecPush(&neg, true); // negative
    
        bool result = (BitVecSignedCompare(&neg, &empty) < 0);

In Compare.c:1456:

    
        // [1,1]: MSB (index 1) set -> both negative, identical magnitude.
        BitVecPush(&a, true);
        BitVecPush(&a, true);
        BitVecPush(&b, true);

In Compare.c:1457:

        // [1,1]: MSB (index 1) set -> both negative, identical magnitude.
        BitVecPush(&a, true);
        BitVecPush(&a, true);
        BitVecPush(&b, true);
        BitVecPush(&b, true);

In Compare.c:1458:

        BitVecPush(&a, true);
        BitVecPush(&a, true);
        BitVecPush(&b, true);
        BitVecPush(&b, true);

In Compare.c:1459:

        BitVecPush(&a, true);
        BitVecPush(&b, true);
        BitVecPush(&b, true);
    
        bool result = (BitVecSignedCompare(&a, &b) == 0);

In Compare.c:1481:

    
        // a = [1,1]: index1 (MSB) set -> negative, magnitude 3.
        BitVecPush(&a, true);
        BitVecPush(&a, true);
        // b = [0,1]: index1 (MSB) set -> negative, magnitude 2.

In Compare.c:1482:

        // a = [1,1]: index1 (MSB) set -> negative, magnitude 3.
        BitVecPush(&a, true);
        BitVecPush(&a, true);
        // b = [0,1]: index1 (MSB) set -> negative, magnitude 2.
        BitVecPush(&b, false);

In Compare.c:1484:

        BitVecPush(&a, true);
        // b = [0,1]: index1 (MSB) set -> negative, magnitude 2.
        BitVecPush(&b, false);
        BitVecPush(&b, true);

In Compare.c:1485:

        // b = [0,1]: index1 (MSB) set -> negative, magnitude 2.
        BitVecPush(&b, false);
        BitVecPush(&b, true);
    
        // a has the larger magnitude, so a is the more-negative -> a < b.

In Compare.c:1504:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecNumericalCompare(&bv, NULL); // must abort

In Compare.c:1520:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecSignedCompare(NULL, &bv); // must abort

In Compare.c:1536:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecSignedCompare(&bv, NULL); // must abort

In Compare.c:1552:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
    
        BitVecIsSubset(NULL, &bv); // must abort

In Compare.c:1575:

    
        for (u64 i = 0; i < 50; i++) {
            BitVecPush(&bv1, i == 45);
            BitVecPush(&bv2, false);
        }

In Compare.c:1576:

        for (u64 i = 0; i < 50; i++) {
            BitVecPush(&bv1, i == 45);
            BitVecPush(&bv2, false);
        }

In Compare.c:1601:

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

In Compare.c:1602:

    
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);

In Compare.c:1604:

        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:1605:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:1606:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:1607:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Compare.c:1608:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
    
        // bv1's only 1 (pos 0) is set in bv2 -> subset is true.

In Compare.c:1632:

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

In Compare.c:1633:

    
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Compare.c:1634:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Compare.c:1635:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Compare.c:1636:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);

In Compare.c:1638:

        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Compare.c:1639:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        // bv1's only 1 (pos 0) is set in bv2 -> subset is true.

In Compare.c:1664:

    
        // Both: 0 1 1 -- no shared 1 at position 0, shared 1s at 1 and 2.
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Compare.c:1665:

        // Both: 0 1 1 -- no shared 1 at position 0, shared 1s at 1 and 2.
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Compare.c:1666:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
    
        BitVecPush(&bv2, false);

In Compare.c:1668:

        BitVecPush(&bv1, true);
    
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:1669:

    
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Compare.c:1670:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        // They share 1-bits, so they are NOT disjoint.

In Compare.c:1690:

    
        BitVec bv1 = BitVecInit(base);
        BitVecPush(&bv1, true);
    
        // Should abort on the NULL second argument.

In Compare.c:1709:

    
        BitVec bv2 = BitVecInit(base);
        BitVecPush(&bv2, true);
    
        // Should abort on the NULL first argument.

In Compare.c:1728:

    
        BitVec bv1 = BitVecInit(base);
        BitVecPush(&bv1, true);
    
        // Should abort on the NULL second argument.

In Compare.c:1751:

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

In Compare.c:1754:

        }
        for (int i = 0; i < 512; i++) {
            BitVecPush(&b, false);
        }
        // Byte content differs (32 vs 64 zero bytes), so this alone is not a pure

In Insert.c:31:

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

In Insert.c:36:

    
        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Insert.c:37:

        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Insert.c:38:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Insert.c:39:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Insert.c:40:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Check length

In Insert.c:108:

    
        // Create target bitvector
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Insert.c:109:

        // Create target bitvector
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
    
        // Insert range of true bits

In Insert.c:140:

    
        // Start with some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Insert.c:141:

        // Start with some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Create source bitvector to insert

In Insert.c:144:

    
        // Create source bitvector to insert
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Insert.c:145:

        // Create source bitvector to insert
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Insert.c:146:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
    
        // Insert multiple bits from source

In Insert.c:177:

    
        // Start with some bits
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Insert.c:178:

        // Start with some bits
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
    
        // Insert pattern 0x0B (1011 in binary) using 4 bits

In Insert.c:196:

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

In Insert.c:231:

    
        // Test inserting at end
        BitVecPush(&bv, true);
        BitVecInsertRange(&bv, 1, 2, false);
        result = result && (BitVecLen(&bv) == 3);

In Insert.c:264:

    
        // Test inserting single bit bitvec
        BitVecPush(&source, true);
        BitVecInsertMultiple(&bv, 0, &source);
        result = result && (BitVecLen(&bv) == 1) && (BitVecGet(&bv, 0) == true);

In Insert.c:271:

        BitVecClear(&source);
        for (int i = 0; i < 500; i++) {
            BitVecPush(&source, false);
        }
        BitVecInsertMultiple(&bv, 1, &source);

In Insert.c:358:

    
        // Original: [1, 0, 1, 1]
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Insert.c:359:

        // Original: [1, 0, 1, 1]
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Insert.c:360:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Insert.c:361:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        // Insert 2 false bits at index 1 -> [1, 0, 0, 0, 1, 1]

In Insert.c:390:

    
        // bv: [1, 0, 1]
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Insert.c:391:

        // bv: [1, 0, 1]
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Insert.c:392:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // other: [1, 1]

In Insert.c:395:

    
        // other: [1, 1]
        BitVecPush(&other, true);
        BitVecPush(&other, true);

In Insert.c:396:

        // other: [1, 1]
        BitVecPush(&other, true);
        BitVecPush(&other, true);
    
        // Insert other at index 1 -> [1, 1, 1, 0, 1]

In Insert.c:432:

    
        BitVec other = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&other, true);
    
        BitVecInsertMultiple(NULL, 0, &other);

In Insert.c:449:

    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
    
        BitVecInsertMultiple(&bv, 0, NULL);

In Pattern.Deadend.c:51:

    static void push_bits(BitVec *bv, const char *bits) {
        for (const char *c = bits; *c != '\0'; c++)
            BitVecPush(bv, *c == '1');
    }

In Pattern.Deadend.c:61:

    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
    
        BitVecFindPattern(NULL, &pattern); // Should cause LOG_FATAL

In Pattern.Deadend.c:77:

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

In Pattern.Deadend.c:78:

        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        BitVecFindPattern(&source, NULL); // Should cause LOG_FATAL

In Pattern.Deadend.c:94:

    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
    
        BitVecFindLastPattern(NULL, &pattern); // Should cause LOG_FATAL

In Pattern.Deadend.c:110:

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

In Pattern.Deadend.c:111:

        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        BitVecFindLastPattern(&source, NULL); // Should cause LOG_FATAL

In Pattern.Deadend.c:140:

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

In Pattern.Deadend.c:141:

        size   results[10];
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        BitVecFindAllPattern(&source, NULL, results, 10); // Should cause LOG_FATAL

In Pattern.Deadend.c:158:

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

In Pattern.Deadend.c:159:

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

In Pattern.Deadend.c:160:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&pattern, true);
    
        BitVecFindAllPattern(&source, &pattern, NULL, 10); // Should cause LOG_FATAL

In Pattern.Deadend.c:179:

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

In Pattern.Deadend.c:180:

        size   results[10];
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&pattern, true);

In Pattern.Deadend.c:181:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&pattern, true);
    
        BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL

In Pattern.Deadend.c:198:

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

In Pattern.Deadend.c:210:

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

In Pattern.Deadend.c:222:

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

In Pattern.Deadend.c:234:

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

In Pattern.Deadend.c:246:

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

In Pattern.Deadend.c:258:

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

In Pattern.Deadend.c:279:

        BitVec pattern  = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
        BitVecPush(&wildcard, false);
        BitVecMatches(NULL, &pattern, &wildcard);

In Pattern.Deadend.c:280:

        BitVec wildcard = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
        BitVecPush(&wildcard, false);
        BitVecMatches(NULL, &pattern, &wildcard);
        BitVecDeinit(&pattern);

In Pattern.Deadend.c:299:

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

In Pattern.Deadend.c:310:

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

In Pattern.Deadend.c:322:

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

In Pattern.Deadend.c:333:

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

In Pattern.Deadend.c:345:

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

In Pattern.Deadend.c:370:

    
        BitVec pattern = BitVecInit(base);
        BitVecPush(&pattern, true);
    
        BitVecMatchIndices matches = VecInitT(matches, base);

In Pattern.Deadend.c:386:

    
        BitVec source = BitVecInit(base);
        BitVecPush(&source, true);
    
        BitVecMatchIndices matches = VecInitT(matches, base);

In Pattern.Deadend.c:398:

    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
    
        BitVecCountPattern(NULL, &pattern); // Should LOG_FATAL

In Pattern.Deadend.c:412:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
    
        BitVecCountPattern(&source, NULL); // Should LOG_FATAL

In Pattern.Deadend.c:426:

    
        BitVec pattern = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&pattern, true);
    
        BitVecRFindPattern(NULL, &pattern, 0); // Should LOG_FATAL

In Pattern.Deadend.c:440:

    
        BitVec source = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&source, true);
    
        BitVecRFindPattern(&source, NULL, 0); // Should LOG_FATAL

In Pattern.Deadend.c:544:

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

In Pattern.Deadend.c:545:

        BitVec wildcard = BitVecInit(base);
        BitVecPush(&source, true);
        BitVecPush(&wildcard, false);
    
        BitVecMatches(&source, NULL, &wildcard); // must abort

In Pattern.Deadend.c:562:

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

In Pattern.Deadend.c:563:

        BitVec pattern = BitVecInit(base);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
    
        BitVecMatches(&source, &pattern, NULL); // must abort

In Pattern.Deadend.c:579:

    
        BitVec pattern = BitVecInit(base);
        BitVecPush(&pattern, true);
    
        BitVecFuzzyMatch(NULL, &pattern, 0); // must abort

In Pattern.Deadend.c:595:

    
        BitVec source = BitVecInit(base);
        BitVecPush(&source, true);
    
        BitVecFuzzyMatch(&source, NULL, 0); // must abort

In Foreach.Deadend.c:38:

    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        bool values[5];

In Foreach.Deadend.c:55:

    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        u64 runs[5];

In Foreach.Deadend.c:72:

    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
        u64  runs[5];
        bool values[5];

In Foreach.Simple.c:44:

    
        // Add test pattern: true, false, true, false
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:45:

        // Add test pattern: true, false, true, false
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:46:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:47:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Test forward iteration with index

In Foreach.Simple.c:81:

    
        // Add test pattern: true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:82:

        // Add test pattern: true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:83:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Test forward iteration without explicit index

In Foreach.Simple.c:116:

    
        // Add test pattern: true, false, true, false
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:117:

        // Add test pattern: true, false, true, false
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:118:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:119:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Test reverse iteration with index

In Foreach.Simple.c:151:

    
        // Add test pattern: true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:152:

        // Add test pattern: true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:153:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Test reverse iteration

In Foreach.Simple.c:185:

    
        // Add test pattern: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:186:

        // Add test pattern: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:187:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:188:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:189:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Test range iteration from index 1 to 4 (exclusive)

In Foreach.Simple.c:225:

    
        // Add test pattern: false, true, true, false, true
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Foreach.Simple.c:226:

        // Add test pattern: false, true, true, false, true
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:227:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:228:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:229:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Test range iteration from index 1 to 3 (exclusive)

In Foreach.Simple.c:273:

    
        // Test foreach on single element
        BitVecPush(&bv, true);
        count = 0;
        BitVecForeach(&bv, bit) {

In Foreach.Simple.c:284:

        BitVecClear(&bv);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Foreach.Simple.c:315:

    
        // Test foreach idx on single element
        BitVecPush(&bv, false);
        BitVecForeachIdx(&bv, bit, idx) {
            result   = result && (idx == 0);

In Foreach.Simple.c:326:

        BitVecClear(&bv);
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Foreach.Simple.c:356:

    
        // Test reverse foreach on single element
        BitVecPush(&bv, true);
        int count = 0;
        BitVecForeachReverse(&bv, bit) {

In Foreach.Simple.c:366:

        // Test reverse ordering
        BitVecClear(&bv);
        BitVecPush(&bv, true);                          // idx 0
        BitVecPush(&bv, false);                         // idx 1
        BitVecPush(&bv, true);                          // idx 2

In Foreach.Simple.c:367:

        BitVecClear(&bv);
        BitVecPush(&bv, true);                          // idx 0
        BitVecPush(&bv, false);                         // idx 1
        BitVecPush(&bv, true);                          // idx 2

In Foreach.Simple.c:368:

        BitVecPush(&bv, true);                          // idx 0
        BitVecPush(&bv, false);                         // idx 1
        BitVecPush(&bv, true);                          // idx 2
    
        bool expected_sequence[] = {true, false, true}; // Reverse order

In Foreach.Simple.c:392:

        // Setup test data
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Foreach.Simple.c:444:

            // Create bitvec of varying sz
            for (int i = 0; i < sz; i++) {
                BitVecPush(&bv, i % 3 == 0);
            }

In Foreach.Simple.c:491:

    
        // Test pattern: 11100101 (3 true, 2 false, 1 true, 1 false, 1 true)
        BitVecPush(&bv, true);  // 0
        BitVecPush(&bv, true);  // 1
        BitVecPush(&bv, true);  // 2

In Foreach.Simple.c:492:

        // Test pattern: 11100101 (3 true, 2 false, 1 true, 1 false, 1 true)
        BitVecPush(&bv, true);  // 0
        BitVecPush(&bv, true);  // 1
        BitVecPush(&bv, true);  // 2
        BitVecPush(&bv, false); // 3

In Foreach.Simple.c:493:

        BitVecPush(&bv, true);  // 0
        BitVecPush(&bv, true);  // 1
        BitVecPush(&bv, true);  // 2
        BitVecPush(&bv, false); // 3
        BitVecPush(&bv, false); // 4

In Foreach.Simple.c:494:

        BitVecPush(&bv, true);  // 1
        BitVecPush(&bv, true);  // 2
        BitVecPush(&bv, false); // 3
        BitVecPush(&bv, false); // 4
        BitVecPush(&bv, true);  // 5

In Foreach.Simple.c:495:

        BitVecPush(&bv, true);  // 2
        BitVecPush(&bv, false); // 3
        BitVecPush(&bv, false); // 4
        BitVecPush(&bv, true);  // 5
        BitVecPush(&bv, false); // 6

In Foreach.Simple.c:496:

        BitVecPush(&bv, false); // 3
        BitVecPush(&bv, false); // 4
        BitVecPush(&bv, true);  // 5
        BitVecPush(&bv, false); // 6
        BitVecPush(&bv, true);  // 7

In Foreach.Simple.c:497:

        BitVecPush(&bv, false); // 4
        BitVecPush(&bv, true);  // 5
        BitVecPush(&bv, false); // 6
        BitVecPush(&bv, true);  // 7

In Foreach.Simple.c:498:

        BitVecPush(&bv, true);  // 5
        BitVecPush(&bv, false); // 6
        BitVecPush(&bv, true);  // 7
    
        u64  runs[10];

In Foreach.Simple.c:530:

    
        BitVec bv = BitVecInit(base);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Foreach.Simple.c:531:

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

In Foreach.Simple.c:532:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Foreach.Simple.c:533:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:534:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Foreach.Simple.c:535:

        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:536:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Foreach.Simple.c:537:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        BitVecRuns runs   = VecInitT(runs, base);

In Foreach.Simple.c:573:

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

In Foreach.Simple.c:581:

        // 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);
        result = result && (count == 1);

In Foreach.Simple.c:590:

        BitVec all_true_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 10; i++) {
            BitVecPush(&all_true_bv, true);
        }
        count  = BitVecRunLengths(&all_true_bv, runs, values, 5);

In Foreach.Simple.c:600:

        BitVec alternating_bv = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 7; i++) {
            BitVecPush(&alternating_bv, i % 2 == 0);
        }
        u64  alt_runs[10];

In Foreach.Simple.c:628:

        // Create pattern with many runs: 10101010 (8 runs)
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Foreach.Simple.c:673:

            bool value = (block % 2 == 0);
            for (int i = 0; i < 5; i++) {
                BitVecPush(&large_bv, value);
            }
        }

In Foreach.Simple.c:699:

    
        for (int i = 0; i < pattern_len; i++) {
            BitVecPush(&large_bv, pattern[i]);
        }

In BitWise.Simple.c:51:

    
        // Set up first bitvector: 1101
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:52:

        // Set up first bitvector: 1101
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In BitWise.Simple.c:53:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In BitWise.Simple.c:54:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
    
        // Set up second bitvector: 1010

In BitWise.Simple.c:57:

    
        // Set up second bitvector: 1010
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In BitWise.Simple.c:58:

        // Set up second bitvector: 1010
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:59:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:60:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        // Perform AND operation

In BitWise.Simple.c:93:

    
        // Set up first bitvector: 1100
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:94:

        // Set up first bitvector: 1100
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:95:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:96:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
    
        // Set up second bitvector: 1010

In BitWise.Simple.c:99:

    
        // Set up second bitvector: 1010
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In BitWise.Simple.c:100:

        // Set up second bitvector: 1010
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:101:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:102:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        // Perform OR operation

In BitWise.Simple.c:135:

    
        // Set up first bitvector: 1100
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:136:

        // Set up first bitvector: 1100
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:137:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In BitWise.Simple.c:138:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
    
        // Set up second bitvector: 1010

In BitWise.Simple.c:141:

    
        // Set up second bitvector: 1010
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In BitWise.Simple.c:142:

        // Set up second bitvector: 1010
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:143:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:144:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        // Perform XOR operation

In BitWise.Simple.c:176:

    
        // Set up bitvector: 1010
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:177:

        // Set up bitvector: 1010
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitWise.Simple.c:178:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitWise.Simple.c:179:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Perform NOT operation

In BitWise.Simple.c:209:

    
        // Set up bitvector: 1011 (indices 0,1,2,3)
        BitVecPush(&bv, true);  // index 0
        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2

In BitWise.Simple.c:210:

        // Set up bitvector: 1011 (indices 0,1,2,3)
        BitVecPush(&bv, true);  // index 0
        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2
        BitVecPush(&bv, true);  // index 3

In BitWise.Simple.c:211:

        BitVecPush(&bv, true);  // index 0
        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2
        BitVecPush(&bv, true);  // index 3

In BitWise.Simple.c:212:

        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2
        BitVecPush(&bv, true);  // index 3
    
        // Shift left by 2 positions

In BitWise.Simple.c:254:

    
        // Set up bitvector: 1011
        BitVecPush(&bv, true);  // index 0
        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2

In BitWise.Simple.c:255:

        // Set up bitvector: 1011
        BitVecPush(&bv, true);  // index 0
        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2
        BitVecPush(&bv, true);  // index 3

In BitWise.Simple.c:256:

        BitVecPush(&bv, true);  // index 0
        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2
        BitVecPush(&bv, true);  // index 3

In BitWise.Simple.c:257:

        BitVecPush(&bv, false); // index 1
        BitVecPush(&bv, true);  // index 2
        BitVecPush(&bv, true);  // index 3
    
        // Shift right by 2 positions

In BitWise.Simple.c:292:

    
        // Set up bitvector: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:293:

        // Set up bitvector: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:294:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:295:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        // Rotate left by 2 positions

In BitWise.Simple.c:324:

    
        // Set up bitvector: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:325:

        // Set up bitvector: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:326:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:327:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        // Rotate right by 1 position

In BitWise.Simple.c:356:

    
        // Set up bitvector: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:357:

        // Set up bitvector: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:358:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:359:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        // Reverse the bits

In BitWise.Simple.c:396:

    
        // Test shift by 0 (should be no-op)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecShiftLeft(&bv, 0);

In BitWise.Simple.c:397:

        // Test shift by 0 (should be no-op)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecShiftLeft(&bv, 0);
        result = result && (BitVecLen(&bv) == 2);

In BitWise.Simple.c:409:

        BitVecClear(&bv);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        BitVecShiftLeft(&bv, 1);

In BitWise.Simple.c:432:

    
        // Test rotate by 0
        BitVecPush(&bv, true);
        BitVecRotateRight(&bv, 0);
        result = result && (BitVecGet(&bv, 0) == true);

In BitWise.Simple.c:437:

    
        // Test rotate by length (should be no-op)
        BitVecPush(&bv, false);
        BitVecRotateLeft(&bv, 2);
        result = result && (BitVecLen(&bv) == 2);

In BitWise.Simple.c:468:

    
        // Test operations with different lengths
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:469:

        // Test operations with different lengths
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:470:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
    
        BitVecAnd(&result_bv, &bv1, &bv2);

In BitWise.Simple.c:480:

        result = result && (BitVecLen(&result_bv) == 0);
    
        BitVecPush(&bv1, true);
        BitVecNot(&result_bv, &bv1);
        result = result && (BitVecGet(&result_bv, 0) == false);

In BitWise.Simple.c:505:

    
        // Test reverse single bit
        BitVecPush(&bv, true);
        BitVecReverse(&bv);
        result = result && (BitVecLen(&bv) == 1);

In BitWise.Simple.c:512:

        // Test reverse even length
        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecReverse(&bv);

In BitWise.Simple.c:513:

        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecReverse(&bv);
        result = result && (BitVecGet(&bv, 0) == false);

In BitWise.Simple.c:543:

        // bv2: 1011     (4 bits)
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv1, (0b11010110 >> i) & 1);
        }
        for (int i = 0; i < 4; i++) {

In BitWise.Simple.c:546:

        }
        for (int i = 0; i < 4; i++) {
            BitVecPush(&bv2, (0b1011 >> i) & 1);
        }

In BitWise.Simple.c:564:

        BitVecClear(&bv1);
        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);

In BitWise.Simple.c:565:

        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);
    
        BitVecAnd(&result, &bv1, &bv2);

In BitWise.Simple.c:577:

        BitVecClear(&bv1);
        for (int i = 0; i < 100; i++) {
            BitVecPush(&bv1, i % 3 == 0);
        }

In BitWise.Simple.c:609:

        // Pattern: 10101010 10101011 (16 bits) - asymmetric to detect shifts
        for (int i = 0; i < 15; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        BitVecPush(&bv, true); // Make the last bit different to break symmetry

In BitWise.Simple.c:611:

            BitVecPush(&bv, i % 2 == 0);
        }
        BitVecPush(&bv, true); // Make the last bit different to break symmetry
    
        // Test various shift amounts

In BitWise.Simple.c:633:

        BitVecClear(&bv);
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv, true);
        }

In BitWise.Simple.c:642:

        BitVecClear(&bv);
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, true);
        }

In BitWise.Simple.c:650:

        // Test boundary conditions - shift by length-1
        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitWise.Simple.c:651:

        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitWise.Simple.c:652:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        BitVecShiftLeft(&bv, 2);

In BitWise.Simple.c:678:

        // Pattern: 10110100
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv, (0b10110100 >> i) & 1);
        }

In BitWise.Simple.c:711:

        // Test rotate with odd length
        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:712:

        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In BitWise.Simple.c:713:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true); // 5 bits: 10101

In BitWise.Simple.c:714:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true); // 5 bits: 10101

In BitWise.Simple.c:715:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true); // 5 bits: 10101
    
        BitVecRotateLeft(&bv, 2);

In BitWise.Simple.c:744:

        // Create test pattern
        for (int i = 0; i < 16; i++) {
            BitVecPush(&bv1, i % 3 == 0);
        }

In BitWise.Simple.c:792:

        BitVecClear(&bv2);
        for (int i = 0; i < 16; i++) {
            BitVecPush(&bv2, false);
        }

In BitWise.Simple.c:808:

        BitVecClear(&bv2);
        for (int i = 0; i < 16; i++) {
            BitVecPush(&bv2, true);
        }

In BitWise.Simple.c:842:

        // Create different patterns
        for (int i = 0; i < 12; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 3 == 0);
        }

In BitWise.Simple.c:843:

        for (int i = 0; i < 12; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 3 == 0);
        }

In BitWise.Simple.c:906:

        // Create large bitvectors (1000 bits each)
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 7 == 0);  // Pattern every 7 bits
            BitVecPush(&bv2, i % 11 == 0); // Pattern every 11 bits
        }

In BitWise.Simple.c:907:

        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 7 == 0);  // Pattern every 7 bits
            BitVecPush(&bv2, i % 11 == 0); // Pattern every 11 bits
        }

In BitWise.Simple.c:939:

        BitVecClear(&result);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&result, i % 2 == 0);
        }

In BitWise.Simple.c:979:

    
        // a = 10 (len 2)
        BitVecPush(&a, true);
        BitVecPush(&a, false);

In BitWise.Simple.c:980:

        // a = 10 (len 2)
        BitVecPush(&a, true);
        BitVecPush(&a, false);
    
        // b = 0110 (len 4, strictly longer than a)

In BitWise.Simple.c:983:

    
        // b = 0110 (len 4, strictly longer than a)
        BitVecPush(&b, false);
        BitVecPush(&b, true);
        BitVecPush(&b, true);

In BitWise.Simple.c:984:

        // b = 0110 (len 4, strictly longer than a)
        BitVecPush(&b, false);
        BitVecPush(&b, true);
        BitVecPush(&b, true);
        BitVecPush(&b, false);

In BitWise.Simple.c:985:

        BitVecPush(&b, false);
        BitVecPush(&b, true);
        BitVecPush(&b, true);
        BitVecPush(&b, false);

In BitWise.Simple.c:986:

        BitVecPush(&b, true);
        BitVecPush(&b, true);
        BitVecPush(&b, false);
    
        BitVecOr(&result, &a, &b);

In BitWise.Simple.c:1017:

    
        // a = 10 (len 2)
        BitVecPush(&a, true);
        BitVecPush(&a, false);

In BitWise.Simple.c:1018:

        // a = 10 (len 2)
        BitVecPush(&a, true);
        BitVecPush(&a, false);
    
        // b = 0110 (len 4, strictly longer than a)

In BitWise.Simple.c:1021:

    
        // b = 0110 (len 4, strictly longer than a)
        BitVecPush(&b, false);
        BitVecPush(&b, true);
        BitVecPush(&b, true);

In BitWise.Simple.c:1022:

        // b = 0110 (len 4, strictly longer than a)
        BitVecPush(&b, false);
        BitVecPush(&b, true);
        BitVecPush(&b, true);
        BitVecPush(&b, false);

In BitWise.Simple.c:1023:

        BitVecPush(&b, false);
        BitVecPush(&b, true);
        BitVecPush(&b, true);
        BitVecPush(&b, false);

In BitWise.Simple.c:1024:

        BitVecPush(&b, true);
        BitVecPush(&b, true);
        BitVecPush(&b, false);
    
        BitVecXor(&result, &a, &b);

In BitWise.Simple.c:1051:

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

In BitWise.Simple.c:1071:

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

In BitWise.Simple.c:1072:

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

In BitWise.Simple.c:1073:

        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, true);  // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4

In BitWise.Simple.c:1074:

        BitVecPush(&bv, true);  // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5

In BitWise.Simple.c:1075:

        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, false); // bit 6

In BitWise.Simple.c:1076:

        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, false); // bit 6
        BitVecPush(&bv, false); // bit 7

In BitWise.Simple.c:1077:

        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, false); // bit 6
        BitVecPush(&bv, false); // bit 7

In BitWise.Simple.c:1078:

        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, false); // bit 6
        BitVecPush(&bv, false); // bit 7
    
        BitVecShiftRight(&bv, 2);

In BitWise.Simple.c:1103:

        bool pat[5] = {true, false, false, true, true};
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, pat[i]);
        }
        BitVecRotateRight(&bv, 2);

In BitWise.Simple.c:1135:

        // 1011 -- length > 1 and positions % length != 0 so the rotate body
        // (clone + copy-back) actually runs.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:1136:

        // (clone + copy-back) actually runs.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:1137:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:1138:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        BitVecRotateRight(&bv, 1);

In BitWise.Simple.c:1177:

        // length > 1 and positions % length != 0 so the rotate body
        // (clone + copy-back) actually runs.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In BitWise.Simple.c:1178:

        // (clone + copy-back) actually runs.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:1179:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In BitWise.Simple.c:1180:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        BitVecRotateLeft(&bv, 2);

In BitWise.Deadend.c:87:

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

In BitWise.Deadend.c:88:

        BitVec bv2 = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);
    
        // Test NULL result pointer - should abort

In Pattern.Simple.c:15:

    static void push_bits(BitVec *bv, const char *bits) {
        for (const char *c = bits; *c != '\0'; c++)
            BitVecPush(bv, *c == '1');
    }

In Pattern.Simple.c:87:

    
        // Create source: 11010011101
        BitVecPush(&source, true);  // 0
        BitVecPush(&source, true);  // 1
        BitVecPush(&source, false); // 2

In Pattern.Simple.c:88:

        // Create source: 11010011101
        BitVecPush(&source, true);  // 0
        BitVecPush(&source, true);  // 1
        BitVecPush(&source, false); // 2
        BitVecPush(&source, true);  // 3

In Pattern.Simple.c:89:

        BitVecPush(&source, true);  // 0
        BitVecPush(&source, true);  // 1
        BitVecPush(&source, false); // 2
        BitVecPush(&source, true);  // 3
        BitVecPush(&source, false); // 4

In Pattern.Simple.c:90:

        BitVecPush(&source, true);  // 1
        BitVecPush(&source, false); // 2
        BitVecPush(&source, true);  // 3
        BitVecPush(&source, false); // 4
        BitVecPush(&source, false); // 5

In Pattern.Simple.c:91:

        BitVecPush(&source, false); // 2
        BitVecPush(&source, true);  // 3
        BitVecPush(&source, false); // 4
        BitVecPush(&source, false); // 5
        BitVecPush(&source, true);  // 6

In Pattern.Simple.c:92:

        BitVecPush(&source, true);  // 3
        BitVecPush(&source, false); // 4
        BitVecPush(&source, false); // 5
        BitVecPush(&source, true);  // 6
        BitVecPush(&source, true);  // 7

In Pattern.Simple.c:93:

        BitVecPush(&source, false); // 4
        BitVecPush(&source, false); // 5
        BitVecPush(&source, true);  // 6
        BitVecPush(&source, true);  // 7
        BitVecPush(&source, true);  // 8

In Pattern.Simple.c:94:

        BitVecPush(&source, false); // 5
        BitVecPush(&source, true);  // 6
        BitVecPush(&source, true);  // 7
        BitVecPush(&source, true);  // 8
        BitVecPush(&source, false); // 9

In Pattern.Simple.c:95:

        BitVecPush(&source, true);  // 6
        BitVecPush(&source, true);  // 7
        BitVecPush(&source, true);  // 8
        BitVecPush(&source, false); // 9
        BitVecPush(&source, true);  // 10

In Pattern.Simple.c:96:

        BitVecPush(&source, true);  // 7
        BitVecPush(&source, true);  // 8
        BitVecPush(&source, false); // 9
        BitVecPush(&source, true);  // 10

In Pattern.Simple.c:97:

        BitVecPush(&source, true);  // 8
        BitVecPush(&source, false); // 9
        BitVecPush(&source, true);  // 10
    
        // Create pattern: 101

In Pattern.Simple.c:100:

    
        // Create pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:101:

        // Create pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:102:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        // Test basic pattern finding

In Pattern.Simple.c:127:

        for (int i = 0; i < 12; i++) {
            bool bit = (i % 4 == 0 || i % 4 == 1 || i % 4 == 3);
            BitVecPush(&source, bit);
        }

In Pattern.Simple.c:131:

    
        // Pattern 1: 101 (should find multiple occurrences)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:132:

        // Pattern 1: 101 (should find multiple occurrences)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:133:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        u64 index = BitVecFindPattern(&source, &pattern);

In Pattern.Simple.c:140:

        // Pattern 2: Single bit pattern
        BitVecClear(&pattern);
        BitVecPush(&pattern, true);
        index  = BitVecFindPattern(&source, &pattern);
        result = result && (index == 0); // First true bit at index 0

In Pattern.Simple.c:146:

        // Pattern 3: Non-existent pattern
        BitVecClear(&pattern);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:147:

        BitVecClear(&pattern);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        index  = BitVecFindPattern(&source, &pattern);

In Pattern.Simple.c:148:

        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        index  = BitVecFindPattern(&source, &pattern);
        result = result && (index == SIZE_MAX); // Should not find three consecutive falses

In Pattern.Simple.c:154:

        // Pattern 4: Pattern at the end
        BitVecClear(&pattern);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        // Depending on the exact source pattern, adjust this test

In Pattern.Simple.c:155:

        BitVecClear(&pattern);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        // Depending on the exact source pattern, adjust this test

In Pattern.Simple.c:176:

        // Create source with multiple pattern occurrences: 101010101
        for (int i = 0; i < 9; i++) {
            BitVecPush(&source, i % 2 == 0);
        }

In Pattern.Simple.c:180:

    
        // Pattern: 10
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:181:

        // Pattern: 10
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
    
        u64 index = BitVecFindLastPattern(&source, &pattern);

In Pattern.Simple.c:191:

    
        // Source: 110011
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:192:

        // Source: 110011
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, false);

In Pattern.Simple.c:193:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:194:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:195:

        BitVecPush(&source, false);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:196:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
    
        // Pattern: 001

In Pattern.Simple.c:199:

    
        // Pattern: 001
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:200:

        // Pattern: 001
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:201:

        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        index  = BitVecFindLastPattern(&source, &pattern);

In Pattern.Simple.c:224:

        // Create source: 10101010101
        for (int i = 0; i < 11; i++) {
            BitVecPush(&source, i % 2 == 0);
        }

In Pattern.Simple.c:228:

    
        // Pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:229:

        // Pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:230:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        size results[10];

In Pattern.Simple.c:256:

        for (int i = 0; i < 9; i++) {
            bool bit = (i % 3 == 0 || i % 3 == 1);
            BitVecPush(&source, bit);
        }

In Pattern.Simple.c:260:

    
        // Pattern: 110
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:261:

        // Pattern: 110
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:262:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
    
        count  = BitVecFindAllPattern(&source, &pattern, results, 10);

In Pattern.Simple.c:289:

        // Source: 10101010101 (11 bits)
        for (int i = 0; i < 11; i++)
            BitVecPush(&source, i % 2 == 0);
        // Pattern: 101
        BitVecPush(&pattern, true);

In Pattern.Simple.c:291:

            BitVecPush(&source, i % 2 == 0);
        // Pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:292:

        // Pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:293:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        BitVecMatchIndices matches = VecInitT(matches, base);

In Pattern.Simple.c:324:

    
        // Test empty pattern
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        u64 index = BitVecFindPattern(&source, &pattern); // Empty pattern

In Pattern.Simple.c:325:

        // Test empty pattern
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        u64 index = BitVecFindPattern(&source, &pattern); // Empty pattern
        result    = result && (index == SIZE_MAX);

In Pattern.Simple.c:332:

        BitVecClear(&pattern);
        for (int i = 0; i < 5; i++) {
            BitVecPush(&pattern, true);
        }
        index  = BitVecFindPattern(&source, &pattern); // Pattern length 5, source length 2

In Pattern.Simple.c:340:

        BitVecClear(&source);
        BitVecClear(&pattern);
        BitVecPush(&pattern, true);
        index  = BitVecFindPattern(&source, &pattern);
        result = result && (index == SIZE_MAX);

In Pattern.Simple.c:347:

        BitVecClear(&source);
        BitVecClear(&pattern);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:348:

        BitVecClear(&pattern);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:349:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:350:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:351:

        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        index  = BitVecFindPattern(&source, &pattern);

In Pattern.Simple.c:352:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        index  = BitVecFindPattern(&source, &pattern);
        result = result && (index == 0);

In Pattern.Simple.c:359:

        BitVecClear(&source);
        BitVecClear(&pattern);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
        index  = BitVecFindPattern(&source, &pattern);

In Pattern.Simple.c:360:

        BitVecClear(&pattern);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
        index  = BitVecFindPattern(&source, &pattern);
        result = result && (index == 0);

In Pattern.Simple.c:364:

        result = result && (index == 0);
    
        BitVecPush(&pattern, false); // Now pattern is longer than source
        index  = BitVecFindPattern(&source, &pattern);
        result = result && (index == SIZE_MAX);

In Pattern.Simple.c:372:

        BitVecClear(&source);
        BitVecClear(&pattern);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:373:

        BitVecClear(&pattern);
        BitVecPush(&source, true);
        BitVecPush(&pattern, true);
    
        u64 count = BitVecFindAllPattern(&source, &pattern, results, 1);

In Pattern.Simple.c:399:

            // Create pattern "1010" every 100 bits, rest are "1100"
            if (i % 100 == 0) {
                BitVecPush(&source, true); // Start of 1010 pattern
                BitVecPush(&source, false);
                BitVecPush(&source, true);

In Pattern.Simple.c:400:

            if (i % 100 == 0) {
                BitVecPush(&source, true); // Start of 1010 pattern
                BitVecPush(&source, false);
                BitVecPush(&source, true);
                BitVecPush(&source, false);

In Pattern.Simple.c:401:

                BitVecPush(&source, true); // Start of 1010 pattern
                BitVecPush(&source, false);
                BitVecPush(&source, true);
                BitVecPush(&source, false);
                i += 3; // Skip next 3 iterations

In Pattern.Simple.c:402:

                BitVecPush(&source, false);
                BitVecPush(&source, true);
                BitVecPush(&source, false);
                i += 3; // Skip next 3 iterations
            } else {

In Pattern.Simple.c:405:

                i += 3; // Skip next 3 iterations
            } else {
                BitVecPush(&source, i % 2 == 0);
            }
        }

In Pattern.Simple.c:410:

    
        // Pattern: 1010
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:411:

        // Pattern: 1010
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:412:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:413:

        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
    
        u64 index = BitVecFindPattern(&source, &pattern);

In Pattern.Simple.c:450:

    
        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:451:

        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:452:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:453:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:454:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:455:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
    
        // Test prefix: 110

In Pattern.Simple.c:458:

    
        // Test prefix: 110
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);

In Pattern.Simple.c:459:

        // Test prefix: 110
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);

In Pattern.Simple.c:460:

        BitVecPush(&prefix, true);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
    
        result = result && BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:466:

        // Test non-matching prefix: 101
        BitVecClear(&prefix);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        BitVecPush(&prefix, true);

In Pattern.Simple.c:467:

        BitVecClear(&prefix);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        BitVecPush(&prefix, true);

In Pattern.Simple.c:468:

        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        BitVecPush(&prefix, true);
    
        result = result && !BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:488:

    
        // Test empty prefix (should always match)
        BitVecPush(&source, true);
        result = result && BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:493:

        // Test prefix longer than source
        BitVecClear(&source);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        result = result && !BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:494:

        BitVecClear(&source);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        result = result && !BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:500:

        BitVecClear(&source);
        BitVecClear(&prefix);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&prefix, true);

In Pattern.Simple.c:501:

        BitVecClear(&prefix);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);

In Pattern.Simple.c:502:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        result = result && BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:503:

        BitVecPush(&source, false);
        BitVecPush(&prefix, true);
        BitVecPush(&prefix, false);
        result = result && BitVecStartsWith(&source, &prefix);

In Pattern.Simple.c:523:

    
        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:524:

        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:525:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:526:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:527:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:528:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
    
        // Test suffix: 101

In Pattern.Simple.c:531:

    
        // Test suffix: 101
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);
        BitVecPush(&suffix, true);

In Pattern.Simple.c:532:

        // Test suffix: 101
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);
        BitVecPush(&suffix, true);

In Pattern.Simple.c:533:

        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);
        BitVecPush(&suffix, true);
    
        result = result && BitVecEndsWith(&source, &suffix);

In Pattern.Simple.c:539:

        // Test non-matching suffix: 110
        BitVecClear(&suffix);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);

In Pattern.Simple.c:540:

        BitVecClear(&suffix);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);

In Pattern.Simple.c:541:

        BitVecPush(&suffix, true);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);
    
        result = result && !BitVecEndsWith(&source, &suffix);

In Pattern.Simple.c:561:

    
        // Test empty suffix (should always match)
        BitVecPush(&source, true);
        result = result && BitVecEndsWith(&source, &suffix);

In Pattern.Simple.c:566:

        // Test suffix longer than source
        BitVecClear(&source);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);
        result = result && !BitVecEndsWith(&source, &suffix);

In Pattern.Simple.c:567:

        BitVecClear(&source);
        BitVecPush(&suffix, true);
        BitVecPush(&suffix, false);
        result = result && !BitVecEndsWith(&source, &suffix);

In Pattern.Simple.c:587:

    
        // Create source: 1101011
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:588:

        // Create source: 1101011
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:589:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:590:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:591:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:592:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:593:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
    
        // Test pattern: 101 (exists at positions 2 and 4)

In Pattern.Simple.c:596:

    
        // Test pattern: 101 (exists at positions 2 and 4)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:597:

        // Test pattern: 101 (exists at positions 2 and 4)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:598:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        result = result && (BitVecFindPattern(&source, &pattern) != SIZE_MAX);

In Pattern.Simple.c:604:

        // Test non-existing pattern: 000
        BitVecClear(&pattern);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:605:

        BitVecClear(&pattern);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:606:

        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, false);
    
        result = result && (BitVecFindPattern(&source, &pattern) == SIZE_MAX);

In Pattern.Simple.c:627:

    
        // Create source: 1101011
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:628:

        // Create source: 1101011
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:629:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:630:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:631:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:632:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:633:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
    
        // Test pattern: 101

In Pattern.Simple.c:636:

    
        // Test pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:637:

        // Test pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:638:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match

In Pattern.Simple.c:660:

    
        // Create small source
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:661:

        // Create small source
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        // Test pattern that extends beyond source

In Pattern.Simple.c:664:

    
        // Test pattern that extends beyond source
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:665:

        // Test pattern that extends beyond source
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:666:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long

In Pattern.Simple.c:688:

        // Create source: 101010101
        for (int i = 0; i < 9; i++) {
            BitVecPush(&source, i % 2 == 0);
        }

In Pattern.Simple.c:692:

    
        // Test pattern: 101 (should find 4 occurrences at 0, 2, 4, 6)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:693:

        // Test pattern: 101 (should find 4 occurrences at 0, 2, 4, 6)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:694:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        u64 count = BitVecCountPattern(&source, &pattern);

In Pattern.Simple.c:701:

        // Test pattern: 010 (should find 3 occurrences at 1, 3, 5)
        BitVecClear(&pattern);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:702:

        BitVecClear(&pattern);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:703:

        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
    
        count  = BitVecCountPattern(&source, &pattern);

In Pattern.Simple.c:725:

    
        // Create source: 101101101
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:726:

        // Create source: 101101101
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:727:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:728:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:729:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:730:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:731:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:732:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:733:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
    
        // Test pattern: 101

In Pattern.Simple.c:736:

    
        // Test pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:737:

        // Test pattern: 101
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:738:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        // Search from index 8 backwards

In Pattern.Simple.c:766:

    
        // Create source: 110110
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:767:

        // Create source: 110110
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:768:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:769:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:770:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:771:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        // Old pattern: 110

In Pattern.Simple.c:774:

    
        // Old pattern: 110
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, false);

In Pattern.Simple.c:775:

        // Old pattern: 110
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, false);

In Pattern.Simple.c:776:

        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, false);
    
        // New pattern: 101

In Pattern.Simple.c:779:

    
        // New pattern: 101
        BitVecPush(&new_pattern, true);
        BitVecPush(&new_pattern, false);
        BitVecPush(&new_pattern, true);

In Pattern.Simple.c:780:

        // New pattern: 101
        BitVecPush(&new_pattern, true);
        BitVecPush(&new_pattern, false);
        BitVecPush(&new_pattern, true);

In Pattern.Simple.c:781:

        BitVecPush(&new_pattern, true);
        BitVecPush(&new_pattern, false);
        BitVecPush(&new_pattern, true);
    
        bool replaced = BitVecReplace(&source, &old_pattern, &new_pattern);

In Pattern.Simple.c:812:

        // Create source: 110110110
        for (int i = 0; i < 3; i++) {
            BitVecPush(&source, true);
            BitVecPush(&source, true);
            BitVecPush(&source, false);

In Pattern.Simple.c:813:

        for (int i = 0; i < 3; i++) {
            BitVecPush(&source, true);
            BitVecPush(&source, true);
            BitVecPush(&source, false);
        }

In Pattern.Simple.c:814:

            BitVecPush(&source, true);
            BitVecPush(&source, true);
            BitVecPush(&source, false);
        }

In Pattern.Simple.c:818:

    
        // Old pattern: 110
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, false);

In Pattern.Simple.c:819:

        // Old pattern: 110
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, false);

In Pattern.Simple.c:820:

        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, true);
        BitVecPush(&old_pattern, false);
    
        // New pattern: 01

In Pattern.Simple.c:823:

    
        // New pattern: 01
        BitVecPush(&new_pattern, false);
        BitVecPush(&new_pattern, true);

In Pattern.Simple.c:824:

        // New pattern: 01
        BitVecPush(&new_pattern, false);
        BitVecPush(&new_pattern, true);
    
        u64 replacements = BitVecReplaceAll(&source, &old_pattern, &new_pattern);

In Pattern.Simple.c:851:

    
        // Create source: 1101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:852:

        // Create source: 1101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:853:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:854:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
    
        // Create pattern: 1?01 (where ? can be anything)

In Pattern.Simple.c:857:

    
        // Create pattern: 1?01 (where ? can be anything)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false); // This will be wildcarded
        BitVecPush(&pattern, false);

In Pattern.Simple.c:858:

        // Create pattern: 1?01 (where ? can be anything)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false); // This will be wildcarded
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:859:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false); // This will be wildcarded
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:860:

        BitVecPush(&pattern, false); // This will be wildcarded
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
    
        // Create wildcard: 0100 (1 means wildcard, 0 means must match exactly)

In Pattern.Simple.c:863:

    
        // Create wildcard: 0100 (1 means wildcard, 0 means must match exactly)
        BitVecPush(&wildcard, false);
        BitVecPush(&wildcard, true); // Wildcard position
        BitVecPush(&wildcard, false);

In Pattern.Simple.c:864:

        // Create wildcard: 0100 (1 means wildcard, 0 means must match exactly)
        BitVecPush(&wildcard, false);
        BitVecPush(&wildcard, true); // Wildcard position
        BitVecPush(&wildcard, false);
        BitVecPush(&wildcard, false);

In Pattern.Simple.c:865:

        BitVecPush(&wildcard, false);
        BitVecPush(&wildcard, true); // Wildcard position
        BitVecPush(&wildcard, false);
        BitVecPush(&wildcard, false);

In Pattern.Simple.c:866:

        BitVecPush(&wildcard, true); // Wildcard position
        BitVecPush(&wildcard, false);
        BitVecPush(&wildcard, false);
    
        result = result && BitVecMatches(&source, &pattern, &wildcard);

In Pattern.Simple.c:888:

    
        // Create source: 110100111
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:889:

        // Create source: 110100111
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:890:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:891:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, false);

In Pattern.Simple.c:892:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:893:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:894:

        BitVecPush(&source, false);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:895:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:896:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
    
        // Create pattern: 111 (should match at position 6 with 0 errors)

In Pattern.Simple.c:899:

    
        // Create pattern: 111 (should match at position 6 with 0 errors)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:900:

        // Create pattern: 111 (should match at position 6 with 0 errors)
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:901:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
    
        u64 pos = BitVecFuzzyMatch(&source, &pattern, 0);

In Pattern.Simple.c:926:

    
        // Create source: 101010
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:927:

        // Create source: 101010
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:928:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:929:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:930:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:931:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        // Test simple substring match

In Pattern.Simple.c:955:

    
        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:956:

        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:957:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:958:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:959:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:960:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
    
        BitVec *p0 = VecPtrAt(&patterns, 0);

In Pattern.Simple.c:971:

    
        // Pattern 0: 111 (should not match)
        BitVecPush(p0, true);
        BitVecPush(p0, true);
        BitVecPush(p0, true);

In Pattern.Simple.c:972:

        // Pattern 0: 111 (should not match)
        BitVecPush(p0, true);
        BitVecPush(p0, true);
        BitVecPush(p0, true);

In Pattern.Simple.c:973:

        BitVecPush(p0, true);
        BitVecPush(p0, true);
        BitVecPush(p0, true);
    
        // Pattern 1: 110 (should match)

In Pattern.Simple.c:976:

    
        // Pattern 1: 110 (should match)
        BitVecPush(p1, true);
        BitVecPush(p1, true);
        BitVecPush(p1, false);

In Pattern.Simple.c:977:

        // Pattern 1: 110 (should match)
        BitVecPush(p1, true);
        BitVecPush(p1, true);
        BitVecPush(p1, false);

In Pattern.Simple.c:978:

        BitVecPush(p1, true);
        BitVecPush(p1, true);
        BitVecPush(p1, false);
    
        // Pattern 2: 101 (should not match as prefix)

In Pattern.Simple.c:981:

    
        // Pattern 2: 101 (should not match as prefix)
        BitVecPush(p2, true);
        BitVecPush(p2, false);
        BitVecPush(p2, true);

In Pattern.Simple.c:982:

        // Pattern 2: 101 (should not match as prefix)
        BitVecPush(p2, true);
        BitVecPush(p2, false);
        BitVecPush(p2, true);

In Pattern.Simple.c:983:

        BitVecPush(p2, true);
        BitVecPush(p2, false);
        BitVecPush(p2, true);
    
        u64 match_idx = BitVecPrefixMatch(&source, &patterns);

In Pattern.Simple.c:1007:

    
        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1008:

        // Create source: 110101
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1009:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1010:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1011:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1012:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
    
        BitVec *p0 = VecPtrAt(&patterns, 0);

In Pattern.Simple.c:1023:

    
        // Pattern 0: 111 (should not match)
        BitVecPush(p0, true);
        BitVecPush(p0, true);
        BitVecPush(p0, true);

In Pattern.Simple.c:1024:

        // Pattern 0: 111 (should not match)
        BitVecPush(p0, true);
        BitVecPush(p0, true);
        BitVecPush(p0, true);

In Pattern.Simple.c:1025:

        BitVecPush(p0, true);
        BitVecPush(p0, true);
        BitVecPush(p0, true);
    
        // Pattern 1: 101 (should match as suffix)

In Pattern.Simple.c:1028:

    
        // Pattern 1: 101 (should match as suffix)
        BitVecPush(p1, true);
        BitVecPush(p1, false);
        BitVecPush(p1, true);

In Pattern.Simple.c:1029:

        // Pattern 1: 101 (should match as suffix)
        BitVecPush(p1, true);
        BitVecPush(p1, false);
        BitVecPush(p1, true);

In Pattern.Simple.c:1030:

        BitVecPush(p1, true);
        BitVecPush(p1, false);
        BitVecPush(p1, true);
    
        // Pattern 2: 110 (should not match as suffix)

In Pattern.Simple.c:1033:

    
        // Pattern 2: 110 (should not match as suffix)
        BitVecPush(p2, true);
        BitVecPush(p2, true);
        BitVecPush(p2, false);

In Pattern.Simple.c:1034:

        // Pattern 2: 110 (should not match as suffix)
        BitVecPush(p2, true);
        BitVecPush(p2, true);
        BitVecPush(p2, false);

In Pattern.Simple.c:1035:

        BitVecPush(p2, true);
        BitVecPush(p2, true);
        BitVecPush(p2, false);
    
        u64 match_idx = BitVecSuffixMatch(&source, &patterns);

In Pattern.Simple.c:1060:

    
        // Source and pattern are both 1011, same length.
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1061:

        // Source and pattern are both 1011, same length.
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:1062:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);

In Pattern.Simple.c:1063:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, true);
    
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1065:

        BitVecPush(&source, true);
    
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1066:

    
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1067:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1068:

        BitVecPush(&pattern, false);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
    
        // Exact-length match must be found at index 0.

In Pattern.Simple.c:1092:

    
        // Source and pattern are both 110, same length.
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1093:

        // Source and pattern are both 110, same length.
        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1094:

        BitVecPush(&source, true);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1096:

        BitVecPush(&source, false);
    
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:1097:

    
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);

In Pattern.Simple.c:1098:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, false);
    
        BitVecMatchIndices matches = VecInitT(matches, base);

In Pattern.Simple.c:1380:

        // source: 0000 (no occurrence of "11")
        for (int i = 0; i < 4; i++)
            BitVecPush(&source, false);
    
        // old: 11 (absent), new: 1

In Pattern.Simple.c:1383:

    
        // old: 11 (absent), new: 1
        BitVecPush(&old, true);
        BitVecPush(&old, true);
        BitVecPush(&neww, true);

In Pattern.Simple.c:1384:

        // old: 11 (absent), new: 1
        BitVecPush(&old, true);
        BitVecPush(&old, true);
        BitVecPush(&neww, true);

In Pattern.Simple.c:1385:

        BitVecPush(&old, true);
        BitVecPush(&old, true);
        BitVecPush(&neww, true);
    
        u64 n  = BitVecReplaceAll(&source, &old, &neww);

In Pattern.Simple.c:1415:

        // source: 110110110
        for (int i = 0; i < 3; i++) {
            BitVecPush(&source, true);
            BitVecPush(&source, true);
            BitVecPush(&source, false);

In Pattern.Simple.c:1416:

        for (int i = 0; i < 3; i++) {
            BitVecPush(&source, true);
            BitVecPush(&source, true);
            BitVecPush(&source, false);
        }

In Pattern.Simple.c:1417:

            BitVecPush(&source, true);
            BitVecPush(&source, true);
            BitVecPush(&source, false);
        }

In Pattern.Simple.c:1421:

    
        // old: 110, new: 01  (each 110 -> 01, result 010101)
        BitVecPush(&old, true);
        BitVecPush(&old, true);
        BitVecPush(&old, false);

In Pattern.Simple.c:1422:

        // old: 110, new: 01  (each 110 -> 01, result 010101)
        BitVecPush(&old, true);
        BitVecPush(&old, true);
        BitVecPush(&old, false);
        BitVecPush(&neww, false);

In Pattern.Simple.c:1423:

        BitVecPush(&old, true);
        BitVecPush(&old, true);
        BitVecPush(&old, false);
        BitVecPush(&neww, false);
        BitVecPush(&neww, true);

In Pattern.Simple.c:1424:

        BitVecPush(&old, true);
        BitVecPush(&old, false);
        BitVecPush(&neww, false);
        BitVecPush(&neww, true);

In Pattern.Simple.c:1425:

        BitVecPush(&old, false);
        BitVecPush(&neww, false);
        BitVecPush(&neww, true);
    
        u64 n  = BitVecReplaceAll(&source, &old, &neww);

In Pattern.Simple.c:1457:

        // source: 1010, pattern: 1111, wildcard: 0000 (no wildcards).
        // Position 0 matches (1 vs 1); position 1 mismatches (0 vs 1) -> false.
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1458:

        // Position 0 matches (1 vs 1); position 1 mismatches (0 vs 1) -> false.
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1459:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1460:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        for (int i = 0; i < 4; i++)

In Pattern.Simple.c:1463:

    
        for (int i = 0; i < 4; i++)
            BitVecPush(&pattern, true);
        for (int i = 0; i < 4; i++)
            BitVecPush(&wildcard, false);

In Pattern.Simple.c:1465:

            BitVecPush(&pattern, true);
        for (int i = 0; i < 4; i++)
            BitVecPush(&wildcard, false);
    
        result = result && (BitVecMatches(&source, &pattern, &wildcard) == false);

In Pattern.Simple.c:1473:

        BitVec wild_all = BitVecInit(base);
        for (int i = 0; i < 4; i++)
            BitVecPush(&wild_all, true);
        result = result && (BitVecMatches(&source, &pattern, &wild_all) == true);

In Pattern.Simple.c:1497:

        // source: 111, pattern: 111 (same length, exact match).
        for (int i = 0; i < 3; i++) {
            BitVecPush(&source, true);
            BitVecPush(&pattern, true);
        }

In Pattern.Simple.c:1498:

        for (int i = 0; i < 3; i++) {
            BitVecPush(&source, true);
            BitVecPush(&pattern, true);
        }

In Pattern.Simple.c:1524:

        // source: 00000111 (8 bits), pattern: 111.
        for (int i = 0; i < 5; i++)
            BitVecPush(&source, false);
        for (int i = 0; i < 3; i++)
            BitVecPush(&source, true);

In Pattern.Simple.c:1526:

            BitVecPush(&source, false);
        for (int i = 0; i < 3; i++)
            BitVecPush(&source, true);
    
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1528:

            BitVecPush(&source, true);
    
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1529:

    
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1530:

        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
        BitVecPush(&pattern, true);
    
        // Window [4,6] = 011 -> 1 error <= 1 (first acceptable window).

In Pattern.Simple.c:1562:

        // zero errors, so the loop must traverse every valid i and report SIZE_MAX.
        for (int i = 0; i < 4096; i++)
            BitVecPush(&source, false);
        BitVecPush(&pattern, true);

In Pattern.Simple.c:1563:

        for (int i = 0; i < 4096; i++)
            BitVecPush(&source, false);
        BitVecPush(&pattern, true);
    
        bool result = (BitVecFuzzyMatch(&source, &pattern, 0) == SIZE_MAX);

In Pattern.Simple.c:1586:

    
        // Source rendering: 101010
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1587:

        // Source rendering: 101010
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1588:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);

In Pattern.Simple.c:1589:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1590:

        BitVecPush(&source, true);
        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);

In Pattern.Simple.c:1591:

        BitVecPush(&source, false);
        BitVecPush(&source, true);
        BitVecPush(&source, false);
    
        // "111" never appears in "101010" -> must be false.

In Pattern.Simple.c:1624:

    
        // 101010 so the render is a non-empty Str that must be freed.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Pattern.Simple.c:1625:

        // 101010 so the render is a non-empty Str that must be freed.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Pattern.Simple.c:1626:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Pattern.Simple.c:1627:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Pattern.Simple.c:1628:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Pattern.Simple.c:1629:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        bool matched = BitVecRegexMatch(&bv, "101");

In Pattern.Simple.c:1660:

    
        BitVec bv = BitVecInit(adbg);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Pattern.Simple.c:1661:

        BitVec bv = BitVecInit(adbg);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Pattern.Simple.c:1662:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Pattern.Simple.c:1663:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Pattern.Simple.c:1664:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Pattern.Simple.c:1665:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Pattern "101" as a Str on a separate (untracked) allocator.

In Math.c:72:

    static void push_bits(BitVec *bv, const char *bits) {
        for (const char *p = bits; *p != '\0'; p++)
            BitVecPush(bv, *p == '1');
    }

In Math.c:86:

    
        // Test identical bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:87:

        // Test identical bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:88:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:89:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:90:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:91:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        u64 distance = BitVecHammingDistance(&bv1, &bv2);

In Math.c:98:

        // Test completely different bitvectors
        BitVecClear(&bv2);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:99:

        BitVecClear(&bv2);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:100:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        distance = BitVecHammingDistance(&bv1, &bv2);

In Math.c:107:

        // Test partially different bitvectors
        BitVecClear(&bv2);
        BitVecPush(&bv2, true); // Same
        BitVecPush(&bv2, true); // Different
        BitVecPush(&bv2, true); // Same

In Math.c:108:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true); // Same
        BitVecPush(&bv2, true); // Different
        BitVecPush(&bv2, true); // Same

In Math.c:109:

        BitVecPush(&bv2, true); // Same
        BitVecPush(&bv2, true); // Different
        BitVecPush(&bv2, true); // Same
    
        distance = BitVecHammingDistance(&bv1, &bv2);

In Math.c:135:

    
        // Test different lengths
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:136:

        // Test different lengths
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:137:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
    
        distance = BitVecHammingDistance(&bv1, &bv2);

In Math.c:164:

    
        // Test identical bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:165:

        // Test identical bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:166:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:167:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:168:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:169:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        double similarity = BitVecJaccardSimilarity(&bv1, &bv2);

In Math.c:177:

        BitVecClear(&bv1);
        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In Math.c:178:

        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:179:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:180:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        similarity = BitVecJaccardSimilarity(&bv1, &bv2);

In Math.c:188:

        BitVecClear(&bv1);
        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:189:

        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:190:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:191:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Math.c:192:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        // Intersection: 1, Union: 2, Jaccard = 1/2 = 0.5

In Math.c:193:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
        // Intersection: 1, Union: 2, Jaccard = 1/2 = 0.5

In Math.c:220:

    
        // Test all zeros
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In Math.c:221:

        // Test all zeros
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Math.c:222:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Math.c:223:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
    
        similarity = BitVecJaccardSimilarity(&bv1, &bv2);

In Math.c:245:

    
        // Test identical bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:246:

        // Test identical bitvectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:247:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:248:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:249:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:250:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        double similarity = BitVecCosineSimilarity(&bv1, &bv2);

In Math.c:258:

        BitVecClear(&bv1);
        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In Math.c:259:

        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:260:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:261:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        similarity = BitVecCosineSimilarity(&bv1, &bv2);

In Math.c:283:

    
        // Test zero vectors
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In Math.c:284:

        // Test zero vectors
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Math.c:285:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);

In Math.c:286:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, false);
    
        double similarity = BitVecCosineSimilarity(&bv1, &bv2);

In Math.c:293:

        // Test one zero vector
        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:294:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        similarity = BitVecCosineSimilarity(&bv1, &bv2);

In Math.c:316:

    
        // Test basic dot product
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:317:

        // Test basic dot product
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Math.c:318:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:319:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:320:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:321:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:322:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:323:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        u64 product = BitVecDotProduct(&bv1, &bv2);

In Math.c:331:

        BitVecClear(&bv1);
        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);

In Math.c:332:

        BitVecClear(&bv2);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:333:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:334:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        product = BitVecDotProduct(&bv1, &bv2);

In Math.c:360:

    
        // Test different lengths
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Math.c:361:

        // Test different lengths
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:362:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:363:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:364:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        product = BitVecDotProduct(&bv1, &bv2);

In Math.c:386:

    
        // Test identical strings
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:387:

        // Test identical strings
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:388:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:389:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:390:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:391:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        bool error    = true;

In Math.c:399:

        // Test single substitution
        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // Changed from false
        BitVecPush(&bv2, true);

In Math.c:400:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // Changed from false
        BitVecPush(&bv2, true);

In Math.c:401:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true); // Changed from false
        BitVecPush(&bv2, true);
    
        distance = BitVecEditDistance(&bv1, &bv2);

In Math.c:408:

        // Test insertion
        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:409:

        BitVecClear(&bv2);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false); // Extra bit

In Math.c:410:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false); // Extra bit

In Math.c:411:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false); // Extra bit
    
        distance = BitVecEditDistance(&bv1, &bv2);

In Math.c:437:

    
        // Test empty to non-empty
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:438:

        // Test empty to non-empty
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        distance = BitVecEditDistance(&bv1, &bv2);

In Math.c:464:

    
        // Test perfect correlation
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:465:

        // Test perfect correlation
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:466:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:467:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:468:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:469:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:470:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:471:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        double correlation = BitVecCorrelation(&bv1, &bv2);

In Math.c:478:

        // Test perfect anti-correlation
        BitVecClear(&bv2);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:479:

        BitVecClear(&bv2);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:480:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:481:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        correlation = BitVecCorrelation(&bv1, &bv2);

In Math.c:507:

    
        // Test uniform vectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Math.c:508:

        // Test uniform vectors
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:509:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:510:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:511:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:512:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        correlation = BitVecCorrelation(&bv1, &bv2);

In Math.c:533:

    
        // Test maximum entropy (equal 0s and 1s)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Math.c:534:

        // Test maximum entropy (equal 0s and 1s)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Math.c:535:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Math.c:536:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        double entropy = BitVecEntropy(&bv);

In Math.c:543:

        // Test minimum entropy (all same)
        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Math.c:544:

        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Math.c:545:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        entropy = BitVecEntropy(&bv);

In Math.c:569:

    
        // Test single bit
        BitVecPush(&bv, true);
        entropy = BitVecEntropy(&bv);
        result  = result && (entropy == 0.0);

In Math.c:589:

    
        // Test perfect match
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:590:

        // Test perfect match
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:591:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:592:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:593:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:594:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
    
        int score = BitVecAlignmentScore(&bv1, &bv2, 2, -1);

In Math.c:601:

        // Test perfect mismatch
        BitVecClear(&bv2);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:602:

        BitVecClear(&bv2);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:603:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        score  = BitVecAlignmentScore(&bv1, &bv2, 2, -1);

In Math.c:629:

    
        // Test different lengths (only overlapping region scored)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:630:

        // Test different lengths (only overlapping region scored)
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:631:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:632:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:633:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        score  = BitVecAlignmentScore(&bv1, &bv2, 1, -1);

In Math.c:655:

    
        // Create bv1: 1100110
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:656:

        // Create bv1: 1100110
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Math.c:657:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:658:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);

In Math.c:659:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:660:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:661:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        // Create bv2: 110 (should match at position 0 and 4)

In Math.c:664:

    
        // Create bv2: 110 (should match at position 0 and 4)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:665:

        // Create bv2: 110 (should match at position 0 and 4)
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:666:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        u64 best_pos = BitVecBestAlignment(&bv1, &bv2);

In Math.c:692:

    
        // Test bv2 longer than bv1
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:693:

        // Test bv2 longer than bv1
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:694:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        best_pos = BitVecBestAlignment(&bv1, &bv2);

In Math.c:717:

        // Create large bitvectors
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 3 == 0);
        }

In Math.c:718:

        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv1, i % 2 == 0);
            BitVecPush(&bv2, i % 3 == 0);
        }

In Math.c:735:

        BitVec small2 = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 50; i++) {
            BitVecPush(&small1, i % 2 == 0);
            BitVecPush(&small2, i % 3 == 0);
        }

In Math.c:736:

        for (int i = 0; i < 50; i++) {
            BitVecPush(&small1, i % 2 == 0);
            BitVecPush(&small2, i % 3 == 0);
        }
        u64 edit_dist = BitVecEditDistance(&small1, &small2);

In Math.c:769:

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

In Math.c:781:

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

In Math.c:793:

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

In Math.c:805:

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

In Math.c:817:

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

In Math.c:829:

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

In Math.c:841:

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

In Math.c:853:

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

In Math.c:865:

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

In Math.c:877:

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

In Math.c:889:

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

In Math.c:901:

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

In Math.c:919:

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

In Math.c:931:

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

In Math.c:943:

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

In Math.c:955:

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

In Math.c:974:

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

In Math.c:1005:

    
        // bv1 = {1}, bv2 = {1, 0}. Intersection 1 (pos 0), union 1 -> 1.0.
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:1006:

        // bv1 = {1}, bv2 = {1, 0}. Intersection 1 (pos 0), union 1 -> 1.0.
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:1007:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        double s      = BitVecJaccardSimilarity(&bv1, &bv2);

In Math.c:1031:

    
        // bv1 = {1, 0}, bv2 = {1}. Intersection 1 (pos 0), union 1 -> 1.0.
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:1032:

        // bv1 = {1, 0}, bv2 = {1}. Intersection 1 (pos 0), union 1 -> 1.0.
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:1033:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
    
        double s      = BitVecJaccardSimilarity(&bv1, &bv2);

In Math.c:1058:

    
        // bv1 = {0, 0}, bv2 = {1, 1}. Intersection 0, union 2 -> 0.0.
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);

In Math.c:1059:

        // bv1 = {0, 0}, bv2 = {1, 1}. Intersection 0, union 2 -> 0.0.
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:1060:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:1061:

        BitVecPush(&bv1, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        double s      = BitVecJaccardSimilarity(&bv1, &bv2);

In Math.c:1084:

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

In Math.c:1085:

    
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);

In Math.c:1086:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
    
        u64  dist   = BitVecEditDistance(&bv1, &bv2);

In Math.c:1109:

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

In Math.c:1110:

    
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);

In Math.c:1111:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, false);
    
        u64  dist   = BitVecEditDistance(&bv1, &bv2);

In Math.c:1143:

        BitVec warm_b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 5; i++) {
            BitVecPush(&warm_a, (i % 2) == 0);
            BitVecPush(&warm_b, (i % 3) == 0);
        }

In Math.c:1144:

        for (int i = 0; i < 5; i++) {
            BitVecPush(&warm_a, (i % 2) == 0);
            BitVecPush(&warm_b, (i % 3) == 0);
        }
        (void)BitVecEditDistance(&warm_a, &warm_b);

In Math.c:1153:

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

In Math.c:1181:

        BitVec warm_b = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 4; i++) {
            BitVecPush(&warm_a, (i % 2) == 1);
            BitVecPush(&warm_b, (i % 2) == 0);
        }

In Math.c:1182:

        for (int i = 0; i < 4; i++) {
            BitVecPush(&warm_a, (i % 2) == 1);
            BitVecPush(&warm_b, (i % 2) == 0);
        }
        (void)BitVecEditDistance(&warm_a, &warm_b);

In Math.c:1191:

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

In Math.c:1217:

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

In Math.c:1218:

    
        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:1219:

        BitVecPush(&bv1, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:1220:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        u64  dist   = BitVecEditDistance(&bv1, &bv2);

In Math.c:1266:

    
        // bv1 length 2, bv2 length 4 -> bv1 is the shorter operand.
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:1267:

        // bv1 length 2, bv2 length 4 -> bv1 is the shorter operand.
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);

In Math.c:1269:

        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);

In Math.c:1270:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:1271:

        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:1272:

        BitVecPush(&bv2, false);
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        double correlation = BitVecCorrelation(&bv1, &bv2);

In Math.c:1296:

    
        // bv1 length 4, bv2 length 2 -> bv2 is the shorter operand.
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);

In Math.c:1297:

        // bv1 length 4, bv2 length 2 -> bv2 is the shorter operand.
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:1298:

        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);

In Math.c:1299:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, true);
        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);

In Math.c:1301:

        BitVecPush(&bv1, false);
    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);

In Math.c:1302:

    
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, false);
    
        double correlation = BitVecCorrelation(&bv1, &bv2);

In Math.c:1326:

        bool   result = true;
    
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Math.c:1327:

    
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Math.c:1328:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Math.c:1329:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        double entropy = BitVecEntropy(&bv);

In Math.c:1362:

    
        // bv1 = 0 0 0 0
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Math.c:1363:

        // bv1 = 0 0 0 0
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Math.c:1364:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);

In Math.c:1365:

        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
        BitVecPush(&bv1, false);
    
        // bv2 = 1 1

In Math.c:1368:

    
        // bv2 = 1 1
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);

In Math.c:1369:

        // bv2 = 1 1
        BitVecPush(&bv2, true);
        BitVecPush(&bv2, true);
    
        u64 best_offset = BitVecBestAlignment(&bv1, &bv2);

In Math.c:1395:

        // With sqrt forced to sqrt(42), cosine collapses to 4/42 ~= 0.095.
        for (u64 i = 0; i < 4; i++) {
            BitVecPush(&bv1, true);
            BitVecPush(&bv2, true);
        }

In Math.c:1396:

        for (u64 i = 0; i < 4; i++) {
            BitVecPush(&bv1, true);
            BitVecPush(&bv2, true);
        }

In Math.c:1422:

        // 3 ones, 1 zero -> p1=0.75, p0=0.25.
        // entropy = -(0.75*log2(0.75) + 0.25*log2(0.25)) ~= 0.8112782517.
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Math.c:1423:

        // entropy = -(0.75*log2(0.75) + 0.25*log2(0.25)) ~= 0.8112782517.
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Math.c:1424:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Math.c:1425:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        double entropy = BitVecEntropy(&bv);

In Math.c:1448:

    
        // 1000 -> one 1, three 0s : p1 = 0.25, p0 = 0.75.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Math.c:1449:

        // 1000 -> one 1, three 0s : p1 = 0.25, p0 = 0.75.
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Math.c:1450:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);

In Math.c:1451:

        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
        BitVecPush(&bv, false);
    
        double entropy = BitVecEntropy(&bv);

In Remove.c:42:

    
        // Add some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:43:

        // Add some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:44:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Pop the last bit

In Remove.c:80:

    
        // Add some bits: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:81:

        // Add some bits: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:82:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:83:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:84:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Remove bit at index 2 (middle true)

In Remove.c:120:

    
        // Add some bits: true, false, true, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:121:

        // Add some bits: true, false, true, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Remove.c:122:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:123:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:124:

        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:125:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Remove range from index 1 to 3 (3 bits)

In Remove.c:153:

    
        // Add some bits: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:154:

        // Add some bits: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:155:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:156:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:157:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Remove first occurrence of false

In Remove.c:194:

    
        // Add some bits: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:195:

        // Add some bits: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:196:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:197:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:198:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Remove last occurrence of false

In Remove.c:236:

    
        // Add some bits: true, false, true, false, true, false
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:237:

        // Add some bits: true, false, true, false, true, false
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:238:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Remove.c:239:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:240:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Remove.c:241:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Remove all false bits

In Remove.c:278:

    
        // Test pop single element
        BitVecPush(&bv, true);
        bool popped = BitVecPop(&bv);
        result      = result && (popped == true) && (BitVecLen(&bv) == 0);

In Remove.c:284:

        // Test multiple pops in sequence
        for (int i = 0; i < 100; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        for (int i = 99; i >= 0; i--) {

In Remove.c:306:

    
        // Test remove last element
        BitVecPush(&bv, true);
        bool removed = BitVecRemove(&bv, 0);
        result       = result && (removed == true) && (BitVecLen(&bv) == 0);

In Remove.c:312:

        // Test remove from large bitvec
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 3 == 0);
        }

In Remove.c:334:

    
        // Test remove 0 elements (should be no-op)
        BitVecPush(&bv, true);
        BitVecRemoveRange(&bv, 0, 0);
        result = result && (BitVecLen(&bv) == 1);

In Remove.c:341:

        BitVecClear(&bv);
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        BitVecRemoveRange(&bv, 0, 10);

In Remove.c:348:

        // Test remove partial range
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        BitVecRemoveRange(&bv, 1, 5);             // Remove 5 elements starting at index 1

In Remove.c:374:

    
        // Test remove when value doesn't exist
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        found  = BitVecRemoveFirst(&bv, false);

In Remove.c:375:

        // Test remove when value doesn't exist
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        found  = BitVecRemoveFirst(&bv, false);
        result = result && (found == false) && (BitVecLen(&bv) == 2);

In Remove.c:381:

        // Test remove single occurrence
        BitVecClear(&bv);
        BitVecPush(&bv, false);
        found  = BitVecRemoveFirst(&bv, false);
        result = result && (found == true) && (BitVecLen(&bv) == 0);

In Remove.c:387:

        // Test remove from large uniform data
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, true);
        }
        found  = BitVecRemoveFirst(&bv, true);

In Remove.c:410:

    
        // Test remove all when value doesn't exist
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        count  = BitVecRemoveAll(&bv, false);

In Remove.c:411:

        // Test remove all when value doesn't exist
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
        count  = BitVecRemoveAll(&bv, false);
        result = result && (count == 0) && (BitVecLen(&bv) == 2);

In Remove.c:418:

        BitVecClear(&bv);
        for (int i = 0; i < 100; i++) {
            BitVecPush(&bv, true);
        }
        count  = BitVecRemoveAll(&bv, true);

In Remove.c:425:

        // Test remove all mixed data
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        count  = BitVecRemoveAll(&bv, false); // Remove odds

In Remove.c:526:

        // Length 10, all true.
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, true);
        }

In Remove.c:558:

        // Length 10, all true.
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, true);
        }

In Remove.c:586:

        bool pattern[] = {true, false, true, false, false, true, false, true, true, false};
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, pattern[i]);
        }

In Remove.c:625:

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

In Remove.c:626:

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

In Remove.c:627:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // length is 3; idx 3 is out of range and must abort.

In Convert.c:46:

    
        // Create pattern: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Convert.c:47:

        // Create pattern: 1011
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Convert.c:48:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Convert.c:49:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        // Convert to string

In Convert.c:111:

    
        // Create pattern: 10110011 (0xB3)
        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2

In Convert.c:112:

        // Create pattern: 10110011 (0xB3)
        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3

In Convert.c:113:

        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4

In Convert.c:114:

        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5

In Convert.c:115:

        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, true);  // bit 6

In Convert.c:116:

        BitVecPush(&bv, true);  // bit 3
        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, true);  // bit 6
        BitVecPush(&bv, true);  // bit 7

In Convert.c:117:

        BitVecPush(&bv, false); // bit 4
        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, true);  // bit 6
        BitVecPush(&bv, true);  // bit 7

In Convert.c:118:

        BitVecPush(&bv, false); // bit 5
        BitVecPush(&bv, true);  // bit 6
        BitVecPush(&bv, true);  // bit 7
    
        u8  bytes[2];           // Buffer for byte output

In Convert.c:184:

    
        // Create pattern: 1011 (decimal 11 if MSB first, 13 if LSB first)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Convert.c:185:

        // Create pattern: 1011 (decimal 11 if MSB first, 13 if LSB first)
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Convert.c:186:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);

In Convert.c:187:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, true);
    
        // Convert to integer

In Convert.c:200:

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

In Convert.c:327:

    
        // Test converting single bit
        BitVecPush(&bv, true);
        str_obj = BitVecToStr(&bv);
        result  = result && (StrLen(&str_obj) == 1);

In Convert.c:336:

        BitVecClear(&bv);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        str_obj = BitVecToStr(&bv);

In Convert.c:522:

        BitVec oversized = BitVecInit(ALLOCATOR_OF(&alloc));
        for (int i = 0; i < 100; i++) { // 100 bits > 64 bit limit
            BitVecPush(&oversized, i % 2 == 0);
        }

In Convert.c:647:

        // Create a 1000-bit pattern
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&large_bv, (i % 3) == 0); // Every third bit set
        }

In Convert.c:728:

    
        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        BitVecPush(&bv, true);
    
        // Zero max_len is a contract violation - should abort.

In Convert.c:825:

        BitVec bv = BitVecInit(ALLOCATOR_OF(&alloc));
        // 4-bit pattern 1011 -> LSB-first packing: bits 0,2,3 set -> 0x0D.
        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2

In Convert.c:826:

        // 4-bit pattern 1011 -> LSB-first packing: bits 0,2,3 set -> 0x0D.
        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3

In Convert.c:827:

        BitVecPush(&bv, true);  // bit 0
        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3

In Convert.c:828:

        BitVecPush(&bv, false); // bit 1
        BitVecPush(&bv, true);  // bit 2
        BitVecPush(&bv, true);  // bit 3
    
        u8  bytes[1] = {0};

In Convert.c:859:

        // 16 bits; ensure byte 1 has at least one set bit (bit 8 -> byte1 bit0).
        for (u64 i = 0; i < 16; i++) {
            BitVecPush(&bv, i == 8); // only bit 8 set
        }

In Access.Simple.c:41:

    
        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:42:

        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Access.Simple.c:43:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Access.Simple.c:44:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Test getting bits

In Access.Simple.c:88:

    
        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:89:

        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Access.Simple.c:90:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Access.Simple.c:91:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Flip some bits

In Access.Simple.c:120:

    
        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:121:

        // Push some bits
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:122:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        result = result && (BitVecLen(&bv) == 3);

In Access.Simple.c:146:

    
        // Push a pattern: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:147:

        // Push a pattern: true, false, true, false, true
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Access.Simple.c:148:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:149:

        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:150:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        // Count true and false bits

In Access.Simple.c:170:

    
        // Test with single bit
        BitVecPush(&bv, true);
        result = result && (BitVecGet(&bv, 0) == true);

In Access.Simple.c:175:

        // Test with larger index
        for (int i = 1; i < 64; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Access.Simple.c:216:

    
        // Test flipping single bit
        BitVecPush(&bv, false);
        BitVecFlip(&bv, 0);
        bool result = (BitVecGet(&bv, 0) == true);

In Access.Simple.c:243:

    
        // Test single bit
        BitVecPush(&bv, true);
        result = result && (BitVecCountOnes(&bv) == 1);
        result = result && (BitVecCountZeros(&bv) == 0);

In Access.Simple.c:250:

        BitVecClear(&bv);
        for (int i = 0; i < 100; i++) {
            BitVecPush(&bv, true);
        }
        result = result && (BitVecCountOnes(&bv) == 100);

In Access.Simple.c:270:

    
        // Create pattern using different methods
        BitVecPush(&bv, true);
        BitVecResize(&bv, 5);
        BitVecSet(&bv, 1, false);

In Access.Simple.c:311:

        // Create large alternating pattern
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }

In Access.Simple.c:348:

    
        // Test BITVEC_GET, BITVEC_SET, BITVEC_FLIP if they exist
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);

In Access.Simple.c:349:

        // Test BITVEC_GET, BITVEC_SET, BITVEC_FLIP if they exist
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
    
        // Test length and capacity macros if they exist

In Access.Simple.c:435:

        // Test all zeros
        for (int i = 0; i < 64; i++) {
            BitVecPush(&bv, false);
        }
        result = result && (BitVecCountZeros(&bv) == 64);

In Access.Simple.c:443:

        BitVecClear(&bv);
        for (int i = 0; i < 64; i++) {
            BitVecPush(&bv, true);
        }
        result = result && (BitVecCountOnes(&bv) == 64);

In Access.Simple.c:451:

        BitVecClear(&bv);
        for (int i = 0; i < 64; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        result = result && (BitVecCountOnes(&bv) == 32);

In Access.Simple.c:459:

        BitVecClear(&bv);
        for (int i = 0; i < 64; i++) {
            BitVecPush(&bv, i % 8 == 0);
        }
        result = result && (BitVecCountOnes(&bv) == 8);

In Access.Simple.c:467:

        BitVecClear(&bv);
        for (int i = 0; i < 100; i++) {
            BitVecPush(&bv, (i * 17 + 3) % 7 < 3); // Pseudo-random pattern
        }

In Access.Simple.c:492:

        // Create pattern: F T F T F T F T
        for (int i = 0; i < 8; i++) {
            BitVecPush(&bv, i % 2 == 1);
        }

In Access.Simple.c:506:

        BitVecClear(&bv);
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, true);
        }
        result = result && (BitVecFind(&bv, true) == 0);

In Access.Simple.c:529:

        // Test with all true
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, true);
        }
        result = result && BitVecAll(&bv, true);

In Access.Simple.c:541:

        BitVecClear(&bv);
        for (int i = 0; i < 5; i++) {
            BitVecPush(&bv, false);
        }
        result = result && !BitVecAll(&bv, true);

In Access.Simple.c:552:

        // Test with mixed values
        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:553:

        BitVecClear(&bv);
        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);

In Access.Simple.c:554:

        BitVecPush(&bv, true);
        BitVecPush(&bv, false);
        BitVecPush(&bv, true);
    
        result = result && !BitVecAll(&bv, true);

In Access.Simple.c:580:

        bool pattern[] = {true, true, true, false, false, true, true, false, false, false, false};
        for (int i = 0; i < 11; i++) {
            BitVecPush(&bv, pattern[i]);
        }

In Access.Simple.c:590:

        BitVecClear(&bv);
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, true);
        }
        result = result && (BitVecLongestRun(&bv, true) == 10);

In Access.Simple.c:598:

        BitVecClear(&bv);
        for (int i = 0; i < 10; i++) {
            BitVecPush(&bv, i % 2 == 0);
        }
        result = result && (BitVecLongestRun(&bv, true) == 1);

In Access.Simple.c:624:

    
        // Test single element
        BitVecPush(&bv, true);
        result = result && (BitVecFind(&bv, true) == 0);
        result = result && (BitVecFindLast(&bv, true) == 0);

In Access.Simple.c:633:

        BitVecClear(&bv);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, i == 500 || i == 999); // Only indices 500 and 999 are true
        }
        result = result && (BitVecFind(&bv, true) == 500);

In Access.Simple.c:661:

    
        // Test single element bitvector
        BitVecPush(&bv, true);
        result = result && BitVecAll(&bv, true);
        result = result && !BitVecAll(&bv, false);

In Access.Simple.c:670:

        BitVecClear(&bv);
        for (int i = 0; i < 1000; i++) {
            BitVecPush(&bv, true); // All true
        }
        result = result && BitVecAll(&bv, true);

In Access.Simple.c:700:

    
        // Test single element
        BitVecPush(&bv, true);
        result = result && (BitVecLongestRun(&bv, true) == 1);
        result = result && (BitVecLongestRun(&bv, false) == 0);

In Access.Simple.c:707:

        BitVecClear(&bv);
        for (int i = 0; i < 10000; i++) {
            BitVecPush(&bv, true);
        }
        result = result && (BitVecLongestRun(&bv, true) == 10000);

In Type.c:83:

        Int original = IntInit(&alloc);
    
        BitVecPush(&original.bits, true);
        BitVecPush(&original.bits, false);
        BitVecPush(&original.bits, true);

In Type.c:84:

    
        BitVecPush(&original.bits, true);
        BitVecPush(&original.bits, false);
        BitVecPush(&original.bits, true);

In Type.c:85:

        BitVecPush(&original.bits, true);
        BitVecPush(&original.bits, false);
        BitVecPush(&original.bits, true);
    
        Int clone = IntClone(&original);

Last updated on July 1, 2026

BitVecPrefixMatch BitVecRegexMatch