BitVecDeinit

Documentation

API Reference

BitVecDeinit

Description

Deinitialize bitvector and free all allocated memory. After calling this, the bitvector should not be used unless re-initialized.

Parameters

Name	Direction	Description
`bv`	in	Pointer to bitvector to deinitialize

Usage example (from documentation)

  BitVecDeinit(&flags);

Usage example (Cross-references)

Usage examples (Cross-references)

In BitVec.c:38:

    #define BYTES_FOR_BITS(bits) (((bits) + BITS_PER_BYTE - 1) / BITS_PER_BYTE)
    
    void BitVecDeinit(BitVec *bitvec) {
        ValidateBitVec(bitvec);
        if (bitvec->data) {

In BitVec.c:934:

        }
    
        BitVecDeinit(&temp);
    }

In BitVec.c:958:

        }
    
        BitVecDeinit(&temp);
    }

In BitVec.Pattern.Deadend.c:43:

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

In BitVec.Pattern.Deadend.c:57:

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

In BitVec.Pattern.Deadend.c:70:

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

In BitVec.Pattern.Deadend.c:84:

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

In BitVec.Pattern.Deadend.c:111:

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

In BitVec.Pattern.Deadend.c:127:

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

In BitVec.Pattern.Deadend.c:128:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return true;
    }

In BitVec.Pattern.Deadend.c:145:

        BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return true;

In BitVec.Pattern.Deadend.c:146:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return true;
    }

In BitVec.Pattern.Deadend.c:157:

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

In BitVec.Pattern.Deadend.c:166:

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

In BitVec.Pattern.Deadend.c:175:

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

In BitVec.Pattern.Deadend.c:184:

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

In BitVec.Pattern.Deadend.c:193:

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

In BitVec.Pattern.Deadend.c:202:

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

In BitVec.Pattern.Deadend.c:221:

        BitVecPush(&wildcard, false);
        BitVecMatches(NULL, &pattern, &wildcard);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        return true;

In BitVec.Pattern.Deadend.c:222:

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

In BitVec.Pattern.Deadend.c:237:

        BitVecPush(&source, true);
        BitVecRegexMatch(&source, NULL);
        BitVecDeinit(&source);
        return true;
    }

In BitVec.Pattern.Deadend.c:243:

    bool test_bitvec_prefix_match_null_source(void) {
        WriteFmt("Testing BitVecPrefixMatch(NULL, patterns, 1) - should fatal\n");
        BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit);
        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecPrefixMatch(NULL, &vp);

In BitVec.Pattern.Deadend.c:255:

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

In BitVec.Pattern.Deadend.c:261:

    bool test_bitvec_suffix_match_null_source(void) {
        WriteFmt("Testing BitVecSuffixMatch(NULL, patterns, 1) - should fatal\n");
        BitVecs vp = VecInitWithDeepCopy(NULL, BitVecDeinit);
        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecSuffixMatch(NULL, &vp);

In BitVec.Pattern.Deadend.c:273:

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

In Io.Read.c:838:

        );
        StrDeinit(&result1);
        BitVecDeinit(&bv1);
    
        // Test 2: Reading hex format

In Io.Read.c:847:

        success    = success && (value2 == 0xDEAD);
        WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");
        BitVecDeinit(&bv2);
    
        // Test 3: Reading octal format

In Io.Read.c:856:

        success    = success && (value3 == 0755);
        WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");
        BitVecDeinit(&bv3);
    
        // Test 4: Reading with whitespace

In Io.Read.c:870:

        );
        StrDeinit(&result4);
        BitVecDeinit(&bv4);
    
        // Test 5: Reading zero values

In Io.Read.c:880:

        WriteFmt("Test 5 - Zero: {}, Success: {}\n", result5, (ZstrCompare(result5.data, "0") == 0) ? "true" : "false");
        StrDeinit(&result5);
        BitVecDeinit(&bv5);
    
        WriteFmt("Overall BitVec reading success: {}\n", success ? "true" : "false");

In BitVec.Access.Simple.c:48:

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

In BitVec.Access.Simple.c:69:

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

In BitVec.Access.Simple.c:95:

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

In BitVec.Access.Simple.c:121:

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

In BitVec.Access.Simple.c:141:

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

In BitVec.Access.Simple.c:163:

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

In BitVec.Access.Simple.c:182:

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

In BitVec.Access.Simple.c:201:

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

In BitVec.Access.Simple.c:229:

        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.Simple.c:266:

        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.Simple.c:301:

        result = result && (BitVecCountZeros(&bv) == 500);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.Simple.c:331:

        result = result && (BitVecCountZeros(&bv) == 1);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.Simple.c:381:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.Simple.c:435:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.Simple.c:469:

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

In BitVec.Access.Simple.c:516:

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

In BitVec.Access.Simple.c:553:

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

In BitVec.Access.Simple.c:585:

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

In BitVec.Access.Simple.c:625:

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

In BitVec.Access.Simple.c:658:

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

In BitVec.Foreach.c:62:

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

In BitVec.Foreach.c:93:

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

In BitVec.Foreach.c:124:

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

In BitVec.Foreach.c:154:

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

In BitVec.Foreach.c:190:

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

In BitVec.Foreach.c:225:

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

In BitVec.Foreach.c:267:

        result = result && (count == 1000);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.c:306:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.c:344:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.c:391:

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

In BitVec.Foreach.c:433:

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

In BitVec.Foreach.c:473:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.c:488:

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

In BitVec.Foreach.c:496:

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

In BitVec.Foreach.c:504:

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

In BitVec.Foreach.c:514:

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

In BitVec.Foreach.c:530:

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

In BitVec.Foreach.c:568:

        result = result && (count == 8);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.c:630:

        }
    
        BitVecDeinit(&large_bv);
        return result;
    }

In BitVec.Foreach.c:658:

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

In BitVec.Foreach.c:672:

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

In BitVec.Foreach.c:687:

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

In BitVec.Access.Deadend.c:90:

        BitVecGet(&bv, 0);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.Deadend.c:102:

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

In BitVec.Access.Deadend.c:114:

        BitVecFlip(&bv, 0);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.Deadend.c:130:

        BitVecGet(&bv, 1000);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.Deadend.c:144:

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

In BitVec.Access.Deadend.c:159:

        BitVecFlip(&bv, 10);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.Deadend.c:181:

        BitVecGet(&bv, SIZE_MAX);
    
        BitVecDeinit(&bv);
        return false;
    }

In Io.Write.c:610:

    
        // Cleanup
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv_empty);
        BitVecDeinit(&bv2);

In Io.Write.c:611:

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

In Io.Write.c:612:

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

In Io.Write.c:613:

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

In Io.Write.c:614:

        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
        BitVecDeinit(&bv_zero);
        StrDeinit(&output);
        return success;

In BitVec.Foreach.Simple.c:62:

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

In BitVec.Foreach.Simple.c:93:

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

In BitVec.Foreach.Simple.c:124:

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

In BitVec.Foreach.Simple.c:154:

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

In BitVec.Foreach.Simple.c:190:

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

In BitVec.Foreach.Simple.c:225:

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

In BitVec.Foreach.Simple.c:267:

        result = result && (count == 1000);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.Simple.c:306:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.Simple.c:344:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.Simple.c:391:

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

In BitVec.Foreach.Simple.c:433:

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

In BitVec.Foreach.Simple.c:473:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.Simple.c:488:

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

In BitVec.Foreach.Simple.c:496:

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

In BitVec.Foreach.Simple.c:504:

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

In BitVec.Foreach.Simple.c:514:

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

In BitVec.Foreach.Simple.c:530:

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

In BitVec.Foreach.Simple.c:568:

        result = result && (count == 8);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Foreach.Simple.c:630:

        }
    
        BitVecDeinit(&large_bv);
        return result;
    }

In BitVec.Remove.c:55:

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

In BitVec.Remove.c:91:

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

In BitVec.Remove.c:120:

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

In BitVec.Remove.c:157:

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

In BitVec.Remove.c:195:

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

In BitVec.Remove.c:232:

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

In BitVec.Remove.c:259:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Remove.c:284:

        result  = result && (bv.length == 999);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Remove.c:314:

        result = result && (bv.length == 5); // Should have 5 elements left
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Remove.c:350:

        result = result && (found == true) && (bv.length == 999);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Remove.c:385:

        result = result && (count == 500) && (bv.length == 500);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Remove.c:416:

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

In BitVec.Remove.c:428:

        BitVecPop(&bv);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Remove.c:440:

        BitVecRemove(&bv, 0);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Remove.c:452:

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

In BitVec.Math.c:88:

        result   = result && (distance == 1);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:89:

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

In BitVec.Math.c:118:

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

In BitVec.Math.c:119:

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

In BitVec.Math.c:167:

        result     = result && (fabs(similarity - 0.5) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:168:

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

In BitVec.Math.c:193:

        result     = result && (fabs(similarity - 1.0) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:194:

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

In BitVec.Math.c:228:

        result     = result && (fabs(similarity - 0.0) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:229:

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

In BitVec.Math.c:258:

        result     = result && (similarity == 0.0);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:259:

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

In BitVec.Math.c:295:

        result  = result && (product == 0);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:296:

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

In BitVec.Math.c:322:

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

In BitVec.Math.c:323:

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

In BitVec.Math.c:365:

        result   = result && (distance == 1);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:366:

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

In BitVec.Math.c:393:

        result   = result && (distance == 2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:394:

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

In BitVec.Math.c:429:

        result      = result && (fabs(correlation + 1.0) < 0.001);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:430:

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

In BitVec.Math.c:457:

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

In BitVec.Math.c:458:

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

In BitVec.Math.c:487:

        result  = result && (entropy == 0.0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Math.c:507:

        result  = result && (entropy == 0.0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Math.c:539:

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

In BitVec.Math.c:540:

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

In BitVec.Math.c:566:

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

In BitVec.Math.c:567:

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

In BitVec.Math.c:596:

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

In BitVec.Math.c:597:

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

In BitVec.Math.c:621:

        result   = result && (best_pos == 0);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Math.c:622:

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

In BitVec.Math.c:670:

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

In BitVec.Math.c:671:

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

In BitVec.Math.c:672:

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

In BitVec.Math.c:673:

        BitVecDeinit(&bv2);
        BitVecDeinit(&small1);
        BitVecDeinit(&small2);
        return result;
    }

In BitVec.Math.c:684:

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

In BitVec.Math.c:693:

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

In BitVec.Math.c:702:

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

In BitVec.Math.c:711:

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

In BitVec.Math.c:720:

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

In BitVec.Math.c:729:

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

In BitVec.Math.c:738:

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

In BitVec.Math.c:747:

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

In BitVec.Math.c:756:

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

In BitVec.Math.c:765:

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

In BitVec.Math.c:774:

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

In BitVec.Math.c:783:

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

In BitVec.Math.c:798:

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

In BitVec.Math.c:807:

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

In BitVec.Math.c:816:

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

In BitVec.Math.c:825:

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

In BitVec.Compare.c:70:

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

In BitVec.Compare.c:71:

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

In BitVec.Compare.c:72:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        return result;

In BitVec.Compare.c:107:

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

In BitVec.Compare.c:108:

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

In BitVec.Compare.c:141:

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

In BitVec.Compare.c:142:

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

In BitVec.Compare.c:177:

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

In BitVec.Compare.c:178:

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

In BitVec.Compare.c:213:

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

In BitVec.Compare.c:214:

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

In BitVec.Compare.c:256:

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

In BitVec.Compare.c:257:

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

In BitVec.Compare.c:298:

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

In BitVec.Compare.c:299:

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

In BitVec.Compare.c:300:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        return result;

In BitVec.Compare.c:342:

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

In BitVec.Compare.c:343:

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

In BitVec.Compare.c:383:

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

In BitVec.Compare.c:384:

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

In BitVec.Compare.c:427:

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

In BitVec.Compare.c:428:

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

In BitVec.Compare.c:469:

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

In BitVec.Compare.c:470:

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

In BitVec.Compare.c:516:

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

In BitVec.Compare.c:517:

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

In BitVec.Compare.c:555:

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

In BitVec.Compare.c:556:

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

In BitVec.Compare.c:557:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        return result;

In BitVec.Compare.c:601:

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

In BitVec.Compare.c:638:

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

In BitVec.Compare.c:639:

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

In BitVec.Compare.c:669:

        result = result && BitVecOverlaps(&bv1, &bv2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Compare.c:670:

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

In BitVec.Compare.c:736:

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

In BitVec.Compare.c:737:

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

In BitVec.Compare.c:738:

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

In BitVec.Compare.c:739:

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

In BitVec.Compare.c:740:

        BitVecDeinit(&bv3);
        BitVecDeinit(&subset);
        BitVecDeinit(&superset);
    
        return result;

In BitVec.Compare.c:800:

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

In BitVec.Compare.c:801:

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

In BitVec.Compare.c:802:

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

In BitVec.Compare.c:803:

        BitVecDeinit(&large2);
        BitVecDeinit(&pos);
        BitVecDeinit(&neg);
    
        return result;

In BitVec.Compare.c:817:

        BitVecEquals(NULL, &bv);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Compare.c:838:

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

In BitVec.Compare.c:857:

        BitVecEqualsRange(&bv1, 0, &bv2, 0, 5); // Range exceeds length
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return false;

In BitVec.Compare.c:858:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return false;
    }

In BitVec.Init.c:36:

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

In BitVec.Init.c:43:

    // Test BitVecDeinit function
    bool test_bitvec_deinit(void) {
        WriteFmt("Testing BitVecDeinit\n");
    
        BitVec bv = BitVecInit();

In BitVec.Init.c:56:

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

In BitVec.Init.c:97:

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

In BitVec.Init.c:132:

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

In BitVec.Init.c:173:

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

In BitVec.Init.c:191:

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

In BitVec.Init.c:192:

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

In BitVec.Init.c:193:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        return result;

In BitVec.Init.c:222:

        result = result && (bv.capacity == cap_before);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Init.c:258:

        result = result && (bv.length == 10);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Init.c:289:

        result = result && (bv.length == 0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Init.c:308:

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

In BitVec.Init.c:322:

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

In BitVec.Init.c:339:

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

In BitVec.Init.c:354:

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

In BitVec.BitWise.Deadend.c:40:

        BitVecAnd(NULL, &bv, &bv2);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        return false;

In BitVec.BitWise.Deadend.c:41:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        return false;
    }

In BitVec.BitWise.Deadend.c:84:

        BitVecAnd(NULL, &bv1, &bv2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return false;

In BitVec.BitWise.Deadend.c:85:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return false;
    }

In BitVec.BitWise.Deadend.c:98:

        BitVecOr(&result, &bv1, NULL);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;

In BitVec.BitWise.Deadend.c:99:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;
    }

In BitVec.BitWise.Deadend.c:112:

        BitVecXor(&result, NULL, &bv1);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;

In BitVec.BitWise.Deadend.c:113:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;
    }

In BitVec.BitWise.Deadend.c:125:

        BitVecNot(&result, NULL);
    
        BitVecDeinit(&result);
        return false;
    }

In BitVec.BitWise.Simple.c:62:

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

In BitVec.BitWise.Simple.c:63:

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

In BitVec.BitWise.Simple.c:64:

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

In BitVec.BitWise.Simple.c:100:

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

In BitVec.BitWise.Simple.c:101:

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

In BitVec.BitWise.Simple.c:102:

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

In BitVec.BitWise.Simple.c:138:

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

In BitVec.BitWise.Simple.c:139:

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

In BitVec.BitWise.Simple.c:140:

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

In BitVec.BitWise.Simple.c:169:

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

In BitVec.BitWise.Simple.c:170:

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

In BitVec.BitWise.Simple.c:211:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.Simple.c:245:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.Simple.c:273:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.Simple.c:301:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.Simple.c:329:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.Simple.c:367:

        result = result && (bv.length == 1000);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.BitWise.Simple.c:395:

        result = result && (bv.length == 2);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.BitWise.Simple.c:431:

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

In BitVec.BitWise.Simple.c:433:

        BitVecDeinit(&result_bv);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.BitWise.Simple.c:434:

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

In BitVec.BitWise.Simple.c:467:

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

In BitVec.BitWise.Simple.c:531:

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

In BitVec.BitWise.Simple.c:532:

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

In BitVec.BitWise.Simple.c:533:

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

In BitVec.BitWise.Simple.c:598:

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

In BitVec.BitWise.Simple.c:599:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        return result;
    }

In BitVec.BitWise.Simple.c:660:

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

In BitVec.BitWise.Simple.c:661:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        return result;
    }

In BitVec.BitWise.Simple.c:753:

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

In BitVec.BitWise.Simple.c:754:

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

In BitVec.BitWise.Simple.c:755:

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

In BitVec.BitWise.Simple.c:814:

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

In BitVec.BitWise.Simple.c:815:

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

In BitVec.BitWise.Simple.c:816:

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

In BitVec.BitWise.Simple.c:817:

        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);
        return test_result;
    }

In BitVec.BitWise.Simple.c:876:

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

In BitVec.BitWise.Simple.c:877:

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

In BitVec.BitWise.Simple.c:878:

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

In BitVec.Type.c:25:

    
        // Clean up
        BitVecDeinit(&bitvec);
    
        return result;

In BitVec.Type.c:41:

    
        // Clean up
        BitVecDeinit(&bitvec);
    
        // Note: We can't easily test the negative case (invalid bitvector)

In BitVec.Foreach.Deadend.c:41:

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

In BitVec.Foreach.Deadend.c:55:

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

In BitVec.Foreach.Deadend.c:70:

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

In BitVec.Memory.c:55:

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

In BitVec.Memory.c:92:

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

In BitVec.Memory.c:135:

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

In BitVec.Memory.c:136:

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

In BitVec.Memory.c:181:

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

In BitVec.Memory.c:182:

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

In BitVec.Memory.c:215:

        result = result && (bv.length == 0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Memory.c:252:

        result = result && (bv.capacity >= 10000);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Memory.c:292:

        result = result && (bv1.length == 2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.Memory.c:293:

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

In BitVec.Memory.c:306:

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

In BitVec.Memory.c:313:

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

In BitVec.Memory.c:333:

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

In BitVec.Memory.c:334:

    
        BitVecDeinit(&clone3);
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Memory.c:368:

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

In BitVec.Memory.c:369:

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

In BitVec.Memory.c:370:

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

In BitVec.Memory.c:394:

        BitVecSwap(NULL, &bv);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Convert.c:57:

        // Clean up
        StrDeinit(&str);
        BitVecDeinit(&bv);
    
        return result;

In BitVec.Convert.c:82:

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

In BitVec.Convert.c:83:

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

In BitVec.Convert.c:115:

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

In BitVec.Convert.c:148:

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

In BitVec.Convert.c:183:

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

In BitVec.Convert.c:184:

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

In BitVec.Convert.c:230:

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

In BitVec.Convert.c:231:

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

In BitVec.Convert.c:264:

        StrDeinit(&str_obj);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Convert.c:276:

        BitVec bv1 = BitVecFromStr("");
        result     = result && (bv1.length == 0);
        BitVecDeinit(&bv1);
    
        // Test single character

In BitVec.Convert.c:282:

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

In BitVec.Convert.c:295:

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

In BitVec.Convert.c:315:

        BitVec bv2            = BitVecFromBytes(empty_bytes, 0); // 0 bits
        result                = result && (bv2.length == 0);
        BitVecDeinit(&bv2);
    
        // Test single byte

In BitVec.Convert.c:321:

        BitVec bv3            = BitVecFromBytes(single_byte, 8); // 8 bits from 1 byte
        result                = result && (bv3.length == 8);
        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);

In BitVec.Convert.c:323:

        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Convert.c:340:

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

In BitVec.Convert.c:345:

        BitVec bv3 = BitVecFromInteger(UINT64_MAX, 64); // 64 bits for max value
        result     = result && (bv3.length == 64);
        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);

In BitVec.Convert.c:347:

        BitVecDeinit(&bv3);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Convert.c:368:

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

In BitVec.Convert.c:389:

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

In BitVec.Convert.c:404:

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

In BitVec.Convert.c:422:

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

In BitVec.Convert.c:433:

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

In BitVec.Convert.c:450:

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

In BitVec.Convert.c:494:

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

In BitVec.Convert.c:515:

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

In BitVec.Convert.c:516:

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

In BitVec.Convert.c:517:

        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        BitVecDeinit(&bv3);
    
        return result;

In BitVec.Convert.c:575:

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

In BitVec.Convert.c:576:

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

In BitVec.Convert.c:600:

        result = result && large_pattern_correct;
    
        BitVecDeinit(&large_from_str);
    
        return result;

In BitVec.Convert.c:618:

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

In BitVec.Convert.c:624:

        BitVec empty_bv       = BitVecFromBytes(dummy_bytes, 0);
        bool   result         = (empty_bv.length == 0);
        BitVecDeinit(&empty_bv);
    
        return result;

In BitVec.BitWise.c:62:

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

In BitVec.BitWise.c:63:

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

In BitVec.BitWise.c:64:

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

In BitVec.BitWise.c:100:

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

In BitVec.BitWise.c:101:

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

In BitVec.BitWise.c:102:

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

In BitVec.BitWise.c:138:

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

In BitVec.BitWise.c:139:

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

In BitVec.BitWise.c:140:

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

In BitVec.BitWise.c:169:

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

In BitVec.BitWise.c:170:

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

In BitVec.BitWise.c:211:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.c:245:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.c:273:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.c:301:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.c:329:

    
        // Clean up
        BitVecDeinit(&bv);
    
        return test_result;

In BitVec.BitWise.c:367:

        result = result && (bv.length == 1000);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.BitWise.c:395:

        result = result && (bv.length == 2);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.BitWise.c:431:

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

In BitVec.BitWise.c:433:

        BitVecDeinit(&result_bv);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return result;

In BitVec.BitWise.c:434:

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

In BitVec.BitWise.c:467:

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

In BitVec.BitWise.c:531:

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

In BitVec.BitWise.c:532:

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

In BitVec.BitWise.c:533:

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

In BitVec.BitWise.c:598:

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

In BitVec.BitWise.c:599:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        return result;
    }

In BitVec.BitWise.c:660:

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

In BitVec.BitWise.c:661:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&original);
        return result;
    }

In BitVec.BitWise.c:753:

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

In BitVec.BitWise.c:754:

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

In BitVec.BitWise.c:755:

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

In BitVec.BitWise.c:814:

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

In BitVec.BitWise.c:815:

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

In BitVec.BitWise.c:816:

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

In BitVec.BitWise.c:817:

        BitVecDeinit(&bv2);
        BitVecDeinit(&result1);
        BitVecDeinit(&result2);
        return test_result;
    }

In BitVec.BitWise.c:876:

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

In BitVec.BitWise.c:877:

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

In BitVec.BitWise.c:878:

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

In BitVec.BitWise.c:901:

        BitVecAnd(NULL, &bv, &bv2);
    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        return false;

In BitVec.BitWise.c:902:

    
        BitVecDeinit(&bv);
        BitVecDeinit(&bv2);
        return false;
    }

In BitVec.BitWise.c:945:

        BitVecAnd(NULL, &bv1, &bv2);
    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return false;

In BitVec.BitWise.c:946:

    
        BitVecDeinit(&bv1);
        BitVecDeinit(&bv2);
        return false;
    }

In BitVec.BitWise.c:959:

        BitVecOr(&result, &bv1, NULL);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;

In BitVec.BitWise.c:960:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;
    }

In BitVec.BitWise.c:973:

        BitVecXor(&result, NULL, &bv1);
    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;

In BitVec.BitWise.c:974:

    
        BitVecDeinit(&result);
        BitVecDeinit(&bv1);
        return false;
    }

In BitVec.BitWise.c:986:

        BitVecNot(&result, NULL);
    
        BitVecDeinit(&result);
        return false;
    }

In BitVec.Insert.c:46:

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

In BitVec.Insert.c:81:

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

In BitVec.Insert.c:108:

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

In BitVec.Insert.c:141:

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

In BitVec.Insert.c:142:

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

In BitVec.Insert.c:186:

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

In BitVec.Insert.c:187:

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

In BitVec.Insert.c:217:

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

In BitVec.Insert.c:248:

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

In BitVec.Insert.c:249:

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

In BitVec.Insert.c:250:

        BitVecDeinit(&bv);
        BitVecDeinit(&empty);
        BitVecDeinit(&source);
        return result;
    }

In BitVec.Insert.c:275:

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

In BitVec.Insert.c:297:

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

In BitVec.Access.c:53:

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

In BitVec.Access.c:83:

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

In BitVec.Access.c:120:

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

In BitVec.Access.c:151:

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

In BitVec.Access.c:185:

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

In BitVec.Access.c:210:

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

In BitVec.Access.c:230:

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

In BitVec.Access.c:248:

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

In BitVec.Access.c:280:

        result = result && (BitVecCountZeros(&bv) == 0);
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.c:305:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.c:342:

        result = result && (BitVecGet(&bv, bv.length - 1) == true); // Last bit
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.c:378:

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

In BitVec.Access.c:418:

        }
    
        BitVecDeinit(&bv);
        return result;
    }

In BitVec.Access.c:482:

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

In BitVec.Access.c:522:

        BitVecGet(&bv, 0);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.c:534:

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

In BitVec.Access.c:546:

        BitVecFlip(&bv, 0);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.c:562:

        BitVecGet(&bv, 1000);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.c:576:

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

In BitVec.Access.c:591:

        BitVecFlip(&bv, 10);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.c:613:

        BitVecGet(&bv, SIZE_MAX);
    
        BitVecDeinit(&bv);
        return false;
    }

In BitVec.Access.c:657:

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

In BitVec.Access.c:706:

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

In BitVec.Access.c:755:

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

In BitVec.Access.c:787:

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

In BitVec.Access.c:827:

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

In BitVec.Access.c:860:

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

In BitVec.Pattern.c:86:

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

In BitVec.Pattern.c:87:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:133:

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

In BitVec.Pattern.c:134:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:178:

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

In BitVec.Pattern.c:179:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:236:

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

In BitVec.Pattern.c:237:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:305:

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

In BitVec.Pattern.c:306:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:346:

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

In BitVec.Pattern.c:347:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:360:

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

In BitVec.Pattern.c:374:

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

In BitVec.Pattern.c:387:

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

In BitVec.Pattern.c:401:

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

In BitVec.Pattern.c:428:

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

In BitVec.Pattern.c:444:

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

In BitVec.Pattern.c:445:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return true;
    }

In BitVec.Pattern.c:462:

        BitVecFindAllPattern(&source, &pattern, results, 0); // Should cause LOG_FATAL
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return true;

In BitVec.Pattern.c:463:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return true;
    }

In BitVec.Pattern.c:500:

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

In BitVec.Pattern.c:501:

    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        return result;
    }

In BitVec.Pattern.c:531:

        result = result && BitVecStartsWith(&source, &prefix);
    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        return result;

In BitVec.Pattern.c:532:

    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        return result;
    }

In BitVec.Pattern.c:567:

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

In BitVec.Pattern.c:568:

    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        return result;
    }

In BitVec.Pattern.c:589:

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

In BitVec.Pattern.c:590:

    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        return result;
    }

In BitVec.Pattern.c:626:

        result = result && !BitVecContains(&source, &pattern);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;

In BitVec.Pattern.c:627:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:657:

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

In BitVec.Pattern.c:658:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:680:

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

In BitVec.Pattern.c:681:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:715:

        result = result && (count == 3);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;

In BitVec.Pattern.c:716:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:752:

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

In BitVec.Pattern.c:753:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:793:

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

In BitVec.Pattern.c:794:

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

In BitVec.Pattern.c:795:

        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        return result;
    }

In BitVec.Pattern.c:830:

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

In BitVec.Pattern.c:831:

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

In BitVec.Pattern.c:832:

        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        return result;
    }

In BitVec.Pattern.c:865:

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

In BitVec.Pattern.c:866:

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

In BitVec.Pattern.c:867:

        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        return result;
    }

In BitVec.Pattern.c:902:

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

In BitVec.Pattern.c:903:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.c:926:

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

In BitVec.Pattern.c:970:

    
        for (int i = 0; i < 3; i++) {
            BitVecDeinit(&patterns[i]);
        }
        BitVecDeinit(&source);

In BitVec.Pattern.c:972:

            BitVecDeinit(&patterns[i]);
        }
        BitVecDeinit(&source);
        return result;
    }

In BitVec.Pattern.c:1016:

    
        for (int i = 0; i < 3; i++) {
            BitVecDeinit(&patterns[i]);
        }
        BitVecDeinit(&source);

In BitVec.Pattern.c:1018:

            BitVecDeinit(&patterns[i]);
        }
        BitVecDeinit(&source);
        return result;
    }

In BitVec.Pattern.c:1029:

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

In BitVec.Pattern.c:1038:

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

In BitVec.Pattern.c:1047:

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

In BitVec.Pattern.c:1056:

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

In BitVec.Pattern.c:1065:

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

In BitVec.Pattern.c:1074:

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

In BitVec.Pattern.c:1093:

        BitVecPush(&wildcard, false);
        BitVecMatches(NULL, &pattern, &wildcard);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        return true;

In BitVec.Pattern.c:1094:

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

In BitVec.Pattern.c:1109:

        BitVecPush(&source, true);
        BitVecRegexMatch(&source, NULL);
        BitVecDeinit(&source);
        return true;
    }

In BitVec.Pattern.c:1118:

        BitVecPush(&patterns[0], true);
        BitVecPrefixMatch(NULL, patterns, 1);
        BitVecDeinit(&patterns[0]);
        return true;
    }

In BitVec.Pattern.c:1127:

        BitVecPush(&source, true);
        BitVecPrefixMatch(&source, NULL, 1);
        BitVecDeinit(&source);
        return true;
    }

In BitVec.Pattern.c:1136:

        BitVecPush(&patterns[0], true);
        BitVecSuffixMatch(NULL, patterns, 1);
        BitVecDeinit(&patterns[0]);
        return true;
    }

In BitVec.Pattern.c:1145:

        BitVecPush(&source, true);
        BitVecSuffixMatch(&source, NULL, 1);
        BitVecDeinit(&source);
        return true;
    }

In BitVec.Pattern.Simple.c:86:

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

In BitVec.Pattern.Simple.c:87:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:133:

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

In BitVec.Pattern.Simple.c:134:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:178:

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

In BitVec.Pattern.Simple.c:179:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:236:

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

In BitVec.Pattern.Simple.c:237:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:305:

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

In BitVec.Pattern.Simple.c:306:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:346:

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

In BitVec.Pattern.Simple.c:347:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:384:

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

In BitVec.Pattern.Simple.c:385:

    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        return result;
    }

In BitVec.Pattern.Simple.c:415:

        result = result && BitVecStartsWith(&source, &prefix);
    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        return result;

In BitVec.Pattern.Simple.c:416:

    
        BitVecDeinit(&source);
        BitVecDeinit(&prefix);
        return result;
    }

In BitVec.Pattern.Simple.c:451:

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

In BitVec.Pattern.Simple.c:452:

    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        return result;
    }

In BitVec.Pattern.Simple.c:473:

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

In BitVec.Pattern.Simple.c:474:

    
        BitVecDeinit(&source);
        BitVecDeinit(&suffix);
        return result;
    }

In BitVec.Pattern.Simple.c:510:

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

In BitVec.Pattern.Simple.c:511:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:541:

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

In BitVec.Pattern.Simple.c:542:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:564:

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

In BitVec.Pattern.Simple.c:565:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:599:

        result = result && (count == 3);
    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;

In BitVec.Pattern.Simple.c:600:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:636:

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

In BitVec.Pattern.Simple.c:637:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:677:

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

In BitVec.Pattern.Simple.c:678:

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

In BitVec.Pattern.Simple.c:679:

        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:714:

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

In BitVec.Pattern.Simple.c:715:

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

In BitVec.Pattern.Simple.c:716:

        BitVecDeinit(&source);
        BitVecDeinit(&old_pattern);
        BitVecDeinit(&new_pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:749:

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

In BitVec.Pattern.Simple.c:750:

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

In BitVec.Pattern.Simple.c:751:

        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        BitVecDeinit(&wildcard);
        return result;
    }

In BitVec.Pattern.Simple.c:786:

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

In BitVec.Pattern.Simple.c:787:

    
        BitVecDeinit(&source);
        BitVecDeinit(&pattern);
        return result;
    }

In BitVec.Pattern.Simple.c:810:

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

In BitVec.Pattern.Simple.c:819:

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

In BitVec.Pattern.Simple.c:859:

    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        return result;
    }

In BitVec.Pattern.Simple.c:868:

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

In BitVec.Pattern.Simple.c:908:

    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        return result;
    }

In Init.h:41:

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

Last updated on April 20, 2026

BitVecCountZeros BitVecEmpty