LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowToSortedBuffer(ImVector<ImGuiWindow*>&, ImGuiWindow*)
static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window)
{
    out_sorted_windows.push_back(window);
    if (window->Active)
    {
        int count = window->DC.ChildWindows.Size;
        if (count > 1)
            qsort(window->DC.ChildWindows.begin(), (size_t)count, sizeof(ImGuiWindow*), ChildWindowComparer);
        for (int i = 0; i < count; i++)
        {
            ImGuiWindow* child = window->DC.ChildWindows[i];
            if (child->Active)
                AddWindowToSortedBuffer(out_sorted_windows, child);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r12d
movl 0x4(%rdi), %eax
cmpl %eax, %r12d
jne 0xd28f
incl %r12d
testl %eax, %eax
je 0xd223
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xd228
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0xd28f
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x4824e(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd27a
movq 0x4821c(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x4820f(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movq 0x8(%r14), %rax
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movq %rbx, (%rax,%rcx,8)
cmpb $0x1, 0x70(%rbx)
jne 0xd303
movslq 0x100(%rbx), %r15
cmpq $0x2, %r15
jl 0xd2ce
movq 0x108(%rbx), %rdi
leaq 0x1643d(%rip), %rcx     # 0x236fe
movl $0x8, %edx
movq %r15, %rsi
callq 0x7540
testl %r15d, %r15d
jle 0xd303
xorl %r12d, %r12d
movslq 0x100(%rbx), %rax
cmpq %rax, %r12
jge 0xd30c
movq 0x108(%rbx), %rax
movq (%rax,%r12,8), %rsi
cmpb $0x1, 0x70(%rsi)
jne 0xd2fb
movq %r14, %rdi
callq 0xd1ef
incq %r12
cmpq %r12, %r15
jne 0xd2d6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31a9d(%rip), %rdi     # 0x3edb0
leaq 0x31779(%rip), %rsi     # 0x3ea93
leaq 0x31eef(%rip), %rcx     # 0x3f210
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowToRenderList(ImVector<ImDrawList*>&, ImGuiWindow*)
static void AddWindowToRenderList(ImVector<ImDrawList*>& out_render_list, ImGuiWindow* window)
{
    AddDrawListToRenderList(out_render_list, window->DrawList);
    for (int i = 0; i < window->DC.ChildWindows.Size; i++)
    {
        ImGuiWindow* child = window->DC.ChildWindows[i];
        if (!child->Active) // clipped children may have been marked not active
            continue;
        if ((child->Flags & ImGuiWindowFlags_Popup) && child->HiddenFrames > 0)
            continue;
        AddWindowToRenderList(out_render_list, child);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x270(%rsi), %rsi
callq 0xdee2
cmpl $0x0, 0x100(%rbx)
jle 0xded7
xorl %r15d, %r15d
movq 0x108(%rbx), %rax
movq (%rax,%r15,8), %rsi
cmpb $0x1, 0x70(%rsi)
jne 0xdec8
testb $0x2, 0xf(%rsi)
je 0xdec0
cmpl $0x0, 0x90(%rsi)
jg 0xdec8
movq %r14, %rdi
callq 0xde78
incq %r15
movslq 0x100(%rbx), %rax
cmpq %rax, %r15
jl 0xdea0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddDrawListToRenderList(ImVector<ImDrawList*>&, ImDrawList*)
static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list)
{
    if (!draw_list->CmdBuffer.empty() && !draw_list->VtxBuffer.empty())
    {
        if (draw_list->CmdBuffer.back().ElemCount == 0)
            draw_list->CmdBuffer.pop_back();
        out_render_list.push_back(draw_list);

        // Check that draw_list doesn't use more vertices than indexable (default ImDrawIdx = 2 bytes = 64K vertices)
        // If this assert triggers because you are drawing lots of stuff manually, A) workaround by calling BeginChild()/EndChild() to put your draw commands in multiple draw lists, B) #define ImDrawIdx to a 'unsigned int' in imconfig.h and render accordingly.
        const unsigned long long int max_vtx_idx = (unsigned long long int)1L << (sizeof(ImDrawIdx)*8);
        IM_ASSERT((unsigned long long int)draw_list->_VtxCurrentIdx <= max_vtx_idx);

        GImGui->IO.MetricsRenderVertices += draw_list->VtxBuffer.Size;
        GImGui->IO.MetricsRenderIndices += draw_list->IdxBuffer.Size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rsi), %eax
testq %rax, %rax
je 0xdfea
movq %rsi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0xdfea
testl %eax, %eax
jle 0xdff3
movq %rdi, %r14
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
cmpl $0x0, -0x30(%rcx,%rdx)
jne 0xdf27
decl %eax
movl %eax, (%rbx)
movl (%r14), %r12d
movl 0x4(%r14), %eax
cmpl %eax, %r12d
jne 0xdfb7
incl %r12d
testl %eax, %eax
je 0xdf4b
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xdf50
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0xdfb7
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x47526(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdfa2
movq 0x474f4(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x474e7(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movq 0x8(%r14), %rax
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r14)
movq %rbx, (%rax,%rcx,8)
cmpl $0x10001, 0x38(%rbx)    # imm = 0x10001
jae 0xe012
movl 0x20(%rbx), %eax
movq 0x474b5(%rip), %rcx     # 0x55490
addl %eax, 0x338(%rcx)
movl 0x10(%rbx), %eax
addl %eax, 0x33c(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38bbb(%rip), %rdi     # 0x46bb5
leaq 0x30a92(%rip), %rsi     # 0x3ea93
leaq 0x30b91(%rip), %rcx     # 0x3eb99
movl $0x326, %edx            # imm = 0x326
callq 0x7140
leaq 0x30afa(%rip), %rdi     # 0x3eb13
leaq 0x2f665(%rip), %rsi     # 0x3d685
leaq 0x30b2d(%rip), %rcx     # 0x3eb54
movl $0x8ab, %edx            # imm = 0x8AB
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogText(char const*, ...)
void ImGui::LogText(const char* fmt, ...)
{
    ImGuiState& g = *GImGui;
    if (!g.LogEnabled)
        return;

    va_list args;
    va_start(args, fmt);
    if (g.LogFile)
    {
        vfprintf(g.LogFile, fmt, args);
    }
    else
    {
        g.LogClipboard->appendv(fmt, args);
    }
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xe066
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq 0x47400(%rip), %rax     # 0x55490
cmpb $0x1, 0x2be8(%rax)
jne 0xe0ea
movq %rdi, %r10
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
movq %rcx, -0x20(%rbp)
movq 0x2bf0(%rax), %rdi
testq %rdi, %rdi
je 0xe0d7
leaq -0x20(%rbp), %rdx
movq %r10, %rsi
callq 0x77f0
jmp 0xe0ea
movq 0x2bf8(%rax), %rdi
leaq -0x20(%rbp), %rdx
movq %r10, %rsi
callq 0xa25e
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderText(ImVec2, char const*, char const*, bool)
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

    // Hide anything after a '##' string
    const char* text_display_end;
    if (hide_text_after_hash)
    {
        text_display_end = FindTextDisplayEnd(text, text_end);
    }
    else
    {
        if (!text_end)
            text_end = text + strlen(text); // FIXME-OPT
        text_display_end = text_end;
    }

    const int text_len = (int)(text_display_end - text);
    if (text_len > 0)
    {
        // Render
        window->DrawList->AddText(g.Font, g.FontSize, pos, window->Color(ImGuiCol_Text), text, text_display_end);

        // Log as text
        if (g.LogEnabled)
            LogRenderedText(pos, text, text_display_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0x4737b(%rip), %r13     # 0x55490
movq 0x1758(%r13), %r15
movb $0x1, 0x72(%r15)
testl %edx, %edx
je 0xe135
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe1e7
movq %rax, %r14
jmp 0xe148
testq %r14, %r14
jne 0xe148
movq %rbx, %rdi
callq 0x72f0
movq %rax, %r14
addq %rbx, %r14
movl %r14d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0xe1d8
movq 0x270(%r15), %r15
movq 0x1710(%r13), %r12
movss 0x1718(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movups 0x1460(%r13), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%r13), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8cce
movq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
xorps %xmm1, %xmm1
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x3081e
cmpb $0x1, 0x2be8(%r13)
jne 0xe1d8
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe244
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindTextDisplayEnd(char const*, char const*)
static const char*  FindTextDisplayEnd(const char* text, const char* text_end)
{
    const char* text_display_end = text;
    if (!text_end)
        text_end = (const char*)-1;

    ImGuiState& g = *GImGui;
    if (g.DisableHideTextAfterDoubleHash > 0)
    {
        while (text_display_end < text_end && *text_display_end != '\0')
            text_display_end++;
    }
    else
    {
        while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
            text_display_end++;
    }
    return text_display_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x1, %rsi
sbbq %rcx, %rcx
orq %rsi, %rcx
movq 0x4728f(%rip), %rdx     # 0x55490
cmpl $0x0, 0x17c4(%rdx)
jle 0xe21e
cmpq %rax, %rcx
jbe 0xe242
cmpb $0x0, (%rax)
je 0xe242
incq %rax
cmpq %rcx, %rax
jne 0xe20f
jmp 0xe23f
cmpq %rax, %rcx
jbe 0xe242
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0xe231
testl %edx, %edx
jne 0xe237
jmp 0xe242
cmpb $0x23, 0x1(%rax)
je 0xe242
incq %rax
cmpq %rcx, %rax
jne 0xe223
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderTextWrapped(ImVec2, char const*, char const*, float)
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

    if (!text_end)
        text_end = text + strlen(text); // FIXME-OPT

    const int text_len = (int)(text_end - text);
    if (text_len > 0)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, window->Color(ImGuiCol_Text), text, text_end, wrap_width);
        if (g.LogEnabled)
            LogRenderedText(pos, text, text_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm1, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0x470ea(%rip), %r13     # 0x55490
movq 0x1758(%r13), %r15
movb $0x1, 0x72(%r15)
testq %rsi, %rsi
jne 0xe3c5
movq %rbx, %rdi
callq 0x72f0
movq %rax, %r14
addq %rbx, %r14
movl %r14d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0xe457
movq 0x270(%r15), %r15
movq 0x1710(%r13), %r12
movss 0x1718(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movups 0x1460(%r13), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%r13), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8cce
movq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
movss -0x30(%rbp), %xmm1
callq 0x3081e
cmpb $0x1, 0x2be8(%r13)
jne 0xe457
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe244
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcTextSize(char const*, char const*, bool, float)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
    ImGuiState& g = *GImGui;

    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindTextDisplayEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;

    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);

    // Cancel out character spacing for the last character of a line (it is baked into glyph->XAdvance field)
    const float font_scale = font_size / font->FontSize;
    const float character_spacing_x = 1.0f * font_scale;
    if (text_size.x > 0.0f)
        text_size.x -= character_spacing_x;

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movaps %xmm0, %xmm2
movq %rsi, %rax
movq %rdi, %rbx
movq 0x46d56(%rip), %r15     # 0x55490
testl %edx, %edx
je 0xe753
movq %rbx, %rdi
movq %rax, %rsi
movss %xmm2, -0x1c(%rbp)
callq 0xe1e7
movss -0x1c(%rbp), %xmm2
movq 0x1710(%r15), %r14
movss 0x1718(%r15), %xmm0
movss 0x2ec55(%rip), %xmm1    # 0x3d3c0
movq %r14, %rdi
movss %xmm0, -0x1c(%rbp)
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x35d02
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xe79d
movss -0x1c(%rbp), %xmm2
divss (%r14), %xmm2
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %esi, %ebx
movl %edi, %ecx
leaq -0x38(%rbp), %rsi
movlps %xmm0, (%rsi)
leaq -0x48(%rbp), %rdx
movlps %xmm1, (%rdx)
movq 0x46cbe(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r15
movb $0x1, 0x72(%r15)
movq 0x270(%r15), %rdi
movss %xmm2, -0x2c(%rbp)
movaps %xmm2, %xmm0
movl $0xf, %r8d
callq 0x300c8
testl %ebx, %ebx
je 0xe8f7
testb $-0x80, 0xc(%r15)
je 0xe8f7
movss 0x2eb6d(%rip), %xmm0    # 0x3d380
leaq -0x38(%rbp), %rax
movss (%rax), %xmm1
addss %xmm0, %xmm1
addss 0x4(%rax), %xmm0
movq 0x270(%r15), %r12
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
leaq -0x40(%rbp), %rbx
movlps %xmm1, (%rbx)
movq 0x46c54(%rip), %rax     # 0x55490
movups 0x14b0(%rax), %xmm0
leaq -0x60(%rbp), %r14
movaps %xmm0, (%r14)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%r14), %xmm0
movss %xmm0, 0xc(%r14)
movq %r14, %rdi
callq 0x8cce
leaq -0x48(%rbp), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl $0xf, %r8d
callq 0x2ffde
movq 0x270(%r15), %r12
movss 0x2eaf7(%rip), %xmm0    # 0x3d38c
movss (%r13), %xmm1
addss %xmm0, %xmm1
addss 0x4(%r13), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlps %xmm1, (%rbx)
movq 0x46bde(%rip), %rax     # 0x55490
movups 0x14a0(%rax), %xmm0
movaps %xmm0, (%r14)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%r14), %xmm0
movss %xmm0, 0xc(%r14)
leaq -0x60(%rbp), %rdi
callq 0x8cce
leaq -0x40(%rbp), %rdx
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl $0xf, %r8d
callq 0x2ffde
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4654a(%rip), %rcx     # 0x55490
xorl %eax, %eax
cmpb $0x0, 0x2be8(%rcx)
jne 0xefaa
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_O1/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 0xf11e
cmpl $0x200, %edi            # imm = 0x200
jge 0xf12d
movq 0x463f2(%rip), %r14     # 0x55490
movl %edi, %eax
movss 0x3e4(%r14,%rax,4), %xmm0
movb $0x1, %bl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xf0b6
jnp 0xf120
testb %sil, %sil
je 0xf11e
movss 0x80(%r14), %xmm2
ucomiss %xmm2, %xmm0
jbe 0xf11e
movss 0x84(%r14), %xmm1
movss %xmm1, -0x1c(%rbp)
subss %xmm2, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x78f0
movss 0x2e2cf(%rip), %xmm2    # 0x3d3bc
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 0x78f0
ucomiss -0x20(%rbp), %xmm0
setbe %al
cmpb %al, %r15b
je 0xf120
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e8d0(%rip), %rdi     # 0x3da04
leaq 0x2e54a(%rip), %rsi     # 0x3d685
leaq 0x2e916(%rip), %rcx     # 0x3da58
movl $0xae8, %edx            # imm = 0xAE8
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf17e
cmpl $0x200, %edi            # imm = 0x200
jge 0xf181
movq 0x46331(%rip), %rcx     # 0x55490
movl %edi, %edx
movss 0xbe4(%rcx,%rdx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xf17e
movb $0x1, %al
cmpb $0x1, 0x108(%rcx,%rdx)
jne 0xf180
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2e878(%rip), %rdi     # 0x3da04
leaq 0x2e4f2(%rip), %rsi     # 0x3d685
leaq 0x2e8e2(%rip), %rcx     # 0x3da7c
movl $0xafa, %edx            # imm = 0xAFA
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf289
movq 0x46296(%rip), %r14     # 0x55490
movl %edi, %eax
movss 0x3a8(%r14,%rax,4), %xmm0
movb $0x1, %bl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xf212
jnp 0xf27c
testb %sil, %sil
je 0xf27a
movss 0x80(%r14), %xmm2
ucomiss %xmm2, %xmm0
jbe 0xf27a
movss 0x84(%r14), %xmm1
movss %xmm1, -0x1c(%rbp)
subss %xmm2, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x78f0
movss 0x2e173(%rip), %xmm2    # 0x3d3bc
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 0x78f0
ucomiss -0x20(%rbp), %xmm0
setbe %al
cmpb %al, %r15b
je 0xf27c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e80b(%rip), %rdi     # 0x3da9b
leaq 0x2e3ee(%rip), %rsi     # 0x3d685
leaq 0x2e86a(%rip), %rcx     # 0x3db08
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf356
movq 0x4616a(%rip), %rax     # 0x55490
movl %edi, %ecx
cmpb $0x1, 0xf8(%rax,%rcx)
jne 0xf353
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xf33f
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 0x2e73a(%rip), %rdi     # 0x3da9b
leaq 0x2e31d(%rip), %rsi     # 0x3d685
leaq 0x2e806(%rip), %rcx     # 0x3db75
movl $0xb2a, %edx            # imm = 0xB2A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x460fb(%rip), %rax     # 0x55490
movslq 0x1808(%rax), %rcx
testq %rcx, %rcx
jle 0xf3be
cmpl %ecx, 0x17f8(%rax)
jl 0xf3c9
movq 0x1800(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0xc, %rax
jmp 0xf3c4
addq $0xf0, %rax
movsd (%rax), %xmm0
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2f9dc(%rip), %rdi     # 0x3edb0
leaq 0x2f6b8(%rip), %rsi     # 0x3ea93
leaq 0x2ff44(%rip), %rcx     # 0x3f326
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf44f
movaps %xmm0, %xmm1
movq 0x46095(%rip), %rax     # 0x55490
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0xf408
movss 0x30(%rax), %xmm1
movl %edi, %ecx
xorps %xmm0, %xmm0
cmpb $0x1, 0xf8(%rax,%rcx)
jne 0xf44e
movss 0x3d0(%rax,%rcx,4), %xmm2
mulss %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jb 0xf44e
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 0x2e641(%rip), %rdi     # 0x3da9b
leaq 0x2e224(%rip), %rsi     # 0x3d685
leaq 0x2e735(%rip), %rcx     # 0x3db9d
movl $0xb43, %edx            # imm = 0xB43
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf490
movq 0x46012(%rip), %rax     # 0x55490
movl %edi, %ecx
movq 0xf0(%rax), %rdx
movq %rdx, 0x35c(%rax,%rcx,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2e600(%rip), %rdi     # 0x3da9b
leaq 0x2e1e3(%rip), %rsi     # 0x3d685
leaq 0x2e720(%rip), %rcx     # 0x3dbc9
movl $0xb4f, %edx            # imm = 0xB4F
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45f50(%rip), %rax     # 0x55490
movl 0x1790(%rax), %ecx
testl %ecx, %ecx
je 0xf55c
movq 0x1758(%rax), %rax
cmpl 0xe0(%rax), %ecx
sete %al
jmp 0xf55e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movaps %xmm0, %xmm1
movq 0x45e1d(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movss 0xe4(%rax), %xmm3
movss 0xe8(%rax), %xmm2
subss %xmm0, %xmm3
subss %xmm0, %xmm2
movss 0xec(%rax), %xmm4
addss %xmm0, %xmm4
addss 0xf0(%rax), %xmm1
movsd (%rdi), %xmm0
testl %esi, %esi
jne 0xf6b3
ucomiss %xmm3, %xmm0
jae 0xf6f0
ucomiss %xmm4, %xmm0
jbe 0xf6be
movss %xmm4, %xmm0            # xmm0 = xmm4[0],xmm0[1,2,3]
jmp 0xf6c7
ucomiss %xmm0, %xmm3
jbe 0xf6c7
movss %xmm3, %xmm0            # xmm0 = xmm3[0],xmm0[1,2,3]
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
ucomiss %xmm1, %xmm3
jbe 0xf6df
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
movaps %xmm1, %xmm0
jmp 0xf706
ucomiss %xmm3, %xmm2
jbe 0xf706
movlhps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm2     # xmm2 = xmm2[2,0],xmm0[2,3]
movaps %xmm2, %xmm0
jmp 0xf706
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm2, %xmm5
jb 0xf6b3
ucomiss %xmm0, %xmm4
jbe 0xf6b3
ucomiss %xmm5, %xmm1
jbe 0xf6b3
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x42912(%rip), %rsi     # 0x55490
movl 0x1808(%rsi), %eax
testl %eax, %eax
jle 0x12bf2
leal -0x1(%rax), %edi
movl 0x17f8(%rsi), %ecx
cmpl %ecx, %edi
jg 0x12bf2
cmpl %eax, %ecx
jl 0x12bff
movq 0x1800(%rsi), %rdx
movq 0x1810(%rsi), %rsi
movslq %edi, %r8
shlq $0x3, %r8
leaq (%r8,%r8,4), %r8
movl (%rsi,%r8), %esi
cmpl (%rdx,%r8), %esi
jne 0x12bf2
cmpl $0x1, %eax
je 0x12bfc
movl %edi, %esi
cmpl %ecx, %edi
jge 0x12bff
leal -0x1(%rax), %r8d
movl %r8d, %r9d
leaq (%r9,%r9,4), %r9
movq 0x8(%rdx,%r9,8), %r9
testq %r9, %r9
je 0x12bf4
testb $0x8, 0xf(%r9)
je 0x12bfa
decl %esi
movl %r8d, %eax
cmpl $0x1, %r8d
jg 0x12bc3
xorl %edi, %edi
jmp 0x12bfc
popq %rbp
retq
decl %eax
movl %eax, %edi
jmp 0x12bfc
movl %esi, %edi
popq %rbp
jmp 0x12c1e
leaq 0x2c1aa(%rip), %rdi     # 0x3edb0
leaq 0x2be86(%rip), %rsi     # 0x3ea93
leaq 0x2c712(%rip), %rcx     # 0x3f326
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ClosePopupToLevel(int)
static void ClosePopupToLevel(int remaining)
{
    ImGuiState& g = *GImGui;
    if (remaining > 0)
        ImGui::FocusWindow(g.OpenedPopupStack[remaining-1].Window);
    else
        ImGui::FocusWindow(g.OpenedPopupStack[0].ParentWindow);
    g.OpenedPopupStack.resize(remaining);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0x4285e(%rip), %r15     # 0x55490
movl 0x17f8(%r15), %eax
testl %edi, %edi
jle 0x12c5c
cmpl %ebx, %eax
jl 0x12d31
movq 0x1800(%r15), %rax
movl %ebx, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x20, %rax
jmp 0x12c6f
testl %eax, %eax
jle 0x12d31
movq 0x1800(%r15), %rax
addq $0x10, %rax
movq (%rax), %rdi
callq 0xd00c
movl 0x17fc(%r15), %eax
cmpl %ebx, %eax
jge 0x12d21
testl %eax, %eax
je 0x12c9c
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0x12ca2
movl $0x8, %r12d
cmpl %ebx, %r12d
cmovlel %ebx, %r12d
cmpl %r12d, %eax
jge 0x12d21
movslq %r12d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdi
movq 0x427d0(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r14
movq 0x1800(%r15), %rsi
movslq 0x17f8(%r15), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
callq 0x7080
movq 0x1800(%r15), %rdi
testq %rdi, %rdi
je 0x12d06
movq 0x42790(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x42783(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r14, 0x1800(%r15)
movl %r12d, 0x17fc(%r15)
movl %ebx, 0x17f8(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c078(%rip), %rdi     # 0x3edb0
leaq 0x2bd54(%rip), %rsi     # 0x3ea93
leaq 0x2c5e0(%rip), %rcx     # 0x3f326
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42716(%rip), %r13     # 0x55490
movq 0x1758(%r13), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa872
movl %eax, %r15d
movq 0x426fb(%rip), %rax     # 0x55490
movslq 0x1808(%rax), %rcx
cmpl %ecx, 0x17f8(%rax)
jle 0x12de8
movq 0x1800(%rax), %rdx
leaq (%rcx,%rcx,4), %rcx
cmpl %r15d, (%rdx,%rcx,8)
jne 0x12de8
xorps %xmm0, %xmm0
movl $0x2, %edi
callq 0x137a2
movl %r12d, %r14d
orl $0x2000147, %r14d       # imm = 0x2000147
btl $0x1b, %r12d
jb 0x12e0e
leaq 0x2be9f(%rip), %rdx     # 0x3ec79
leaq -0x50(%rbp), %rdi
movl $0x14, %esi
movl %r15d, %ecx
jmp 0x12e25
xorps %xmm0, %xmm0
movups %xmm0, 0x1834(%rax)
movb $0x0, 0x1844(%rax)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x1808(%r13), %ecx
leaq 0x2be53(%rip), %rdx     # 0x3ec6f
leaq -0x50(%rbp), %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x86d8
leaq -0x30(%rbp), %rdx
movq $0x0, (%rdx)
leaq -0x50(%rbp), %rdi
movss 0x2a53d(%rip), %xmm0    # 0x3d380
xorl %esi, %esi
movl %r14d, %ecx
callq 0xf7d7
movl %eax, %r14d
testb $-0x80, 0xc(%rbx)
jne 0x12e64
movq 0x1758(%r13), %rax
andl $0xffffff7f, 0xc(%rax)  # imm = 0xFFFFFF7F
testb %r14b, %r14b
jne 0x12dfc
callq 0x12f3e
jmp 0x12dfc
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %r12
movq 0x42601(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xa872
movl %eax, %ebx
movq 0x425e7(%rip), %rax     # 0x55490
movslq 0x1808(%rax), %rcx
cmpl %ecx, 0x17f8(%rax)
jle 0x12f17
movq 0x1800(%rax), %rdx
leaq (%rcx,%rcx,4), %rcx
cmpl %ebx, (%rdx,%rcx,8)
jne 0x12f17
orl $0x6000120, %r15d       # imm = 0x6000120
leaq -0x28(%rbp), %rdx
movq $0x0, (%rdx)
movss 0x2a4aa(%rip), %xmm0    # 0x3d38c
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %ecx
callq 0xf7d7
testb %al, %al
je 0x12f37
movl %eax, %r15d
movb $0x1, %al
testq %r14, %r14
je 0x12f2a
cmpb $0x0, (%r14)
jne 0x12f2a
callq 0x12f3e
testb %r15b, %r15b
je 0x12f28
movl %ebx, %edi
callq 0x12fc5
jmp 0x12f28
xorps %xmm0, %xmm0
movups %xmm0, 0x1834(%rax)
movb $0x0, 0x1844(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x12f3e
jmp 0x12f28
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42545(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
testb $0x2, 0xf(%rbx)
je 0x12f87
cmpl $0x0, 0x1808(%rax)
jle 0x12fa6
callq 0xcdc7
testb $0x4, 0xf(%rbx)
jne 0x12f80
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12ffd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2acc4(%rip), %rdi     # 0x3dc52
leaq 0x2a6f0(%rip), %rsi     # 0x3d685
leaq 0x2acdd(%rip), %rcx     # 0x3dc79
movl $0xc71, %edx            # imm = 0xC71
callq 0x7140
leaq 0x2ace3(%rip), %rdi     # 0x3dc90
leaq 0x2a6d1(%rip), %rsi     # 0x3d685
leaq 0x2acbe(%rip), %rcx     # 0x3dc79
movl $0xc72, %edx            # imm = 0xC72
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ClosePopup(unsigned int)
static void ClosePopup(ImGuiID id)
{
    if (!IsPopupOpen(id))
        return;
    ImGuiState& g = *GImGui;
    ClosePopupToLevel(g.OpenedPopupStack.Size - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
movq 0x424be(%rip), %rcx     # 0x55490
movl 0x17f8(%rcx), %edi
movslq 0x1808(%rcx), %rdx
cmpl %edx, %edi
jle 0x12ffb
movq 0x1800(%rcx), %rcx
leaq (%rdx,%rdx,4), %rdx
cmpl %eax, (%rcx,%rdx,8)
jne 0x12ffb
decl %edi
popq %rbp
jmp 0x12c1e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %edi, %edi
jle 0x13104
movl %edi, %ebx
movq 0x42471(%rip), %rcx     # 0x55490
leaq 0x141c(%rcx), %rax
movq %rax, -0x50(%rbp)
leaq 0x1414(%rcx), %rax
movq %rax, -0x48(%rbp)
leaq 0x1408(%rcx), %rax
movq %rax, -0x40(%rbp)
leaq 0x13f4(%rcx), %rax
movq %rax, -0x38(%rbp)
leaq 0x13ec(%rcx), %rax
movq %rax, -0x30(%rbp)
movl 0x17d8(%rcx), %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
leaq -0x8(,%rax,4), %r12
incl %ebx
movq %rcx, -0x58(%rbp)
testl %r13d, %r13d
jle 0x13113
movq 0x17e0(%rcx), %r15
movl -0x4(%r15,%r12), %r14d
movl %r14d, %edi
callq 0x152bc
testq %rax, %rax
je 0x130a4
movss (%r15,%r12), %xmm0
movss %xmm0, (%rax)
jmp 0x130e7
xorl %eax, %eax
decl %r14d
cmpl $0x7, %r14d
ja 0x130db
leaq 0x2a3ce(%rip), %rdx     # 0x3d484
movslq (%rdx,%r14,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq -0x30(%rbp), %rax
jmp 0x130db
movq -0x40(%rbp), %rax
jmp 0x130db
movq -0x38(%rbp), %rax
jmp 0x130db
movq -0x48(%rbp), %rax
jmp 0x130db
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x130e7
movq (%r15,%r12), %rcx
movq %rcx, (%rax)
decl %r13d
movq -0x58(%rbp), %rcx
movl %r13d, 0x17d8(%rcx)
addq $-0xc, %r12
decl %ebx
cmpl $0x1, %ebx
jg 0x13076
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33a9b(%rip), %rdi     # 0x46bb5
leaq 0x2b972(%rip), %rsi     # 0x3ea93
leaq 0x2c4fd(%rip), %rcx     # 0x3f625
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
testq %rsi, %rsi
leaq 0x2aafd(%rip), %rbx     # 0x3dcb3
cmovneq %rsi, %rbx
movq 0x422cf(%rip), %rax     # 0x55490
movq 0x1778(%rax), %rcx
cmpq 0x1758(%rax), %rcx
je 0x131e4
movq %rbx, %rdi
movl $0x80, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12d5c
cmpl $0x5, %edx
jae 0x13221
movl %edx, %ecx
movss 0x3a8(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x131d1
jp 0x131d1
testb %dil, %dil
je 0x1320d
movq %rbx, %rdi
callq 0x128f4
jmp 0x131d1
cmpl $0x0, 0x1788(%rax)
jne 0x131d1
cmpl $0x0, 0x178c(%rax)
jne 0x131d1
jmp 0x13203
leaq 0x2a873(%rip), %rdi     # 0x3da9b
leaq 0x2a456(%rip), %rsi     # 0x3d685
leaq 0x2a8d2(%rip), %rcx     # 0x3db08
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2aa77(%rip), %rbx     # 0x3dcc7
cmovneq %rdi, %rbx
movq 0x42235(%rip), %rax     # 0x55490
cmpq $0x0, 0x1778(%rax)
jne 0x13287
cmpl $0x5, %esi
jae 0x1329a
movl %esi, %ecx
movss 0x3a8(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x13287
jp 0x13287
movq %rbx, %rdi
callq 0x128f4
movq %rbx, %rdi
movl $0x80, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12d5c
leaq 0x2a7fa(%rip), %rdi     # 0x3da9b
leaq 0x2a3dd(%rip), %rsi     # 0x3d685
leaq 0x2a859(%rip), %rcx     # 0x3db08
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq 0x41fa9(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rdx
movb $0x1, 0x72(%rdx)
movl 0xc(%rdx), %ecx
btl $0x14, %ecx
jae 0x135ca
btl $0x17, %ecx
jb 0x1350b
cmpl $0x2, 0x78(%rdx)
jl 0x13516
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xcdc7
movsd 0x20(%rdx), %xmm0
movsd %xmm0, -0x10(%rbp)
btl $0x15, %ecx
jae 0x13544
movss -0x10(%rbp), %xmm0
subss 0x13ec(%rax), %xmm0
movss 0x29e69(%rip), %xmm1    # 0x3d3a4
maxss %xmm0, %xmm1
movss %xmm1, -0x10(%rbp)
btl $0x16, %ecx
jae 0x13568
movss -0xc(%rbp), %xmm0
subss 0x13f0(%rax), %xmm0
movss 0x29e45(%rip), %xmm1    # 0x3d3a4
maxss %xmm0, %xmm1
movss %xmm1, -0xc(%rbp)
callq 0xcdc7
movq 0x41f1c(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
movss 0xa8(%rax), %xmm0
leaq -0x10(%rbp), %rdi
addss (%rdi), %xmm0
movss 0xac(%rax), %xmm1
addss 0x4(%rdi), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0xa8(%rax), %rax
leaq -0x20(%rbp), %rbx
movq %rax, (%rbx)
movlps %xmm0, 0x8(%rbx)
xorps %xmm0, %xmm0
callq 0xaab7
movq %rbx, %rdi
xorl %esi, %esi
callq 0xac09
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2a719(%rip), %rdi     # 0x3dcea
leaq 0x2a0ad(%rip), %rsi     # 0x3d685
leaq 0x2a738(%rip), %rcx     # 0x3dd17
movl $0xcbf, %edx            # imm = 0xCBF
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq 0x41e74(%rip), %r15     # 0x55490
leaq 0x14c0(%r15), %rsi
movl $0x3, %edi
callq 0x1367a
movss 0x1410(%r15), %xmm0
movl $0x4, %edi
callq 0x137a2
leaq 0x2a698(%rip), %rdx     # 0x3dcdf
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movl $0x20, %esi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x86d8
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x132b9
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq 0x41df8(%rip), %r13     # 0x55490
movslq %edi, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %r12
addq $0x1460, %r12           # imm = 0x1460
movups (%r12), %xmm0
movaps %xmm0, -0x40(%rbp)
movl 0x17c8(%r13), %r15d
movl 0x17cc(%r13), %eax
cmpl %eax, %r15d
jne 0x13762
incl %r15d
testl %eax, %eax
je 0x136de
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x136e3
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
cmpl %r15d, %eax
jge 0x13762
movslq %r15d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
incl 0x334(%r13)
callq *0xd0(%r13)
movq %rax, %rdi
movq 0x17d0(%r13), %rsi
movslq 0x17c8(%r13), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %rdi, -0x30(%rbp)
callq 0x7080
movq 0x17d0(%r13), %rdi
testq %rdi, %rdi
je 0x13743
movq 0x41d53(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x41d46(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq -0x30(%rbp), %rax
movq %rax, 0x17d0(%r13)
movl %r15d, 0x17cc(%r13)
movq 0x17d0(%r13), %rax
movslq 0x17c8(%r13), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x17c8(%r13)
leaq (%rcx,%rcx,4), %rcx
movl %r14d, (%rax,%rcx,4)
movaps -0x40(%rbp), %xmm0
movups %xmm0, 0x4(%rax,%rcx,4)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq