static void int_normalize(Int *value) {
    ValidateInt(value);
    BitVecResize(INT_BITS(value), int_significant_bits(value));
    }

    
    if (positions == 0) {
    BitVecResize(INT_BITS(value), bits);
    return;
    }

    }
    
    BitVecResize(INT_BITS(value), bits + positions);
    
    for (u64 i = bits; i > 0; i--) {

    
    if (positions == 0) {
    BitVecResize(INT_BITS(value), bits);
    return;
    }

    }
    
    BitVecResize(INT_BITS(value), bits - positions);
    int_normalize(value);
    }

    
    if (IntBitLength(&q) < bit + 1) {
    BitVecResize(INT_BITS(&q), bit + 1);
    }
    BitVecSet(INT_BITS(&q), bit, true);

    }
    
    void BitVecResize(BitVec *bitvec, u64 new_size) {
    ValidateBitVec(bitvec);
    if (new_size > bitvec->capacity) {

    // Reserve space for the clone
    BitVecReserve(&clone, bv->length);
    BitVecResize(&clone, bv->length);
    
    // Copy all bits

    }
    
    BitVecResize(bitvec, bitvec->length + 1);
    BitVecSet(bitvec, bitvec->length - 1, value);
    }

    }
    bool value = BitVecGet(bitvec, bitvec->length - 1);
    BitVecResize(bitvec, bitvec->length - 1);
    return value;
    }

    // Grow the bitvector to accommodate new bits
    u64 old_length = bv->length;
    BitVecResize(bv, old_length + count);
    
    // Shift existing bits to the right

    // Grow the bitvector to accommodate new bits
    u64 old_length = bv->length;
    BitVecResize(bv, old_length + other->length);
    
    // Shift existing bits to the right

    // Grow the bitvector to accommodate new bits
    u64 old_length = bv->length;
    BitVecResize(bv, old_length + pattern_bits);
    
    // Shift existing bits to the right

    }
    
    BitVecResize(bv, bv->length - 1);
    return removed_bit; // Return the actual bit value that was removed
    }

    
    // Shrink the bitvector
    BitVecResize(bv, bv->length - count);
    }

    
    // Shrink the bitvector to the new size
    BitVecResize(bv, write_idx);
    
    return removed_count;

    
    u64 min_len = MIN2(a->length, b->length);
    BitVecResize(result, min_len);
    
    for (u64 i = 0; i < min_len; i++) {

    
    u64 max_len = MAX2(a->length, b->length);
    BitVecResize(result, max_len);
    
    for (u64 i = 0; i < max_len; i++) {

    
    u64 max_len = MAX2(a->length, b->length);
    BitVecResize(result, max_len);
    
    for (u64 i = 0; i < max_len; i++) {

    ValidateBitVec(bitvec);
    
    BitVecResize(result, bitvec->length);
    
    for (u64 i = 0; i < bitvec->length; i++) {

    
    BitVecReserve(&result, bit_len);
    BitVecResize(&result, bit_len);
    
    // Copy bits from bytes

    
    BitVecReserve(&result, bits);
    BitVecResize(&result, bits);
    
    // Convert integer to bits (LSB first)

    
    // Reserve space and set bits
    BitVecResize(&bv, 4);
    BitVecSet(&bv, 0, true);
    BitVecSet(&bv, 1, false);

    
    // Set first bit
    BitVecResize(&bv, 1);
    BitVecSet(&bv, 0, true);
    bool result = (BitVecGet(&bv, 0) == true);

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

    // Set alternating pattern
    for (int i = 0; i < size; i++) {
    BitVecResize(&bv, i + 1);
    BitVecSet(&bv, i, i % 3 == 0); // Every third bit is true
    }

    // Test BitVecReu64 function
    bool test_bitvec_resize(void) {
    WriteFmt("Testing BitVecResize\n");
    
    BitVec bv = BitVecInit();

    
    // Test resizing to larger size
    BitVecResize(&bv, 6);
    
    // Check that length was increased and new bits have the default value

    
    // Test resizing to smaller size
    BitVecResize(&bv, 2);
    
    // Check that length was decreased and data was truncated

    
    // Test resizing to same size (should be no-op)
    BitVecResize(&bv, 2);
    result = result && (bv.length == 2);

    BitVecPush(&bv, true);
    BitVecPush(&bv, false);
    BitVecResize(&bv, 0);
    result = result && (bv.length == 0);

    
    // Test reu64 from 0 to non-zero
    BitVecResize(&bv, 5);
    result = result && (bv.length == 5);
    // New bits should be false

    
    // Test reu64 to same size
    BitVecResize(&bv, 5);
    result = result && (bv.length == 5);

    
    // Test large resize
    BitVecResize(&bv, 1000);
    result = result && (bv.length == 1000);

    
    // Test shrinking from large size
    BitVecResize(&bv, 10);
    result = result && (bv.length == 10);

    
    // This should trigger an abort if validation is working
    BitVecResize(&bv, SIZE_MAX);
    
    // If we reach here, validation didn't work as expected