// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderBehavior(ImRect const&, unsigned int, float*, float, float, float, int, bool)
bool ImGui::SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, bool horizontal)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    const ImGuiStyle& style = g.Style;

    // Draw frame
    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding);

    const bool is_non_linear = fabsf(power - 1.0f) > 0.0001f;

    const float grab_padding = 2.0f;
    const float slider_sz = horizontal ? (frame_bb.GetWidth() - grab_padding * 2.0f) : (frame_bb.GetHeight() - grab_padding * 2.0f);
    float grab_sz;
    if (decimal_precision > 0)
        grab_sz = ImMin(style.GrabMinSize, slider_sz);
    else
        grab_sz = ImMin(ImMax(1.0f * (slider_sz / (v_max-v_min+1.0f)), style.GrabMinSize), slider_sz);  // Integer sliders, if possible have the grab size represent 1 unit
    const float slider_usable_sz = slider_sz - grab_sz;
    const float slider_usable_pos_min = (horizontal ? frame_bb.Min.x : frame_bb.Min.y) + grab_padding + grab_sz*0.5f;
    const float slider_usable_pos_max = (horizontal ? frame_bb.Max.x : frame_bb.Max.y) - grab_padding - grab_sz*0.5f;

    // For logarithmic sliders that cross over sign boundary we want the exponential increase to be symmetric around 0.0f
    float linear_zero_pos = 0.0f;   // 0.0->1.0f
    if (v_min * v_max < 0.0f)
    {
        // Different sign
        const float linear_dist_min_to_0 = powf(fabsf(0.0f - v_min), 1.0f/power);
        const float linear_dist_max_to_0 = powf(fabsf(v_max - 0.0f), 1.0f/power);
        linear_zero_pos = linear_dist_min_to_0 / (linear_dist_min_to_0+linear_dist_max_to_0);
    }
    else
    {
        // Same sign
        linear_zero_pos = v_min < 0.0f ? 1.0f : 0.0f;
    }

    // Process clicking on the slider
    bool value_changed = false;
    if (g.ActiveId == id)
    {
        if (g.IO.MouseDown[0])
        {
            const float mouse_abs_pos = horizontal ? g.IO.MousePos.x : g.IO.MousePos.y;
            float normalized_pos = ImClamp((mouse_abs_pos - slider_usable_pos_min) / slider_usable_sz, 0.0f, 1.0f);
            if (!horizontal)
                normalized_pos = 1.0f - normalized_pos;

            float new_value;
            if (is_non_linear)
            {
                // Account for logarithmic scale on both sides of the zero
                if (normalized_pos < linear_zero_pos)
                {
                    // Negative: rescale to the negative range before powering
                    float a = 1.0f - (normalized_pos / linear_zero_pos);
                    a = powf(a, power);
                    new_value = ImLerp(ImMin(v_max,0.0f), v_min, a);
                }
                else
                {
                    // Positive: rescale to the positive range before powering
                    float a;
                    if (fabsf(linear_zero_pos - 1.0f) > 1.e-6)
                        a = (normalized_pos - linear_zero_pos) / (1.0f - linear_zero_pos);
                    else
                        a = normalized_pos;
                    a = powf(a, power);
                    new_value = ImLerp(ImMax(v_min,0.0f), v_max, a);
                }
            }
            else
            {
                // Linear slider
                new_value = ImLerp(v_min, v_max, normalized_pos);
            }

            // Round past decimal precision
            new_value = RoundScalar(new_value, decimal_precision);
            if (*v != new_value)
            {
                *v = new_value;
                value_changed = true;
            }
        }
        else
        {
            SetActiveID(0);
        }
    }

    // Calculate slider grab positioning
    float grab_t;
    if (is_non_linear)
    {
        float v_clamped = ImClamp(*v, v_min, v_max);
        if (v_clamped < 0.0f)
        {
            const float f = 1.0f - (v_clamped - v_min) / (ImMin(0.0f,v_max) - v_min);
            grab_t = (1.0f - powf(f, 1.0f/power)) * linear_zero_pos;
        }
        else
        {
            const float f = (v_clamped - ImMax(0.0f,v_min)) / (v_max - ImMax(0.0f,v_min));
            grab_t = linear_zero_pos + powf(f, 1.0f/power) * (1.0f - linear_zero_pos);
        }
    }
    else
    {
        // Linear slider
        grab_t = (ImClamp(*v, v_min, v_max) - v_min) / (v_max - v_min);
    }

    // Draw
    if (!horizontal)
        grab_t = 1.0f - grab_t;
    const float grab_pos = ImLerp(slider_usable_pos_min, slider_usable_pos_max, grab_t);
    ImRect grab_bb;
    if (horizontal)
        grab_bb = ImRect(ImVec2(grab_pos - grab_sz*0.5f, frame_bb.Min.y + grab_padding), ImVec2(grab_pos + grab_sz*0.5f, frame_bb.Max.y - grab_padding));
    else
        grab_bb = ImRect(ImVec2(frame_bb.Min.x + grab_padding, grab_pos - grab_sz*0.5f), ImVec2(frame_bb.Max.x - grab_padding, grab_pos + grab_sz*0.5f));
    window->DrawList->AddRectFilled(grab_bb.Min, grab_bb.Max, window->Color(g.ActiveId == id ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), style.GrabRounding);

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movl %ecx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq 0x596b9(%rip), %rax     # 0x794c0
movq %rax, -0x38(%rbp)
callq 0x2e220
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
movl $0x6, %esi
movss 0x3b1ce(%rip), %xmm0    # 0x5b018
callq 0x2ea40
movl %eax, %edi
movq -0x48(%rbp), %rax
movss 0x28(%rax), %xmm2
movsd -0x50(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movl $0x1, %esi
callq 0x10a20
movss -0x24(%rbp), %xmm0
movss 0x3b19d(%rip), %xmm1    # 0x5b018
subss %xmm1, %xmm0
movaps 0x3b2ba(%rip), %xmm1    # 0x5b140
pand %xmm1, %xmm0
movss 0x3b27a(%rip), %xmm1    # 0x5b10c
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x59(%rbp)
movss 0x3b213(%rip), %xmm0    # 0x5b0b8
movss %xmm0, -0x60(%rbp)
testb $0x1, -0x29(%rbp)
je 0x1fecf
movq -0x8(%rbp), %rdi
callq 0x2fe50
movss 0x3b197(%rip), %xmm1    # 0x5b058
subss %xmm1, %xmm0
movss %xmm0, -0x100(%rbp)
jmp 0x1feec
movq -0x8(%rbp), %rdi
callq 0x2f520
movss 0x3b178(%rip), %xmm1    # 0x5b058
subss %xmm1, %xmm0
movss %xmm0, -0x100(%rbp)
movss -0x100(%rbp), %xmm0
movss %xmm0, -0x64(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x1ff19
movq -0x48(%rbp), %rax
movss 0x58(%rax), %xmm0
movss -0x64(%rbp), %xmm1
callq 0xe370
movss %xmm0, -0x68(%rbp)
jmp 0x1ff61
movss -0x64(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
movss 0x3b0e8(%rip), %xmm2    # 0x5b018
addss %xmm2, %xmm0
divss %xmm0, %xmm1
movss 0x3b0d8(%rip), %xmm0    # 0x5b018
mulss %xmm1, %xmm0
movq -0x48(%rbp), %rax
movss 0x58(%rax), %xmm1
callq 0xb7c0
movss -0x64(%rbp), %xmm1
callq 0xe370
movss %xmm0, -0x68(%rbp)
movss -0x64(%rbp), %xmm0
subss -0x68(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
testb $0x1, -0x29(%rbp)
je 0x1ff88
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x104(%rbp)
jmp 0x1ff99
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x104(%rbp)
movss -0x104(%rbp), %xmm1
movss 0x3b10f(%rip), %xmm0    # 0x5b0b8
addss %xmm0, %xmm1
movss -0x68(%rbp), %xmm0
movss 0x3b06a(%rip), %xmm2    # 0x5b024
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x70(%rbp)
testb $0x1, -0x29(%rbp)
je 0x1ffe0
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x108(%rbp)
jmp 0x1fff1
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x108(%rbp)
movss -0x108(%rbp), %xmm1
movss 0x3b0b7(%rip), %xmm0    # 0x5b0b8
subss %xmm0, %xmm1
movss -0x68(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0x3b005(%rip), %xmm2    # 0x5b024
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x74(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x78(%rbp)
movss -0x1c(%rbp), %xmm1
mulss -0x20(%rbp), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x200b8
xorps %xmm0, %xmm0
subss -0x1c(%rbp), %xmm0
movaps 0x3b0eb(%rip), %xmm1    # 0x5b140
pand %xmm1, %xmm0
movss 0x3afb7(%rip), %xmm1    # 0x5b018
divss -0x24(%rbp), %xmm1
callq 0x7680
movss %xmm0, -0x7c(%rbp)
movss -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
subss %xmm1, %xmm0
movaps 0x3b0bd(%rip), %xmm1    # 0x5b140
pand %xmm1, %xmm0
movss 0x3af89(%rip), %xmm1    # 0x5b018
divss -0x24(%rbp), %xmm1
callq 0x7680
movss %xmm0, -0x80(%rbp)
movss -0x7c(%rbp), %xmm0
movss -0x7c(%rbp), %xmm1
addss -0x80(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x78(%rbp)
jmp 0x200de
movss -0x1c(%rbp), %xmm0
movss 0x3af53(%rip), %xmm3    # 0x5b018
xorps %xmm2, %xmm2
cmpltss %xmm2, %xmm0
movaps %xmm0, %xmm1
andps %xmm3, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movss %xmm0, -0x78(%rbp)
movb $0x0, -0x81(%rbp)
movq -0x38(%rbp), %rax
movl 0x1790(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2032f
movq -0x38(%rbp), %rax
testb $0x1, 0xf8(%rax)
je 0x20322
testb $0x1, -0x29(%rbp)
je 0x20125
movq -0x38(%rbp), %rax
movss 0xf0(%rax), %xmm0
movss %xmm0, -0x10c(%rbp)
jmp 0x20139
movq -0x38(%rbp), %rax
movss 0xf4(%rax), %xmm0
movss %xmm0, -0x10c(%rbp)
movss -0x10c(%rbp), %xmm0
movss %xmm0, -0x88(%rbp)
movss -0x88(%rbp), %xmm0
subss -0x70(%rbp), %xmm0
divss -0x6c(%rbp), %xmm0
xorps %xmm1, %xmm1
movss 0x3aeb2(%rip), %xmm2    # 0x5b018
callq 0xe3b0
movss %xmm0, -0x8c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x20191
movss 0x3ae97(%rip), %xmm0    # 0x5b018
subss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
testb $0x1, -0x59(%rbp)
je 0x202bd
movss -0x8c(%rbp), %xmm1
movss -0x78(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x20214
movss -0x8c(%rbp), %xmm1
divss -0x78(%rbp), %xmm1
movss 0x3ae56(%rip), %xmm0    # 0x5b018
subss %xmm1, %xmm0
movss %xmm0, -0x94(%rbp)
movss -0x94(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x7680
movss %xmm0, -0x94(%rbp)
movss -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0xe370
movss -0x1c(%rbp), %xmm1
movss -0x94(%rbp), %xmm2
callq 0x20750
movss %xmm0, -0x90(%rbp)
jmp 0x202bb
movss -0x78(%rbp), %xmm0
movss 0x3adf7(%rip), %xmm1    # 0x5b018
subss %xmm1, %xmm0
movaps 0x3af14(%rip), %xmm1    # 0x5b140
pand %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3b05c(%rip), %xmm1    # 0x5b298
ucomisd %xmm1, %xmm0
jbe 0x2026a
movss -0x8c(%rbp), %xmm0
subss -0x78(%rbp), %xmm0
movss 0x3adc1(%rip), %xmm1    # 0x5b018
subss -0x78(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x98(%rbp)
jmp 0x2027a
movss -0x8c(%rbp), %xmm0
movss %xmm0, -0x98(%rbp)
movss -0x98(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x7680
movss %xmm0, -0x98(%rbp)
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0xb7c0
movss -0x20(%rbp), %xmm1
movss -0x98(%rbp), %xmm2
callq 0x20750
movss %xmm0, -0x90(%rbp)
jmp 0x202dc
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
movss -0x8c(%rbp), %xmm2
callq 0x20750
movss %xmm0, -0x90(%rbp)
movss -0x90(%rbp), %xmm0
movl -0x28(%rbp), %edi
callq 0x1fcc0
movss %xmm0, -0x90(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
ucomiss -0x90(%rbp), %xmm0
jne 0x20309
jp 0x20309
jmp 0x20320
movss -0x90(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movb $0x1, -0x81(%rbp)
jmp 0x2032d
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xbe60
jmp 0x2032f
testb $0x1, -0x59(%rbp)
je 0x204a9
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
callq 0xe3b0
movss %xmm0, -0xa0(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xa0(%rbp), %xmm0
jbe 0x203ea
movss -0xa0(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
movss %xmm0, -0x110(%rbp)
movss -0x20(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0xe370
movss -0x110(%rbp), %xmm1
subss -0x1c(%rbp), %xmm0
divss %xmm0, %xmm1
movss 0x3ac75(%rip), %xmm0    # 0x5b018
subss %xmm1, %xmm0
movss %xmm0, -0xa4(%rbp)
movss -0xa4(%rbp), %xmm0
movss 0x3ac59(%rip), %xmm1    # 0x5b018
divss -0x24(%rbp), %xmm1
callq 0x7680
movaps %xmm0, %xmm1
movss 0x3ac44(%rip), %xmm0    # 0x5b018
subss %xmm1, %xmm0
mulss -0x78(%rbp), %xmm0
movss %xmm0, -0x9c(%rbp)
jmp 0x204a7
movss -0xa0(%rbp), %xmm0
movss %xmm0, -0x120(%rbp)
movss -0x1c(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0xb7c0
movaps %xmm0, %xmm1
movss -0x120(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x118(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x11c(%rbp)
movss -0x1c(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0xb7c0
movss -0x11c(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x118(%rbp), %xmm0
subss %xmm2, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0xa8(%rbp)
movss -0x78(%rbp), %xmm0
movss %xmm0, -0x114(%rbp)
movss -0xa8(%rbp), %xmm0
movss 0x3aba0(%rip), %xmm1    # 0x5b018
divss -0x24(%rbp), %xmm1
callq 0x7680
movss -0x114(%rbp), %xmm1
movss 0x3ab86(%rip), %xmm2    # 0x5b018
subss -0x78(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x9c(%rbp)
jmp 0x204db
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
callq 0xe3b0
subss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
subss -0x1c(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x9c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x204f9
movss 0x3ab2f(%rip), %xmm0    # 0x5b018
subss -0x9c(%rbp), %xmm0
movss %xmm0, -0x9c(%rbp)
movss -0x70(%rbp), %xmm0
movss -0x74(%rbp), %xmm1
movss -0x9c(%rbp), %xmm2
callq 0x20750
movss %xmm0, -0xac(%rbp)
leaq -0xbc(%rbp), %rdi
callq 0x2dda0
testb $0x1, -0x29(%rbp)
je 0x205ee
movss -0xac(%rbp), %xmm1
movss -0x68(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0x3aad4(%rip), %xmm2    # 0x5b024
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss 0x3ab54(%rip), %xmm1    # 0x5b0b8
addss 0x4(%rax), %xmm1
leaq -0xd4(%rbp), %rdi
callq 0x2d280
movss -0xac(%rbp), %xmm1
movss -0x68(%rbp), %xmm0
movss 0x3aa9a(%rip), %xmm2    # 0x5b024
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm1
movss 0x3ab15(%rip), %xmm2    # 0x5b0b8
subss %xmm2, %xmm1
leaq -0xdc(%rbp), %rdi
callq 0x2d280
leaq -0xcc(%rbp), %rdi
leaq -0xd4(%rbp), %rsi
leaq -0xdc(%rbp), %rdx
callq 0x2eb40
movq -0xcc(%rbp), %rax
movq %rax, -0xbc(%rbp)
movq -0xc4(%rbp), %rax
movq %rax, -0xb4(%rbp)
jmp 0x206a8
movq -0x8(%rbp), %rax
movss 0x3aabe(%rip), %xmm0    # 0x5b0b8
addss (%rax), %xmm0
movss -0xac(%rbp), %xmm2
movss -0x68(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
movss 0x3aa04(%rip), %xmm3    # 0x5b024
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0xf4(%rbp), %rdi
callq 0x2d280
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0x3aa73(%rip), %xmm1    # 0x5b0b8
subss %xmm1, %xmm0
movss -0xac(%rbp), %xmm2
movss -0x68(%rbp), %xmm1
movss 0x3a9c6(%rip), %xmm3    # 0x5b024
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0xfc(%rbp), %rdi
callq 0x2d280
leaq -0xec(%rbp), %rdi
leaq -0xf4(%rbp), %rsi
leaq -0xfc(%rbp), %rdx
callq 0x2eb40
movq -0xec(%rbp), %rax
movq %rax, -0xbc(%rbp)
movq -0xe4(%rbp), %rax
movq %rax, -0xb4(%rbp)
movq -0x40(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x138(%rbp)
leaq -0xbc(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0xbc(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x128(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x1790(%rax), %ecx
movl -0xc(%rbp), %edx
movl $0x13, %esi
movl $0x14, %eax
cmpl %edx, %ecx
cmovel %eax, %esi
movss 0x3a916(%rip), %xmm0    # 0x5b018
callq 0x2ea40
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movss 0x5c(%rax), %xmm0
movl $0xf, %r8d
callq 0x40670
movb -0x81(%rbp), %al
andb $0x1, %al
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)