} else {
    // Convert to integer (up to 64 bits) and format as hex
    u64          value  = BitVecToInteger(bv);
    StrIntFormat config = {.base = 16, .uppercase = (fmt_info->flags & FMT_FLAG_CAPS) != 0, .use_prefix = true};
    StrFromU64(o, value, &config);

    StrPushBackZstr(o, "0o0");
    } else {
    u64          value  = BitVecToInteger(bv);
    StrIntFormat config = {.base = 8, .uppercase = false, .use_prefix = true};
    StrFromU64(o, value, &config);

    }
    
    u64 BitVecToInteger(BitVec *bv) {
    ValidateBitVec(bv);
    if (bv->length == 0) {

    z          = "0xDEAD";
    StrReadFmt(z, "{}", bv2);
    u64 value2 = BitVecToInteger(&bv2);
    success    = success && (value2 == 0xDEAD);
    WriteFmt("Test 2 - Hex: {}, Success: {}\n", value2, (value2 == 0xDEAD) ? "true" : "false");

    z          = "0o755";
    StrReadFmt(z, "{}", bv3);
    u64 value3 = BitVecToInteger(&bv3);
    success    = success && (value3 == 0755);
    WriteFmt("Test 3 - Octal: {}, Success: {}\n", value3, (value3 == 0755) ? "true" : "false");

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

    
    // Convert to integer
    u64 value = BitVecToInteger(&bv);
    
    // Check result - pattern 1011 (bits stored as: index 0=true, 1=false, 2=true, 3=true)

    }
    
    u64 value2 = BitVecToInteger(&bv2);
    result     = result && (value2 > 0); // Should be some positive value

    
    // Test empty bitvec to integer
    u64 value = BitVecToInteger(&bv);
    result    = result && (value == 0);

    
    BitVec bv        = BitVecFromInteger(value, bits);
    u64    recovered = BitVecToInteger(&bv);
    
    result = result && (recovered == value);

    result          = result && (large_bv.length == 64);
    
    u64 large_value = BitVecToInteger(&large_bv);
    result          = result && (large_value == 0xFFFFFFFFFFFFFFFF);
    BitVecDeinit(&large_bv);

    }
    
    u64 oversized_value = BitVecToInteger(&oversized);
    // Should return some value or 0, but not crash
    result = result && (oversized_value >= 0); // Always true for u64, but documents intent

    StrDeinit(&empty_str);
    
    u64 empty_value = BitVecToInteger(&empty);
    result          = result && (empty_value == 0);

    
    // Test integer conversion (may depend on bit order)
    u64 value = BitVecToInteger(&bv);
    // We test that we get a consistent value (not necessarily the exact expected one)
    result = result && (value > 0 || ZstrCompare(test_cases[i].pattern, "00000000") == 0);

    
    // Test BitVecToInteger with NULL pointer - should abort
    u64 value = BitVecToInteger(NULL);
    (void)value; // Suppress unused variable warning