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