LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowSize(ImGuiWindow*, ImVec2 const&, int)
static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
        return;
    window->SetWindowSizeAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);

    // Set
    if (size.x > 0.0f)
    {
        window->AutoFitFramesX = 0;
        window->SizeFull.x = size.x;
    }
    else
    {
        window->AutoFitFramesX = 2;
        window->AutoFitOnlyGrows = false;
    }
    if (size.y > 0.0f)
    {
        window->AutoFitFramesY = 0;
        window->SizeFull.y = size.y;
    }
    else
    {
        window->AutoFitFramesY = 2;
        window->AutoFitOnlyGrows = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
setne %cl
movl 0x98(%rdi), %eax
testl %edx, %eax
sete %dl
testb %dl, %cl
jne 0x119eb
andl $-0xf, %eax
movl %eax, 0x98(%rdi)
movss (%rsi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x119b0
movss %xmm0, 0x28(%rdi)
xorl %eax, %eax
jmp 0x119bc
movb $0x0, 0x88(%rdi)
movl $0x2, %eax
movl %eax, 0x80(%rdi)
movss 0x4(%rsi), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x119da
andl $0x0, 0x84(%rdi)
movss %xmm0, 0x2c(%rdi)
jmp 0x119eb
movl $0x2, 0x84(%rdi)
movb $0x0, 0x88(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowCollapsed(ImGuiWindow*, bool, int)
static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowCollapsedAllowFlags & cond) == 0)
        return;
    window->SetWindowCollapsedAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);

    // Set
    window->Collapsed = collapsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
setne %cl
movl 0x9c(%rdi), %eax
testl %edx, %eax
sete %dl
testb %dl, %cl
jne 0x11a3e
andl $-0xf, %eax
movl %eax, 0x9c(%rdi)
movb %sil, 0x73(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11a9d
pushq %rbp
movq %rsp, %rbp
callq 0x1013c
testq %rax, %rax
popq %rbp
je 0x11aa4
movq %rax, %rdi
jmp 0xb5a3
xorl %edi, %edi
jmp 0xb5a3
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %esi
movq 0x3e8f1(%rip), %rbx     # 0x50480
movq 0x1758(%rbx), %r14
testl %edi, %edi
jns 0x11ba1
movl 0x19c(%r14), %esi
movl 0x1790(%rbx), %eax
testl %eax, %eax
je 0x11bc3
movl 0x1b8(%r14), %ecx
addl %esi, %ecx
cmpl %ecx, %eax
jne 0x11bc3
movl %esi, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1c966
cmpl 0x1c0(%r14), %esi
jge 0x11c2c
leaq 0x1c0(%r14), %rdi
callq 0x1f61c
movss 0x38(%r14), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x11bee
jp 0x11bee
movss 0x20(%r14), %xmm0
movss (%rax), %xmm2
movss 0x194(%r14), %xmm3
subss 0x4c(%r14), %xmm0
testb $0x8, 0xc(%r14)
jne 0x11c10
movss 0x1438(%rbx), %xmm1
subss %xmm1, %xmm0
subss %xmm3, %xmm0
mulss %xmm0, %xmm2
addss %xmm3, %xmm2
cvttps2dq %xmm2, %xmm0
cvtdq2ps %xmm0, %xmm0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x25baa(%rip), %rdi     # 0x377dd
leaq 0x24a33(%rip), %rsi     # 0x3666d
leaq 0x25bcb(%rip), %rcx     # 0x3780c
movl $0x21e0, %edx           # imm = 0x21E0
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e698(%rip), %rax     # 0x50480
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_O2/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 0x3e24b(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1224b
popq %rbx
popq %r14
popq %rbp
retq
movq %rsi, %rcx
movq %rdi, %rdx
leaq 0x2df2(%r14), %rbx
movq %rbx, %rdi
movl $0xc01, %esi            # imm = 0xC01
callq 0x8446
cltq
leaq (%r14,%rax), %rsi
addq $0x2df2, %rsi           # imm = 0x2DF2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbba1
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3df28(%rip), %rcx     # 0x50480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x125c2
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jne 0x12573
jnp 0x1258b
maxss %xmm1, %xmm2
movss 0x18(%rax), %xmm1
subss 0x4c(%rax), %xmm1
addss %xmm0, %xmm1
addss %xmm2, %xmm1
jmp 0x125a0
ucomiss %xmm1, %xmm2
jbe 0x12598
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_O2/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 0x3dab2(%rip), %rbx     # 0x50480
movss 0x140c(%rbx), %xmm0
movss %xmm0, -0xc(%rbp)
andl $0x0, 0x140c(%rbx)
leaq -0x14(%rbp), %rsi
andq $0x0, (%rsi)
pushq $0x40
popq %rdx
callq 0x127e2
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x140c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3da64(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
cmpb $0x0, 0x74(%r14)
je 0x12a36
xorl %ebx, %ebx
jmp 0x12ac7
movq %rsi, %r12
movq %rdi, %rsi
xorl %ebx, %ebx
movq %r14, %rdi
xorl %edx, %edx
callq 0x9858
leaq -0x28(%rbp), %r15
movl %eax, (%r15)
movsd (%r12), %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x9ecf
movss 0xa8(%r14), %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0xac(%r14), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq 0xa8(%r14), %rax
leaq -0x38(%rbp), %r14
movq %rax, (%r14)
movlps %xmm1, 0x8(%r14)
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x9af8
movq %r14, %rdi
movq %r15, %rsi
callq 0x9b28
testb %al, %al
je 0x12ac7
movl -0x28(%rbp), %esi
leaq -0x38(%rbp), %rdi
leaq -0x22(%rbp), %rdx
leaq -0x21(%rbp), %rcx
pushq $0x1
popq %r8
xorl %r9d, %r9d
callq 0x1077a
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_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Image(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec4 const&, ImVec4 const&)
void ImGui::Image(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, const ImVec4& tint_col, const ImVec4& border_col)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    if (border_col.w > 0.0f)
        bb.Max += ImVec2(2,2);
    ItemSize(bb);
    if (!ItemAdd(bb, NULL))
        return;

    if (border_col.w > 0.0f)
    {
        window->DrawList->AddRect(bb.Min, bb.Max, window->Color(border_col), 0.0f);
        window->DrawList->AddImage(user_texture_id, bb.Min+ImVec2(1,1), bb.Max-ImVec2(1,1), uv0, uv1, window->Color(tint_col));
    }
    else
    {
        window->DrawList->AddImage(user_texture_id, bb.Min, bb.Max, uv0, uv1, window->Color(tint_col));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x3d992(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r13
movb $0x1, 0x72(%r13)
cmpb $0x0, 0x74(%r13)
jne 0x12c5b
movq %r9, %rbx
movq %r8, %r12
movq %rdi, %r15
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movss 0xa8(%r13), %xmm0
addss (%rsi), %xmm0
movss 0xac(%r13), %xmm1
addss 0x4(%rsi), %xmm1
movaps %xmm0, %xmm2
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movq 0xa8(%r13), %rax
movq %rax, -0x38(%rbp)
movlps %xmm2, -0x30(%rbp)
movss 0xc(%r9), %xmm2
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm2
jbe 0x12b6e
movss 0x2387c(%rip), %xmm2    # 0x363d8
addss %xmm2, %xmm0
movss %xmm0, -0x30(%rbp)
addss %xmm2, %xmm1
movss %xmm1, -0x2c(%rbp)
leaq -0x38(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x9af8
movq %r14, %rdi
xorl %esi, %esi
callq 0x9b28
testb %al, %al
je 0x12c5b
movss 0xc(%rbx), %xmm0
ucomiss 0x23815(%rip), %xmm0    # 0x363b0
movq 0x270(%r13), %r14
jbe 0x12c32
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1f43c
leaq -0x38(%rbp), %rbx
pushq $0xf
popq %r8
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
leaq -0x30(%rbp), %rdx
movl %eax, %ecx
callq 0x299ca
movss 0x237b9(%rip), %xmm0    # 0x36390
movss (%rbx), %xmm1
addss %xmm0, %xmm1
addss 0x4(%rbx), %xmm0
movq 0x270(%r13), %r14
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
leaq -0x50(%rbp), %rax
movss 0x237a2(%rip), %xmm0    # 0x3639c
movss 0x8(%rbx), %xmm2
addss %xmm0, %xmm2
addss 0xc(%rbx), %xmm0
movlps %xmm1, (%rax)
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
leaq -0x58(%rbp), %rbx
movlps %xmm2, (%rbx)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f43c
movl %eax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rcx
jmp 0x12c4e
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f43c
movl %eax, (%rsp)
leaq -0x38(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
leaq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
callq 0x2a510
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x3d5b0(%rip), %rax     # 0x50480
cmpb $0x0, 0x2be8(%rax)
jne 0x12f0e
movq 0x1758(%rax), %rcx
movb $0x1, 0x2be8(%rax)
movq 0x3d0ea(%rip), %rdx     # 0x4ffd8
movq (%rdx), %rdx
movq %rdx, 0x2bf0(%rax)
movl 0xdc(%rcx), %ecx
movl %ecx, 0x2c00(%rax)
testl %edi, %edi
js 0x12f0e
movl %edi, 0x2c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d55f(%rip), %r14     # 0x50480
cmpb $0x0, 0x2be8(%r14)
jne 0x12f81
movl %edi, %ebx
movq 0x1758(%r14), %r15
testq %rsi, %rsi
jne 0x12f42
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x12f81
leaq 0x23ff1(%rip), %rax     # 0x36f3a
movq %rsi, %rdi
movq %rax, %rsi
callq 0x78a0
movq %rax, 0x2bf0(%r14)
testq %rax, %rax
je 0x12f8c
movb $0x1, 0x2be8(%r14)
movl 0xdc(%r15), %eax
movl %eax, 0x2c00(%r14)
testl %ebx, %ebx
js 0x12f81
movl %ebx, 0x2c04(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x241e8(%rip), %rdi     # 0x3717b
leaq 0x236d3(%rip), %rsi     # 0x3666d
leaq 0x241ee(%rip), %rcx     # 0x3718f
movl $0x14e4, %edx           # imm = 0x14E4
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d4ca(%rip), %rax     # 0x50480
cmpb $0x0, 0x2be8(%rax)
jne 0x12feb
movq 0x1758(%rax), %rcx
movb $0x1, 0x2be8(%rax)
andq $0x0, 0x2bf0(%rax)
movl 0xdc(%rcx), %ecx
movl %ecx, 0x2c00(%rax)
testl %edi, %edi
js 0x12feb
movl %edi, 0x2c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogButtons()
void ImGui::LogButtons()
{
    ImGuiState& g = *GImGui;

    ImGui::PushID("LogButtons");
    const bool log_to_tty = ImGui::Button("Log To TTY");
    ImGui::SameLine();
    const bool log_to_file = ImGui::Button("Log To File");
    ImGui::SameLine();
    const bool log_to_clipboard = ImGui::Button("Log To Clipboard");
    ImGui::SameLine();

    ImGui::PushItemWidth(80.0f);
    ImGui::PushAllowKeyboardFocus(false);
    ImGui::SliderInt("Depth", &g.LogAutoExpandMaxDepth, 0, 9, NULL);
    ImGui::PopAllowKeyboardFocus();
    ImGui::PopItemWidth();
    ImGui::PopID();

    // Start logging at the end of the function so that the buttons don't appear in the log
    if (log_to_tty)
        LogToTTY(g.LogAutoExpandMaxDepth);
    if (log_to_file)
        LogToFile(g.LogAutoExpandMaxDepth, g.IO.LogFilename);
    if (log_to_clipboard)
        LogToClipboard(g.LogAutoExpandMaxDepth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x3d47e(%rip), %r13     # 0x50480
leaq 0x241af(%rip), %rdi     # 0x371b8
callq 0x13116
leaq -0x30(%rbp), %r14
andq $0x0, (%r14)
leaq 0x241a6(%rip), %rdi     # 0x371c3
movq %r14, %rsi
callq 0x129b2
movl %eax, %ebx
movss 0x2336d(%rip), %xmm1    # 0x3639c
xorps %xmm0, %xmm0
callq 0x1254d
andq $0x0, (%r14)
leaq 0x2418c(%rip), %rdi     # 0x371ce
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x129b2
movl %eax, %r14d
xorps %xmm0, %xmm0
movss 0x23340(%rip), %xmm1    # 0x3639c
callq 0x1254d
andq $0x0, (%r15)
leaq 0x2416e(%rip), %rdi     # 0x371da
leaq -0x30(%rbp), %rsi
callq 0x129b2
movl %eax, %r15d
xorps %xmm0, %xmm0
movss 0x23319(%rip), %xmm1    # 0x3639c
callq 0x1254d
movss 0x23398(%rip), %xmm0    # 0x36428
callq 0x91e1
xorl %edi, %edi
callq 0x114b0
leaq 0x2c04(%r13), %r12
leaq 0x24141(%rip), %rdi     # 0x371eb
pushq $0x9
popq %rcx
movq %r12, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x13154
callq 0x114ec
callq 0x9272
callq 0x12ea2
testb %bl, %bl
je 0x130d6
movl (%r12), %edi
callq 0x12ec5
testb %r14b, %r14b
je 0x130eb
movl 0x2c04(%r13), %edi
movq 0x20(%r13), %rsi
callq 0x12f10
testb %r15b, %r15b
je 0x13107
movl (%r12), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12fab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x26eff(%rip), %rax     # 0x3a06b
cmovneq %r8, %rax
cvtsi2ssl (%rsi), %xmm1
leaq -0x14(%rbp), %r14
cvtsi2ss %edx, %xmm0
movss %xmm1, (%r14)
cvtsi2ss %ecx, %xmm1
movss 0x23203(%rip), %xmm2    # 0x36390
movq %r14, %rsi
movq %rax, %rdx
callq 0x167a0
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d2c0(%rip), %r13     # 0x50480
movq 0x1758(%r13), %rbx
movq 0x110(%rbx), %r12
movl 0x1848(%r13), %eax
testl %eax, %eax
je 0x1321e
movl %esi, -0x2c(%rbp)
testb $0x1, %al
jne 0x131fb
pushq $-0x1
popq %rdx
movq %r12, %rdi
movl %r15d, %esi
callq 0x8d34
cmpl $-0x1, %eax
je 0x131fb
testl %eax, %eax
setne %r14b
jmp 0x13211
movb 0x1845(%r13), %r14b
movzbl %r14b, %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x8f22
andl $0x0, 0x1848(%r13)
movl -0x2c(%rbp), %ecx
jmp 0x1323a
movl %esi, %edx
andl $0x1, %edx
movq %r12, %rdi
movl %esi, %r14d
movl %r15d, %esi
callq 0x8d34
movl %r14d, %ecx
testl %eax, %eax
setne %r14b
testb $0x2, %cl
jne 0x13262
cmpb $0x0, 0x2be8(%r13)
je 0x13262
movl 0xdc(%rbx), %eax
cmpl 0x2c04(%r13), %eax
movzbl %r14b, %eax
pushq $0x1
popq %r14
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_O2/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 $0x38, %rsp
movq 0x3cd17(%rip), %r15     # 0x50480
movq 0x1758(%r15), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x1384f
movss 0x1718(%r15), %xmm2
movss 0xa8(%rbx), %xmm0
addss %xmm2, %xmm0
movss 0xac(%rbx), %xmm1
movaps %xmm2, -0x40(%rbp)
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0xa8(%rbx), %rax
leaq -0x30(%rbp), %r14
movq %rax, (%r14)
movlps %xmm0, 0x8(%r14)
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x9af8
movq %r14, %rdi
xorl %esi, %esi
callq 0x9b28
testb %al, %al
je 0x1383f
movss 0x22c52(%rip), %xmm0    # 0x3642c
movaps -0x40(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
mulss 0x22be1(%rip), %xmm1    # 0x363d0
movss 0x1408(%r15), %xmm0
addss %xmm1, %xmm0
addss -0x30(%rbp), %xmm0
addss -0x2c(%rbp), %xmm1
movq 0x270(%rbx), %r14
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x48(%rbp), %r15
movlps %xmm0, (%r15)
movss 0x22b70(%rip), %xmm0    # 0x36390
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1eae4
pushq $0xc
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movss -0x1c(%rbp), %xmm0
movl %eax, %edx
callq 0x29c92
movss 0x22b55(%rip), %xmm1    # 0x3639c
xorps %xmm0, %xmm0
callq 0x1254d
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 %rbx
pushq %rax
movq 0x3c9f7(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x13a9f
xorl %r15d, %r15d
jmp 0x13b02
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
addq $0x2df2, %r14           # imm = 0x2DF2
movq %r14, %rdi
movl $0xc01, %esi            # imm = 0xC01
movq %r15, %rdx
callq 0x8446
testq %rbx, %rbx
je 0x13ac9
cmpb $0x0, (%rbx)
jne 0x13acc
movq %r15, %rbx
movq %rbx, %rdi
callq 0x13116
leaq 0x26b4e(%rip), %rsi     # 0x3a629
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x13274
movl %eax, %r14d
callq 0x12ea2
testb %r14b, %r14b
je 0x13b02
movq %rbx, %rdi
callq 0x13b10
movb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3c95f(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
callq 0x1cb1a
incl 0xdc(%r14)
testq %rbx, %rbx
leaq 0x23d13(%rip), %rdi     # 0x37856
cmovneq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x13116
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq 0x3c8a8(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x13bee
xorl %r15d, %r15d
jmp 0x13c4b
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
addq $0x2df2, %r14           # imm = 0x2DF2
movq %r14, %rdi
movl $0xc01, %esi            # imm = 0xC01
movq %r15, %rdx
callq 0x8446
testq %rbx, %rbx
cmoveq %r15, %rbx
movq %rbx, %rdi
callq 0x12e66
leaq 0x26a05(%rip), %rsi     # 0x3a629
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x13274
movl %eax, %r14d
callq 0x12ea2
testb %r14b, %r14b
je 0x13c4b
movq %rbx, %rdi
callq 0x13c59
movb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3c816(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
callq 0x1cb1a
incl 0xdc(%r14)
testq %rbx, %rbx
leaq 0x23bca(%rip), %rdi     # 0x37856
cmovneq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x12e66
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %rax
pushq $0x25
popq %r14
movq %rax, %rdi
movl %r14d, %esi
callq 0x73f0
testq %rax, %rax
je 0x160e5
movb 0x1(%rax), %cl
addq $0x2, %rax
cmpb $0x25, %cl
je 0x160a7
jmp 0x160ca
movb (%rax), %cl
incq %rax
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
jbe 0x160c5
cmpb $0x2e, %cl
jne 0x160e5
movq %rax, %rdi
callq 0x7240
cmpl $0xb, %eax
cmovbl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1610d
movl %edi, %eax
leaq 0x2044a(%rip), %rcx     # 0x36550
movss (%rcx,%rax,4), %xmm1
jmp 0x16123
negl %edi
cvtsi2ss %edi, %xmm1
movss 0x20331(%rip), %xmm0    # 0x3644c
callq 0x7610
movaps %xmm0, %xmm1
movaps 0x201b6(%rip), %xmm0    # 0x362e0
andps -0x10(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0x78c0
movss 0x2028d(%rip), %xmm1    # 0x363d0
movaps -0x20(%rbp), %xmm4
mulss %xmm4, %xmm1
subss %xmm0, %xmm4
movaps 0x201da(%rip), %xmm2    # 0x36330
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_O2/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 0x1f719(%rip), %xmm2    # 0x36450
divss 0x1f715(%rip), %xmm2    # 0x36454
leaq -0x14(%rbp), %r14
movss %xmm2, (%r14)
leaq 0x2058a(%rip), %rdx     # 0x372d9
movss 0x1f639(%rip), %xmm2    # 0x36390
movq %r14, %rsi
callq 0x167a0
movss 0x1f6ed(%rip), %xmm0    # 0x36454
mulss (%r14), %xmm0
divss 0x1f6dc(%rip), %xmm0    # 0x36450
movss %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x232d2(%rip), %rax     # 0x3a06b
cmovneq %r9, %rax
cvtsi2ssl (%rdx), %xmm1
leaq -0x14(%rbp), %r14
cvtsi2ss %ecx, %xmm0
movss %xmm1, (%r14)
cvtsi2ss %r8d, %xmm1
movss 0x1f5d5(%rip), %xmm2    # 0x36390
movq %r14, %rdx
movq %rax, %rcx
callq 0x16acc
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3967f(%rip), %r15     # 0x50480
movq 0x1758(%r15), %rax
movb $0x1, 0x72(%rax)
xorl %ebx, %ebx
cmpb $0x0, 0x74(%rax)
jne 0x16ebc
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
callq 0x16ed0
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x13116
movl %r12d, %edi
callq 0x16fb2
testl %r12d, %r12d
cmovlel %ebx, %r12d
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x16e99
movl %r14d, %edi
callq 0x13d85
leaq 0x2048a(%rip), %rdi     # 0x372e2
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movq -0x48(%rbp), %rdx
movss -0x34(%rbp), %xmm2
callq 0x167a0
orb %al, %bl
movss 0x141c(%r15), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
callq 0x12ea2
callq 0x9272
incq %r14
addq $0x4, %r13
jmp 0x16e44
callq 0x12ea2
movq -0x40(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 %rbx
pushq %rax
movq 0x3959f(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r14
movb $0x1, %r15b
movb %r15b, 0x72(%r14)
leaq 0x168(%r14), %rbx
movl 0x168(%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x1ef7a
movq %rbx, %rdi
callq 0x1f5b2
movq 0xa8(%r14), %rcx
movq %rcx, (%rax)
movq 0xc0(%r14), %rcx
movq %rcx, 0x8(%rax)
movss 0x194(%r14), %xmm0
movss %xmm0, 0x10(%rax)
movss 0xc8(%r14), %xmm0
movss %xmm0, 0x14(%rax)
movss 0xcc(%r14), %xmm0
movss %xmm0, 0x18(%rax)
movss 0xd8(%r14), %xmm0
movss %xmm0, 0x1c(%rax)
movb %r15b, 0x20(%rax)
movss 0xa8(%r14), %xmm0
subss 0x18(%r14), %xmm0
movss %xmm0, 0x194(%r14)
movq 0xa8(%r14), %rax
movq %rax, 0xc0(%r14)
andl $0x0, 0xc8(%r14)
shrq $0x20, %rax
movd %eax, %xmm0
addss 0x1f41e(%rip), %xmm0    # 0x363bc
movss %xmm0, 0xd8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: PushMultiItemsWidths(int, float)
static void PushMultiItemsWidths(int components, float w_full)
{
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    const ImGuiStyle& style = GImGui->Style;
    if (w_full <= 0.0f)
        w_full = ImGui::CalcItemWidth();
    const float w_item_one  = ImMax(1.0f, (float)(int)((w_full - (style.FramePadding.x*2.0f + style.ItemInnerSpacing.x) * (components-1)) / (float)components));
    const float w_item_last = ImMax(1.0f, (float)(int)(w_full - (w_item_one + style.FramePadding.x*2.0f + style.ItemInnerSpacing.x) * (components-1)));
    window->DC.ItemWidthStack.push_back(w_item_last);
    for (int i = 0; i < components-1; i++)
        window->DC.ItemWidthStack.push_back(w_item_one);
    window->DC.ItemWidth = window->DC.ItemWidthStack.back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x394b7(%rip), %r14     # 0x50480
movq 0x1758(%r14), %r15
movb $0x1, 0x72(%r15)
callq 0x1137a
movss 0x1408(%r14), %xmm1
movss 0x141c(%r14), %xmm2
addss %xmm1, %xmm1
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
leal -0x1(%rbx), %r12d
cvtsi2ss %r12d, %xmm4
mulss %xmm4, %xmm3
cvtsi2ss %ebx, %xmm5
movaps %xmm0, %xmm6
subss %xmm3, %xmm6
divss %xmm5, %xmm6
cvttps2dq %xmm6, %xmm3
cvtdq2ps %xmm3, %xmm3
movss 0x1f36e(%rip), %xmm5    # 0x36390
movaps %xmm5, %xmm6
maxss %xmm3, %xmm6
leaq -0x30(%rbp), %rbx
movss %xmm6, (%rbx)
addss %xmm1, %xmm6
addss %xmm2, %xmm6
mulss %xmm4, %xmm6
subss %xmm6, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
maxss %xmm0, %xmm5
leaq -0x2c(%rbp), %rsi
movss %xmm5, (%rsi)
leaq 0x128(%r15), %r14
movq %r14, %rdi
callq 0x1f086
xorl %r13d, %r13d
testl %r12d, %r12d
cmovgl %r12d, %r13d
subl $0x1, %r13d
jb 0x17080
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f086
jmp 0x1706d
movq %r14, %rdi
callq 0x1f108
movss (%rax), %xmm0
movss %xmm0, 0x11c(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 $0x18, %rsp
movq %r9, -0x40(%rbp)
movl %r8d, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movq 0x391dd(%rip), %r13     # 0x50480
movq 0x1758(%r13), %rax
movb $0x1, 0x72(%rax)
xorl %ebx, %ebx
cmpb $0x0, 0x74(%rax)
jne 0x17355
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x16ed0
movq %r12, -0x38(%rbp)
movq %r12, %rdi
callq 0x13116
movl %r14d, %edi
callq 0x16fb2
testl %r14d, %r14d
cmovlel %ebx, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x17332
movl %r12d, %edi
callq 0x13d85
leaq 0x1ffe8(%rip), %rdi     # 0x372e2
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
movq -0x40(%rbp), %r8
callq 0x13154
orb %al, %bl
movss 0x141c(%r13), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
callq 0x12ea2
callq 0x9272
incq %r12
addq $0x4, %r15
jmp 0x172e6
callq 0x12ea2
movq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 0x38a7e(%rip), %r15     # 0x50480
movq 0x1758(%r15), %rax
movb $0x1, 0x72(%rax)
xorl %ebx, %ebx
cmpb $0x0, 0x74(%rax)
jne 0x17ac2
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
callq 0x16ed0
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x13116
movl %r12d, %edi
callq 0x16fb2
testl %r12d, %r12d
cmovlel %ebx, %r12d
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x17a9f
movl %r14d, %edi
callq 0x13d85
leaq 0x1f889(%rip), %rdi     # 0x372e2
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movq -0x48(%rbp), %rdx
movss -0x38(%rbp), %xmm3
callq 0x17681
orb %al, %bl
movss 0x141c(%r15), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
callq 0x12ea2
callq 0x9272
incq %r14
addq $0x4, %r13
jmp 0x17a45
callq 0x12ea2
movq -0x40(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::DragFloatRange2(char const*, float*, float*, float, float, float, char const*, char const*, float)
bool ImGui::DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, const char* display_format, const char* display_format_max, float power)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiState& g = *GImGui;
    ImGui::PushID(label);
    ImGui::BeginGroup();
    PushMultiItemsWidths(2);

    bool value_changed = ImGui::DragFloat("##min", v_current_min, v_speed, (v_min >= v_max) ? -FLT_MAX : v_min, (v_min >= v_max) ? *v_current_max : ImMin(v_max, *v_current_max), display_format, power);
    ImGui::PopItemWidth();
    ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
    value_changed |= ImGui::DragFloat("##max", v_current_max, v_speed, (v_min >= v_max) ? *v_current_min : ImMax(v_min, *v_current_min), (v_min >= v_max) ? FLT_MAX : v_max, display_format_max ? display_format_max : display_format, power);
    ImGui::PopItemWidth();
    ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);

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

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm3, -0x34(%rbp)
movss %xmm0, -0x30(%rbp)
movq 0x38952(%rip), %r12     # 0x50480
movq 0x1758(%r12), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x17b48
xorl %r13d, %r13d
jmp 0x17c76
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %r8, -0x40(%rbp)
movss %xmm2, -0x2c(%rbp)
movaps %xmm1, -0x60(%rbp)
callq 0x13116
callq 0x16ed0
pushq $0x2
popq %rdi
callq 0x16fb2
movss -0x2c(%rbp), %xmm3
movaps -0x60(%rbp), %xmm2
ucomiss %xmm3, %xmm2
movaps %xmm3, %xmm1
cmpless %xmm2, %xmm1
movss 0x1e831(%rip), %xmm0    # 0x363c0
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss (%r13), %xmm2
movq %r13, -0x48(%rbp)
jae 0x17bae
movaps %xmm3, %xmm0
minss %xmm2, %xmm0
movaps %xmm0, %xmm2
leaq 0x1f731(%rip), %rdi     # 0x372e6
movq %r15, %rsi
movss -0x30(%rbp), %xmm0
movq %r14, %rdx
movss -0x34(%rbp), %xmm3
callq 0x17681
movl %eax, %r13d
callq 0x9272
movss 0x141c(%r12), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
movaps -0x60(%rbp), %xmm3
movss -0x2c(%rbp), %xmm2
ucomiss %xmm2, %xmm3
movss (%r15), %xmm1
jae 0x17c0d
movaps %xmm1, %xmm0
cmpless %xmm3, %xmm0
andps %xmm0, %xmm3
andnps %xmm1, %xmm0
orps %xmm3, %xmm0
movaps %xmm0, %xmm1
jmp 0x17c15
movss 0x1e7bf(%rip), %xmm2    # 0x363d4
movq -0x40(%rbp), %rax
testq %rax, %rax
cmovneq %rax, %r14
leaq 0x1f6c5(%rip), %rdi     # 0x372ec
movq -0x48(%rbp), %rsi
movss -0x30(%rbp), %xmm0
movq %r14, %rdx
movss -0x34(%rbp), %xmm3
callq 0x17681
orb %al, %r13b
callq 0x9272
movss 0x141c(%r12), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc24f
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
callq 0x12ea2
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x223cb(%rip), %rax     # 0x3a06b
cmovneq %r8, %rax
cvtsi2ssl (%rsi), %xmm2
leaq -0x14(%rbp), %r14
cvtsi2ss %edx, %xmm1
movss %xmm2, (%r14)
cvtsi2ss %ecx, %xmm2
movss 0x1e6cf(%rip), %xmm3    # 0x36390
movq %r14, %rsi
movq %rax, %rdx
callq 0x17681
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq