LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %r9, -0x48(%rbp)
movl %r8d, -0x34(%rbp)
movl %ecx, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
movq 0x3877c(%rip), %r13     # 0x50480
movq 0x1758(%r13), %rax
movb $0x1, 0x72(%rax)
xorl %ebx, %ebx
cmpb $0x0, 0x74(%rax)
jne 0x17dbb
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x16ed0
movq %r12, -0x40(%rbp)
movq %r12, %rdi
callq 0x13116
movl %r14d, %edi
callq 0x16fb2
testl %r14d, %r14d
cmovlel %ebx, %r14d
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x17d98
movl %r12d, %edi
callq 0x13d85
leaq 0x1f587(%rip), %rdi     # 0x372e2
movq %r15, %rsi
movss -0x2c(%rbp), %xmm0
movl -0x30(%rbp), %edx
movl -0x34(%rbp), %ecx
movq -0x48(%rbp), %r8
callq 0x17c88
orb %al, %bl
movss 0x141c(%r13), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
callq 0x12ea2
callq 0x9272
incq %r12
addq $0x4, %r15
jmp 0x17d47
callq 0x12ea2
movq -0x40(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::DragIntRange2(char const*, int*, int*, float, int, int, char const*, char const*)
bool ImGui::DragIntRange2(const char* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, const char* display_format, const char* display_format_max)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

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

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

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

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x38654(%rip), %r15     # 0x50480
movq 0x1758(%r15), %rax
movb $0x1, 0x72(%rax)
cmpb $0x0, 0x74(%rax)
je 0x17e44
xorl %ebx, %ebx
jmp 0x17f38
movl %r8d, %r13d
movl %ecx, %ebx
movq %rdi, -0x48(%rbp)
movss %xmm0, -0x30(%rbp)
movq %rdx, %r14
movq %rdx, -0x40(%rbp)
movq %r9, -0x38(%rbp)
movq %rsi, %r12
callq 0x13116
callq 0x16ed0
pushq $0x2
popq %rdi
callq 0x16fb2
movl (%r14), %eax
cmpl %eax, %r13d
movl %eax, %ecx
cmovll %r13d, %ecx
cmpl %r13d, %ebx
movl $0x80000000, %edx       # imm = 0x80000000
cmovll %ebx, %edx
cmovgel %eax, %ecx
leaq 0x1f453(%rip), %rdi     # 0x372e6
movq %r12, %rsi
movss -0x30(%rbp), %xmm0
movq -0x38(%rbp), %r14
movq %r14, %r8
callq 0x17c88
movb %al, -0x29(%rbp)
callq 0x9272
movss 0x141c(%r15), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
movl (%r12), %eax
cmpl %eax, %ebx
movl %eax, %edx
cmovgl %ebx, %edx
cmpl %r13d, %ebx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmovll %r13d, %ecx
cmovgel %eax, %edx
movq 0x10(%rbp), %r8
testq %r8, %r8
cmoveq %r14, %r8
leaq 0x1f400(%rip), %rdi     # 0x372ec
movq -0x40(%rbp), %rsi
movss -0x30(%rbp), %xmm0
callq 0x17c88
movl %eax, %ebx
orb -0x29(%rbp), %bl
callq 0x9272
movss 0x141c(%r15), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
movq -0x48(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
callq 0x12ea2
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x18846
cmpb $0x1, (%r15)
jne 0x18c49
orl (%r14), %ebx
jmp 0x18c4e
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_O2/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 0x18c5c
testb %al, %al
je 0x190ad
movl %ebx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 (%rax,%rcx), %r8b
testb %r8b, %r8b
je 0x19ac3
movb %r8b, (%rax)
incq %rax
jmp 0x19ab2
movb $0x0, (%rax)
movb $0x1, 0x24(%rdi)
movl 0x28(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl %esi, %ecx
jge 0x19ada
cmpl %esi, %eax
jge 0x19ade
jmp 0x19ae3
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_O2/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 0x7300
movq %rax, %r13
testq %r14, %r14
jne 0x19b2b
movq %r15, %rdi
callq 0x7300
movq %rax, %r14
addq %r15, %r14
subq %r15, %r14
leal (%r14,%r13), %eax
incl %eax
cmpl 0x20(%rbx), %eax
jge 0x19bac
leal (%r14,%r13), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movslq %ecx, %rax
subl %ecx, %r13d
jne 0x19b50
movslq %r14d, %rdx
jmp 0x19b77
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 0x19ba6
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_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: DataTypeApplyOp(ImGuiDataType, int, void*, void const*)
static void DataTypeApplyOp(ImGuiDataType data_type, int op, void* value1, const void* value2)// Store into value1
{
    if (data_type == ImGuiDataType_Int)
    {
        if (op == '+')
            *(int*)value1 = *(int*)value1 + *(const int*)value2;
        else if (op == '-')
            *(int*)value1 = *(int*)value1 - *(const int*)value2;
    }
    else if (data_type == ImGuiDataType_Float)
    {
        if (op == '+')
            *(float*)value1 = *(float*)value1 + *(const float*)value2;
        else if (op == '-')
            *(float*)value1 = *(float*)value1 - *(const float*)value2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, %edi
je 0x1a12d
testl %edi, %edi
jne 0x1a153
cmpl $0x2d, %esi
je 0x1a141
cmpl $0x2b, %esi
jne 0x1a153
movl (%rcx), %eax
addl %eax, (%rdx)
jmp 0x1a153
cmpl $0x2d, %esi
je 0x1a147
cmpl $0x2b, %esi
jne 0x1a153
movss (%rdx), %xmm0
addss (%rcx), %xmm0
jmp 0x1a14f
movl (%rcx), %eax
subl %eax, (%rdx)
jmp 0x1a153
movss (%rdx), %xmm0
subss (%rcx), %xmm0
movss %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a1a6
movl %edx, %ecx
leaq 0x1d4b1(%rip), %rdx     # 0x37633
leaq -0x40(%rbp), %rdi
pushq $0x10
popq %rsi
xorl %eax, %eax
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
callq 0x83b1
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
jmp 0x1a1b0
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)
pushq $0x1
popq %rsi
leaq -0x40(%rbp), %r9
movq %r15, %rdi
movq %rbx, %rdx
callq 0x19e6a
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 0x3621e(%rip), %r12     # 0x50480
movq 0x1758(%r12), %rax
movb $0x1, 0x72(%rax)
xorl %ebx, %ebx
cmpb $0x0, 0x74(%rax)
jne 0x1a34b
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r15
movq %rax, -0x38(%rbp)
callq 0x16ed0
movq %r15, -0x40(%rbp)
movq %r15, %rdi
callq 0x13116
movl %r13d, %edi
callq 0x16fb2
testl %r13d, %r13d
cmovlel %ebx, %r13d
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x1a2f9
movl %r15d, %edi
callq 0x13d85
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
leaq 0x1d01e(%rip), %rdi     # 0x372e2
movq %r14, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x1a155
orb %al, %bl
movss 0x141c(%r12), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
callq 0x12ea2
callq 0x9272
incq %r15
addq $0x4, %r14
jmp 0x1a2aa
callq 0x12ea2
movq -0x38(%rbp), %rax
movss 0xcc(%rax), %xmm0
movss 0x140c(%r12), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0xcc(%rax)
movq -0x40(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::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 $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq 0x360ca(%rip), %r15     # 0x50480
movq 0x1758(%r15), %rax
movb $0x1, 0x72(%rax)
xorl %ebx, %ebx
cmpb $0x0, 0x74(%rax)
jne 0x1a498
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movq %rax, -0x38(%rbp)
callq 0x16ed0
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x13116
movl %r12d, %edi
callq 0x16fb2
testl %r12d, %r12d
cmovlel %ebx, %r12d
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x1a447
movl %r14d, %edi
callq 0x13d85
leaq 0x1ced1(%rip), %rdi     # 0x372e2
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movl -0x2c(%rbp), %r8d
callq 0x1a1ec
orb %al, %bl
movss 0x141c(%r15), %xmm1
xorps %xmm0, %xmm0
callq 0x1254d
callq 0x12ea2
callq 0x9272
incq %r14
addq $0x4, %r13
jmp 0x1a3fd
callq 0x12ea2
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), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xc24f
movq %r14, %rdi
movq %rax, %rsi
callq 0xbba1
callq 0x170a4
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 0x3557a(%rip), %rax     # 0x50480
movq 0x1758(%rax), %r14
movb $0x1, 0x72(%r14)
movl 0x19c(%r14), %ebx
movss 0x18(%r14), %xmm0
movss %xmm0, -0x14(%rbp)
movl %ebx, %edi
callq 0x11b7f
addss -0x14(%rbp), %xmm0
addss 0x1b464(%rip), %xmm0    # 0x3639c
movss %xmm0, -0x14(%rbp)
movss 0x18(%r14), %xmm0
movss %xmm0, -0x18(%rbp)
incl %ebx
movl %ebx, %edi
callq 0x11b7f
addss -0x18(%rbp), %xmm0
addss 0x1b43e(%rip), %xmm0    # 0x3639c
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
pushq $0x1
popq %rsi
callq 0x103af
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x7
popq %rax
cmovll %esi, %eax
testl %edx, %edx
cmovnsl %edx, %eax
cvtsi2ss %eax, %xmm0
cmpl %esi, %eax
jge 0x1b186
addss 0x1b256(%rip), %xmm0    # 0x363dc
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
andl $0x0, (%rsi)
movq 0x352e4(%rip), %rax     # 0x50480
movss 0x1418(%rax), %xmm1
movss 0x1718(%rax), %xmm2
addss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movss %xmm2, 0x4(%rsi)
callq 0x1afae
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x996d
movq %rax, %rbx
movups 0xe4(%rax), %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movq 0x3528d(%rip), %r15     # 0x50480
callq 0x100c6
movss 0x1b19c(%rip), %xmm1    # 0x3639c
xorps %xmm0, %xmm0
callq 0x1254d
movq (%r14), %rax
movq %rax, 0xa8(%rbx)
movss 0x140c(%r15), %xmm0
movq %r14, %rdi
callq 0x9af8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x170a4
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b168
testb %al, %al
je 0x1b30e
movq 0x351fd(%rip), %rax     # 0x50480
movss 0x1718(%rax), %xmm0
addss 0x1418(%rax), %xmm0
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x1f524
movl $0x0, -0x2c(%rbp)
movl 0x8(%r13), %r13d
cmpl -0x3c(%rbp), %r13d
jge 0x1b312
movl (%r12), %ebx
movq %r14, %rdi
movl %r13d, %esi
leaq -0x38(%rbp), %rdx
callq *%r15
testb %al, %al
jne 0x1b2d2
leaq 0x1c36b(%rip), %rax     # 0x37639
movq %rax, -0x38(%rbp)
movl %r13d, %edi
callq 0x13d85
xorl %esi, %esi
cmpl %ebx, %r13d
sete %sil
movq -0x38(%rbp), %rdi
andq $0x0, -0x50(%rbp)
xorl %edx, %edx
leaq -0x50(%rbp), %rcx
callq 0x1ab4d
testb %al, %al
je 0x1b304
movl %r13d, (%r12)
movb $0x1, %al
movl %eax, -0x2c(%rbp)
callq 0x12ea2
incl %r13d
jmp 0x1b2ac
xorl %eax, %eax
jmp 0x1b32c
leaq -0x48(%rbp), %rdi
callq 0x1f532
callq 0x1b1c8
leaq -0x48(%rbp), %rdi
callq 0x1f588
movl -0x2c(%rbp), %eax
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b341
jmp 0x1b341
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1f588
movq %rbx, %rdi
callq 0x74b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq 0x34f1f(%rip), %rbx     # 0x50480
andq $0x0, 0x1818(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1834(%rbx)
movl 0x8(%rbx), %eax
movss 0x140c(%rbx), %xmm0
addss %xmm0, %xmm0
addss 0x171c(%rbx), %xmm0
movl %eax, 0x1820(%rbx)
movss %xmm0, 0x1824(%rbx)
pushq $0x2
popq %rdi
xorps %xmm0, %xmm0
callq 0x10054
leaq -0x10(%rbp), %rsi
andq $0x0, (%rsi)
pushq $0x3
popq %rdi
callq 0x116b2
leaq 0x1c087(%rip), %rdi     # 0x37648
xorl %esi, %esi
movl $0x50f, %edx            # imm = 0x50F
callq 0xb0d4
testb %al, %al
je 0x1b5fd
callq 0x1b613
testb %al, %al
je 0x1b5fd
movss 0x1450(%rbx), %xmm0
movq 0x1758(%rbx), %rax
addss 0xf8(%rax), %xmm0
movss %xmm0, 0xf8(%rax)
movb $0x1, %al
jmp 0x1b60c
callq 0xb516
pushq $0x2
popq %rdi
callq 0xfb23
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34e5d(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x1b63a
testb $0x4, 0xd(%rbx)
jne 0x1b641
xorl %eax, %eax
jmp 0x1b6f4
cmpb $0x1, 0xf6(%rbx)
je 0x1b6fb
callq 0x16ed0
leaq 0x1c034(%rip), %rdi     # 0x3768e
callq 0x13116
movq %rbx, %rdi
callq 0x1ee74
movaps %xmm0, -0x30(%rbp)
movss 0x1ad5d(%rip), %xmm4    # 0x363d0
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 0x1ad53(%rip), %xmm3    # 0x363e0
addss %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
addss 0x1ada7(%rip), %xmm1    # 0x36444
leaq -0x40(%rbp), %rdi
movss %xmm2, (%rdi)
movss %xmm3, 0x4(%rdi)
movss %xmm4, 0x8(%rdi)
movss %xmm1, 0xc(%rdi)
xorl %esi, %esi
callq 0x103af
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 0x124f4
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1bf54(%rip), %rdi     # 0x37656
leaq 0x1af64(%rip), %rsi     # 0x3666d
leaq 0x1bf63(%rip), %rcx     # 0x37673
movl $0x1fc4, %edx           # imm = 0x1FC4
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34d3d(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x1b7b9
testb $0x4, 0xd(%rbx)
je 0x1b7c2
cmpb $0x0, 0xf6(%rbx)
je 0x1b7e1
callq 0x112a5
callq 0x12ea2
movss 0xa8(%rbx), %xmm0
movss %xmm0, -0x14(%rbp)
movq %rbx, %rdi
callq 0x1ee74
movss -0x14(%rbp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xf8(%rbx)
leaq 0x168(%rbx), %rdi
callq 0x1f5b2
xorl %r14d, %r14d
movb %r14b, 0x20(%rax)
callq 0x170a4
andl $0x0, 0x118(%rbx)
movb %r14b, 0xf6(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1becf(%rip), %rdi     # 0x37698
leaq 0x1ae9d(%rip), %rsi     # 0x3666d
leaq 0x1beea(%rip), %rcx     # 0x376c1
movl $0x1fd6, %edx           # imm = 0x1FD6
callq 0x7140
leaq 0x1be6f(%rip), %rdi     # 0x37657
leaq 0x1ae7e(%rip), %rsi     # 0x3666d
leaq 0x1becb(%rip), %rcx     # 0x376c1
movl $0x1fd7, %edx           # imm = 0x1FD7
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq 0x33e20(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
je 0x1c67c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, 0x1a0(%rbx)
jl 0x1c68a
callq 0x112a5
movss 0x18(%rbx), %xmm1
movss 0x20(%rbx), %xmm0
addss %xmm1, %xmm0
cmpl $0x0, 0x168(%rbx)
je 0x1c6a9
addss 0x194(%rbx), %xmm1
movl 0xac(%rbx), %eax
leaq -0x28(%rbp), %r14
movss %xmm1, (%r14)
movl %eax, 0x4(%r14)
movss %xmm0, 0x8(%r14)
movl %eax, 0xc(%r14)
leaq -0x30(%rbp), %rdi
andq $0x0, (%rdi)
xorps %xmm0, %xmm0
callq 0x99d9
movq %r14, %rdi
xorl %esi, %esi
callq 0x9b28
testb %al, %al
je 0x1c760
leaq -0x20(%rbp), %r14
movq 0x270(%rbx), %r15
pushq $0x4
popq %rsi
movss 0x19c96(%rip), %xmm0    # 0x36390
movq %rbx, %rdi
callq 0x1eae4
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %eax, %ecx
movss 0x19c7a(%rip), %xmm0    # 0x36390
callq 0x29920
movq 0x33d5e(%rip), %rax     # 0x50480
cmpb $0x1, 0x2be8(%rax)
jne 0x1c739
leaq 0x1b053(%rip), %rdi     # 0x37785
xorl %eax, %eax
callq 0xc0ac
cmpl $0x2, 0x1a0(%rbx)
jl 0x1c671
callq 0x1aef4
movss 0xac(%rbx), %xmm0
movss %xmm0, 0x1ac(%rbx)
jmp 0x1c671
cmpl $0x2, 0x1a0(%rbx)
jl 0x1c671
callq 0x1aef4
jmp 0x1c671
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x33ca2(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rbx
movb $0x1, 0x72(%rbx)
cmpb $0x0, 0x74(%rbx)
jne 0x1c86e
cmpl $0x2, 0x1a0(%rbx)
jl 0x1c86e
callq 0x9272
callq 0x112a5
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 0x1c873
callq 0x11b7f
subss 0x194(%rbx), %xmm0
addss 0x1414(%r14), %xmm0
movss %xmm0, 0x198(%rbx)
movq 0x270(%rbx), %rdi
movl 0x19c(%rbx), %esi
jmp 0x1c88c
popq %rbx
popq %r14
popq %rbp
retq
andq $0x0, 0x198(%rbx)
movss %xmm0, 0x1ac(%rbx)
movq 0x270(%rbx), %rdi
xorl %esi, %esi
callq 0x2819a
movss 0x18(%rbx), %xmm0
addss 0x194(%rbx), %xmm0
addss 0x198(%rbx), %xmm0
movss 0x1ac(%rbx), %xmm1
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xa8(%rbx)
movss %xmm1, 0xac(%rbx)
andq $0x0, 0xc8(%rbx)
callq 0x1aef4
pushq $-0x1
popq %rdi
callq 0x1c8eb
mulss 0x19b26(%rip), %xmm0    # 0x36408
popq %rbx
popq %r14
popq %rbp
jmp 0x91e1
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1c90b
movq 0x33b82(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rax
movl 0x19c(%rax), %ebx
leal 0x1(%rbx), %edi
callq 0x11b7f
movss %xmm0, -0xc(%rbp)
movl %ebx, %edi
callq 0x11b7f
movss -0xc(%rbp), %xmm1
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ca0d
movl %edi, %ebx
movq 0x33afe(%rip), %r14     # 0x50480
movq 0x1758(%r14), %rax
movl 0x1b8(%rax), %ecx
addl %edi, %ecx
cmpl %ecx, 0x1790(%r14)
jne 0x1ca2c
movss 0xf0(%r14), %xmm0
addss 0x27b8(%r14), %xmm0
subss 0x18(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
leal -0x1(%rbx), %edi
callq 0x11b7f
addss 0x1434(%r14), %xmm0
movaps %xmm0, -0x20(%rbp)
incl %ebx
movl %ebx, %edi
callq 0x11b7f
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 0x1b571(%rip), %rdi     # 0x37f85
leaq 0x19c52(%rip), %rsi     # 0x3666d
leaq 0x1b574(%rip), %rcx     # 0x37f96
movl $0x21c8, %edx           # imm = 0x21C8
callq 0x7140
leaq 0x1b585(%rip), %rdi     # 0x37fb8
leaq 0x19c33(%rip), %rsi     # 0x3666d
leaq 0x1b555(%rip), %rcx     # 0x37f96
movl $0x21c9, %edx           # imm = 0x21C9
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x33a21(%rip), %rcx     # 0x50480
movq 0x1758(%rcx), %rax
movb $0x1, 0x72(%rax)
testl %edi, %edi
jns 0x1ca74
movl 0x19c(%rax), %ebx
cmpl 0x1c0(%rax), %ebx
jge 0x1cafb
movss 0x38(%rax), %xmm4
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm4
jne 0x1ca90
jp 0x1ca90
movss 0x20(%rax), %xmm4
leaq 0x1c0(%rax), %r14
movl 0x1b8(%rax), %esi
movss 0x4c(%rax), %xmm3
movss 0x194(%rax), %xmm2
testb $0x8, 0xc(%rax)
jne 0x1cab8
movss 0x1438(%rcx), %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(%rax), %rdi
callq 0x8f76
movq %r14, %rdi
movl %ebx, %esi
callq 0x1f61c
movss -0x14(%rbp), %xmm0
movss %xmm0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1acdb(%rip), %rdi     # 0x377dd
leaq 0x19b64(%rip), %rsi     # 0x3666d
leaq 0x1ad1e(%rip), %rcx     # 0x3782e
movl $0x21f1, %edx           # imm = 0x21F1
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3395b(%rip), %rax     # 0x50480
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_O2/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 0x33916(%rip), %rax     # 0x50480
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_O2/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
pushq %rbx
pushq %rax
movq 0x338cf(%rip), %rax     # 0x50480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
callq 0x1cb5f
decl 0xdc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12ea2
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ab9e(%rip), %rdi     # 0x3789d
movl %ebx, %edx
xorl %eax, %eax
callq 0x1227e
movss 0x1968c(%rip), %xmm1    # 0x3639c
xorps %xmm0, %xmm0
callq 0x1254d
movl $0xff, %eax
movl %ebx, %ecx
andl %eax, %ecx
cvtsi2ss %ecx, %xmm0
movss 0x1966b(%rip), %xmm1    # 0x36398
divss %xmm1, %xmm0
leaq -0x18(%rbp), %rdi
movss %xmm0, (%rdi)
movl %ebx, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
cvtsi2ss %ecx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rdi)
movl %ebx, %ecx
shrl $0x10, %ecx
andl %eax, %ecx
cvtsi2ss %ecx, %xmm0
shrl $0x18, %ebx
cvtsi2ss %ebx, %xmm2
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rdi)
divss %xmm1, %xmm2
movss %xmm2, 0xc(%rdi)
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x1be68
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1afa1(%rip), %rsi     # 0x37ff6
xorl %r14d, %r14d
movq %rdx, %rdi
xorl %eax, %eax
callq 0x13b50
testb %al, %al
je 0x1d09c
leaq 0x1a950(%rip), %r15     # 0x379bd
cmpl (%rbx), %r14d
jge 0x1d08d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1e6f4
movq (%rax), %rdi
movq %r15, %rsi
callq 0x1dcaa
incl %r14d
jmp 0x1d06d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1cba4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x17b0, %r14d          # imm = 0x17B0
addq 0x3315e(%rip), %r14     # 0x50480
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x846d
movl %eax, %r15d
xorl %r12d, %r12d
cmpl (%r14), %r12d
je 0x1d34f
movq %r14, %rdi
movl %r12d, %esi
callq 0x1e872
incl %r12d
cmpl %r15d, 0x8(%rax)
jne 0x1d333
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: 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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x33114(%rip), %rdi     # 0x50480
movl $0x17b0, %r14d          # imm = 0x17B0
movl 0x17b0(%rdi), %esi
addq %r14, %rdi
incl %esi
callq 0x1f9ec
addq 0x330f7(%rip), %r14     # 0x50480
movq %r14, %rdi
callq 0x1fa2a
movq %rax, %r14
movq %rbx, %rdi
callq 0x826a
movq %rax, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x846d
movl %eax, 0x8(%r14)
movb $0x0, 0x1c(%r14)
movsd 0x18fc4(%rip), %xmm0    # 0x36380
movups %xmm0, 0xc(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d404
movl $0x1000000, %esi        # imm = 0x1000000
movl %ecx, %eax
andl %esi, %eax
andl %edx, %esi
subl %esi, %eax
jne 0x1d404
movl $0x800000, %eax         # imm = 0x800000
andl %eax, %ecx
andl %eax, %edx
subl %edx, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStb::STB_TEXTEDIT_DELETECHARS(ImGuiTextEditState*, int, int)
static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
{
    ImWchar* dst = obj->Text.Data + pos;

    // We maintain our buffer length in both UTF-8 and wchar formats
    obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
    obj->CurLenW -= n;

    // Offset remaining text
    const ImWchar* src = obj->Text.Data + pos + n;
    while (ImWchar c = *src++)
        *dst++ = c;
    *dst = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq %esi, %rbx
addq %rbx, %rbx
addq 0x10(%rdi), %rbx
movslq %edx, %r15
leaq (%rbx,%r15,2), %rsi
movq %rbx, %rdi
callq 0x88c6
subl %eax, 0x38(%r14)
subl %r15d, 0x3c(%r14)
movzwl (%rbx,%r15,2), %eax
testw %ax, %ax
je 0x1d447
movw %ax, (%rbx)
addq $0x2, %rbx
jmp 0x1d434
andw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq