} 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);

        }
    
        return BitVecToInteger(INT_BITS(value));
    }

    }
    
    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