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