LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderFrame(ImVec2, ImVec2, unsigned int, bool, float)
void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
    ImGuiWindow* window = GetCurrentWindow();

    window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
    if (border && (window->Flags & ImGuiWindowFlags_ShowBorders))
    {
        window->DrawList->AddRect(p_min+ImVec2(1,1), p_max, window->Color(ImGuiCol_BorderShadow), rounding);
        window->DrawList->AddRect(p_min, p_max-ImVec2(1,1), window->Color(ImGuiCol_Border), rounding);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movl %edi, %ecx
leaq -0x48(%rbp), %rsi
movlps %xmm0, (%rsi)
leaq -0x40(%rbp), %rdx
movlps %xmm1, (%rdx)
movq 0x43cea(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
movq 0x270(%rbx), %rdi
pushq $0xf
popq %r8
movss %xmm2, -0x2c(%rbp)
movaps %xmm2, %xmm0
callq 0x29a42
testl %r14d, %r14d
je 0xc879
testb $-0x80, 0xc(%rbx)
je 0xc879
movq 0x270(%rbx), %r13
movss 0x29bb5(%rip), %xmm0    # 0x36390
leaq -0x48(%rbp), %r14
movss (%r14), %xmm2
addss %xmm0, %xmm2
movss 0x4(%r14), %xmm1
addss %xmm0, %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x38(%rbp), %r12
movlps %xmm2, (%r12)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x1eae4
leaq -0x40(%rbp), %r15
pushq $0xf
popq %r8
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
callq 0x299ca
movq 0x270(%rbx), %r13
movss 0x29b67(%rip), %xmm0    # 0x3639c
movss (%r15), %xmm1
addss %xmm0, %xmm1
addss 0x4(%r15), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlps %xmm1, (%r12)
pushq $0x4
popq %rsi
movq %rbx, %rdi
movss 0x29b36(%rip), %xmm0    # 0x36390
callq 0x1eae4
leaq -0x38(%rbp), %rdx
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
pushq $0xf
popq %r8
callq 0x299ca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderCheckMark(ImVec2, unsigned int)
void ImGui::RenderCheckMark(ImVec2 pos, ImU32 col)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

    ImVec2 a, b, c;
    float start_x = (float)(int)(g.FontSize * 0.307f + 0.5f);
    float rem_third = (float)(int)((g.FontSize - start_x) / 3.0f);
    a.x = pos.x + 0.5f + start_x;
    b.x = a.x + rem_third;
    c.x = a.x + rem_third * 3.0f;
    b.y = pos.y - 1.0f + (float)(int)(g.Font->Ascent * (g.FontSize / g.Font->FontSize) + 0.5f) + (float)(int)(g.Font->DisplayOffset.y);
    a.y = b.y - rem_third;
    c.y = b.y - rem_third * 2.0f;

    window->DrawList->PathLineTo(a);
    window->DrawList->PathLineTo(b);
    window->DrawList->PathLineTo(c);
    window->DrawList->PathStroke(col, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x43a16(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r12
movb $0x1, 0x72(%r12)
movss 0x1718(%rax), %xmm2
movss 0x29965(%rip), %xmm1    # 0x363ec
mulss %xmm2, %xmm1
movss 0x2993d(%rip), %xmm3    # 0x363d0
addss %xmm3, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm4
movaps %xmm2, %xmm1
subss %xmm4, %xmm1
movss 0x29943(%rip), %xmm5    # 0x363f0
divss %xmm5, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movaps %xmm0, %xmm6
addss %xmm3, %xmm6
addss %xmm4, %xmm6
leaq -0x38(%rbp), %rsi
movss %xmm6, (%rsi)
mulss %xmm1, %xmm5
addss %xmm6, %xmm5
addss %xmm1, %xmm6
leaq -0x30(%rbp), %r15
movss %xmm6, (%r15)
leaq -0x28(%rbp), %rbx
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0x298ac(%rip), %xmm0    # 0x3639c
movss %xmm5, (%rbx)
movq 0x1710(%rax), %rax
divss (%rax), %xmm2
movl %edi, %r14d
mulss 0x24(%rax), %xmm2
addss %xmm3, %xmm2
cvttps2dq %xmm2, %xmm2
cvtdq2ps %xmm2, %xmm2
addss %xmm0, %xmm2
movss 0xc(%rax), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
addss %xmm2, %xmm0
movss %xmm0, 0x4(%r15)
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x4(%rsi)
addss %xmm1, %xmm1
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
movq 0x270(%r12), %rdi
addq $0x70, %rdi
callq 0x1fbe6
movq 0x270(%r12), %rdi
addq $0x70, %rdi
movq %r15, %rsi
callq 0x1fbe6
movq 0x270(%r12), %rdi
addq $0x70, %rdi
movq %rbx, %rsi
callq 0x1fbe6
movq 0x270(%r12), %rdi
movss 0x29802(%rip), %xmm0    # 0x36390
movl %r14d, %esi
xorl %edx, %edx
callq 0x1eb26
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcListClipping(int, float, int*, int*)
void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();
    if (g.LogEnabled)
    {
        // If logging is active, do not perform any clipping
        *out_items_display_start = 0;
        *out_items_display_end = items_count;
        return;
    }

    const ImVec2 pos = window->DC.CursorPos;
    int start = (int)((window->ClipRect.Min.y - pos.y) / items_height);
    int end = (int)((window->ClipRect.Max.y - pos.y) / items_height);
    start = ImClamp(start, 0, items_count);
    end = ImClamp(end + 1, start, items_count);
    *out_items_display_start = start;
    *out_items_display_end = end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x438d0(%rip), %rcx     # 0x50480
xorl %eax, %eax
cmpb $0x0, 0x2be8(%rcx)
jne 0xcc14
movq 0x1758(%rcx), %rax
movss 0xac(%rax), %xmm1
movss 0x1e4(%rax), %xmm2
subss %xmm1, %xmm2
divss %xmm0, %xmm2
cvttss2si %xmm2, %ecx
movss 0x1ec(%rax), %xmm2
subss %xmm1, %xmm2
divss %xmm0, %xmm2
cvttss2si %xmm2, %r8d
cmpl %edi, %ecx
movl %edi, %r9d
cmovll %ecx, %r9d
xorl %eax, %eax
testl %ecx, %ecx
cmovnsl %r9d, %eax
incl %r8d
cmpl %edi, %r8d
cmovll %r8d, %edi
cmpl %eax, %r8d
cmovll %eax, %edi
movl %eax, (%rsi)
movl %edi, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsKeyPressed(int, bool)
bool ImGui::IsKeyPressed(int key_index, bool repeat)
{
    ImGuiState& g = *GImGui;
    if (key_index < 0) return false;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[key_index];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
        if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %edi, %edi
js 0xcd88
cmpl $0x200, %edi            # imm = 0x200
jae 0xcd97
movq 0x43778(%rip), %r14     # 0x50480
movl %edi, %eax
movss 0x3e4(%r14,%rax,4), %xmm0
movb $0x1, %bl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xcd20
jnp 0xcd8a
testb %sil, %sil
je 0xcd88
movss 0x80(%r14), %xmm2
ucomiss %xmm2, %xmm0
jbe 0xcd88
movss 0x84(%r14), %xmm1
movss %xmm1, -0x1c(%rbp)
subss %xmm2, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x78c0
movss 0x29679(%rip), %xmm2    # 0x363d0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm2
movss %xmm2, -0x20(%rbp)
ucomiss %xmm2, %xmm0
seta %r15b
movss -0x24(%rbp), %xmm0
subss 0x10(%r14), %xmm0
callq 0x78c0
ucomiss -0x20(%rbp), %xmm0
setbe %al
cmpb %al, %r15b
je 0xcd8a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29c4e(%rip), %rdi     # 0x369ec
leaq 0x298c8(%rip), %rsi     # 0x3666d
leaq 0x29c94(%rip), %rcx     # 0x36a40
movl $0xae8, %edx            # imm = 0xAE8
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsKeyReleased(int)
bool ImGui::IsKeyReleased(int key_index)
{
    ImGuiState& g = *GImGui;
    if (key_index < 0) return false;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    if (g.IO.KeysDownDurationPrev[key_index] >= 0.0f && !g.IO.KeysDown[key_index])
        return true;
    return false;
}

// Assembly:
testl %edi, %edi
js 0xcde8
cmpl $0x200, %edi            # imm = 0x200
jae 0xcdeb
movq 0x436b7(%rip), %rcx     # 0x50480
movl %edi, %edx
movss 0xbe4(%rcx,%rdx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xcde8
movb $0x1, %al
cmpb $0x1, 0x108(%rcx,%rdx)
jne 0xcdea
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x29bf6(%rip), %rdi     # 0x369ec
leaq 0x29870(%rip), %rsi     # 0x3666d
leaq 0x29c60(%rip), %rcx     # 0x36a64
movl $0xafa, %edx            # imm = 0xAFA
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseClicked(int, bool)
bool ImGui::IsMouseClicked(int button, bool repeat)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    const float t = g.IO.MouseDownDuration[button];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
        if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
            return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x5, %edi
jae 0xcef3
movq 0x4361c(%rip), %r14     # 0x50480
movl %edi, %eax
movss 0x3a8(%r14,%rax,4), %xmm0
movb $0x1, %bl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xce7c
jnp 0xcee6
testb %sil, %sil
je 0xcee4
movss 0x80(%r14), %xmm2
ucomiss %xmm2, %xmm0
jbe 0xcee4
movss 0x84(%r14), %xmm1
movss %xmm1, -0x1c(%rbp)
subss %xmm2, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x78c0
movss 0x2951d(%rip), %xmm2    # 0x363d0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm2
movss %xmm2, -0x20(%rbp)
ucomiss %xmm2, %xmm0
seta %r15b
movss -0x24(%rbp), %xmm0
subss 0x10(%r14), %xmm0
callq 0x78c0
ucomiss -0x20(%rbp), %xmm0
setbe %al
cmpb %al, %r15b
je 0xcee6
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29b89(%rip), %rdi     # 0x36a83
leaq 0x2976c(%rip), %rsi     # 0x3666d
leaq 0x29be8(%rip), %rcx     # 0x36af0
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseDragging(int, float)
bool ImGui::IsMouseDragging(int button, float lock_threshold)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (!g.IO.MouseDown[button])
        return false;
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    return g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold;
}

// Assembly:
cmpl $0x5, %edi
jae 0xcfc0
movq 0x434f0(%rip), %rax     # 0x50480
movl %edi, %ecx
cmpb $0x1, 0xf8(%rax,%rcx)
jne 0xcfbd
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xcfa9
movss 0x30(%rax), %xmm0
movss 0x3d0(%rax,%rcx,4), %xmm1
mulss %xmm0, %xmm0
ucomiss %xmm0, %xmm1
setae %al
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x29ab8(%rip), %rdi     # 0x36a83
leaq 0x2969b(%rip), %rsi     # 0x3666d
leaq 0x29b84(%rip), %rcx     # 0x36b5d
movl $0xb2a, %edx            # imm = 0xB2A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetMousePosOnOpeningCurrentPopup()
ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup()
{
    ImGuiState& g = *GImGui;
    if (g.CurrentPopupStack.Size > 0)
        return g.OpenedPopupStack[g.CurrentPopupStack.Size-1].MousePosOnOpen;
    return g.IO.MousePos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x4347d(%rip), %rax     # 0x50480
movl 0x1808(%rax), %esi
testl %esi, %esi
jle 0xd023
addq $0x17f8, %rax           # imm = 0x17F8
decl %esi
movq %rax, %rdi
callq 0x1ebd4
addq $0x1c, %rax
jmp 0xd029
addq $0xf0, %rax
movsd (%rax), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetMouseDragDelta(int, float)
ImVec2 ImGui::GetMouseDragDelta(int button, float lock_threshold)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    if (g.IO.MouseDown[button])
        if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
            return g.IO.MousePos - g.IO.MouseClickedPos[button];     // Assume we can only get active with left-mouse button (at the moment).
    return ImVec2(0.0f, 0.0f);
}

// Assembly:
cmpl $0x5, %edi
jae 0xd092
movaps %xmm0, %xmm1
movq 0x43442(%rip), %rax     # 0x50480
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0xd04b
movss 0x30(%rax), %xmm1
movl %edi, %ecx
xorps %xmm0, %xmm0
cmpb $0x1, 0xf8(%rax,%rcx)
jne 0xd091
movss 0x3d0(%rax,%rcx,4), %xmm2
mulss %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jb 0xd091
movss 0xf0(%rax), %xmm0
subss 0x35c(%rax,%rcx,8), %xmm0
movss 0xf4(%rax), %xmm1
subss 0x360(%rax,%rcx,8), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x299e6(%rip), %rdi     # 0x36a83
leaq 0x295c9(%rip), %rsi     # 0x3666d
leaq 0x29ada(%rip), %rcx     # 0x36b85
movl $0xb43, %edx            # imm = 0xB43
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ResetMouseDragDelta(int)
void ImGui::ResetMouseDragDelta(int button)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    // NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
    g.IO.MouseClickedPos[button] = g.IO.MousePos;
}

// Assembly:
cmpl $0x5, %edi
jae 0xd0d3
movq 0x433bf(%rip), %rax     # 0x50480
movl %edi, %ecx
movq 0xf0(%rax), %rdx
movq %rdx, 0x35c(%rax,%rcx,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x299a5(%rip), %rdi     # 0x36a83
leaq 0x29588(%rip), %rsi     # 0x3666d
leaq 0x29ac5(%rip), %rcx     # 0x36bb1
movl $0xb4f, %edx            # imm = 0xB4F
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsItemActive()
bool ImGui::IsItemActive()
{
    ImGuiState& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = GetCurrentWindowRead();
        return g.ActiveId == window->DC.LastItemID;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x432fd(%rip), %rax     # 0x50480
movl 0x1790(%rax), %ecx
testl %ecx, %ecx
je 0xd19f
movq 0x1758(%rax), %rax
cmpl 0xe0(%rax), %ecx
sete %al
jmp 0xd1a1
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemRectClosestPoint(ImVec2 const&, bool, float)
ImVec2 ImGui::CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge, float outward)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImRect rect = window->DC.LastItemRect;
    rect.Expand(outward);
    return rect.GetClosestPoint(pos, on_edge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x431f0(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rax
movups 0xe4(%rax), %xmm1
leaq -0x10(%rbp), %rax
movaps %xmm1, (%rax)
movss (%rax), %xmm1
movss 0x4(%rax), %xmm2
subss %xmm0, %xmm1
movss %xmm1, (%rax)
subss %xmm0, %xmm2
movss %xmm2, 0x4(%rax)
movss 0x8(%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rax)
addss 0xc(%rax), %xmm0
movss %xmm0, 0xc(%rax)
movsd (%rdi), %xmm0
movq %rax, %rdi
callq 0x1ec08
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::OpenPopup(char const*)
void ImGui::OpenPopup(const char* str_id)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetID(str_id);
    int current_stack_size = g.CurrentPopupStack.Size;
    ImGuiPopupRef popup_ref = ImGuiPopupRef(id, window, window->GetID("##menus"), g.IO.MousePos); // Tagged as new ref because constructor sets Window to NULL (we are passing the ParentWindow info here)
    if (g.OpenedPopupStack.Size < current_stack_size + 1)
        g.OpenedPopupStack.push_back(popup_ref);
    else if (g.OpenedPopupStack[current_stack_size].PopupID != id)
    {
        g.OpenedPopupStack.resize(current_stack_size+1);
        g.OpenedPopupStack[current_stack_size] = popup_ref;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
movq 0x40d89(%rip), %r12     # 0x50480
movq 0x1758(%r12), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x9858
movl %eax, %r14d
movl 0x1808(%r12), %ebx
leaq 0x27517(%rip), %rsi     # 0x36c32
movq %r15, %rdi
xorl %edx, %edx
callq 0x9858
movl %r14d, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movq %r15, -0x38(%rbp)
movl %eax, -0x30(%rbp)
movq 0xf0(%r12), %rax
movq %rax, -0x2c(%rbp)
leaq 0x17f8(%r12), %r15
cmpl %ebx, 0x17f8(%r12)
jle 0xf78e
movq %r15, %rdi
movl %ebx, %esi
callq 0x1ebd4
cmpl %r14d, (%rax)
je 0xf79a
leal 0x1(%rbx), %esi
movq %r15, %rdi
callq 0x1e80c
movq %r15, %rdi
movl %ebx, %esi
callq 0x1ebd4
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x20(%rax)
jmp 0xf79a
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x1ec70
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CloseCurrentPopup()
void ImGui::CloseCurrentPopup()
{
    ImGuiState& g = *GImGui;
    int popup_idx = g.CurrentPopupStack.Size - 1;
    if (popup_idx < 0 || popup_idx > g.OpenedPopupStack.Size || g.CurrentPopupStack[popup_idx].PopupID != g.OpenedPopupStack[popup_idx].PopupID)
        return;
    while (popup_idx > 0 && g.OpenedPopupStack[popup_idx].Window && (g.OpenedPopupStack[popup_idx].Window->Flags & ImGuiWindowFlags_ChildMenu))
        popup_idx--;
    ClosePopupToLevel(popup_idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40cc8(%rip), %r14     # 0x50480
movl 0x1808(%r14), %ebx
testl %ebx, %ebx
jle 0xf822
decl %ebx
cmpl 0x17f8(%r14), %ebx
jg 0xf822
leaq 0x1808(%r14), %rdi
addq $0x17f8, %r14           # imm = 0x17F8
movl %ebx, %esi
callq 0x1ebd4
movl (%rax), %r15d
movq %r14, %rdi
movl %ebx, %esi
callq 0x1ebd4
cmpl (%rax), %r15d
jne 0xf822
testl %ebx, %ebx
jle 0xf82d
movq %r14, %rdi
movl %ebx, %esi
callq 0x1ebd4
cmpq $0x0, 0x8(%rax)
je 0xf82f
movq %r14, %rdi
movl %ebx, %esi
callq 0x1ebd4
movq 0x8(%rax), %rax
testb $0x8, 0xf(%rax)
je 0xf82f
decl %ebx
jmp 0xf7f5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf83d
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: BeginPopupEx(char const*, int)
static bool BeginPopupEx(const char* str_id, ImGuiWindowFlags extra_flags)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(str_id);
    if (!IsPopupOpen(id))
    {
        ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
        return false;
    }

    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
    ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_AlwaysAutoResize;

    char name[32];
    if (flags & ImGuiWindowFlags_ChildMenu)
        ImFormatString(name, 20, "##menu_%d", g.CurrentPopupStack.Size);    // Recycle windows based on depth
    else
        ImFormatString(name, 20, "##popup_%08x", id); // Not recycling, so we can close/open during the same frame
    float alpha = 1.0f;

    bool opened = ImGui::Begin(name, NULL, ImVec2(0.0f, 0.0f), alpha, flags);
    if (!(window->Flags & ImGuiWindowFlags_ShowBorders))
        g.CurrentWindow->Flags &= ~ImGuiWindowFlags_ShowBorders;
    if (!opened) // opened can be 'false' when the popup is completely clipped (e.g. zero size display)
        ImGui::EndPopup();

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %rsi
movq 0x40bc7(%rip), %r13     # 0x50480
movq 0x1758(%r13), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9858
movl %eax, %r15d
movl %eax, %edi
callq 0xfa41
testb %al, %al
je 0xf907
pushq $0x2
popq %rdi
xorps %xmm0, %xmm0
callq 0x10054
movl %r12d, %r14d
orl $0x2000147, %r14d       # imm = 0x2000147
btl $0x1b, %r12d
jb 0xf924
leaq 0x2839b(%rip), %rdx     # 0x37c96
leaq -0x50(%rbp), %rdi
pushq $0x14
popq %rsi
movl %r15d, %ecx
jmp 0xf939
movq 0x40b72(%rip), %rax     # 0x50480
xorps %xmm0, %xmm0
movups %xmm0, 0x1834(%rax)
movb $0x0, 0x1844(%rax)
xorl %r14d, %r14d
jmp 0xf97f
movl 0x1808(%r13), %ecx
leaq 0x2835a(%rip), %rdx     # 0x37c8c
leaq -0x50(%rbp), %rdi
pushq $0x14
popq %rsi
xorl %eax, %eax
callq 0x83b1
leaq -0x30(%rbp), %rdx
andq $0x0, (%rdx)
leaq -0x50(%rbp), %rdi
movss 0x26a3c(%rip), %xmm0    # 0x36390
xorl %esi, %esi
movl %r14d, %ecx
callq 0xd385
movl %eax, %r14d
testb $-0x80, 0xc(%rbx)
jne 0xf975
movq 0x1758(%r13), %rax
andl $0xffffff7f, 0xc(%rax)  # imm = 0xFFFFFF7F
testb %r14b, %r14b
jne 0xf97f
callq 0xfa7a
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupModal(char const*, bool*, int)
bool ImGui::BeginPopupModal(const char* name, bool* p_opened, ImGuiWindowFlags extra_flags)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(name);
    if (!IsPopupOpen(id))
    {
        ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
        return false;
    }

    ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_Modal|ImGuiWindowFlags_NoCollapse|ImGuiWindowFlags_NoSavedSettings;
    bool opened = ImGui::Begin(name, p_opened, ImVec2(0.0f, 0.0f), -1.0f, flags);
    if (!opened || (p_opened && !*p_opened)) // Opened can be 'false' when the popup is completely clipped (e.g. zero size display)
    {
        ImGui::EndPopup();
        if (opened)
            ClosePopup(id);
        return false;
    }

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movq 0x40ad0(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x9858
movl %eax, %r14d
movl %eax, %edi
callq 0xfa41
testb %al, %al
je 0xfa13
orl $0x6000120, %r15d       # imm = 0x6000120
leaq -0x28(%rbp), %rdx
andq $0x0, (%rdx)
movss 0x269b6(%rip), %xmm0    # 0x3639c
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %ecx
callq 0xd385
testb %al, %al
je 0xfa2d
movb $0x1, %al
testq %rbx, %rbx
je 0xfa34
cmpb $0x0, (%rbx)
jne 0xfa34
callq 0xfa7a
movl %r14d, %edi
callq 0xfaff
jmp 0xfa32
movq 0x40a66(%rip), %rax     # 0x50480
xorps %xmm0, %xmm0
movups %xmm0, 0x1834(%rax)
movb $0x0, 0x1844(%rax)
jmp 0xfa32
callq 0xfa7a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::EndPopup()
void ImGui::EndPopup()
{
    ImGuiWindow* window = GetCurrentWindow();
    IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup);
    IM_ASSERT(GImGui->CurrentPopupStack.Size > 0);
    ImGui::End();
    if (!(window->Flags & ImGuiWindowFlags_Modal))
        ImGui::PopStyleVar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x409f9(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
testb $0x2, 0xf(%rbx)
je 0xfac1
cmpl $0x0, 0x1808(%rax)
jle 0xfae0
callq 0xb516
testb $0x4, 0xf(%rbx)
jne 0xfaba
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xfb23
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x27172(%rip), %rdi     # 0x36c3a
leaq 0x26b9e(%rip), %rsi     # 0x3666d
leaq 0x2718b(%rip), %rcx     # 0x36c61
movl $0xc71, %edx            # imm = 0xC71
callq 0x7140
leaq 0x27191(%rip), %rdi     # 0x36c78
leaq 0x26b7f(%rip), %rsi     # 0x3666d
leaq 0x2716c(%rip), %rcx     # 0x36c61
movl $0xc72, %edx            # imm = 0xC72
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopStyleVar(int)
void ImGui::PopStyleVar(int count)
{
    ImGuiState& g = *GImGui;
    while (count > 0)
    {
        ImGuiStyleMod& backup = g.StyleModifiers.back();
        if (float* pvar_f = GetStyleVarFloatAddr(backup.Var))
            *pvar_f = backup.PreviousValue.x;
        else if (ImVec2* pvar_v = GetStyleVarVec2Addr(backup.Var))
            *pvar_v = backup.PreviousValue;
        g.StyleModifiers.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movl $0x17d8, %r14d          # imm = 0x17D8
addq 0x40943(%rip), %r14     # 0x50480
testl %ebx, %ebx
jle 0xfb88
movq %r14, %rdi
callq 0x1f3d2
movq %rax, %r15
movl (%rax), %r12d
movl %r12d, %edi
callq 0x11655
testq %rax, %rax
je 0xfb68
movss 0x4(%r15), %xmm0
movss %xmm0, (%rax)
jmp 0xfb7c
movl %r12d, %edi
callq 0x11721
testq %rax, %rax
je 0xfb7c
movq 0x4(%r15), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x1f40e
decl %ebx
jmp 0xfb3d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupContextWindow(bool, char const*, int)
bool ImGui::BeginPopupContextWindow(bool also_over_items, const char* str_id, int mouse_button)
{
    if (!str_id) str_id = "window_context_menu";
    if (ImGui::IsMouseHoveringWindow() && ImGui::IsMouseClicked(mouse_button))
        if (also_over_items || !ImGui::IsAnyItemHovered())
            ImGui::OpenPopup(str_id);
    return ImGui::BeginPopup(str_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
leaq 0x270b6(%rip), %rbx     # 0x36c9b
cmovneq %rsi, %rbx
movq 0x40890(%rip), %rax     # 0x50480
movq 0x1778(%rax), %rcx
cmpq 0x1758(%rax), %rcx
jne 0xfc38
movl %edi, %r14d
movl %edx, %edi
xorl %esi, %esi
callq 0xce47
testb %al, %al
je 0xfc38
testb %r14b, %r14b
je 0xfc1f
movq %rbx, %rdi
callq 0xf6de
jmp 0xfc38
movq 0x4085a(%rip), %rax     # 0x50480
cmpl $0x0, 0x1788(%rax)
jne 0xfc38
cmpl $0x0, 0x178c(%rax)
je 0xfc15
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xf88f
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupContextVoid(char const*, int)
bool ImGui::BeginPopupContextVoid(const char* str_id, int mouse_button)
{
    if (!str_id) str_id = "void_context_menu";
    if (!ImGui::IsMouseHoveringAnyWindow() && ImGui::IsMouseClicked(mouse_button))
        ImGui::OpenPopup(str_id);
    return ImGui::BeginPopup(str_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
leaq 0x2705b(%rip), %rbx     # 0x36caf
cmovneq %rdi, %rbx
movq 0x40821(%rip), %rax     # 0x50480
cmpq $0x0, 0x1778(%rax)
jne 0xfc7e
movl %esi, %edi
xorl %esi, %esi
callq 0xce47
testb %al, %al
je 0xfc7e
movq %rbx, %rdi
callq 0xf6de
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf88f
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::EndChild()
void ImGui::EndChild()
{
    ImGuiWindow* window = GetCurrentWindow();

    IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow);
    if ((window->Flags & ImGuiWindowFlags_ComboBox) || window->BeginCount > 1)
    {
        ImGui::End();
    }
    else
    {
        // When using auto-filling child window, we don't provide full width/height to ItemSize so that it doesn't feed back into automatic size-fitting.
        ImGuiState& g = *GImGui;
        ImVec2 sz = ImGui::GetWindowSize();
        if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitX) // Arbitrary minimum zeroish child size of 4.0f
            sz.x = ImMax(4.0f, sz.x - g.Style.WindowPadding.x);
        if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitY)
            sz.y = ImMax(4.0f, sz.y - g.Style.WindowPadding.y);

        ImGui::End();

        window = GetCurrentWindow();
        ImRect bb(window->DC.CursorPos, window->DC.CursorPos + sz);
        ItemSize(sz);
        ItemAdd(bb, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq 0x40601(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rdx
movb $0x1, 0x72(%rdx)
movl 0xc(%rdx), %ecx
btl $0x14, %ecx
jae 0xff73
btl $0x17, %ecx
jb 0xfea3
cmpl $0x2, 0x78(%rdx)
jl 0xfeae
addq $0x38, %rsp
popq %rbx
popq %rbp
jmp 0xb516
movsd 0x20(%rdx), %xmm1
movsd %xmm1, -0x10(%rbp)
btl $0x15, %ecx
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
jae 0xfee5
movss 0x13ec(%rax), %xmm0
subss %xmm0, %xmm1
movss 0x264db(%rip), %xmm0    # 0x363b4
maxss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movaps %xmm0, %xmm1
btl $0x16, %ecx
movaps %xmm1, -0x30(%rbp)
jb 0xfef5
movaps %xmm2, -0x20(%rbp)
jmp 0xff12
subss 0x13f0(%rax), %xmm2
movss 0x264af(%rip), %xmm0    # 0x363b4
maxss %xmm2, %xmm0
movss %xmm0, -0xc(%rbp)
movaps %xmm0, -0x20(%rbp)
callq 0xb516
movq 0x40562(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
movaps -0x30(%rbp), %xmm0
addss 0xa8(%rax), %xmm0
movaps -0x20(%rbp), %xmm1
addss 0xac(%rax), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0xa8(%rax), %rax
leaq -0x40(%rbp), %rbx
movq %rax, (%rbx)
movlps %xmm0, 0x8(%rbx)
leaq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x99d9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9b28
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x26d58(%rip), %rdi     # 0x36cd2
leaq 0x266ec(%rip), %rsi     # 0x3666d
leaq 0x26d77(%rip), %rcx     # 0x36cff
movl $0xcbf, %edx            # imm = 0xCBF
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginChildFrame(unsigned int, ImVec2 const&)
bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size)
{
    ImGuiState& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    ImGui::PushStyleColor(ImGuiCol_ChildWindowBg, style.Colors[ImGuiCol_FrameBg]);
    ImGui::PushStyleVar(ImGuiStyleVar_ChildWindowRounding, style.FrameRounding);
    return ImGui::BeginChild(id, size, false, ImGuiWindowFlags_NoMove);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq 0x404be(%rip), %r15     # 0x50480
leaq 0x14c0(%r15), %rsi
pushq $0x3
popq %rdi
callq 0x10000
movss 0x1410(%r15), %xmm0
pushq $0x4
popq %r15
movl %r15d, %edi
callq 0x10054
movl %r14d, %edi
movq %rbx, %rsi
xorl %edx, %edx
movl %r15d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfe21
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleColor(int, ImVec4 const&)
void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
    ImGuiState& g = *GImGui;
    ImGuiColMod backup;
    backup.Col = idx;
    backup.PreviousValue = g.Style.Colors[idx];
    g.ColorModifiers.push_back(backup);
    g.Style.Colors[idx] = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x40469(%rip), %r14     # 0x50480
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
movslq %edi, %r15
shlq $0x4, %r15
movups 0x1460(%r14,%r15), %xmm0
movups %xmm0, 0x4(%rsi)
leaq 0x17c8(%r14), %rdi
callq 0x1f2ac
movups (%rbx), %xmm0
movups %xmm0, 0x1460(%r14,%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, float)
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
    ImGuiState& g = *GImGui;
    float* pvar = GetStyleVarFloatAddr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a float.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = ImVec2(*pvar, 0.0f);
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x14(%rbp)
movl %edi, %r14d
callq 0x11655
testq %rax, %rax
je 0x100a7
movq %rax, %rbx
movl $0x17d8, %edi           # imm = 0x17D8
addq 0x40400(%rip), %rdi     # 0x50480
leaq -0x20(%rbp), %rsi
movl %r14d, (%rsi)
movl (%rax), %eax
movl %eax, 0x4(%rsi)
andl $0x0, 0x8(%rsi)
callq 0x1f374
movss -0x14(%rbp), %xmm0
movss %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x26d7a(%rip), %rdi     # 0x36e28
leaq 0x265b8(%rip), %rsi     # 0x3666d
leaq 0x26d7b(%rip), %rcx     # 0x36e37
movl $0x10e2, %edx           # imm = 0x10E2
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopStyleColor(int)
void ImGui::PopStyleColor(int count)
{
    ImGuiState& g = *GImGui;
    while (count > 0)
    {
        ImGuiColMod& backup = g.ColorModifiers.back();
        g.Style.Colors[backup.Col] = backup.PreviousValue;
        g.ColorModifiers.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x40385(%rip), %r15     # 0x50480
leaq 0x17c8(%r15), %r14
addq $0x1460, %r15           # imm = 0x1460
testl %ebx, %ebx
jle 0x10131
movq %r14, %rdi
callq 0x1f30a
movslq (%rax), %rcx
shlq $0x4, %rcx
movups 0x4(%rax), %xmm0
movups %xmm0, (%r15,%rcx)
movq %r14, %rdi
callq 0x1f346
decl %ebx
jmp 0x10109
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindWindowByName(char const*)
static ImGuiWindow* FindWindowByName(const char* name)
{
    // FIXME-OPT: Store sorted hashes -> pointers.
    ImGuiState& g = *GImGui;
    ImGuiID id = ImHash(name, 0);
    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i]->ID == id)
            return g.Windows[i];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1738, %r14d          # imm = 0x1738
addq 0x4032c(%rip), %r14     # 0x50480
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x846d
movl %eax, %r12d
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x10191
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e6f4
movq (%rax), %rax
cmpl %r12d, 0x8(%rax)
je 0x10183
incl %r15d
jmp 0x10165
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e6f4
movq (%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetCurrentWindow(ImGuiWindow*)
static void SetCurrentWindow(ImGuiWindow* window)
{
    ImGuiState& g = *GImGui;
    g.CurrentWindow = window;
    if (window)
        g.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x402d8(%rip), %rax     # 0x50480
movq %rdi, 0x1758(%rax)
testq %rdi, %rdi
je 0x101cc
movss 0x171c(%rax), %xmm0
mulss 0x268(%rdi), %xmm0
movss %xmm0, 0x1718(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: PushClipRect(ImRect const&, bool)
static void PushClipRect(const ImRect& clip_rect, bool clipped)
{
    ImGuiWindow* window = ImGui::GetCurrentWindow();

    ImRect cr = clip_rect;
    if (clipped)
    {
        // Clip our argument with the current clip rect
        cr.Clip(window->ClipRect);
    }
    cr.Max.x = ImMax(cr.Min.x, cr.Max.x);
    cr.Max.y = ImMax(cr.Min.y, cr.Max.y);

    IM_ASSERT(cr.Min.x <= cr.Max.x && cr.Min.y <= cr.Max.y);
    window->ClipRect = cr;
    window->DrawList->PushClipRect(ImVec4(cr.Min.x, cr.Min.y, cr.Max.x, cr.Max.y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq 0x400c1(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
movups (%rdi), %xmm0
movaps %xmm0, -0x20(%rbp)
testl %esi, %esi
je 0x103e5
leaq 0x1e0(%rbx), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1eb52
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x18(%rbp), %xmm3
movaps %xmm3, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm4
andps %xmm0, %xmm4
andnps %xmm3, %xmm2
orps %xmm4, %xmm2
movss %xmm2, -0x18(%rbp)
movss -0x14(%rbp), %xmm4
movaps %xmm4, %xmm3
cmpless %xmm1, %xmm3
movaps %xmm3, %xmm5
andps %xmm1, %xmm5
andnps %xmm4, %xmm3
orps %xmm5, %xmm3
movss %xmm3, -0x14(%rbp)
ucomiss %xmm0, %xmm2
jb 0x1046a
ucomiss %xmm1, %xmm3
jb 0x1046a
movaps -0x20(%rbp), %xmm4
movups %xmm4, 0x1e0(%rbx)
movq 0x270(%rbx), %rdi
leaq -0x30(%rbp), %rsi
movss %xmm0, (%rsi)
movss %xmm1, 0x4(%rsi)
movss %xmm2, 0x8(%rsi)
movss %xmm3, 0xc(%rsi)
callq 0x27d8a
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x27871(%rip), %rdi     # 0x37ce2
leaq 0x261f5(%rip), %rsi     # 0x3666d
leaq 0x27890(%rip), %rcx     # 0x37d0f
movl $0x8cd, %edx            # imm = 0x8CD
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetVisibleRect()
static ImRect GetVisibleRect()
{
    ImGuiState& g = *GImGui;
    if (g.IO.DisplayVisibleMin.x != g.IO.DisplayVisibleMax.x && g.IO.DisplayVisibleMin.y != g.IO.DisplayVisibleMax.y)
        return ImRect(g.IO.DisplayVisibleMin, g.IO.DisplayVisibleMax);
    return ImRect(0.0f, 0.0f, g.IO.DisplaySize.x, g.IO.DisplaySize.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3ffec(%rip), %rax     # 0x50480
movss 0xa8(%rax), %xmm0
ucomiss 0xb0(%rax), %xmm0
jne 0x104a7
jnp 0x104cc
movss 0xac(%rax), %xmm0
ucomiss 0xb4(%rax), %xmm0
jne 0x104ba
jnp 0x104cc
movsd 0xa8(%rax), %xmm0
movsd 0xb0(%rax), %xmm1
jmp 0x104d4
movsd 0x8(%rax), %xmm1
xorps %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogFinish()
void ImGui::LogFinish()
{
    ImGuiState& g = *GImGui;
    if (!g.LogEnabled)
        return;

    ImGui::LogText(IM_NEWLINE);
    g.LogEnabled = false;
    if (g.LogFile != NULL)
    {
        if (g.LogFile == stdout)
            fflush(g.LogFile);
        else
            fclose(g.LogFile);
        g.LogFile = NULL;
    }
    if (g.LogClipboard->size() > 1)
    {
        if (g.IO.SetClipboardTextFn)
            g.IO.SetClipboardTextFn(g.LogClipboard->begin());
        g.LogClipboard->clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3f188(%rip), %rbx     # 0x50480
cmpb $0x1, 0x2be8(%rbx)
jne 0x11375
leaq 0x29320(%rip), %rdi     # 0x3a628
xorl %eax, %eax
callq 0xc0ac
movb $0x0, 0x2be8(%rbx)
movq 0x2bf0(%rbx), %rdi
testq %rdi, %rdi
je 0x11342
movq 0x3ecaf(%rip), %rax     # 0x4ffd8
cmpq (%rax), %rdi
je 0x11335
callq 0x7350
jmp 0x1133a
callq 0x73c0
andq $0x0, 0x2bf0(%rbx)
movq 0x2bf8(%rbx), %rdi
cmpl $0x3, (%rdi)
jl 0x11375
movq 0xc8(%rbx), %r14
testq %r14, %r14
je 0x1136c
callq 0x1fd62
movq %rax, %rdi
callq *%r14
movq 0x2bf8(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1f472
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemWidth()
float ImGui::CalcItemWidth()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    float w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        // Align to a right-side limit. We include 1 frame padding in the calculation because this is how the width is always used (we add 2 frame padding to it), but we could move that responsibility to the widget as well.
        ImGuiState& g = *GImGui;
        float width_to_right_edge = ImGui::GetContentRegionAvail().x;
        w = ImMax(1.0f, width_to_right_edge + w - g.Style.FramePadding.x * 2.0f);
    }
    w = (float)(int)w;
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq 0x3f0f6(%rip), %rbx     # 0x50480
movq 0x1758(%rbx), %rax
movss 0x11c(%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x113d1
movaps %xmm1, -0x20(%rbp)
callq 0xfdd2
movaps -0x20(%rbp), %xmm1
addss %xmm0, %xmm1
movss 0x1408(%rbx), %xmm0
addss %xmm0, %xmm0
subss %xmm0, %xmm1
movss 0x24fc6(%rip), %xmm0    # 0x36390
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushFont(ImFont*)
void ImGui::PushFont(ImFont* font)
{
    ImGuiState& g = *GImGui;
    if (!font)
        font = g.IO.Fonts->Fonts[0];
    SetCurrentFont(font);
    g.FontStack.push_back(font);
    g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, -0x18(%rbp)
movq 0x3f08b(%rip), %r14     # 0x50480
testq %rdi, %rdi
jne 0x11413
movq 0x90(%r14), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1e75e
movq (%rax), %rdi
movq %rdi, -0x18(%rbp)
callq 0xad87
leaq 0x17e8(%r14), %rdi
leaq -0x18(%rbp), %rbx
movq %rbx, %rsi
callq 0x1f140
movq 0x1758(%r14), %rax
movq 0x270(%rax), %rdi
movq (%rbx), %rax
movq 0x30(%rax), %rsi
callq 0x27e64
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopFont()
void  ImGui::PopFont()
{
    ImGuiState& g = *GImGui;
    g.CurrentWindow->DrawList->PopTextureID();
    g.FontStack.pop_back();
    SetCurrentFont(g.FontStack.empty() ? g.IO.Fonts->Fonts[0] : g.FontStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3f024(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rax
movq 0x270(%rax), %rdi
callq 0x27e84
leaq 0x17e8(%r14), %rbx
movq %rbx, %rdi
callq 0x1f192
cmpl $0x0, 0x17e8(%r14)
je 0x11492
movq %rbx, %rdi
callq 0x1f1c0
jmp 0x114a4
movq 0x90(%r14), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1e75e
movq (%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xad87
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetStyleVarFloatAddr(int)
static float* GetStyleVarFloatAddr(ImGuiStyleVar idx)
{
    ImGuiState& g = *GImGui;
    switch (idx)
    {
    case ImGuiStyleVar_Alpha: return &g.Style.Alpha;
    case ImGuiStyleVar_WindowRounding: return &g.Style.WindowRounding;
    case ImGuiStyleVar_ChildWindowRounding: return &g.Style.ChildWindowRounding;
    case ImGuiStyleVar_FrameRounding: return &g.Style.FrameRounding;
    case ImGuiStyleVar_IndentSpacing: return &g.Style.IndentSpacing;
    case ImGuiStyleVar_GrabMinSize: return &g.Style.GrabMinSize;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl $0xa, %edi
ja 0x116b0
movq 0x3ee19(%rip), %rcx     # 0x50480
movl %edi, %edx
leaq 0x24e24(%rip), %rsi     # 0x36494
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
addq $0x13e8, %rcx           # imm = 0x13E8
jmp 0x116ad
addq $0x1404, %rcx           # imm = 0x1404
jmp 0x116ad
addq $0x1440, %rcx           # imm = 0x1440
jmp 0x116ad
addq $0x13fc, %rcx           # imm = 0x13FC
jmp 0x116ad
addq $0x1410, %rcx           # imm = 0x1410
jmp 0x116ad
addq $0x1430, %rcx           # imm = 0x1430
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    ImGuiState& g = *GImGui;
    ImVec2* pvar = GetStyleVarVec2Addr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a ImVec2.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = *pvar;
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r15d
callq 0x11721
testq %rax, %rax
je 0x11702
movq %rax, %r14
movl $0x17d8, %edi           # imm = 0x17D8
addq 0x3eda2(%rip), %rdi     # 0x50480
leaq -0x24(%rbp), %rsi
movl %r15d, (%rsi)
movq (%rax), %rax
movq %rax, 0x4(%rsi)
callq 0x1f374
movq (%rbx), %rax
movq %rax, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2571f(%rip), %rdi     # 0x36e28
leaq 0x24f5d(%rip), %rsi     # 0x3666d
leaq 0x2574f(%rip), %rcx     # 0x36e66
movl $0x10ef, %edx           # imm = 0x10EF
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetStyleVarVec2Addr(int)
static ImVec2* GetStyleVarVec2Addr(ImGuiStyleVar idx)
{
    ImGuiState& g = *GImGui;
    switch (idx)
    {
    case ImGuiStyleVar_WindowPadding: return &g.Style.WindowPadding;
    case ImGuiStyleVar_WindowMinSize: return &g.Style.WindowMinSize;
    case ImGuiStyleVar_FramePadding: return &g.Style.FramePadding;
    case ImGuiStyleVar_ItemSpacing: return &g.Style.ItemSpacing;
    case ImGuiStyleVar_ItemInnerSpacing: return &g.Style.ItemInnerSpacing;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
decl %edi
cmpl $0x7, %edi
ja 0x11773
movq 0x3ed4b(%rip), %rcx     # 0x50480
leaq 0x24d84(%rip), %rdx     # 0x364c0
movslq (%rdx,%rdi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
addq $0x13ec, %rcx           # imm = 0x13EC
jmp 0x11770
addq $0x1408, %rcx           # imm = 0x1408
jmp 0x11770
addq $0x13f4, %rcx           # imm = 0x13F4
jmp 0x11770
addq $0x1414, %rcx           # imm = 0x1414
jmp 0x11770
addq $0x141c, %rcx           # imm = 0x141C
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowPos(ImGuiWindow*, ImVec2 const&, int)
static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
        return;
    window->SetWindowPosAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
    window->SetWindowPosCenterWanted = false;

    // Set
    const ImVec2 old_pos = window->Pos;
    window->PosFloat = pos;
    window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
    window->DC.CursorPos += (window->Pos - old_pos);    // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
    window->DC.CursorMaxPos += (window->Pos - old_pos); // And more importantly we need to adjust this so size calculation doesn't get affected.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
setne %cl
movl 0x94(%rdi), %eax
testl %edx, %eax
sete %dl
testb %dl, %cl
jne 0x1194c
andl $-0xf, %eax
movl %eax, 0x94(%rdi)
movb $0x0, 0xa0(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movd %eax, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
shrq $0x20, %rax
movd %eax, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movaps %xmm0, %xmm2
subss 0x18(%rdi), %xmm2
movss %xmm0, 0x18(%rdi)
movaps %xmm1, %xmm0
subss 0x1c(%rdi), %xmm0
movss %xmm1, 0x1c(%rdi)
movss 0xa8(%rdi), %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0xa8(%rdi)
movss 0xac(%rdi), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xac(%rdi)
addss 0xc0(%rdi), %xmm2
movss %xmm2, 0xc0(%rdi)
addss 0xc4(%rdi), %xmm0
movss %xmm0, 0xc4(%rdi)
popq %rbp
retq