LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopStyleVar(int)
void ImGui::PopStyleVar(int count)
{
    ImGuiState& g = *GImGui;
    while (count > 0)
    {
        ImGuiStyleMod& backup = g.StyleModifiers.back();
        if (float* pvar_f = GetStyleVarFloatAddr(backup.Var))
            *pvar_f = backup.PreviousValue.x;
        else if (ImVec2* pvar_v = GetStyleVarVec2Addr(backup.Var))
            *pvar_v = backup.PreviousValue;
        g.StyleModifiers.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x63abe(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x15a92
movq -0x10(%rbp), %rdi
addq $0x17d8, %rdi           # imm = 0x17D8
callq 0x2fc70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x18a20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x15a4d
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x15a74
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x18b70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x15a72
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x4(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x15a74
movq -0x10(%rbp), %rdi
addq $0x17d8, %rdi           # imm = 0x17D8
callq 0x2fcd0
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15a06
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupContextWindow(bool, char const*, int)
bool ImGui::BeginPopupContextWindow(bool also_over_items, const char* str_id, int mouse_button)
{
    if (!str_id) str_id = "window_context_menu";
    if (ImGui::IsMouseHoveringWindow() && ImGui::IsMouseClicked(mouse_button))
        if (also_over_items || !ImGui::IsAnyItemHovered())
            ImGui::OpenPopup(str_id);
    return ImGui::BeginPopup(str_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15b19
leaq 0x45dde(%rip), %rax     # 0x5b8f3
movq %rax, -0x10(%rbp)
callq 0x11330
testb $0x1, %al
jne 0x15b24
jmp 0x15b4e
movl -0x14(%rbp), %edi
xorl %esi, %esi
callq 0x11740
testb $0x1, %al
jne 0x15b34
jmp 0x15b4e
testb $0x1, -0x1(%rbp)
jne 0x15b43
callq 0x11d70
testb $0x1, %al
jne 0x15b4c
movq -0x10(%rbp), %rdi
callq 0x15330
jmp 0x15b4e
movq -0x10(%rbp), %rdi
callq 0x155b0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupContextVoid(char const*, int)
bool ImGui::BeginPopupContextVoid(const char* str_id, int mouse_button)
{
    if (!str_id) str_id = "void_context_menu";
    if (!ImGui::IsMouseHoveringAnyWindow() && ImGui::IsMouseClicked(mouse_button))
        ImGui::OpenPopup(str_id);
    return ImGui::BeginPopup(str_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x15b81
leaq 0x45d8a(%rip), %rax     # 0x5b907
movq %rax, -0x8(%rbp)
callq 0x11360
testb $0x1, %al
jne 0x15ba3
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x11740
testb $0x1, %al
jne 0x15b9a
jmp 0x15ba3
movq -0x8(%rbp), %rdi
callq 0x15330
movq -0x8(%rbp), %rdi
callq 0x155b0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::EndChild()
void ImGui::EndChild()
{
    ImGuiWindow* window = GetCurrentWindow();

    IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow);
    if ((window->Flags & ImGuiWindowFlags_ComboBox) || window->BeginCount > 1)
    {
        ImGui::End();
    }
    else
    {
        // When using auto-filling child window, we don't provide full width/height to ItemSize so that it doesn't feed back into automatic size-fitting.
        ImGuiState& g = *GImGui;
        ImVec2 sz = ImGui::GetWindowSize();
        if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitX) // Arbitrary minimum zeroish child size of 4.0f
            sz.x = ImMax(4.0f, sz.x - g.Style.WindowPadding.x);
        if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitY)
            sz.y = ImMax(4.0f, sz.y - g.Style.WindowPadding.y);

        ImGui::End();

        window = GetCurrentWindow();
        ImRect bb(window->DC.CursorPos, window->DC.CursorPos + sz);
        ItemSize(sz);
        ItemAdd(bb, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x2e220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0x15e84
jmp 0x15ea3
leaq 0x45a9f(%rip), %rdi     # 0x5b92a
leaq 0x45433(%rip), %rsi     # 0x5b2c5
movl $0xcbf, %edx            # imm = 0xCBF
leaq 0x45ab9(%rip), %rcx     # 0x5b957
callq 0x7160
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x800000, %eax         # imm = 0x800000
cmpl $0x0, %eax
jne 0x15ebe
movq -0x8(%rbp), %rax
cmpl $0x1, 0x78(%rax)
jle 0x15ec8
callq 0xee30
jmp 0x15f9a
movq 0x635f1(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
callq 0x15fa0
movlpd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x200000, %eax         # imm = 0x200000
cmpl $0x0, %eax
je 0x15f11
movss -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
subss 0x13ec(%rax), %xmm1
movss 0x45151(%rip), %xmm0    # 0x5b058
callq 0xb7c0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x400000, %eax         # imm = 0x400000
cmpl $0x0, %eax
je 0x15f45
movss -0x14(%rbp), %xmm1
movq -0x10(%rbp), %rax
subss 0x13f0(%rax), %xmm1
movss 0x4511d(%rip), %xmm0    # 0x5b058
callq 0xb7c0
movss %xmm0, -0x14(%rbp)
callq 0xee30
callq 0x2e220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x38(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xc7e0
movq -0x38(%rbp), %rsi
movlpd %xmm0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x2eb40
leaq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xbeb0
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0a0
addq $0x40, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginChildFrame(unsigned int, ImVec2 const&)
bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size)
{
    ImGuiState& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    ImGui::PushStyleColor(ImGuiCol_ChildWindowBg, style.Colors[ImGuiCol_FrameBg]);
    ImGui::PushStyleVar(ImGuiStyleVar_ChildWindowRounding, style.FrameRounding);
    return ImGui::BeginChild(id, size, false, ImGuiWindowFlags_NoMove);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x634da(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x78, %rsi
addq $0x60, %rsi
movl $0x3, %edi
callq 0x16040
movq -0x20(%rbp), %rax
movss 0x28(%rax), %xmm0
movl $0x4, %edi
callq 0x160e0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x15e00
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleColor(int, ImVec4 const&)
void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
    ImGuiState& g = *GImGui;
    ImGuiColMod backup;
    backup.Col = idx;
    backup.PreviousValue = g.Style.Colors[idx];
    g.ColorModifiers.push_back(backup);
    g.Style.Colors[idx] = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x6346a(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x2fa90
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x78, %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x17c8, %rdi           # imm = 0x17C8
leaq -0x2c(%rbp), %rsi
callq 0x2fab0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x78, %rax
movslq -0x4(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, float)
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
    ImGuiState& g = *GImGui;
    float* pvar = GetStyleVarFloatAddr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a float.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = ImVec2(*pvar, 0.0f);
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq 0x633c9(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x18a20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16110
jmp 0x1612f
leaq 0x45969(%rip), %rdi     # 0x5ba80
leaq 0x451a7(%rip), %rsi     # 0x5b2c5
movl $0x10e2, %edx           # imm = 0x10E2
leaq 0x45965(%rip), %rcx     # 0x5ba8f
callq 0x7160
leaq -0x24(%rbp), %rdi
callq 0x2fbe0
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
leaq -0x2c(%rbp), %rdi
xorps %xmm1, %xmm1
callq 0x2d280
movq -0x2c(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x17d8, %rdi           # imm = 0x17D8
leaq -0x24(%rbp), %rsi
callq 0x2fc00
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopStyleColor(int)
void ImGui::PopStyleColor(int count)
{
    ImGuiState& g = *GImGui;
    while (count > 0)
    {
        ImGuiColMod& backup = g.ColorModifiers.back();
        g.Style.Colors[backup.Col] = backup.PreviousValue;
        g.ColorModifiers.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x632fe(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x1622a
movq -0x10(%rbp), %rdi
addq $0x17c8, %rdi           # imm = 0x17C8
callq 0x2fb30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x78, %rax
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x4(%rcx), %rdx
movq %rdx, (%rax)
movq 0xc(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x17c8, %rdi           # imm = 0x17C8
callq 0x2fb90
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x161c6
addq $0x20, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindWindowByName(char const*)
static ImGuiWindow* FindWindowByName(const char* name)
{
    // FIXME-OPT: Store sorted hashes -> pointers.
    ImGuiState& g = *GImGui;
    ImGuiID id = ImHash(name, 0);
    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i]->ID == id)
            return g.Windows[i];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x6327d(%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 0x1738(%rcx), %eax
jge 0x162b4
movq -0x18(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
movl -0x20(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x162a7
movq -0x18(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
movl -0x20(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x162bc
jmp 0x162a9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1625e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetCurrentWindow(ImGuiWindow*)
static void SetCurrentWindow(ImGuiWindow* window)
{
    ImGuiState& g = *GImGui;
    g.CurrentWindow = window;
    if (window)
        g.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x62f4d(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1758(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x165a2
movq -0x8(%rbp), %rdi
callq 0x2e440
movq -0x10(%rbp), %rax
movss %xmm0, 0x1718(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: PushClipRect(ImRect const&, bool)
static void PushClipRect(const ImRect& clip_rect, bool clipped)
{
    ImGuiWindow* window = ImGui::GetCurrentWindow();

    ImRect cr = clip_rect;
    if (clipped)
    {
        // Clip our argument with the current clip rect
        cr.Clip(window->ClipRect);
    }
    cr.Max.x = ImMax(cr.Min.x, cr.Max.x);
    cr.Max.y = ImMax(cr.Min.y, cr.Max.y);

    IM_ASSERT(cr.Min.x <= cr.Max.x && cr.Min.y <= cr.Max.y);
    window->ClipRect = cr;
    window->DrawList->PushClipRect(ImVec4(cr.Min.x, cr.Min.y, cr.Max.x, cr.Max.y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x2e220
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1694a
movq -0x18(%rbp), %rsi
addq $0x1e0, %rsi            # imm = 0x1E0
leaq -0x28(%rbp), %rdi
callq 0x2eb70
movss -0x28(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
callq 0xb7c0
movss %xmm0, -0x20(%rbp)
movss -0x24(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
callq 0xb7c0
movss %xmm0, -0x1c(%rbp)
movss -0x28(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x39(%rbp)
jb 0x16999
movss -0x24(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x169a2
jmp 0x169a4
jmp 0x169c3
leaq 0x4600f(%rip), %rdi     # 0x5c9ba
leaq 0x44913(%rip), %rsi     # 0x5b2c5
movl $0x8cd, %edx            # imm = 0x8CD
leaq 0x46029(%rip), %rcx     # 0x5c9e7
callq 0x7160
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x1e0(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x1e8(%rax)
movq -0x18(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x48(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
movss -0x20(%rbp), %xmm2
movss -0x1c(%rbp), %xmm3
leaq -0x38(%rbp), %rdi
callq 0x2d2b0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3d140
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetVisibleRect()
static ImRect GetVisibleRect()
{
    ImGuiState& g = *GImGui;
    if (g.IO.DisplayVisibleMin.x != g.IO.DisplayVisibleMax.x && g.IO.DisplayVisibleMin.y != g.IO.DisplayVisibleMax.y)
        return ImRect(g.IO.DisplayVisibleMin, g.IO.DisplayVisibleMax);
    return ImRect(0.0f, 0.0f, g.IO.DisplaySize.x, g.IO.DisplaySize.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x62a91(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss 0xa8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0xb0(%rax), %xmm0
jne 0x16a50
jp 0x16a50
jmp 0x16a96
movq -0x18(%rbp), %rax
movss 0xac(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0xb4(%rax), %xmm0
jne 0x16a6d
jp 0x16a6d
jmp 0x16a96
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0xa0, %rsi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
addq $0xa8, %rdx
leaq -0x10(%rbp), %rdi
callq 0x2eb40
jmp 0x16ab7
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm3
leaq -0x10(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2f230
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogFinish()
void ImGui::LogFinish()
{
    ImGuiState& g = *GImGui;
    if (!g.LogEnabled)
        return;

    ImGui::LogText(IM_NEWLINE);
    g.LogEnabled = false;
    if (g.LogFile != NULL)
    {
        if (g.LogFile == stdout)
            fflush(g.LogFile);
        else
            fclose(g.LogFile);
        g.LogFile = NULL;
    }
    if (g.LogClipboard->size() > 1)
    {
        if (g.IO.SetClipboardTextFn)
            g.IO.SetClipboardTextFn(g.LogClipboard->begin());
        g.LogClipboard->clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x60fd1(%rip), %rax     # 0x794c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2be8(%rax)
jne 0x18505
jmp 0x185cf
leaq 0x46d41(%rip), %rdi     # 0x5f24d
movb $0x0, %al
callq 0x10010
movq -0x8(%rbp), %rax
movb $0x0, 0x2be8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2bf0(%rax)
je 0x18574
movq -0x8(%rbp), %rax
movq 0x2bf0(%rax), %rax
movq 0x60a92(%rip), %rcx     # 0x78fd0
cmpq (%rcx), %rax
jne 0x18555
movq -0x8(%rbp), %rax
movq 0x2bf0(%rax), %rdi
callq 0x73f0
jmp 0x18565
movq -0x8(%rbp), %rax
movq 0x2bf0(%rax), %rdi
callq 0x7390
movq -0x8(%rbp), %rax
movq $0x0, 0x2bf0(%rax)
movq -0x8(%rbp), %rax
movq 0x2bf8(%rax), %rdi
callq 0x2fd70
cmpl $0x1, %eax
jle 0x185cf
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x185bf
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x2bf8(%rax), %rdi
callq 0x2fd90
movq %rax, %rdi
movq -0x10(%rbp), %rax
callq *%rax
movq -0x8(%rbp), %rax
movq 0x2bf8(%rax), %rdi
callq 0x2fdb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemWidth()
float ImGui::CalcItemWidth()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    float w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        // Align to a right-side limit. We include 1 frame padding in the calculation because this is how the width is always used (we add 2 frame padding to it), but we could move that responsibility to the widget as well.
        ImGuiState& g = *GImGui;
        float width_to_right_edge = ImGui::GetContentRegionAvail().x;
        w = ImMax(1.0f, width_to_right_edge + w - g.Style.FramePadding.x * 2.0f);
    }
    w = (float)(int)w;
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x2e290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x11c(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x18667
movq 0x60eae(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
callq 0x15d60
movlpd %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
addss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss 0x1408(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
addss %xmm1, %xmm1
addss %xmm0, %xmm1
movss 0x429bb(%rip), %xmm0    # 0x5b018
callq 0xb7c0
movss %xmm0, -0xc(%rbp)
cvttss2si -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushFont(ImFont*)
void ImGui::PushFont(ImFont* font)
{
    ImGuiState& g = *GImGui;
    if (!font)
        font = g.IO.Fonts->Fonts[0];
    SetCurrentFont(font);
    g.FontStack.push_back(font);
    g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x60e2d(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x186bb
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x2e330
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdde0
movq -0x10(%rbp), %rdi
addq $0x17e8, %rdi           # imm = 0x17E8
leaq -0x8(%rbp), %rsi
callq 0x2f830
movq -0x10(%rbp), %rax
movq 0x1758(%rax), %rax
movq 0x270(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x3d2c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopFont()
void  ImGui::PopFont()
{
    ImGuiState& g = *GImGui;
    g.CurrentWindow->DrawList->PopTextureID();
    g.FontStack.pop_back();
    SetCurrentFont(g.FontStack.empty() ? g.IO.Fonts->Fonts[0] : g.FontStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x60db1(%rip), %rax     # 0x794c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1758(%rax), %rax
movq 0x270(%rax), %rdi
callq 0x3d300
movq -0x8(%rbp), %rdi
addq $0x17e8, %rdi           # imm = 0x17E8
callq 0x2f890
movq -0x8(%rbp), %rdi
addq $0x17e8, %rdi           # imm = 0x17E8
callq 0x2f8e0
testb $0x1, %al
jne 0x18750
jmp 0x1876f
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x2e330
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x18786
movq -0x8(%rbp), %rdi
addq $0x17e8, %rdi           # imm = 0x17E8
callq 0x2f900
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdde0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetStyleVarFloatAddr(int)
static float* GetStyleVarFloatAddr(ImGuiStyleVar idx)
{
    ImGuiState& g = *GImGui;
    switch (idx)
    {
    case ImGuiStyleVar_Alpha: return &g.Style.Alpha;
    case ImGuiStyleVar_WindowRounding: return &g.Style.WindowRounding;
    case ImGuiStyleVar_ChildWindowRounding: return &g.Style.ChildWindowRounding;
    case ImGuiStyleVar_FrameRounding: return &g.Style.FrameRounding;
    case ImGuiStyleVar_IndentSpacing: return &g.Style.IndentSpacing;
    case ImGuiStyleVar_GrabMinSize: return &g.Style.GrabMinSize;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq 0x60a92(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0xa, %rax
ja 0x18acb
movq -0x20(%rbp), %rax
leaq 0x4272a(%rip), %rcx     # 0x5b178
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
movq %rax, -0x8(%rbp)
jmp 0x18ad3
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x14, %rax
movq %rax, -0x8(%rbp)
jmp 0x18ad3
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x1c, %rax
movq %rax, -0x8(%rbp)
jmp 0x18ad3
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x18ad3
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x48, %rax
movq %rax, -0x8(%rbp)
jmp 0x18ad3
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x58, %rax
movq %rax, -0x8(%rbp)
jmp 0x18ad3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    ImGuiState& g = *GImGui;
    ImVec2* pvar = GetStyleVarVec2Addr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a ImVec2.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = *pvar;
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x609ca(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x18b70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x18b0f
jmp 0x18b2e
leaq 0x42f6a(%rip), %rdi     # 0x5ba80
leaq 0x427a8(%rip), %rsi     # 0x5b2c5
movl $0x10ef, %edx           # imm = 0x10EF
leaq 0x42f95(%rip), %rcx     # 0x5babe
callq 0x7160
leaq -0x2c(%rbp), %rdi
callq 0x2fbe0
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x17d8, %rdi           # imm = 0x17D8
leaq -0x2c(%rbp), %rsi
callq 0x2fc00
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetStyleVarVec2Addr(int)
static ImVec2* GetStyleVarVec2Addr(ImGuiStyleVar idx)
{
    ImGuiState& g = *GImGui;
    switch (idx)
    {
    case ImGuiStyleVar_WindowPadding: return &g.Style.WindowPadding;
    case ImGuiStyleVar_WindowMinSize: return &g.Style.WindowMinSize;
    case ImGuiStyleVar_FramePadding: return &g.Style.FramePadding;
    case ImGuiStyleVar_ItemSpacing: return &g.Style.ItemSpacing;
    case ImGuiStyleVar_ItemInnerSpacing: return &g.Style.ItemInnerSpacing;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq 0x60942(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x18c0a
movq -0x20(%rbp), %rax
leaq 0x42607(%rip), %rcx     # 0x5b1a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x18c12
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0xc, %rax
movq %rax, -0x8(%rbp)
jmp 0x18c12
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x18c12
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x2c, %rax
movq %rax, -0x8(%rbp)
jmp 0x18c12
movq -0x18(%rbp), %rax
addq $0x13e8, %rax           # imm = 0x13E8
addq $0x34, %rax
movq %rax, -0x8(%rbp)
jmp 0x18c12
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowPos(ImGuiWindow*, ImVec2 const&, int)
static void SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
        return;
    window->SetWindowPosAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);
    window->SetWindowPosCenterWanted = false;

    // Set
    const ImVec2 old_pos = window->Pos;
    window->PosFloat = pos;
    window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
    window->DC.CursorPos += (window->Pos - old_pos);    // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
    window->DC.CursorMaxPos += (window->Pos - old_pos); // And more importantly we need to adjust this so size calculation doesn't get affected.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x19110
movq -0x8(%rbp), %rax
movl 0x94(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x19110
jmp 0x191d6
movq -0x8(%rbp), %rax
movl 0x94(%rax), %ecx
andl $-0xf, %ecx
movl %ecx, 0x94(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
movss 0x14(%rax), %xmm1
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
leaq -0x28(%rbp), %rdi
callq 0x2d280
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x40(%rbp)
callq 0xdf20
movlpd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xe4f0
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0xdf20
movlpd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
callq 0xe4f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowSize(ImGuiWindow*, ImVec2 const&, int)
static void SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
        return;
    window->SetWindowSizeAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1924c
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x1924c
jmp 0x192f5
movq -0x8(%rbp), %rax
movl 0x98(%rax), %ecx
andl $-0xf, %ecx
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x19290
movq -0x8(%rbp), %rax
movl $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
jmp 0x192a9
movq -0x8(%rbp), %rax
movl $0x2, 0x80(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x88(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x192dc
movq -0x8(%rbp), %rax
movl $0x0, 0x84(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2c(%rax)
jmp 0x192f5
movq -0x8(%rbp), %rax
movl $0x2, 0x84(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x88(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: SetWindowCollapsed(ImGuiWindow*, bool, int)
static void SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiSetCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowCollapsedAllowFlags & cond) == 0)
        return;
    window->SetWindowCollapsedAllowFlags &= ~(ImGuiSetCond_Once | ImGuiSetCond_FirstUseEver | ImGuiSetCond_Appearing);

    // Set
    window->Collapsed = collapsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x1936d
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0x1936d
jmp 0x1938d
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %ecx
andl $-0xf, %ecx
movl %ecx, 0x9c(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x73(%rax)
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetWindowFocus(char const*)
void ImGui::SetWindowFocus(const char* name)
{
    if (name)
    {
        ImGuiWindow* window = FindWindowByName(name);
        if (window)
            FocusWindow(window);
    }
    else
    {
        FocusWindow(NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x19432
movq -0x8(%rbp), %rdi
callq 0x16230
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x19430
movq -0x10(%rbp), %rdi
callq 0xef00
jmp 0x1943b
xorl %eax, %eax
movl %eax, %edi
callq 0xef00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetWindowContentRegionMax()
ImVec2 ImGui::GetWindowContentRegionMax()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImVec2 content_region_size = ImVec2(window->SizeContentsExplicit.x ? window->SizeContentsExplicit.x : window->Size.x, window->SizeContentsExplicit.y ? window->SizeContentsExplicit.y : window->Size.y);
    ImVec2 m = content_region_size - window->Scroll - window->WindowPadding - window->ScrollbarSizes;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x2e290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x198d6
jp 0x198d6
jmp 0x198e6
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x198f4
movq -0x10(%rbp), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movss 0x3c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x19913
jp 0x19913
jmp 0x19923
movq -0x10(%rbp), %rax
movss 0x3c(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x19931
movq -0x10(%rbp), %rax
movss 0x24(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x30(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2d280
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4c, %rsi
callq 0xdf20
movlpd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
leaq -0x28(%rbp), %rdi
callq 0xdf20
movlpd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
leaq -0x20(%rbp), %rdi
callq 0xdf20
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetWindowFontScale(float)
void ImGui::SetWindowFontScale(float scale)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->FontWindowScale = scale;
    g.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq 0x5f9cc(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
callq 0x2e220
movq %rax, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x268(%rax)
movq -0x18(%rbp), %rdi
callq 0x2e440
movq -0x10(%rbp), %rax
movss %xmm0, 0x1718(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SetScrollFromPosY(float, float)
void ImGui::SetScrollFromPosY(float pos_y, float center_y_ratio)
{
    // We store a target position so centering can occur on the next frame when we are guaranteed to have a known window size
    ImGuiWindow* window = GetCurrentWindow();
    IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
    window->ScrollTarget.y = (float)(int)(pos_y + window->Scroll.y);
    if (center_y_ratio <= 0.0f && window->ScrollTarget.y <= window->WindowPadding.y)    // Minor hack to make "scroll to top" take account of WindowPadding, else it would scroll to (WindowPadding.y - ItemSpacing.y)
        window->ScrollTarget.y = 0.0f;
    window->ScrollTargetCenterRatio.y = center_y_ratio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
callq 0x2e220
movq %rax, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rbp)
jb 0x19f9f
movss 0x41083(%rip), %xmm0    # 0x5b018
ucomiss -0x8(%rbp), %xmm0
setae %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x19fa8
jmp 0x19faa
jmp 0x19fc9
leaq 0x41d77(%rip), %rdi     # 0x5bd28
leaq 0x4130d(%rip), %rsi     # 0x5b2c5
movl $0x12d4, %edx           # imm = 0x12D4
leaq 0x41d95(%rip), %rcx     # 0x5bd59
callq 0x7160
movss -0x4(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss 0x50(%rax), %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x58(%rax)
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jb 0x1a014
movq -0x10(%rbp), %rax
movss 0x58(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x44(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x1a014
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x58(%rax)
movss -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::TextV(char const*, __va_list_tag*)
void ImGui::TextV(const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    TextUnformatted(g.TempBuffer, text_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2e220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x1a1b5
jmp 0x1a20f
movq 0x5f304(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x2df2, %rax           # imm = 0x2DF2
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x2df2, %rdi           # imm = 0x2DF2
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xc01, %esi            # imm = 0xC01
callq 0x9680
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x2df2, %rdi           # imm = 0x2DF2
movq -0x28(%rbp), %rsi
callq 0xf8c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::AlignFirstTextHeightToWidgets()
void ImGui::AlignFirstTextHeightToWidgets()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    // Declare a dummy item size to that upcoming items that are smaller will center-align on the newly expanded line height.
    ImGuiState& g = *GImGui;
    ItemSize(ImVec2(0, g.FontSize + g.Style.FramePadding.y*2), g.Style.FramePadding.y);
    ImGui::SameLine(0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x2e220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x1a57d
jmp 0x1a5d4
movq 0x5ef3c(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x1718(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x140c(%rax), %xmm1
addss %xmm1, %xmm1
addss %xmm0, %xmm1
leaq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2d280
movq -0x10(%rbp), %rax
movss 0x140c(%rax), %xmm0
leaq -0x18(%rbp), %rdi
callq 0xbeb0
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x1a5e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SameLine(float, float)
void ImGui::SameLine(float local_pos_x, float spacing_w)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiState& g = *GImGui;
    float x, y;
    if (local_pos_x != 0.0f)
    {
        if (spacing_w < 0.0f) spacing_w = 0.0f;
        x = window->Pos.x - window->Scroll.x + local_pos_x + spacing_w;
        y = window->DC.CursorPosPrevLine.y;
    }
    else
    {
        if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
        x = window->DC.CursorPosPrevLine.x + spacing_w;
        y = window->DC.CursorPosPrevLine.y;
    }
    window->DC.CurrentLineHeight = window->DC.PrevLineHeight;
    window->DC.CurrentLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
    window->DC.CursorPos = ImVec2(x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
callq 0x2e220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x1a60a
jmp 0x1a6fe
movq 0x5eeaf(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1a626
jp 0x1a626
jmp 0x1a66b
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x1a637
xorps %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x4c(%rax), %xmm0
addss -0x4(%rbp), %xmm0
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss 0xb4(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x1a6ac
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x1a685
movq -0x18(%rbp), %rax
movss 0x1414(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movss 0xb0(%rax), %xmm0
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss 0xb4(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0xd0(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc8(%rax)
movq -0x10(%rbp), %rax
movss 0xd4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xcc(%rax)
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
leaq -0x28(%rbp), %rdi
callq 0x2d280
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0xa8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::SmallButton(char const*)
bool ImGui::SmallButton(const char* label)
{
    ImGuiState& g = *GImGui;
    float backup_padding_y = g.Style.FramePadding.y;
    g.Style.FramePadding.y = 0.0f;
    bool pressed = ButtonEx(label, ImVec2(0,0), ImGuiButtonFlags_AlignTextBaseLine);
    g.Style.FramePadding.y = backup_padding_y;
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5e76d(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x140c(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x140c(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x40, %edx
callq 0x1aa80
andb $0x1, %al
movb %al, -0x15(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x140c(%rax)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::InvisibleButton(char const*, ImVec2 const&)
bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    const ImGuiID id = window->GetID(str_id);
    ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(bb);
    if (!ItemAdd(bb, &id))
        return false;

    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, true);

    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x2e220
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x74(%rax)
je 0x1adfc
movb $0x0, -0x1(%rbp)
jmp 0x1aeab
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbc60
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0xc690
movlpd %xmm0, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x60(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0xc7e0
movq -0x60(%rbp), %rsi
movlpd %xmm0, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x2eb40
leaq -0x48(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xc060
leaq -0x48(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xc0a0
testb $0x1, %al
jne 0x1ae81
movb $0x0, -0x1(%rbp)
jmp 0x1aeab
movl -0x24(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq -0x51(%rbp), %rdx
leaq -0x52(%rbp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x17010
andb $0x1, %al
movb %al, -0x53(%rbp)
movb -0x53(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToTTY(int)
void ImGui::LogToTTY(int max_depth)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    g.LogEnabled = true;
    g.LogFile = stdout;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x5df2e(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x2be8(%rax)
je 0x1b5a5
jmp 0x1b5f5
callq 0x2e290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x2be8(%rax)
movq 0x5da10(%rip), %rax     # 0x78fd0
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2bf0(%rax)
movq -0x18(%rbp), %rax
movl 0xdc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c00(%rax)
cmpl $0x0, -0x4(%rbp)
jl 0x1b5f5
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c04(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToFile(int, char const*)
void ImGui::LogToFile(int max_depth, const char* filename)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    if (!filename)
    {
        filename = g.IO.LogFilename;
        if (!filename)
            return;
    }

    g.LogFile = fopen(filename, "ab");
    if (!g.LogFile)
    {
        IM_ASSERT(g.LogFile != NULL); // Consider this an error
        return;
    }
    g.LogEnabled = true;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x5deaa(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x2be8(%rax)
je 0x1b62c
jmp 0x1b6e5
callq 0x2e290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b656
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b654
jmp 0x1b6e5
jmp 0x1b656
movq -0x10(%rbp), %rdi
leaq 0x40531(%rip), %rsi     # 0x5bb92
callq 0x7910
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x2bf0(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2bf0(%rax)
jne 0x1b6b3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2bf0(%rax)
je 0x1b692
jmp 0x1b6b1
leaq 0x4073a(%rip), %rdi     # 0x5bdd3
leaq 0x3fc25(%rip), %rsi     # 0x5b2c5
movl $0x14e4, %edx           # imm = 0x14E4
leaq 0x4073b(%rip), %rcx     # 0x5bde7
callq 0x7160
jmp 0x1b6e5
movq -0x18(%rbp), %rax
movb $0x1, 0x2be8(%rax)
movq -0x20(%rbp), %rax
movl 0xdc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c00(%rax)
cmpl $0x0, -0x4(%rbp)
jl 0x1b6e5
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c04(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogToClipboard(int)
void ImGui::LogToClipboard(int max_depth)
{
    ImGuiState& g = *GImGui;
    if (g.LogEnabled)
        return;
    ImGuiWindow* window = GetCurrentWindowRead();

    g.LogEnabled = true;
    g.LogFile = NULL;
    g.LogStartDepth = window->DC.TreeDepth;
    if (max_depth >= 0)
        g.LogAutoExpandMaxDepth = max_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x5ddbe(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x2be8(%rax)
je 0x1b715
jmp 0x1b75f
callq 0x2e290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x2be8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x2bf0(%rax)
movq -0x18(%rbp), %rax
movl 0xdc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c00(%rax)
cmpl $0x0, -0x4(%rbp)
jl 0x1b75f
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c04(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)