LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x261be
cmpl $0x2b, -0x8(%rbp)
jne 0x261a2
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x261bc
cmpl $0x2d, -0x8(%rbp)
jne 0x261ba
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
subl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x261bc
jmp 0x26208
cmpl $0x1, -0x4(%rbp)
jne 0x26206
cmpl $0x2b, -0x8(%rbp)
jne 0x261e4
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
addss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x26204
cmpl $0x2d, -0x8(%rbp)
jne 0x26202
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
subss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x26204
jmp 0x26206
jmp 0x26208
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x26248
leaq -0x30(%rbp), %rdi
leaq 0x378db(%rip), %rsi     # 0x5db1c
callq 0x7350
jmp 0x26262
leaq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movl $0x10, %esi
leaq 0x36034(%rip), %rdx     # 0x5c28f
movb $0x0, %al
callq 0x95a0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x26289
leaq -0x14(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x26291
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x26291
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movss -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x262b0
leaq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x262b8
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x262b8
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %r8
leaq -0x30(%rbp), %r9
movl -0x20(%rbp), %eax
movl $0x1, %esi
movl %eax, (%rsp)
callq 0x25cb0
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
callq 0x2e220
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x263e6
movb $0x0, -0x1(%rbp)
jmp 0x264eb
movq 0x530d3(%rip), %rax     # 0x794c0
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
callq 0x211c0
movq -0x10(%rbp), %rdi
callq 0x1b8c0
movl -0x1c(%rbp), %edi
xorps %xmm0, %xmm0
callq 0x21310
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2648f
movl -0x40(%rbp), %edi
callq 0x1cc80
movq -0x18(%rbp), %rsi
movslq -0x40(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq 0x35afd(%rip), %rdi     # 0x5bf3e
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x26210
andb $0x1, %al
movzbl %al, %ecx
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x38(%rbp), %rax
movss 0x141c(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0x1a5e0
callq 0x1b550
callq 0xb0f0
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x26415
callq 0x1b550
movq -0x30(%rbp), %rax
movss 0xcc(%rax), %xmm0
movq -0x38(%rbp), %rax
movss 0x140c(%rax), %xmm1
callq 0xb7c0
movq -0x30(%rbp), %rax
movss %xmm0, 0xcc(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10230
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xf8c0
callq 0x21490
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
callq 0x2e220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x265f2
movb $0x0, -0x1(%rbp)
jmp 0x266f3
movq 0x52ec7(%rip), %rax     # 0x794c0
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x211c0
movq -0x10(%rbp), %rdi
callq 0x1b8c0
movl -0x1c(%rbp), %edi
xorps %xmm0, %xmm0
callq 0x21310
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x26697
movl -0x38(%rbp), %edi
callq 0x1cc80
movq -0x18(%rbp), %rsi
movslq -0x38(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x20(%rbp), %r8d
leaq 0x358f3(%rip), %rdi     # 0x5bf3e
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x262f0
andb $0x1, %al
movzbl %al, %ecx
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rax
movss 0x141c(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0x1a5e0
callq 0x1b550
callq 0xb0f0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x26621
callq 0x1b550
movq -0x28(%rbp), %rax
movss 0xcc(%rax), %xmm0
movq -0x30(%rbp), %rax
movss 0x140c(%rax), %xmm1
callq 0xb7c0
movq -0x28(%rbp), %rax
movss %xmm0, 0xcc(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10230
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xf8c0
callq 0x21490
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Spacing()
void ImGui::Spacing()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
    ItemSize(ImVec2(0,0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2e220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x2712d
jmp 0x27148
leaq -0x10(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
leaq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xbeb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
callq 0x2e220
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x27827
movq -0x10(%rbp), %rax
movl 0x19c(%rax), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movl -0x4(%rbp), %edi
callq 0x19660
movaps %xmm0, %xmm1
movss -0x40(%rbp), %xmm0
addss %xmm1, %xmm0
movss 0x337c7(%rip), %xmm1    # 0x5b018
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x19660
movaps %xmm0, %xmm1
movss -0x3c(%rbp), %xmm0
addss %xmm1, %xmm0
movss 0x33791(%rip), %xmm1    # 0x5b018
subss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm2
leaq -0x38(%rbp), %rdi
movss 0x337fa(%rip), %xmm1    # 0x5b0a0
movss 0x337ee(%rip), %xmm3    # 0x5b09c
callq 0x2d2b0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2eff0
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x16900
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::Selectable(char const*, bool*, int, ImVec2 const&)
bool ImGui::Selectable(const char* label, bool* p_selected, ImGuiSelectableFlags flags, const ImVec2& size_arg)
{
    if (ImGui::Selectable(label, *p_selected, flags, size_arg))
    {
        *p_selected = !*p_selected;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb (%rax), %al
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
andb $0x1, %al
movzbl %al, %esi
callq 0x27150
testb $0x1, %al
jne 0x27918
jmp 0x27930
movq -0x18(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x27934
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x27be8
movl -0xc(%rbp), %edi
movl $0x7, %esi
callq 0x22cd0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27c08
cvtsi2ssl -0x10(%rbp), %xmm0
movss 0x3343f(%rip), %xmm1    # 0x5b03c
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x27c19
cvtsi2ssl -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x2d230
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
callq 0x19a00
movss %xmm0, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
callq 0xcab0
movss -0x28(%rbp), %xmm0
movss -0x24(%rbp), %xmm2
movss 0x30(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x27940
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
callq 0xbdf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xe4(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0xec(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0xcab0
movq %rax, -0x20(%rbp)
callq 0x16190
xorps %xmm0, %xmm0
movss 0x333b8(%rip), %xmm1    # 0x5b07c
callq 0x1a5e0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x20(%rbp), %rax
movss 0x24(%rax), %xmm0
leaq -0x18(%rbp), %rdi
callq 0xc060
callq 0x21490
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::MenuItem(char const*, char const*, bool*, bool)
bool ImGui::MenuItem(const char* label, const char* shortcut, bool* p_selected, bool enabled)
{
    if (ImGui::MenuItem(label, shortcut, p_selected ? *p_selected : false, enabled))
    {
        if (p_selected)
            *p_selected = !*p_selected;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2817d
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
jmp 0x28184
xorl %eax, %eax
movb %al, -0x39(%rbp)
jmp 0x28184
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movb -0x39(%rbp), %cl
movb -0x21(%rbp), %al
movzbl %cl, %edx
andl $0x1, %edx
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x27ed0
testb $0x1, %al
jne 0x281a9
jmp 0x281c8
cmpq $0x0, -0x20(%rbp)
je 0x281c2
movq -0x20(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x281cc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq 0x512d1(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x19450
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x171c(%rax), %xmm2
movq -0x10(%rbp), %rax
movss 0x140c(%rax), %xmm1
addss %xmm1, %xmm1
addss %xmm2, %xmm1
leaq -0x20(%rbp), %rdi
callq 0x2d280
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xe790
movl $0x2, %edi
xorps %xmm0, %xmm0
callq 0x160e0
leaq -0x28(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movl $0x3, %edi
leaq -0x28(%rbp), %rsi
callq 0x18ae0
leaq 0x34029(%rip), %rdi     # 0x5c2a4
xorl %eax, %eax
movl %eax, %esi
movl $0x50f, %edx            # imm = 0x50F
callq 0xe7e0
testb $0x1, %al
jne 0x2828f
jmp 0x28298
callq 0x282f0
testb $0x1, %al
jne 0x282ad
callq 0xee30
movl $0x2, %edi
callq 0x159f0
movb $0x0, -0x1(%rbp)
jmp 0x282d8
movq -0x10(%rbp), %rax
movss 0x1450(%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x1758(%rax), %rax
addss 0xf8(%rax), %xmm0
movss %xmm0, 0xf8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
callq 0x2e220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x28314
movb $0x0, -0x1(%rbp)
jmp 0x28432
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x2832e
movb $0x0, -0x1(%rbp)
jmp 0x28432
movq -0x10(%rbp), %rax
movb 0xf6(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x28340
jmp 0x28342
jmp 0x28361
leaq 0x33f69(%rip), %rdi     # 0x5c2b2
leaq 0x32f75(%rip), %rsi     # 0x5b2c5
movl $0x1fc4, %edx           # imm = 0x1FC4
leaq 0x33f73(%rip), %rcx     # 0x5c2cf
callq 0x7160
callq 0x211c0
leaq 0x33f7d(%rip), %rdi     # 0x5c2ea
callq 0x1b8c0
movq -0x10(%rbp), %rdi
callq 0x2f320
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movss 0x32c97(%rip), %xmm0    # 0x5b024
addss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss 0x32c85(%rip), %xmm2    # 0x5b024
subss %xmm2, %xmm1
movss 0x32c79(%rip), %xmm2    # 0x5b024
addss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm3
movss 0x32d67(%rip), %xmm4    # 0x5b124
subss %xmm4, %xmm3
leaq -0x40(%rbp), %rdi
callq 0x2d2b0
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2eff0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x16900
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss 0xf8(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
leaq -0x48(%rbp), %rdi
callq 0x2d280
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x118(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0xf6(%rax)
callq 0x1a560
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
callq 0x2e220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x28480
jmp 0x2855c
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x28493
jmp 0x284b2
leaq 0x33e5a(%rip), %rdi     # 0x5c2f4
leaq 0x32e24(%rip), %rsi     # 0x5b2c5
movl $0x1fd6, %edx           # imm = 0x1FD6
leaq 0x33e70(%rip), %rcx     # 0x5c31d
callq 0x7160
movq -0x8(%rbp), %rax
testb $0x1, 0xf6(%rax)
je 0x284c1
jmp 0x284e0
leaq 0x33deb(%rip), %rdi     # 0x5c2b3
leaq 0x32df6(%rip), %rsi     # 0x5b2c5
movl $0x1fd7, %edx           # imm = 0x1FD7
leaq 0x33e42(%rip), %rcx     # 0x5c31d
callq 0x7160
callq 0x18470
callq 0x1b550
movq -0x8(%rbp), %rdi
movss 0xa8(%rdi), %xmm0
movss %xmm0, -0x1c(%rbp)
callq 0x2f320
movaps %xmm0, %xmm2
movss -0x1c(%rbp), %xmm0
movlpd %xmm2, -0x18(%rbp)
movlpd %xmm1, -0x10(%rbp)
subss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xf8(%rax)
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
addq $0xc0, %rdi
callq 0x30190
movb $0x0, 0x20(%rax)
callq 0x21490
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xf6(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ColorEdit3(char const*, float*)
bool ImGui::ColorEdit3(const char* label, float col[3])
{
    float col4[4];
    col4[0] = col[0];
    col4[1] = col[1];
    col4[2] = col[2];
    col4[3] = 1.0f;
    const bool value_changed = ImGui::ColorEdit4(label, col4, false);
    col[0] = col4[0];
    col[1] = col4[1];
    col[2] = col4[2];
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x31d47(%rip), %xmm0    # 0x5b018
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x29320
andb $0x1, %al
movb %al, -0x21(%rbp)
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x2e290
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2a027
movq -0x10(%rbp), %rax
movl 0x19c(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x19660
movss %xmm0, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x19660
movaps %xmm0, %xmm1
movss -0x18(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x4f3ee(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
callq 0x2e290
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x2a0e7
jmp 0x2a106
leaq 0x32b6f(%rip), %rdi     # 0x5cc5d
leaq 0x311d0(%rip), %rsi     # 0x5b2c5
movl $0x21c8, %edx           # imm = 0x21C8
leaq 0x32b6d(%rip), %rcx     # 0x5cc6e
callq 0x7160
movq -0x10(%rbp), %rax
movl 0x1790(%rax), %eax
movq -0x18(%rbp), %rcx
movl 0x1b8(%rcx), %ecx
addl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2a123
jmp 0x2a142
leaq 0x32b66(%rip), %rdi     # 0x5cc90
leaq 0x31194(%rip), %rsi     # 0x5b2c5
movl $0x21c9, %edx           # imm = 0x21C9
leaq 0x32b31(%rip), %rcx     # 0x5cc6e
callq 0x7160
movq -0x10(%rbp), %rax
movss 0xf0(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x27b8(%rax), %xmm0
movq -0x18(%rbp), %rax
subss 0x18(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
callq 0x19660
movq -0x10(%rbp), %rax
addss 0x1434(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x19660
movss -0x24(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss 0x1434(%rax), %xmm2
callq 0xe3b0
movss %xmm0, -0x1c(%rbp)
cvttss2si -0x1c(%rbp), %eax
cvtsi2ss %eax, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq 0x4f2d9(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
callq 0x2e220
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x2a207
movq -0x18(%rbp), %rax
movl 0x19c(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c0(%rcx), %eax
jge 0x2a218
jmp 0x2a237
leaq 0x3221a(%rip), %rdi     # 0x5c439
leaq 0x3109f(%rip), %rsi     # 0x5b2c5
movl $0x21f1, %edx           # imm = 0x21F1
leaq 0x32258(%rip), %rcx     # 0x5c48a
callq 0x7160
movq -0x18(%rbp), %rax
movl 0x1b8(%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0x38(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2a25c
jp 0x2a25c
jmp 0x2a26c
movq -0x18(%rbp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
jmp 0x2a27a
movq -0x18(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x194(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x4c(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2a2c1
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x2a2d2
movq -0x10(%rbp), %rax
movss 0x1438(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x8(%rbp), %xmm0
subss -0x24(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
subss -0x24(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rdi
movl -0x1c(%rbp), %esi
movss -0x2c(%rbp), %xmm0
callq 0xac10
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
addq $0x118, %rdi            # imm = 0x118
movl -0x4(%rbp), %esi
callq 0x30290
movss -0x3c(%rbp), %xmm0
movss %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq 0x4f161(%rip), %rax     # 0x794c0
movq %rax, -0x8(%rbp)
callq 0x2e220
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x1430(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x194(%rax), %xmm0
movss %xmm0, 0x194(%rax)
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x194(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x198(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xa8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq 0x4f0f1(%rip), %rax     # 0x794c0
movq %rax, -0x8(%rbp)
callq 0x2e220
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x1430(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x194(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x194(%rax)
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x194(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x198(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xa8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
callq 0x2e220
movq %rax, -0x8(%rbp)
callq 0x2a3c0
movq -0x8(%rbp), %rax
movl 0xdc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xdc(%rax)
callq 0x1b550
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq 0x31eac(%rip), %rdi     # 0x5c4f9
xorl %eax, %eax
callq 0x1a220
xorps %xmm0, %xmm0
movss 0x30a1d(%rip), %xmm1    # 0x5b07c
callq 0x1a5e0
leaq -0x1c(%rbp), %rdi
callq 0x2d250
movzbl -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss 0x30a0f(%rip), %xmm1    # 0x5b08c
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movzbl -0xb(%rbp), %eax
cvtsi2ss %eax, %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movzbl -0xa(%rbp), %eax
cvtsi2ss %eax, %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movzbl -0x9(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss 0x309d4(%rip), %xmm1    # 0x5b08c
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x28f80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x321a9(%rip), %rsi     # 0x5ccce
movb $0x0, %al
callq 0x1c920
testb $0x1, %al
jne 0x2ab32
jmp 0x2ab6f
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2ab6a
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rdi
leaq 0x31abf(%rip), %rsi     # 0x5c619
callq 0x2c8c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ab39
callq 0x2a440
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0x4e56d(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x96e0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x17b0(%rcx), %eax
je 0x2afb7
movq -0x18(%rbp), %rdi
addq $0x17b0, %rdi           # imm = 0x17B0
movl -0x20(%rbp), %esi
callq 0x2e560
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2afaa
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2afbf
jmp 0x2afac
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2af6e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x4e4dd(%rip), %rdi     # 0x794c0
addq $0x17b0, %rdi           # imm = 0x17B0
movq 0x4e4cf(%rip), %rax     # 0x794c0
movl 0x17b0(%rax), %esi
addl $0x1, %esi
callq 0x30e40
movq 0x4e4ba(%rip), %rdi     # 0x794c0
addq $0x17b0, %rdi           # imm = 0x17B0
callq 0x30e90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9360
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x96e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1c(%rax)
leaq -0x18(%rbp), %rdi
movss 0x30049(%rip), %xmm1    # 0x5b09c
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0xc(%rax)
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
andl $0x2000000, %ecx        # imm = 0x2000000
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2b0de
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b13d
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
andl $0x1000000, %ecx        # imm = 0x1000000
subl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x2b10a
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b13d
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x800000, %eax         # imm = 0x800000
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
andl $0x800000, %ecx         # imm = 0x800000
subl %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x2b136
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b13d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rax
shlq %rax
addq %rax, %rsi
callq 0x9fa0
movl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x38(%rax)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x20(%rbp)
movw (%rax), %ax
movw %ax, -0x22(%rbp)
cmpw $0x0, -0x22(%rbp)
je 0x2b2d1
movw -0x22(%rbp), %cx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x18(%rbp)
movw %cx, (%rax)
jmp 0x2b29c
movq -0x18(%rbp), %rax
movw $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGuiStb::STB_TEXTEDIT_INSERTCHARS(ImGuiTextEditState*, int, unsigned short const*, int)
static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
{
    const int text_len = obj->CurLenW;
    if (new_text_len + text_len + 1 > obj->Text.Size)
        return false;

    const int new_text_len_utf8 = ImTextCountUtf8BytesFromStr(new_text, new_text + new_text_len);
    if (new_text_len_utf8 + obj->CurLenA + 1 > obj->BufSizeA)
        return false;

    ImWchar* text = obj->Text.Data;
    if (pos != text_len)
        memmove(text + pos + new_text_len, text + pos, (size_t)(text_len - pos) * sizeof(ImWchar));
    memcpy(text + pos, new_text, (size_t)new_text_len * sizeof(ImWchar));

    obj->CurLenW += new_text_len;
    obj->CurLenA += new_text_len_utf8;
    obj->Text[obj->CurLenW] = '\0';

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x2b31b
movb $0x0, -0x1(%rbp)
jmp 0x2b3f4
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rax
shlq %rax
addq %rax, %rsi
callq 0x9fa0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x38(%rcx), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jle 0x2b354
movb $0x0, -0x1(%rbp)
jmp 0x2b3f4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x2b39f
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq %rax
addq %rax, %rdi
movslq -0x24(%rbp), %rax
shlq %rax
addq %rax, %rdi
movq -0x38(%rbp), %rsi
movslq -0x14(%rbp), %rax
shlq %rax
addq %rax, %rsi
movl -0x28(%rbp), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rdx
shlq %rdx
callq 0x7150
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
shlq %rdx
callq 0x7080
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %esi
callq 0x31550
movw $0x0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_move_to_word_previous(ImGuiTextEditState*, ImGuiStb::STB_TexteditState*)
static int stb_textedit_move_to_word_previous( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
{
   int c = _state->cursor - 1;
   while( c >= 0 && !is_word_boundary( _str, c ) )
      --c;

   if( c < 0 )
      c = 0;

   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jl 0x2bb0e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2c480
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x2bb17
jmp 0x2bb22
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2baec
cmpl $0x0, -0x14(%rbp)
jge 0x2bb2f
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_textedit_move_to_word_next(ImGuiTextEditState*, ImGuiStb::STB_TexteditState*)
static int stb_textedit_move_to_word_next( STB_TEXTEDIT_STRING *_str, STB_TexteditState *_state )
{
   const int len = STB_TEXTEDIT_STRINGLEN(_str);
   int c = _state->cursor+1;
   while( c < len && !is_word_boundary( _str, c ) )
      ++c;

   if( c > len )
      c = len;

   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b180
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x19(%rbp)
jge 0x2bb8c
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2c480
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2bb95
jmp 0x2bba0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2bb68
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x2bbae
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/stb_textedit.h
// Function: ImGuiStb::stb_text_createundo(ImGuiStb::StbUndoState*, int, int, int)
static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
{
   StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
   if (r == NULL)
      return NULL;

   r->where = pos;
   r->insert_length = (short) insert_len;
   r->delete_length = (short) delete_len;

   if (insert_len == 0) {
      r->char_storage = -1;
      return NULL;
   } else {
      r->char_storage = state->undo_char_point;
      state->undo_char_point = state->undo_char_point + (short) insert_len;
      return &state->undo_char[r->char_storage];
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2c050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2bfa9
movq $0x0, -0x8(%rbp)
jmp 0x2c039
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x4(%rax)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x6(%rax)
cmpl $0x0, -0x18(%rbp)
jne 0x2bfe8
movq -0x28(%rbp), %rax
movw $0xffff, 0x8(%rax)      # imm = 0xFFFF
movq $0x0, -0x8(%rbp)
jmp 0x2c039
movq -0x10(%rbp), %rax
movw 0xc76(%rax), %cx
movq -0x28(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movswl 0xc76(%rax), %eax
movl -0x18(%rbp), %ecx
movswl %cx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc76(%rax)
movq -0x10(%rbp), %rax
addq $0x4a4, %rax            # imm = 0x4A4
movq -0x28(%rbp), %rcx
movswq 0x8(%rcx), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)