LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x4(%rdx), %r15d
testl %r15d, %r15d
movq %rdi, -0x38(%rbp)
jns 0x9e9f
movq 0x4b633(%rip), %rax     # 0x55480
incl 0x334(%rax)
xorl %r15d, %r15d
xorl %edi, %edi
callq *0xd0(%rax)
movq %rax, %r12
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
movq 0x4b601(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9e8a
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r12, 0x8(%rbx)
movl $0x0, 0x4(%rbx)
movq -0x38(%rbp), %rdi
movl $0x0, (%rbx)
movq (%rdi), %r13
movq 0x8(%rdi), %rcx
cmpq %rcx, %r13
jae 0xa02e
xorl %eax, %eax
movq %r13, %rdx
movl %r14d, -0x2c(%rbp)
cmpb %r14b, (%r13)
jne 0x9f77
cmpl %r15d, %eax
jne 0x9ee5
movq %rdx, %r14
testl %r15d, %r15d
je 0x9eeb
movl %r15d, %eax
shrl $0x1f, %eax
addl %r15d, %eax
sarl %eax
addl %r15d, %eax
jmp 0x9ef0
movq 0x8(%rbx), %r12
jmp 0x9f5b
movl $0x8, %eax
incl %r15d
cmpl %r15d, %eax
cmovgl %eax, %r15d
movslq %r15d, %rdi
shlq $0x4, %rdi
movq 0x4b578(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r12
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
movq 0x4b54b(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x9f40
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r12, 0x8(%rbx)
movl %r15d, 0x4(%rbx)
movl (%rbx), %eax
movq %r14, %rdx
movl -0x2c(%rbp), %r14d
movq -0x38(%rbp), %rdi
movslq %eax, %rcx
incl %eax
movl %eax, (%rbx)
shlq $0x4, %rcx
movq %rdx, (%r12,%rcx)
movq %r13, 0x8(%r12,%rcx)
leaq 0x1(%r13), %rdx
movq 0x8(%rdi), %rcx
incq %r13
cmpq %rcx, %r13
jb 0x9ebe
cmpq %rdx, %r13
je 0xa02e
cmpl %r15d, %eax
jne 0x9fae
leal 0x1(%r15), %r12d
testl %r15d, %r15d
movq %rdx, -0x40(%rbp)
je 0x9fb4
movl %r15d, %eax
shrl $0x1f, %eax
addl %r15d, %eax
sarl %eax
addl %r15d, %eax
jmp 0x9fb9
movq 0x8(%rbx), %r14
jmp 0xa01a
movl $0x8, %eax
cmpl %r12d, %eax
cmovgl %eax, %r12d
movslq %r12d, %rdi
shlq $0x4, %rdi
movq 0x4b4b2(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rsi
movslq (%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%rbx), %rdi
movq 0x4b485(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xa006
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r14, 0x8(%rbx)
movl %r12d, 0x4(%rbx)
movl (%rbx), %eax
movq -0x40(%rbp), %rdx
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cltq
shlq $0x4, %rax
movq %rdx, (%r14,%rax)
movq %r13, 0x8(%r14,%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl 0x100(%rdi), %r13d
testq %r13, %r13
je 0xa0de
testq %rsi, %rsi
leaq 0x373d0(%rip), %rax     # 0x41439
cmovneq %rsi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movq 0x108(%rdi), %r14
xorl %ebx, %ebx
testl %r13d, %r13d
movl $0x0, %r15d
cmovgl %r13d, %r15d
shlq $0x4, %r15
shlq $0x4, %r13
cmpq %rbx, %r15
je 0xa0f3
movq (%r14,%rbx), %rdx
movq 0x8(%r14,%rbx), %rcx
cmpq %rcx, %rdx
je 0xa0c4
cmpb $0x2d, (%rdx)
setne %r12b
jne 0xa0b2
incq %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x85ba
testq %rax, %rax
jne 0xa0e1
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0xa093
movq -0x40(%rbp), %rax
cmpl $0x0, 0x110(%rax)
sete %r12b
jmp 0xa0e1
movb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34ce6(%rip), %rdi     # 0x3ede0
leaq 0x349c2(%rip), %rsi     # 0x3eac3
leaq 0x3508b(%rip), %rcx     # 0x3f193
movl $0x31d, %edx            # imm = 0x31D
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %rax
movq %rax, -0x40(%rbp)
movups (%rdx), %xmm0
movaps %xmm0, -0x50(%rbp)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x74d0
testl %eax, %eax
jle 0xa224
movl %eax, %r15d
movq %rbx, -0x38(%rbp)
movslq (%r14), %rcx
leal (%rcx,%r15), %ebx
movl 0x4(%r14), %eax
cmpl %eax, %ebx
jl 0xa17b
leal (%rax,%rax), %r13d
cmpl %r13d, %ebx
cmovgl %ebx, %r13d
cmpl %r13d, %eax
jge 0xa17b
movq %rcx, -0x30(%rbp)
jmp 0xa1ac
cmpl %ebx, %eax
jge 0xa199
testl %eax, %eax
movq %rcx, -0x30(%rbp)
je 0xa19f
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0xa1a5
movq 0x8(%r14), %r12
jmp 0xa1fc
movl $0x8, %r13d
cmpl %ebx, %r13d
cmovlel %ebx, %r13d
movslq %r13d, %rdi
movq 0x4b2ca(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r12
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x4b2a1(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xa1ea
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r12, 0x8(%r14)
movl %r13d, 0x4(%r14)
movq -0x30(%rbp), %rcx
movl %ebx, (%r14)
leaq (%r12,%rcx), %rbx
leaq (%r12,%rcx), %rdi
decq %rdi
movl %r15d, %r14d
leaq 0x1(%r14), %rsi
leaq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
callq 0x74d0
movb $0x0, -0x1(%r14,%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa341
movl %esi, (%rdi)
movq $0x0, 0x8(%rdi)
movss %xmm0, 0x4(%rdi)
testb %dl, %dl
je 0xa2eb
xorps %xmm1, %xmm1
movups %xmm1, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
testl %esi, %esi
jle 0xa340
movl %esi, %eax
xorps %xmm1, %xmm1
xorl %ecx, %ecx
xorps %xmm2, %xmm2
testq %rcx, %rcx
je 0xa30f
movss 0x30(%rdi,%rcx,4), %xmm3
ucomiss %xmm1, %xmm3
jbe 0xa314
addss %xmm0, %xmm2
jmp 0xa314
movss 0x30(%rdi), %xmm3
movaps %xmm2, %xmm4
cvttps2dq %xmm2, %xmm2
cvtdq2ps %xmm2, %xmm2
movss %xmm2, 0x10(%rdi,%rcx,4)
movaps %xmm3, %xmm2
addss %xmm4, %xmm2
movl $0x0, 0x30(%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xa2f9
movss %xmm2, 0x8(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x333f4(%rip), %rdi     # 0x3d740
leaq 0x33362(%rip), %rsi     # 0x3d6b5
leaq 0x33411(%rip), %rcx     # 0x3d76b
movl $0x5a2, %edx            # imm = 0x5A2
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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
movss 0x30(%rdi,%rax,4), %xmm0
xorps %xmm2, %xmm2
testq %rax, %rax
je 0xa3d9
cmpltss %xmm0, %xmm2
andps %xmm3, %xmm2
addss %xmm2, %xmm0
addss %xmm0, %xmm1
incq %rax
cmpq $0x3, %rax
jne 0xa3c3
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_O3/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
movslq 0x1d0(%rdi), %rax
testq %rax, %rax
jle 0xa7b1
movq 0x1d8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
movl %edx, %edi
subl %esi, %edi
xorl %ecx, %ecx
testq %rdx, %rdx
cmovnel %edi, %ecx
movq %rsi, %rdi
movl %ecx, %esi
movl %eax, %edx
callq 0x8734
movq 0x4ace0(%rip), %rcx     # 0x55480
cmpl %eax, 0x1790(%rcx)
jne 0xa7af
movb $0x1, 0x1798(%rcx)
popq %rbp
retq
leaq 0x3c37d(%rip), %rdi     # 0x46b35
leaq 0x34304(%rip), %rsi     # 0x3eac3
leaq 0x34a3c(%rip), %rcx     # 0x3f202
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2443c
movq 0x270(%rbx), %rdi
movq 0x4ac8d(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xa7fe
decl 0x334(%rax)
callq *0xd8(%rax)
movq $0x0, 0x270(%rbx)
movq (%rbx), %rdi
movq 0x4ac67(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xa824
decl 0x334(%rax)
callq *0xd8(%rax)
movq $0x0, (%rbx)
leaq 0x258(%rbx), %rdi
callq 0x24aa8
leaq 0x1d0(%rbx), %rdi
callq 0x243ae
leaq 0x1c0(%rbx), %rdi
callq 0x2492e
leaq 0x168(%rbx), %rdi
callq 0x24958
leaq 0x158(%rbx), %rdi
callq 0x24982
leaq 0x148(%rbx), %rdi
callq 0x24982
leaq 0x138(%rbx), %rdi
callq 0x2492e
leaq 0x128(%rbx), %rdi
callq 0x2492e
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x248b0
movq %rax, %rdi
callq 0x24499
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movslq 0x1d0(%rdi), %rax
testq %rax, %rax
jle 0xa917
movq 0x1d8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %edx
leaq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x8734
movq 0x4ab7e(%rip), %rcx     # 0x55480
cmpl %eax, 0x1790(%rcx)
jne 0xa911
movb $0x1, 0x1798(%rcx)
addq $0x10, %rsp
popq %rbp
retq
leaq 0x3c217(%rip), %rdi     # 0x46b35
leaq 0x3419e(%rip), %rsi     # 0x3eac3
leaq 0x348d6(%rip), %rcx     # 0x3f202
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4aafb(%rip), %rax     # 0x55480
movl %edi, 0x1790(%rax)
movw $0x1, 0x1799(%rax)
movq %rsi, 0x17a0(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %r15
movq 0x4a976(%rip), %r13     # 0x55480
movq 0x1758(%r13), %r12
movb $0x1, 0x72(%r12)
testq %rsi, %rsi
je 0xab21
movl (%r14), %eax
jmp 0xab23
xorl %eax, %eax
movl %eax, 0xe0(%r12)
movups (%r15), %xmm0
movups %xmm0, 0xe4(%r12)
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xabfb
movl %eax, %ebx
testb %al, %al
jne 0xabcf
leaq 0x8(%r15), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0xac66
testb %al, %al
je 0xabcf
movw $0x100, 0xf4(%r12) # imm = 0x100
movq 0x1780(%r13), %rax
cmpq 0x278(%r12), %rax
jne 0xabda
movl 0x1790(%r13), %ecx
testl %ecx, %ecx
je 0xaba6
testq %r14, %r14
je 0xab95
cmpl (%r14), %ecx
je 0xaba6
cmpb $0x0, 0x179a(%r13)
jne 0xaba6
cmpl 0x48(%r12), %ecx
jne 0xabda
movq 0x1770(%r13), %rcx
testq %rcx, %rcx
je 0xabc4
movq 0x278(%rcx), %rcx
testq %rcx, %rcx
je 0xabc4
testb $0x2, 0xf(%rcx)
jne 0xabee
movb $0x1, 0xf4(%r12)
jmp 0xabda
movw $0x0, 0xf4(%r12)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rax, %rcx
je 0xabc4
cmpb $0x0, 0x71(%rcx)
jne 0xabda
jmp 0xabc4
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x4a87a(%rip), %rcx     # 0x55480
movq 0x1758(%rcx), %rax
movss 0xc(%rdi), %xmm0
ucomiss 0x1e4(%rax), %xmm0
jbe 0xac44
movss 0x1ec(%rax), %xmm0
ucomiss 0x4(%rdi), %xmm0
jbe 0xac44
movss 0x8(%rdi), %xmm0
ucomiss 0x1e0(%rax), %xmm0
jbe 0xac44
movss 0x1e8(%rax), %xmm0
ucomiss (%rdi), %xmm0
ja 0xac62
testq %rsi, %rsi
je 0xac53
movl (%rsi), %eax
cmpl 0x1790(%rcx), %eax
je 0xac62
movb $0x1, %al
testb %dl, %dl
jne 0xac64
cmpb $0x1, 0x2be8(%rcx)
jne 0xac64
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x4a80f(%rip), %rax     # 0x55480
movss (%rdi), %xmm5
movss 0x4(%rdi), %xmm1
movss (%rsi), %xmm2
movss 0x4(%rsi), %xmm4
testl %edx, %edx
je 0xacc1
movq 0x1758(%rax), %rcx
movss 0x1e0(%rcx), %xmm3
movss 0x1e4(%rcx), %xmm0
maxss %xmm5, %xmm3
maxss %xmm1, %xmm0
movss 0x1e8(%rcx), %xmm1
minss %xmm2, %xmm1
movss 0x1ec(%rcx), %xmm2
ucomiss %xmm2, %xmm4
jbe 0xacca
jmp 0xaccd
movaps %xmm5, %xmm3
movaps %xmm1, %xmm0
movaps %xmm2, %xmm1
movaps %xmm4, %xmm2
movss 0x1424(%rax), %xmm5
subss %xmm5, %xmm3
movss 0xf0(%rax), %xmm4
ucomiss %xmm3, %xmm4
jae 0xacea
xorl %eax, %eax
jmp 0xad1d
movss 0x1428(%rax), %xmm3
addss %xmm3, %xmm2
addss %xmm5, %xmm1
subss %xmm3, %xmm0
movss 0xf4(%rax), %xmm3
cmpltps %xmm1, %xmm4
cmpleps %xmm3, %xmm0
andps %xmm4, %xmm0
ucomiss %xmm3, %xmm2
movd %xmm0, %ecx
seta %al
andb %cl, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a754(%rip), %rbx     # 0x55480
movl 0x1788(%rbx), %eax
testl %eax, %eax
setne %cl
cmpl %esi, %eax
setne %al
testb %al, %cl
jne 0xadcb
movq 0x1758(%rbx), %rax
cmpq %rax, 0x1778(%rbx)
je 0xad68
testb %dl, %dl
je 0xadcb
movq 0x1780(%rbx), %rcx
cmpq 0x278(%rax), %rcx
jne 0xadcb
movl 0x1790(%rbx), %eax
testl %eax, %eax
sete %cl
cmpl %esi, %eax
sete %al
orb %cl, %al
jne 0xad85
cmpb $0x1, 0x179a(%rbx)
jne 0xadcb
leaq 0x8(%rdi), %rsi
movl $0x1, %edx
callq 0xac66
testb %al, %al
je 0xadcb
movq 0x1770(%rbx), %rax
testq %rax, %rax
je 0xadd4
movq 0x278(%rax), %rax
testq %rax, %rax
je 0xadd4
testb $0x2, 0xf(%rax)
je 0xadd4
cmpb $0x1, 0x71(%rax)
jne 0xadd4
movq 0x1780(%rbx), %rcx
cmpq 0x278(%rcx), %rax
je 0xadd4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, %al
jmp 0xadcd
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a693(%rip), %r15     # 0x55480
movb 0x124(%rdi), %r14b
incl 0x288(%rdi)
cmpb $0x1, %r14b
jne 0xae06
incl 0x28c(%rbx)
testb %dl, %dl
je 0xae64
cmpl $0x7fffffff, 0x298(%rbx) # imm = 0x7FFFFFFF
jne 0xae64
cmpl $0x7fffffff, 0x29c(%rbx) # imm = 0x7FFFFFFF
setne %al
xorb $0x1, %sil
orb %al, %sil
jne 0xae64
movl 0x34(%r15), %edi
movl $0x1, %r12d
movl $0x1, %esi
callq 0xedf5
testb %al, %al
je 0xae64
movzbl %r14b, %eax
negl %eax
cmpb $0x0, 0x106(%r15)
cmovnel %eax, %r12d
addl 0x28c(%rbx), %r12d
movl %r12d, 0x29c(%rbx)
movl 0x288(%rbx), %ecx
movb $0x1, %al
cmpl 0x290(%rbx), %ecx
je 0xae89
testb %r14b, %r14b
je 0xae87
movl 0x28c(%rbx), %ecx
cmpl 0x294(%rbx), %ecx
je 0xae89
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a5c0(%rip), %rbx     # 0x55480
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
ja 0xaed0
xorps %xmm6, %xmm6
ucomiss %xmm4, %xmm0
jbe 0xaf13
movq 0x1758(%rbx), %r14
movaps %xmm3, -0x50(%rbp)
movaps %xmm4, -0x40(%rbp)
movaps %xmm2, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0xaf8c
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 0xaf48
ucomiss %xmm0, %xmm3
jne 0xaf22
jnp 0xaf44
movq 0x1758(%rbx), %rax
movss 0xa8(%rax), %xmm5
movaps %xmm6, %xmm1
subss %xmm5, %xmm1
maxss 0x32470(%rip), %xmm1    # 0x3d3b0
addss %xmm3, %xmm1
movss %xmm1, %xmm3            # xmm3 = xmm1[0],xmm3[1,2,3]
ucomiss %xmm4, %xmm0
jb 0xaf80
ucomiss %xmm0, %xmm4
jne 0xaf54
jnp 0xaf76
shufps $0x55, %xmm6, %xmm6     # xmm6 = xmm6[1,1,1,1]
movq 0x1758(%rbx), %rax
subss 0xac(%rax), %xmm6
maxss 0x32441(%rip), %xmm6    # 0x3d3b0
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_O3/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 0x4a4e4(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rbx
movss 0x38(%rbx), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jne 0xafbc
jp 0xafbc
movss 0x20(%rbx), %xmm2
subss 0x68(%rbx), %xmm2
movss 0x3c(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jne 0xafd2
jp 0xafd2
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 0xb010
movl 0x19c(%rbx), %edi
incl %edi
movaps %xmm2, -0x20(%rbp)
callq 0x15481
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_O3/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 0xb07e
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4a44d(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xb051
jp 0xb051
callq 0xaf8c
addss 0x18(%r14), %xmm0
jmp 0xb063
jbe 0xb063
movss 0x18(%r14), %xmm1
subss 0x4c(%r14), %xmm1
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xb07a
subss (%rbx), %xmm0
maxss 0x3233d(%rip), %xmm0    # 0x3d3b4
movaps %xmm0, %xmm1
popq %rbx
popq %r14
popq %rbp
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc0ef
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc0ef
movss 0x4(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc10e
movq 0x493dc(%rip), %rcx     # 0x55480
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 0xc0da
mulss 0x268(%rdx), %xmm0
movaps %xmm0, %xmm1
movss %xmm1, 0x1718(%rcx)
movq 0x24(%rax), %rax
movq %rax, 0x1720(%rcx)
popq %rbp
retq
leaq 0x32c8f(%rip), %rdi     # 0x3ed85
leaq 0x315b8(%rip), %rsi     # 0x3d6b5
leaq 0x32c9a(%rip), %rcx     # 0x3ed9e
movl $0x1067, %edx           # imm = 0x1067
callq 0x7140
leaq 0x32ca7(%rip), %rdi     # 0x3edbc
leaq 0x31599(%rip), %rsi     # 0x3d6b5
leaq 0x32c7b(%rip), %rcx     # 0x3ed9e
movl $0x1068, %edx           # imm = 0x1068
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x49146(%rip), %rcx     # 0x55480
movslq 0x1738(%rcx), %rdx
testq %rdx, %rdx
jle 0xc3cf
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
movq 0x1740(%rcx), %rsi
incq %rdx
movq -0x10(%rsi,%rdx,8), %rax
cmpb $0x1, 0x70(%rax)
jne 0xc3c6
movl 0xc(%rax), %r8d
btl $0x9, %r8d
jb 0xc3c6
shrl $0x14, %r8d
testb %dil, %r8b
jne 0xc3c6
movss 0x1f0(%rax), %xmm3
movss 0x1424(%rcx), %xmm2
subss %xmm2, %xmm3
ucomiss %xmm3, %xmm0
jb 0xc3c6
movss 0x1428(%rcx), %xmm3
movss 0x1f4(%rax), %xmm4
subss %xmm3, %xmm4
ucomiss %xmm4, %xmm1
jb 0xc3c6
addss 0x1f8(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0xc3c6
addss 0x1fc(%rax), %xmm3
ucomiss %xmm1, %xmm3
ja 0xc3d1
decq %rdx
cmpq $0x1, %rdx
ja 0xc35b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x490a6(%rip), %rax     # 0x55480
movl 0x17f8(%rax), %ecx
testq %rcx, %rcx
je 0xc404
testl %ecx, %ecx
jle 0xc407
movq 0x1800(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movq -0x20(%rax,%rcx,8), %rax
testq %rax, %rax
je 0xc404
testb $0x4, 0xf(%rax)
jne 0xc406
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3a723(%rip), %rdi     # 0x46b35
leaq 0x326aa(%rip), %rsi     # 0x3eac3
leaq 0x3283f(%rip), %rcx     # 0x3ec5f
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq 0x48606(%rip), %r14     # 0x55480
movq %rdi, 0x1770(%r14)
testq %rdi, %rdi
je 0xcfef
movq 0x278(%rdi), %r15
testq %r15, %r15
cmoveq %rdi, %r15
testb $0x2, 0xf(%r15)
je 0xcede
cmpl $0x0, 0x1790(%r14)
je 0xcede
movq 0x17a0(%r14), %rax
testq %rax, %rax
je 0xcede
cmpq %r15, 0x278(%rax)
je 0xcede
movl $0x0, 0x1790(%r14)
movw $0x1, 0x1799(%r14)
movq $0x0, 0x17a0(%r14)
movslq 0x1738(%r14), %rax
testq %rax, %rax
jle 0xcff8
movq 0x1740(%r14), %rdi
cmpq %r15, -0x8(%rdi,%rax,8)
je 0xcfef
movq %rax, %rdx
shlq $0x3, %rdx
xorl %ecx, %ecx
cmpq %r15, (%rdi,%rcx)
je 0xcf1a
addq $0x8, %rcx
cmpq %rcx, %rdx
jne 0xcf09
jmp 0xcf41
leaq (%rdi,%rcx), %rsi
addq $0x8, %rsi
addq %rcx, %rdi
subq %rcx, %rdx
addq $-0x8, %rdx
callq 0x7130
movl 0x1738(%r14), %eax
decl %eax
movl %eax, 0x1738(%r14)
cmpl 0x173c(%r14), %eax
jne 0xcf5f
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0xcf68
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xcf6d
movq 0x1740(%r14), %rbx
jmp 0xcfdf
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x484fe(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %rbx
movq 0x1740(%r14), %rsi
movslq 0x1738(%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x1740(%r14), %rdi
movq 0x484c7(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xcfc4
decl 0x334(%rax)
callq *0xd8(%rax)
movq %rbx, 0x1740(%r14)
movl %r12d, 0x173c(%r14)
movl 0x1738(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1738(%r14)
cltq
movq %r15, (%rbx,%rax,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39b36(%rip), %rdi     # 0x46b35
leaq 0x31abd(%rip), %rsi     # 0x3eac3
leaq 0x32392(%rip), %rcx     # 0x3f39f
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowToSortedBuffer(ImVector<ImGuiWindow*>&, ImGuiWindow*)
static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window)
{
    out_sorted_windows.push_back(window);
    if (window->Active)
    {
        int count = window->DC.ChildWindows.Size;
        if (count > 1)
            qsort(window->DC.ChildWindows.begin(), (size_t)count, sizeof(ImGuiWindow*), ChildWindowComparer);
        for (int i = 0; i < count; i++)
        {
            ImGuiWindow* child = window->DC.ChildWindows[i];
            if (child->Active)
                AddWindowToSortedBuffer(out_sorted_windows, child);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
jne 0xd044
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0xd04a
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xd04f
movq 0x8(%r14), %r15
jmp 0xd0ad
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x4841c(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x483ef(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xd09c
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
cltq
movq %rbx, (%r15,%rax,8)
cmpb $0x1, 0x70(%rbx)
jne 0xd11f
movl 0x100(%rbx), %r15d
cmpl $0x2, %r15d
jl 0xd0e9
movq 0x108(%rbx), %rdi
leaq 0x16340(%rip), %rcx     # 0x2341a
movl $0x8, %edx
movq %r15, %rsi
callq 0x7530
jmp 0xd0ef
cmpl $0x1, %r15d
jne 0xd11f
xorl %r12d, %r12d
movslq 0x100(%rbx), %rax
cmpq %rax, %r12
jge 0xd128
movq 0x108(%rbx), %rax
movq (%rax,%r12,8), %rsi
cmpb $0x1, 0x70(%rsi)
jne 0xd117
movq %r14, %rdi
callq 0xd017
incq %r12
cmpq %r12, %r15
jne 0xd0f2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31cb1(%rip), %rdi     # 0x3ede0
leaq 0x3198d(%rip), %rsi     # 0x3eac3
leaq 0x32103(%rip), %rcx     # 0x3f240
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdccc
movl 0x100(%rbx), %eax
testl %eax, %eax
jle 0xdcc1
xorl %r15d, %r15d
movq 0x108(%rbx), %rcx
movq (%rcx,%r15,8), %rsi
cmpb $0x1, 0x70(%rsi)
jne 0xdcb6
testb $0x2, 0xf(%rsi)
je 0xdca8
cmpl $0x0, 0x90(%rsi)
jg 0xdcb6
movq %r14, %rdi
callq 0xdc5f
movl 0x100(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xdc88
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddDrawListToRenderList(ImVector<ImDrawList*>&, ImDrawList*)
static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list)
{
    if (!draw_list->CmdBuffer.empty() && !draw_list->VtxBuffer.empty())
    {
        if (draw_list->CmdBuffer.back().ElemCount == 0)
            draw_list->CmdBuffer.pop_back();
        out_render_list.push_back(draw_list);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rsi), %eax
testq %rax, %rax
je 0xddc6
movq %rsi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0xddc6
testl %eax, %eax
jle 0xddcf
movq %rdi, %r14
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
cmpl $0x0, -0x30(%rcx,%rdx)
jne 0xdd11
decl %eax
movl %eax, (%rbx)
movl (%r14), %eax
cmpl 0x4(%r14), %eax
jne 0xdd2f
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0xdd35
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xdd3a
movq 0x8(%r14), %r15
jmp 0xdd98
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x47731(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r15
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x8(%r14), %rdi
movq 0x47704(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0xdd87
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
cltq
movq %rbx, (%r15,%rax,8)
cmpl $0x10001, 0x38(%rbx)    # imm = 0x10001
jae 0xddee
movl 0x20(%rbx), %eax
movq 0x476c9(%rip), %rcx     # 0x55480
addl %eax, 0x338(%rcx)
movl 0x10(%rbx), %eax
addl %eax, 0x33c(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38d5f(%rip), %rdi     # 0x46b35
leaq 0x30ce6(%rip), %rsi     # 0x3eac3
leaq 0x30de5(%rip), %rcx     # 0x3ebc9
movl $0x326, %edx            # imm = 0x326
callq 0x7140
leaq 0x30d4e(%rip), %rdi     # 0x3eb43
leaq 0x2f8b9(%rip), %rsi     # 0x3d6b5
leaq 0x30d81(%rip), %rcx     # 0x3eb84
movl $0x8ab, %edx            # imm = 0x8AB
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xde42
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 0x47614(%rip), %rax     # 0x55480
cmpb $0x1, 0x2be8(%rax)
jne 0xdec6
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 0xdeb3
leaq -0x20(%rbp), %rdx
movq %r10, %rsi
callq 0x77d0
jmp 0xdec6
movq 0x2bf8(%rax), %rdi
leaq -0x20(%rbp), %rdx
movq %r10, %rsi
callq 0xa112
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderText(ImVec2, char const*, char const*, bool)
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0x4758f(%rip), %r13     # 0x55480
movq 0x1758(%r13), %r15
movb $0x1, 0x72(%r15)
testl %edx, %edx
je 0xdf11
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdfc4
movq %rax, %r14
jmp 0xdf24
testq %r14, %r14
jne 0xdf24
movq %rbx, %rdi
callq 0x72e0
movq %rax, %r14
addq %rbx, %r14
movl %r14d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0xdfb5
movq 0x270(%r15), %r15
movq 0x1710(%r13), %r12
movss 0x1718(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movups 0x1460(%r13), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%r13), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8c82
movq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
xorps %xmm1, %xmm1
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x30008
cmpb $0x1, 0x2be8(%r13)
jne 0xdfb5
movss -0x34(%rbp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe021
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x474a2(%rip), %rdx     # 0x55480
cmpl $0x0, 0x17c4(%rdx)
jle 0xdffb
cmpq %rax, %rcx
jbe 0xe01f
cmpb $0x0, (%rax)
je 0xe01f
incq %rax
cmpq %rcx, %rax
jne 0xdfec
jmp 0xe01c
cmpq %rax, %rcx
jbe 0xe01f
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0xe00e
testl %edx, %edx
jne 0xe014
jmp 0xe01f
cmpb $0x23, 0x1(%rax)
je 0xe01f
incq %rax
cmpq %rcx, %rax
jne 0xe000
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderTextWrapped(ImVec2, char const*, char const*, float)
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm1, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0x47307(%rip), %r13     # 0x55480
movq 0x1758(%r13), %r15
movb $0x1, 0x72(%r15)
testq %rsi, %rsi
jne 0xe198
movq %rbx, %rdi
callq 0x72e0
movq %rax, %r14
addq %rbx, %r14
movl %r14d, %eax
subl %ebx, %eax
testl %eax, %eax
jle 0xe22b
movq 0x270(%r15), %r15
movq 0x1710(%r13), %r12
movss 0x1718(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movups 0x1460(%r13), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%r13), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8c82
movq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
movss -0x30(%rbp), %xmm1
callq 0x30008
cmpb $0x1, 0x2be8(%r13)
jne 0xe22b
movss -0x34(%rbp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe021
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq