// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: bool ImGui::SliderBehaviorT<unsigned long long, long long, double>(ImRect const&, unsigned int, int, unsigned long long*, unsigned long long, unsigned long long, 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 $0xa8, %rsp
movq %r8, %rbx
movl %esi, %r13d
movq %r8, %rax
subq %r9, %rax
negq %rax
movq %r8, -0x78(%rbp)
movq %r9, -0x80(%rbp)
subq %r9, %rbx
movl 0x18(%rbp), %r14d
cmovbq %rax, %rbx
leaq 0x514fc(%rip), %rsi     # 0xfbcd0
movl %r14d, %r12d
andl $0x100000, %r12d        # imm = 0x100000
movl %edx, -0x44(%rbp)
andl $-0x2, %edx
movl %edx, -0xc0(%rbp)
cmpl $0x8, %edx
sete %al
movl %r12d, %edx
shrl $0x12, %edx
movss (%rdi,%rdx), %xmm4
movq %rdi, -0x70(%rbp)
movss 0x8(%rdi,%rdx), %xmm2
movl %r14d, -0x84(%rbp)
andl $0x20, %r14d
shrl $0x5, %r14d
andb %al, %r14b
testq %rbx, %rbx
sets %dl
orb %al, %dl
movq (%rsi), %rdx
movaps %xmm2, %xmm5
subss %xmm4, %xmm5
addss 0xb02f(%rip), %xmm5     # 0xb5860
movss 0x15d8(%rdx), %xmm3
jne 0xaa85f
leaq 0x1(%rbx), %rax
cvtsi2ss %rax, %xmm0
movaps %xmm5, %xmm1
divss %xmm0, %xmm1
movaps %xmm3, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm3, %xmm0
orps %xmm1, %xmm0
movaps %xmm0, %xmm3
movq 0x10(%rbp), %r15
minss %xmm5, %xmm3
movaps %xmm5, %xmm8
subss %xmm3, %xmm8
addss 0xaff0(%rip), %xmm4     # 0xb5868
movss 0xa784(%rip), %xmm6     # 0xb5004
mulss %xmm3, %xmm6
xorps %xmm7, %xmm7
xorps %xmm1, %xmm1
testb %r14b, %r14b
movaps %xmm3, -0xa0(%rbp)
je 0xaa93d
movq %r15, %rdi
movl $0x3, %esi
movss %xmm2, -0x3c(%rbp)
movl %r12d, -0x34(%rbp)
movq %rcx, %r12
movss %xmm4, -0x30(%rbp)
movss %xmm5, -0x40(%rbp)
movss %xmm6, -0x38(%rbp)
movl %r13d, %r15d
movl %r14d, %r13d
movq %rdx, %r14
movss %xmm8, -0x2c(%rbp)
callq 0x97b86
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0xafa8(%rip), %xmm0     # 0xb5888
callq 0xc730
movss -0x2c(%rbp), %xmm8
movq %r14, %rdx
movl %r13d, %r14d
movl %r15d, %r13d
movss -0x38(%rbp), %xmm6
movss -0x40(%rbp), %xmm5
movss -0x30(%rbp), %xmm4
movq %r12, %rcx
movl -0x34(%rbp), %r12d
movq 0x10(%rbp), %r15
movaps -0xa0(%rbp), %xmm3
movss -0x3c(%rbp), %xmm2
movaps %xmm0, %xmm1
movss 0x15e0(%rdx), %xmm7
mulss 0xa6d7(%rip), %xmm7     # 0xb5004
movaps %xmm8, %xmm0
maxss 0xa6ab(%rip), %xmm0     # 0xb4fe4
divss %xmm0, %xmm7
addss %xmm6, %xmm4
cmpl %r13d, 0x1b30(%rdx)
jne 0xaab8b
movl 0x1b68(%rdx), %eax
cmpl $0x2, %eax
je 0xaaa5e
cmpl $0x1, %eax
jne 0xaab8b
cmpb $0x0, 0x130(%rdx)
movss %xmm2, -0x3c(%rbp)
movss %xmm4, -0x30(%rbp)
movss %xmm5, -0x40(%rbp)
movss %xmm6, -0x38(%rbp)
je 0xaab51
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm8
jbe 0xaa9ca
movl %r12d, %eax
shrl $0x14, %eax
movss 0x128(%rdx,%rax,4), %xmm0
subss %xmm4, %xmm0
divss %xmm8, %xmm0
movss 0xa633(%rip), %xmm9     # 0xb4fe4
minss %xmm0, %xmm9
movaps %xmm1, %xmm8
xorps %xmm1, %xmm1
cmpltss %xmm1, %xmm0
movaps %xmm8, %xmm1
andnps %xmm9, %xmm0
testl %r12d, %r12d
movl -0x44(%rbp), %ebx
movl 0x18(%rbp), %r13d
movq %rcx, -0x58(%rbp)
je 0xaa9e9
movss 0xa602(%rip), %xmm2     # 0xb4fe4
subss %xmm0, %xmm2
movaps %xmm2, %xmm0
movq -0x70(%rbp), %r15
andl $0x40, %r13d
movzbl %r14b, %ecx
movl %ebx, %edi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
movss %xmm1, -0x2c(%rbp)
movss %xmm7, -0x34(%rbp)
movaps %xmm7, %xmm2
callq 0xacf61
testl %r13d, %r13d
jne 0xaaa24
movq 0x10(%rbp), %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0xad10c
movss -0x30(%rbp), %xmm4
movq -0x58(%rbp), %rcx
cmpq %rax, (%rcx)
movss -0x3c(%rbp), %xmm2
movaps -0xa0(%rbp), %xmm3
movss -0x40(%rbp), %xmm5
movss -0x38(%rbp), %xmm6
movss -0x34(%rbp), %xmm7
movss -0x2c(%rbp), %xmm1
jne 0xaad4d
xorl %r13d, %r13d
jmp 0xaab92
movss %xmm1, -0x2c(%rbp)
movss %xmm7, -0x34(%rbp)
movss %xmm6, -0x38(%rbp)
movss %xmm5, -0x40(%rbp)
movss %xmm4, -0x30(%rbp)
movq %rcx, -0x58(%rbp)
movss %xmm2, -0x3c(%rbp)
cmpb $0x1, 0x1b3c(%rdx)
jne 0xaaa9a
movl $0x0, 0x3094(%rdx)
movb $0x0, 0x3098(%rdx)
movq %rdx, -0x50(%rbp)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movl $0x3, %edi
movl $0x5, %esi
callq 0x57fa4
testl %r12d, %r12d
je 0xaaac3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps 0xa4fd(%rip), %xmm0     # 0xb4fc0
ucomiss 0xad7a(%rip), %xmm0     # 0xb5844
movq -0x58(%rbp), %rcx
movss -0x34(%rbp), %xmm7
jne 0xaaadb
jnp 0xaad30
cmpl $0x8, -0xc0(%rbp)
jne 0xaacd9
movq %r15, %rdi
movl $0x3, %esi
movaps %xmm0, -0xc0(%rbp)
callq 0x97b86
movaps -0xc0(%rbp), %xmm0
movss -0x34(%rbp), %xmm7
movq -0x58(%rbp), %rcx
testl %eax, %eax
jle 0xaacd9
divss 0xad68(%rip), %xmm0     # 0xb5884
leaq 0x511ad(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movss 0x37c(%rax), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
movss -0x30(%rbp), %xmm4
movss -0x38(%rbp), %xmm6
jbe 0xaad60
divss 0xa4bc(%rip), %xmm0     # 0xb5008
jmp 0xaad60
movq %rcx, %rbx
movss %xmm7, -0x34(%rbp)
movss %xmm1, -0x2c(%rbp)
callq 0x46130
movss -0x2c(%rbp), %xmm1
movss -0x34(%rbp), %xmm7
movss -0x38(%rbp), %xmm6
movss -0x40(%rbp), %xmm5
movss -0x30(%rbp), %xmm4
movq %rbx, %rcx
movaps -0xa0(%rbp), %xmm3
movss -0x3c(%rbp), %xmm2
xorl %r13d, %r13d
movq -0x70(%rbp), %r15
movq 0x20(%rbp), %rbx
movss 0xa446(%rip), %xmm0     # 0xb4fe4
ucomiss %xmm5, %xmm0
jbe 0xaabb2
movq (%r15), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0xaacc4
movss %xmm4, -0x30(%rbp)
addss 0xaccd(%rip), %xmm2     # 0xb588c
movaps 0xa3fa(%rip), %xmm0     # 0xb4fc0
xorps %xmm3, %xmm0
movaps %xmm0, -0x70(%rbp)
subss %xmm6, %xmm2
movss %xmm2, -0x3c(%rbp)
movq (%rcx), %rsi
movzbl %r14b, %r8d
movl -0x44(%rbp), %edi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
movaps %xmm1, %xmm0
movaps %xmm7, %xmm1
callq 0xace12
testl %r12d, %r12d
je 0xaac07
movss 0xa3e4(%rip), %xmm1     # 0xb4fe4
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss -0x30(%rbp), %xmm1
movss -0x3c(%rbp), %xmm3
subss %xmm1, %xmm3
mulss %xmm0, %xmm3
addss %xmm1, %xmm3
jne 0xaac73
movss 0xa3dd(%rip), %xmm0     # 0xb5004
movaps -0x70(%rbp), %xmm5
mulss %xmm0, %xmm5
addss %xmm3, %xmm5
movss 0x4(%r15), %xmm1
movss 0xc(%r15), %xmm2
addss 0xac21(%rip), %xmm1     # 0xb5868
movaps -0xa0(%rbp), %xmm4
mulss %xmm0, %xmm4
addss %xmm3, %xmm4
addss 0xac2e(%rip), %xmm2     # 0xb588c
movss %xmm5, (%rbx)
movss %xmm1, 0x4(%rbx)
movss %xmm4, 0x8(%rbx)
movss %xmm2, 0xc(%rbx)
jmp 0xaacc4
movss (%r15), %xmm0
addss 0xabe8(%rip), %xmm0     # 0xb5868
movss 0x8(%r15), %xmm1
movss 0xa376(%rip), %xmm2     # 0xb5004
movaps -0x70(%rbp), %xmm5
mulss %xmm2, %xmm5
addss %xmm3, %xmm5
addss 0xabea(%rip), %xmm1     # 0xb588c
movaps -0xa0(%rbp), %xmm4
mulss %xmm2, %xmm4
addss %xmm3, %xmm4
movss %xmm0, (%rbx)
movss %xmm5, 0x4(%rbx)
movss %xmm1, 0x8(%rbx)
movss %xmm4, 0xc(%rbx)
movl %r13d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64(%rbx), %rdx
leaq 0x50fec(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
cmpq $0xc9, %rdx
movss -0x30(%rbp), %xmm4
movss -0x38(%rbp), %xmm6
jb 0xaad0a
movss 0x37c(%rax), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jbe 0xaad58
xorps %xmm2, %xmm2
cvtsi2ss %rbx, %xmm2
xorps %xmm1, %xmm1
xorl %esi, %esi
ucomiss %xmm0, %xmm1
seta %sil
leaq 0x10383(%rip), %rdx     # 0xbb0a8
movss (%rdx,%rsi,4), %xmm0
divss %xmm2, %xmm0
jmp 0xaad60
movq -0x50(%rbp), %rdx
movss 0x3094(%rdx), %xmm2
movss -0x30(%rbp), %xmm4
movss -0x38(%rbp), %xmm6
movss -0x2c(%rbp), %xmm1
jmp 0xaada1
movq %rax, (%rcx)
movb $0x1, %r13b
jmp 0xaab92
divss 0xab24(%rip), %xmm0     # 0xb5884
movss -0x2c(%rbp), %xmm1
movq -0x50(%rbp), %rdx
movss 0xa297(%rip), %xmm3     # 0xb5008
xorps %xmm2, %xmm2
cmpltss 0x380(%rax), %xmm2
mulss %xmm0, %xmm3
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
orps %xmm3, %xmm2
addss 0x3094(%rdx), %xmm2
movss %xmm2, 0x3094(%rdx)
movb $0x1, 0x3098(%rdx)
cmpl %r13d, 0x1ca8(%rdx)
jne 0xaadb7
cmpb $0x0, 0x1b3c(%rdx)
je 0xaae65
cmpb $0x1, 0x3098(%rdx)
jne 0xaae82
movq (%rcx), %rsi
movzbl %r14b, %r13d
movl -0x44(%rbp), %edi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
movl %r13d, %r8d
movaps %xmm1, %xmm0
movaps %xmm7, %xmm1
movaps %xmm2, -0xc0(%rbp)
callq 0xace12
movaps -0xc0(%rbp), %xmm1
movaps %xmm0, %xmm3
ucomiss 0xa1e8(%rip), %xmm0     # 0xb4fe4
jb 0xaae06
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
ja 0xaae1b
xorps %xmm2, %xmm2
ucomiss %xmm3, %xmm2
jb 0xaae9f
ucomiss %xmm1, %xmm2
jbe 0xaae9f
movq -0x50(%rbp), %rax
movl $0x0, 0x3094(%rax)
movb $0x0, 0x3098(%rax)
xorl %r13d, %r13d
movq -0x70(%rbp), %r15
movss -0x3c(%rbp), %xmm2
movaps -0xa0(%rbp), %xmm3
movq -0x58(%rbp), %rcx
movss -0x30(%rbp), %xmm4
movss -0x40(%rbp), %xmm5
movss -0x38(%rbp), %xmm6
movss -0x34(%rbp), %xmm7
movss -0x2c(%rbp), %xmm1
jmp 0xaab92
callq 0x46130
movss -0x2c(%rbp), %xmm1
movss -0x34(%rbp), %xmm7
movss -0x38(%rbp), %xmm6
movss -0x30(%rbp), %xmm4
movq -0x58(%rbp), %rcx
xorl %r13d, %r13d
movq -0x70(%rbp), %r15
movss -0x3c(%rbp), %xmm2
movaps -0xa0(%rbp), %xmm3
movss -0x40(%rbp), %xmm5
jmp 0xaab92
movaps %xmm1, %xmm0
movss %xmm3, -0xa4(%rbp)
addss %xmm3, %xmm0
movss 0xa12e(%rip), %xmm1     # 0xb4fe4
minss %xmm0, %xmm1
cmpltss %xmm2, %xmm0
andnps %xmm1, %xmm0
movl -0x44(%rbp), %ebx
movl %ebx, %edi
movaps %xmm0, -0xd0(%rbp)
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
movl %r13d, %ecx
movss -0x2c(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
callq 0xacf61
andl $0x40, -0x84(%rbp)
jne 0xaaefe
movq %r15, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0xad10c
movl %ebx, %edi
movq %rax, %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
movl %r13d, %r8d
movss -0x2c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
callq 0xace12
subss -0xa4(%rbp), %xmm0
xorl %eax, %eax
movaps -0xc0(%rbp), %xmm2
ucomiss %xmm2, %xmm0
setae %al
xorl %ecx, %ecx
ucomiss %xmm0, %xmm2
seta %cl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
movq -0x50(%rbp), %rdx
movss 0x3094(%rdx), %xmm1
cmoval %ecx, %eax
testb %al, %al
jne 0xaaf58
movaps %xmm2, %xmm0
subss %xmm0, %xmm1
movss %xmm1, 0x3094(%rdx)
movb $0x0, 0x3098(%rdx)
movq -0x70(%rbp), %r15
movl -0x44(%rbp), %ebx
movl -0x84(%rbp), %r13d
movss -0x34(%rbp), %xmm7
movss -0x2c(%rbp), %xmm1
movaps -0xd0(%rbp), %xmm0
jmp 0xaa9f1