LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movb (%rcx,%rax), %r8b
testb %r8b, %r8b
je 0x1edd1
leaq 0x1(%rax), %r9
movb %r8b, (%rax)
movb 0x1(%rax,%rcx), %r8b
movq %r9, %rax
testb %r8b, %r8b
jne 0x1edbb
jmp 0x1edd4
movq %rax, %r9
movb $0x0, (%r9)
movb $0x1, 0x24(%rdi)
movl 0x28(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl %esi, %ecx
jge 0x1edec
cmpl %esi, %eax
jge 0x1edf0
jmp 0x1edf5
subl %edx, %eax
movl %eax, %esi
movl %esi, 0x28(%rdi)
movl %esi, %eax
movl %eax, 0x30(%rdi)
movl %eax, 0x2c(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x18(%rdi), %r12
movq %r12, %rdi
callq 0x72e0
movq %rax, %r13
testq %r14, %r14
jne 0x1ee3d
movq %r15, %rdi
callq 0x72e0
movq %rax, %r14
addq %r15, %r14
subq %r15, %r14
leal (%r14,%r13), %eax
incl %eax
cmpl 0x20(%rbx), %eax
jge 0x1eebe
leal (%r14,%r13), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movslq %ecx, %rax
subl %ecx, %r13d
jne 0x1ee62
movslq %r14d, %rdx
jmp 0x1ee89
addq %rax, %r12
movslq %r14d, %rcx
movq %rcx, -0x30(%rbp)
leaq (%r12,%rcx), %rdi
movslq %r13d, %rdx
movq %r12, %rsi
movq %rax, %r12
callq 0x7130
movq -0x30(%rbp), %rdx
movq %r12, %rax
movq 0x18(%rbx), %r12
addq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %r15
callq 0x7080
movq 0x18(%rbx), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x1, 0x24(%rbx)
movl 0x28(%rbx), %eax
cmpl %r15d, %eax
jl 0x1eeb8
addl %r14d, %eax
movl %eax, 0x28(%rbx)
movl %eax, 0x30(%rbx)
movl %eax, 0x2c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/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
movl 0x3c(%rdi), %eax
movl 0x4(%rsi), %ecx
movl 0x8(%rsi), %edx
cmpl %edx, %ecx
je 0x1f073
cmpl %eax, %ecx
jle 0x1f064
movl %eax, 0x4(%rbx)
movl %eax, %ecx
cmpl %eax, %edx
jle 0x1f06d
movl %eax, 0x8(%rbx)
movl %eax, %edx
cmpl %edx, %ecx
jne 0x1f073
movl %ecx, (%rbx)
cmpl %eax, (%rbx)
jle 0x1f079
movl %eax, (%rbx)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x235ee
movl (%rbx), %esi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x23518
testb %al, %al
je 0x1f0b1
movl (%rbx), %esi
leaq 0x18(%rbx), %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x23994
addl %r14d, (%rbx)
movb $0x0, 0xf(%rbx)
jmp 0x1f0c6
movzwl 0xc8a(%rbx), %eax
testw %ax, %ax
je 0x1f0c6
decl %eax
movw %ax, 0xc8a(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 0x363a6(%rip), %r8      # 0x55480
movq 0x1710(%r8), %rax
movss 0x1718(%r8), %xmm0
movaps %xmm0, %xmm3
divss (%rax), %xmm3
leaq 0x50(%rax), %r8
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpq %rsi, %rdi
jae 0x1f163
movzwl (%rdi), %r9d
addq $0x2, %rdi
cmpl $0xd, %r9d
je 0x1f0fb
cmpl $0xa, %r9d
je 0x1f137
leal (,%r9,4), %r10d
addq 0x60(%rax), %r10
cmpl %r9d, 0x58(%rax)
cmovleq %r8, %r10
movss (%r10), %xmm4
mulss %xmm3, %xmm4
addss %xmm4, %xmm2
jmp 0x1f0fb
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]
movaps %xmm1, %xmm2
addss %xmm0, %xmm2
movaps %xmm4, %xmm1
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
testb %cl, %cl
je 0x1f0f8
xorps %xmm2, %xmm2
testq %rdx, %rdx
je 0x1f16b
movq %rdi, (%rdx)
ucomiss %xmm1, %xmm2
jbe 0x1f174
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 0x1f199
movaps %xmm1, %xmm0
jmp 0x1f1a4
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_O3/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 $0x38, %rsp
movl %ecx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movss %xmm0, -0x28(%rbp)
movss %xmm1, -0x24(%rbp)
testl %edx, %edx
js 0x1f5f8
movl %edx, %ecx
leaq 0x1f0a9(%rip), %rdx     # 0x3e67b
leaq -0x40(%rbp), %rdi
movl $0x10, %esi
xorl %eax, %eax
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
callq 0x8678
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
jmp 0x1f602
movb $0x0, -0x3e(%rbp)
movw $0x6625, -0x40(%rbp)    # imm = 0x6625
xorl %eax, %eax
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
leaq -0x28(%rbp), %rcx
cmovbeq %rax, %rcx
ucomiss %xmm2, %xmm1
leaq -0x24(%rbp), %r8
cmovbeq %rax, %r8
movl %r14d, (%rsp)
leaq -0x40(%rbp), %r9
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x1f1de
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x35dca(%rip), %r15     # 0x55480
movq 0x1758(%r15), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1f6cf
xorl %r14d, %r14d
jmp 0x1f7f3
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
movq %rax, -0x38(%rbp)
callq 0x1b560
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x16f0c
movl %ebx, %edi
callq 0x1b714
testl %ebx, %ebx
jle 0x1f79f
movl %ebx, %r12d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x17e36
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
leaq 0x1ec13(%rip), %rdi     # 0x3e32a
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x1f5a5
movss 0x141c(%r15), %xmm0
movq 0x35d4b(%rip), %rdx     # 0x55480
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1f780
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1f756
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 0x16b19
callq 0x9db1
incq %rbx
addq $0x4, %r13
cmpq %rbx, %r12
jne 0x1f703
jmp 0x1f7a2
xorl %r14d, %r14d
callq 0x16b19
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 0xdfc4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd741
callq 0x1b97c
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_O3/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 0x35c20(%rip), %rax     # 0x55480
movq %rax, -0x38(%rbp)
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x1f87d
xorl %r14d, %r14d
jmp 0x1f9c1
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq %rax, -0x40(%rbp)
callq 0x1b560
movq %r14, -0x48(%rbp)
movq %r14, %rdi
callq 0x16f0c
movl %ebx, %edi
callq 0x1b714
testl %ebx, %ebx
jle 0x1f96a
testb $0x2, -0x2c(%rbp)
leaq 0x1f003(%rip), %rax     # 0x3e8b7
leaq 0x1f02e(%rip), %r13     # 0x3e8e9
cmoveq %rax, %r13
movl %ebx, %r15d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x17e36
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
leaq 0x1ea4f(%rip), %rdi     # 0x3e32a
xorl %esi, %esi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0x1f1de
movq -0x38(%rbp), %rcx
movss 0x141c(%rcx), %xmm0
movq 0x35b80(%rip), %rdx     # 0x55480
movq 0x1758(%rdx), %rcx
movb $0x1, 0x72(%rcx)
cmpb $0x0, 0x74(%rcx)
jne 0x1f94b
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1f921
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 0x16b19
callq 0x9db1
incq %rbx
addq $0x4, %r12
cmpq %rbx, %r15
jne 0x1f8c7
jmp 0x1f96d
xorl %r14d, %r14d
callq 0x16b19
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 0xdfc4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd741
callq 0x1b97c
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_O3/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 0x34e8f(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
movl 0x19c(%r14), %ebx
movss 0x18(%r14), %xmm0
movss %xmm0, -0x14(%rbp)
movl %ebx, %edi
callq 0x15481
addss -0x14(%rbp), %xmm0
addss 0x1cd79(%rip), %xmm0    # 0x3d39c
movss %xmm0, -0x14(%rbp)
movss 0x18(%r14), %xmm0
movss %xmm0, -0x18(%rbp)
incl %ebx
movl %ebx, %edi
callq 0x15481
addss -0x18(%rbp), %xmm0
addss 0x1cd53(%rip), %xmm0    # 0x3d39c
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 0x1372e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20887
addss 0x1cb55(%rip), %xmm0    # 0x3d3dc
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x34be0(%rip), %rax     # 0x55480
movss 0x1418(%rax), %xmm1
movss 0x1718(%rax), %xmm2
addss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movss %xmm2, 0x4(%rsi)
callq 0x2069b
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa936
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 0x34b68(%rip), %r14     # 0x55480
callq 0x13129
movl $0x1, %edi
callq 0x12c6e
movl $0x1, %edi
callq 0x13561
movq 0x34b48(%rip), %rcx     # 0x55480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x2097b
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 0xa99d
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1b97c
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12d
movq %rcx, -0x48(%rbp)
movq %rdx, %r14
movq %rsi, %r15
cmpl $0x7, %r8d
movl $0x7, %eax
cmovll %r8d, %eax
testl %r9d, %r9d
cmovnsl %r9d, %eax
cvtsi2ss %eax, %xmm0
cmpl %r8d, %eax
jge 0x20a27
addss 0x1c9b5(%rip), %xmm0    # 0x3d3dc
leaq -0x40(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x34a48(%rip), %rax     # 0x55480
movss 0x1418(%rax), %xmm1
movss 0x1718(%rax), %xmm2
addss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movss %xmm2, 0x4(%rsi)
callq 0x2069b
testb %al, %al
je 0x20b02
movq 0x34a13(%rip), %rax     # 0x55480
movss 0x1718(%rax), %xmm0
addss 0x1418(%rax), %xmm0
leaq -0x40(%rbp), %rbx
movl $0xffffffff, 0x4(%rbx)  # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %r12d, %esi
callq 0x24ad2
movl 0x8(%rbx), %r13d
cmpl 0xc(%rbx), %r13d
jge 0x20b07
xorl %r12d, %r12d
movl (%r15), %ebx
movq -0x48(%rbp), %rdi
movl %r13d, %esi
leaq -0x30(%rbp), %rdx
callq *%r14
testb %al, %al
jne 0x20ac0
leaq 0x1dbc5(%rip), %rax     # 0x3e681
movq %rax, -0x30(%rbp)
movl %r13d, %edi
callq 0x17e36
xorl %esi, %esi
cmpl %ebx, %r13d
sete %sil
movq -0x30(%rbp), %rdi
movq $0x0, -0x50(%rbp)
xorl %edx, %edx
leaq -0x50(%rbp), %rcx
callq 0x201b9
testb %al, %al
je 0x20af2
movl %r13d, (%r15)
movb $0x1, %r12b
callq 0x16b19
incl %r13d
cmpl -0x34(%rbp), %r13d
jl 0x20aa0
jmp 0x20b0a
xorl %r12d, %r12d
jmp 0x20b1e
xorl %r12d, %r12d
leaq -0x40(%rbp), %rdi
callq 0x24712
callq 0x208cc
cmpl $-0x1, -0x3c(%rbp)
jne 0x20b46
andb $0x1, %r12b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20b38
jmp 0x20b38
cmpl $-0x1, -0x3c(%rbp)
jne 0x20b46
movq %rax, %rdi
callq 0x74c0
leaq 0x1e33e(%rip), %rdi     # 0x3ee8b
leaq 0x1df6f(%rip), %rsi     # 0x3eac3
leaq 0x1e397(%rip), %rcx     # 0x3eef2
movl $0x3e2, %edx            # imm = 0x3E2
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34678(%rip), %r14     # 0x55480
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 0x133f5
leaq -0x20(%rbp), %rbx
movq %r15, (%rbx)
movl $0x3, %edi
movq %rbx, %rsi
callq 0x14ee8
movq %r15, (%rbx)
leaq 0x1d818(%rip), %rdi     # 0x3e690
leaq -0x20(%rbp), %rdx
movss 0x1c518(%rip), %xmm0    # 0x3d39c
xorl %esi, %esi
movl $0x50f, %ecx            # imm = 0x50F
callq 0xf554
testb %al, %al
je 0x20ec1
callq 0x20edd
testb %al, %al
je 0x20ec1
movss 0x1450(%r14), %xmm0
movq 0x1758(%r14), %rax
addss 0xf8(%rax), %xmm0
movss %xmm0, 0xf8(%rax)
movb $0x1, %al
jmp 0x20ed2
callq 0xcc43
movl $0x2, %edi
callq 0x12c6e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x34593(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x20f04
testb $0x4, 0xd(%rbx)
jne 0x20f0b
xorl %eax, %eax
jmp 0x20fbe
cmpb $0x1, 0xf6(%rbx)
je 0x20fc5
callq 0x1b560
leaq 0x1d7b2(%rip), %rdi     # 0x3e6d6
callq 0x16f0c
movq %rbx, %rdi
callq 0x245d0
movaps %xmm0, -0x30(%rbp)
movss 0x1c48f(%rip), %xmm4    # 0x3d3cc
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 0x1c489(%rip), %xmm3    # 0x3d3e0
addss %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
addss 0x1c4e1(%rip), %xmm1    # 0x3d448
leaq -0x40(%rbp), %rdi
movss %xmm2, (%rdi)
movss %xmm3, 0x4(%rdi)
movss %xmm4, 0x8(%rdi)
movss %xmm1, 0xc(%rdi)
xorl %esi, %esi
callq 0x1372e
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 0x15ec9
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1d6d2(%rip), %rdi     # 0x3e69e
leaq 0x1c6e2(%rip), %rsi     # 0x3d6b5
leaq 0x1d6e1(%rip), %rcx     # 0x3e6bb
movl $0x1fc4, %edx           # imm = 0x1FC4
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34471(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x21098
testb $0x4, 0xd(%rbx)
je 0x210a1
cmpb $0x0, 0xf6(%rbx)
je 0x210c0
callq 0x14778
callq 0x16b19
movss 0xa8(%rbx), %xmm0
movss %xmm0, -0x14(%rbp)
movq %rbx, %rdi
callq 0x245d0
movss -0x14(%rbp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xf8(%rbx)
movslq 0x168(%rbx), %rax
testq %rax, %rax
jle 0x210df
movq 0x170(%rbx), %rcx
leaq (%rax,%rax,8), %rax
xorl %r14d, %r14d
movb %r14b, -0x4(%rcx,%rax,4)
callq 0x1b97c
movl $0x0, 0x118(%rbx)
movb %r14b, 0xf6(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d638(%rip), %rdi     # 0x3e6e0
leaq 0x1c606(%rip), %rsi     # 0x3d6b5
leaq 0x1d653(%rip), %rcx     # 0x3e709
movl $0x1fd6, %edx           # imm = 0x1FD6
callq 0x7140
leaq 0x1d5d8(%rip), %rdi     # 0x3e69f
leaq 0x1c5e7(%rip), %rsi     # 0x3d6b5
leaq 0x1d634(%rip), %rcx     # 0x3e709
movl $0x1fd7, %edx           # imm = 0x1FD7
callq 0x7140
leaq 0x25a4f(%rip), %rdi     # 0x46b35
leaq 0x1d9d6(%rip), %rsi     # 0x3eac3
leaq 0x1e510(%rip), %rcx     # 0x3f604
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x33190(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r15
movb $0x1, 0x72(%r15)
cmpb $0x0, 0x74(%r15)
je 0x2230e
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, 0x1a0(%r15)
jl 0x2231d
callq 0x14778
movss 0x18(%r15), %xmm1
movss 0x20(%r15), %xmm0
addss %xmm1, %xmm0
cmpl $0x0, 0x168(%r15)
je 0x22340
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 0xa99d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xaaef
testb %al, %al
je 0x22417
leaq -0x20(%rbp), %rbx
movq 0x270(%r15), %r14
movq 0x330ef(%rip), %rax     # 0x55480
movups 0x14a0(%rax), %xmm0
leaq -0x40(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x8c82
leaq -0x28(%rbp), %rsi
movss 0x1afce(%rip), %xmm0    # 0x3d390
movq %r14, %rdi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x2f6ea
movq 0x330aa(%rip), %rax     # 0x55480
cmpb $0x1, 0x2be8(%rax)
jne 0x223ed
leaq 0x1c3e7(%rip), %rdi     # 0x3e7cd
xorl %eax, %eax
callq 0xde0d
cmpl $0x2, 0x1a0(%r15)
jl 0x22303
callq 0x205df
movss 0xac(%r15), %xmm0
movss %xmm0, 0x1ac(%r15)
jmp 0x22303
cmpl $0x2, 0x1a0(%r15)
jl 0x22303
callq 0x205df
jmp 0x22303
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::NextColumn()
void ImGui::NextColumn()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    if (window->DC.ColumnsCount > 1)
    {
        ImGui::PopItemWidth();
        PopClipRect();

        window->DC.ColumnsCellMaxY = ImMax(window->DC.ColumnsCellMaxY, window->DC.CursorPos.y);
        if (++window->DC.ColumnsCurrent < window->DC.ColumnsCount)
        {
            window->DC.ColumnsOffsetX = ImGui::GetColumnOffset(window->DC.ColumnsCurrent) - window->DC.ColumnsStartX + g.Style.ItemSpacing.x;
            window->DrawList->ChannelsSetCurrent(window->DC.ColumnsCurrent);
        }
        else
        {
            window->DC.ColumnsCurrent = 0;
            window->DC.ColumnsOffsetX = 0.0f;
            window->DC.ColumnsCellMinY = window->DC.ColumnsCellMaxY;
            window->DrawList->ChannelsSetCurrent(0);
        }
        window->DC.CursorPos.x = (float)(int)(window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX);
        window->DC.CursorPos.y = window->DC.ColumnsCellMinY;
        window->DC.CurrentLineHeight = 0.0f;
        window->DC.CurrentLineTextBaseOffset = 0.0f;

        PushColumnClipRect();
        ImGui::PushItemWidth(ImGui::GetColumnWidth() * 0.65f);  // FIXME
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x32fe1(%rip), %r14     # 0x55480
movq 0x1758(%r14), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x2252f
cmpl $0x2, 0x1a0(%rbx)
jl 0x2252f
callq 0x9db1
callq 0x14778
movss 0x1b0(%rbx), %xmm1
movss 0xac(%rbx), %xmm2
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
movss %xmm0, 0x1b0(%rbx)
movl 0x19c(%rbx), %edi
incl %edi
movl %edi, 0x19c(%rbx)
cmpl 0x1a0(%rbx), %edi
jge 0x22538
callq 0x15481
subss 0x194(%rbx), %xmm0
addss 0x1414(%r14), %xmm0
movss %xmm0, 0x198(%rbx)
movq 0x270(%rbx), %rdi
movl 0x19c(%rbx), %esi
jmp 0x22554
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq $0x0, 0x198(%rbx)
movss %xmm0, 0x1ac(%rbx)
movq 0x270(%rbx), %rdi
xorl %esi, %esi
callq 0x2d908
movss 0x18(%rbx), %xmm0
addss 0x194(%rbx), %xmm0
movss 0x1ac(%rbx), %xmm1
addss 0x198(%rbx), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xa8(%rbx)
movss %xmm1, 0xac(%rbx)
movq $0x0, 0xc8(%rbx)
callq 0x205df
movq 0x32edc(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movl 0x19c(%rax), %ebx
leal 0x1(%rbx), %edi
callq 0x15481
movss %xmm0, -0x14(%rbp)
movl %ebx, %edi
callq 0x15481
movss -0x14(%rbp), %xmm1
subss %xmm0, %xmm1
mulss 0x1ae32(%rip), %xmm1    # 0x3d408
movaps %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9c64
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetColumnWidth(int)
float ImGui::GetColumnWidth(int column_index)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    const float w = GetColumnOffset(column_index+1) - GetColumnOffset(column_index);
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jns 0x22606
movq 0x32e87(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movl 0x19c(%rax), %ebx
leal 0x1(%rbx), %edi
callq 0x15481
movss %xmm0, -0xc(%rbp)
movl %ebx, %edi
callq 0x15481
movss -0xc(%rbp), %xmm1
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetDraggedColumnOffset(int)
static float GetDraggedColumnOffset(int column_index)
{
    // Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
    // window creates a feedback loop because we store normalized positions/ So while dragging we enforce absolute positioning
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = ImGui::GetCurrentWindowRead();
    IM_ASSERT(column_index > 0); // We cannot drag column 0. If you get this assert you may have a conflict between the ID of your columns and another widgets.
    IM_ASSERT(g.ActiveId == window->DC.ColumnsSetID + ImGuiID(column_index));

    float x = g.IO.MousePos.x + g.ActiveClickDeltaToCenter.x - window->Pos.x;
    x = ImClamp(x, ImGui::GetColumnOffset(column_index-1)+g.Style.ColumnsMinSpacing, ImGui::GetColumnOffset(column_index+1)-g.Style.ColumnsMinSpacing);

    return (float)(int)x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testl %edi, %edi
jle 0x22708
movl %edi, %ebx
movq 0x32e03(%rip), %r14     # 0x55480
movq 0x1758(%r14), %rax
movl 0x1b8(%rax), %ecx
addl %edi, %ecx
cmpl %ecx, 0x1790(%r14)
jne 0x22727
movss 0xf0(%r14), %xmm0
addss 0x27b8(%r14), %xmm0
subss 0x18(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
leal -0x1(%rbx), %edi
callq 0x15481
addss 0x1434(%r14), %xmm0
movaps %xmm0, -0x20(%rbp)
incl %ebx
movl %ebx, %edi
callq 0x15481
subss 0x1434(%r14), %xmm0
movaps -0x30(%rbp), %xmm2
minss %xmm2, %xmm0
movaps -0x20(%rbp), %xmm3
cmpltss %xmm3, %xmm2
movaps %xmm2, %xmm1
andnps %xmm0, %xmm1
andps %xmm3, %xmm2
orps %xmm1, %xmm2
cvttps2dq %xmm2, %xmm0
cvtdq2ps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c809(%rip), %rdi     # 0x3ef18
leaq 0x1af9f(%rip), %rsi     # 0x3d6b5
leaq 0x1c80c(%rip), %rcx     # 0x3ef29
movl $0x21c8, %edx           # imm = 0x21C8
callq 0x7140
leaq 0x1c81d(%rip), %rdi     # 0x3ef4b
leaq 0x1af80(%rip), %rsi     # 0x3d6b5
leaq 0x1c7ed(%rip), %rcx     # 0x3ef29
movl $0x21c9, %edx           # imm = 0x21C9
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetColumnOffset(int, float)
void ImGui::SetColumnOffset(int column_index, float offset)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    if (column_index < 0)
        column_index = window->DC.ColumnsCurrent;

    IM_ASSERT(column_index < window->DC.ColumnsOffsetsT.Size);
    const ImGuiID column_id = window->DC.ColumnsSetID + ImGuiID(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 t = (offset - min_x) / (max_x - min_x);
    window->DC.StateStorage->SetFloat(column_id, t);
    window->DC.ColumnsOffsetsT[column_index] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0x32d26(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
testl %edi, %edi
jns 0x22771
movl 0x19c(%r14), %ebx
cmpl 0x1c0(%r14), %ebx
jge 0x22806
movss 0x38(%r14), %xmm4
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm4
jne 0x22794
jp 0x22794
movss 0x20(%r14), %xmm4
movl 0x1b8(%r14), %esi
movss 0x4c(%r14), %xmm3
movss 0x194(%r14), %xmm2
testb $0x8, 0xc(%r14)
jne 0x227b9
movss 0x1438(%rax), %xmm1
subss %xmm3, %xmm4
subss %xmm1, %xmm4
addl %ebx, %esi
subss %xmm2, %xmm0
subss %xmm2, %xmm4
divss %xmm4, %xmm0
movss %xmm0, -0x14(%rbp)
movq 0x110(%r14), %rdi
callq 0x972c
cmpl %ebx, 0x1c0(%r14)
jle 0x22825
movq 0x1c8(%r14), %rax
movslq %ebx, %rcx
movss -0x14(%rbp), %xmm0
movss %xmm0, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1c018(%rip), %rdi     # 0x3e825
leaq 0x1aea1(%rip), %rsi     # 0x3d6b5
leaq 0x1c05b(%rip), %rcx     # 0x3e876
movl $0x21f1, %edx           # imm = 0x21F1
callq 0x7140
leaq 0x1c5b4(%rip), %rdi     # 0x3ede0
leaq 0x1c290(%rip), %rsi     # 0x3eac3
leaq 0x1ce4b(%rip), %rcx     # 0x3f685
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Indent()
void ImGui::Indent()
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.ColumnsStartX += g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x32c31(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x1430(%rax), %xmm0
addss 0x194(%rcx), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Unindent()
void ImGui::Unindent()
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.ColumnsStartX -= g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.ColumnsStartX + window->DC.ColumnsOffsetX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x32bec(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x194(%rcx), %xmm0
subss 0x1430(%rax), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TreePop()
void ImGui::TreePop()
{
    ImGuiWindow* window = GetCurrentWindow();
    ImGui::Unindent();
    window->DC.TreeDepth--;
    PopID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x32ba7(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rcx
movb $0x1, 0x72(%rcx)
movss 0x194(%rcx), %xmm0
subss 0x1430(%rax), %xmm0
movss %xmm0, 0x194(%rcx)
addss 0x18(%rcx), %xmm0
addss 0x198(%rcx), %xmm0
movss %xmm0, 0xa8(%rcx)
decl 0xdc(%rcx)
popq %rbp
jmp 0x16b19
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Color(char const*, unsigned int)
void ImGui::Color(const char* prefix, unsigned int v)
{
    ImGui::Text("%s: %08X", prefix, v);
    ImGui::SameLine();

    ImVec4 col;
    col.x = (float)((v >> 0) & 0xFF) / 255.0f;
    col.y = (float)((v >> 8) & 0xFF) / 255.0f;
    col.z = (float)((v >> 16) & 0xFF) / 255.0f;
    col.w = (float)((v >> 24) & 0xFF) / 255.0f;
    ImGui::ColorButton(col, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x1be57(%rip), %rdi     # 0x3e8e5
movl %ebx, %edx
xorl %eax, %eax
callq 0x15c0a
movq 0x329e2(%rip), %rcx     # 0x55480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
jne 0x22ae1
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)
movl $0xff, %eax
movl %ebx, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss 0x1a89f(%rip), %xmm1    # 0x3d398
divss %xmm1, %xmm0
leaq -0x18(%rbp), %rdi
movss %xmm0, (%rdi)
movl %ebx, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rdi)
movl %ebx, %ecx
shrl $0x10, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
shrl $0x18, %ebx
cvtsi2ss %ebx, %xmm2
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rdi)
divss %xmm1, %xmm2
movss %xmm2, 0xc(%rdi)
movl $0x1, %esi
movl $0x1, %edx
callq 0x21844
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ShowMetricsWindow(bool*)::Funcs::NodeWindows(ImVector<ImGuiWindow*>&, char const*)
static void NodeWindows(ImVector<ImGuiWindow*>& windows, const char* label)
            {
                if (!ImGui::TreeNode(label, "%s (%d)", label, windows.Size))
                    return;
                for (int i = 0; i < windows.Size; i++)
                    Funcs::NodeWindow(windows[i], "Window");
                ImGui::TreePop();
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
leaq 0x1c132(%rip), %rsi     # 0x3ef89
movq %rdx, %rdi
xorl %eax, %eax
callq 0x17b31
testb %al, %al
je 0x22e9e
cmpl $0x0, (%rbx)
jle 0x22e8f
xorl %r15d, %r15d
leaq 0x1bb91(%rip), %r14     # 0x3ea05
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x23d90
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x22e74
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x228ce
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindWindowSettings(char const*)
static ImGuiIniData* FindWindowSettings(const char* name)
{
    ImGuiState& g = *GImGui;
    ImGuiID id = ImHash(name, 0);
    for (int i = 0; i != g.Settings.Size; i++)
    {
        ImGuiIniData* ini = &g.Settings[i];
        if (ini->ID == id)
            return ini;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x3221d(%rip), %r14     # 0x55480
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x8734
movl 0x17b0(%r14), %ecx
testq %rcx, %rcx
je 0x232b1
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
shlq $0x5, %rdx
shlq $0x5, %rcx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x232b9
movq 0x17b8(%r14), %rdi
cmpl %eax, 0x8(%rdi,%rsi)
je 0x232ab
addq $0x20, %rsi
cmpq %rsi, %rcx
jne 0x2328e
jmp 0x232b1
addq %rsi, %rdi
movq %rdi, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bb20(%rip), %rdi     # 0x3ede0
leaq 0x1b7fc(%rip), %rsi     # 0x3eac3
leaq 0x1bffa(%rip), %rcx     # 0x3f2c8
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowSettings(char const*)
static ImGuiIniData* AddWindowSettings(const char* name)
{
    GImGui->Settings.resize(GImGui->Settings.Size + 1);
    ImGuiIniData* ini = &GImGui->Settings.back();
    ini->Name = ImStrdup(name);
    ini->ID = ImHash(name, 0);
    ini->Collapsed = false;
    ini->Pos = ImVec2(FLT_MAX,FLT_MAX);
    ini->Size = ImVec2(0,0);
    return ini;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x32190(%rip), %r15     # 0x55480
movl 0x17b0(%r15), %edx
movl 0x17b4(%r15), %eax
leal 0x1(%rdx), %r12d
movq %r15, %rcx
cmpl %edx, %eax
jg 0x23396
testl %eax, %eax
je 0x23323
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x23329
movl $0x8, %r13d
cmpl %r12d, %r13d
cmovlel %r12d, %r13d
movslq %r13d, %rdi
shlq $0x5, %rdi
incl 0x334(%r15)
callq *0xd0(%r15)
movq %rax, %r14
movq 0x17b8(%r15), %rsi
movslq 0x17b0(%r15), %rdx
shlq $0x5, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x17b8(%r15), %rdi
movq 0x32110(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x2337b
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r14, 0x17b8(%r15)
movl %r13d, 0x17b4(%r15)
movq 0x320ea(%rip), %rcx     # 0x55480
movl %r12d, 0x17b0(%r15)
movslq 0x17b0(%rcx), %rax
testq %rax, %rax
jle 0x233fb
movq 0x17b8(%rcx), %rcx
shlq $0x5, %rax
leaq (%rcx,%rax), %r14
addq $-0x20, %r14
movq %rbx, %rdi
callq 0x852f
movq %rax, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8734
movl %eax, 0x8(%r14)
movb $0x0, 0x1c(%r14)
movsd 0x19f9c(%rip), %xmm0    # 0x3d380
movups %xmm0, 0xc(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23733(%rip), %rdi     # 0x46b35
leaq 0x1b6ba(%rip), %rsi     # 0x3eac3
leaq 0x1b6c3(%rip), %rcx     # 0x3ead3
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ChildWindowComparer(void const*, void const*)
static int ChildWindowComparer(const void* lhs, const void* rhs)
{
    const ImGuiWindow* a = *(const ImGuiWindow**)lhs;
    const ImGuiWindow* b = *(const ImGuiWindow**)rhs;
    if (int d = (a->Flags & ImGuiWindowFlags_Popup) - (b->Flags & ImGuiWindowFlags_Popup))
        return d;
    if (int d = (a->Flags & ImGuiWindowFlags_Tooltip) - (b->Flags & ImGuiWindowFlags_Tooltip))
        return d;
    if (int d = (a->Flags & ImGuiWindowFlags_ComboBox) - (b->Flags & ImGuiWindowFlags_ComboBox))
        return d;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq (%rsi), %rdx
movl 0xc(%rax), %ecx
movl $0x2000000, %esi        # imm = 0x2000000
movl %ecx, %eax
andl %esi, %eax
movl 0xc(%rdx), %edx
andl %edx, %esi
subl %esi, %eax
jne 0x23455
movl $0x1000000, %esi        # imm = 0x1000000
movl %ecx, %eax
andl %esi, %eax
andl %edx, %esi
subl %esi, %eax
jne 0x23455
movl $0x800000, %eax         # imm = 0x800000
andl %eax, %ecx
andl %eax, %edx
subl %edx, %ecx
movl %ecx, %eax
popq %rbp
retq