// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: bool ImGui::SliderBehaviorT<float, float, float>(ImRect const&, unsigned int, int, float*, float, float, char const*, int, ImRect*)
bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;

    const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
    const bool is_decimal = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);
    const bool is_logarithmic = (flags & ImGuiSliderFlags_Logarithmic) && is_decimal;

    const float grab_padding = 2.0f;
    const float slider_sz = (bb.Max[axis] - bb.Min[axis]) - grab_padding * 2.0f;
    float grab_sz = style.GrabMinSize;
    SIGNEDTYPE v_range = (v_min < v_max ? v_max - v_min : v_min - v_max);
    if (!is_decimal && v_range >= 0)                                             // v_range < 0 may happen on integer overflows
        grab_sz = ImMax((float)(slider_sz / (v_range + 1)), style.GrabMinSize);  // For integer sliders: if possible have the grab size represent 1 unit
    grab_sz = ImMin(grab_sz, slider_sz);
    const float slider_usable_sz = slider_sz - grab_sz;
    const float slider_usable_pos_min = bb.Min[axis] + grab_padding + grab_sz * 0.5f;
    const float slider_usable_pos_max = bb.Max[axis] - grab_padding - grab_sz * 0.5f;

    float logarithmic_zero_epsilon = 0.0f; // Only valid when is_logarithmic is true
    float zero_deadzone_halfsize = 0.0f; // Only valid when is_logarithmic is true
    if (is_logarithmic)
    {
        // When using logarithmic sliders, we need to clamp to avoid hitting zero, but our choice of clamp value greatly affects slider precision. We attempt to use the specified precision to estimate a good lower bound.
        const int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 1;
        logarithmic_zero_epsilon = ImPow(0.1f, (float)decimal_precision);
        zero_deadzone_halfsize = (style.LogSliderDeadzone * 0.5f) / ImMax(slider_usable_sz, 1.0f);
    }

    // Process interacting with the slider
    bool value_changed = false;
    if (g.ActiveId == id)
    {
        bool set_new_value = false;
        float clicked_t = 0.0f;
        if (g.ActiveIdSource == ImGuiInputSource_Mouse)
        {
            if (!g.IO.MouseDown[0])
            {
                ClearActiveID();
            }
            else
            {
                const float mouse_abs_pos = g.IO.MousePos[axis];
                clicked_t = (slider_usable_sz > 0.0f) ? ImClamp((mouse_abs_pos - slider_usable_pos_min) / slider_usable_sz, 0.0f, 1.0f) : 0.0f;
                if (axis == ImGuiAxis_Y)
                    clicked_t = 1.0f - clicked_t;
                set_new_value = true;
            }
        }
        else if (g.ActiveIdSource == ImGuiInputSource_Nav)
        {
            if (g.ActiveIdIsJustActivated)
            {
                g.SliderCurrentAccum = 0.0f; // Reset any stored nav delta upon activation
                g.SliderCurrentAccumDirty = false;
            }

            const ImVec2 input_delta2 = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard | ImGuiNavDirSourceFlags_PadDPad, ImGuiInputReadMode_RepeatFast, 0.0f, 0.0f);
            float input_delta = (axis == ImGuiAxis_X) ? input_delta2.x : -input_delta2.y;
            if (input_delta != 0.0f)
            {
                const int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 0;
                if (decimal_precision > 0)
                {
                    input_delta /= 100.0f;    // Gamepad/keyboard tweak speeds in % of slider bounds
                    if (IsNavInputDown(ImGuiNavInput_TweakSlow))
                        input_delta /= 10.0f;
                }
                else
                {
                    if ((v_range >= -100.0f && v_range <= 100.0f) || IsNavInputDown(ImGuiNavInput_TweakSlow))
                        input_delta = ((input_delta < 0.0f) ? -1.0f : +1.0f) / (float)v_range; // Gamepad/keyboard tweak speeds in integer steps
                    else
                        input_delta /= 100.0f;
                }
                if (IsNavInputDown(ImGuiNavInput_TweakFast))
                    input_delta *= 10.0f;

                g.SliderCurrentAccum += input_delta;
                g.SliderCurrentAccumDirty = true;
            }

            float delta = g.SliderCurrentAccum;
            if (g.NavActivatePressedId == id && !g.ActiveIdIsJustActivated)
            {
                ClearActiveID();
            }
            else if (g.SliderCurrentAccumDirty)
            {
                clicked_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, *v, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);

                if ((clicked_t >= 1.0f && delta > 0.0f) || (clicked_t <= 0.0f && delta < 0.0f)) // This is to avoid applying the saturation when already past the limits
                {
                    set_new_value = false;
                    g.SliderCurrentAccum = 0.0f; // If pushing up against the limits, don't continue to accumulate
                }
                else
                {
                    set_new_value = true;
                    float old_clicked_t = clicked_t;
                    clicked_t = ImSaturate(clicked_t + delta);

                    // Calculate what our "new" clicked_t will be, and thus how far we actually moved the slider, and subtract this from the accumulator
                    TYPE v_new = ScaleValueFromRatioT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, clicked_t, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);
                    if (!(flags & ImGuiSliderFlags_NoRoundToFormat))
                        v_new = RoundScalarWithFormatT<TYPE, SIGNEDTYPE>(format, data_type, v_new);
                    float new_clicked_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_new, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);

                    if (delta > 0)
                        g.SliderCurrentAccum -= ImMin(new_clicked_t - old_clicked_t, delta);
                    else
                        g.SliderCurrentAccum -= ImMax(new_clicked_t - old_clicked_t, delta);
                }

                g.SliderCurrentAccumDirty = false;
            }
        }

        if (set_new_value)
        {
            TYPE v_new = ScaleValueFromRatioT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, clicked_t, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);

            // Round to user desired precision based on format string
            if (!(flags & ImGuiSliderFlags_NoRoundToFormat))
                v_new = RoundScalarWithFormatT<TYPE, SIGNEDTYPE>(format, data_type, v_new);

            // Apply result
            if (*v != v_new)
            {
                *v = v_new;
                value_changed = true;
            }
        }
    }

    if (slider_sz < 1.0f)
    {
        *out_grab_bb = ImRect(bb.Min, bb.Min);
    }
    else
    {
        // Output grab position so it can be displayed by the caller
        float grab_t = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, *v, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);
        if (axis == ImGuiAxis_Y)
            grab_t = 1.0f - grab_t;
        const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);
        if (axis == ImGuiAxis_X)
            *out_grab_bb = ImRect(grab_pos - grab_sz * 0.5f, bb.Min.y + grab_padding, grab_pos + grab_sz * 0.5f, bb.Max.y - grab_padding);
        else
            *out_grab_bb = ImRect(bb.Min.x + grab_padding, grab_pos - grab_sz * 0.5f, bb.Max.x - grab_padding, grab_pos + grab_sz * 0.5f);
    }

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, %ebx
movq %r8, -0x98(%rbp)
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
movq %rcx, -0xa0(%rbp)
movl %edx, %r13d
movl %esi, -0xd0(%rbp)
movq %rdi, %r12
leaq 0x51b5b(%rip), %rax     # 0xe3ce0
movq (%rax), %r15
movl %r9d, %eax
andl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x48(%rbp)
movl %eax, %r14d
shrl $0x14, %r14d
movl %edx, -0x90(%rbp)
andl $-0x2, %r13d
cmpl $0x8, %r13d
sete %al
movl %r9d, -0x64(%rbp)
andl $0x20, %ebx
shrl $0x5, %ebx
andb %al, %bl
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
movq %r14, %rsi
callq 0x95124
movss %xmm0, -0x60(%rbp)
movq %r12, -0xa8(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x95124
movss -0x60(%rbp), %xmm3
subss %xmm0, %xmm3
addss 0xa69d(%rip), %xmm3     # 0x9c88c
movq %r15, %r12
movss 0x15d8(%r15), %xmm2
movl %r13d, %r15d
movss -0x38(%rbp), %xmm5
movaps %xmm5, %xmm0
movss -0x34(%rbp), %xmm4
subss %xmm4, %xmm0
movaps %xmm4, %xmm1
subss %xmm5, %xmm1
cmpltss %xmm5, %xmm4
andps %xmm4, %xmm0
andnps %xmm1, %xmm4
orps %xmm0, %xmm4
cmpl $0x8, %r13d
movaps %xmm4, -0xe0(%rbp)
je 0x92260
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm4
jb 0x92260
movss 0x9db7(%rip), %xmm0     # 0x9bff8
addss %xmm4, %xmm0
movaps %xmm3, %xmm1
divss %xmm0, %xmm1
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movaps %xmm0, %xmm2
minss %xmm3, %xmm2
movaps %xmm2, -0x80(%rbp)
movss %xmm3, -0x60(%rbp)
subss %xmm2, %xmm3
movss %xmm3, -0xc0(%rbp)
movq -0xa8(%rbp), %rdi
movq %r14, %rsi
callq 0x95124
addss 0xa604(%rip), %xmm0     # 0x9c894
movss %xmm0, -0x44(%rbp)
movss 0x9d7b(%rip), %xmm0     # 0x9c018
mulss -0x80(%rbp), %xmm0
movss %xmm0, -0x68(%rbp)
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x95124
movaps %xmm0, %xmm5
xorps %xmm4, %xmm4
xorps %xmm3, %xmm3
testb %bl, %bl
je 0x92313
pushq $0x3
popq %rsi
movq -0x98(%rbp), %rdi
movss %xmm5, -0x40(%rbp)
callq 0x80ac1
cvtsi2ss %eax, %xmm1
movss 0xa5d4(%rip), %xmm0     # 0x9c8b4
callq 0xc770
movss -0x40(%rbp), %xmm5
movaps %xmm0, %xmm3
movss 0x15e0(%r12), %xmm4
mulss 0x9d19(%rip), %xmm4     # 0x9c018
movss -0xc0(%rbp), %xmm0
maxss 0x9ce9(%rip), %xmm0     # 0x9bff8
divss %xmm0, %xmm4
movss -0x44(%rbp), %xmm0
addss -0x68(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movzbl %bl, %r13d
movl -0xd0(%rbp), %eax
cmpl %eax, 0x1b30(%r12)
jne 0x92444
movq %r12, %rdi
movl 0x1b68(%r12), %eax
cmpl $0x2, %eax
movss %xmm4, -0x30(%rbp)
movss %xmm3, -0x2c(%rbp)
je 0x92457
cmpl $0x1, %eax
movl -0x90(%rbp), %r15d
jne 0x9251d
movss %xmm5, -0x40(%rbp)
cmpb $0x0, 0x130(%rdi)
je 0x9267b
addq $0x128, %rdi            # imm = 0x128
movq %r14, %rsi
callq 0x8e818
xorps %xmm0, %xmm0
movss -0xc0(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x923bd
movss (%rax), %xmm0
subss -0x44(%rbp), %xmm0
divss %xmm1, %xmm0
movss 0x9c4a(%rip), %xmm2     # 0x9bff8
minss %xmm0, %xmm2
xorps %xmm1, %xmm1
cmpltss %xmm1, %xmm0
andnps %xmm2, %xmm0
cmpl $0x0, -0x48(%rbp)
movl -0x64(%rbp), %ebx
movss -0x30(%rbp), %xmm4
movss -0x2c(%rbp), %xmm3
je 0x923df
movss 0x9c20(%rip), %xmm1     # 0x9bff8
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
andl $0x40, %ebx
movl %r15d, %edi
movss -0x34(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movl %r13d, %esi
callq 0x947f3
testl %ebx, %ebx
jne 0x9240a
movq -0x98(%rbp), %rdi
movl %r15d, %esi
callq 0x94a30
movq -0xa0(%rbp), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
movaps -0x80(%rbp), %xmm1
movss -0x60(%rbp), %xmm2
movss -0x40(%rbp), %xmm5
movss -0x30(%rbp), %xmm4
movss -0x2c(%rbp), %xmm3
jne 0x92438
jnp 0x926f1
movss %xmm0, (%rax)
movb $0x1, %r14b
jmp 0x92529
xorl %r14d, %r14d
movaps -0x80(%rbp), %xmm1
movl -0x90(%rbp), %r15d
jmp 0x92524
movss %xmm5, -0x40(%rbp)
cmpb $0x1, 0x1b3c(%rdi)
jne 0x92473
andl $0x0, 0x3094(%rdi)
movb $0x0, 0x3098(%rdi)
pushq $0x3
popq %rdi
pushq $0x5
popq %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x457c8
cmpl $0x0, -0x48(%rbp)
movl -0x64(%rbp), %ebx
je 0x92498
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps 0x9b48(%rip), %xmm0     # 0x9bfe0
ucomiss 0xa425(%rip), %xmm0     # 0x9c8c4
movss -0x30(%rbp), %xmm4
movss -0x2c(%rbp), %xmm3
jne 0x924b1
jnp 0x926db
cmpl $0x8, %r15d
jne 0x92685
pushq $0x3
popq %rsi
movq -0x98(%rbp), %rdi
movaps %xmm0, -0xc0(%rbp)
callq 0x80ac1
movaps -0xc0(%rbp), %xmm0
movss -0x2c(%rbp), %xmm3
movss -0x30(%rbp), %xmm4
testl %eax, %eax
jle 0x92685
divss 0xa3be(%rip), %xmm0     # 0x9c8b0
leaq 0x517e7(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movss 0x37c(%rax), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jbe 0x92701
divss 0x9b04(%rip), %xmm0     # 0x9c01c
jmp 0x92701
xorl %r14d, %r14d
movaps -0x80(%rbp), %xmm1
movss -0x60(%rbp), %xmm2
movq 0x10(%rbp), %rbx
movss 0x9ac3(%rip), %xmm0     # 0x9bff8
ucomiss %xmm2, %xmm0
jbe 0x92550
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x92666
addss 0xa360(%rip), %xmm5     # 0x9c8b8
movaps 0x9a81(%rip), %xmm0     # 0x9bfe0
xorps %xmm1, %xmm0
movaps %xmm0, -0x60(%rbp)
subss -0x68(%rbp), %xmm5
movss %xmm5, -0x40(%rbp)
movq -0xa0(%rbp), %rax
movss (%rax), %xmm0
movl %r15d, %edi
movss -0x34(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movl %r13d, %esi
callq 0x94531
cmpl $0x0, -0x48(%rbp)
je 0x925a5
movss 0x9a5a(%rip), %xmm1     # 0x9bff8
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss -0x40(%rbp), %xmm4
movss -0x44(%rbp), %xmm1
subss %xmm1, %xmm4
mulss %xmm0, %xmm4
addss %xmm1, %xmm4
jne 0x92613
movss 0x9a53(%rip), %xmm0     # 0x9c018
movaps -0x60(%rbp), %xmm5
mulss %xmm0, %xmm5
addss %xmm4, %xmm5
movq -0xa8(%rbp), %rax
movss 0x4(%rax), %xmm1
movss 0xc(%rax), %xmm2
addss 0xa2aa(%rip), %xmm1     # 0x9c894
movaps -0x80(%rbp), %xmm3
mulss %xmm0, %xmm3
addss %xmm4, %xmm3
addss 0xa2ba(%rip), %xmm2     # 0x9c8b8
movss %xmm5, (%rbx)
movss %xmm1, 0x4(%rbx)
movss %xmm3, 0x8(%rbx)
movss %xmm2, 0xc(%rbx)
jmp 0x92666
movq -0xa8(%rbp), %rax
movss (%rax), %xmm0
addss 0xa26e(%rip), %xmm0     # 0x9c894
movss 0x8(%rax), %xmm1
movss 0x99e5(%rip), %xmm2     # 0x9c018
movaps -0x60(%rbp), %xmm5
mulss %xmm2, %xmm5
addss %xmm4, %xmm5
addss 0xa271(%rip), %xmm1     # 0x9c8b8
movaps -0x80(%rbp), %xmm3
mulss %xmm2, %xmm3
addss %xmm4, %xmm3
movss %xmm0, (%rbx)
movss %xmm5, 0x4(%rbx)
movss %xmm1, 0x8(%rbx)
movss %xmm3, 0xc(%rbx)
movl %r14d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x37444
jmp 0x927d2
movaps 0xa164(%rip), %xmm2     # 0x9c7f0
andps -0xe0(%rbp), %xmm2
movss 0xa215(%rip), %xmm1     # 0x9c8b0
ucomiss %xmm2, %xmm1
leaq 0x5163b(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
jae 0x926ba
movss 0x37c(%rax), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jbe 0x926f9
xorps %xmm1, %xmm1
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
seta %cl
leaq 0xfd0c(%rip), %rdx      # 0xa23d8
movss (%rdx,%rcx,4), %xmm0
divss -0xe0(%rbp), %xmm0
jmp 0x92701
movq %r12, %rax
movss 0x3094(%r12), %xmm2
movl -0x90(%rbp), %r15d
jmp 0x92749
xorl %r14d, %r14d
jmp 0x92529
divss 0xa1af(%rip), %xmm0     # 0x9c8b0
movl -0x90(%rbp), %r15d
movss 0x990c(%rip), %xmm1     # 0x9c01c
xorps %xmm2, %xmm2
cmpltss 0x380(%rax), %xmm2
mulss %xmm0, %xmm1
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
movq %r12, %rax
addss 0x3094(%r12), %xmm2
movss %xmm2, 0x3094(%r12)
movb $0x1, 0x3098(%r12)
movl -0xd0(%rbp), %ecx
cmpl %ecx, 0x1ca8(%rax)
jne 0x92764
cmpb $0x0, 0x1b3c(%rax)
je 0x927f2
cmpb $0x1, 0x3098(%rax)
jne 0x92801
movq -0xa0(%rbp), %rax
movss (%rax), %xmm0
movl %r15d, %edi
movss -0x34(%rbp), %xmm1
movaps %xmm2, -0xd0(%rbp)
movss -0x38(%rbp), %xmm2
movl %r13d, %esi
callq 0x94531
movaps -0xd0(%rbp), %xmm1
movaps %xmm0, %xmm3
ucomiss 0x984f(%rip), %xmm0     # 0x9bff8
jb 0x927b3
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
ja 0x927c0
xorps %xmm2, %xmm2
ucomiss %xmm3, %xmm2
jb 0x92817
ucomiss %xmm1, %xmm2
jbe 0x92817
andl $0x0, 0x3094(%r12)
movb $0x0, 0x3098(%r12)
xorl %r14d, %r14d
movaps -0x80(%rbp), %xmm1
movss -0x60(%rbp), %xmm2
movss -0x40(%rbp), %xmm5
movss -0x30(%rbp), %xmm4
movss -0x2c(%rbp), %xmm3
jmp 0x92529
callq 0x37444
movss -0x2c(%rbp), %xmm3
movss -0x30(%rbp), %xmm4
xorl %r14d, %r14d
movaps -0x80(%rbp), %xmm1
movss -0x60(%rbp), %xmm2
movss -0x40(%rbp), %xmm5
jmp 0x92529
movaps %xmm1, %xmm0
movss %xmm3, -0xc0(%rbp)
addss %xmm3, %xmm0
movss 0x97ca(%rip), %xmm1     # 0x9bff8
minss %xmm0, %xmm1
cmpltss %xmm2, %xmm0
andnps %xmm1, %xmm0
movl %r15d, %edi
movaps %xmm0, -0x90(%rbp)
movss -0x34(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movl %r13d, %esi
movss -0x2c(%rbp), %xmm3
movss -0x30(%rbp), %xmm4
callq 0x947f3
andl $0x40, %ebx
jne 0x92874
movq -0x98(%rbp), %rdi
movl %r15d, %esi
callq 0x94a30
movl %r15d, %edi
movss -0x34(%rbp), %xmm1
movss -0x38(%rbp), %xmm2
movl %r13d, %esi
movss -0x2c(%rbp), %xmm3
movss -0x30(%rbp), %xmm4
callq 0x94531
subss -0xc0(%rbp), %xmm0
xorl %eax, %eax
movaps -0xd0(%rbp), %xmm2
ucomiss %xmm2, %xmm0
setae %al
xorl %ecx, %ecx
ucomiss %xmm0, %xmm2
seta %cl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
movss 0x3094(%r12), %xmm1
cmoval %ecx, %eax
testb %al, %al
jne 0x928cc
movaps %xmm2, %xmm0
subss %xmm0, %xmm1
movss %xmm1, 0x3094(%r12)
movb $0x0, 0x3098(%r12)
movss -0x30(%rbp), %xmm4
movss -0x2c(%rbp), %xmm3
movaps -0x90(%rbp), %xmm0
jmp 0x923e2