LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::TextRange::split(char, ImVector<ImGuiTextFilter::TextRange>&)
void ImGuiTextFilter::TextRange::split(char separator, ImVector<TextRange>& out)
{
    out.resize(0);
    const char* wb = b;
    const char* we = wb;
    while (we < e)
    {
        if (*we == separator)
        {
            out.push_back(TextRange(wb, we));
            wb = we + 1;
        }
        we++;
    }
    if (wb != we)
        out.push_back(TextRange(wb, we));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq %rdx, %rdi
xorl %esi, %esi
callq 0x1e218
movq (%r15), %rax
leaq -0x38(%rbp), %r12
movq %rax, %r13
cmpq 0x8(%r15), %r13
jae 0x931e
cmpb %r14b, (%r13)
jne 0x9319
movq %rax, -0x38(%rbp)
movq %r13, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1e256
leaq 0x1(%r13), %rax
incq %r13
jmp 0x92f6
cmpq %rax, %r13
je 0x9336
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq %r13, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1e256
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextFilter::PassFilter(char const*, char const*) const
bool ImGuiTextFilter::PassFilter(const char* text, const char* text_end) const
{
    if (Filters.empty())
        return true;

    if (text == NULL)
        text = "";

    for (int i = 0; i != Filters.Size; i++)
    {
        const TextRange& f = Filters[i];
        if (f.empty())
            continue;
        if (f.front() == '-')
        {
            // Subtract
            if (ImStristr(text, text_end, f.begin()+1, f.end()) != NULL)
                return false;
        }
        else
        {
            // Grep
            if (ImStristr(text, text_end, f.begin(), f.end()) != NULL)
                return true;
        }
    }

    // Implicit * grep
    if (CountGrep == 0)
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x100(%rdi), %eax
testl %eax, %eax
je 0x93ce
movq %rdx, %rbx
movq %rdi, -0x30(%rbp)
leaq 0x100(%rdi), %r15
testq %rsi, %rsi
leaq 0x312b3(%rip), %r12     # 0x3a629
cmovneq %rsi, %r12
xorl %r13d, %r13d
cmpl %eax, %r13d
je 0x93bd
movq %r15, %rdi
movl %r13d, %esi
callq 0x1e326
movq (%rax), %rdx
movq 0x8(%rax), %rcx
cmpq %rcx, %rdx
je 0x93b5
cmpb $0x2d, (%rdx)
setne %r14b
jne 0x93a5
incq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x82f5
testq %rax, %rax
jne 0x93d1
incl %r13d
movl (%r15), %eax
jmp 0x937d
movq -0x30(%rbp), %rax
cmpl $0x0, 0x110(%rax)
sete %r14b
jmp 0x93d1
movb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextBuffer::appendv(char const*, __va_list_tag*)
void ImGuiTextBuffer::appendv(const char* fmt, va_list args)
{
    va_list args_copy;
    va_copy(args_copy, args);

    int len = vsnprintf(NULL, 0, fmt, args);         // FIXME-OPT: could do a first pass write attempt, likely successful on first pass.
    if (len <= 0)
        return;

    const int write_off = Buf.Size;
    const int needed_sz = write_off + len;
    if (write_off + len >= Buf.Capacity)
    {
        int double_capacity = Buf.Capacity * 2;
        Buf.reserve(needed_sz > double_capacity ? needed_sz : double_capacity);
    }

    Buf.resize(needed_sz);
    ImFormatStringV(&Buf[write_off] - 1, len+1, fmt, args_copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %rax
movq %rax, -0x30(%rbp)
movups (%rdx), %xmm0
movaps %xmm0, -0x40(%rbp)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x74d0
testl %eax, %eax
jle 0x946d
movl %eax, %r15d
movl (%r14), %r12d
movl 0x4(%r14), %esi
leal (%r12,%r15), %r13d
cmpl %esi, %r13d
jl 0x9441
addl %esi, %esi
cmpl %esi, %r13d
cmovgl %r13d, %esi
movq %r14, %rdi
callq 0x1e35a
movq %r14, %rdi
movl %r13d, %esi
callq 0x1e3b4
movq %r14, %rdi
movl %r12d, %esi
callq 0x1e3f2
leaq -0x1(%rax), %rdi
incl %r15d
leaq -0x40(%rbp), %rcx
movl %r15d, %esi
movq %rbx, %rdx
callq 0x8446
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiSimpleColumns::Update(int, float, bool)
void ImGuiSimpleColumns::Update(int count, float spacing, bool clear)
{
    IM_ASSERT(Count <= IM_ARRAYSIZE(Pos));
    Count = count;
    Width = NextWidth = 0.0f;
    Spacing = spacing;
    if (clear) memset(NextWidths, 0, sizeof(NextWidths));
    for (int i = 0; i < Count; i++)
    {
        if (i > 0 && NextWidths[i] > 0.0f)
            Width += Spacing;
        Pos[i] = (float)(int)Width;
        Width += NextWidths[i];
        NextWidths[i] = 0.0f;
    }
}

// Assembly:
cmpl $0x9, (%rdi)
jge 0x957e
movl %esi, (%rdi)
andq $0x0, 0x8(%rdi)
movss %xmm0, 0x4(%rdi)
testb %dl, %dl
je 0x9530
xorps %xmm1, %xmm1
movups %xmm1, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpq %rax, %rsi
je 0x957d
testq %rax, %rax
je 0x9558
movss 0x30(%rdi,%rax,4), %xmm3
ucomiss %xmm1, %xmm3
jbe 0x955d
addss %xmm0, %xmm2
jmp 0x955d
movss 0x30(%rdi), %xmm3
cvttps2dq %xmm2, %xmm4
cvtdq2ps %xmm4, %xmm4
movss %xmm4, 0x10(%rdi,%rax,4)
addss %xmm3, %xmm2
movss %xmm2, 0x8(%rdi)
andl $0x0, 0x30(%rdi,%rax,4)
incq %rax
jmp 0x953d
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2d16f(%rip), %rdi     # 0x366f8
leaq 0x2d0dd(%rip), %rsi     # 0x3666d
leaq 0x2d18c(%rip), %rcx     # 0x36723
movl $0x5a2, %edx            # imm = 0x5A2
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiSimpleColumns::DeclColumns(float, float, float)
float ImGuiSimpleColumns::DeclColumns(float w0, float w1, float w2) // not using va_arg because they promote float to double
{
    NextWidth = 0.0f;
    NextWidths[0] = ImMax(NextWidths[0], w0);
    NextWidths[1] = ImMax(NextWidths[1], w1);
    NextWidths[2] = ImMax(NextWidths[2], w2);
    for (int i = 0; i < 3; i++)
        NextWidth += NextWidths[i] + ((i > 0 && NextWidths[i] > 0.0f) ? Spacing : 0.0f);
    return ImMax(Width, NextWidth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss 0x4(%rdi), %xmm3
movss 0x30(%rdi), %xmm4
movaps %xmm0, %xmm5
cmpless %xmm4, %xmm5
andps %xmm5, %xmm4
andnps %xmm0, %xmm5
orps %xmm4, %xmm5
movss %xmm5, 0x30(%rdi)
movss 0x34(%rdi), %xmm0
movaps %xmm1, %xmm4
cmpless %xmm0, %xmm4
andps %xmm4, %xmm0
andnps %xmm1, %xmm4
orps %xmm0, %xmm4
movss %xmm4, 0x34(%rdi)
movss 0x38(%rdi), %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0x38(%rdi)
xorps %xmm1, %xmm1
xorl %eax, %eax
cmpq $0x3, %rax
je 0x962a
movss 0x30(%rdi,%rax,4), %xmm0
xorps %xmm2, %xmm2
testq %rax, %rax
je 0x961d
cmpltss %xmm0, %xmm2
andps %xmm3, %xmm2
addss %xmm2, %xmm0
addss %xmm0, %xmm1
incq %rax
jmp 0x9601
movss %xmm1, 0xc(%rdi)
movss 0x8(%rdi), %xmm2
movaps %xmm1, %xmm0
cmpless %xmm2, %xmm0
andps %xmm0, %xmm2
andnps %xmm1, %xmm0
orps %xmm2, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiWindow::GetID(char const*, char const*)
ImGuiID ImGuiWindow::GetID(const char* str, const char* str_end)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHash(str, str_end ? (int)(str_end - str) : 0, seed);
    ImGui::KeepAliveID(id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x1e6bc
movl (%rax), %edx
movl %ebx, %eax
subl %r14d, %eax
xorl %esi, %esi
testq %rbx, %rbx
cmovnel %eax, %esi
movq %r14, %rdi
callq 0x846d
movq 0x46bf1(%rip), %rcx     # 0x50480
cmpl %eax, 0x1790(%rcx)
jne 0x989e
movb $0x1, 0x1798(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiWindow::~ImGuiWindow()
ImGuiWindow::~ImGuiWindow()
{
    DrawList->~ImDrawList();
    ImGui::MemFree(DrawList);
    DrawList = NULL;
    ImGui::MemFree(Name);
    Name = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x270(%rdi), %rdi
callq 0x1e650
movq 0x270(%rbx), %rdi
callq 0x8d0c
andq $0x0, 0x270(%rbx)
movq (%rbx), %rdi
callq 0x8d0c
andq $0x0, (%rbx)
leaq 0x258(%rbx), %rdi
callq 0x1f972
leaq 0x1d0(%rbx), %rdi
callq 0x1e5c2
addq $0xa8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e5ec
movq %rax, %rdi
callq 0x1e6ad
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiWindow::GetID(void const*)
ImGuiID ImGuiWindow::GetID(const void* ptr)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHash(&ptr, sizeof(void*), seed);
    ImGui::KeepAliveID(id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq %rsi, (%rbx)
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x1e6bc
movl (%rax), %edx
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x846d
movq 0x46b29(%rip), %rcx     # 0x50480
cmpl %eax, 0x1790(%rcx)
jne 0x9966
movb $0x1, 0x1798(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetActiveID(unsigned int, ImGuiWindow*)
void ImGui::SetActiveID(ImGuiID id, ImGuiWindow* window = NULL)
{
    ImGuiState& g = *GImGui;
    g.ActiveId = id;
    g.ActiveIdIsFocusedOnly = false;
    g.ActiveIdIsJustActivated = true;
    g.ActiveIdWindow = window;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x46abf(%rip), %rax     # 0x50480
movl %edi, 0x1790(%rax)
movw $0x1, 0x1799(%rax)
movq %rsi, 0x17a0(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ItemSize(ImVec2 const&, float)
void ImGui::ItemSize(const ImVec2& size, float text_offset_y)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    // Always align ourselves on pixel boundaries
    ImGuiState& g = *GImGui;
    const float line_height = ImMax(window->DC.CurrentLineHeight, size.y);
    const float text_base_offset = ImMax(window->DC.CurrentLineTextBaseOffset, text_offset_y);
    window->DC.CursorPosPrevLine = ImVec2(window->DC.CursorPos.x + size.x, window->DC.CursorPos.y);
    window->DC.CursorPos = ImVec2((float)(int)(window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX), (float)(int)(window->DC.CursorPos.y + line_height + g.Style.ItemSpacing.y));
    window->DC.CursorMaxPos.x = ImMax(window->DC.CursorMaxPos.x, window->DC.CursorPosPrevLine.x);
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, window->DC.CursorPos.y);

    //window->DrawList->AddCircle(window->DC.CursorMaxPos, 3.0f, 0xFF0000FF, 4); // Debug

    window->DC.PrevLineHeight = line_height;
    window->DC.PrevLineTextBaseOffset = text_base_offset;
    window->DC.CurrentLineHeight = window->DC.CurrentLineTextBaseOffset = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x46a9c(%rip), %rcx     # 0x50480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x9af6
movss 0xc8(%rax), %xmm2
movss 0x4(%rdi), %xmm3
movaps %xmm3, %xmm1
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm3, %xmm1
orps %xmm2, %xmm1
movss 0xcc(%rax), %xmm3
movaps %xmm0, %xmm2
cmpless %xmm3, %xmm2
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
movss 0xa8(%rax), %xmm0
addss (%rdi), %xmm0
movss 0x18(%rax), %xmm4
movss 0xac(%rax), %xmm5
movss %xmm0, 0xb0(%rax)
movss %xmm5, 0xb4(%rax)
addss 0x194(%rax), %xmm4
addss 0x198(%rax), %xmm4
orps %xmm3, %xmm2
cvttps2dq %xmm4, %xmm3
cvtdq2ps %xmm3, %xmm3
movaps %xmm1, %xmm4
addss %xmm5, %xmm4
addss 0x1418(%rcx), %xmm4
cvttps2dq %xmm4, %xmm4
cvtdq2ps %xmm4, %xmm4
movss %xmm3, 0xa8(%rax)
movss %xmm4, 0xac(%rax)
movss 0xc0(%rax), %xmm3
movaps %xmm0, %xmm5
cmpless %xmm3, %xmm5
movaps %xmm5, %xmm6
andnps %xmm0, %xmm6
andps %xmm3, %xmm5
orps %xmm6, %xmm5
movss %xmm5, 0xc0(%rax)
movss 0xc4(%rax), %xmm0
movaps %xmm4, %xmm3
cmpless %xmm0, %xmm3
movaps %xmm3, %xmm5
andnps %xmm4, %xmm5
andps %xmm0, %xmm3
orps %xmm5, %xmm3
movss %xmm3, 0xc4(%rax)
movss %xmm1, 0xd0(%rax)
movss %xmm2, 0xd4(%rax)
andq $0x0, 0xc8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ItemAdd(ImRect const&, unsigned int const*)
bool ImGui::ItemAdd(const ImRect& bb, const ImGuiID* id)
{
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.LastItemID = id ? *id : 0;
    window->DC.LastItemRect = bb;
    if (IsClippedEx(bb, id, false))
    {
        window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
        return false;
    }

    // This is a sensible default, but widgets are free to override it after calling ItemAdd()
    ImGuiState& g = *GImGui;
    if (IsMouseHoveringRect(bb.Min, bb.Max))
    {
        // Matching the behavior of IsHovered() but ignore if ActiveId==window->MoveID (we clicked on the window background)
        // So that clicking on items with no active id such as Text() still returns true with IsItemHovered()
        window->DC.LastItemHoveredRect = true;
        window->DC.LastItemHoveredAndUsable = false;
        if (g.HoveredRootWindow == window->RootWindow)
            if (g.ActiveId == 0 || (id && g.ActiveId == *id) || g.ActiveIdIsFocusedOnly || (g.ActiveId == window->MoveID))
                if (IsWindowContentHoverable(window))
                    window->DC.LastItemHoveredAndUsable = true;
    }
    else
    {
        window->DC.LastItemHoveredAndUsable = window->DC.LastItemHoveredRect = false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movq 0x4693d(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
testq %rsi, %rsi
je 0x9b58
movl (%r15), %eax
jmp 0x9b5a
xorl %eax, %eax
movl %eax, 0xe0(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0xe4(%rbx)
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x9c0b
movl %eax, %r14d
testb %al, %al
jne 0x9bed
movq 0x468f9(%rip), %r13     # 0x50480
leaq 0x8(%r12), %rsi
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x9c6a
testb %al, %al
je 0x9bed
movw $0x100, 0xf4(%rbx)      # imm = 0x100
movq 0x1780(%r13), %rax
cmpq 0x278(%rbx), %rax
jne 0x9bf5
movl 0x1790(%r13), %eax
testl %eax, %eax
je 0x9bd8
testq %r15, %r15
je 0x9bc9
cmpl (%r15), %eax
je 0x9bd8
cmpb $0x0, 0x179a(%r13)
jne 0x9bd8
cmpl 0x48(%rbx), %eax
jne 0x9bf5
movq %rbx, %rdi
callq 0x9d24
testb %al, %al
je 0x9bf5
movb $0x1, 0xf4(%rbx)
jmp 0x9bf5
andw $0x0, 0xf4(%rbx)
xorb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsClippedEx(ImRect const&, unsigned int const*, bool)
bool ImGui::IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();

    if (!bb.Overlaps(window->ClipRect))
    {
        if (!id || *id != GImGui->ActiveId)
            if (clip_even_when_logged || !g.LogEnabled)
                return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq 0x4685f(%rip), %r15     # 0x50480
movl $0x1e0, %esi            # imm = 0x1E0
addq 0x1758(%r15), %rsi
callq 0x1e728
testb %al, %al
jne 0x9c5d
testq %r14, %r14
je 0x9c4d
movl (%r14), %eax
movq 0x4683b(%rip), %rcx     # 0x50480
cmpl 0x1790(%rcx), %eax
je 0x9c5d
movb $0x1, %al
testb %bl, %bl
jne 0x9c5f
cmpb $0x1, 0x2be8(%r15)
jne 0x9c5f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseHoveringRect(ImVec2 const&, ImVec2 const&, bool)
bool ImGui::IsMouseHoveringRect(const ImVec2& pos_min, const ImVec2& pos_max, bool clip)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();

    // Clip
    ImRect rect_clipped(pos_min, pos_max);
    if (clip)
        rect_clipped.Clip(window->ClipRect);

    // Expand for touch input
    const ImRect rect_for_touch(rect_clipped.Min - g.Style.TouchExtraPadding, rect_clipped.Max + g.Style.TouchExtraPadding);
    return rect_for_touch.Contains(g.IO.MousePos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq 0x46801(%rip), %rbx     # 0x50480
movq 0x1758(%rbx), %rsi
movq (%rdi), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
testl %edx, %edx
je 0x9cc4
addq $0x1e0, %rsi            # imm = 0x1E0
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x1eb52
movd (%r14), %xmm0
movd 0x4(%r14), %xmm2
movd 0x8(%r14), %xmm1
movd 0xc(%r14), %xmm3
jmp 0x9cdc
movd %ecx, %xmm0
shrq $0x20, %rcx
movd %ecx, %xmm2
movd %eax, %xmm1
shrq $0x20, %rax
movd %eax, %xmm3
movss 0x1424(%rbx), %xmm4
movss 0x1428(%rbx), %xmm5
subss %xmm4, %xmm0
subss %xmm5, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
addss %xmm4, %xmm1
addss %xmm5, %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq -0x30(%rbp), %rdi
movups %xmm0, (%rdi)
addq $0xf0, %rbx
movq %rbx, %rsi
callq 0x1eb9e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: IsWindowContentHoverable(ImGuiWindow*)
static inline bool IsWindowContentHoverable(ImGuiWindow* window)
{
    // An active popup disable hovering on other windows (apart from its own children)
    ImGuiState& g = *GImGui;
    if (ImGuiWindow* focused_window = g.FocusedWindow)
        if (ImGuiWindow* focused_root_window = focused_window->RootWindow)
            if ((focused_root_window->Flags & ImGuiWindowFlags_Popup) != 0 && focused_root_window->WasActive && focused_root_window != window->RootWindow)
                return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x46751(%rip), %rax     # 0x50480
movq 0x1770(%rax), %rcx
movb $0x1, %al
testq %rcx, %rcx
je 0x9d60
movq 0x278(%rcx), %rcx
testq %rcx, %rcx
je 0x9d60
testb $0x2, 0xf(%rcx)
je 0x9d60
cmpb $0x1, 0x71(%rcx)
jne 0x9d60
cmpq 0x278(%rdi), %rcx
je 0x9d60
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsHovered(ImRect const&, unsigned int, bool)
bool ImGui::IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs)
{
    ImGuiState& g = *GImGui;
    if (g.HoveredId == 0 || g.HoveredId == id)
    {
        ImGuiWindow* window = GetCurrentWindowRead();
        if (g.HoveredWindow == window || (flatten_childs && g.HoveredRootWindow == window->RootWindow))
            if ((g.ActiveId == 0 || g.ActiveId == id || g.ActiveIdIsFocusedOnly) && ImGui::IsMouseHoveringRect(bb.Min, bb.Max))
                if (IsWindowContentHoverable(g.HoveredRootWindow))
                    return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x46711(%rip), %rbx     # 0x50480
movl 0x1788(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl %esi, %eax
setne %al
testb %al, %cl
jne 0x9de8
movq 0x1758(%rbx), %rax
cmpq %rax, 0x1778(%rbx)
je 0x9da7
testb %dl, %dl
je 0x9de8
movq 0x1780(%rbx), %rcx
cmpq 0x278(%rax), %rcx
jne 0x9de8
movl 0x1790(%rbx), %eax
testl %eax, %eax
sete %cl
cmpl %esi, %eax
sete %al
orb %cl, %al
jne 0x9dc4
cmpb $0x1, 0x179a(%rbx)
jne 0x9de8
leaq 0x8(%rdi), %rsi
pushq $0x1
popq %rdx
callq 0x9c6a
testb %al, %al
je 0x9de8
movq 0x1780(%rbx), %rdi
callq 0x9d24
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x9dea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::FocusableItemRegister(ImGuiWindow*, bool, bool)
bool ImGui::FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop)
{
    ImGuiState& g = *GImGui;

    const bool allow_keyboard_focus = window->DC.AllowKeyboardFocus;
    window->FocusIdxAllCounter++;
    if (allow_keyboard_focus)
        window->FocusIdxTabCounter++;

    // Process keyboard input at this point: TAB, Shift-TAB switch focus
    // We can always TAB out of a widget that doesn't allow tabbing in.
    if (tab_stop && window->FocusIdxAllRequestNext == IM_INT_MAX && window->FocusIdxTabRequestNext == IM_INT_MAX && is_active && IsKeyPressedMap(ImGuiKey_Tab))
    {
        // Modulo on index will be applied at the end of frame once we've got the total counter of items.
        window->FocusIdxTabRequestNext = window->FocusIdxTabCounter + (g.IO.KeyShift ? (allow_keyboard_focus ? -1 : 0) : +1);
    }

    if (window->FocusIdxAllCounter == window->FocusIdxAllRequestCurrent)
        return true;

    if (allow_keyboard_focus)
        if (window->FocusIdxTabCounter == window->FocusIdxTabRequestCurrent)
            return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x4667a(%rip), %r12     # 0x50480
movb 0x124(%rdi), %r15b
incl 0x288(%rdi)
cmpb $0x1, %r15b
jne 0x9e1f
incl 0x28c(%rbx)
testb %dl, %dl
je 0x9e78
cmpl $0x7fffffff, 0x298(%rbx) # imm = 0x7FFFFFFF
jne 0x9e78
cmpl $0x7fffffff, 0x29c(%rbx) # imm = 0x7FFFFFFF
setne %al
xorb $0x1, %sil
orb %al, %sil
jne 0x9e78
pushq $0x1
popq %r14
xorl %edi, %edi
movl %r14d, %esi
callq 0x9ea6
testb %al, %al
je 0x9e78
movzbl %r15b, %eax
negl %eax
cmpb $0x0, 0x106(%r12)
cmovnel %eax, %r14d
addl 0x28c(%rbx), %r14d
movl %r14d, 0x29c(%rbx)
movl 0x288(%rbx), %ecx
movb $0x1, %al
cmpl 0x290(%rbx), %ecx
je 0x9e9d
testb %r15b, %r15b
je 0x9e9b
movl 0x28c(%rbx), %ecx
cmpl 0x294(%rbx), %ecx
je 0x9e9d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemSize(ImVec2, float, float)
ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_x, float default_y)
{
    ImGuiState& g = *GImGui;
    ImVec2 content_max;
    if (size.x < 0.0f || size.y < 0.0f)
        content_max = g.CurrentWindow->Pos + ImGui::GetContentRegionMax();
    if (size.x <= 0.0f)
        size.x = (size.x == 0.0f) ? default_x : ImMax(content_max.x - g.CurrentWindow->DC.CursorPos.x, 4.0f) + size.x;
    if (size.y <= 0.0f)
        size.y = (size.y == 0.0f) ? default_y : ImMax(content_max.y - g.CurrentWindow->DC.CursorPos.y, 4.0f) + size.y;
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movaps %xmm0, %xmm3
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm4     # xmm4 = xmm4[1,1],xmm0[1,1]
movq 0x46595(%rip), %rbx     # 0x50480
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
ja 0x9efb
xorps %xmm6, %xmm6
ucomiss %xmm4, %xmm0
jbe 0x9f3e
movq 0x1758(%rbx), %r14
movaps %xmm3, -0x50(%rbp)
movaps %xmm4, -0x40(%rbp)
movaps %xmm2, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0x9fb7
movaps -0x20(%rbp), %xmm1
movaps -0x30(%rbp), %xmm2
movaps -0x40(%rbp), %xmm4
movaps -0x50(%rbp), %xmm3
movss 0x18(%r14), %xmm6
addss %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0x1c(%r14), %xmm0
unpcklps %xmm0, %xmm6            # xmm6 = xmm6[0],xmm0[0],xmm6[1],xmm0[1]
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
jb 0x9f73
ucomiss %xmm0, %xmm3
jne 0x9f4d
jnp 0x9f6f
movq 0x1758(%rbx), %rax
movss 0xa8(%rax), %xmm5
movaps %xmm6, %xmm1
subss %xmm5, %xmm1
maxss 0x2c449(%rip), %xmm1    # 0x363b4
addss %xmm3, %xmm1
movss %xmm1, %xmm3            # xmm3 = xmm1[0],xmm3[1,2,3]
ucomiss %xmm4, %xmm0
jb 0x9fab
ucomiss %xmm0, %xmm4
jne 0x9f7f
jnp 0x9fa1
shufps $0x55, %xmm6, %xmm6     # xmm6 = xmm6[1,1,1,1]
movq 0x1758(%rbx), %rax
subss 0xac(%rax), %xmm6
maxss 0x2c41a(%rip), %xmm6    # 0x363b4
addss %xmm6, %xmm4
movaps %xmm4, %xmm2
movlhps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm2     # xmm2 = xmm2[2,0],xmm3[2,3]
movaps %xmm2, %xmm3
movaps %xmm3, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetContentRegionMax()
ImVec2 ImGui::GetContentRegionMax()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImVec2 content_region_size = ImVec2(window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x - window->ScrollbarSizes.x, window->SizeContentsExplicit.y ? window->SizeContentsExplicit.y : window->Size.y - window->ScrollbarSizes.y);
    ImVec2 mx = content_region_size - window->Scroll - window->WindowPadding;
    if (window->DC.ColumnsCount != 1)
        mx.x = ImGui::GetColumnOffset(window->DC.ColumnsCurrent + 1) - window->WindowPadding.x;
    return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq 0x464b9(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movss 0x38(%rbx), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jne 0x9fe7
jp 0x9fe7
movss 0x20(%rbx), %xmm2
subss 0x68(%rbx), %xmm2
movss 0x3c(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jne 0x9ffd
jp 0x9ffd
movss 0x24(%rbx), %xmm0
subss 0x6c(%rbx), %xmm0
subss 0x4c(%rbx), %xmm2
subss 0x50(%rbx), %xmm0
subss 0x40(%rbx), %xmm2
subss 0x44(%rbx), %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
cmpl $0x1, 0x1a0(%rbx)
je 0xa03b
movl 0x19c(%rbx), %edi
incl %edi
movaps %xmm2, -0x20(%rbp)
callq 0x11b7f
movaps -0x20(%rbp), %xmm2
subss 0x40(%rbx), %xmm0
movss %xmm0, %xmm2            # xmm2 = xmm0[0],xmm2[1,2,3]
movaps %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcWrapWidthForPos(ImVec2 const&, float)
float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
    if (wrap_pos_x < 0.0f)
        return 0.0f;

    ImGuiWindow* window = GetCurrentWindowRead();
    if (wrap_pos_x == 0.0f)
        wrap_pos_x = ImGui::GetContentRegionMax().x + window->Pos.x;
    else if (wrap_pos_x > 0.0f)
        wrap_pos_x += window->Pos.x - window->Scroll.x; // wrap_pos_x is provided is window local space

    const float wrap_width = wrap_pos_x > 0.0f ? ImMax(wrap_pos_x - pos.x, 0.00001f) : 0.0f;
    return wrap_width;
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0xa0a9
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x46422(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xa07c
jp 0xa07c
callq 0x9fb7
addss 0x18(%r14), %xmm0
jmp 0xa08e
jbe 0xa08e
movss 0x18(%r14), %xmm1
subss 0x4c(%r14), %xmm1
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xa0a5
subss (%rbx), %xmm0
maxss 0x2c316(%rip), %xmm0    # 0x363b8
movaps %xmm0, %xmm1
popq %rbx
popq %r14
popq %rbp
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetCurrentFont(ImFont*)
static void SetCurrentFont(ImFont* font)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(font && font->IsLoaded());
    IM_ASSERT(font->Scale > 0.0f);
    g.Font = font;
    g.FontBaseSize = g.IO.FontGlobalScale * g.Font->FontSize * g.Font->Scale;
    g.FontSize = g.CurrentWindow ? g.CurrentWindow->CalcFontSize() : 0.0f;
    g.FontTexUvWhitePixel = g.Font->ContainerAtlas->TexUvWhitePixel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xadf8
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xadf8
movss 0x4(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xae17
movq 0x456d3(%rip), %rcx     # 0x50480
movq %rdi, 0x1710(%rcx)
movss 0x98(%rcx), %xmm2
mulss (%rdi), %xmm2
mulss %xmm2, %xmm0
movss %xmm0, 0x171c(%rcx)
movq 0x1758(%rcx), %rdx
testq %rdx, %rdx
je 0xade3
mulss 0x268(%rdx), %xmm0
movaps %xmm0, %xmm1
movss %xmm1, 0x1718(%rcx)
movq 0x24(%rax), %rax
movq %rax, 0x1720(%rcx)
popq %rbp
retq
leaq 0x2cf73(%rip), %rdi     # 0x37d72
leaq 0x2b867(%rip), %rsi     # 0x3666d
leaq 0x2cf7e(%rip), %rcx     # 0x37d8b
movl $0x1067, %edx           # imm = 0x1067
callq 0x7140
leaq 0x2cf8b(%rip), %rdi     # 0x37da9
leaq 0x2b848(%rip), %rsi     # 0x3666d
leaq 0x2cf5f(%rip), %rcx     # 0x37d8b
movl $0x1068, %edx           # imm = 0x1068
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindHoveredWindow(ImVec2, bool)
static ImGuiWindow* FindHoveredWindow(ImVec2 pos, bool excluding_childs)
{
    ImGuiState& g = *GImGui;
    for (int i = g.Windows.Size-1; i >= 0; i--)
    {
        ImGuiWindow* window = g.Windows[i];
        if (!window->Active)
            continue;
        if (window->Flags & ImGuiWindowFlags_NoInputs)
            continue;
        if (excluding_childs && (window->Flags & ImGuiWindowFlags_ChildWindow) != 0)
            continue;

        // Using the clipped AABB so a child window will typically be clipped by its parent.
        ImRect bb(window->ClippedWindowRect.Min - g.Style.TouchExtraPadding, window->ClippedWindowRect.Max + g.Style.TouchExtraPadding);
        if (bb.Contains(pos))
            return window;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
movq 0x454bd(%rip), %r12     # 0x50480
leaq 0x1738(%r12), %r14
movl 0x1738(%r12), %r15d
movaps %xmm0, -0x40(%rbp)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, -0x30(%rbp)
testl %r15d, %r15d
jle 0xb06f
decl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x1e6f4
movq (%rax), %rax
cmpb $0x1, 0x70(%rax)
jne 0xafdf
movl 0xc(%rax), %ecx
btl $0x9, %ecx
jb 0xafdf
shrl $0x14, %ecx
testb %bl, %cl
jne 0xafdf
movss 0x1f0(%rax), %xmm1
movss 0x1424(%r12), %xmm0
subss %xmm0, %xmm1
movaps -0x40(%rbp), %xmm2
ucomiss %xmm1, %xmm2
jb 0xafdf
movss 0x1428(%r12), %xmm1
movss 0x1f4(%rax), %xmm2
subss %xmm1, %xmm2
movaps -0x30(%rbp), %xmm3
ucomiss %xmm2, %xmm3
jb 0xafdf
addss 0x1f8(%rax), %xmm0
ucomiss -0x40(%rbp), %xmm0
jbe 0xafdf
addss 0x1fc(%rax), %xmm1
ucomiss -0x30(%rbp), %xmm1
jbe 0xafdf
jmp 0xb071
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetFrontMostModalRootWindow()
static ImGuiWindow* GetFrontMostModalRootWindow()
{
    ImGuiState& g = *GImGui;
    if (!g.OpenedPopupStack.empty())
        if (ImGuiWindow* front_most_popup = g.OpenedPopupStack.back().Window)
            if (front_most_popup->Flags & ImGuiWindowFlags_Modal)
                return front_most_popup;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x453f7(%rip), %rdi     # 0x50480
cmpl $0x0, 0x17f8(%rdi)
je 0xb0ad
addq $0x17f8, %rdi           # imm = 0x17F8
callq 0x1fcea
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xb0ad
testb $0x4, 0xf(%rax)
jne 0xb0af
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::End()
void ImGui::End()
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    ImGui::Columns(1, "#CloseColumns");
    PopClipRect();   // inner window clip rectangle

    // Stop logging
    if (!(window->Flags & ImGuiWindowFlags_ChildWindow))    // FIXME: add more options for scope of logging
        ImGui::LogFinish();

    // Pop
    // NB: we don't clear 'window->RootWindow'. The pointer is allowed to live until the next call to Begin().
    g.CurrentWindowStack.pop_back();
    if (window->Flags & ImGuiWindowFlags_Popup)
        g.CurrentPopupStack.pop_back();
    CheckStacksSize(window, false);
    SetCurrentWindow(g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x44f59(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rbx
leaq 0x2b8e5(%rip), %rsi     # 0x36e1a
pushq $0x1
popq %rdi
movl %edi, %edx
callq 0x10eb3
callq 0x112a5
testb $0x10, 0xe(%rbx)
jne 0xb54f
callq 0x112ea
leaq 0x1760(%r14), %r15
movq %r15, %rdi
callq 0x1efb8
testb $0x2, 0xf(%rbx)
je 0xb573
addq $0x1808, %r14           # imm = 0x1808
movq %r14, %rdi
callq 0x1efe6
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x101ce
cmpl $0x0, (%r15)
je 0xb591
movq %r15, %rdi
callq 0x1ecd8
movq (%rax), %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1019d
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::FocusWindow(ImGuiWindow*)
void ImGui::FocusWindow(ImGuiWindow* window)
{
    ImGuiState& g = *GImGui;

    // Always mark the window we passed as focused. This is used for keyboard interactions such as tabbing.
    g.FocusedWindow = window;

    // Passing NULL allow to disable keyboard focus
    if (!window)
        return;

    // And move its root window to the top of the pile
    if (window->RootWindow)
        window = window->RootWindow;

    // Steal focus on active widgets
    if (window->Flags & ImGuiWindowFlags_Popup) // FIXME: This statement should be unnecessary. Need further testing before removing it..
        if (g.ActiveId != 0 && g.ActiveIdWindow && g.ActiveIdWindow->RootWindow != window)
            ImGui::SetActiveID(0);

    if (g.Windows.back() == window)
        return;

    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i] == window)
        {
            g.Windows.erase(g.Windows.begin() + i);
            break;
        }
    g.Windows.push_back(window);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq 0x44ec4(%rip), %r13     # 0x50480
movq %rdi, 0x1770(%r13)
testq %rdi, %rdi
je 0xb677
movq %rdi, %rbx
movq 0x278(%rdi), %rax
testq %rax, %rax
je 0xb5e2
movq %rax, -0x30(%rbp)
movq %rax, %rbx
testb $0x2, 0xf(%rbx)
je 0xb621
cmpl $0x0, 0x1790(%r13)
je 0xb621
movq 0x17a0(%r13), %rax
testq %rax, %rax
je 0xb621
cmpq %rbx, 0x278(%rax)
je 0xb621
andl $0x0, 0x1790(%r13)
movw $0x1, 0x1799(%r13)
andq $0x0, 0x17a0(%r13)
leaq 0x1738(%r13), %r14
movq %r14, %rdi
callq 0x1ecd8
cmpq %rbx, (%rax)
je 0xb677
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl (%r14), %r12d
jge 0xb66b
movq %r14, %rdi
movl %r12d, %esi
callq 0x1e6f4
cmpq %rbx, (%rax)
je 0xb659
incl %r12d
addq $0x8, %r15
jmp 0xb63b
addq 0x1740(%r13), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f014
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x1ed10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %rsi, (%r14)
movq %r14, %rsi
callq 0x1ed10
movq (%r14), %rax
cmpb $0x1, 0x70(%rax)
jne 0xb710
movslq 0x100(%rax), %r14
cmpq $0x2, %r14
jl 0xb6d6
movq 0x108(%rax), %rdi
leaq 0x11cfe(%rip), %rcx     # 0x1d3c9
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x7520
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
movl $0x100, %r12d           # imm = 0x100
cmpl %r15d, %r14d
je 0xb710
movq -0x28(%rbp), %rdi
addq %r12, %rdi
movl %r15d, %esi
callq 0x1e6f4
movq (%rax), %rsi
cmpb $0x1, 0x70(%rsi)
jne 0xb70b
movq %rbx, %rdi
callq 0xb686
incl %r15d
jmp 0xb6e6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 0xc01b
addq $0x100, %rbx            # imm = 0x100
xorl %r15d, %r15d
cmpl (%rbx), %r15d
jge 0xc010
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1e6f4
movq (%rax), %rsi
cmpb $0x1, 0x70(%rsi)
jne 0xc00b
testb $0x2, 0xf(%rsi)
je 0xc003
cmpl $0x0, 0x90(%rsi)
jg 0xc00b
movq %r14, %rdi
callq 0xbfb5
incl %r15d
jmp 0xbfdb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, -0x18(%rbp)
cmpl $0x0, (%rsi)
je 0xc084
movq %rsi, %r14
cmpl $0x0, 0x20(%rsi)
je 0xc084
movq %rdi, %rbx
movq %r14, %rdi
callq 0x1fac8
cmpl $0x0, (%rax)
jne 0xc050
movq %r14, %rdi
callq 0x1fb04
leaq -0x18(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fb32
movq (%r14), %rax
cmpl $0x10001, 0x38(%rax)    # imm = 0x10001
jae 0xc08d
movl 0x20(%rax), %ecx
movq 0x4440b(%rip), %rdx     # 0x50480
addl %ecx, 0x338(%rdx)
movl 0x10(%rax), %eax
addl %eax, 0x33c(%rdx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2ba67(%rip), %rdi     # 0x37afb
leaq 0x2a5d2(%rip), %rsi     # 0x3666d
leaq 0x2ba9a(%rip), %rcx     # 0x37b3c
movl $0x8ab, %edx            # imm = 0x8AB
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc0e1
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 0x44375(%rip), %rax     # 0x50480
cmpb $0x1, 0x2be8(%rax)
jne 0xc165
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 0xc152
leaq -0x20(%rbp), %rdx
movq %r10, %rsi
callq 0x77b0
jmp 0xc165
movq 0x2bf8(%rax), %rdi
leaq -0x20(%rbp), %rdx
movq %r10, %rsi
callq 0x93e4
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0x442f0(%rip), %r12     # 0x50480
movq 0x1758(%r12), %r15
movb $0x1, 0x72(%r15)
testl %edx, %edx
je 0xc1b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc24f
movq %rax, %r14
jmp 0xc1c4
testq %r14, %r14
jne 0xc1c4
movq %rbx, %rdi
callq 0x7300
movq %rax, %r14
addq %rbx, %r14
movl %r14d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0xc240
movq 0x270(%r15), %rax
movq %rax, -0x40(%rbp)
movq 0x1710(%r12), %r13
movss 0x1718(%r12), %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x2a199(%rip), %xmm0    # 0x36390
movq %r15, %rdi
xorl %esi, %esi
callq 0x1eae4
andq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
xorps %xmm1, %xmm1
movq -0x40(%rbp), %rdi
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x29d4c
cmpb $0x1, 0x2be8(%r12)
jne 0xc240
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc29f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 0x44217(%rip), %rdx     # 0x50480
cmpl $0x0, 0x17c4(%rdx)
jle 0xc298
cmpq %rcx, %rax
jae 0xc29d
cmpb $0x0, (%rax)
je 0xc29d
incq %rax
jmp 0xc272
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0xc28f
testl %edx, %edx
jne 0xc295
jmp 0xc29d
cmpb $0x23, 0x1(%rax)
je 0xc29d
incq %rax
cmpq %rcx, %rax
jb 0xc281
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movss %xmm1, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0x4408e(%rip), %r12     # 0x50480
movq 0x1758(%r12), %r15
movb $0x1, 0x72(%r15)
testq %rsi, %rsi
jne 0xc412
movq %rbx, %rdi
callq 0x7300
movq %rax, %r14
addq %rbx, %r14
movl %r14d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0xc490
movq 0x270(%r15), %rax
movq %rax, -0x40(%rbp)
movq 0x1710(%r12), %r13
movss 0x1718(%r12), %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x29f4b(%rip), %xmm0    # 0x36390
movq %r15, %rdi
xorl %esi, %esi
callq 0x1eae4
andq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
movss -0x30(%rbp), %xmm1
callq 0x29d4c
cmpb $0x1, 0x2be8(%r12)
jne 0xc490
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc29f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x43d83(%rip), %r15     # 0x50480
testl %edx, %edx
je 0xc716
movq %rbx, %rdi
movq %rax, %rsi
movss %xmm2, -0x1c(%rbp)
callq 0xc24f
movss -0x1c(%rbp), %xmm2
movq 0x1710(%r15), %r14
movss 0x1718(%r15), %xmm0
movss 0x29ca6(%rip), %xmm1    # 0x363d4
movq %r14, %rdi
movss %xmm0, -0x1c(%rbp)
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2e77e
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc760
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