LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39cbc(%rip), %rbx     # 0x55490
movq 0x1758(%rbx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1b7ed
xorl %r15d, %r15d
jmp 0x1b8ea
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0x1b900
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x173b3
movl %r15d, %edi
callq 0x1bac1
testl %r15d, %r15d
jle 0x1b8c4
movl %r15d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, %edi
callq 0x18358
leaq 0x22aca(%rip), %rdi     # 0x3e2fa
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movq -0x48(%rbp), %rdx
movss -0x34(%rbp), %xmm2
callq 0x1b0db
movss 0x141c(%rbx), %xmm0
movq 0x39c36(%rip), %rdx     # 0x55490
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1b8a5
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1b87b
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 0x16fc0
callq 0x9e68
incq %r13
addq $0x4, %r12
cmpq %r13, %r14
jne 0x1b821
jmp 0x1b8c7
xorl %r15d, %r15d
callq 0x16fc0
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd93a
callq 0x1bd59
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_O1/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 0x39b7b(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
movl 0x168(%r14), %r12d
movl 0x16c(%r14), %ecx
leal 0x1(%r12), %r15d
cmpl %r12d, %ecx
jg 0x1b9d1
testl %ecx, %ecx
je 0x1b953
movl %ecx, %r13d
shrl $0x1f, %r13d
addl %ecx, %r13d
sarl %r13d
addl %ecx, %r13d
jmp 0x1b959
movl $0x8, %r13d
cmpl %r15d, %r13d
cmovlel %r15d, %r13d
cmpl %r13d, %ecx
jge 0x1b9d1
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
testq %rdi, %rdi
je 0x1b9b6
movq 0x39ae0(%rip), %rax     # 0x55490
decl 0x334(%rax)
movq 0x39ad3(%rip), %rax     # 0x55490
callq *0xd8(%rax)
movq %rbx, 0x170(%r14)
movl %r13d, 0x16c(%r14)
movl %r15d, 0x168(%r14)
testl %r12d, %r12d
js 0x1baa2
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 0xac(%r14), %xmm1
movss %xmm0, 0x194(%r14)
movq 0xa8(%r14), %rax
movq %rax, 0xc0(%r14)
movl $0x0, 0xc8(%r14)
addss 0x2197a(%rip), %xmm1    # 0x3d404
movss %xmm1, 0xd8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b10c(%rip), %rdi     # 0x46bb5
leaq 0x22fe3(%rip), %rsi     # 0x3ea93
leaq 0x23be9(%rip), %rcx     # 0x3f6a0
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x394d8(%rip), %rax     # 0x55490
movq %rax, -0x48(%rbp)
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1bfd5
xorl %r15d, %r15d
jmp 0x1c11c
movq %r9, %r13
movl %r8d, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, -0x2c(%rbp)
callq 0x1b900
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
callq 0x173b3
movl %r15d, %edi
callq 0x1bac1
testl %r15d, %r15d
jle 0x1c0f6
testq %r13, %r13
movl %r12d, %eax
leaq 0x24ee5(%rip), %r12     # 0x40efb
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 0x18358
xorps %xmm0, %xmm0
cvtsi2ssl (%r14,%r13,4), %xmm0
movss %xmm0, -0x30(%rbp)
leaq 0x222a4(%rip), %rdi     # 0x3e2fa
leaq -0x30(%rbp), %rsi
movss -0x2c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
movq %r12, %rdx
movss 0x21311(%rip), %xmm2    # 0x3d380
callq 0x1b0db
cvttss2si -0x30(%rbp), %ecx
movl %ecx, (%r14,%r13,4)
movq -0x48(%rbp), %rcx
movss 0x141c(%rcx), %xmm0
movq 0x39400(%rip), %rdx     # 0x55490
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1c0db
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1c0b1
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 0x16fc0
callq 0x9e68
incq %r13
cmpq %r13, %rbx
jne 0x1c039
jmp 0x1c0f9
xorl %r15d, %r15d
callq 0x16fc0
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd93a
callq 0x1bd59
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_O1/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 0x38c10(%rip), %rbx     # 0x55490
movq 0x1758(%rbx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1c899
xorl %r15d, %r15d
jmp 0x1c99b
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0x1b900
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x173b3
movl %r15d, %edi
callq 0x1bac1
testl %r15d, %r15d
jle 0x1c975
movl %r15d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, %edi
callq 0x18358
leaq 0x21a1e(%rip), %rdi     # 0x3e2fa
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movq -0x48(%rbp), %rdx
movss -0x38(%rbp), %xmm3
callq 0x1c4a4
movss 0x141c(%rbx), %xmm0
movq 0x38b85(%rip), %rdx     # 0x55490
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1c956
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1c92c
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 0x16fc0
callq 0x9e68
incq %r13
addq $0x4, %r12
cmpq %r13, %r14
jne 0x1c8cd
jmp 0x1c978
xorl %r15d, %r15d
callq 0x16fc0
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd93a
callq 0x1bd59
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_O1/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 0x242d7(%rip), %rax     # 0x40efb
cmovneq %r8, %rax
cvtsi2ssl (%rsi), %xmm2
leaq -0x14(%rbp), %r14
cvtsi2ss %edx, %xmm1
movss %xmm2, (%r14)
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
movss 0x20738(%rip), %xmm3    # 0x3d380
movq %r14, %rsi
movq %rax, %rdx
callq 0x1c4a4
cvttss2si (%r14), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38810(%rip), %rax     # 0x55490
movq %rax, -0x48(%rbp)
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1cc9d
xorl %r15d, %r15d
jmp 0x1cdec
movq %r9, %r15
movl %r8d, %r12d
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, -0x2c(%rbp)
callq 0x1b900
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
callq 0x173b3
movl %r13d, %edi
callq 0x1bac1
testl %r13d, %r13d
jle 0x1cdc6
testq %r15, %r15
movl %r12d, %eax
leaq 0x2421d(%rip), %r12     # 0x40efb
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 0x18358
xorps %xmm0, %xmm0
cvtsi2ssl (%r14,%r13,4), %xmm0
movss %xmm0, -0x30(%rbp)
leaq 0x215d9(%rip), %rdi     # 0x3e2fa
leaq -0x30(%rbp), %rsi
movss -0x38(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
movq %r12, %rdx
movss 0x20641(%rip), %xmm3    # 0x3d380
callq 0x1c4a4
cvttss2si -0x30(%rbp), %ecx
movl %ecx, (%r14,%r13,4)
movq -0x48(%rbp), %rcx
movss 0x141c(%rcx), %xmm0
movq 0x38730(%rip), %rdx     # 0x55490
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1cdab
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1cd81
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 0x16fc0
callq 0x9e68
incq %r13
cmpq %r13, %rbx
jne 0x1cd04
jmp 0x1cdc9
xorl %r15d, %r15d
callq 0x16fc0
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd93a
callq 0x1bd59
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_O1/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 0x1da36
cmpb $0x1, (%r15)
jne 0x1deb3
orl (%r14), %ebx
jmp 0x1deb8
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_O1/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 0x1dec6
testb %al, %al
je 0x1e437
movl %ebx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextEditCallbackData::DeleteChars(int, int)
void ImGuiTextEditCallbackData::DeleteChars(int pos, int bytes_count)
{
    char* dst = Buf + pos;
    const char* src = Buf + pos + bytes_count;
    while (char c = *src++)
        *dst++ = c;
    *dst = '\0';

    BufDirty = true;
    if (CursorPos + bytes_count >= pos)
        CursorPos -= bytes_count;
    else if (CursorPos >= pos)
        CursorPos = pos;
    SelectionStart = SelectionEnd = CursorPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
addq 0x18(%rdi), %rax
movslq %edx, %rcx
addq %rax, %rcx
movb (%rcx), %r8b
testb %r8b, %r8b
je 0x1f0b3
movb %r8b, (%rax)
incq %rax
incq %rcx
testb %r8b, %r8b
jne 0x1f0a5
movb $0x0, (%rax)
movb $0x1, 0x24(%rdi)
movl 0x28(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl %esi, %ecx
jge 0x1f0d2
cmpl %esi, %eax
jge 0x1f0d6
jmp 0x1f0d9
subl %edx, %eax
movl %eax, %esi
movl %esi, 0x28(%rdi)
movl 0x28(%rdi), %eax
movl %eax, 0x30(%rdi)
movl %eax, 0x2c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiTextEditCallbackData::InsertChars(int, char const*, char const*)
void ImGuiTextEditCallbackData::InsertChars(int pos, const char* new_text, const char* new_text_end)
{
    const int text_len = (int)strlen(Buf);
    if (!new_text_end)
        new_text_end = new_text + strlen(new_text);
    const int new_text_len = (int)(new_text_end - new_text);

    if (new_text_len + text_len + 1 >= BufSize)
        return;

    if (text_len != pos)
        memmove(Buf + pos + new_text_len, Buf + pos, (size_t)(text_len - pos));
    memcpy(Buf + pos, new_text, (size_t)new_text_len * sizeof(char));
    Buf[text_len + new_text_len] = '\0';

    BufDirty = true;
    if (CursorPos >= pos)
        CursorPos += new_text_len;
    SelectionStart = SelectionEnd = CursorPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x18(%rdi), %r12
movq %r12, %rdi
callq 0x72f0
movq %rax, %r13
testq %r14, %r14
jne 0x1f120
movq %r15, %rdi
callq 0x72f0
movq %rax, %r14
addq %r15, %r14
subq %r15, %r14
leal (%r14,%r13), %eax
incl %eax
cmpl 0x20(%rbx), %eax
jge 0x1f196
leal (%r14,%r13), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
movslq %eax, %rcx
subl %eax, %r13d
je 0x1f15a
addq %rcx, %r12
movslq %r14d, %rdi
addq %r12, %rdi
movslq %r13d, %rdx
movq %r12, %rsi
movq %rcx, %r12
callq 0x7130
movq %r12, %rcx
movq 0x18(%rbx), %rdi
addq %rcx, %rdi
movslq %r14d, %rdx
movq %r15, %rsi
movq %rcx, %r15
callq 0x7080
movq 0x18(%rbx), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x1, 0x24(%rbx)
movl 0x28(%rbx), %eax
cmpl %r15d, %eax
jl 0x1f18d
addl %r14d, %eax
movl %eax, 0x28(%rbx)
movl 0x28(%rbx), %eax
movl %eax, 0x30(%rbx)
movl %eax, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_paste(ImGuiTextEditState*, ImGuiStb::STB_TexteditState*, unsigned short const*, int)
static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
{
   STB_TEXTEDIT_CHARTYPE *text = (STB_TEXTEDIT_CHARTYPE *) ctext;
   // if there's a selection, the paste should delete it
   stb_textedit_clamp(str, state);
   stb_textedit_delete_selection(str,state);
   // try to insert the characters
   if (STB_TEXTEDIT_INSERTCHARS(str, state->cursor, text, len)) {
      stb_text_makeundo_insert(state, state->cursor, len);
      state->cursor += len;
      state->has_preferred_x = 0;
      return 1;
   }
   // remove the undo since we didn't actually insert the characters
   if (state->undostate.undo_point)
      --state->undostate.undo_point;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0x2396d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x238d0
movl (%rbx), %esi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x237f5
testb %al, %al
je 0x1f37d
movl (%rbx), %esi
leaq 0x18(%rbx), %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x23c91
addl %r14d, (%rbx)
movb $0x0, 0xf(%rbx)
jmp 0x1f392
movzwl 0xc8a(%rbx), %eax
testw %ax, %ax
je 0x1f392
decl %eax
movw %ax, 0xc8a(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: InputTextCalcTextSizeW(unsigned short const*, unsigned short const*, unsigned short const**, ImVec2*, bool)
static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining, ImVec2* out_offset, bool stop_on_new_line)
{
    ImFont* font = GImGui->Font;
    const float line_height = GImGui->FontSize;
    const float scale = line_height / font->FontSize;

    ImVec2 text_size = ImVec2(0,0);
    float line_width = 0.0f;

    const ImWchar* s = text_begin;
    while (s < text_end)
    {
        unsigned int c = (unsigned int)(*s++);
        if (c == '\n')
        {
            text_size.x = ImMax(text_size.x, line_width);
            text_size.y += line_height;
            line_width = 0.0f;
            if (stop_on_new_line)
                break;
            continue;
        }
        if (c == '\r')
            continue;

        const float char_width = font->GetCharAdvance((unsigned short)c) * scale;
        line_width += char_width;
    }

    if (text_size.x < line_width)
        text_size.x = line_width;

    if (out_offset)
        *out_offset = ImVec2(line_width, text_size.y + line_height);  // offset allow for the possibility of sitting after a trailing \n

    if (line_width > 0 || text_size.y == 0.0f)                        // whereas size.y will ignore the trailing \n
        text_size.y += line_height;

    if (remaining)
        *remaining = s;

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x360ea(%rip), %r8      # 0x55490
movq 0x1710(%r8), %rax
movss 0x1718(%r8), %xmm0
movaps %xmm0, %xmm3
divss (%rax), %xmm3
leaq 0x50(%rax), %r8
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
cmpq %rsi, %rdi
jae 0x1f433
movzwl (%rdi), %r9d
cmpl $0xd, %r9d
je 0x1f427
cmpl $0xa, %r9d
jne 0x1f406
movaps %xmm2, %xmm4
cmpless %xmm1, %xmm4
movaps %xmm4, %xmm5
andps %xmm1, %xmm5
andnps %xmm2, %xmm4
orps %xmm5, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
addss %xmm0, %xmm1
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
xorps %xmm2, %xmm2
movaps %xmm4, %xmm1
movl %ecx, %r9d
jmp 0x1f42a
leal (,%r9,4), %r10d
addq 0x60(%rax), %r10
cmpl %r9d, 0x58(%rax)
cmovleq %r8, %r10
movss (%r10), %xmm4
mulss %xmm3, %xmm4
addss %xmm4, %xmm2
xorl %r9d, %r9d
addq $0x2, %rdi
testb %r9b, %r9b
je 0x1f3c7
testq %rdx, %rdx
je 0x1f43b
movq %rdi, (%rdx)
ucomiss %xmm1, %xmm2
jbe 0x1f444
movss %xmm2, %xmm1            # xmm1 = xmm2[0],xmm1[1,2,3]
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
xorps %xmm4, %xmm4
movaps %xmm3, %xmm5
cmpeqps %xmm4, %xmm5
cmpltps %xmm2, %xmm4
orps %xmm5, %xmm4
movd %xmm4, %eax
testb $0x1, %al
jne 0x1f469
movaps %xmm1, %xmm0
jmp 0x1f474
addss %xmm3, %xmm0
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::InputFloat(char const*, float*, float, float, int, int)
bool ImGui::InputFloat(const char* label, float* v, float step, float step_fast, int decimal_precision, ImGuiInputTextFlags extra_flags)
{
    char display_format[16];
    if (decimal_precision < 0)
        strcpy(display_format, "%f");      // Ideally we'd have a minimum decimal precision of 1 to visually denote that this is a float, while hiding non-significant digits? %f doesn't have a minimum of 1
    else
        ImFormatString(display_format, 16, "%%%df", decimal_precision);
    return InputScalarEx(label, ImGuiDataType_Float, (void*)v, (void*)(step>0.0f ? &step : NULL), (void*)(step_fast>0.0f ? &step_fast : NULL), display_format, extra_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movss %xmm0, -0x20(%rbp)
movss %xmm1, -0x1c(%rbp)
testl %edx, %edx
js 0x1f8ad
movl %edx, %ecx
leaq 0x1edb0(%rip), %rdx     # 0x3e64b
leaq -0x30(%rbp), %rdi
movl $0x10, %esi
xorl %eax, %eax
callq 0x86d8
jmp 0x1f8b7
movb $0x0, -0x2e(%rbp)
movw $0x6625, -0x30(%rbp)    # imm = 0x6625
leaq -0x20(%rbp), %rcx
movss (%rcx), %xmm0
xorl %r8d, %r8d
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
cmovbeq %r8, %rcx
leaq -0x1c(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
cmovaq %rax, %r8
movl %r14d, (%rsp)
leaq -0x30(%rbp), %r9
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1f4ae
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::InputFloatN(char const*, float*, int, int, int)
bool ImGui::InputFloatN(const char* label, float* v, int components, int decimal_precision, ImGuiInputTextFlags extra_flags)
{
    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::InputFloat("##v", &v[i], 0, 0, decimal_precision, extra_flags);
        ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
        ImGui::PopID();
        ImGui::PopItemWidth();
    }
    ImGui::PopID();

    window->DC.CurrentLineTextBaseOffset = ImMax(window->DC.CurrentLineTextBaseOffset, g.Style.FramePadding.y);
    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
movl %r8d, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movq 0x35b1c(%rip), %r15     # 0x55490
movq 0x1758(%r15), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1f98d
xorl %r14d, %r14d
jmp 0x1fab1
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
movq %rax, -0x38(%rbp)
callq 0x1b900
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x173b3
movl %ebx, %edi
callq 0x1bac1
testl %ebx, %ebx
jle 0x1fa5d
movl %ebx, %r12d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x18358
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
leaq 0x1e925(%rip), %rdi     # 0x3e2fa
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x1f86e
movss 0x141c(%r15), %xmm0
movq 0x35a9d(%rip), %rdx     # 0x55490
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1fa3e
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1fa14
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, %r14b
callq 0x16fc0
callq 0x9e68
incq %rbx
addq $0x4, %r13
cmpq %rbx, %r12
jne 0x1f9c1
jmp 0x1fa60
xorl %r14d, %r14d
callq 0x16fc0
movq -0x38(%rbp), %rax
movss 0xcc(%rax), %xmm0
movss 0x140c(%r15), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0xcc(%rax)
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd93a
callq 0x1bd59
andb $0x1, %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::InputIntN(char const*, int*, int, int)
bool ImGui::InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags)
{
    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::InputInt("##v", &v[i], 0, 0, extra_flags);
        ImGui::SameLine(0, g.Style.ItemInnerSpacing.x);
        ImGui::PopID();
        ImGui::PopItemWidth();
    }
    ImGui::PopID();

    window->DC.CurrentLineTextBaseOffset = ImMax(window->DC.CurrentLineTextBaseOffset, g.Style.FramePadding.y);
    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
movl %ecx, -0x2c(%rbp)
movq 0x35972(%rip), %rax     # 0x55490
movq %rax, -0x38(%rbp)
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1fb3b
xorl %r14d, %r14d
jmp 0x1fc7f
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %rax, -0x40(%rbp)
callq 0x1b900
movq %r14, -0x48(%rbp)
movq %r14, %rdi
callq 0x173b3
movl %ebx, %edi
callq 0x1bac1
testl %ebx, %ebx
jle 0x1fc28
testb $0x2, -0x2c(%rbp)
leaq 0x1ed15(%rip), %rax     # 0x3e887
leaq 0x1ed40(%rip), %r13     # 0x3e8b9
cmoveq %rax, %r13
movl %ebx, %r15d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x18358
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
leaq 0x1e761(%rip), %rdi     # 0x3e2fa
xorl %esi, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0x1f4ae
movq -0x38(%rbp), %rcx
movss 0x141c(%rcx), %xmm0
movq 0x358d2(%rip), %rdx     # 0x55490
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1fc09
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1fbdf
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, %r14b
callq 0x16fc0
callq 0x9e68
incq %rbx
addq $0x4, %r12
cmpq %rbx, %r15
jne 0x1fb85
jmp 0x1fc2b
xorl %r14d, %r14d
callq 0x16fc0
movq -0x40(%rbp), %rax
movss 0xcc(%rax), %xmm0
movq -0x38(%rbp), %rcx
movss 0x140c(%rcx), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0xcc(%rax)
movq -0x48(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe1e7
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd93a
callq 0x1bd59
andb $0x1, %r14b
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: PushColumnClipRect(int)
static void PushColumnClipRect(int column_index)
{
    ImGuiWindow* window = ImGui::GetCurrentWindow();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    const float x1 = window->Pos.x + ImGui::GetColumnOffset(column_index) - 1;
    const float x2 = window->Pos.x + ImGui::GetColumnOffset(column_index+1) - 1;
    PushClipRect(ImVec4(x1,-FLT_MAX,x2,+FLT_MAX));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x34ba7(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
movl 0x19c(%r14), %ebx
movss 0x18(%r14), %xmm0
movss %xmm0, -0x14(%rbp)
movl %ebx, %edi
callq 0x158dd
addss -0x14(%rbp), %xmm0
addss 0x1ca71(%rip), %xmm0    # 0x3d38c
movss %xmm0, -0x14(%rbp)
movss 0x18(%r14), %xmm0
movss %xmm0, -0x18(%rbp)
incl %ebx
movl %ebx, %edi
callq 0x158dd
addss -0x18(%rbp), %xmm0
addss 0x1ca4b(%rip), %xmm0    # 0x3d38c
leaq -0x28(%rbp), %rdi
movss -0x14(%rbp), %xmm1
movss %xmm1, (%rdi)
movl $0xff7fffff, 0x4(%rdi)  # imm = 0xFF7FFFFF
movss %xmm0, 0x8(%rdi)
movl $0x7f7fffff, 0xc(%rdi)  # imm = 0x7F7FFFFF
movl $0x1, %esi
callq 0x13a7b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ListBoxHeader(char const*, int, int)
bool ImGui::ListBoxHeader(const char* label, int items_count, int height_in_items)
{
    // Size default to hold ~7 items. Fractional number of items helps seeing that we can scroll down/up without looking at scrollbar.
    // However we don't add +0.40f if items_count <= height_in_items. It is slightly dodgy, because it means a dynamic list of items will make the widget resize occasionally when it crosses that size.
    // I am expecting that someone will come and complain about this behavior in a remote future, then we can advise on a better solution.
    if (height_in_items < 0)
        height_in_items = ImMin(items_count, 7);
    float height_in_items_f = height_in_items < items_count ? (height_in_items + 0.40f) : (height_in_items + 0.00f);

    // We include ItemSpacing.y so that a list sized for the exact number of items doesn't make a scrollbar appears. We could also enforce that by passing a flag to BeginChild().
    ImVec2 size;
    size.x = 0.0f;
    size.y = ImGui::GetTextLineHeightWithSpacing() * height_in_items_f + ImGui::GetStyle().ItemSpacing.y;
    return ImGui::ListBoxHeader(label, size);
}

// Assembly:
cmpl $0x7, %esi
movl $0x7, %eax
cmovll %esi, %eax
testl %edx, %edx
cmovnsl %edx, %eax
cvtsi2ss %eax, %xmm0
cmpl %esi, %eax
jge 0x20b7f
addss 0x1c849(%rip), %xmm0    # 0x3d3c8
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movq $0x0, (%rsi)
movq 0x348f7(%rip), %rax     # 0x55490
movss 0x1418(%rax), %xmm1
movss 0x1718(%rax), %xmm2
addss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movss %xmm2, 0x4(%rsi)
callq 0x20993
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ListBoxFooter()
void ImGui::ListBoxFooter()
{
    ImGuiWindow* parent_window = GetParentWindow();
    const ImRect bb = parent_window->DC.LastItemRect;
    const ImGuiStyle& style = ImGui::GetStyle();

    ImGui::EndChildFrame();

    // Redeclare item size so that it includes the label (we have stored the full size in LastItemRect)
    // We call SameLine() to restore DC.CurrentLine* data
    ImGui::SameLine();
    parent_window->DC.CursorPos = bb.Min;
    ItemSize(bb, style.FramePadding.y);
    ImGui::EndGroup();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
callq 0xaa50
movq %rax, %rbx
movss 0xe4(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movss 0xe8(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movss 0xec(%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movss 0xf0(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movq 0x3487f(%rip), %r14     # 0x55490
callq 0x134d7
movl $0x1, %edi
callq 0x12ffd
movl $0x1, %edi
callq 0x13916
movq 0x3485f(%rip), %rcx     # 0x55490
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x20c74
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)
movss -0x14(%rbp), %xmm3
movss %xmm3, 0xa8(%rbx)
movss -0x18(%rbp), %xmm2
movss %xmm2, 0xac(%rbx)
movss 0x140c(%r14), %xmm0
movaps -0x40(%rbp), %xmm1
subss %xmm3, %xmm1
movaps -0x30(%rbp), %xmm3
subss %xmm2, %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
leaq -0x48(%rbp), %rdi
movlps %xmm1, (%rdi)
callq 0xaab7
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1bd59
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ListBox(char const*, int*, bool (*)(void*, int, char const**), void*, int, int)
bool ImGui::ListBox(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items)
{
    if (!ImGui::ListBoxHeader(label, items_count, height_in_items))
        return false;

    // Assume all items have even height (= 1 line of text). If you need items of different or variable sizes you can create a custom version of ListBox() in your code without using the clipper.
    bool value_changed = false;
    ImGuiListClipper clipper(items_count, ImGui::GetTextLineHeightWithSpacing());
    for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
    {
        const bool item_selected = (i == *current_item);
        const char* item_text;
        if (!items_getter(data, i, &item_text))
            item_text = "*Unknown item*";

        ImGui::PushID(i);
        if (ImGui::Selectable(item_text, item_selected))
        {
            *current_item = i;
            value_changed = true;
        }
        ImGui::PopID();
    }
    clipper.End();
    ImGui::ListBoxFooter();
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %r8d, %esi
movl %r9d, %edx
callq 0x20b5f
testb %al, %al
je 0x20db5
movq 0x3477c(%rip), %rax     # 0x55490
movss 0x1718(%rax), %xmm0
addss 0x1418(%rax), %xmm0
leaq -0x48(%rbp), %rdi
movl $0xffffffff, 0x4(%rdi)  # imm = 0xFFFFFFFF
movq %rdi, %r13
movl %ebx, %esi
callq 0x24ee4
movq %r13, %rax
movl 0x8(%r13), %r13d
cmpl 0xc(%rax), %r13d
jge 0x20db9
movl $0x0, -0x2c(%rbp)
movl (%r12), %ebx
movq %r14, %rdi
movl %r13d, %esi
leaq -0x38(%rbp), %rdx
callq *%r15
testb %al, %al
jne 0x20d6d
leaq 0x1d8e8(%rip), %rax     # 0x3e651
movq %rax, -0x38(%rbp)
movl %r13d, %edi
callq 0x18358
xorl %esi, %esi
cmpl %ebx, %r13d
sete %sil
movq -0x38(%rbp), %rdi
movq $0x0, -0x50(%rbp)
xorl %edx, %edx
leaq -0x50(%rbp), %rcx
callq 0x20486
testb %al, %al
je 0x20da2
movl %r13d, (%r12)
movb $0x1, %al
movl %eax, -0x2c(%rbp)
callq 0x16fc0
incl %r13d
cmpl -0x3c(%rbp), %r13d
jl 0x20d4d
movl -0x2c(%rbp), %ebx
jmp 0x20dbb
xorl %ebx, %ebx
jmp 0x20dcf
xorl %ebx, %ebx
leaq -0x48(%rbp), %rdi
callq 0x24b20
callq 0x20bc5
cmpl $-0x1, -0x44(%rbp)
jne 0x20df5
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20de7
jmp 0x20de7
cmpl $-0x1, -0x44(%rbp)
jne 0x20df5
movq %rax, %rdi
callq 0x74d0
leaq 0x1e05f(%rip), %rdi     # 0x3ee5b
leaq 0x1dc90(%rip), %rsi     # 0x3ea93
leaq 0x1e0b8(%rip), %rcx     # 0x3eec2
movl $0x3e2, %edx            # imm = 0x3E2
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginMainMenuBar()
bool ImGui::BeginMainMenuBar()
{
    ImGuiState& g = *GImGui;
    ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
    ImGui::SetNextWindowSize(ImVec2(g.IO.DisplaySize.x, g.FontBaseSize + g.Style.FramePadding.y * 2.0f));
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0,0));
    if (!ImGui::Begin("##MainMenuBar", NULL, ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoScrollbar|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_MenuBar)
        || !ImGui::BeginMenuBar())
    {
        ImGui::End();
        ImGui::PopStyleVar(2);
        return false;
    }
    g.CurrentWindow->DC.MenuBarOffsetX += g.Style.DisplaySafeAreaPadding.x;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x343d7(%rip), %r14     # 0x55490
xorl %r15d, %r15d
movq %r15, 0x1818(%r14)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1834(%r14)
movl 0x8(%r14), %eax
movss 0x140c(%r14), %xmm0
addss %xmm0, %xmm0
addss 0x171c(%r14), %xmm0
movl %eax, 0x1820(%r14)
movss %xmm0, 0x1824(%r14)
xorps %xmm0, %xmm0
movl $0x2, %edi
callq 0x137a2
leaq -0x20(%rbp), %rbx
movq %r15, (%rbx)
movl $0x3, %edi
movq %rbx, %rsi
callq 0x15319
movq %r15, (%rbx)
leaq 0x1d537(%rip), %rdi     # 0x3e660
leaq -0x20(%rbp), %rdx
movss 0x1c257(%rip), %xmm0    # 0x3d38c
xorl %esi, %esi
movl $0x50f, %ecx            # imm = 0x50F
callq 0xf7d7
testb %al, %al
je 0x21172
callq 0x2118e
testb %al, %al
je 0x21172
movss 0x1450(%r14), %xmm0
movq 0x1758(%r14), %rax
addss 0xf8(%rax), %xmm0
movss %xmm0, 0xf8(%rax)
movb $0x1, %al
jmp 0x21183
callq 0xcdc7
movl $0x2, %edi
callq 0x12ffd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginMenuBar()
bool ImGui::BeginMenuBar()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;
    if (!(window->Flags & ImGuiWindowFlags_MenuBar))
        return false;

    IM_ASSERT(!window->DC.MenuBarAppending);
    ImGui::BeginGroup(); // Save position
    ImGui::PushID("##menubar");
    ImRect rect = window->MenuBarRect();
    PushClipRect(ImVec4(rect.Min.x+0.5f, rect.Min.y-0.5f, rect.Max.x+0.5f, rect.Max.y-1.5f), false);
    window->DC.CursorPos = ImVec2(rect.Min.x + window->DC.MenuBarOffsetX, rect.Min.y);// + g.Style.FramePadding.y);
    window->DC.LayoutType = ImGuiLayoutType_Horizontal;
    window->DC.MenuBarAppending = true;
    ImGui::AlignFirstTextHeightToWidgets();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq 0x342f2(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x211b5
testb $0x4, 0xd(%rbx)
jne 0x211bc
xorl %eax, %eax
jmp 0x2126f
cmpb $0x1, 0xf6(%rbx)
je 0x21276
callq 0x1b900
leaq 0x1d4d1(%rip), %rdi     # 0x3e6a6
callq 0x173b3
movq %rbx, %rdi
callq 0x249c6
movaps %xmm0, -0x30(%rbp)
movss 0x1c1ce(%rip), %xmm4    # 0x3d3bc
movaps %xmm0, %xmm2
addss %xmm4, %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movaps %xmm3, -0x20(%rbp)
addss 0x1c1c4(%rip), %xmm3    # 0x3d3cc
addss %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
addss 0x1c220(%rip), %xmm1    # 0x3d438
leaq -0x40(%rbp), %rdi
movss %xmm2, (%rdi)
movss %xmm3, 0x4(%rdi)
movss %xmm4, 0x8(%rdi)
movss %xmm1, 0xc(%rdi)
xorl %esi, %esi
callq 0x13a7b
movss 0xf8(%rbx), %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, 0xa8(%rbx)
movaps -0x20(%rbp), %xmm0
movss %xmm0, 0xac(%rbx)
movl $0x1, 0x118(%rbx)
movb $0x1, 0xf6(%rbx)
callq 0x1635b
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1d3f1(%rip), %rdi     # 0x3e66e
leaq 0x1c401(%rip), %rsi     # 0x3d685
leaq 0x1d400(%rip), %rcx     # 0x3e68b
movl $0x1fc4, %edx           # imm = 0x1FC4
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::EndMenuBar()
void ImGui::EndMenuBar()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    IM_ASSERT(window->Flags & ImGuiWindowFlags_MenuBar);
    IM_ASSERT(window->DC.MenuBarAppending);
    PopClipRect();
    ImGui::PopID();
    window->DC.MenuBarOffsetX = window->DC.CursorPos.x - window->MenuBarRect().Min.x;
    window->DC.GroupStack.back().AdvanceCursor = false;
    ImGui::EndGroup();
    window->DC.LayoutType = ImGuiLayoutType_Vertical;
    window->DC.MenuBarAppending = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x341d0(%rip), %rax     # 0x55490
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x21349
testb $0x4, 0xd(%rbx)
je 0x21352
cmpb $0x0, 0xf6(%rbx)
je 0x21371
callq 0x14adb
callq 0x16fc0
movss 0xa8(%rbx), %xmm0
movss %xmm0, -0x14(%rbp)
movq %rbx, %rdi
callq 0x249c6
movss -0x14(%rbp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xf8(%rbx)
movslq 0x168(%rbx), %rax
testq %rax, %rax
jle 0x21390
movq 0x170(%rbx), %rcx
leaq (%rax,%rax,8), %rax
xorl %r14d, %r14d
movb %r14b, -0x4(%rcx,%rax,4)
callq 0x1bd59
movl $0x0, 0x118(%rbx)
movb %r14b, 0xf6(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d357(%rip), %rdi     # 0x3e6b0
leaq 0x1c325(%rip), %rsi     # 0x3d685
leaq 0x1d372(%rip), %rcx     # 0x3e6d9
movl $0x1fd6, %edx           # imm = 0x1FD6
callq 0x7140
leaq 0x1d2f7(%rip), %rdi     # 0x3e66f
leaq 0x1c306(%rip), %rsi     # 0x3d685
leaq 0x1d353(%rip), %rcx     # 0x3e6d9
movl $0x1fd7, %edx           # imm = 0x1FD7
callq 0x7140
leaq 0x2581e(%rip), %rdi     # 0x46bb5
leaq 0x1d6f5(%rip), %rsi     # 0x3ea93
leaq 0x1e2fb(%rip), %rcx     # 0x3f6a0
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ColorEdit3(char const*, float*)
bool ImGui::ColorEdit3(const char* label, float col[3])
{
    float col4[4];
    col4[0] = col[0];
    col4[1] = col[1];
    col4[2] = col[2];
    col4[3] = 1.0f;
    const bool value_changed = ImGui::ColorEdit4(label, col4, false);
    col[0] = col4[0];
    col[1] = col4[1];
    col[2] = col4[2];
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movss (%rsi), %xmm0
leaq -0x20(%rbp), %r14
movss %xmm0, (%r14)
movss 0x4(%rsi), %xmm0
movss %xmm0, 0x4(%r14)
movss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%r14)
movl $0x3f800000, 0xc(%r14)  # imm = 0x3F800000
movq %r14, %rsi
xorl %edx, %edx
callq 0x21d54
movss (%r14), %xmm0
movss %xmm0, (%rbx)
movss 0x4(%r14), %xmm0
movss %xmm0, 0x4(%rbx)
movss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Separator()
void ImGui::Separator()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    if (window->DC.ColumnsCount > 1)
        PopClipRect();

    float x1 = window->Pos.x;
    float x2 = window->Pos.x + window->Size.x;
    if (!window->DC.GroupStack.empty())
        x1 += window->DC.ColumnsStartX;

    const ImRect bb(ImVec2(x1, window->DC.CursorPos.y), ImVec2(x2, window->DC.CursorPos.y));
    ItemSize(ImVec2(0.0f, 0.0f)); // NB: we don't provide our width so that it doesn't get feed back into AutoFit   // FIXME: Height should be 1.0f not 0.0f ?
    if (!ItemAdd(bb, NULL))
    {
        if (window->DC.ColumnsCount > 1)
            PushColumnClipRect();
        return;
    }

    window->DrawList->AddLine(bb.Min, bb.Max, window->Color(ImGuiCol_Border));

    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        ImGui::LogText(IM_NEWLINE "--------------------------------");

    if (window->DC.ColumnsCount > 1)
    {
        PushColumnClipRect();
        window->DC.ColumnsCellMinY = window->DC.CursorPos.y;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x32edd(%rip), %rax     # 0x55490
movq 0x1758(%rax), %r15
movb $0x1, 0x72(%r15)
cmpb $0x0, 0x74(%r15)
je 0x225d1
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, 0x1a0(%r15)
jl 0x225e0
callq 0x14adb
movss 0x18(%r15), %xmm1
movss 0x20(%r15), %xmm0
addss %xmm1, %xmm0
cmpl $0x0, 0x168(%r15)
je 0x22603
addss 0x194(%r15), %xmm1
movl 0xac(%r15), %eax
leaq -0x28(%rbp), %rbx
movss %xmm1, (%rbx)
movl %eax, 0x4(%rbx)
movss %xmm0, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq -0x40(%rbp), %rdi
movq $0x0, (%rdi)
xorps %xmm0, %xmm0
callq 0xaab7
movq %rbx, %rdi
xorl %esi, %esi
callq 0xac09
testb %al, %al
je 0x226da
leaq -0x20(%rbp), %rbx
movq 0x270(%r15), %r14
movq 0x32e3c(%rip), %rax     # 0x55490
movups 0x14a0(%rax), %xmm0
leaq -0x40(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8cce
leaq -0x28(%rbp), %rsi
movss 0x1acfb(%rip), %xmm0    # 0x3d380
movq %r14, %rdi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x2fdee
movq 0x32df7(%rip), %rax     # 0x55490
cmpb $0x1, 0x2be8(%rax)
jne 0x226b0
leaq 0x1c0f4(%rip), %rdi     # 0x3e79d
xorl %eax, %eax
callq 0xe031
cmpl $0x2, 0x1a0(%r15)
jl 0x225c6
callq 0x208d7
movss 0xac(%r15), %xmm0
movss %xmm0, 0x1ac(%r15)
jmp 0x225c6
cmpl $0x2, 0x1a0(%r15)
jl 0x225c6
callq 0x208d7
jmp 0x225c6