LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    ImGuiState& g = *GImGui;
    ImVec2* pvar = GetStyleVarVec2Addr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a ImVec2.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = *pvar;
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %r14d
leal -0x1(%r14), %eax
cmpl $0x8, %eax
jae 0x15040
movl $0xd5, %ecx
btl %eax, %ecx
jae 0x15040
movq 0x40562(%rip), %r12     # 0x55480
movl %eax, %eax
leaq 0x28671(%rip), %rcx     # 0x3d598
movq (%rcx,%rax,8), %r13
movss (%r12,%r13), %xmm0
movss 0x4(%r12,%r13), %xmm1
movl 0x17d8(%r12), %eax
cmpl 0x17dc(%r12), %eax
jne 0x14f6c
leal 0x1(%rax), %ebx
testl %eax, %eax
movq %rsi, -0x38(%rbp)
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
je 0x14f79
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x14f7e
movq 0x17e0(%r12), %r15
jmp 0x15007
movl $0x8, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
movslq %ebx, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
incl 0x334(%r12)
callq *0xd0(%r12)
movq %rax, %r15
movq 0x17e0(%r12), %rsi
movslq 0x17d8(%r12), %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %r15, %rdi
callq 0x7080
movq 0x17e0(%r12), %rdi
movq 0x404b0(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x14fdb
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x17e0(%r12)
movl %ebx, 0x17dc(%r12)
movl 0x17d8(%r12), %eax
movq -0x38(%rbp), %rsi
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
leal 0x1(%rax), %ecx
movl %ecx, 0x17d8(%r12)
cltq
leaq (%rax,%rax,2), %rax
movl %r14d, (%r15,%rax,4)
movss %xmm0, 0x4(%r15,%rax,4)
movss %xmm1, 0x8(%r15,%rax,4)
movq (%rsi), %rax
movq %rax, (%r12,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28e29(%rip), %rdi     # 0x3de70
leaq 0x28667(%rip), %rsi     # 0x3d6b5
leaq 0x28e59(%rip), %rcx     # 0x3deae
movl $0x10ef, %edx           # imm = 0x10EF
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetWindowFocus(char const*)
void ImGui::SetWindowFocus(const char* name)
{
    if (name)
    {
        ImGuiWindow* window = FindWindowByName(name);
        if (window)
            FocusWindow(window);
    }
    else
    {
        FocusWindow(NULL);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x15394
pushq %rbp
movq %rsp, %rbp
callq 0x135fc
testq %rax, %rax
popq %rbp
je 0x153a6
movq %rax, %rdi
jmp 0xce68
movq 0x400e5(%rip), %rax     # 0x55480
movq $0x0, 0x1770(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetColumnOffset(int)
float ImGui::GetColumnOffset(int column_index)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    if (g.ActiveId)
    {
        const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(column_index);
        if (g.ActiveId == column_id)
            return GetDraggedColumnOffset(column_index);
    }

    // Read from cache
    IM_ASSERT(column_index < window->DC.ColumnsOffsetsT.Size);
    const float t = window->DC.ColumnsOffsetsT[column_index];

    const float content_region_width = window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x;
    const float min_x = window->DC.ColumnsStartX;
    const float max_x = content_region_width - window->Scroll.x - ((window->Flags & ImGuiWindowFlags_NoScrollbar) ? 0 : g.Style.ScrollbarSize);// - window->WindowPadding().x;
    const float x = min_x + t * (max_x - min_x);
    return (float)(int)x;
}

// Assembly:
movq 0x3fff8(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
testl %edi, %edi
jns 0x15499
movl 0x19c(%rcx), %edi
movl 0x1790(%rax), %edx
testl %edx, %edx
je 0x154b3
movl 0x1b8(%rcx), %esi
addl %edi, %esi
cmpl %esi, %edx
je 0x22661
cmpl 0x1c0(%rcx), %edi
jge 0x15511
movq 0x1c8(%rcx), %rdx
movslq %edi, %rsi
movss 0x38(%rcx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x154d9
jp 0x154d9
movss 0x20(%rcx), %xmm0
movss (%rdx,%rsi,4), %xmm2
movss 0x194(%rcx), %xmm3
subss 0x4c(%rcx), %xmm0
testb $0x8, 0xc(%rcx)
jne 0x154f9
movss 0x1438(%rax), %xmm1
subss %xmm1, %xmm0
subss %xmm3, %xmm0
mulss %xmm0, %xmm2
addss %xmm3, %xmm2
cvttps2dq %xmm2, %xmm0
cvtdq2ps %xmm0, %xmm0
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x29309(%rip), %rdi     # 0x3e825
leaq 0x28192(%rip), %rsi     # 0x3d6b5
leaq 0x2932a(%rip), %rcx     # 0x3e854
movl $0x21e0, %edx           # imm = 0x21E0
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetWindowFontScale(float)
void ImGui::SetWindowFontScale(float scale)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->FontWindowScale = scale;
    g.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3fd61(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss %xmm0, 0x268(%rcx)
mulss 0x171c(%rax), %xmm0
movss %xmm0, 0x1718(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextV(char const*, __va_list_tag*)
void ImGui::TextV(const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    TextUnformatted(g.TempBuffer, text_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3f8d3(%rip), %r14     # 0x55480
movq 0x1758(%r14), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x15bc3
popq %rbx
popq %r14
popq %rbp
retq
movq %rsi, %rcx
movq %rdi, %rdx
leaq 0x2df2(%r14), %rbx
movl $0xc01, %esi            # imm = 0xC01
movq %rbx, %rdi
callq 0x74d0
movb $0x0, 0x39f2(%r14)
cmpl $-0x1, %eax
movl $0xc01, %ecx            # imm = 0xC01
cmovnel %eax, %ecx
movslq %ecx, %rax
leaq (%r14,%rax), %rsi
addq $0x2df2, %rsi           # imm = 0x2DF2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd741
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextColored(ImVec4 const&, char const*, ...)
void ImGui::TextColored(const ImVec4& col, const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    TextColoredV(col, fmt, args);
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0xe0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x15d0d
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
xorl %edi, %edi
callq 0x132dd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15b9f
movl $0x1, %edi
callq 0x13561
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextWrapped(char const*, ...)
void ImGui::TextWrapped(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    TextWrappedV(fmt, args);
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x15e88
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
xorps %xmm0, %xmm0
callq 0x14d35
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15b9f
callq 0x14e20
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::AlignFirstTextHeightToWidgets()
void ImGui::AlignFirstTextHeightToWidgets()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    // Declare a dummy item size to that upcoming items that are smaller will center-align on the newly expanded line height.
    ImGuiState& g = *GImGui;
    ItemSize(ImVec2(0, g.FontSize + g.Style.FramePadding.y*2), g.Style.FramePadding.y);
    ImGui::SameLine(0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3f5a8(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x15f59
movss 0x140c(%rax), %xmm0
movaps %xmm0, %xmm1
addss %xmm0, %xmm1
addss 0x1718(%rax), %xmm1
leaq -0x8(%rbp), %rdi
movl $0x0, (%rdi)
movss %xmm1, 0x4(%rdi)
callq 0xa99d
movq 0x3f565(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x15f59
xorps %xmm0, %xmm0
addss 0xb0(%rax), %xmm0
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm0, 0xa8(%rax)
movl %ecx, 0xac(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SameLine(float, float)
void ImGui::SameLine(float local_pos_x, float spacing_w)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    float x, y;
    if (local_pos_x != 0.0f)
    {
        if (spacing_w < 0.0f) spacing_w = 0.0f;
        x = window->Pos.x - window->Scroll.x + local_pos_x + spacing_w;
        y = window->DC.CursorPosPrevLine.y;
    }
    else
    {
        if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
        x = window->DC.CursorPosPrevLine.x + spacing_w;
        y = window->DC.CursorPosPrevLine.y;
    }
    window->DC.CurrentLineHeight = window->DC.PrevLineHeight;
    window->DC.CurrentLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
    window->DC.CursorPos = ImVec2(x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3f516(%rip), %rcx     # 0x55480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x15fd4
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jne 0x15f85
jnp 0x15f9d
maxss %xmm1, %xmm2
movss 0x18(%rax), %xmm1
subss 0x4c(%rax), %xmm1
addss %xmm0, %xmm1
addss %xmm2, %xmm1
jmp 0x15fb2
ucomiss %xmm1, %xmm2
jbe 0x15faa
movss 0x1414(%rcx), %xmm1
addss 0xb0(%rax), %xmm1
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm1, 0xa8(%rax)
movl %ecx, 0xac(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SmallButton(char const*)
bool ImGui::SmallButton(const char* label)
{
    ImGuiState& g = *GImGui;
    float backup_padding_y = g.Style.FramePadding.y;
    g.Style.FramePadding.y = 0.0f;
    bool pressed = ButtonEx(label, ImVec2(0,0), ImGuiButtonFlags_AlignTextBaseLine);
    g.Style.FramePadding.y = backup_padding_y;
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq 0x3f035(%rip), %rbx     # 0x55480
movss 0x140c(%rbx), %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, 0x140c(%rbx)
leaq -0x14(%rbp), %rsi
movq $0x0, (%rsi)
movl $0x40, %edx
callq 0x1621f
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x140c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::InvisibleButton(char const*, ImVec2 const&)
bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    const ImGuiID id = window->GetID(str_id);
    ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(bb);
    if (!ItemAdd(bb, &id))
        return false;

    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, true);

    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x3efdf(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r15
movb $0x1, 0x72(%r15)
cmpb $0x0, 0x74(%r15)
je 0x164bb
xorl %ebx, %ebx
jmp 0x1656c
movq %rsi, %r12
movq %rdi, %rsi
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
callq 0xa766
leaq -0x28(%rbp), %r14
movl %eax, (%r14)
movsd (%r12), %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0xaea4
movss 0xa8(%r15), %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0xac(%r15), %xmm0
movaps %xmm1, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movq 0xa8(%r15), %rax
leaq -0x40(%rbp), %r15
movq %rax, (%r15)
movlps %xmm2, 0x8(%r15)
movd %eax, %xmm2
subss %xmm2, %xmm1
shrq $0x20, %rax
movd %eax, %xmm2
subss %xmm2, %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
leaq -0x30(%rbp), %rdi
movlps %xmm1, (%rdi)
xorps %xmm0, %xmm0
callq 0xa99d
movq %r15, %rdi
movq %r14, %rsi
callq 0xaaef
testb %al, %al
je 0x1656c
movl -0x28(%rbp), %esi
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x21(%rbp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x13a49
movl %eax, %ebx
movl %ebx, %eax
addq $0x20, %rsp
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::LogToTTY(int)
void ImGui::LogToTTY(int max_depth)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    g.LogEnabled = true;
    g.LogFile = stdout;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3e914(%rip), %rax     # 0x55480
cmpb $0x0, 0x2be8(%rax)
jne 0x16baa
movq 0x1758(%rax), %rcx
movb $0x1, 0x2be8(%rax)
movq 0x3e446(%rip), %rdx     # 0x54fd0
movq (%rdx), %rdx
movq %rdx, 0x2bf0(%rax)
movl 0xdc(%rcx), %ecx
movl %ecx, 0x2c00(%rax)
testl %edi, %edi
js 0x16baa
movl %edi, 0x2c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToFile(int, char const*)
void ImGui::LogToFile(int max_depth, const char* filename)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    if (!filename)
    {
        filename = g.IO.LogFilename;
        if (!filename)
            return;
    }

    g.LogFile = fopen(filename, "ab");
    if (!g.LogFile)
    {
        IM_ASSERT(g.LogFile != NULL); // Consider this an error
        return;
    }
    g.LogEnabled = true;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x3e8c3(%rip), %r14     # 0x55480
cmpb $0x0, 0x2be8(%r14)
jne 0x16c1d
movl %edi, %ebx
movq 0x1758(%r14), %r15
testq %rsi, %rsi
jne 0x16bde
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x16c1d
leaq 0x2739d(%rip), %rax     # 0x3df82
movq %rsi, %rdi
movq %rax, %rsi
callq 0x78b0
movq %rax, 0x2bf0(%r14)
testq %rax, %rax
je 0x16c28
movb $0x1, 0x2be8(%r14)
movl 0xdc(%r15), %eax
movl %eax, 0x2c00(%r14)
testl %ebx, %ebx
js 0x16c1d
movl %ebx, 0x2c04(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27594(%rip), %rdi     # 0x3e1c3
leaq 0x26a7f(%rip), %rsi     # 0x3d6b5
leaq 0x2759a(%rip), %rcx     # 0x3e1d7
movl $0x14e4, %edx           # imm = 0x14E4
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToClipboard(int)
void ImGui::LogToClipboard(int max_depth)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    g.LogEnabled = true;
    g.LogFile = NULL;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3e82e(%rip), %rax     # 0x55480
cmpb $0x0, 0x2be8(%rax)
jne 0x16c8a
movq 0x1758(%rax), %rcx
movb $0x1, 0x2be8(%rax)
movq $0x0, 0x2bf0(%rax)
movl 0xdc(%rcx), %ecx
movl %ecx, 0x2c00(%rax)
testl %edi, %edi
js 0x16c8a
movl %edi, 0x2c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderInt(char const*, int*, int, int, char const*)
bool ImGui::SliderInt(const char* label, int* v, int v_min, int v_max, const char* display_format)
{
    if (!display_format)
        display_format = "%.0f";
    float v_f = (float)*v;
    bool value_changed = ImGui::SliderFloat(label, &v_f, (float)v_min, (float)v_max, display_format, 1.0f);
    *v = (int)v_f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %r8, %r8
leaq 0x29e70(%rip), %rax     # 0x40e7b
cmovneq %r8, %rax
cvtsi2ssl (%rsi), %xmm1
leaq -0x14(%rbp), %r14
cvtsi2ss %edx, %xmm0
movss %xmm1, (%r14)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss 0x26361(%rip), %xmm2    # 0x3d390
movq %r14, %rsi
movq %rax, %rdx
callq 0x1ad02
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreeNodeBehaviorIsOpened(unsigned int, int)
bool ImGui::TreeNodeBehaviorIsOpened(ImGuiID id, ImGuiTreeNodeFlags flags)
{
    // We only write to the tree storage if the user clicks (or explicitely use SetNextTreeNode*** functions)
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiStorage* storage = window->DC.StateStorage;

    bool opened;
    if (g.SetNextTreeNodeOpenedCond != 0)
    {
        if (g.SetNextTreeNodeOpenedCond & ImGuiSetCond_Always)
        {
            opened = g.SetNextTreeNodeOpenedVal;
            storage->SetInt(id, opened);
        }
        else
        {
            // We treat ImGuiSetCondition_Once and ImGuiSetCondition_FirstUseEver the same because tree node state are not saved persistently.
            const int stored_value = storage->GetInt(id, -1);
            if (stored_value == -1)
            {
                opened = g.SetNextTreeNodeOpenedVal;
                storage->SetInt(id, opened);
            }
            else
            {
                opened = stored_value != 0;
            }
        }
        g.SetNextTreeNodeOpenedCond = 0;
    }
    else
    {
        opened = storage->GetInt(id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;
    }

    // When logging is enabled, we automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behavior).
    // NB- If we are above max depth we still allow manually opened nodes to be logged.
    if (g.LogEnabled && !(flags & ImGuiTreeNodeFlags_NoAutoExpandOnLog) && window->DC.TreeDepth < g.LogAutoExpandMaxDepth)
        opened = true;

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r15d
movq 0x3e41e(%rip), %r13     # 0x55480
movq 0x1758(%r13), %rbx
movq 0x110(%rbx), %r12
movl 0x1848(%r13), %eax
testl %eax, %eax
je 0x170c5
movl %esi, -0x2c(%rbp)
testb $0x1, %al
jne 0x1709f
movq %r12, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x906c
cmpl $-0x1, %eax
je 0x1709f
testl %eax, %eax
setne %r14b
jmp 0x170b5
movb 0x1845(%r13), %r14b
movzbl %r14b, %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x95c6
movl $0x0, 0x1848(%r13)
movl -0x2c(%rbp), %ecx
jmp 0x170e1
movl %esi, %edx
andl $0x1, %edx
movq %r12, %rdi
movl %esi, %r14d
movl %r15d, %esi
callq 0x906c
movl %r14d, %ecx
testl %eax, %eax
setne %r14b
testb $0x2, %cl
jne 0x1710b
cmpb $0x0, 0x2be8(%r13)
je 0x1710b
movl 0xdc(%rbx), %eax
cmpl 0x2c04(%r13), %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
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_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Bullet()
void ImGui::Bullet()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const float line_height = g.FontSize;
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(line_height, line_height));
    ItemSize(bb);
    if (!ItemAdd(bb, NULL))
    {
        ImGui::SameLine(0, -1);
        return;
    }

    // Render
    const float bullet_size = line_height*0.15f;
    window->DrawList->AddCircleFilled(bb.Min + ImVec2(style.FramePadding.x + line_height*0.5f, line_height*0.5f), bullet_size, window->Color(ImGuiCol_Text));

    // Stay on same line
    ImGui::SameLine(0, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq 0x3de40(%rip), %r14     # 0x55480
movq 0x1758(%r14), %r15
movb $0x1, 0x72(%r15)
cmpb $0x0, 0x74(%r15)
jne 0x177ab
movss 0x1718(%r14), %xmm2
movss 0xa8(%r15), %xmm0
addss %xmm2, %xmm0
movss 0xac(%r15), %xmm1
movaps %xmm2, -0x40(%rbp)
addss %xmm2, %xmm1
movaps %xmm0, %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movq 0xa8(%r15), %rax
leaq -0x68(%rbp), %rbx
movq %rax, (%rbx)
movlps %xmm2, 0x8(%rbx)
movd %eax, %xmm2
movd %xmm2, -0x24(%rbp)
subss %xmm2, %xmm0
shrq $0x20, %rax
movd %eax, %xmm2
movd %xmm2, -0x20(%rbp)
subss %xmm2, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x50(%rbp), %rdi
movlps %xmm0, (%rdi)
xorps %xmm0, %xmm0
callq 0xa99d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xaaef
testb %al, %al
je 0x17761
movss 0x25d50(%rip), %xmm0    # 0x3d430
movaps -0x40(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
mulss 0x25cd7(%rip), %xmm1    # 0x3d3cc
movq 0x270(%r15), %rbx
movss 0x1408(%r14), %xmm0
addss %xmm1, %xmm0
addss -0x24(%rbp), %xmm0
addss -0x20(%rbp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x58(%rbp), %r14
movlps %xmm0, (%r14)
movq 0x3dd5b(%rip), %rax     # 0x55480
movups 0x1460(%rax), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8c82
movq %rbx, %rdi
movq %r14, %rsi
movss -0x1c(%rbp), %xmm0
movl %eax, %edx
movl $0xc, %ecx
callq 0x2fe28
movq 0x3dd18(%rip), %rcx     # 0x55480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x177ab
movss 0x1414(%rcx), %xmm0
addss 0xb0(%rax), %xmm0
movl 0xb4(%rax), %ecx
movq 0xd0(%rax), %rdx
movq %rdx, 0xc8(%rax)
movss %xmm0, 0xa8(%rax)
movl %ecx, 0xac(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreeNodeV(char const*, char const*, __va_list_tag*)
bool ImGui::TreeNodeV(const char* str_id, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    if (!str_id || !str_id[0])
        str_id = fmt;

    ImGui::PushID(str_id);
    const bool opened = ImGui::CollapsingHeader(g.TempBuffer, "", false);
    ImGui::PopID();

    if (opened)
        ImGui::TreePush(str_id);

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x3da3c(%rip), %r12     # 0x55480
movq 0x1758(%r12), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x17a5b
xorl %r15d, %r15d
jmp 0x17ac8
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2df2(%r12), %r14
movl $0xc01, %esi            # imm = 0xC01
movq %r14, %rdi
movq %r15, %rdx
callq 0x74d0
movb $0x0, 0x39f2(%r12)
testq %rbx, %rbx
je 0x17a8f
cmpb $0x0, (%rbx)
jne 0x17a92
movq %r15, %rbx
movq %rbx, %rdi
callq 0x16f0c
leaq 0x29998(%rip), %rsi     # 0x41439
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1711d
movl %eax, %r14d
callq 0x16b19
testb %r14b, %r14b
je 0x17ac8
movq %rbx, %rdi
callq 0x17ad4
movb $0x1, %r15b
movl %r15d, %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::TreePush(char const*)
void ImGui::TreePush(const char* str_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    ImGui::Indent();
    window->DC.TreeDepth++;
    PushID(str_id ? str_id : "#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3d9a1(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x1430(%rax), %xmm0
addss 0x194(%rcx), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
incl 0xdc(%rcx)
testq %rdi, %rdi
leaq 0x26d77(%rip), %rax     # 0x3e89e
cmoveq %rax, %rdi
popq %rbp
jmp 0x16f0c
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreeNodeV(void const*, char const*, __va_list_tag*)
bool ImGui::TreeNodeV(const void* ptr_id, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);

    if (!ptr_id)
        ptr_id = fmt;

    ImGui::PushID(ptr_id);
    const bool opened = ImGui::CollapsingHeader(g.TempBuffer, "", false);
    ImGui::PopID();

    if (opened)
        ImGui::TreePush(ptr_id);

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x3d8c6(%rip), %r12     # 0x55480
movq 0x1758(%r12), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x17bd1
xorl %r14d, %r14d
jmp 0x17c38
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2df2(%r12), %r15
movl $0xc01, %esi            # imm = 0xC01
movq %r15, %rdi
movq %r14, %rdx
callq 0x74d0
movb $0x0, 0x39f2(%r12)
testq %rbx, %rbx
cmoveq %r14, %rbx
movq %rbx, %rdi
callq 0x16a34
leaq 0x29828(%rip), %rsi     # 0x41439
xorl %r14d, %r14d
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1711d
movl %eax, %r15d
callq 0x16b19
testb %r15b, %r15b
je 0x17c38
movq %rbx, %rdi
callq 0x17c44
movb $0x1, %r14b
movl %r14d, %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::TreePush(void const*)
void ImGui::TreePush(const void* ptr_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    ImGui::Indent();
    window->DC.TreeDepth++;
    PushID(ptr_id ? ptr_id : (const void*)"#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3d831(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x1430(%rax), %xmm0
addss 0x194(%rcx), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
incl 0xdc(%rcx)
testq %rdi, %rdi
leaq 0x26c07(%rip), %rax     # 0x3e89e
cmoveq %rax, %rdi
popq %rbp
jmp 0x16a34
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ParseFormatPrecision(char const*, int)
int ImGui::ParseFormatPrecision(const char* fmt, int default_precision)
{
    int precision = default_precision;
    while ((fmt = strchr(fmt, '%')) != NULL)
    {
        fmt++;
        if (fmt[0] == '%') { fmt++; continue; } // Ignore "%%"
        while (*fmt >= '0' && *fmt <= '9')
            fmt++;
        if (*fmt == '.')
        {
            precision = atoi(fmt + 1);
            if (precision < 0 || precision > 10)
                precision = default_precision;
        }
        break;
    }
    return precision;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0x25, %esi
callq 0x73f0
testq %rax, %rax
je 0x1a619
movb 0x1(%rax), %cl
cmpb $0x25, %cl
jne 0x1a5ec
addq $0x2, %rax
movq %rax, %rdi
jmp 0x1a5cc
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x1a602
movb 0x2(%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
cmpb $0xa, %dl
jb 0x1a5f4
cmpb $0x2e, %cl
jne 0x1a619
addq $0x2, %rax
movq %rax, %rdi
callq 0x7230
cmpl $0xb, %eax
cmovbl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RoundScalar(float, int)
float ImGui::RoundScalar(float value, int decimal_precision)
{
    // Round past decimal precision
    // So when our value is 1.99999 with a precision of 0.001 we'll end up rounding to 2.0
    // FIXME: Investigate better rounding methods
    static const float min_steps[10] = { 1.0f, 0.1f, 0.01f, 0.001f, 0.0001f, 0.00001f, 0.000001f, 0.0000001f, 0.00000001f, 0.000000001f };
    float min_step = (decimal_precision >= 0 && decimal_precision < 10) ? min_steps[decimal_precision] : powf(10.0f, (float)-decimal_precision);
    bool negative = value < 0.0f;
    value = fabsf(value);
    float remainder = fmodf(value, min_step);
    if (remainder <= min_step*0.5f)
        value -= remainder;
    else
        value += (min_step - remainder);
    return negative ? -value : value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movaps %xmm0, -0x10(%rbp)
cmpl $0x9, %edi
ja 0x1a643
movl %edi, %eax
leaq 0x22f14(%rip), %rcx     # 0x3d550
movss (%rcx,%rax,4), %xmm1
jmp 0x1a659
negl %edi
cvtsi2ss %edi, %xmm1
movss 0x22dff(%rip), %xmm0    # 0x3d450
callq 0x7630
movaps %xmm0, %xmm1
movaps 0x22c80(%rip), %xmm0    # 0x3d2e0
andps -0x10(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0x78d0
movss 0x22d53(%rip), %xmm1    # 0x3d3cc
movaps -0x20(%rbp), %xmm4
mulss %xmm4, %xmm1
subss %xmm0, %xmm4
movaps 0x22ca4(%rip), %xmm2    # 0x3d330
movaps %xmm0, %xmm3
xorps %xmm2, %xmm3
cmpnless %xmm1, %xmm0
andps %xmm0, %xmm4
andnps %xmm3, %xmm0
orps %xmm4, %xmm0
addss -0x30(%rbp), %xmm0
xorps %xmm0, %xmm2
xorps %xmm1, %xmm1
movaps -0x10(%rbp), %xmm3
cmpltss %xmm1, %xmm3
movaps %xmm3, %xmm1
andnps %xmm0, %xmm1
andps %xmm2, %xmm3
orps %xmm1, %xmm3
movaps %xmm3, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderAngle(char const*, float*, float, float)
bool ImGui::SliderAngle(const char* label, float* v_rad, float v_degrees_min, float v_degrees_max)
{
    float v_deg = (*v_rad) * 360.0f / (2*IM_PI);
    bool value_changed = ImGui::SliderFloat(label, &v_deg, v_degrees_min, v_degrees_max, "%.0f deg", 1.0f);
    *v_rad = v_deg * (2*IM_PI) / 360.0f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movss (%rsi), %xmm2
mulss 0x220ed(%rip), %xmm2    # 0x3d454
divss 0x220e9(%rip), %xmm2    # 0x3d458
leaq -0x14(%rbp), %r14
movss %xmm2, (%r14)
leaq 0x22fa2(%rip), %rdx     # 0x3e321
movss 0x22009(%rip), %xmm2    # 0x3d390
movq %r14, %rsi
callq 0x1ad02
movss 0x220c1(%rip), %xmm0    # 0x3d458
mulss (%r14), %xmm0
divss 0x220b0(%rip), %xmm0    # 0x3d454
movss %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::VSliderInt(char const*, ImVec2 const&, int*, int, int, char const*)
bool ImGui::VSliderInt(const char* label, const ImVec2& size, int* v, int v_min, int v_max, const char* display_format)
{
    if (!display_format)
        display_format = "%.0f";
    float v_f = (float)*v;
    bool value_changed = ImGui::VSliderFloat(label, size, &v_f, (float)v_min, (float)v_max, display_format, 1.0f);
    *v = (int)v_f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
testq %r9, %r9
leaq 0x25ab2(%rip), %rax     # 0x40e7b
cmovneq %r9, %rax
cvtsi2ssl (%rdx), %xmm1
leaq -0x14(%rbp), %r14
cvtsi2ss %ecx, %xmm0
movss %xmm1, (%r14)
xorps %xmm1, %xmm1
cvtsi2ss %r8d, %xmm1
movss 0x21fa2(%rip), %xmm2    # 0x3d390
movq %r14, %rdx
movq %rax, %rcx
callq 0x1b0ae
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderFloatN(char const*, float*, int, float, float, char const*, float)
bool ImGui::SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    bool value_changed = false;
    ImGui::BeginGroup();
    ImGui::PushID(label);
    PushMultiItemsWidths(components);
    for (int i = 0; i < components; i++)
    {
        ImGui::PushID(i);
        value_changed |= ImGui::SliderFloat("##v", &v[i], v_min, v_max, display_format, power);
        ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
        ImGui::PopID();
        ImGui::PopItemWidth();
    }
    ImGui::PopID();

    ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
    ImGui::EndGroup();

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm2, -0x34(%rbp)
movq %rcx, -0x48(%rbp)
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
movq 0x3a04c(%rip), %rbx     # 0x55480
movq 0x1758(%rbx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1b44d
xorl %r15d, %r15d
jmp 0x1b54a
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0x1b560
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x16f0c
movl %r15d, %edi
callq 0x1b714
testl %r15d, %r15d
jle 0x1b524
movl %r15d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, %edi
callq 0x17e36
leaq 0x22e9a(%rip), %rdi     # 0x3e32a
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movq -0x48(%rbp), %rdx
movss -0x34(%rbp), %xmm2
callq 0x1ad02
movss 0x141c(%rbx), %xmm0
movq 0x39fc6(%rip), %rdx     # 0x55480
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1b505
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1b4db
movss 0x1414(%rdx), %xmm0
addss 0xb0(%rcx), %xmm0
movl 0xb4(%rcx), %edx
movq 0xd0(%rcx), %rsi
movq %rsi, 0xc8(%rcx)
movss %xmm0, 0xa8(%rcx)
movl %edx, 0xac(%rcx)
orb %al, %r15b
callq 0x16b19
callq 0x9db1
incq %r13
addq $0x4, %r12
cmpq %r13, %r14
jne 0x1b481
jmp 0x1b527
xorl %r15d, %r15d
callq 0x16b19
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xdfc4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd741
callq 0x1b97c
andb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %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: ImGui::BeginGroup()
void ImGui::BeginGroup()
{
    ImGuiWindow* window = GetCurrentWindow();

    window->DC.GroupStack.resize(window->DC.GroupStack.Size + 1);
    ImGuiGroupData& group_data = window->DC.GroupStack.back();
    group_data.BackupCursorPos = window->DC.CursorPos;
    group_data.BackupCursorMaxPos = window->DC.CursorMaxPos;
    group_data.BackupColumnsStartX = window->DC.ColumnsStartX;
    group_data.BackupCurrentLineHeight = window->DC.CurrentLineHeight;
    group_data.BackupCurrentLineTextBaseOffset = window->DC.CurrentLineTextBaseOffset;
    group_data.BackupLogLinePosY = window->DC.LogLinePosY;
    group_data.AdvanceCursor = true;

    window->DC.ColumnsStartX = window->DC.CursorPos.x - window->Pos.x;
    window->DC.CursorMaxPos = window->DC.CursorPos;
    window->DC.CurrentLineHeight = 0.0f;
    window->DC.LogLinePosY = window->DC.CursorPos.y - 9999.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x39f0b(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
movl 0x168(%r14), %r12d
movl 0x16c(%r14), %ecx
leal 0x1(%r12), %r15d
cmpl %r12d, %ecx
jg 0x1b625
testl %ecx, %ecx
je 0x1b5b3
movl %ecx, %r13d
shrl $0x1f, %r13d
addl %ecx, %r13d
sarl %r13d
addl %ecx, %r13d
jmp 0x1b5b9
movl $0x8, %r13d
cmpl %r15d, %r13d
cmovlel %r15d, %r13d
movslq %r13d, %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,8), %rdi
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %rbx
movq 0x170(%r14), %rsi
movslq 0x168(%r14), %rax
shlq $0x2, %rax
leaq (%rax,%rax,8), %rdx
movq %rbx, %rdi
callq 0x7080
movq 0x170(%r14), %rdi
movq 0x39e7a(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x1b611
decl 0x334(%rax)
callq *0xd8(%rax)
movq %rbx, 0x170(%r14)
movl %r13d, 0x16c(%r14)
movl %r15d, 0x168(%r14)
testl %r12d, %r12d
js 0x1b6f5
movq 0xa8(%r14), %rax
movq 0x170(%r14), %rcx
movl %r15d, %edx
leaq (%rdx,%rdx,8), %rdx
movq %rax, -0x24(%rcx,%rdx,4)
movq 0xc0(%r14), %rax
movq %rax, -0x1c(%rcx,%rdx,4)
movss 0x194(%r14), %xmm0
movss %xmm0, -0x14(%rcx,%rdx,4)
movss 0xc8(%r14), %xmm0
movss %xmm0, -0x10(%rcx,%rdx,4)
movss 0xcc(%r14), %xmm0
movss %xmm0, -0xc(%rcx,%rdx,4)
movss 0xd8(%r14), %xmm0
movss %xmm0, -0x8(%rcx,%rdx,4)
movb $0x1, -0x4(%rcx,%rdx,4)
movss 0xa8(%r14), %xmm0
subss 0x18(%r14), %xmm0
movss %xmm0, 0x194(%r14)
movq 0xa8(%r14), %rax
movq %rax, 0xc0(%r14)
movl $0x0, 0xc8(%r14)
shrq $0x20, %rax
movd %eax, %xmm0
addss 0x21cdb(%rip), %xmm0    # 0x3d3b8
movss %xmm0, 0xd8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b439(%rip), %rdi     # 0x46b35
leaq 0x233c0(%rip), %rsi     # 0x3eac3
leaq 0x23efa(%rip), %rcx     # 0x3f604
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SliderIntN(char const*, int*, int, int, int, char const*)
bool ImGui::SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* display_format)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    bool value_changed = false;
    ImGui::BeginGroup();
    ImGui::PushID(label);
    PushMultiItemsWidths(components);
    for (int i = 0; i < components; i++)
    {
        ImGui::PushID(i);
        value_changed |= ImGui::SliderInt("##v", &v[i], v_min, v_max, display_format);
        ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
        ImGui::PopID();
        ImGui::PopItemWidth();
    }
    ImGui::PopID();

    ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
    ImGui::EndGroup();

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x398d0(%rip), %rax     # 0x55480
movq %rax, -0x48(%rbp)
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1bbcd
xorl %r15d, %r15d
jmp 0x1bd14
movq %r9, %r13
movl %r8d, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, -0x2c(%rbp)
callq 0x1b560
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
callq 0x16f0c
movl %r15d, %edi
callq 0x1b714
testl %r15d, %r15d
jle 0x1bcee
testq %r13, %r13
movl %r12d, %eax
leaq 0x2526d(%rip), %r12     # 0x40e7b
cmovneq %r13, %r12
cvtsi2ssl -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movl %r15d, %ebx
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, %edi
callq 0x17e36
xorps %xmm0, %xmm0
cvtsi2ssl (%r14,%r13,4), %xmm0
movss %xmm0, -0x30(%rbp)
leaq 0x226dc(%rip), %rdi     # 0x3e32a
leaq -0x30(%rbp), %rsi
movss -0x2c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
movq %r12, %rdx
movss 0x21729(%rip), %xmm2    # 0x3d390
callq 0x1ad02
cvttss2si -0x30(%rbp), %ecx
movl %ecx, (%r14,%r13,4)
movq -0x48(%rbp), %rcx
movss 0x141c(%rcx), %xmm0
movq 0x397f8(%rip), %rdx     # 0x55480
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1bcd3
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1bca9
movss 0x1414(%rdx), %xmm0
addss 0xb0(%rcx), %xmm0
movl 0xb4(%rcx), %edx
movq 0xd0(%rcx), %rsi
movq %rsi, 0xc8(%rcx)
movss %xmm0, 0xa8(%rcx)
movl %edx, 0xac(%rcx)
orb %al, %r15b
callq 0x16b19
callq 0x9db1
incq %r13
cmpq %r13, %rbx
jne 0x1bc31
jmp 0x1bcf1
xorl %r15d, %r15d
callq 0x16b19
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xdfc4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd741
callq 0x1b97c
andb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %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: ImGui::DragFloatN(char const*, float*, int, float, float, float, char const*, float)
bool ImGui::DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* display_format, float power)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    bool value_changed = false;
    ImGui::BeginGroup();
    ImGui::PushID(label);
    PushMultiItemsWidths(components);
    for (int i = 0; i < components; i++)
    {
        ImGui::PushID(i);
        value_changed |= ImGui::DragFloat("##v", &v[i], v_speed, v_min, v_max, display_format, power);
        ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
        ImGui::PopID();
        ImGui::PopItemWidth();
    }
    ImGui::PopID();

    ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
    ImGui::EndGroup();

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm3, -0x38(%rbp)
movq %rcx, -0x48(%rbp)
movss %xmm2, -0x34(%rbp)
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
movq 0x39004(%rip), %rbx     # 0x55480
movq 0x1758(%rbx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1c495
xorl %r15d, %r15d
jmp 0x1c597
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0x1b560
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x16f0c
movl %r15d, %edi
callq 0x1b714
testl %r15d, %r15d
jle 0x1c571
movl %r15d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, %edi
callq 0x17e36
leaq 0x21e52(%rip), %rdi     # 0x3e32a
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movq -0x48(%rbp), %rdx
movss -0x38(%rbp), %xmm3
callq 0x1c08e
movss 0x141c(%rbx), %xmm0
movq 0x38f79(%rip), %rdx     # 0x55480
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1c552
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1c528
movss 0x1414(%rdx), %xmm0
addss 0xb0(%rcx), %xmm0
movl 0xb4(%rcx), %edx
movq 0xd0(%rcx), %rsi
movq %rsi, 0xc8(%rcx)
movss %xmm0, 0xa8(%rcx)
movl %edx, 0xac(%rcx)
orb %al, %r15b
callq 0x16b19
callq 0x9db1
incq %r13
addq $0x4, %r12
cmpq %r13, %r14
jne 0x1c4c9
jmp 0x1c574
xorl %r15d, %r15d
callq 0x16b19
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xdfc4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd741
callq 0x1b97c
andb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %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: ImGui::DragInt(char const*, int*, float, int, int, char const*)
bool ImGui::DragInt(const char* label, int* v, float v_speed, int v_min, int v_max, const char* display_format)
{
    if (!display_format)
        display_format = "%.0f";
    float v_f = (float)*v;
    bool value_changed = ImGui::DragFloat(label, &v_f, v_speed, (float)v_min, (float)v_max, display_format);
    *v = (int)v_f;
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %r8, %r8
leaq 0x2465b(%rip), %rax     # 0x40e7b
cmovneq %r8, %rax
cvtsi2ssl (%rsi), %xmm2
leaq -0x14(%rbp), %r14
cvtsi2ss %edx, %xmm1
movss %xmm2, (%r14)
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
movss 0x20b4c(%rip), %xmm3    # 0x3d390
movq %r14, %rsi
movq %rax, %rdx
callq 0x1c08e
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::DragIntN(char const*, int*, int, float, int, int, char const*)
bool ImGui::DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* display_format)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    bool value_changed = false;
    ImGui::BeginGroup();
    ImGui::PushID(label);
    PushMultiItemsWidths(components);
    for (int i = 0; i < components; i++)
    {
        ImGui::PushID(i);
        value_changed |= ImGui::DragInt("##v", &v[i], v_speed, v_min, v_max, display_format);
        ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
        ImGui::PopID();
        ImGui::PopItemWidth();
    }
    ImGui::PopID();

    ImGui::TextUnformatted(label, FindTextDisplayEnd(label));
    ImGui::EndGroup();

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, -0x38(%rbp)
movq 0x38c04(%rip), %rax     # 0x55480
movq %rax, -0x48(%rbp)
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1c899
xorl %r15d, %r15d
jmp 0x1c9e8
movq %r9, %r15
movl %r8d, %r12d
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, -0x2c(%rbp)
callq 0x1b560
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
callq 0x16f0c
movl %r13d, %edi
callq 0x1b714
testl %r13d, %r13d
jle 0x1c9c2
testq %r15, %r15
movl %r12d, %eax
leaq 0x245a1(%rip), %r12     # 0x40e7b
cmovneq %r15, %r12
xorps %xmm0, %xmm0
cvtsi2ssl -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x34(%rbp)
movl %r13d, %ebx
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, %edi
callq 0x17e36
xorps %xmm0, %xmm0
cvtsi2ssl (%r14,%r13,4), %xmm0
movss %xmm0, -0x30(%rbp)
leaq 0x21a0d(%rip), %rdi     # 0x3e32a
leaq -0x30(%rbp), %rsi
movss -0x38(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movq %r12, %rdx
movss 0x20a55(%rip), %xmm3    # 0x3d390
callq 0x1c08e
cvttss2si -0x30(%rbp), %ecx
movl %ecx, (%r14,%r13,4)
movq -0x48(%rbp), %rcx
movss 0x141c(%rcx), %xmm0
movq 0x38b24(%rip), %rdx     # 0x55480
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1c9a7
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1c97d
movss 0x1414(%rdx), %xmm0
addss 0xb0(%rcx), %xmm0
movl 0xb4(%rcx), %edx
movq 0xd0(%rcx), %rsi
movq %rsi, 0xc8(%rcx)
movss %xmm0, 0xa8(%rcx)
movl %edx, 0xac(%rcx)
orb %al, %r15b
callq 0x16b19
callq 0x9db1
incq %r13
cmpq %r13, %rbx
jne 0x1c900
jmp 0x1c9c5
xorl %r15d, %r15d
callq 0x16b19
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xdfc4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd741
callq 0x1b97c
andb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %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: ImGui::CheckboxFlags(char const*, unsigned int*, unsigned int)
bool ImGui::CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value)
{
    bool v = (*flags & flags_value) ? true : false;
    bool pressed = ImGui::Checkbox(label, &v);
    if (v)
        *flags |= flags_value;
    else
        *flags &= ~flags_value;
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
testl %edx, (%rsi)
leaq -0x19(%rbp), %r15
setne (%r15)
movq %r15, %rsi
callq 0x1d626
cmpb $0x1, (%r15)
jne 0x1dad3
orl (%r14), %ebx
jmp 0x1dad8
notl %ebx
andl (%r14), %ebx
movl %ebx, (%r14)
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: ImGui::RadioButton(char const*, int*, int)
bool ImGui::RadioButton(const char* label, int* v, int v_button)
{
    const bool pressed = ImGui::RadioButton(label, *v == v_button);
    if (pressed)
    {
        *v = v_button;
    }
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
xorl %esi, %esi
cmpl %edx, (%r14)
sete %sil
callq 0x1dae6
testb %al, %al
je 0x1e03d
movl %ebx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq