LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::NextColumn()
void ImGui::NextColumn()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    if (window->DC.ColumnsCount > 1)
    {
        ImGui::PopItemWidth();
        PopClipRect();

        window->DC.ColumnsCellMaxY = ImMax(window->DC.ColumnsCellMaxY, window->DC.CursorPos.y);
        if (++window->DC.ColumnsCurrent < window->DC.ColumnsCount)
        {
            window->DC.ColumnsOffsetX = ImGui::GetColumnOffset(window->DC.ColumnsCurrent) - window->DC.ColumnsStartX + g.Style.ItemSpacing.x;
            window->DrawList->ChannelsSetCurrent(window->DC.ColumnsCurrent);
        }
        else
        {
            window->DC.ColumnsCurrent = 0;
            window->DC.ColumnsOffsetX = 0.0f;
            window->DC.ColumnsCellMinY = window->DC.ColumnsCellMaxY;
            window->DrawList->ChannelsSetCurrent(0);
        }
        window->DC.CursorPos.x = (float)(int)(window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX);
        window->DC.CursorPos.y = window->DC.ColumnsCellMinY;
        window->DC.CurrentLineHeight = 0.0f;
        window->DC.CurrentLineTextBaseOffset = 0.0f;

        PushColumnClipRect();
        ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f);  // FIXME
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x32d2a(%rip), %r14     # 0x55490
movq 0x1758(%r14), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x227f6
cmpl $0x2, 0x1a0(%rbx)
jl 0x227f6
callq 0x9e68
callq 0x14adb
movss 0x1b0(%rbx), %xmm1
movss 0xac(%rbx), %xmm2
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movss %xmm0, 0x1b0(%rbx)
movl 0x19c(%rbx), %edi
incl %edi
movl %edi, 0x19c(%rbx)
cmpl 0x1a0(%rbx), %edi
jge 0x227ff
callq 0x158dd
subss 0x194(%rbx), %xmm0
addss 0x1414(%r14), %xmm0
movss %xmm0, 0x198(%rbx)
movq 0x270(%rbx), %rdi
movl 0x19c(%rbx), %esi
jmp 0x2281b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq $0x0, 0x198(%rbx)
movss %xmm0, 0x1ac(%rbx)
movq 0x270(%rbx), %rdi
xorl %esi, %esi
callq 0x2de80
movss 0x18(%rbx), %xmm0
addss 0x194(%rbx), %xmm0
movss 0x1ac(%rbx), %xmm1
addss 0x198(%rbx), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xa8(%rbx)
movss %xmm1, 0xac(%rbx)
movq $0x0, 0xc8(%rbx)
callq 0x208d7
movq 0x32c25(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movl 0x19c(%rax), %ebx
leal 0x1(%rbx), %edi
callq 0x158dd
movss %xmm0, -0x14(%rbp)
movl %ebx, %edi
callq 0x158dd
movss -0x14(%rbp), %xmm1
subss %xmm0, %xmm1
mulss 0x1ab57(%rip), %xmm1    # 0x3d3f4
movaps %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9d0e
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetColumnWidth(int)
float ImGui::GetColumnWidth(int column_index)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    const float w = GetColumnOffset(column_index+1) - GetColumnOffset(column_index);
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jns 0x228cd
movq 0x32bd0(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movl 0x19c(%rax), %ebx
leal 0x1(%rbx), %edi
callq 0x158dd
movss %xmm0, -0xc(%rbp)
movl %ebx, %edi
callq 0x158dd
movss -0xc(%rbp), %xmm1
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetDraggedColumnOffset(int)
static float GetDraggedColumnOffset(int column_index)
{
    // Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
    // window creates a feedback loop because we store normalized positions/ So while dragging we enforce absolute positioning
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = ImGui::GetCurrentWindowRead();
    IM_ASSERT(column_index > 0); // We cannot drag column 0. If you get this assert you may have a conflict between the ID of your columns and another widgets.
    IM_ASSERT(g.ActiveId == window->DC.ColumnsSetID + ImGuiID(column_index));

    float x = g.IO.MousePos.x + g.ActiveClickDeltaToCenter.x - window->Pos.x;
    x = ImClamp(x, ImGui::GetColumnOffset(column_index-1)+g.Style.ColumnsMinSpacing, ImGui::GetColumnOffset(column_index+1)-g.Style.ColumnsMinSpacing);

    return (float)(int)x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testl %edi, %edi
jle 0x229cf
movl %edi, %ebx
movq 0x32b4c(%rip), %r14     # 0x55490
movq 0x1758(%r14), %rax
movl 0x1b8(%rax), %ecx
addl %edi, %ecx
cmpl %ecx, 0x1790(%r14)
jne 0x229ee
movss 0xf0(%r14), %xmm0
addss 0x27b8(%r14), %xmm0
subss 0x18(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
leal -0x1(%rbx), %edi
callq 0x158dd
addss 0x1434(%r14), %xmm0
movaps %xmm0, -0x20(%rbp)
incl %ebx
movl %ebx, %edi
callq 0x158dd
subss 0x1434(%r14), %xmm0
movaps -0x30(%rbp), %xmm2
minss %xmm2, %xmm0
movaps -0x20(%rbp), %xmm3
cmpltss %xmm3, %xmm2
movaps %xmm2, %xmm1
andnps %xmm0, %xmm1
andps %xmm3, %xmm2
orps %xmm1, %xmm2
cvttps2dq %xmm2, %xmm0
cvtdq2ps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c512(%rip), %rdi     # 0x3eee8
leaq 0x1aca8(%rip), %rsi     # 0x3d685
leaq 0x1c515(%rip), %rcx     # 0x3eef9
movl $0x21c8, %edx           # imm = 0x21C8
callq 0x7140
leaq 0x1c526(%rip), %rdi     # 0x3ef1b
leaq 0x1ac89(%rip), %rsi     # 0x3d685
leaq 0x1c4f6(%rip), %rcx     # 0x3eef9
movl $0x21c9, %edx           # imm = 0x21C9
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetColumnOffset(int, float)
void ImGui::SetColumnOffset(int column_index, float offset)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    IM_ASSERT(column_index < window->DC.ColumnsOffsetsT.Size);
    const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);

    const float content_region_width = window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x;
    const float min_x = window->DC.ColumnsStartX;
    const float max_x = content_region_width - window->Scroll.x  - ((window->Flags & ImGuiWindowFlags_NoScrollbar) ? 0 : g.Style.ScrollbarSize);// - window->WindowPadding().x;
    const float t = (offset - min_x) / (max_x - min_x);
    window->DC.StateStorage->SetFloat(column_id, t);
    window->DC.ColumnsOffsetsT[column_index] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0x32a6f(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
testl %edi, %edi
jns 0x22a38
movl 0x19c(%r14), %ebx
cmpl 0x1c0(%r14), %ebx
jge 0x22acd
movss 0x38(%r14), %xmm4
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm4
jne 0x22a5b
jp 0x22a5b
movss 0x20(%r14), %xmm4
movl 0x1b8(%r14), %esi
movss 0x4c(%r14), %xmm3
movss 0x194(%r14), %xmm2
testb $0x8, 0xc(%r14)
jne 0x22a80
movss 0x1438(%rax), %xmm1
subss %xmm3, %xmm4
subss %xmm1, %xmm4
addl %ebx, %esi
subss %xmm2, %xmm0
subss %xmm2, %xmm4
divss %xmm4, %xmm0
movss %xmm0, -0x14(%rbp)
movq 0x110(%r14), %rdi
callq 0x97b4
cmpl %ebx, 0x1c0(%r14)
jle 0x22aec
movq 0x1c8(%r14), %rax
movslq %ebx, %rcx
movss -0x14(%rbp), %xmm0
movss %xmm0, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bd21(%rip), %rdi     # 0x3e7f5
leaq 0x1abaa(%rip), %rsi     # 0x3d685
leaq 0x1bd64(%rip), %rcx     # 0x3e846
movl $0x21f1, %edx           # imm = 0x21F1
callq 0x7140
leaq 0x1c2bd(%rip), %rdi     # 0x3edb0
leaq 0x1bf99(%rip), %rsi     # 0x3ea93
leaq 0x1cc20(%rip), %rcx     # 0x3f721
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Indent()
void ImGui::Indent()
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.ColumnsStartX += g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3297a(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x1430(%rax), %xmm0
addss 0x194(%rcx), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Unindent()
void ImGui::Unindent()
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.ColumnsStartX -= g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x32935(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x194(%rcx), %xmm0
subss 0x1430(%rax), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreePop()
void ImGui::TreePop()
{
    ImGuiWindow* window = GetCurrentWindow();
    ImGui::Unindent();
    window->DC.TreeDepth--;
    PopID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x328f0(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x194(%rcx), %xmm0
subss 0x1430(%rax), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
decl 0xdc(%rcx)
popq %rbp
jmp 0x16fc0
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Color(char const*, unsigned int)
void ImGui::Color(const char* prefix, unsigned int v)
{
    ImGui::Text("%s: %08X", prefix, v);
    ImGui::SameLine();

    ImVec4 col;
    col.x = (float)((v >> 0) & 0xFF) / 255.0f;
    col.y = (float)((v >> 8) & 0xFF) / 255.0f;
    col.z = (float)((v >> 16) & 0xFF) / 255.0f;
    col.w = (float)((v >> 24) & 0xFF) / 255.0f;
    ImGui::ColorButton(col, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x1bb60(%rip), %rdi     # 0x3e8b5
movl %ebx, %edx
xorl %eax, %eax
callq 0x1609c
movq 0x3272b(%rip), %rcx     # 0x55490
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x22da8
movss 0x1414(%rcx), %xmm0
addss 0xb0(%rax), %xmm0
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm0, 0xa8(%rax)
movl %ecx, 0xac(%rax)
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
movl $0xff, %eax
movl %ebx, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss 0x1a5be(%rip), %xmm1    # 0x3d388
divss %xmm1, %xmm0
movss %xmm0, (%rdi)
movl %ebx, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rdi)
movl %ebx, %ecx
shrl $0x10, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
shrl $0x18, %ebx
cvtsi2ss %ebx, %xmm2
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rdi)
divss %xmm1, %xmm2
movss %xmm2, 0xc(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x21ada
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ShowMetricsWindow(bool*)::Funcs::NodeWindows(ImVector<ImGuiWindow*>&, char const*)
static void NodeWindows(ImVector<ImGuiWindow*>& windows, const char* label)
            {
                if (!ImGui::TreeNode(label, "%s (%d)", label, windows.Size))
                    return;
                for (int i = 0; i < windows.Size; i++)
                    Funcs::NodeWindow(windows[i], "Window");
                ImGui::TreePop();
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
leaq 0x1be2a(%rip), %rsi     # 0x3ef59
movq %rdx, %rdi
xorl %eax, %eax
callq 0x18049
testb %al, %al
je 0x23176
cmpl $0x0, (%rbx)
jle 0x23167
xorl %r15d, %r15d
leaq 0x1b889(%rip), %r14     # 0x3e9d5
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x240a8
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x2314c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22b95
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindWindowSettings(char const*)
static ImGuiIniData* FindWindowSettings(const char* name)
{
    ImGuiState& g = *GImGui;
    ImGuiID id = ImHash(name, 0);
    for (int i = 0; i != g.Settings.Size; i++)
    {
        ImGuiIniData* ini = &g.Settings[i];
        if (ini->ID == id)
            return ini;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x31f54(%rip), %rbx     # 0x55490
xorl %esi, %esi
xorl %edx, %edx
callq 0x8794
movl 0x17b0(%rbx), %edx
testq %rdx, %rdx
je 0x23588
testl %edx, %edx
movl $0x0, %esi
cmovgl %edx, %esi
shlq $0x5, %rsi
shlq $0x5, %rdx
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x23594
movq 0x17b8(%rbx), %r8
leaq (%r8,%rdi), %r9
cmpl %eax, 0x8(%r8,%rdi)
cmoveq %r9, %rcx
je 0x2358a
addq $0x20, %rdi
cmpq %rdi, %rdx
jne 0x23564
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1b815(%rip), %rdi     # 0x3edb0
leaq 0x1b4f1(%rip), %rsi     # 0x3ea93
leaq 0x1bcef(%rip), %rcx     # 0x3f298
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowSettings(char const*)
static ImGuiIniData* AddWindowSettings(const char* name)
{
    GImGui->Settings.resize(GImGui->Settings.Size + 1);
    ImGuiIniData* ini = &GImGui->Settings.back();
    ini->Name = ImStrdup(name);
    ini->ID = ImHash(name, 0);
    ini->Collapsed = false;
    ini->Pos = ImVec2(FLT_MAX,FLT_MAX);
    ini->Size = ImVec2(0,0);
    return ini;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x31ec5(%rip), %r15     # 0x55490
movl 0x17b0(%r15), %ecx
movl 0x17b4(%r15), %eax
leal 0x1(%rcx), %r12d
cmpl %ecx, %eax
jg 0x23673
testl %eax, %eax
je 0x235fb
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x23601
movl $0x8, %r13d
cmpl %r12d, %r13d
cmovlel %r12d, %r13d
cmpl %r13d, %eax
jge 0x23673
movslq %r13d, %rdi
shlq $0x5, %rdi
incl 0x334(%r15)
callq *0xd0(%r15)
movq %rax, %r14
movq 0x17b8(%r15), %rsi
movslq 0x17b0(%r15), %rdx
shlq $0x5, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x17b8(%r15), %rdi
testq %rdi, %rdi
je 0x23658
movq 0x31e3e(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x31e31(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r14, 0x17b8(%r15)
movl %r13d, 0x17b4(%r15)
movl %r12d, 0x17b0(%r15)
movq 0x31e0f(%rip), %rcx     # 0x55490
movslq 0x17b0(%rcx), %rax
testq %rax, %rax
jle 0x236df
movq 0x17b8(%rcx), %rcx
shlq $0x5, %rax
leaq (%rcx,%rax), %r14
addq $-0x20, %r14
movq %rbx, %rdi
callq 0x857f
movq %rax, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8794
movl %eax, 0x8(%r14)
movb $0x0, 0x1c(%r14)
movsd 0x19ca8(%rip), %xmm0    # 0x3d370
movups %xmm0, 0xc(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x234cf(%rip), %rdi     # 0x46bb5
leaq 0x1b3a6(%rip), %rsi     # 0x3ea93
leaq 0x1b3af(%rip), %rcx     # 0x3eaa3
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ChildWindowComparer(void const*, void const*)
static int ChildWindowComparer(const void* lhs, const void* rhs)
{
    const ImGuiWindow* a = *(const ImGuiWindow**)lhs;
    const ImGuiWindow* b = *(const ImGuiWindow**)rhs;
    if (int d = (a->Flags & ImGuiWindowFlags_Popup) - (b->Flags & ImGuiWindowFlags_Popup))
        return d;
    if (int d = (a->Flags & ImGuiWindowFlags_Tooltip) - (b->Flags & ImGuiWindowFlags_Tooltip))
        return d;
    if (int d = (a->Flags & ImGuiWindowFlags_ComboBox) - (b->Flags & ImGuiWindowFlags_ComboBox))
        return d;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq (%rsi), %rdx
movl 0xc(%rax), %ecx
movl $0x2000000, %esi        # imm = 0x2000000
movl %ecx, %eax
andl %esi, %eax
movl 0xc(%rdx), %edx
andl %edx, %esi
subl %esi, %eax
jne 0x2373c
movl $0x1000000, %esi        # imm = 0x1000000
movl %ecx, %edi
andl %esi, %edi
andl %edx, %esi
subl %esi, %edi
cmovnel %edi, %eax
jne 0x2373c
movl $0x800000, %eax         # imm = 0x800000
andl %eax, %ecx
andl %eax, %edx
subl %edx, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStb::STB_TEXTEDIT_DELETECHARS(ImGuiTextEditState*, int, int)
static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
{
    ImWchar* dst = obj->Text.Data + pos;

    // We maintain our buffer length in both UTF-8 and wchar formats
    obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
    obj->CurLenW -= n;

    // Offset remaining text
    const ImWchar* src = obj->Text.Data + pos + n;
    while (ImWchar c = *src++)
        *dst++ = c;
    *dst = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movslq %esi, %rbx
addq %rbx, %rbx
addq 0x10(%rdi), %rbx
movslq %edx, %r12
leaq (%rbx,%r12,2), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8bf6
subl %eax, 0x38(%r15)
subl %r12d, 0x3c(%r15)
movzwl (%r14), %eax
testw %ax, %ax
je 0x237de
movw %ax, (%rbx)
addq $0x2, %rbx
addq $0x2, %r14
testw %ax, %ax
jne 0x237ce
movw $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStb::STB_TEXTEDIT_INSERTCHARS(ImGuiTextEditState*, int, unsigned short const*, int)
static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
{
    const int text_len = obj->CurLenW;
    if (new_text_len + text_len + 1 > obj->Text.Size)
        return false;

    const int new_text_len_utf8 = ImTextCountUtf8BytesFromStr(new_text, new_text + new_text_len);
    if (new_text_len_utf8 + obj->CurLenA + 1 > obj->BufSizeA)
        return false;

    ImWchar* text = obj->Text.Data;
    if (pos != text_len)
        memmove(text + pos + new_text_len, text + pos, (size_t)(text_len - pos) * sizeof(ImWchar));
    memcpy(text + pos, new_text, (size_t)new_text_len * sizeof(ImWchar));

    obj->CurLenW += new_text_len;
    obj->CurLenA += new_text_len_utf8;
    obj->Text[obj->CurLenW] = '\0';

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x3c(%rdi), %r15d
leal (%r15,%rcx), %eax
cmpl 0x8(%rdi), %eax
jge 0x238a0
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
movslq %ecx, %r13
leaq (%rdx,%r13,2), %rsi
movq %rdx, %rdi
callq 0x8bf6
movl %eax, %ecx
movl 0x38(%rbx), %eax
addl %ecx, %eax
cmpl 0x40(%rbx), %eax
setl %al
jge 0x238a2
movl %ecx, -0x2c(%rbp)
movq 0x10(%rbx), %rax
movslq %r12d, %rcx
subl %r12d, %r15d
je 0x23869
leaq (%rax,%rcx,2), %rsi
leaq (%rsi,%r13,2), %rdi
movslq %r15d, %rdx
addq %rdx, %rdx
movq %rax, %r15
movq %rcx, %r12
callq 0x7130
movq %r12, %rcx
movq %r15, %rax
leaq (%rax,%rcx,2), %rdi
leaq (,%r13,2), %rdx
movq %r14, %rsi
callq 0x7080
movslq 0x3c(%rbx), %rax
addq %r13, %rax
movl %eax, 0x3c(%rbx)
movl -0x2c(%rbp), %ecx
addl %ecx, 0x38(%rbx)
cmpl %eax, 0x8(%rbx)
jle 0x238b1
movq 0x10(%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movb $0x1, %al
jmp 0x238a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b4f8(%rip), %rdi     # 0x3edb0
leaq 0x1b1d4(%rip), %rsi     # 0x3ea93
leaq 0x1b4f3(%rip), %rcx     # 0x3edb9
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_move_to_word_next(ImGuiTextEditState*, ImGuiStb::STB_TexteditState*)
static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
{
   const int len = STB_TEXTEDIT_STRINGLEN(_str);
   int c = _state->cursor+1;
   while( c < len && !is_word_boundary( _str, c ) )
      ++c;

   if( c > len )
      c = len;

   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x3c(%rdi), %r15d
movl (%rsi), %ebx
movl %ebx, %r12d
leal 0x1(%r12), %ebx
cmpl %r15d, %ebx
jge 0x239cd
movq %r14, %rdi
movl %ebx, %esi
callq 0x23e28
testl %eax, %eax
je 0x239b2
cmpl %r15d, %r12d
cmovgel %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_text_createundo(ImGuiStb::StbUndoState*, int, int, int)
static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
{
   StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
   if (r == NULL)
      return NULL;

   r->where = pos;
   r->insert_length = (short) insert_len;
   r->delete_length = (short) delete_len;

   if (insert_len == 0) {
      r->char_storage = -1;
      return NULL;
   } else {
      r->char_storage = state->undo_char_point;
      state->undo_char_point = state->undo_char_point + (short) insert_len;
      return &state->undo_char[r->char_storage];
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movw $0x63, 0xc74(%rdi)
movw $0x3e7, 0xc78(%rdi)     # imm = 0x3E7
cmpw $0x63, 0xc72(%rdi)
jne 0x23ccc
movq %rbx, %rdi
callq 0x23d76
cmpl $0x3e7, %r14d           # imm = 0x3E7
jle 0x23ce7
xorl %eax, %eax
movw %ax, 0xc72(%rbx)
movw %ax, 0xc76(%rbx)
jmp 0x23d2b
movswl 0xc76(%rbx), %eax
addl %r14d, %eax
cmpl $0x3e8, %eax            # imm = 0x3E8
jl 0x23d11
movq %rbx, %rdi
callq 0x23d76
movswl 0xc76(%rbx), %eax
addl %r14d, %eax
cmpl $0x3e7, %eax            # imm = 0x3E7
jg 0x23cf8
movswq 0xc72(%rbx), %rax
leal 0x1(%rax), %ecx
movw %cx, 0xc72(%rbx)
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,4), %rax
testq %rax, %rax
je 0x23d6b
movl %r12d, (%rax)
movw %r14w, 0x4(%rax)
movw %r15w, 0x6(%rax)
testl %r14d, %r14d
je 0x23d65
movswq 0xc76(%rbx), %rcx
movw %cx, 0x8(%rax)
leal (%r14,%rcx), %eax
movw %ax, 0xc76(%rbx)
leaq (%rbx,%rcx,2), %rax
addq $0x4a4, %rax            # imm = 0x4A4
jmp 0x23d6d
movw $0xffff, 0x8(%rax)      # imm = 0xFFFF
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_discard_undo(ImGuiStb::StbUndoState*)
static void stb_textedit_discard_undo(StbUndoState *state)
{
   if (state->undo_point > 0) {
      // if the 0th undo state has characters, clean those up
      if (state->undo_rec[0].char_storage >= 0) {
         int n = state->undo_rec[0].insert_length, i;
         // delete n characters from all other records
         state->undo_char_point = state->undo_char_point - (short) n;  // vsnet05
         memmove(state->undo_char, state->undo_char + n, (size_t) ((size_t)state->undo_char_point*sizeof(STB_TEXTEDIT_CHARTYPE)));
         for (i=0; i < state->undo_point; ++i)
            if (state->undo_rec[i].char_storage >= 0)
               state->undo_rec[i].char_storage = state->undo_rec[i].char_storage - (short) n; // vsnet05 // @OPTIMIZE: get rid of char_storage and infer it
      }
      --state->undo_point;
      memmove(state->undo_rec, state->undo_rec+1, (size_t) ((size_t)state->undo_point*sizeof(state->undo_rec[0])));
   }
}

// Assembly:
cmpw $0x0, 0xc72(%rdi)
jle 0x23e27
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x8(%rdi)
js 0x23dfb
movswq 0x4(%rbx), %r14
movzwl 0xc76(%rbx), %eax
subl %r14d, %eax
movw %ax, 0xc76(%rbx)
leaq 0x4a4(%rbx), %rdi
leaq (%rbx,%r14,2), %rsi
addq $0x4a4, %rsi            # imm = 0x4A4
movswq %ax, %rdx
addq %rdx, %rdx
callq 0x7130
movswq 0xc72(%rbx), %rax
testq %rax, %rax
jle 0x23dfb
shlq $0x2, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
movzwl 0x8(%rbx,%rcx), %edx
testw %dx, %dx
js 0x23df2
subl %r14d, %edx
movw %dx, 0x8(%rbx,%rcx)
addq $0xc, %rcx
cmpq %rcx, %rax
jne 0x23de0
movzwl 0xc72(%rbx), %eax
decl %eax
movw %ax, 0xc72(%rbx)
leaq 0xc(%rbx), %rsi
movswq %ax, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7130
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ShowMetricsWindow(bool*)::Funcs::NodeWindow(ImGuiWindow*, char const*)
static void NodeWindow(ImGuiWindow* window, const char* label)
            {
                if (!ImGui::TreeNode(window, "%s '%s', %d @ 0x%p", label, window->Name, window->Active || window->WasActive, window))
                    return;
                NodeDrawList(window->DrawList, "DrawList");
                if (window->RootWindow != window) NodeWindow(window->RootWindow, "RootWindow");
                if (window->DC.ChildWindows.Size > 0) NodeWindows(window->DC.ChildWindows, "ChildWindows");
                ImGui::BulletText("Storage: %d bytes", window->StateStorage.Data.Size * (int)sizeof(ImGuiStorage::Pair));
                ImGui::TreePop();
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rcx
movl $0x1, %r8d
cmpb $0x0, 0x70(%rdi)
jne 0x240c8
movzbl 0x71(%rbx), %r8d
leaq 0x1ae92(%rip), %rsi     # 0x3ef61
movq %rbx, %rdi
movq %rbx, %r9
xorl %eax, %eax
callq 0x181b3
testb %al, %al
je 0x24142
movq 0x270(%rbx), %rdi
callq 0x23182
movq 0x278(%rbx), %rdi
cmpq %rbx, %rdi
je 0x24104
leaq 0x1ae75(%rip), %rsi     # 0x3ef74
callq 0x240a8
cmpl $0x0, 0x100(%rbx)
jle 0x24120
leaq 0x100(%rbx), %rdi
leaq 0x1ae64(%rip), %rsi     # 0x3ef7f
callq 0x23116
movl 0x258(%rbx), %esi
shll $0x4, %esi
leaq 0x1ae5c(%rip), %rdi     # 0x3ef8c
xorl %eax, %eax
callq 0x17ed5
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22b95
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.h
// Function: ImVector<char>::resize(int)
inline void                 reserve(int new_capacity)
    {
        if (new_capacity <= Capacity) return;
        T* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(value_type));
        memcpy(new_data, Data, (size_t)Size * sizeof(value_type));
        ImGui::MemFree(Data);
        Data = new_data;
        Capacity = new_capacity;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jge 0x24620
testl %eax, %eax
je 0x245bb
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0x245c1
movl $0x8, %r12d
cmpl %ebx, %r12d
cmovlel %ebx, %r12d
cmpl %r12d, %eax
jge 0x24620
movslq %r12d, %rdi
movq 0x30eb9(%rip), %rax     # 0x55490
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2460b
movq 0x30e8b(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x30e7e(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movl %ebx, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_internal.h
// Function: ImGuiDrawContext::ImGuiDrawContext()
ImGuiDrawContext()
    {
        CursorPos = CursorPosPrevLine = CursorStartPos = CursorMaxPos = ImVec2(0.0f, 0.0f);
        CurrentLineHeight = PrevLineHeight = 0.0f;
        CurrentLineTextBaseOffset = PrevLineTextBaseOffset = 0.0f;
        LogLinePosY = -1.0f;
        TreeDepth = 0;
        LastItemID = 0;
        LastItemRect = ImRect(0.0f,0.0f,0.0f,0.0f);
        LastItemHoveredAndUsable = LastItemHoveredRect = false;
        MenuBarAppending = false;
        MenuBarOffsetX = 0.0f;
        StateStorage = NULL;
        LayoutType = ImGuiLayoutType_Vertical;
        ItemWidth = 0.0f;
        ButtonRepeat = false;
        AllowKeyboardFocus = true;
        TextWrapPos = -1.0f;
        ColorEditMode = ImGuiColorEditMode_RGB;
        memset(StackSizesBackup, 0, sizeof(StackSizesBackup));

        ColumnsStartX = 0.0f;
        ColumnsOffsetX = 0.0f;
        ColumnsCurrent = 0;
        ColumnsCount = 1;
        ColumnsStartPos = ImVec2(0.0f, 0.0f);
        ColumnsCellMinY = ColumnsCellMaxY = 0.0f;
        ColumnsShowBorders = true;
        ColumnsSetID = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movabsq $0x7f7fffff7f7fffff, %rax # imm = 0x7F7FFFFF7F7FFFFF
movq %rax, 0x3c(%rdi)
movups %xmm0, 0x58(%rdi)
xorl %eax, %eax
movq %rax, 0xfc(%rdi)
movups %xmm0, 0x118(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xc0(%rdi)
movl $0xbf800000, %ecx       # imm = 0xBF800000
movl %ecx, 0x30(%rdi)
movl %eax, 0x50(%rdi)
movups %xmm0, 0x34(%rdi)
movups %xmm0, 0x3f(%rdi)
movups %xmm0, 0x68(%rdi)
movw $0x1, 0x7c(%rdi)
movl %ecx, 0x78(%rdi)
movups %xmm0, 0xd0(%rdi)
movups %xmm0, 0xe0(%rdi)
movq %rax, 0xf0(%rdi)
movl $0x1, 0xf8(%rdi)
movups %xmm0, 0xfc(%rdi)
movb $0x1, 0x10c(%rdi)
movl %eax, 0x110(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.h
// Function: ImGuiListClipper::Begin(int, float)
void Begin(int count, float height)        // items_height: generally pass GetTextLineHeightWithSpacing() or GetItemsLineHeightWithSpacing()
    {
        IM_ASSERT(ItemsCount == -1);
        ItemsCount = count;
        ItemsHeight = height;
        ImGui::CalcListClipping(ItemsCount, ItemsHeight, &DisplayStart, &DisplayEnd); // calculate how many to clip/display
        ImGui::SetCursorPosY(ImGui::GetCursorPosY() + DisplayStart * ItemsHeight);    // advance cursor
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $-0x1, 0x4(%rdi)
jne 0x24f88
movq %rdi, %rbx
movl %esi, 0x4(%rdi)
movss %xmm0, (%rdi)
leaq 0x8(%rdi), %rax
leaq 0xc(%rdi), %rdx
movl %esi, %edi
movq %rax, %rsi
callq 0xef3b
movq 0x30579(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rax
movb $0x1, %cl
movb %cl, 0x72(%rax)
movss 0xac(%rax), %xmm0
movss 0x1c(%rax), %xmm1
movss 0x50(%rax), %xmm2
subss %xmm1, %xmm0
cvtsi2ssl 0x8(%rbx), %xmm3
addss %xmm2, %xmm0
mulss (%rbx), %xmm3
addss %xmm0, %xmm3
movb %cl, 0x72(%rax)
subss %xmm2, %xmm1
addss %xmm3, %xmm1
movss %xmm1, 0xac(%rax)
movss 0xc4(%rax), %xmm0
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
movss %xmm2, 0xc4(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x19ecc(%rip), %rdi     # 0x3ee5b
leaq 0x19afd(%rip), %rsi     # 0x3ea93
leaq 0x19ecf(%rip), %rcx     # 0x3ee6c
movl $0x3e6, %edx            # imm = 0x3E6
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ImGui::ShowUserGuide()
void ImGui::ShowUserGuide()
{
    ImGui::BulletText("Double-click on title bar to collapse window.");
    ImGui::BulletText("Click and drag on lower right corner to resize window.");
    ImGui::BulletText("Click and drag on any empty space to move window.");
    ImGui::BulletText("Mouse Wheel to scroll.");
    if (ImGui::GetIO().FontAllowUserScaling)
        ImGui::BulletText("CTRL+Mouse Wheel to zoom window contents.");
    ImGui::BulletText("TAB/SHIFT+TAB to cycle through keyboard editable fields.");
    ImGui::BulletText("CTRL+Click on a slider or drag box to input text.");
    ImGui::BulletText(
        "While editing text:\n"
        "- Hold SHIFT or use mouse to select text\n"
        "- CTRL+Left/Right to word jump\n"
        "- CTRL+A or double-click to select all\n"
        "- CTRL+X,CTRL+C,CTRL+V clipboard\n"
        "- CTRL+Z,CTRL+Y undo/redo\n"
        "- ESCAPE to revert\n"
        "- You can apply arithmetic operators +,*,/ on numerical values.\n"
        "  Use +- to subtract.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1a8d5(%rip), %rdi     # 0x3f888
xorl %eax, %eax
callq 0x17ed5
leaq 0x1a8f5(%rip), %rdi     # 0x3f8b6
xorl %eax, %eax
callq 0x17ed5
leaq 0x1a91e(%rip), %rdi     # 0x3f8ed
xorl %eax, %eax
callq 0x17ed5
leaq 0x1a942(%rip), %rdi     # 0x3f91f
xorl %eax, %eax
callq 0x17ed5
callq 0xb1e1
cmpb $0x1, 0x94(%rax)
jne 0x25000
leaq 0x1a93d(%rip), %rdi     # 0x3f936
xorl %eax, %eax
callq 0x17ed5
leaq 0x1c7cd(%rip), %rdi     # 0x417d4
xorl %eax, %eax
callq 0x17ed5
leaq 0x1a94b(%rip), %rdi     # 0x3f960
xorl %eax, %eax
callq 0x17ed5
leaq 0x1a96f(%rip), %rdi     # 0x3f992
xorl %eax, %eax
popq %rbp
jmp 0x17ed5
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_demo.cpp
// Function: ExampleAppConsole::ClearLog()
void    ClearLog()
    {
        for (int i = 0; i < Items.Size; i++)
            free(Items[i]);
        Items.clear();
        ScrollToBottom = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x100(%rdi)
jle 0x2bf3b
xorl %r14d, %r14d
movq 0x108(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7900
incq %r14
movslq 0x100(%rbx), %rax
cmpq %rax, %r14
jl 0x2bf1c
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x2bf5d
xorl %r14d, %r14d
movq %r14, 0x100(%rbx)
callq 0x9065
movq %r14, 0x108(%rbx)
movb $0x1, 0x110(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::ClearFreeMemory()
void ImDrawList::ClearFreeMemory()
{
    CmdBuffer.clear();
    IdxBuffer.clear();
    VtxBuffer.clear();
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.clear();
    _TextureIdStack.clear();
    _Path.clear();
    _ChannelsCurrent = 0;
    _ChannelsCount = 1;
    for (int i = 0; i < _Channels.Size; i++)
    {
        if (i == 0) memset(&_Channels[0], 0, sizeof(_Channels[0]));  // channel 0 is a copy of CmdBuffer/IdxBuffer, don't destruct again
        _Channels[i].CmdBuffer.clear();
        _Channels[i].IdxBuffer.clear();
    }
    _Channels.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2cf6f
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x9065
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2cf88
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
callq 0x9065
movq %r14, 0x18(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2cfa1
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
callq 0x9065
movq %r14, 0x28(%rbx)
movl $0x0, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x2cfc8
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
callq 0x9065
movq %r14, 0x58(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x2cfe1
xorl %r14d, %r14d
movq %r14, 0x60(%rbx)
callq 0x9065
movq %r14, 0x68(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2cffa
xorl %r14d, %r14d
movq %r14, 0x70(%rbx)
callq 0x9065
movq %r14, 0x78(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x80(%rbx)
movl 0x88(%rbx), %eax
testl %eax, %eax
jle 0x2d0b3
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %r15, %r15
jne 0x2d040
testl %eax, %eax
jle 0x2d0e4
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movslq 0x88(%rbx), %rax
cmpq %rax, %r12
jge 0x2d0e4
movq 0x90(%rbx), %r13
movq 0x8(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x2d070
movq %r14, (%r13,%r15)
callq 0x9065
movq %r14, 0x8(%r13,%r15)
movslq 0x88(%rbx), %rax
cmpq %rax, %r12
jge 0x2d0e4
movq 0x90(%rbx), %r13
movq 0x18(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x2d09c
movq %r14, 0x10(%r13,%r15)
callq 0x9065
movq %r14, 0x18(%r13,%r15)
incq %r12
movslq 0x88(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x2d022
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x2d0d5
xorl %r14d, %r14d
movq %r14, 0x88(%rbx)
callq 0x9065
movq %r14, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11cc5(%rip), %rdi     # 0x3edb0
leaq 0x119a1(%rip), %rsi     # 0x3ea93
leaq 0x1a235(%rip), %rcx     # 0x4732e
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddDrawCmd()
void ImDrawList::AddDrawCmd()
{
    ImDrawCmd draw_cmd;
    draw_cmd.ClipRect = _ClipRectStack.Size ? _ClipRectStack.back() : GNullClipRect;
    draw_cmd.TextureId = _TextureIdStack.Size ? _TextureIdStack.back() : NULL;

    IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
    CmdBuffer.push_back(draw_cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %eax
testq %rax, %rax
je 0x2d137
testl %eax, %eax
jle 0x2d284
movq 0x58(%rbx), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x2d13e
leaq 0x2c662(%rip), %rax     # 0x597a0
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
movss 0x8(%rax), %xmm2
movss 0xc(%rax), %xmm3
movl 0x60(%rbx), %eax
testq %rax, %rax
je 0x2d16c
testl %eax, %eax
jle 0x2d29b
movq 0x68(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %r15
jmp 0x2d16f
xorl %r15d, %r15d
ucomiss %xmm0, %xmm2
jb 0x2d265
ucomiss %xmm1, %xmm3
jb 0x2d265
movl (%rbx), %r12d
movl 0x4(%rbx), %eax
cmpl %eax, %r12d
jne 0x2d218
incl %r12d
testl %eax, %eax
je 0x2d1a4
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x2d1a9
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x2d218
movslq %r12d, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
movss %xmm2, -0x28(%rbp)
movss %xmm3, -0x24(%rbp)
callq 0x85d9
movq %rax, %r14
movq 0x8(%rbx), %rsi
movslq (%rbx), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
callq 0x9065
movss -0x24(%rbp), %xmm3
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm1
movss -0x30(%rbp), %xmm0
movq %r14, 0x8(%rbx)
movl %r12d, 0x4(%rbx)
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movl $0x0, (%rax,%rcx)
movss %xmm0, 0x4(%rax,%rcx)
movss %xmm1, 0x8(%rax,%rcx)
movss %xmm2, 0xc(%rax,%rcx)
movss %xmm3, 0x10(%rax,%rcx)
movq %r15, 0x18(%rax,%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax,%rcx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19551(%rip), %rdi     # 0x467bd
leaq 0x195a3(%rip), %rsi     # 0x46816
leaq 0x195b3(%rip), %rcx     # 0x4682d
movl $0x8f, %edx
callq 0x7140
leaq 0x1992a(%rip), %rdi     # 0x46bb5
leaq 0x11801(%rip), %rsi     # 0x3ea93
leaq 0x11a81(%rip), %rcx     # 0x3ed1a
jmp 0x2d2b0
leaq 0x19913(%rip), %rdi     # 0x46bb5
leaq 0x117ea(%rip), %rsi     # 0x3ea93
leaq 0x1a0c7(%rip), %rcx     # 0x47377
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCallback(void (*)(ImDrawList const*, ImDrawCmd const*), void*)
void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
{
    ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
    if (!current_cmd || current_cmd->ElemCount != 0 || current_cmd->UserCallback != NULL)
    {
        AddDrawCmd();
        current_cmd = &CmdBuffer.back();
    }
    current_cmd->UserCallback = callback;
    current_cmd->UserCallbackData = callback_data;

    // Force a new command after us (we function this way so that the most common calls AddLine, AddRect, etc. always have a command to add to without doing any check).
    AddDrawCmd();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
testq %rax, %rax
je 0x2d2ed
testl %eax, %eax
jle 0x2d33d
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x30, %rax
jmp 0x2d2ef
xorl %eax, %eax
testq %rax, %rax
je 0x2d300
cmpl $0x0, (%rax)
jne 0x2d300
cmpq $0x0, 0x20(%rax)
je 0x2d323
movq %r14, %rdi
callq 0x2d104
movslq (%r14), %rax
testq %rax, %rax
jle 0x2d33d
movq 0x8(%r14), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x30, %rax
movq %r15, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2d104
leaq 0x19871(%rip), %rdi     # 0x46bb5
leaq 0x11748(%rip), %rsi     # 0x3ea93
leaq 0x11847(%rip), %rcx     # 0x3eb99
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::UpdateClipRect()
void ImDrawList::UpdateClipRect()
{
    ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
    if (!current_cmd || (current_cmd->ElemCount != 0) || current_cmd->UserCallback != NULL)
    {
        AddDrawCmd();
    }
    else
    {
        ImVec4 current_clip_rect = _ClipRectStack.Size ? _ClipRectStack.back() : GNullClipRect;
        if (CmdBuffer.Size >= 2 && ImLengthSqr(CmdBuffer.Data[CmdBuffer.Size-2].ClipRect - current_clip_rect) < 0.00001f)
            CmdBuffer.pop_back();
        else
            current_cmd->ClipRect = current_clip_rect;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
testq %rax, %rax
je 0x2d384
testl %eax, %eax
jle 0x2d456
movq 0x8(%rdi), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $-0x30, %rcx
jmp 0x2d386
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x2d397
cmpl $0x0, (%rcx)
jne 0x2d397
cmpq $0x0, 0x20(%rcx)
je 0x2d39d
popq %rbp
jmp 0x2d104
movl 0x50(%rdi), %edx
testq %rdx, %rdx
je 0x2d3be
testl %edx, %edx
jle 0x2d475
movq 0x58(%rdi), %rsi
shlq $0x4, %rdx
addq %rsi, %rdx
addq $-0x10, %rdx
jmp 0x2d3c5
leaq 0x2c3db(%rip), %rdx     # 0x597a0
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
movss 0x8(%rdx), %xmm2
movss 0xc(%rdx), %xmm3
cmpl $0x2, %eax
jl 0x2d440
movq 0x8(%rdi), %rdx
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
movss -0x5c(%rdx,%rsi), %xmm4
movss -0x58(%rdx,%rsi), %xmm5
subss %xmm0, %xmm4
subss %xmm1, %xmm5
movss -0x54(%rdx,%rsi), %xmm6
subss %xmm2, %xmm6
movss -0x50(%rdx,%rsi), %xmm7
subss %xmm7, %xmm7
mulss %xmm5, %xmm5
mulss %xmm4, %xmm4
addss %xmm5, %xmm4
mulss %xmm6, %xmm6
addss %xmm4, %xmm6
mulss %xmm7, %xmm7
addss %xmm6, %xmm7
movss 0xff73(%rip), %xmm4     # 0x3d3a8
ucomiss %xmm7, %xmm4
jbe 0x2d440
decl %eax
movl %eax, (%rdi)
jmp 0x2d454
movss %xmm0, 0x4(%rcx)
movss %xmm1, 0x8(%rcx)
movss %xmm2, 0xc(%rcx)
movss %xmm3, 0x10(%rcx)
popq %rbp
retq
leaq 0x19758(%rip), %rdi     # 0x46bb5
leaq 0x1162f(%rip), %rsi     # 0x3ea93
leaq 0x1172e(%rip), %rcx     # 0x3eb99
movl $0x326, %edx            # imm = 0x326
callq 0x7140
leaq 0x19739(%rip), %rdi     # 0x46bb5
leaq 0x11610(%rip), %rsi     # 0x3ea93
leaq 0x11890(%rip), %rcx     # 0x3ed1a
jmp 0x2d46b
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::UpdateTextureID()
void ImDrawList::UpdateTextureID()
{
    ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
    const ImTextureID texture_id = _TextureIdStack.Size ? _TextureIdStack.back() : NULL;
    if (!current_cmd || (current_cmd->ElemCount != 0 && current_cmd->TextureId != texture_id) || current_cmd->UserCallback != NULL)
        AddDrawCmd();
    else
        current_cmd->TextureId = texture_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
testq %rax, %rax
je 0x2d596
testl %eax, %eax
jle 0x2d5d4
movq 0x8(%rdi), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x30, %rax
jmp 0x2d598
xorl %eax, %eax
movl 0x60(%rdi), %ecx
testq %rcx, %rcx
je 0x2d5af
testl %ecx, %ecx
jle 0x2d5eb
movq 0x68(%rdi), %rdx
movq -0x8(%rdx,%rcx,8), %rcx
jmp 0x2d5b1
xorl %ecx, %ecx
testq %rax, %rax
je 0x2d5c8
cmpl $0x0, (%rax)
je 0x2d5c1
cmpq %rcx, 0x18(%rax)
jne 0x2d5c8
cmpq $0x0, 0x20(%rax)
je 0x2d5ce
popq %rbp
jmp 0x2d104
movq %rcx, 0x18(%rax)
popq %rbp
retq
leaq 0x195da(%rip), %rdi     # 0x46bb5
leaq 0x114b1(%rip), %rsi     # 0x3ea93
leaq 0x115b0(%rip), %rcx     # 0x3eb99
jmp 0x2d600
leaq 0x195c3(%rip), %rdi     # 0x46bb5
leaq 0x1149a(%rip), %rsi     # 0x3ea93
leaq 0x19d77(%rip), %rcx     # 0x47377
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::ChannelsSetCurrent(int)
void ImDrawList::ChannelsSetCurrent(int idx)
{
    if (_ChannelsCurrent == idx) return;
    memcpy(&_Channels.Data[_ChannelsCurrent].CmdBuffer, &CmdBuffer, sizeof(CmdBuffer)); // copy 12 bytes, four times
    memcpy(&_Channels.Data[_ChannelsCurrent].IdxBuffer, &IdxBuffer, sizeof(IdxBuffer));
    _ChannelsCurrent = idx;
    memcpy(&CmdBuffer, &_Channels.Data[_ChannelsCurrent].CmdBuffer, sizeof(CmdBuffer));
    memcpy(&IdxBuffer, &_Channels.Data[_ChannelsCurrent].IdxBuffer, sizeof(IdxBuffer));
    _IdxWritePtr = IdxBuffer.Data + IdxBuffer.Size;
}

// Assembly:
movslq 0x80(%rdi), %rax
cmpl %esi, %eax
je 0x2def0
pushq %rbp
movq %rsp, %rbp
movq 0x90(%rdi), %rcx
shlq $0x5, %rax
movups (%rdi), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0x90(%rdi), %rax
movslq 0x80(%rdi), %rcx
shlq $0x5, %rcx
movups 0x10(%rdi), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
movl %esi, 0x80(%rdi)
movq 0x90(%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movups (%rax,%rcx), %xmm0
movups %xmm0, (%rdi)
movups 0x10(%rax,%rcx), %xmm0
movups %xmm0, 0x10(%rdi)
movslq 0x10(%rdi), %rax
addq %rax, %rax
addq 0x18(%rdi), %rax
movq %rax, 0x48(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PrimReserve(int, int)
void ImDrawList::PrimReserve(int idx_count, int vtx_count)
{
    ImDrawCmd& draw_cmd = CmdBuffer.Data[CmdBuffer.Size-1];
    draw_cmd.ElemCount += idx_count;

    int vtx_buffer_size = VtxBuffer.Size;
    VtxBuffer.resize(vtx_buffer_size + vtx_count);
    _VtxWritePtr = VtxBuffer.Data + vtx_buffer_size;

    int idx_buffer_size = IdxBuffer.Size;
    IdxBuffer.resize(idx_buffer_size + idx_count);
    _IdxWritePtr = IdxBuffer.Data + idx_buffer_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addl %esi, -0x30(%rax,%rcx)
movslq 0x20(%rdi), %r13
addl %r13d, %r15d
movl 0x24(%rdi), %eax
cmpl %r15d, %eax
jge 0x2df94
testl %eax, %eax
je 0x2df41
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0x2df47
movl $0x8, %r12d
cmpl %r15d, %r12d
cmovlel %r15d, %r12d
cmpl %r12d, %eax
jge 0x2df94
movslq %r12d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
callq 0x85d9
movq %rax, %rdi
movq %rax, -0x30(%rbp)
movq 0x28(%rbx), %rsi
movslq 0x20(%rbx), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
callq 0x7080
movq 0x28(%rbx), %rdi
callq 0x9065
movq -0x30(%rbp), %rax
movq %rax, 0x28(%rbx)
movl %r12d, 0x24(%rbx)
movl %r15d, 0x20(%rbx)
leaq (,%r13,4), %rax
addq %r13, %rax
shlq $0x2, %rax
addq 0x28(%rbx), %rax
movq %rax, 0x40(%rbx)
movslq 0x10(%rbx), %r12
addl %r12d, %r14d
movl 0x14(%rbx), %eax
cmpl %r14d, %eax
jge 0x2e018
testl %eax, %eax
je 0x2dfd4
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x2dfda
movl $0x8, %r13d
cmpl %r14d, %r13d
cmovlel %r14d, %r13d
cmpl %r13d, %eax
jge 0x2e018
movslq %r13d, %rdi
addq %rdi, %rdi
callq 0x85d9
movq %rax, %r15
movq 0x18(%rbx), %rsi
movslq 0x10(%rbx), %rdx
addq %rdx, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x18(%rbx), %rdi
callq 0x9065
movq %r15, 0x18(%rbx)
movl %r13d, 0x14(%rbx)
movl %r14d, 0x10(%rbx)
addq %r12, %r12
addq 0x18(%rbx), %r12
movq %r12, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq