BitVecPush

Function
August 22, 2025

Table of Contents

`BitVecPush`

Description

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

Parameters

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

Usage example (from documentation)

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

Usage example (Cross-references)

In BitVec.c:223:

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

In BitVec.c:250:

    }
    // For now, implement as push + manual bit shifting (simple but not efficient)
    BitVecPush(bitvec, false);
    
    // Shift bits right from idx to end

In BitVec.c:756:

    for (u64 i = 0; i < str_len; i++) {
    if (str[i] == '1') {
    BitVecPush(&result, true);
    } else if (str[i] == '0') {
    BitVecPush(&result, false);

In BitVec.c:758:

    BitVecPush(&result, true);
    } else if (str[i] == '0') {
    BitVecPush(&result, false);
    }
    // Ignore other characters

In BitVec.Foreach.c:41:

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

In BitVec.Foreach.c:42:

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

In BitVec.Foreach.c:43:

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

In BitVec.Foreach.c:44:

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

In BitVec.Foreach.c:74:

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

In BitVec.Foreach.c:75:

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

In BitVec.Foreach.c:76:

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

In BitVec.Foreach.c:105:

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

In BitVec.Foreach.c:106:

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

In BitVec.Foreach.c:107:

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

In BitVec.Foreach.c:108:

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

In BitVec.Foreach.c:136:

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

In BitVec.Foreach.c:137:

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

In BitVec.Foreach.c:138:

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

In BitVec.Foreach.c:166:

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

In BitVec.Foreach.c:167:

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

In BitVec.Foreach.c:168:

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

In BitVec.Foreach.c:169:

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

In BitVec.Foreach.c:170:

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

In BitVec.Foreach.c:202:

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

In BitVec.Foreach.c:203:

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

In BitVec.Foreach.c:204:

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

In BitVec.Foreach.c:205:

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

In BitVec.Foreach.c:206:

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

In BitVec.Foreach.c:246:

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

In BitVec.Foreach.c:257:

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

In BitVec.Foreach.c:285:

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

In BitVec.Foreach.c:296:

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

In BitVec.Foreach.c:323:

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

In BitVec.Foreach.c:333:

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

In BitVec.Foreach.c:334:

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

In BitVec.Foreach.c:335:

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

In BitVec.Foreach.c:356:

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

In BitVec.Foreach.c:405:

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

In BitVec.Foreach.c:448:

    
    // 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 BitVec.Foreach.c:449:

    // 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 BitVec.Foreach.c:450:

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

In BitVec.Foreach.c:451:

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

In BitVec.Foreach.c:452:

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

In BitVec.Foreach.c:453:

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

In BitVec.Foreach.c:454:

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

In BitVec.Foreach.c:455:

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

In BitVec.Foreach.c:492:

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

In BitVec.Foreach.c:500:

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

In BitVec.Foreach.c:509:

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

In BitVec.Foreach.c:519:

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

In BitVec.Foreach.c:543:

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

In BitVec.Foreach.c:585:

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

In BitVec.Foreach.c:611:

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

In BitVec.Foreach.c:652:

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

In BitVec.Foreach.c:666:

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

In BitVec.Foreach.c:680:

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

In BitVec.Init.c:48:

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

In BitVec.Init.c:49:

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

In BitVec.Init.c:50:

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

In BitVec.Init.c:85:

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

In BitVec.Init.c:109:

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

In BitVec.Init.c:110:

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

In BitVec.Init.c:111:

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

In BitVec.Init.c:112:

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

In BitVec.Init.c:127:

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

In BitVec.Init.c:144:

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

In BitVec.Init.c:145:

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

In BitVec.Init.c:146:

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

In BitVec.Init.c:233:

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

In BitVec.Init.c:234:

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

In BitVec.Init.c:273:

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

In BitVec.Init.c:284:

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

In BitVec.Init.c:304:

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

In BitVec.Memory.c:30:

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

In BitVec.Memory.c:31:

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

In BitVec.Memory.c:32:

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

In BitVec.Memory.c:67:

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

In BitVec.Memory.c:68:

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

In BitVec.Memory.c:105:

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

In BitVec.Memory.c:106:

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

In BitVec.Memory.c:107:

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

In BitVec.Memory.c:110:

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

In BitVec.Memory.c:111:

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

In BitVec.Memory.c:148:

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

In BitVec.Memory.c:149:

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

In BitVec.Memory.c:150:

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

In BitVec.Memory.c:151:

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

In BitVec.Memory.c:164:

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

In BitVec.Memory.c:199:

    
    // Test shrink on single element
    BitVecPush(&bv, true);
    BitVecShrinkToFit(&bv);
    result = result && (bv.length == 1) && (bv.capacity >= 1);

In BitVec.Memory.c:236:

    // Test set capacity smaller than current length
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }
    u64 original_length = bv.length;

In BitVec.Memory.c:268:

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

In BitVec.Memory.c:269:

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

In BitVec.Memory.c:280:

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

In BitVec.Memory.c:309:

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

In BitVec.Memory.c:318:

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

In BitVec.Memory.c:350:

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

In BitVec.Memory.c:351:

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

In BitVec.Access.Simple.c:39:

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

In BitVec.Access.Simple.c:40:

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

In BitVec.Access.Simple.c:41:

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

In BitVec.Access.Simple.c:42:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    
    // Test getting bits

In BitVec.Access.Simple.c:80:

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

In BitVec.Access.Simple.c:81:

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

In BitVec.Access.Simple.c:82:

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

In BitVec.Access.Simple.c:83:

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

In BitVec.Access.Simple.c:109:

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

In BitVec.Access.Simple.c:110:

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

In BitVec.Access.Simple.c:111:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    result = result && (BitVecLen(&bv) == 3);

In BitVec.Access.Simple.c:132:

    
    // Push a pattern: true, false, true, false, true
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.Simple.c:133:

    // Push a pattern: true, false, true, false, true
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.Simple.c:134:

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

In BitVec.Access.Simple.c:135:

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

In BitVec.Access.Simple.c:136:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Count true and false bits

In BitVec.Access.Simple.c:153:

    
    // Test with single bit
    BitVecPush(&bv, true);
    result = result && (BitVecGet(&bv, 0) == true);

In BitVec.Access.Simple.c:158:

    // Test with larger index
    for (int i = 1; i < 64; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }

In BitVec.Access.Simple.c:193:

    
    // Test flipping single bit
    BitVecPush(&bv, false);
    BitVecFlip(&bv, 0);
    bool result = (BitVecGet(&bv, 0) == true);

In BitVec.Access.Simple.c:217:

    
    // Test single bit
    BitVecPush(&bv, true);
    result = result && (BitVecCountOnes(&bv) == 1);
    result = result && (BitVecCountZeros(&bv) == 0);

In BitVec.Access.Simple.c:224:

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

In BitVec.Access.Simple.c:241:

    
    // Create pattern using different methods
    BitVecPush(&bv, true);
    BitVecResize(&bv, 5);
    BitVecSet(&bv, 1, false);

In BitVec.Access.Simple.c:279:

    // Create large alternating pattern
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }

In BitVec.Access.Simple.c:313:

    
    // Test BITVEC_GET, BITVEC_SET, BITVEC_FLIP if they exist
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.Simple.c:314:

    // Test BITVEC_GET, BITVEC_SET, BITVEC_FLIP if they exist
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    
    // Test length and capacity macros if they exist

In BitVec.Access.Simple.c:394:

    // Test all zeros
    for (int i = 0; i < 64; i++) {
    BitVecPush(&bv, false);
    }
    result = result && (BitVecCountZeros(&bv) == 64);

In BitVec.Access.Simple.c:402:

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

In BitVec.Access.Simple.c:410:

    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }
    result = result && (BitVecCountOnes(&bv) == 32);

In BitVec.Access.Simple.c:418:

    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) {
    BitVecPush(&bv, i % 8 == 0);
    }
    result = result && (BitVecCountOnes(&bv) == 8);

In BitVec.Access.Simple.c:426:

    BitVecClear(&bv);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, (i * 17 + 3) % 7 < 3); // Pseudo-random pattern
    }

In BitVec.Access.Simple.c:448:

    // Create pattern: F T F T F T F T
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv, i % 2 == 1);
    }

In BitVec.Access.Simple.c:462:

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

In BitVec.Access.Simple.c:482:

    // Test with all true
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, true);
    }
    result = result && BitVecAll(&bv, true);

In BitVec.Access.Simple.c:494:

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

In BitVec.Access.Simple.c:505:

    // Test with mixed values
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.Simple.c:506:

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

In BitVec.Access.Simple.c:507:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    result = result && !BitVecAll(&bv, true);

In BitVec.Access.Simple.c:530:

    bool pattern[] = {true, true, true, false, false, true, true, false, false, false, false};
    for (int i = 0; i < 11; i++) {
    BitVecPush(&bv, pattern[i]);
    }

In BitVec.Access.Simple.c:540:

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

In BitVec.Access.Simple.c:548:

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

In BitVec.Access.Simple.c:571:

    
    // Test single element
    BitVecPush(&bv, true);
    result = result && (BitVecFind(&bv, true) == 0);
    result = result && (BitVecFindLast(&bv, true) == 0);

In BitVec.Access.Simple.c:580:

    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i == 500 || i == 999); // Only indices 500 and 999 are true
    }
    result = result && (BitVecFind(&bv, true) == 500);

In BitVec.Access.Simple.c:605:

    
    // Test single element bitvector
    BitVecPush(&bv, true);
    result = result && BitVecAll(&bv, true);
    result = result && !BitVecAll(&bv, false);

In BitVec.Access.Simple.c:614:

    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true); // All true
    }
    result = result && BitVecAll(&bv, true);

In BitVec.Access.Simple.c:641:

    
    // Test single element
    BitVecPush(&bv, true);
    result = result && (BitVecLongestRun(&bv, true) == 1);
    result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.Simple.c:648:

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

In BitVec.Access.Deadend.c:123:

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

In BitVec.Access.Deadend.c:124:

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

In BitVec.Access.Deadend.c:125:

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

In BitVec.Access.Deadend.c:138:

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

In BitVec.Access.Deadend.c:139:

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

In BitVec.Access.Deadend.c:153:

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

In BitVec.Access.Deadend.c:176:

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

In BitVec.Insert.c:24:

    // Test BitVecPush function
    bool test_bitvec_push(void) {
    printf("Testing BitVecPush\n");
    
    BitVec bv = BitVecInit();

In BitVec.Insert.c:29:

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

In BitVec.Insert.c:30:

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

In BitVec.Insert.c:31:

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

In BitVec.Insert.c:32:

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

In BitVec.Insert.c:33:

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

In BitVec.Insert.c:93:

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

In BitVec.Insert.c:94:

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

In BitVec.Insert.c:121:

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

In BitVec.Insert.c:122:

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

In BitVec.Insert.c:125:

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

In BitVec.Insert.c:126:

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

In BitVec.Insert.c:127:

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

In BitVec.Insert.c:154:

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

In BitVec.Insert.c:155:

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

In BitVec.Insert.c:173:

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

In BitVec.Insert.c:204:

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

In BitVec.Insert.c:234:

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

In BitVec.Insert.c:241:

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

In BitVec.Pattern.Deadend.c:39:

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

In BitVec.Pattern.Deadend.c:52:

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

In BitVec.Pattern.Deadend.c:53:

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

In BitVec.Pattern.Deadend.c:66:

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

In BitVec.Pattern.Deadend.c:79:

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

In BitVec.Pattern.Deadend.c:80:

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

In BitVec.Pattern.Deadend.c:106:

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

In BitVec.Pattern.Deadend.c:107:

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

In BitVec.Pattern.Deadend.c:121:

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

In BitVec.Pattern.Deadend.c:122:

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

In BitVec.Pattern.Deadend.c:123:

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

In BitVec.Pattern.Deadend.c:139:

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

In BitVec.Pattern.Deadend.c:140:

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

In BitVec.Pattern.Deadend.c:141:

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

In BitVec.Pattern.Deadend.c:155:

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

In BitVec.Pattern.Deadend.c:164:

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

In BitVec.Pattern.Deadend.c:173:

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

In BitVec.Pattern.Deadend.c:182:

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

In BitVec.Pattern.Deadend.c:191:

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

In BitVec.Pattern.Deadend.c:200:

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

In BitVec.Pattern.Deadend.c:218:

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

In BitVec.Pattern.Deadend.c:219:

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

In BitVec.Pattern.Deadend.c:235:

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

In BitVec.Pattern.Deadend.c:244:

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

In BitVec.Pattern.Deadend.c:253:

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

In BitVec.Pattern.Deadend.c:262:

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

In BitVec.Pattern.Deadend.c:271:

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

In BitVec.Remove.c:33:

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

In BitVec.Remove.c:34:

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

In BitVec.Remove.c:35:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Pop the last bit

In BitVec.Remove.c:67:

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

In BitVec.Remove.c:68:

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

In BitVec.Remove.c:69:

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

In BitVec.Remove.c:70:

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

In BitVec.Remove.c:71:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Remove bit at index 2 (middle true)

In BitVec.Remove.c:103:

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

In BitVec.Remove.c:104:

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

In BitVec.Remove.c:105:

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

In BitVec.Remove.c:106:

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

In BitVec.Remove.c:107:

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

In BitVec.Remove.c:108:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Remove range from index 1 to 3 (3 bits)

In BitVec.Remove.c:132:

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

In BitVec.Remove.c:133:

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

In BitVec.Remove.c:134:

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

In BitVec.Remove.c:135:

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

In BitVec.Remove.c:136:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Remove first occurrence of false

In BitVec.Remove.c:169:

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

In BitVec.Remove.c:170:

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

In BitVec.Remove.c:171:

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

In BitVec.Remove.c:172:

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

In BitVec.Remove.c:173:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Remove last occurrence of false

In BitVec.Remove.c:207:

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

In BitVec.Remove.c:208:

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

In BitVec.Remove.c:209:

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

In BitVec.Remove.c:210:

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

In BitVec.Remove.c:211:

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

In BitVec.Remove.c:212:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    
    // Remove all false bits

In BitVec.Remove.c:245:

    
    // Test pop single element
    BitVecPush(&bv, true);
    bool popped = BitVecPop(&bv);
    result      = result && (popped == true) && (bv.length == 0);

In BitVec.Remove.c:251:

    // Test multiple pops in sequence
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }
    for (int i = 99; i >= 0; i--) {

In BitVec.Remove.c:270:

    
    // Test remove last element
    BitVecPush(&bv, true);
    bool removed = BitVecRemove(&bv, 0);
    result       = result && (removed == true) && (bv.length == 0);

In BitVec.Remove.c:276:

    // Test remove from large bitvec
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 3 == 0);
    }

In BitVec.Remove.c:295:

    
    // Test remove 0 elements (should be no-op)
    BitVecPush(&bv, true);
    BitVecRemoveRange(&bv, 0, 0);
    result = result && (bv.length == 1);

In BitVec.Remove.c:302:

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

In BitVec.Remove.c:309:

    // Test remove partial range
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }
    BitVecRemoveRange(&bv, 1, 5);        // Remove 5 elements starting at index 1

In BitVec.Remove.c:332:

    
    // Test remove when value doesn't exist
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    found  = BitVecRemoveFirst(&bv, false);

In BitVec.Remove.c:333:

    // Test remove when value doesn't exist
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    found  = BitVecRemoveFirst(&bv, false);
    result = result && (found == false) && (bv.length == 2);

In BitVec.Remove.c:339:

    // Test remove single occurrence
    BitVecClear(&bv);
    BitVecPush(&bv, false);
    found  = BitVecRemoveFirst(&bv, false);
    result = result && (found == true) && (bv.length == 0);

In BitVec.Remove.c:345:

    // Test remove from large uniform data
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true);
    }
    found  = BitVecRemoveFirst(&bv, true);

In BitVec.Remove.c:365:

    
    // Test remove all when value doesn't exist
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    count  = BitVecRemoveAll(&bv, false);

In BitVec.Remove.c:366:

    // Test remove all when value doesn't exist
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    count  = BitVecRemoveAll(&bv, false);
    result = result && (count == 0) && (bv.length == 2);

In BitVec.Remove.c:373:

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

In BitVec.Remove.c:380:

    // Test remove all mixed data
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }
    count  = BitVecRemoveAll(&bv, false); // Remove odds

In BitVec.BitWise.c:40:

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

In BitVec.BitWise.c:41:

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

In BitVec.BitWise.c:42:

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

In BitVec.BitWise.c:43:

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

In BitVec.BitWise.c:46:

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

In BitVec.BitWise.c:47:

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

In BitVec.BitWise.c:48:

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

In BitVec.BitWise.c:49:

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

In BitVec.BitWise.c:78:

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

In BitVec.BitWise.c:79:

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

In BitVec.BitWise.c:80:

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

In BitVec.BitWise.c:81:

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

In BitVec.BitWise.c:84:

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

In BitVec.BitWise.c:85:

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

In BitVec.BitWise.c:86:

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

In BitVec.BitWise.c:87:

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

In BitVec.BitWise.c:116:

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

In BitVec.BitWise.c:117:

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

In BitVec.BitWise.c:118:

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

In BitVec.BitWise.c:119:

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

In BitVec.BitWise.c:122:

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

In BitVec.BitWise.c:123:

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

In BitVec.BitWise.c:124:

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

In BitVec.BitWise.c:125:

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

In BitVec.BitWise.c:153:

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

In BitVec.BitWise.c:154:

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

In BitVec.BitWise.c:155:

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

In BitVec.BitWise.c:156:

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

In BitVec.BitWise.c:182:

    
    // 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 BitVec.BitWise.c:183:

    // 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 BitVec.BitWise.c:184:

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

In BitVec.BitWise.c:185:

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

In BitVec.BitWise.c:223:

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

In BitVec.BitWise.c:224:

    // 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 BitVec.BitWise.c:225:

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

In BitVec.BitWise.c:226:

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

In BitVec.BitWise.c:257:

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

In BitVec.BitWise.c:258:

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

In BitVec.BitWise.c:259:

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

In BitVec.BitWise.c:260:

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

In BitVec.BitWise.c:285:

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

In BitVec.BitWise.c:286:

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

In BitVec.BitWise.c:287:

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

In BitVec.BitWise.c:288:

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

In BitVec.BitWise.c:313:

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

In BitVec.BitWise.c:314:

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

In BitVec.BitWise.c:315:

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

In BitVec.BitWise.c:316:

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

In BitVec.BitWise.c:349:

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

In BitVec.BitWise.c:350:

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

In BitVec.BitWise.c:362:

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

In BitVec.BitWise.c:382:

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

In BitVec.BitWise.c:387:

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

In BitVec.BitWise.c:415:

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

In BitVec.BitWise.c:416:

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

In BitVec.BitWise.c:417:

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

In BitVec.BitWise.c:427:

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

In BitVec.BitWise.c:449:

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

In BitVec.BitWise.c:456:

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

In BitVec.BitWise.c:457:

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

In BitVec.BitWise.c:484:

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

In BitVec.BitWise.c:487:

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

In BitVec.BitWise.c:505:

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

In BitVec.BitWise.c:506:

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

In BitVec.BitWise.c:518:

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

In BitVec.BitWise.c:547:

    // 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 BitVec.BitWise.c:549:

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

In BitVec.BitWise.c:571:

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

In BitVec.BitWise.c:580:

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

In BitVec.BitWise.c:588:

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

In BitVec.BitWise.c:589:

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

In BitVec.BitWise.c:590:

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

In BitVec.BitWise.c:613:

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

In BitVec.BitWise.c:646:

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

In BitVec.BitWise.c:647:

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

In BitVec.BitWise.c:648:

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

In BitVec.BitWise.c:649:

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

In BitVec.BitWise.c:650:

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

In BitVec.BitWise.c:676:

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

In BitVec.BitWise.c:724:

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

In BitVec.BitWise.c:740:

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

In BitVec.BitWise.c:771:

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

In BitVec.BitWise.c:772:

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

In BitVec.BitWise.c:832:

    // 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 BitVec.BitWise.c:833:

    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 BitVec.BitWise.c:865:

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

In BitVec.BitWise.c:939:

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

In BitVec.BitWise.c:940:

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

In BitVec.BitWise.Simple.c:40:

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

In BitVec.BitWise.Simple.c:41:

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

In BitVec.BitWise.Simple.c:42:

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

In BitVec.BitWise.Simple.c:43:

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

In BitVec.BitWise.Simple.c:46:

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

In BitVec.BitWise.Simple.c:47:

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

In BitVec.BitWise.Simple.c:48:

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

In BitVec.BitWise.Simple.c:49:

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

In BitVec.BitWise.Simple.c:78:

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

In BitVec.BitWise.Simple.c:79:

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

In BitVec.BitWise.Simple.c:80:

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

In BitVec.BitWise.Simple.c:81:

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

In BitVec.BitWise.Simple.c:84:

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

In BitVec.BitWise.Simple.c:85:

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

In BitVec.BitWise.Simple.c:86:

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

In BitVec.BitWise.Simple.c:87:

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

In BitVec.BitWise.Simple.c:116:

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

In BitVec.BitWise.Simple.c:117:

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

In BitVec.BitWise.Simple.c:118:

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

In BitVec.BitWise.Simple.c:119:

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

In BitVec.BitWise.Simple.c:122:

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

In BitVec.BitWise.Simple.c:123:

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

In BitVec.BitWise.Simple.c:124:

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

In BitVec.BitWise.Simple.c:125:

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

In BitVec.BitWise.Simple.c:153:

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

In BitVec.BitWise.Simple.c:154:

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

In BitVec.BitWise.Simple.c:155:

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

In BitVec.BitWise.Simple.c:156:

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

In BitVec.BitWise.Simple.c:182:

    
    // 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 BitVec.BitWise.Simple.c:183:

    // 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 BitVec.BitWise.Simple.c:184:

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

In BitVec.BitWise.Simple.c:185:

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

In BitVec.BitWise.Simple.c:223:

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

In BitVec.BitWise.Simple.c:224:

    // 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 BitVec.BitWise.Simple.c:225:

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

In BitVec.BitWise.Simple.c:226:

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

In BitVec.BitWise.Simple.c:257:

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

In BitVec.BitWise.Simple.c:258:

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

In BitVec.BitWise.Simple.c:259:

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

In BitVec.BitWise.Simple.c:260:

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

In BitVec.BitWise.Simple.c:285:

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

In BitVec.BitWise.Simple.c:286:

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

In BitVec.BitWise.Simple.c:287:

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

In BitVec.BitWise.Simple.c:288:

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

In BitVec.BitWise.Simple.c:313:

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

In BitVec.BitWise.Simple.c:314:

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

In BitVec.BitWise.Simple.c:315:

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

In BitVec.BitWise.Simple.c:316:

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

In BitVec.BitWise.Simple.c:349:

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

In BitVec.BitWise.Simple.c:350:

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

In BitVec.BitWise.Simple.c:362:

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

In BitVec.BitWise.Simple.c:382:

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

In BitVec.BitWise.Simple.c:387:

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

In BitVec.BitWise.Simple.c:415:

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

In BitVec.BitWise.Simple.c:416:

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

In BitVec.BitWise.Simple.c:417:

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

In BitVec.BitWise.Simple.c:427:

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

In BitVec.BitWise.Simple.c:449:

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

In BitVec.BitWise.Simple.c:456:

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

In BitVec.BitWise.Simple.c:457:

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

In BitVec.BitWise.Simple.c:484:

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

In BitVec.BitWise.Simple.c:487:

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

In BitVec.BitWise.Simple.c:505:

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

In BitVec.BitWise.Simple.c:506:

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

In BitVec.BitWise.Simple.c:518:

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

In BitVec.BitWise.Simple.c:547:

    // 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 BitVec.BitWise.Simple.c:549:

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

In BitVec.BitWise.Simple.c:571:

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

In BitVec.BitWise.Simple.c:580:

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

In BitVec.BitWise.Simple.c:588:

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

In BitVec.BitWise.Simple.c:589:

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

In BitVec.BitWise.Simple.c:590:

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

In BitVec.BitWise.Simple.c:613:

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

In BitVec.BitWise.Simple.c:646:

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

In BitVec.BitWise.Simple.c:647:

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

In BitVec.BitWise.Simple.c:648:

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

In BitVec.BitWise.Simple.c:649:

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

In BitVec.BitWise.Simple.c:650:

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

In BitVec.BitWise.Simple.c:676:

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

In BitVec.BitWise.Simple.c:724:

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

In BitVec.BitWise.Simple.c:740:

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

In BitVec.BitWise.Simple.c:771:

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

In BitVec.BitWise.Simple.c:772:

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

In BitVec.BitWise.Simple.c:832:

    // 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 BitVec.BitWise.Simple.c:833:

    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 BitVec.BitWise.Simple.c:865:

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

In BitVec.Convert.c:40:

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

In BitVec.Convert.c:41:

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

In BitVec.Convert.c:42:

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

In BitVec.Convert.c:43:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    // Convert to string

In BitVec.Convert.c:95:

    
    // Create pattern: 10110011 (0xB3)
    BitVecPush(&bv, true);  // bit 0
    BitVecPush(&bv, false); // bit 1
    BitVecPush(&bv, true);  // bit 2

In BitVec.Convert.c:96:

    // Create pattern: 10110011 (0xB3)
    BitVecPush(&bv, true);  // bit 0
    BitVecPush(&bv, false); // bit 1
    BitVecPush(&bv, true);  // bit 2
    BitVecPush(&bv, true);  // bit 3

In BitVec.Convert.c:97:

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

In BitVec.Convert.c:98:

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

In BitVec.Convert.c:99:

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

In BitVec.Convert.c:100:

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

In BitVec.Convert.c:101:

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

In BitVec.Convert.c:102:

    BitVecPush(&bv, false); // bit 5
    BitVecPush(&bv, true);  // bit 6
    BitVecPush(&bv, true);  // bit 7
    
    u8  bytes[2];           // Buffer for byte output

In BitVec.Convert.c:160:

    
    // Create pattern: 1011 (decimal 11 if MSB first, 13 if LSB first)
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Convert.c:161:

    // Create pattern: 1011 (decimal 11 if MSB first, 13 if LSB first)
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Convert.c:162:

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

In BitVec.Convert.c:163:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    // Convert to integer

In BitVec.Convert.c:176:

    BitVec bv2 = BitVecInit();
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv2, (i % 2 == 0)); // Alternating pattern
    }

In BitVec.Convert.c:249:

    
    // Test converting single bit
    BitVecPush(&bv, true);
    str_obj = BitVecToStr(&bv);
    result  = result && (str_obj.length == 1);

In BitVec.Convert.c:258:

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

In BitVec.Convert.c:427:

    BitVec oversized = BitVecInit();
    for (int i = 0; i < 100; i++) { // 100 bits > 64 bit limit
    BitVecPush(&oversized, i % 2 == 0);
    }

In BitVec.Convert.c:533:

    // Create a 1000-bit pattern
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&large_bv, (i % 3) == 0); // Every third bit set
    }

In BitVec.Convert.c:610:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    
    // Test with insufficient buffer size

In BitVec.Foreach.Simple.c:41:

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

In BitVec.Foreach.Simple.c:42:

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

In BitVec.Foreach.Simple.c:43:

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

In BitVec.Foreach.Simple.c:44:

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

In BitVec.Foreach.Simple.c:74:

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

In BitVec.Foreach.Simple.c:75:

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

In BitVec.Foreach.Simple.c:76:

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

In BitVec.Foreach.Simple.c:105:

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

In BitVec.Foreach.Simple.c:106:

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

In BitVec.Foreach.Simple.c:107:

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

In BitVec.Foreach.Simple.c:108:

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

In BitVec.Foreach.Simple.c:136:

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

In BitVec.Foreach.Simple.c:137:

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

In BitVec.Foreach.Simple.c:138:

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

In BitVec.Foreach.Simple.c:166:

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

In BitVec.Foreach.Simple.c:167:

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

In BitVec.Foreach.Simple.c:168:

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

In BitVec.Foreach.Simple.c:169:

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

In BitVec.Foreach.Simple.c:170:

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

In BitVec.Foreach.Simple.c:202:

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

In BitVec.Foreach.Simple.c:203:

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

In BitVec.Foreach.Simple.c:204:

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

In BitVec.Foreach.Simple.c:205:

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

In BitVec.Foreach.Simple.c:206:

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

In BitVec.Foreach.Simple.c:246:

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

In BitVec.Foreach.Simple.c:257:

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

In BitVec.Foreach.Simple.c:285:

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

In BitVec.Foreach.Simple.c:296:

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

In BitVec.Foreach.Simple.c:323:

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

In BitVec.Foreach.Simple.c:333:

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

In BitVec.Foreach.Simple.c:334:

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

In BitVec.Foreach.Simple.c:335:

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

In BitVec.Foreach.Simple.c:356:

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

In BitVec.Foreach.Simple.c:405:

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

In BitVec.Foreach.Simple.c:448:

    
    // 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 BitVec.Foreach.Simple.c:449:

    // 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 BitVec.Foreach.Simple.c:450:

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

In BitVec.Foreach.Simple.c:451:

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

In BitVec.Foreach.Simple.c:452:

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

In BitVec.Foreach.Simple.c:453:

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

In BitVec.Foreach.Simple.c:454:

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

In BitVec.Foreach.Simple.c:455:

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

In BitVec.Foreach.Simple.c:492:

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

In BitVec.Foreach.Simple.c:500:

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

In BitVec.Foreach.Simple.c:509:

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

In BitVec.Foreach.Simple.c:519:

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

In BitVec.Foreach.Simple.c:543:

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

In BitVec.Foreach.Simple.c:585:

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

In BitVec.Foreach.Simple.c:611:

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

In BitVec.Pattern.Simple.c:65:

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

In BitVec.Pattern.Simple.c:66:

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

In BitVec.Pattern.Simple.c:67:

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

In BitVec.Pattern.Simple.c:68:

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

In BitVec.Pattern.Simple.c:69:

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

In BitVec.Pattern.Simple.c:70:

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

In BitVec.Pattern.Simple.c:71:

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

In BitVec.Pattern.Simple.c:72:

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

In BitVec.Pattern.Simple.c:73:

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

In BitVec.Pattern.Simple.c:74:

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

In BitVec.Pattern.Simple.c:75:

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

In BitVec.Pattern.Simple.c:78:

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

In BitVec.Pattern.Simple.c:79:

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

In BitVec.Pattern.Simple.c:80:

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

In BitVec.Pattern.Simple.c:102:

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

In BitVec.Pattern.Simple.c:106:

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

In BitVec.Pattern.Simple.c:107:

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

In BitVec.Pattern.Simple.c:108:

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

In BitVec.Pattern.Simple.c:115:

    // 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 BitVec.Pattern.Simple.c:121:

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

In BitVec.Pattern.Simple.c:122:

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

In BitVec.Pattern.Simple.c:123:

    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 BitVec.Pattern.Simple.c:129:

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

In BitVec.Pattern.Simple.c:130:

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

In BitVec.Pattern.Simple.c:148:

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

In BitVec.Pattern.Simple.c:152:

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

In BitVec.Pattern.Simple.c:153:

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

In BitVec.Pattern.Simple.c:163:

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

In BitVec.Pattern.Simple.c:164:

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

In BitVec.Pattern.Simple.c:165:

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

In BitVec.Pattern.Simple.c:166:

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

In BitVec.Pattern.Simple.c:167:

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

In BitVec.Pattern.Simple.c:168:

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

In BitVec.Pattern.Simple.c:171:

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

In BitVec.Pattern.Simple.c:172:

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

In BitVec.Pattern.Simple.c:173:

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

In BitVec.Pattern.Simple.c:193:

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

In BitVec.Pattern.Simple.c:197:

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

In BitVec.Pattern.Simple.c:198:

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

In BitVec.Pattern.Simple.c:199:

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

In BitVec.Pattern.Simple.c:225:

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

In BitVec.Pattern.Simple.c:229:

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

In BitVec.Pattern.Simple.c:230:

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

In BitVec.Pattern.Simple.c:231:

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

In BitVec.Pattern.Simple.c:250:

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

In BitVec.Pattern.Simple.c:251:

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

In BitVec.Pattern.Simple.c:258:

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

In BitVec.Pattern.Simple.c:266:

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

In BitVec.Pattern.Simple.c:273:

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

In BitVec.Pattern.Simple.c:274:

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

In BitVec.Pattern.Simple.c:275:

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

In BitVec.Pattern.Simple.c:276:

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

In BitVec.Pattern.Simple.c:277:

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

In BitVec.Pattern.Simple.c:278:

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

In BitVec.Pattern.Simple.c:285:

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

In BitVec.Pattern.Simple.c:286:

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

In BitVec.Pattern.Simple.c:290:

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

In BitVec.Pattern.Simple.c:298:

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

In BitVec.Pattern.Simple.c:299:

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

In BitVec.Pattern.Simple.c:322:

    // 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 BitVec.Pattern.Simple.c:323:

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

In BitVec.Pattern.Simple.c:324:

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

In BitVec.Pattern.Simple.c:325:

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

In BitVec.Pattern.Simple.c:328:

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

In BitVec.Pattern.Simple.c:333:

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

In BitVec.Pattern.Simple.c:334:

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

In BitVec.Pattern.Simple.c:335:

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

In BitVec.Pattern.Simple.c:336:

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

In BitVec.Pattern.Simple.c:362:

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

In BitVec.Pattern.Simple.c:363:

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

In BitVec.Pattern.Simple.c:364:

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

In BitVec.Pattern.Simple.c:365:

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

In BitVec.Pattern.Simple.c:366:

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

In BitVec.Pattern.Simple.c:367:

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

In BitVec.Pattern.Simple.c:370:

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

In BitVec.Pattern.Simple.c:371:

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

In BitVec.Pattern.Simple.c:372:

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

In BitVec.Pattern.Simple.c:378:

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

In BitVec.Pattern.Simple.c:379:

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

In BitVec.Pattern.Simple.c:380:

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

In BitVec.Pattern.Simple.c:397:

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

In BitVec.Pattern.Simple.c:402:

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

In BitVec.Pattern.Simple.c:403:

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

In BitVec.Pattern.Simple.c:409:

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

In BitVec.Pattern.Simple.c:410:

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

In BitVec.Pattern.Simple.c:411:

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

In BitVec.Pattern.Simple.c:412:

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

In BitVec.Pattern.Simple.c:429:

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

In BitVec.Pattern.Simple.c:430:

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

In BitVec.Pattern.Simple.c:431:

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

In BitVec.Pattern.Simple.c:432:

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

In BitVec.Pattern.Simple.c:433:

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

In BitVec.Pattern.Simple.c:434:

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

In BitVec.Pattern.Simple.c:437:

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

In BitVec.Pattern.Simple.c:438:

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

In BitVec.Pattern.Simple.c:439:

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

In BitVec.Pattern.Simple.c:445:

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

In BitVec.Pattern.Simple.c:446:

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

In BitVec.Pattern.Simple.c:447:

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

In BitVec.Pattern.Simple.c:464:

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

In BitVec.Pattern.Simple.c:469:

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

In BitVec.Pattern.Simple.c:470:

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

In BitVec.Pattern.Simple.c:487:

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

In BitVec.Pattern.Simple.c:488:

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

In BitVec.Pattern.Simple.c:489:

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

In BitVec.Pattern.Simple.c:490:

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

In BitVec.Pattern.Simple.c:491:

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

In BitVec.Pattern.Simple.c:492:

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

In BitVec.Pattern.Simple.c:493:

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

In BitVec.Pattern.Simple.c:496:

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

In BitVec.Pattern.Simple.c:497:

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

In BitVec.Pattern.Simple.c:498:

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

In BitVec.Pattern.Simple.c:504:

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

In BitVec.Pattern.Simple.c:505:

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

In BitVec.Pattern.Simple.c:506:

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

In BitVec.Pattern.Simple.c:524:

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

In BitVec.Pattern.Simple.c:525:

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

In BitVec.Pattern.Simple.c:526:

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

In BitVec.Pattern.Simple.c:527:

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

In BitVec.Pattern.Simple.c:528:

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

In BitVec.Pattern.Simple.c:529:

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

In BitVec.Pattern.Simple.c:530:

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

In BitVec.Pattern.Simple.c:533:

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

In BitVec.Pattern.Simple.c:534:

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

In BitVec.Pattern.Simple.c:535:

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

In BitVec.Pattern.Simple.c:554:

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

In BitVec.Pattern.Simple.c:555:

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

In BitVec.Pattern.Simple.c:558:

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

In BitVec.Pattern.Simple.c:559:

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

In BitVec.Pattern.Simple.c:560:

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

In BitVec.Pattern.Simple.c:579:

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

In BitVec.Pattern.Simple.c:583:

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

In BitVec.Pattern.Simple.c:584:

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

In BitVec.Pattern.Simple.c:585:

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

In BitVec.Pattern.Simple.c:592:

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

In BitVec.Pattern.Simple.c:593:

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

In BitVec.Pattern.Simple.c:594:

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

In BitVec.Pattern.Simple.c:613:

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

In BitVec.Pattern.Simple.c:614:

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

In BitVec.Pattern.Simple.c:615:

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

In BitVec.Pattern.Simple.c:616:

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

In BitVec.Pattern.Simple.c:617:

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

In BitVec.Pattern.Simple.c:618:

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

In BitVec.Pattern.Simple.c:619:

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

In BitVec.Pattern.Simple.c:620:

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

In BitVec.Pattern.Simple.c:621:

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

In BitVec.Pattern.Simple.c:624:

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

In BitVec.Pattern.Simple.c:625:

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

In BitVec.Pattern.Simple.c:626:

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

In BitVec.Pattern.Simple.c:651:

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

In BitVec.Pattern.Simple.c:652:

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

In BitVec.Pattern.Simple.c:653:

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

In BitVec.Pattern.Simple.c:654:

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

In BitVec.Pattern.Simple.c:655:

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

In BitVec.Pattern.Simple.c:656:

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

In BitVec.Pattern.Simple.c:659:

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

In BitVec.Pattern.Simple.c:660:

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

In BitVec.Pattern.Simple.c:661:

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

In BitVec.Pattern.Simple.c:664:

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

In BitVec.Pattern.Simple.c:665:

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

In BitVec.Pattern.Simple.c:666:

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

In BitVec.Pattern.Simple.c:694:

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

In BitVec.Pattern.Simple.c:695:

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

In BitVec.Pattern.Simple.c:696:

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

In BitVec.Pattern.Simple.c:700:

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

In BitVec.Pattern.Simple.c:701:

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

In BitVec.Pattern.Simple.c:702:

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

In BitVec.Pattern.Simple.c:705:

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

In BitVec.Pattern.Simple.c:706:

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

In BitVec.Pattern.Simple.c:730:

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

In BitVec.Pattern.Simple.c:731:

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

In BitVec.Pattern.Simple.c:732:

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

In BitVec.Pattern.Simple.c:733:

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

In BitVec.Pattern.Simple.c:736:

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

In BitVec.Pattern.Simple.c:737:

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

In BitVec.Pattern.Simple.c:738:

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

In BitVec.Pattern.Simple.c:739:

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

In BitVec.Pattern.Simple.c:742:

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

In BitVec.Pattern.Simple.c:743:

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

In BitVec.Pattern.Simple.c:744:

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

In BitVec.Pattern.Simple.c:745:

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

In BitVec.Pattern.Simple.c:764:

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

In BitVec.Pattern.Simple.c:765:

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

In BitVec.Pattern.Simple.c:766:

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

In BitVec.Pattern.Simple.c:767:

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

In BitVec.Pattern.Simple.c:768:

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

In BitVec.Pattern.Simple.c:769:

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

In BitVec.Pattern.Simple.c:770:

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

In BitVec.Pattern.Simple.c:771:

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

In BitVec.Pattern.Simple.c:772:

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

In BitVec.Pattern.Simple.c:775:

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

In BitVec.Pattern.Simple.c:776:

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

In BitVec.Pattern.Simple.c:777:

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

In BitVec.Pattern.Simple.c:799:

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

In BitVec.Pattern.Simple.c:800:

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

In BitVec.Pattern.Simple.c:801:

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

In BitVec.Pattern.Simple.c:802:

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

In BitVec.Pattern.Simple.c:803:

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

In BitVec.Pattern.Simple.c:804:

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

In BitVec.Pattern.Simple.c:825:

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

In BitVec.Pattern.Simple.c:826:

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

In BitVec.Pattern.Simple.c:827:

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

In BitVec.Pattern.Simple.c:828:

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

In BitVec.Pattern.Simple.c:829:

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

In BitVec.Pattern.Simple.c:830:

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

In BitVec.Pattern.Simple.c:837:

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

In BitVec.Pattern.Simple.c:838:

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

In BitVec.Pattern.Simple.c:839:

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

In BitVec.Pattern.Simple.c:842:

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

In BitVec.Pattern.Simple.c:843:

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

In BitVec.Pattern.Simple.c:844:

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

In BitVec.Pattern.Simple.c:847:

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

In BitVec.Pattern.Simple.c:848:

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

In BitVec.Pattern.Simple.c:849:

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

In BitVec.Pattern.Simple.c:870:

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

In BitVec.Pattern.Simple.c:871:

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

In BitVec.Pattern.Simple.c:872:

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

In BitVec.Pattern.Simple.c:873:

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

In BitVec.Pattern.Simple.c:874:

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

In BitVec.Pattern.Simple.c:875:

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

In BitVec.Pattern.Simple.c:882:

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

In BitVec.Pattern.Simple.c:883:

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

In BitVec.Pattern.Simple.c:884:

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

In BitVec.Pattern.Simple.c:887:

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

In BitVec.Pattern.Simple.c:888:

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

In BitVec.Pattern.Simple.c:889:

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

In BitVec.Pattern.Simple.c:892:

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

In BitVec.Pattern.Simple.c:893:

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

In BitVec.Pattern.Simple.c:894:

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

In BitVec.Math.c:60:

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

In BitVec.Math.c:61:

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

In BitVec.Math.c:62:

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

In BitVec.Math.c:63:

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

In BitVec.Math.c:64:

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

In BitVec.Math.c:65:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    u64 distance = BitVecHammingDistance(&bv1, &bv2);

In BitVec.Math.c:72:

    // Test completely different bitvectors
    BitVecClear(&bv2);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:73:

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

In BitVec.Math.c:74:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    distance = BitVecHammingDistance(&bv1, &bv2);

In BitVec.Math.c:81:

    // Test partially different bitvectors
    BitVecClear(&bv2);
    BitVecPush(&bv2, true); // Same
    BitVecPush(&bv2, true); // Different
    BitVecPush(&bv2, true); // Same

In BitVec.Math.c:82:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true); // Same
    BitVecPush(&bv2, true); // Different
    BitVecPush(&bv2, true); // Same

In BitVec.Math.c:83:

    BitVecPush(&bv2, true); // Same
    BitVecPush(&bv2, true); // Different
    BitVecPush(&bv2, true); // Same
    
    distance = BitVecHammingDistance(&bv1, &bv2);

In BitVec.Math.c:106:

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

In BitVec.Math.c:107:

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

In BitVec.Math.c:108:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv2, true);
    
    distance = BitVecHammingDistance(&bv1, &bv2);

In BitVec.Math.c:132:

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

In BitVec.Math.c:133:

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

In BitVec.Math.c:134:

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

In BitVec.Math.c:135:

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

In BitVec.Math.c:136:

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

In BitVec.Math.c:137:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    double similarity = BitVecJaccardSimilarity(&bv1, &bv2);

In BitVec.Math.c:145:

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

In BitVec.Math.c:146:

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

In BitVec.Math.c:147:

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

In BitVec.Math.c:148:

    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    similarity = BitVecJaccardSimilarity(&bv1, &bv2);

In BitVec.Math.c:156:

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

In BitVec.Math.c:157:

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

In BitVec.Math.c:158:

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

In BitVec.Math.c:159:

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

In BitVec.Math.c:160:

    BitVecPush(&bv1, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);
    // Intersection: 1, Union: 2, Jaccard = 1/2 = 0.5

In BitVec.Math.c:161:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);
    // Intersection: 1, Union: 2, Jaccard = 1/2 = 0.5

In BitVec.Math.c:185:

    
    // Test all zeros
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);

In BitVec.Math.c:186:

    // Test all zeros
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);

In BitVec.Math.c:187:

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

In BitVec.Math.c:188:

    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);
    
    similarity = BitVecJaccardSimilarity(&bv1, &bv2);

In BitVec.Math.c:207:

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

In BitVec.Math.c:208:

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

In BitVec.Math.c:209:

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

In BitVec.Math.c:210:

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

In BitVec.Math.c:211:

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

In BitVec.Math.c:212:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    double similarity = BitVecCosineSimilarity(&bv1, &bv2);

In BitVec.Math.c:220:

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

In BitVec.Math.c:221:

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

In BitVec.Math.c:222:

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

In BitVec.Math.c:223:

    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    similarity = BitVecCosineSimilarity(&bv1, &bv2);

In BitVec.Math.c:242:

    
    // Test zero vectors
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);

In BitVec.Math.c:243:

    // Test zero vectors
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);

In BitVec.Math.c:244:

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

In BitVec.Math.c:245:

    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);
    
    double similarity = BitVecCosineSimilarity(&bv1, &bv2);

In BitVec.Math.c:252:

    // Test one zero vector
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:253:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    similarity = BitVecCosineSimilarity(&bv1, &bv2);

In BitVec.Math.c:272:

    
    // Test basic dot product
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Math.c:273:

    // Test basic dot product
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Math.c:274:

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

In BitVec.Math.c:275:

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

In BitVec.Math.c:276:

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

In BitVec.Math.c:277:

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

In BitVec.Math.c:278:

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

In BitVec.Math.c:279:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    u64 product = BitVecDotProduct(&bv1, &bv2);

In BitVec.Math.c:287:

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

In BitVec.Math.c:288:

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

In BitVec.Math.c:289:

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

In BitVec.Math.c:290:

    BitVecPush(&bv1, false);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    product = BitVecDotProduct(&bv1, &bv2);

In BitVec.Math.c:313:

    
    // Test different lengths
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Math.c:314:

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

In BitVec.Math.c:315:

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

In BitVec.Math.c:316:

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

In BitVec.Math.c:317:

    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    product = BitVecDotProduct(&bv1, &bv2);

In BitVec.Math.c:336:

    
    // Test identical strings
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Math.c:337:

    // Test identical strings
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);

In BitVec.Math.c:338:

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

In BitVec.Math.c:339:

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

In BitVec.Math.c:340:

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

In BitVec.Math.c:341:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    u64 distance = BitVecEditDistance(&bv1, &bv2);

In BitVec.Math.c:348:

    // Test single substitution
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Changed from false
    BitVecPush(&bv2, true);

In BitVec.Math.c:349:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Changed from false
    BitVecPush(&bv2, true);

In BitVec.Math.c:350:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Changed from false
    BitVecPush(&bv2, true);
    
    distance = BitVecEditDistance(&bv1, &bv2);

In BitVec.Math.c:357:

    // Test insertion
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Math.c:358:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false); // Extra bit

In BitVec.Math.c:359:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false); // Extra bit

In BitVec.Math.c:360:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false); // Extra bit
    
    distance = BitVecEditDistance(&bv1, &bv2);

In BitVec.Math.c:383:

    
    // Test empty to non-empty
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:384:

    // Test empty to non-empty
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    distance = BitVecEditDistance(&bv1, &bv2);

In BitVec.Math.c:407:

    
    // Test perfect correlation
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Math.c:408:

    // Test perfect correlation
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Math.c:409:

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

In BitVec.Math.c:410:

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

In BitVec.Math.c:411:

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

In BitVec.Math.c:412:

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

In BitVec.Math.c:413:

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

In BitVec.Math.c:414:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    double correlation = BitVecCorrelation(&bv1, &bv2);

In BitVec.Math.c:421:

    // Test perfect anti-correlation
    BitVecClear(&bv2);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:422:

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

In BitVec.Math.c:423:

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

In BitVec.Math.c:424:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    correlation = BitVecCorrelation(&bv1, &bv2);

In BitVec.Math.c:447:

    
    // Test uniform vectors
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Math.c:448:

    // Test uniform vectors
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);

In BitVec.Math.c:449:

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

In BitVec.Math.c:450:

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

In BitVec.Math.c:451:

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

In BitVec.Math.c:452:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    
    correlation = BitVecCorrelation(&bv1, &bv2);

In BitVec.Math.c:470:

    
    // Test maximum entropy (equal 0s and 1s)
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Math.c:471:

    // Test maximum entropy (equal 0s and 1s)
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Math.c:472:

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

In BitVec.Math.c:473:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    
    double entropy = BitVecEntropy(&bv);

In BitVec.Math.c:480:

    // Test minimum entropy (all same)
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Math.c:481:

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

In BitVec.Math.c:482:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    entropy = BitVecEntropy(&bv);

In BitVec.Math.c:503:

    
    // Test single bit
    BitVecPush(&bv, true);
    entropy = BitVecEntropy(&bv);
    result  = result && (entropy == 0.0);

In BitVec.Math.c:520:

    
    // Test perfect match
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Math.c:521:

    // Test perfect match
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);

In BitVec.Math.c:522:

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

In BitVec.Math.c:523:

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

In BitVec.Math.c:524:

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

In BitVec.Math.c:525:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    int score = BitVecAlignmentScore(&bv1, &bv2, 2, -1);

In BitVec.Math.c:532:

    // Test perfect mismatch
    BitVecClear(&bv2);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:533:

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

In BitVec.Math.c:534:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    score  = BitVecAlignmentScore(&bv1, &bv2, 2, -1);

In BitVec.Math.c:557:

    
    // Test different lengths (only overlapping region scored)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Math.c:558:

    // Test different lengths (only overlapping region scored)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);

In BitVec.Math.c:559:

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

In BitVec.Math.c:560:

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

In BitVec.Math.c:561:

    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    score  = BitVecAlignmentScore(&bv1, &bv2, 1, -1);

In BitVec.Math.c:580:

    
    // Create bv1: 1100110
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Math.c:581:

    // Create bv1: 1100110
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, false);

In BitVec.Math.c:582:

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

In BitVec.Math.c:583:

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

In BitVec.Math.c:584:

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

In BitVec.Math.c:585:

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

In BitVec.Math.c:586:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    // Create bv2: 110 (should match at position 0 and 4)

In BitVec.Math.c:589:

    
    // Create bv2: 110 (should match at position 0 and 4)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:590:

    // Create bv2: 110 (should match at position 0 and 4)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:591:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    u64 best_pos = BitVecBestAlignment(&bv1, &bv2);

In BitVec.Math.c:614:

    
    // Test bv2 longer than bv1
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:615:

    // Test bv2 longer than bv1
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Math.c:616:

    BitVecPush(&bv1, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    best_pos = BitVecBestAlignment(&bv1, &bv2);

In BitVec.Math.c:636:

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

In BitVec.Math.c:637:

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

In BitVec.Math.c:654:

    BitVec small2 = BitVecInit();
    for (int i = 0; i < 50; i++) {
    BitVecPush(&small1, i % 2 == 0);
    BitVecPush(&small2, i % 3 == 0);
    }

In BitVec.Math.c:655:

    for (int i = 0; i < 50; i++) {
    BitVecPush(&small1, i % 2 == 0);
    BitVecPush(&small2, i % 3 == 0);
    }
    u64 edit_dist = BitVecEditDistance(&small1, &small2);

In BitVec.Math.c:682:

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

In BitVec.Math.c:691:

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

In BitVec.Math.c:700:

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

In BitVec.Math.c:709:

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

In BitVec.Math.c:718:

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

In BitVec.Math.c:727:

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

In BitVec.Math.c:736:

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

In BitVec.Math.c:745:

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

In BitVec.Math.c:754:

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

In BitVec.Math.c:763:

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

In BitVec.Math.c:772:

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

In BitVec.Math.c:781:

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

In BitVec.Math.c:796:

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

In BitVec.Math.c:805:

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

In BitVec.Math.c:814:

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

In BitVec.Math.c:823:

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

In BitVec.Pattern.c:65:

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

In BitVec.Pattern.c:66:

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

In BitVec.Pattern.c:67:

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

In BitVec.Pattern.c:68:

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

In BitVec.Pattern.c:69:

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

In BitVec.Pattern.c:70:

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

In BitVec.Pattern.c:71:

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

In BitVec.Pattern.c:72:

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

In BitVec.Pattern.c:73:

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

In BitVec.Pattern.c:74:

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

In BitVec.Pattern.c:75:

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

In BitVec.Pattern.c:78:

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

In BitVec.Pattern.c:79:

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

In BitVec.Pattern.c:80:

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

In BitVec.Pattern.c:102:

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

In BitVec.Pattern.c:106:

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

In BitVec.Pattern.c:107:

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

In BitVec.Pattern.c:108:

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

In BitVec.Pattern.c:115:

    // 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 BitVec.Pattern.c:121:

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

In BitVec.Pattern.c:122:

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

In BitVec.Pattern.c:123:

    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 BitVec.Pattern.c:129:

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

In BitVec.Pattern.c:130:

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

In BitVec.Pattern.c:148:

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

In BitVec.Pattern.c:152:

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

In BitVec.Pattern.c:153:

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

In BitVec.Pattern.c:163:

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

In BitVec.Pattern.c:164:

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

In BitVec.Pattern.c:165:

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

In BitVec.Pattern.c:166:

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

In BitVec.Pattern.c:167:

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

In BitVec.Pattern.c:168:

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

In BitVec.Pattern.c:171:

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

In BitVec.Pattern.c:172:

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

In BitVec.Pattern.c:173:

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

In BitVec.Pattern.c:193:

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

In BitVec.Pattern.c:197:

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

In BitVec.Pattern.c:198:

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

In BitVec.Pattern.c:199:

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

In BitVec.Pattern.c:225:

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

In BitVec.Pattern.c:229:

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

In BitVec.Pattern.c:230:

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

In BitVec.Pattern.c:231:

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

In BitVec.Pattern.c:250:

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

In BitVec.Pattern.c:251:

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

In BitVec.Pattern.c:258:

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

In BitVec.Pattern.c:266:

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

In BitVec.Pattern.c:273:

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

In BitVec.Pattern.c:274:

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

In BitVec.Pattern.c:275:

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

In BitVec.Pattern.c:276:

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

In BitVec.Pattern.c:277:

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

In BitVec.Pattern.c:278:

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

In BitVec.Pattern.c:285:

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

In BitVec.Pattern.c:286:

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

In BitVec.Pattern.c:290:

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

In BitVec.Pattern.c:298:

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

In BitVec.Pattern.c:299:

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

In BitVec.Pattern.c:322:

    // 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 BitVec.Pattern.c:323:

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

In BitVec.Pattern.c:324:

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

In BitVec.Pattern.c:325:

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

In BitVec.Pattern.c:328:

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

In BitVec.Pattern.c:333:

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

In BitVec.Pattern.c:334:

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

In BitVec.Pattern.c:335:

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

In BitVec.Pattern.c:336:

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

In BitVec.Pattern.c:356:

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

In BitVec.Pattern.c:369:

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

In BitVec.Pattern.c:370:

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

In BitVec.Pattern.c:383:

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

In BitVec.Pattern.c:396:

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

In BitVec.Pattern.c:397:

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

In BitVec.Pattern.c:423:

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

In BitVec.Pattern.c:424:

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

In BitVec.Pattern.c:438:

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

In BitVec.Pattern.c:439:

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

In BitVec.Pattern.c:440:

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

In BitVec.Pattern.c:456:

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

In BitVec.Pattern.c:457:

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

In BitVec.Pattern.c:458:

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

In BitVec.Pattern.c:478:

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

In BitVec.Pattern.c:479:

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

In BitVec.Pattern.c:480:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:481:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:482:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:483:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    
    // Test prefix: 110

In BitVec.Pattern.c:486:

    
    // Test prefix: 110
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.c:487:

    // Test prefix: 110
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.c:488:

    BitVecPush(&prefix, true);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    
    result = result && BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:494:

    // Test non-matching prefix: 101
    BitVecClear(&prefix);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    BitVecPush(&prefix, true);

In BitVec.Pattern.c:495:

    BitVecClear(&prefix);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    BitVecPush(&prefix, true);

In BitVec.Pattern.c:496:

    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    BitVecPush(&prefix, true);
    
    result = result && !BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:513:

    
    // Test empty prefix (should always match)
    BitVecPush(&source, true);
    result = result && BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:518:

    // Test prefix longer than source
    BitVecClear(&source);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    result = result && !BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:519:

    BitVecClear(&source);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    result = result && !BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:525:

    BitVecClear(&source);
    BitVecClear(&prefix);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&prefix, true);

In BitVec.Pattern.c:526:

    BitVecClear(&prefix);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);

In BitVec.Pattern.c:527:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    result = result && BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:528:

    BitVecPush(&source, false);
    BitVecPush(&prefix, true);
    BitVecPush(&prefix, false);
    result = result && BitVecStartsWith(&source, &prefix);

In BitVec.Pattern.c:545:

    
    // Create source: 110101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:546:

    // Create source: 110101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:547:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:548:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:549:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:550:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    
    // Test suffix: 101

In BitVec.Pattern.c:553:

    
    // Test suffix: 101
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);
    BitVecPush(&suffix, true);

In BitVec.Pattern.c:554:

    // Test suffix: 101
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);
    BitVecPush(&suffix, true);

In BitVec.Pattern.c:555:

    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);
    BitVecPush(&suffix, true);
    
    result = result && BitVecEndsWith(&source, &suffix);

In BitVec.Pattern.c:561:

    // Test non-matching suffix: 110
    BitVecClear(&suffix);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);

In BitVec.Pattern.c:562:

    BitVecClear(&suffix);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);

In BitVec.Pattern.c:563:

    BitVecPush(&suffix, true);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);
    
    result = result && !BitVecEndsWith(&source, &suffix);

In BitVec.Pattern.c:580:

    
    // Test empty suffix (should always match)
    BitVecPush(&source, true);
    result = result && BitVecEndsWith(&source, &suffix);

In BitVec.Pattern.c:585:

    // Test suffix longer than source
    BitVecClear(&source);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);
    result = result && !BitVecEndsWith(&source, &suffix);

In BitVec.Pattern.c:586:

    BitVecClear(&source);
    BitVecPush(&suffix, true);
    BitVecPush(&suffix, false);
    result = result && !BitVecEndsWith(&source, &suffix);

In BitVec.Pattern.c:603:

    
    // Create source: 1101011
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:604:

    // Create source: 1101011
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:605:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:606:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:607:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:608:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:609:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    
    // Test pattern: 101 (exists at positions 2 and 4)

In BitVec.Pattern.c:612:

    
    // Test pattern: 101 (exists at positions 2 and 4)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:613:

    // Test pattern: 101 (exists at positions 2 and 4)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:614:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    
    result = result && BitVecContains(&source, &pattern);

In BitVec.Pattern.c:620:

    // Test non-existing pattern: 000
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:621:

    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:622:

    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, false);
    
    result = result && !BitVecContains(&source, &pattern);

In BitVec.Pattern.c:640:

    
    // Create source: 1101011
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:641:

    // Create source: 1101011
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:642:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:643:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:644:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:645:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:646:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    
    // Test pattern: 101

In BitVec.Pattern.c:649:

    
    // Test pattern: 101
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:650:

    // Test pattern: 101
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:651:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    
    result = result && BitVecContainsAt(&source, &pattern, 1);  // Should match

In BitVec.Pattern.c:670:

    
    // Create small source
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:671:

    // Create small source
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    
    // Test pattern that extends beyond source

In BitVec.Pattern.c:674:

    
    // Test pattern that extends beyond source
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:675:

    // Test pattern that extends beyond source
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:676:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    
    result = result && !BitVecContainsAt(&source, &pattern, 0); // Pattern too long

In BitVec.Pattern.c:695:

    // Create source: 101010101
    for (int i = 0; i < 9; i++) {
    BitVecPush(&source, i % 2 == 0);
    }

In BitVec.Pattern.c:699:

    
    // Test pattern: 101 (should find 4 occurrences at 0, 2, 4, 6)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:700:

    // Test pattern: 101 (should find 4 occurrences at 0, 2, 4, 6)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:701:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    
    u64 count = BitVecCountPattern(&source, &pattern);

In BitVec.Pattern.c:708:

    // Test pattern: 010 (should find 3 occurrences at 1, 3, 5)
    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:709:

    BitVecClear(&pattern);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:710:

    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    
    count  = BitVecCountPattern(&source, &pattern);

In BitVec.Pattern.c:729:

    
    // Create source: 101101101
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:730:

    // Create source: 101101101
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:731:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:732:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:733:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:734:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:735:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:736:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:737:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    
    // Test pattern: 101

In BitVec.Pattern.c:740:

    
    // Test pattern: 101
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:741:

    // Test pattern: 101
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:742:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    
    // Search from index 8 backwards

In BitVec.Pattern.c:767:

    
    // Create source: 110110
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:768:

    // Create source: 110110
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:769:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:770:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:771:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:772:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    
    // Old pattern: 110

In BitVec.Pattern.c:775:

    
    // Old pattern: 110
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, false);

In BitVec.Pattern.c:776:

    // Old pattern: 110
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, false);

In BitVec.Pattern.c:777:

    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, false);
    
    // New pattern: 101

In BitVec.Pattern.c:780:

    
    // New pattern: 101
    BitVecPush(&new_pattern, true);
    BitVecPush(&new_pattern, false);
    BitVecPush(&new_pattern, true);

In BitVec.Pattern.c:781:

    // New pattern: 101
    BitVecPush(&new_pattern, true);
    BitVecPush(&new_pattern, false);
    BitVecPush(&new_pattern, true);

In BitVec.Pattern.c:782:

    BitVecPush(&new_pattern, true);
    BitVecPush(&new_pattern, false);
    BitVecPush(&new_pattern, true);
    
    bool replaced = BitVecReplace(&source, &old_pattern, &new_pattern);

In BitVec.Pattern.c:810:

    // Create source: 110110110
    for (int i = 0; i < 3; i++) {
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:811:

    for (int i = 0; i < 3; i++) {
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    }

In BitVec.Pattern.c:812:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    }

In BitVec.Pattern.c:816:

    
    // Old pattern: 110
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, false);

In BitVec.Pattern.c:817:

    // Old pattern: 110
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, false);

In BitVec.Pattern.c:818:

    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, true);
    BitVecPush(&old_pattern, false);
    
    // New pattern: 01

In BitVec.Pattern.c:821:

    
    // New pattern: 01
    BitVecPush(&new_pattern, false);
    BitVecPush(&new_pattern, true);

In BitVec.Pattern.c:822:

    // New pattern: 01
    BitVecPush(&new_pattern, false);
    BitVecPush(&new_pattern, true);
    
    u64 replacements = BitVecReplaceAll(&source, &old_pattern, &new_pattern);

In BitVec.Pattern.c:846:

    
    // Create source: 1101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:847:

    // Create source: 1101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:848:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:849:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    
    // Create pattern: 1?01 (where ? can be anything)

In BitVec.Pattern.c:852:

    
    // Create pattern: 1?01 (where ? can be anything)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false); // This will be wildcarded
    BitVecPush(&pattern, false);

In BitVec.Pattern.c:853:

    // Create pattern: 1?01 (where ? can be anything)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false); // This will be wildcarded
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:854:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, false); // This will be wildcarded
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:855:

    BitVecPush(&pattern, false); // This will be wildcarded
    BitVecPush(&pattern, false);
    BitVecPush(&pattern, true);
    
    // Create wildcard: 0100 (1 means wildcard, 0 means must match exactly)

In BitVec.Pattern.c:858:

    
    // Create wildcard: 0100 (1 means wildcard, 0 means must match exactly)
    BitVecPush(&wildcard, false);
    BitVecPush(&wildcard, true); // Wildcard position
    BitVecPush(&wildcard, false);

In BitVec.Pattern.c:859:

    // Create wildcard: 0100 (1 means wildcard, 0 means must match exactly)
    BitVecPush(&wildcard, false);
    BitVecPush(&wildcard, true); // Wildcard position
    BitVecPush(&wildcard, false);
    BitVecPush(&wildcard, false);

In BitVec.Pattern.c:860:

    BitVecPush(&wildcard, false);
    BitVecPush(&wildcard, true); // Wildcard position
    BitVecPush(&wildcard, false);
    BitVecPush(&wildcard, false);

In BitVec.Pattern.c:861:

    BitVecPush(&wildcard, true); // Wildcard position
    BitVecPush(&wildcard, false);
    BitVecPush(&wildcard, false);
    
    result = result && BitVecMatches(&source, &pattern, &wildcard);

In BitVec.Pattern.c:880:

    
    // Create source: 110100111
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:881:

    // Create source: 110100111
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:882:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:883:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, false);

In BitVec.Pattern.c:884:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:885:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:886:

    BitVecPush(&source, false);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:887:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, true);

In BitVec.Pattern.c:888:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    
    // Create pattern: 111 (should match at position 6 with 0 errors)

In BitVec.Pattern.c:891:

    
    // Create pattern: 111 (should match at position 6 with 0 errors)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:892:

    // Create pattern: 111 (should match at position 6 with 0 errors)
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, true);

In BitVec.Pattern.c:893:

    BitVecPush(&pattern, true);
    BitVecPush(&pattern, true);
    BitVecPush(&pattern, true);
    
    u64 pos = BitVecFuzzyMatch(&source, &pattern, 0);

In BitVec.Pattern.c:915:

    
    // Create source: 101010
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:916:

    // Create source: 101010
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:917:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:918:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:919:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:920:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    
    // Test simple substring match

In BitVec.Pattern.c:944:

    
    // Create source: 110101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:945:

    // Create source: 110101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:946:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:947:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:948:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:949:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    
    // Pattern 0: 111 (should not match)

In BitVec.Pattern.c:952:

    
    // Pattern 0: 111 (should not match)
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);

In BitVec.Pattern.c:953:

    // Pattern 0: 111 (should not match)
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);

In BitVec.Pattern.c:954:

    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    
    // Pattern 1: 110 (should match)

In BitVec.Pattern.c:957:

    
    // Pattern 1: 110 (should match)
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], false);

In BitVec.Pattern.c:958:

    // Pattern 1: 110 (should match)
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], false);

In BitVec.Pattern.c:959:

    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], false);
    
    // Pattern 2: 101 (should not match as prefix)

In BitVec.Pattern.c:962:

    
    // Pattern 2: 101 (should not match as prefix)
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], false);
    BitVecPush(&patterns[2], true);

In BitVec.Pattern.c:963:

    // Pattern 2: 101 (should not match as prefix)
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], false);
    BitVecPush(&patterns[2], true);

In BitVec.Pattern.c:964:

    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], false);
    BitVecPush(&patterns[2], true);
    
    u64 match_idx = BitVecPrefixMatch(&source, patterns, 3);

In BitVec.Pattern.c:990:

    
    // Create source: 110101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:991:

    // Create source: 110101
    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:992:

    BitVecPush(&source, true);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);

In BitVec.Pattern.c:993:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:994:

    BitVecPush(&source, false);
    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);

In BitVec.Pattern.c:995:

    BitVecPush(&source, true);
    BitVecPush(&source, false);
    BitVecPush(&source, true);
    
    // Pattern 0: 111 (should not match)

In BitVec.Pattern.c:998:

    
    // Pattern 0: 111 (should not match)
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);

In BitVec.Pattern.c:999:

    // Pattern 0: 111 (should not match)
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);

In BitVec.Pattern.c:1000:

    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    BitVecPush(&patterns[0], true);
    
    // Pattern 1: 101 (should match as suffix)

In BitVec.Pattern.c:1003:

    
    // Pattern 1: 101 (should match as suffix)
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], false);
    BitVecPush(&patterns[1], true);

In BitVec.Pattern.c:1004:

    // Pattern 1: 101 (should match as suffix)
    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], false);
    BitVecPush(&patterns[1], true);

In BitVec.Pattern.c:1005:

    BitVecPush(&patterns[1], true);
    BitVecPush(&patterns[1], false);
    BitVecPush(&patterns[1], true);
    
    // Pattern 2: 110 (should not match as suffix)

In BitVec.Pattern.c:1008:

    
    // Pattern 2: 110 (should not match as suffix)
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], false);

In BitVec.Pattern.c:1009:

    // Pattern 2: 110 (should not match as suffix)
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], false);

In BitVec.Pattern.c:1010:

    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], true);
    BitVecPush(&patterns[2], false);
    
    u64 match_idx = BitVecSuffixMatch(&source, patterns, 3);

In BitVec.Pattern.c:1027:

    printf("Testing BitVecStartsWith(NULL, prefix) - should fatal\n");
    BitVec prefix = BitVecInit();
    BitVecPush(&prefix, true);
    BitVecStartsWith(NULL, &prefix);
    BitVecDeinit(&prefix);

In BitVec.Pattern.c:1036:

    printf("Testing BitVecStartsWith(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();
    BitVecPush(&source, true);
    BitVecStartsWith(&source, NULL);
    BitVecDeinit(&source);

In BitVec.Pattern.c:1045:

    printf("Testing BitVecEndsWith(NULL, suffix) - should fatal\n");
    BitVec suffix = BitVecInit();
    BitVecPush(&suffix, true);
    BitVecEndsWith(NULL, &suffix);
    BitVecDeinit(&suffix);

In BitVec.Pattern.c:1054:

    printf("Testing BitVecEndsWith(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();
    BitVecPush(&source, true);
    BitVecEndsWith(&source, NULL);
    BitVecDeinit(&source);

In BitVec.Pattern.c:1063:

    printf("Testing BitVecContainsAt(NULL, pattern, 0) - should fatal\n");
    BitVec pattern = BitVecInit();
    BitVecPush(&pattern, true);
    BitVecContainsAt(NULL, &pattern, 0);
    BitVecDeinit(&pattern);

In BitVec.Pattern.c:1072:

    printf("Testing BitVecContainsAt(source, NULL, 0) - should fatal\n");
    BitVec source = BitVecInit();
    BitVecPush(&source, true);
    BitVecContainsAt(&source, NULL, 0);
    BitVecDeinit(&source);

In BitVec.Pattern.c:1090:

    BitVec pattern  = BitVecInit();
    BitVec wildcard = BitVecInit();
    BitVecPush(&pattern, true);
    BitVecPush(&wildcard, false);
    BitVecMatches(NULL, &pattern, &wildcard);

In BitVec.Pattern.c:1091:

    BitVec wildcard = BitVecInit();
    BitVecPush(&pattern, true);
    BitVecPush(&wildcard, false);
    BitVecMatches(NULL, &pattern, &wildcard);
    BitVecDeinit(&pattern);

In BitVec.Pattern.c:1107:

    printf("Testing BitVecRegexMatch(source, NULL) - should fatal\n");
    BitVec source = BitVecInit();
    BitVecPush(&source, true);
    BitVecRegexMatch(&source, NULL);
    BitVecDeinit(&source);

In BitVec.Pattern.c:1116:

    printf("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
    BitVec patterns[1] = {BitVecInit()};
    BitVecPush(&patterns[0], true);
    BitVecPrefixMatch(NULL, patterns, 1);
    BitVecDeinit(&patterns[0]);

In BitVec.Pattern.c:1125:

    printf("Testing BitVecPrefixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();
    BitVecPush(&source, true);
    BitVecPrefixMatch(&source, NULL, 1);
    BitVecDeinit(&source);

In BitVec.Pattern.c:1134:

    printf("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
    BitVec patterns[1] = {BitVecInit()};
    BitVecPush(&patterns[0], true);
    BitVecSuffixMatch(NULL, patterns, 1);
    BitVecDeinit(&patterns[0]);

In BitVec.Pattern.c:1143:

    printf("Testing BitVecSuffixMatch(source, NULL, 1) - should fatal\n");
    BitVec source = BitVecInit();
    BitVecPush(&source, true);
    BitVecSuffixMatch(&source, NULL, 1);
    BitVecDeinit(&source);

In BitVec.BitWise.Deadend.c:78:

    BitVec bv1 = BitVecInit();
    BitVec bv2 = BitVecInit();
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, false);

In BitVec.BitWise.Deadend.c:79:

    BitVec bv2 = BitVecInit();
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, false);
    
    // Test NULL result pointer - should abort

In BitVec.Foreach.Deadend.c:35:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    bool values[5];

In BitVec.Foreach.Deadend.c:49:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    u64 runs[5];

In BitVec.Foreach.Deadend.c:63:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    u64  runs[5];
    bool values[5];

In BitVec.Access.c:41:

    
    // Add a pattern: 1010
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:42:

    // Add a pattern: 1010
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.c:43:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.c:44:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    
    // Test getting each bit

In BitVec.Access.c:65:

    
    // Initialize with some bits
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);

In BitVec.Access.c:66:

    // Initialize with some bits
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);

In BitVec.Access.c:67:

    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    
    // Set specific bits

In BitVec.Access.c:95:

    
    // Initialize with pattern: 101
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:96:

    // Initialize with pattern: 101
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:97:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Flip each bit

In BitVec.Access.c:135:

    
    // Add some bits
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:136:

    // Add some bits
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:137:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    result = result && (BitVecLen(&bv) == 3);

In BitVec.Access.c:163:

    
    // Create pattern: 1101000
    BitVecPush(&bv, true);  // 1 one,  0 zeros
    BitVecPush(&bv, true);  // 2 ones, 0 zeros
    BitVecPush(&bv, false); // 2 ones, 1 zero

In BitVec.Access.c:164:

    // Create pattern: 1101000
    BitVecPush(&bv, true);  // 1 one,  0 zeros
    BitVecPush(&bv, true);  // 2 ones, 0 zeros
    BitVecPush(&bv, false); // 2 ones, 1 zero
    BitVecPush(&bv, true);  // 3 ones, 1 zero

In BitVec.Access.c:165:

    BitVecPush(&bv, true);  // 1 one,  0 zeros
    BitVecPush(&bv, true);  // 2 ones, 0 zeros
    BitVecPush(&bv, false); // 2 ones, 1 zero
    BitVecPush(&bv, true);  // 3 ones, 1 zero
    BitVecPush(&bv, false); // 3 ones, 2 zeros

In BitVec.Access.c:166:

    BitVecPush(&bv, true);  // 2 ones, 0 zeros
    BitVecPush(&bv, false); // 2 ones, 1 zero
    BitVecPush(&bv, true);  // 3 ones, 1 zero
    BitVecPush(&bv, false); // 3 ones, 2 zeros
    BitVecPush(&bv, false); // 3 ones, 3 zeros

In BitVec.Access.c:167:

    BitVecPush(&bv, false); // 2 ones, 1 zero
    BitVecPush(&bv, true);  // 3 ones, 1 zero
    BitVecPush(&bv, false); // 3 ones, 2 zeros
    BitVecPush(&bv, false); // 3 ones, 3 zeros
    BitVecPush(&bv, false); // 3 ones, 4 zeros

In BitVec.Access.c:168:

    BitVecPush(&bv, true);  // 3 ones, 1 zero
    BitVecPush(&bv, false); // 3 ones, 2 zeros
    BitVecPush(&bv, false); // 3 ones, 3 zeros
    BitVecPush(&bv, false); // 3 ones, 4 zeros

In BitVec.Access.c:169:

    BitVecPush(&bv, false); // 3 ones, 2 zeros
    BitVecPush(&bv, false); // 3 ones, 3 zeros
    BitVecPush(&bv, false); // 3 ones, 4 zeros
    
    // Test counting

In BitVec.Access.c:177:

    // Test with all ones
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:178:

    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:179:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    result = result && (BitVecCountOnes(&bv) == 3);

In BitVec.Access.c:198:

    
    // Test boundary conditions (no longer test empty bitvec - strict bounds checking now)
    BitVecPush(&bv, true);
    result = result && (BitVecGet(&bv, 0) == true); // Valid index

In BitVec.Access.c:204:

    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i % 3 == 0);
    }

In BitVec.Access.c:221:

    
    // Test normal setting
    BitVecPush(&bv, false);
    BitVecSet(&bv, 0, true);
    result = result && (BitVecGet(&bv, 0) == true);

In BitVec.Access.c:241:

    
    // Test normal flipping
    BitVecPush(&bv, true);
    BitVecFlip(&bv, 0);
    result = result && (BitVecGet(&bv, 0) == false);

In BitVec.Access.c:263:

    
    // Test count with single bit
    BitVecPush(&bv, true);
    result = result && (BitVecCountOnes(&bv) == 1);
    result = result && (BitVecCountZeros(&bv) == 0);

In BitVec.Access.c:268:

    
    BitVecClear(&bv);
    BitVecPush(&bv, false);
    result = result && (BitVecCountOnes(&bv) == 0);
    result = result && (BitVecCountZeros(&bv) == 1);

In BitVec.Access.c:275:

    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true);
    }
    result = result && (BitVecCountOnes(&bv) == 1000);

In BitVec.Access.c:292:

    // Stress test with many operations
    for (int cycle = 0; cycle < 100; cycle++) {
    BitVecPush(&bv, cycle % 2 == 0);
    
    // Test access during growth

In BitVec.Access.c:321:

    for (int bit = 0; bit < 8; bit++) {
    bool bit_value = (pattern & (1u << bit)) != 0;
    BitVecPush(&bv, bit_value);
    }
    }

In BitVec.Access.c:361:

    // Add bits and test macros again
    for (int i = 0; i < 65; i++) { // Test across byte boundaries
    BitVecPush(&bv, i % 2 == 0);
    }

In BitVec.Access.c:372:

    BitVecClear(&bv);
    for (int i = 0; i < 64; i++) { // Exactly 64 bits
    BitVecPush(&bv, true);
    }

In BitVec.Access.c:393:

    for (u64 i = 0; i < size; i++) {
    // Pattern: alternating every 7 bits
    BitVecPush(&bv, (i / 7) % 2 == 0);
    }

In BitVec.Access.c:431:

    // Test all-zeros pattern
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, false);
    }

In BitVec.Access.c:453:

    BitVecClear(&bv);
    for (int i = 0; i < 100; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }

In BitVec.Access.c:467:

    // Test Fibonacci-like pattern (each bit is XOR of previous two)
    BitVecClear(&bv);
    BitVecPush(&bv, true); // F(0) = 1
    BitVecPush(&bv, true); // F(1) = 1
    for (int i = 2; i < 50; i++) {

In BitVec.Access.c:468:

    BitVecClear(&bv);
    BitVecPush(&bv, true); // F(0) = 1
    BitVecPush(&bv, true); // F(1) = 1
    for (int i = 2; i < 50; i++) {
    bool prev1 = BitVecGet(&bv, i - 1);

In BitVec.Access.c:472:

    bool prev1 = BitVecGet(&bv, i - 1);
    bool prev2 = BitVecGet(&bv, i - 2);
    BitVecPush(&bv, prev1 != prev2); // XOR
    }

In BitVec.Access.c:555:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:556:

    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:557:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    // Test with index way beyond length (3) - should abort

In BitVec.Access.c:570:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);

In BitVec.Access.c:571:

    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    
    // Test with index way beyond length (2) - should abort

In BitVec.Access.c:585:

    BitVec bv = BitVecInit();
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }

In BitVec.Access.c:608:

    
    BitVec bv = BitVecInit();
    BitVecPush(&bv, true);
    
    // Test with maximum possible index value - should abort

In BitVec.Access.c:625:

    
    // Create pattern: 10110100
    BitVecPush(&bv, true);  // 0
    BitVecPush(&bv, false); // 1
    BitVecPush(&bv, true);  // 2

In BitVec.Access.c:626:

    // Create pattern: 10110100
    BitVecPush(&bv, true);  // 0
    BitVecPush(&bv, false); // 1
    BitVecPush(&bv, true);  // 2
    BitVecPush(&bv, true);  // 3

In BitVec.Access.c:627:

    BitVecPush(&bv, true);  // 0
    BitVecPush(&bv, false); // 1
    BitVecPush(&bv, true);  // 2
    BitVecPush(&bv, true);  // 3
    BitVecPush(&bv, false); // 4

In BitVec.Access.c:628:

    BitVecPush(&bv, false); // 1
    BitVecPush(&bv, true);  // 2
    BitVecPush(&bv, true);  // 3
    BitVecPush(&bv, false); // 4
    BitVecPush(&bv, true);  // 5

In BitVec.Access.c:629:

    BitVecPush(&bv, true);  // 2
    BitVecPush(&bv, true);  // 3
    BitVecPush(&bv, false); // 4
    BitVecPush(&bv, true);  // 5
    BitVecPush(&bv, false); // 6

In BitVec.Access.c:630:

    BitVecPush(&bv, true);  // 3
    BitVecPush(&bv, false); // 4
    BitVecPush(&bv, true);  // 5
    BitVecPush(&bv, false); // 6
    BitVecPush(&bv, false); // 7

In BitVec.Access.c:631:

    BitVecPush(&bv, false); // 4
    BitVecPush(&bv, true);  // 5
    BitVecPush(&bv, false); // 6
    BitVecPush(&bv, false); // 7

In BitVec.Access.c:632:

    BitVecPush(&bv, true);  // 5
    BitVecPush(&bv, false); // 6
    BitVecPush(&bv, false); // 7
    
    // Test finding first true (should be at index 0)

In BitVec.Access.c:648:

    // Test with all same values
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:649:

    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:650:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    result = result && (BitVecFind(&bv, true) == 0);

In BitVec.Access.c:669:

    
    // Test with all true bits
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:670:

    // Test with all true bits
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:671:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    result = result && BitVecAll(&bv, true);

In BitVec.Access.c:682:

    // Test with all false bits
    BitVecClear(&bv);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);

In BitVec.Access.c:683:

    BitVecClear(&bv);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);

In BitVec.Access.c:684:

    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    
    result = result && !BitVecAll(&bv, true);

In BitVec.Access.c:695:

    // Test with mixed bits
    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:696:

    BitVecClear(&bv);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Access.c:697:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    
    result = result && !BitVecAll(&bv, true);

In BitVec.Access.c:718:

    
    // Test pattern: 11100110011111
    BitVecPush(&bv, true);  // Run of 3 trues
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:719:

    // Test pattern: 11100110011111
    BitVecPush(&bv, true);  // Run of 3 trues
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false); // 1 false

In BitVec.Access.c:720:

    BitVecPush(&bv, true);  // Run of 3 trues
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses

In BitVec.Access.c:721:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // 1 true

In BitVec.Access.c:722:

    BitVecPush(&bv, true);
    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // 1 true
    BitVecPush(&bv, true);  // Run of 2 trues

In BitVec.Access.c:723:

    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // 1 true
    BitVecPush(&bv, true);  // Run of 2 trues
    BitVecPush(&bv, false); // 1 false

In BitVec.Access.c:724:

    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // 1 true
    BitVecPush(&bv, true);  // Run of 2 trues
    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses

In BitVec.Access.c:725:

    BitVecPush(&bv, true);  // 1 true
    BitVecPush(&bv, true);  // Run of 2 trues
    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // Run of 5 trues

In BitVec.Access.c:726:

    BitVecPush(&bv, true);  // Run of 2 trues
    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // Run of 5 trues
    BitVecPush(&bv, true);

In BitVec.Access.c:727:

    BitVecPush(&bv, false); // 1 false
    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // Run of 5 trues
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:728:

    BitVecPush(&bv, false); // Run of 2 falses
    BitVecPush(&bv, true);  // Run of 5 trues
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:729:

    BitVecPush(&bv, true);  // Run of 5 trues
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:730:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Access.c:731:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    // Longest run of trues should be 5

In BitVec.Access.c:742:

    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, true);
    }
    result = result && (BitVecLongestRun(&bv, true) == 10);

In BitVec.Access.c:750:

    BitVecClear(&bv);
    for (int i = 0; i < 10; i++) {
    BitVecPush(&bv, i % 2 == 0);
    }
    result = result && (BitVecLongestRun(&bv, true) == 1);

In BitVec.Access.c:773:

    
    // Test single element
    BitVecPush(&bv, true);
    result = result && (BitVecFind(&bv, true) == 0);
    result = result && (BitVecFindLast(&bv, true) == 0);

In BitVec.Access.c:782:

    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, i == 500 || i == 999); // Only indices 500 and 999 are true
    }
    result = result && (BitVecFind(&bv, true) == 500);

In BitVec.Access.c:807:

    
    // Test single element bitvector
    BitVecPush(&bv, true);
    result = result && BitVecAll(&bv, true);
    result = result && !BitVecAll(&bv, false);

In BitVec.Access.c:816:

    BitVecClear(&bv);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv, true); // All true
    }
    result = result && BitVecAll(&bv, true);

In BitVec.Access.c:843:

    
    // Test single element
    BitVecPush(&bv, true);
    result = result && (BitVecLongestRun(&bv, true) == 1);
    result = result && (BitVecLongestRun(&bv, false) == 0);

In BitVec.Access.c:850:

    BitVecClear(&bv);
    for (int i = 0; i < 10000; i++) {
    BitVecPush(&bv, true);
    }
    result = result && (BitVecLongestRun(&bv, true) == 10000);

In BitVec.Compare.c:46:

    
    // Add same pattern to both
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:47:

    // Add same pattern to both
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:48:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    
    BitVecPush(&bv2, true);

In BitVec.Compare.c:50:

    BitVecPush(&bv1, true);
    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:51:

    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:52:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    // Should be equal

In BitVec.Compare.c:58:

    
    // Add different pattern to third
    BitVecPush(&bv3, true);
    BitVecPush(&bv3, false);
    BitVecPush(&bv3, false); // Different bit

In BitVec.Compare.c:59:

    // Add different pattern to third
    BitVecPush(&bv3, true);
    BitVecPush(&bv3, false);
    BitVecPush(&bv3, false); // Different bit

In BitVec.Compare.c:60:

    BitVecPush(&bv3, true);
    BitVecPush(&bv3, false);
    BitVecPush(&bv3, false); // Different bit
    
    // Should not be equal

In BitVec.Compare.c:66:

    
    // Test different lengths
    BitVecPush(&bv3, true);
    result = result && !BitVecEquals(&bv1, &bv3);

In BitVec.Compare.c:85:

    
    // Test equal bitvectors
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:86:

    // Test equal bitvectors
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    BitVecPush(&bv2, true);

In BitVec.Compare.c:88:

    BitVecPush(&bv1, false);
    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:89:

    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    
    bool result = (BitVecCompare(&bv1, &bv2) == 0);

In BitVec.Compare.c:97:

    BitVecClear(&bv2);
    
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);  // 11

In BitVec.Compare.c:98:

    
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);  // 11
    
    BitVecPush(&bv2, true);

In BitVec.Compare.c:100:

    BitVecPush(&bv1, true);  // 11
    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false); // 10

In BitVec.Compare.c:101:

    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false); // 10
    
    result = result && (BitVecCompare(&bv1, &bv2) > 0);

In BitVec.Compare.c:121:

    
    // Test lexicographic comparison
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true); // 101

In BitVec.Compare.c:122:

    // Test lexicographic comparison
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true); // 101

In BitVec.Compare.c:123:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true); // 101
    
    BitVecPush(&bv2, true);

In BitVec.Compare.c:125:

    BitVecPush(&bv1, true); // 101
    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // 11 (shorter)

In BitVec.Compare.c:126:

    
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // 11 (shorter)
    
    // Lexicographic comparison considers position-by-position

In BitVec.Compare.c:134:

    // Test equal bitvectors
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true); // 101

In BitVec.Compare.c:135:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true); // 101

In BitVec.Compare.c:136:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true); // 101
    
    result = result && (BitVecCompare(&bv1, &bv2) == 0);

In BitVec.Compare.c:156:

    // Create bitvectors representing different numbers
    // bv1: 101 (binary) = 5 (decimal)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:157:

    // bv1: 101 (binary) = 5 (decimal)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:158:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    
    // bv2: 11 (binary) = 3 (decimal)

In BitVec.Compare.c:161:

    
    // bv2: 11 (binary) = 3 (decimal)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:162:

    // bv2: 11 (binary) = 3 (decimal)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    
    // Numerical comparison should compare the integer values

In BitVec.Compare.c:170:

    // Test equal values
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true); // Also 101

In BitVec.Compare.c:171:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true); // Also 101

In BitVec.Compare.c:172:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true); // Also 101
    
    result = result && (BitVecNumericalCompare(&bv1, &bv2) == 0);

In BitVec.Compare.c:191:

    
    // bv1: 111 (3 ones)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:192:

    // bv1: 111 (3 ones)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:193:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    
    // bv2: 101 (2 ones)

In BitVec.Compare.c:196:

    
    // bv2: 101 (2 ones)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:197:

    // bv2: 101 (2 ones)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:198:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    // Weight comparison should compare number of set bits

In BitVec.Compare.c:206:

    // Test equal weights
    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Also 3 ones

In BitVec.Compare.c:207:

    BitVecClear(&bv2);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Also 3 ones

In BitVec.Compare.c:208:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true); // Also 3 ones
    
    result = result && (BitVecWeightCompare(&bv1, &bv2) == 0);

In BitVec.Compare.c:227:

    
    // Create superset: 1111
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:228:

    // Create superset: 1111
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:229:

    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:230:

    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    
    // Create subset: 1010

In BitVec.Compare.c:233:

    
    // Create subset: 1010
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);

In BitVec.Compare.c:234:

    // Create subset: 1010
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);

In BitVec.Compare.c:235:

    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);

In BitVec.Compare.c:236:

    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 BitVec.Compare.c:248:

    // Test equal sets (should be subset)
    BitVecClear(&superset);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    BitVecPush(&superset, true);

In BitVec.Compare.c:249:

    BitVecClear(&superset);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);

In BitVec.Compare.c:250:

    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);

In BitVec.Compare.c:251:

    BitVecPush(&superset, false);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    
    result = result && BitVecIsSubset(&subset, &superset);

In BitVec.Compare.c:271:

    // Test positive vs negative (MSB is sign bit)
    // bv1: 011 (positive 3)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:272:

    // bv1: 011 (positive 3)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:273:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    // bv2: 111 (negative, MSB=1)

In BitVec.Compare.c:276:

    
    // bv2: 111 (negative, MSB=1)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:277:

    // bv2: 111 (negative, MSB=1)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:278:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    
    // Positive should be greater than negative

In BitVec.Compare.c:286:

    BitVecClear(&bv2);
    // bv2: 001 (positive 1)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:287:

    // bv2: 001 (positive 1)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:288:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);
    
    // 3 > 1

In BitVec.Compare.c:313:

    
    // Create superset: 1111
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:314:

    // Create superset: 1111
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:315:

    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:316:

    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    
    // Create subset: 1010

In BitVec.Compare.c:319:

    
    // Create subset: 1010
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);

In BitVec.Compare.c:320:

    // Create subset: 1010
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);

In BitVec.Compare.c:321:

    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);

In BitVec.Compare.c:322:

    BitVecPush(&subset, false);
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    
    // superset should be a superset of subset

In BitVec.Compare.c:334:

    // Test equal sets (should be superset)
    BitVecClear(&superset);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    BitVecPush(&superset, true);

In BitVec.Compare.c:335:

    BitVecClear(&superset);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);

In BitVec.Compare.c:336:

    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);

In BitVec.Compare.c:337:

    BitVecPush(&superset, false);
    BitVecPush(&superset, true);
    BitVecPush(&superset, false);
    
    result = result && BitVecIsSuperset(&superset, &subset);

In BitVec.Compare.c:357:

    // Create overlapping bitvectors
    // bv1: 1010
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:358:

    // bv1: 1010
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:359:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:360:

    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    // bv2: 1100

In BitVec.Compare.c:363:

    
    // bv2: 1100
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:364:

    // bv2: 1100
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:365:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:366:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, false);
    
    // They overlap at position 0 (both have 1)

In BitVec.Compare.c:374:

    BitVecClear(&bv2);
    // bv2: 0101 (complement of bv1)
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:375:

    // bv2: 0101 (complement of bv1)
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:376:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:377:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    // They should not overlap (no position where both have 1)

In BitVec.Compare.c:398:

    // Create disjoint bitvectors
    // bv1: 1010
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:399:

    // bv1: 1010
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:400:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:401:

    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    // bv2: 0101 (disjoint with bv1)

In BitVec.Compare.c:404:

    
    // bv2: 0101 (disjoint with bv1)
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:405:

    // bv2: 0101 (disjoint with bv1)
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:406:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:407:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    // Should be disjoint and not intersect

In BitVec.Compare.c:443:

    // bv1: 11100111
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv1, (i >= 3 && i <= 5) ? false : true);
    }

In BitVec.Compare.c:448:

    // bv2: 00100100
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv2, (i == 2 || i == 5) ? true : false);
    }

In BitVec.Compare.c:484:

    // Create test patterns
    // bv1: 11010110
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:485:

    // bv1: 11010110
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:486:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:487:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:488:

    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);

In BitVec.Compare.c:489:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:490:

    BitVecPush(&bv1, false);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:491:

    BitVecPush(&bv1, true);
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    // bv2: 01101011

In BitVec.Compare.c:494:

    
    // bv2: 01101011
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:495:

    // bv2: 01101011
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:496:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:497:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);

In BitVec.Compare.c:498:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:499:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:500:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:501:

    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, true);
    
    // Test range comparisons

In BitVec.Compare.c:531:

    // Test lexicographic comparison
    // bv1: 10 (shorter)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);

In BitVec.Compare.c:532:

    // bv1: 10 (shorter)
    BitVecPush(&bv1, true);
    BitVecPush(&bv1, false);
    
    // bv2: 101 (longer)

In BitVec.Compare.c:535:

    
    // bv2: 101 (longer)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:536:

    // bv2: 101 (longer)
    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);

In BitVec.Compare.c:537:

    BitVecPush(&bv2, true);
    BitVecPush(&bv2, false);
    BitVecPush(&bv2, true);
    
    // Lexicographically, shorter comes first

In BitVec.Compare.c:572:

    
    // Test sorted pattern: 0001111
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);

In BitVec.Compare.c:573:

    // Test sorted pattern: 0001111
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);

In BitVec.Compare.c:574:

    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Compare.c:575:

    BitVecPush(&bv, false);
    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Compare.c:576:

    BitVecPush(&bv, false);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Compare.c:577:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);

In BitVec.Compare.c:578:

    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    BitVecPush(&bv, true);
    
    result = result && BitVecIsSorted(&bv);

In BitVec.Compare.c:583:

    
    // Test unsorted pattern (add 0 after 1s)
    BitVecPush(&bv, false);
    result = result && !BitVecIsSorted(&bv);

In BitVec.Compare.c:589:

    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, false);
    }
    result = result && BitVecIsSorted(&bv);

In BitVec.Compare.c:596:

    BitVecClear(&bv);
    for (int i = 0; i < 5; i++) {
    BitVecPush(&bv, true);
    }
    result = result && BitVecIsSorted(&bv);

In BitVec.Compare.c:619:

    
    // Test compare empty vs non-empty
    BitVecPush(&bv1, true);
    result = result && !BitVecEquals(&bv1, &bv2);
    result = result && (BitVecCompare(&bv1, &bv2) != 0);

In BitVec.Compare.c:628:

    for (int i = 0; i < 1000; i++) {
    bool bit = i % 3 == 0;
    BitVecPush(&bv1, bit);
    BitVecPush(&bv2, bit);
    }

In BitVec.Compare.c:629:

    bool bit = i % 3 == 0;
    BitVecPush(&bv1, bit);
    BitVecPush(&bv2, bit);
    }
    result = result && BitVecEquals(&bv1, &bv2);

In BitVec.Compare.c:655:

    
    // Test single bit sets
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, false);
    result = result && !BitVecOverlaps(&bv1, &bv2);

In BitVec.Compare.c:656:

    // Test single bit sets
    BitVecPush(&bv1, true);
    BitVecPush(&bv2, false);
    result = result && !BitVecOverlaps(&bv1, &bv2);

In BitVec.Compare.c:663:

    BitVecClear(&bv2);
    for (int i = 0; i < 1000; i++) {
    BitVecPush(&bv1, i % 2 == 0);
    BitVecPush(&bv2, i % 3 == 0);
    }

In BitVec.Compare.c:664:

    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 BitVec.Compare.c:686:

    int pattern1[] = {1, 0, 1, 0, 1, 1, 0};
    for (int i = 0; i < 7; i++) {
    BitVecPush(&bv1, pattern1[i]);
    }

In BitVec.Compare.c:692:

    int pattern2[] = {1, 1, 0, 0, 1, 0, 1};
    for (int i = 0; i < 7; i++) {
    BitVecPush(&bv2, pattern2[i]);
    }

In BitVec.Compare.c:712:

    // bv3: larger than bv2
    for (int i = 0; i < 8; i++) {
    BitVecPush(&bv3, true);
    }

In BitVec.Compare.c:724:

    
    // Create actual subset/superset relationship
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);

In BitVec.Compare.c:725:

    // Create actual subset/superset relationship
    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);

In BitVec.Compare.c:726:

    BitVecPush(&subset, true);
    BitVecPush(&subset, false);
    BitVecPush(&subset, true);
    
    BitVecPush(&superset, true);

In BitVec.Compare.c:728:

    BitVecPush(&subset, true);
    
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:729:

    
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);

In BitVec.Compare.c:730:

    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    BitVecPush(&superset, true);
    
    result = result && BitVecIsSubset(&subset, &superset);

In BitVec.Compare.c:757:

    // Pattern 1: Fibonacci-like XOR pattern
    bool bit1 = (i % 3 == 0) ^ (i % 5 == 0);
    BitVecPush(&large1, bit1);
    
    // Pattern 2: Prime-like pattern

In BitVec.Compare.c:761:

    // Pattern 2: Prime-like pattern
    bool bit2 = (i % 7 == 0) || (i % 11 == 0);
    BitVecPush(&large2, bit2);
    }

In BitVec.Compare.c:782:

    // Positive number (MSB = 0): 01111111
    for (int i = 0; i < 7; i++) {
    BitVecPush(&pos, true);
    }
    BitVecPush(&pos, false);

In BitVec.Compare.c:784:

    BitVecPush(&pos, true);
    }
    BitVecPush(&pos, false);
    
    // Negative number (MSB = 1): 10000001

In BitVec.Compare.c:787:

    
    // Negative number (MSB = 1): 10000001
    BitVecPush(&neg, true);
    for (int i = 1; i < 7; i++) {
    BitVecPush(&neg, false);

In BitVec.Compare.c:789:

    BitVecPush(&neg, true);
    for (int i = 1; i < 7; i++) {
    BitVecPush(&neg, false);
    }
    BitVecPush(&neg, true);

In BitVec.Compare.c:791:

    BitVecPush(&neg, false);
    }
    BitVecPush(&neg, true);
    
    // Unsigned: 01111111 (127) < 10000001 (129)

In BitVec.Compare.c:850:

    // Create small bitvectors
    for (int i = 0; i < 3; i++) {
    BitVecPush(&bv1, i % 2 == 0);
    BitVecPush(&bv2, i % 2 == 1);
    }

In BitVec.Compare.c:851:

    for (int i = 0; i < 3; i++) {
    BitVecPush(&bv1, i % 2 == 0);
    BitVecPush(&bv2, i % 2 == 1);
    }

BitVecPush

`BitVecPush`

Description

Parameters

Usage example (from documentation)

Usage example (Cross-references)

Tags :

Share :

Related Posts

BitVecFindLast

BitVecCountZeros

BitVecNone