FloatExponent

    }
    
    i64 FloatExponent(const Float *value) {
        ValidateFloat(value);
        return value->exponent;

        // Construction guard: identical significand, exponents differ only in low
        // byte (0 vs 2) -- the only hash input that changes is an exponent byte.
        bool built_ok = (FloatExponent(&a) == 0) && (FloatExponent(&b) == 2);
        bool distinct = float_hash(&a, 0) != float_hash(&b, 0);

        bool result = FloatIsZero(&value);
        result      = result && !FloatIsNegative(&value);
        result      = result && (FloatExponent(&value) == 0);
    
        FloatDeinit(&value);

        bool result = FloatIsZero(&value);
        result      = result && !FloatIsNegative(&value);
        result      = result && (FloatExponent(&value) == 0);
    
        FloatDeinit(&value);

        bool ok = FloatMul(&r, &zero, &big);
        ok      = ok && FloatIsZero(&r);
        ok      = ok && (FloatExponent(&r) == 0);
    
        FloatDeinit(&zero);

        const i64 minexp = (i64)(-9223372036854775807LL - 1);
    
        bool result = ok && (FloatExponent(&f) == minexp);
    
        FloatDeinit(&f);

        Str    text       = FloatToStr(&value);
    
        bool result = (FloatExponent(&value) == 0);
        result      = result && (ZstrCompare(StrBegin(&text), "1152921504606846976") == 0);

    
        bool ok = FloatMul(&r, &a, &b);
        ok      = ok && (FloatExponent(&r) == INT64_MAX);
    
        FloatDeinit(&a);

    
        bool ok = FloatMul(&r, &a, &b);
        ok      = ok && (FloatExponent(&r) == INT64_MIN);
    
        FloatDeinit(&a);

    
        bool ok = FloatDiv(&r, &a, &b, 0);
        ok      = ok && (FloatExponent(&r) == INT64_MIN);
    
        FloatDeinit(&a);

    
        bool ok = FloatDiv(&r, &a, &b, 0);
        ok      = ok && (FloatExponent(&r) == INT64_MAX);
    
        FloatDeinit(&a);

    
        // 100 == 1 * 10^2 after normalization.
        bool result = FloatExponent(&value) == 2;
    
        IntDeinit(&whole);

        Float value = FloatFrom(&whole, &alloc.base);
    
        bool result = FloatExponent(&value) == 3;
    
        FloatNegate(&value);

        result = result && FloatIsNegative(&value);
        result = result && (ZstrCompare(StrBegin(&text), "-2000") == 0);
        result = result && (FloatExponent(&value) == 3);
    
        StrDeinit(&text);

    
        Float value = FloatFrom((u64)100, &alloc.base);
        bool  ok    = FloatExponent(&value) == 2;
    
        FloatDeinit(&value);

    
        Float value = FloatFrom((i64)-200, &alloc.base);
        bool  ok    = FloatExponent(&value) == 2;
    
        FloatDeinit(&value);

        // in a high byte (0 vs 256), so the only hash input that changes is an
        // exponent byte above byte0.
        bool built_ok = (FloatExponent(&a) == 0) && (FloatExponent(&b) == 256);
    
        bool distinct = float_hash(&a, 0) != float_hash(&b, 0);

        Float b = FloatFromStr("1e1", &alloc.base); // exp 1
    
        bool built_ok = (FloatExponent(&a) == 0) && (FloatExponent(&b) == 1);
        bool distinct = float_hash(&a, 0) != float_hash(&b, 0);

        Int   whole = IntFromStr("4503599627370496", &alloc.base);
    
        bool result = (FloatExponent(&value) == 0);
        result      = result && (FloatCompare(&value, &whole) == 0);

    
    bool test_float_exponent(void) {
        WriteFmt("Testing FloatExponent\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

        Float value = FloatFromStr("12.34", &alloc.base);
    
        bool result = FloatExponent(&value) == -2;
    
        FloatDeinit(&value);