LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::FocusWindow(ImGuiWindow*)
void ImGui::FocusWindow(ImGuiWindow* window)
{
    ImGuiState& g = *GImGui;

    // Always mark the window we passed as focused. This is used for keyboard interactions such as tabbing.
    g.FocusedWindow = window;

    // Passing NULL allow to disable keyboard focus
    if (!window)
        return;

    // And move its root window to the top of the pile
    if (window->RootWindow)
        window = window->RootWindow;

    // Steal focus on active widgets
    if (window->Flags & ImGuiWindowFlags_Popup) // FIXME: This statement should be unnecessary. Need further testing before removing it..
        if (g.ActiveId != 0 && g.ActiveIdWindow && g.ActiveIdWindow->RootWindow != window)
            ImGui::SetActiveID(0);

    if (g.Windows.back() == window)
        return;

    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i] == window)
        {
            g.Windows.erase(g.Windows.begin() + i);
            break;
        }
    g.Windows.push_back(window);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6a5ad(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1770(%rax)
cmpq $0x0, -0x8(%rbp)
jne 0xef32
jmp 0xf048
movq -0x8(%rbp), %rax
cmpq $0x0, 0x278(%rax)
je 0xef4f
movq -0x8(%rbp), %rax
movq 0x278(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0xefa0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1790(%rax)
je 0xef9e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x17a0(%rax)
je 0xef9e
movq -0x10(%rbp), %rax
movq 0x17a0(%rax), %rax
movq 0x278(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0xef9e
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xbe60
jmp 0xefa0
movq -0x10(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
callq 0x2ef30
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xefbe
jmp 0xf048
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1738(%rcx), %eax
jge 0xf034
movq -0x10(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
movl -0x14(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xf027
movq -0x10(%rbp), %rax
addq $0x1738, %rax           # imm = 0x1738
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
callq 0x2f6e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x2f5e0
jmp 0xf034
jmp 0xf029
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xefc5
movq -0x10(%rbp), %rdi
addq $0x1738, %rdi           # imm = 0x1738
leaq -0x8(%rbp), %rsi
callq 0x2ef90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowToSortedBuffer(ImVector<ImGuiWindow*>&, ImGuiWindow*)
static void AddWindowToSortedBuffer(ImVector<ImGuiWindow*>& out_sorted_windows, ImGuiWindow* window)
{
    out_sorted_windows.push_back(window);
    if (window->Active)
    {
        int count = window->DC.ChildWindows.Size;
        if (count > 1)
            qsort(window->DC.ChildWindows.begin(), (size_t)count, sizeof(ImGuiWindow*), ChildWindowComparer);
        for (int i = 0; i < count; i++)
        {
            ImGuiWindow* child = window->DC.ChildWindows[i];
            if (child->Active)
                AddWindowToSortedBuffer(out_sorted_windows, child);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2ef90
movq -0x10(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0xf10d
movq -0x10(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0xf0ba
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
addq $0x58, %rdi
callq 0x2f6e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
movl $0x8, %edx
leaq 0x1bfdb(%rip), %rcx     # 0x2b090
callq 0x7560
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xf10b
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
addq $0x58, %rdi
movl -0x18(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0xf0fe
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf050
jmp 0xf100
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf0c1
jmp 0xf10d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddWindowToRenderList(ImVector<ImDrawList*>&, ImGuiWindow*)
static void AddWindowToRenderList(ImVector<ImDrawList*>& out_render_list, ImGuiWindow* window)
{
    AddDrawListToRenderList(out_render_list, window->DrawList);
    for (int i = 0; i < window->DC.ChildWindows.Size; i++)
    {
        ImGuiWindow* child = window->DC.ChildWindows[i];
        if (!child->Active) // clipped children may have been marked not active
            continue;
        if ((child->Flags & ImGuiWindowFlags_Popup) && child->HiddenFrames > 0)
            continue;
        AddWindowToRenderList(out_render_list, child);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x270(%rax), %rsi
callq 0xff40
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x100(%rcx), %eax
jge 0xff2c
movq -0x10(%rbp), %rdi
addq $0xa8, %rdi
addq $0x58, %rdi
movl -0x14(%rbp), %esi
callq 0x2e1c0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x70(%rax)
jne 0xfef4
jmp 0xff21
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0xff14
movq -0x20(%rbp), %rax
cmpl $0x0, 0x90(%rax)
jle 0xff14
jmp 0xff21
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xfe90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfebb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: AddDrawListToRenderList(ImVector<ImDrawList*>&, ImDrawList*)
static void AddDrawListToRenderList(ImVector<ImDrawList*>& out_render_list, ImDrawList* draw_list)
{
    if (!draw_list->CmdBuffer.empty() && !draw_list->VtxBuffer.empty())
    {
        if (draw_list->CmdBuffer.back().ElemCount == 0)
            draw_list->CmdBuffer.pop_back();
        out_render_list.push_back(draw_list);

        // Check that draw_list doesn't use more vertices than indexable (default ImDrawIdx = 2 bytes = 64K vertices)
        // If this assert triggers because you are drawing lots of stuff manually, A) workaround by calling BeginChild()/EndChild() to put your draw commands in multiple draw lists, B) #define ImDrawIdx to a 'unsigned int' in imconfig.h and render accordingly.
        const unsigned long long int max_vtx_idx = (unsigned long long int)1L << (sizeof(ImDrawIdx)*8);
        IM_ASSERT((unsigned long long int)draw_list->_VtxCurrentIdx <= max_vtx_idx);

        GImGui->IO.MetricsRenderVertices += draw_list->VtxBuffer.Size;
        GImGui->IO.MetricsRenderIndices += draw_list->IdxBuffer.Size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30fe0
testb $0x1, %al
jne 0x10006
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2ea20
testb $0x1, %al
jne 0x10006
movq -0x10(%rbp), %rdi
callq 0x31000
cmpl $0x0, (%rax)
jne 0xff8d
movq -0x10(%rbp), %rdi
callq 0x31060
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x310b0
movq $0x10000, -0x18(%rbp)   # imm = 0x10000
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
cmpq $0x10000, %rax          # imm = 0x10000
ja 0xffb3
jmp 0xffd2
leaq 0x4c79d(%rip), %rdi     # 0x5c757
leaq 0x4b304(%rip), %rsi     # 0x5b2c5
movl $0x8ab, %edx            # imm = 0x8AB
leaq 0x4c7cb(%rip), %rcx     # 0x5c798
callq 0x7160
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq 0x694e0(%rip), %rax     # 0x794c0
addl 0x338(%rax), %ecx
movl %ecx, 0x338(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq 0x694c6(%rip), %rax     # 0x794c0
addl 0x33c(%rax), %ecx
movl %ecx, 0x33c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogText(char const*, ...)
void ImGui::LogText(const char* fmt, ...)
{
    ImGuiState& g = *GImGui;
    if (!g.LogEnabled)
        return;

    va_list args;
    va_start(args, fmt);
    if (g.LogFile)
    {
        vfprintf(g.LogFile, fmt, args);
    }
    else
    {
        g.LogClipboard->appendv(fmt, args);
    }
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x10048
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x6944a(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x2be8(%rax)
jne 0x10089
jmp 0x100f1
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2bf0(%rax)
je 0x100d5
movq -0x10(%rbp), %rax
movq 0x2bf0(%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x7820
jmp 0x100ed
movq -0x10(%rbp), %rax
movq 0x2bf8(%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xb3c0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderText(ImVec2, char const*, char const*, bool)
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

    // Hide anything after a '##' string
    const char* text_display_end;
    if (hide_text_after_hash)
    {
        text_display_end = FindTextDisplayEnd(text, text_end);
    }
    else
    {
        if (!text_end)
            text_end = text + strlen(text); // FIXME-OPT
        text_display_end = text_end;
    }

    const int text_len = (int)(text_display_end - text);
    if (text_len > 0)
    {
        // Render
        window->DrawList->AddText(g.Font, g.FontSize, pos, window->Color(ImGuiCol_Text), text, text_display_end);

        // Log as text
        if (g.LogEnabled)
            LogRenderedText(pos, text, text_display_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movlpd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq 0x6939d(%rip), %rax     # 0x794c0
movq %rax, -0x28(%rbp)
callq 0x2e220
movq %rax, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
je 0x10149
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10230
movq %rax, -0x38(%rbp)
jmp 0x10177
cmpq $0x0, -0x18(%rbp)
jne 0x1016f
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7330
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jle 0x1021e
movq -0x30(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq 0x1710(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movss 0x1718(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movss 0x4ae4c(%rip), %xmm0    # 0x5b018
callq 0x2ea40
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movss -0x4c(%rbp), %xmm0
movl %eax, %ecx
movq -0x10(%rbp), %r8
movq -0x38(%rbp), %r9
leaq -0x8(%rbp), %rdx
xorps %xmm1, %xmm1
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x40a90
movq -0x28(%rbp), %rax
testb $0x1, 0x2be8(%rax)
je 0x1021c
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x10320
jmp 0x1021e
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindTextDisplayEnd(char const*, char const*)
static const char*  FindTextDisplayEnd(const char* text, const char* text_end)
{
    const char* text_display_end = text;
    if (!text_end)
        text_end = (const char*)-1;

    ImGuiState& g = *GImGui;
    if (g.DisableHideTextAfterDoubleHash > 0)
    {
        while (text_display_end < text_end && *text_display_end != '\0')
            text_display_end++;
    }
    else
    {
        while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
            text_display_end++;
    }
    return text_display_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10256
movq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq 0x69263(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x17c4(%rax)
jle 0x102a8
jmp 0x10270
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x1028f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x10298
jmp 0x102a6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10270
jmp 0x1030b
jmp 0x102aa
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x22(%rbp)
jae 0x102f2
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x102f2
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x23, %ecx
movb %al, -0x23(%rbp)
jne 0x102ec
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x23, %eax
setne %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x102fb
jmp 0x10309
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x102aa
jmp 0x1030b
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderTextWrapped(ImVec2, char const*, char const*, float)
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

    if (!text_end)
        text_end = text + strlen(text); // FIXME-OPT

    const int text_len = (int)(text_end - text);
    if (text_len > 0)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, window->Color(ImGuiCol_Text), text, text_end, wrap_width);
        if (g.LogEnabled)
            LogRenderedText(pos, text, text_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm1, -0x1c(%rbp)
movq 0x68fbf(%rip), %rax     # 0x794c0
movq %rax, -0x28(%rbp)
callq 0x2e220
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10534
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7330
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x105dd
movq -0x30(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq 0x1710(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movss 0x1718(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movss 0x4aa8f(%rip), %xmm0    # 0x5b018
callq 0x2ea40
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movss -0x44(%rbp), %xmm0
movl %eax, %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movss -0x1c(%rbp), %xmm1
leaq -0x8(%rbp), %rdx
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x40a90
movq -0x28(%rbp), %rax
testb $0x1, 0x2be8(%rax)
je 0x105db
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x10320
jmp 0x105dd
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcTextSize(char const*, char const*, bool, float)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
    ImGuiState& g = *GImGui;

    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindTextDisplayEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;

    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);

    // Cancel out character spacing for the last character of a line (it is baked into glyph->XAdvance field)
    const float font_scale = font_size / font->FontSize;
    const float character_spacing_x = 1.0f * font_scale;
    if (text_size.x > 0.0f)
        text_size.x -= character_spacing_x;

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movss %xmm0, -0x20(%rbp)
movq 0x68b6d(%rip), %rax     # 0x794c0
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x10970
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10230
movq %rax, -0x30(%rbp)
jmp 0x10978
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x1710(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movss 0x1718(%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movss -0x3c(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movss 0x4a6e2(%rip), %xmm1    # 0x5b09c
callq 0x45f00
movlpd %xmm0, -0x8(%rbp)
movss -0x3c(%rbp), %xmm0
movq -0x38(%rbp), %rax
divss (%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movss 0x4a63a(%rip), %xmm0    # 0x5b018
mulss -0x40(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x10a08
movss -0x44(%rbp), %xmm1
movss -0x8(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderFrame(ImVec2, ImVec2, unsigned int, bool, float)
void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
    ImGuiWindow* window = GetCurrentWindow();

    window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
    if (border && (window->Flags & ImGuiWindowFlags_ShowBorders))
    {
        window->DrawList->AddRect(p_min+ImVec2(1,1), p_max, window->Color(ImGuiCol_BorderShadow), rounding);
        window->DrawList->AddRect(p_min, p_max-ImVec2(1,1), window->Color(ImGuiCol_Border), rounding);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movlpd %xmm0, -0x8(%rbp)
movlpd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movss %xmm2, -0x1c(%rbp)
callq 0x2e220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x270(%rax), %rdi
movl -0x14(%rbp), %ecx
movss -0x1c(%rbp), %xmm0
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0xf, %r8d
callq 0x40670
testb $0x1, -0x15(%rbp)
je 0x10b73
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x10b73
movq -0x28(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movss 0x4a566(%rip), %xmm1    # 0x5b018
movss %xmm1, -0x64(%rbp)
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x78(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xc7e0
movaps %xmm0, %xmm1
movss -0x64(%rbp), %xmm0
movlpd %xmm1, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl $0x5, %esi
callq 0x2ea40
movq -0x70(%rbp), %rdi
movl %eax, %ecx
movss -0x1c(%rbp), %xmm0
leaq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movq %rdx, -0x60(%rbp)
movl $0xf, %r8d
callq 0x40590
movss -0x64(%rbp), %xmm1
movq -0x28(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xdf20
movlpd %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movl $0x4, %esi
movss 0x4a4c8(%rip), %xmm0    # 0x5b018
callq 0x2ea40
movq -0x50(%rbp), %rdi
movl %eax, %ecx
movss -0x1c(%rbp), %xmm0
leaq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movl $0xf, %r8d
callq 0x40590
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderCheckMark(ImVec2, unsigned int)
void ImGui::RenderCheckMark(ImVec2 pos, ImU32 col)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();

    ImVec2 a, b, c;
    float start_x = (float)(int)(g.FontSize * 0.307f + 0.5f);
    float rem_third = (float)(int)((g.FontSize - start_x) / 3.0f);
    a.x = pos.x + 0.5f + start_x;
    b.x = a.x + rem_third;
    c.x = a.x + rem_third * 3.0f;
    b.y = pos.y - 1.0f + (float)(int)(g.Font->Ascent * (g.FontSize / g.Font->FontSize) + 0.5f) + (float)(int)(g.Font->DisplayOffset.y);
    a.y = b.y - rem_third;
    c.y = b.y - rem_third * 2.0f;

    window->DrawList->PathLineTo(a);
    window->DrawList->PathLineTo(b);
    window->DrawList->PathLineTo(c);
    window->DrawList->PathStroke(col, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movlpd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq 0x68489(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
callq 0x2e220
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d230
leaq -0x30(%rbp), %rdi
callq 0x2d230
leaq -0x38(%rbp), %rdi
callq 0x2d230
movq -0x18(%rbp), %rax
movss 0x1718(%rax), %xmm0
movss 0x4a059(%rip), %xmm1    # 0x5b0cc
mulss %xmm1, %xmm0
movss 0x49fa5(%rip), %xmm1    # 0x5b024
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movss 0x1718(%rax), %xmm0
subss -0x3c(%rbp), %xmm0
movss 0x49fcb(%rip), %xmm1    # 0x5b074
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x40(%rbp)
movss 0x49f62(%rip), %xmm0    # 0x5b024
addss -0x8(%rbp), %xmm0
addss -0x3c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
addss -0x40(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x28(%rbp), %xmm1
movss -0x40(%rbp), %xmm0
movss 0x49f82(%rip), %xmm2    # 0x5b074
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x49f0c(%rip), %xmm1    # 0x5b018
subss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movq 0x1710(%rax), %rax
movss 0x24(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x1718(%rax), %xmm2
movq -0x18(%rbp), %rax
movq 0x1710(%rax), %rax
divss (%rax), %xmm2
mulss %xmm2, %xmm1
movss 0x49edd(%rip), %xmm2    # 0x5b024
addss %xmm2, %xmm1
cvttss2si %xmm1, %eax
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movq 0x1710(%rax), %rax
cvttss2si 0xc(%rax), %eax
cvtsi2ss %eax, %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
subss -0x40(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x40(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x270(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2eab0
movq -0x20(%rbp), %rax
movq 0x270(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2eab0
movq -0x20(%rbp), %rax
movq 0x270(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2eab0
movq -0x20(%rbp), %rax
movq 0x270(%rax), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
movss 0x49e1d(%rip), %xmm0    # 0x5b018
callq 0x2eae0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcListClipping(int, float, int*, int*)
void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();
    if (g.LogEnabled)
    {
        // If logging is active, do not perform any clipping
        *out_items_display_start = 0;
        *out_items_display_end = items_count;
        return;
    }

    const ImVec2 pos = window->DC.CursorPos;
    int start = (int)((window->ClipRect.Min.y - pos.y) / items_height);
    int end = (int)((window->ClipRect.Max.y - pos.y) / items_height);
    start = ImClamp(start, 0, items_count);
    end = ImClamp(end + 1, start, items_count);
    *out_items_display_start = start;
    *out_items_display_end = end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x68291(%rip), %rax     # 0x794c0
movq %rax, -0x20(%rbp)
callq 0x2e290
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x2be8(%rax)
je 0x1125e
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x112dd
movq -0x28(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movss 0x1e4(%rax), %xmm0
subss -0x2c(%rbp), %xmm0
divss -0x8(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movss 0x1ec(%rax), %xmm0
subss -0x2c(%rbp), %xmm0
divss -0x8(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %edi
movl -0x4(%rbp), %edx
xorl %esi, %esi
callq 0x112f0
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %edi
addl $0x1, %edi
movl -0x34(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x112f0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsKeyPressed(int, bool)
bool ImGui::IsKeyPressed(int key_index, bool repeat)
{
    ImGuiState& g = *GImGui;
    if (key_index < 0) return false;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[key_index];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
        if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x67ff6(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x114dd
movb $0x0, -0x1(%rbp)
jmp 0x11607
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x25(%rbp)
jl 0x114f5
cmpl $0x200, -0x8(%rbp)      # imm = 0x200
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x114fe
jmp 0x11500
jmp 0x1151f
leaq 0x4a13d(%rip), %rdi     # 0x5b644
leaq 0x49db7(%rip), %rsi     # 0x5b2c5
movl $0xae8, %edx            # imm = 0xAE8
leaq 0x4a17e(%rip), %rcx     # 0x5b698
callq 0x7160
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0x3e4(%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1154d
jp 0x1154d
movb $0x1, -0x1(%rbp)
jmp 0x11607
testb $0x1, -0x9(%rbp)
je 0x11603
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x80(%rax), %xmm0
jbe 0x11603
movq -0x18(%rbp), %rax
movss 0x80(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x84(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x1c(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x7930
movss 0x49a79(%rip), %xmm1    # 0x5b024
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movss -0x1c(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x10(%rax), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x7930
movl -0x2c(%rbp), %eax
movss 0x49a3e(%rip), %xmm1    # 0x5b024
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x11601
movb $0x1, -0x1(%rbp)
jmp 0x11607
jmp 0x11603
movb $0x0, -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::IsKeyReleased(int)
bool ImGui::IsKeyReleased(int key_index)
{
    ImGuiState& g = *GImGui;
    if (key_index < 0) return false;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    if (g.IO.KeysDownDurationPrev[key_index] >= 0.0f && !g.IO.KeysDown[key_index])
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0x67e8e(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x11642
movb $0x0, -0x1(%rbp)
jmp 0x116b9
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jl 0x1165a
cmpl $0x200, -0x8(%rbp)      # imm = 0x200
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x11663
jmp 0x11665
jmp 0x11684
leaq 0x49fd8(%rip), %rdi     # 0x5b644
leaq 0x49c52(%rip), %rsi     # 0x5b2c5
movl $0xafa, %edx            # imm = 0xAFA
leaq 0x4a03d(%rip), %rcx     # 0x5b6bc
callq 0x7160
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0xbe4(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x116b5
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
testb $0x1, 0x108(%rax,%rcx)
jne 0x116b5
movb $0x1, -0x1(%rbp)
jmp 0x116b9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseClicked(int, bool)
bool ImGui::IsMouseClicked(int button, bool repeat)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    const float t = g.IO.MouseDownDuration[button];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
        if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
            return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x67d66(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x25(%rbp)
jl 0x11773
cmpl $0x5, -0x8(%rbp)
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x1177c
jmp 0x1177e
jmp 0x1179d
leaq 0x49f56(%rip), %rdi     # 0x5b6db
leaq 0x49b39(%rip), %rsi     # 0x5b2c5
movl $0xb0a, %edx            # imm = 0xB0A
leaq 0x49fb0(%rip), %rcx     # 0x5b748
callq 0x7160
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0x3a8(%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x117cb
jp 0x117cb
movb $0x1, -0x1(%rbp)
jmp 0x11885
testb $0x1, -0x9(%rbp)
je 0x11881
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x80(%rax), %xmm0
jbe 0x11881
movq -0x18(%rbp), %rax
movss 0x80(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x84(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x1c(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x7930
movss 0x497fb(%rip), %xmm1    # 0x5b024
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movss -0x1c(%rbp), %xmm0
subss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x10(%rax), %xmm0
movss -0x24(%rbp), %xmm1
callq 0x7930
movl -0x2c(%rbp), %eax
movss 0x497c0(%rip), %xmm1    # 0x5b024
mulss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x1187f
movb $0x1, -0x1(%rbp)
jmp 0x11885
jmp 0x11881
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseDragging(int, float)
bool ImGui::IsMouseDragging(int button, float lock_threshold)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (!g.IO.MouseDown[button])
        return false;
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    return g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq 0x67b39(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
jl 0x119a0
cmpl $0x5, -0x8(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x119a9
jmp 0x119ab
jmp 0x119ca
leaq 0x49d29(%rip), %rdi     # 0x5b6db
leaq 0x4990c(%rip), %rsi     # 0x5b2c5
movl $0xb2a, %edx            # imm = 0xB2A
leaq 0x49df0(%rip), %rcx     # 0x5b7b5
callq 0x7160
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
testb $0x1, 0xf8(%rax,%rcx)
jne 0x119e2
movb $0x0, -0x1(%rbp)
jmp 0x11a1f
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x119f9
movq -0x18(%rbp), %rax
movss 0x30(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0x3d0(%rax,%rcx,4), %xmm0
movss -0xc(%rbp), %xmm1
mulss -0xc(%rbp), %xmm1
ucomiss %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetMousePosOnOpeningCurrentPopup()
ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup()
{
    ImGuiState& g = *GImGui;
    if (g.CurrentPopupStack.Size > 0)
        return g.OpenedPopupStack[g.CurrentPopupStack.Size-1].MousePosOnOpen;
    return g.IO.MousePos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x67a61(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1808(%rax)
jle 0x11a97
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movq -0x10(%rbp), %rax
movl 0x1808(%rax), %esi
subl $0x1, %esi
callq 0x2eca0
movq 0x1c(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11aa6
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetMouseDragDelta(int, float)
ImVec2 ImGui::GetMouseDragDelta(int button, float lock_threshold)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    if (g.IO.MouseDown[button])
        if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
            return g.IO.MousePos - g.IO.MouseClickedPos[button];     // Assume we can only get active with left-mouse button (at the moment).
    return ImVec2(0.0f, 0.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq 0x679e9(%rip), %rax     # 0x794c0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jl 0x11af0
cmpl $0x5, -0xc(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x11af9
jmp 0x11afb
jmp 0x11b1a
leaq 0x49bd9(%rip), %rdi     # 0x5b6db
leaq 0x497bc(%rip), %rsi     # 0x5b2c5
movl $0xb43, %edx            # imm = 0xB43
leaq 0x49cc8(%rip), %rcx     # 0x5b7dd
callq 0x7160
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x11b31
movq -0x18(%rbp), %rax
movss 0x30(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
testb $0x1, 0xf8(%rax,%rcx)
je 0x11b8b
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x3d0(%rax,%rcx,4), %xmm0
movss -0x10(%rbp), %xmm1
mulss -0x10(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x11b89
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0xf0, %rdi
movslq -0xc(%rbp), %rcx
leaq 0x35c(%rax,%rcx,8), %rsi
callq 0xdf20
movlpd %xmm0, -0x8(%rbp)
jmp 0x11b9a
jmp 0x11b8b
leaq -0x8(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ResetMouseDragDelta(int)
void ImGui::ResetMouseDragDelta(int button)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    // NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
    g.IO.MouseClickedPos[button] = g.IO.MousePos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x678fe(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x11(%rbp)
jl 0x11bdb
cmpl $0x5, -0x4(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x11be4
jmp 0x11be6
jmp 0x11c05
leaq 0x49aee(%rip), %rdi     # 0x5b6db
leaq 0x496d1(%rip), %rsi     # 0x5b2c5
movl $0xb4f, %edx            # imm = 0xB4F
leaq 0x49c09(%rip), %rcx     # 0x5b809
callq 0x7160
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0xf0(%rdx), %rdx
movq %rdx, 0x35c(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsItemActive()
bool ImGui::IsItemActive()
{
    ImGuiState& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = GetCurrentWindowRead();
        return g.ActiveId == window->DC.LastItemID;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x677a1(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1790(%rax)
je 0x11d57
callq 0x2e290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1790(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xe0(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11d5b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemRectClosestPoint(ImVec2 const&, bool, float)
ImVec2 ImGui::CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge, float outward)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImRect rect = window->DC.LastItemRect;
    rect.Expand(outward);
    return rect.GetClosestPoint(pos, on_edge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movss %xmm0, -0x18(%rbp)
callq 0x2e290
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movups 0xe4(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movss -0x18(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2ed00
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
callq 0x2ed60
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::OpenPopup(char const*)
void ImGui::OpenPopup(const char* str_id)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetID(str_id);
    int current_stack_size = g.CurrentPopupStack.Size;
    ImGuiPopupRef popup_ref = ImGuiPopupRef(id, window, window->GetID("##menus"), g.IO.MousePos); // Tagged as new ref because constructor sets Window to NULL (we are passing the ParentWindow info here)
    if (g.OpenedPopupStack.Size < current_stack_size + 1)
        g.OpenedPopupStack.push_back(popup_ref);
    else if (g.OpenedPopupStack[current_stack_size].PopupID != id)
    {
        g.OpenedPopupStack.resize(current_stack_size+1);
        g.OpenedPopupStack[current_stack_size] = popup_ref;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6417d(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1758(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbc60
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1808(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x464fa(%rip), %rsi     # 0x5b88a
xorl %eax, %eax
movl %eax, %edx
callq 0xbc60
movl -0x54(%rbp), %esi
movq -0x50(%rbp), %rdx
movl %eax, %ecx
movq -0x10(%rbp), %r8
addq $0x8, %r8
addq $0xe8, %r8
leaq -0x48(%rbp), %rdi
callq 0x2ee40
movq -0x10(%rbp), %rax
movl 0x17f8(%rax), %eax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x153e4
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
leaq -0x48(%rbp), %rsi
callq 0x2eea0
jmp 0x1543a
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0x20(%rbp), %esi
callq 0x2eca0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x15438
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0x20(%rbp), %esi
addl $0x1, %esi
callq 0x2e4c0
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0x20(%rbp), %esi
callq 0x2eca0
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
movl $0x24, %edx
callq 0x7080
jmp 0x1543a
addq $0x60, %rsp
popq %rbp
retq
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CloseCurrentPopup()
void ImGui::CloseCurrentPopup()
{
    ImGuiState& g = *GImGui;
    int popup_idx = g.CurrentPopupStack.Size - 1;
    if (popup_idx < 0 || popup_idx > g.OpenedPopupStack.Size || g.CurrentPopupStack[popup_idx].PopupID != g.OpenedPopupStack[popup_idx].PopupID)
        return;
    while (popup_idx > 0 && g.OpenedPopupStack[popup_idx].Window && (g.OpenedPopupStack[popup_idx].Window->Flags & ImGuiWindowFlags_ChildMenu))
        popup_idx--;
    ClosePopupToLevel(popup_idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x64071(%rip), %rax     # 0x794c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x1808(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x154ad
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x17f8(%rcx), %eax
jg 0x154ad
movq -0x8(%rbp), %rdi
addq $0x1808, %rdi           # imm = 0x1808
movl -0xc(%rbp), %esi
callq 0x2eca0
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0xc(%rbp), %esi
callq 0x2eca0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
je 0x154af
jmp 0x15522
jmp 0x154b1
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jle 0x15506
movq -0x8(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0xc(%rbp), %esi
callq 0x2eca0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x11(%rbp)
je 0x15506
movq -0x8(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0xc(%rbp), %esi
callq 0x2eca0
movq 0x8(%rax), %rax
movl 0xc(%rax), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1550f
jmp 0x1551a
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x154b1
movl -0xc(%rbp), %edi
callq 0x15530
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ClosePopupToLevel(int)
static void ClosePopupToLevel(int remaining)
{
    ImGuiState& g = *GImGui;
    if (remaining > 0)
        ImGui::FocusWindow(g.OpenedPopupStack[remaining-1].Window);
    else
        ImGui::FocusWindow(g.OpenedPopupStack[0].ParentWindow);
    g.OpenedPopupStack.resize(remaining);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x63f7e(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x1556d
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0x4(%rbp), %esi
subl $0x1, %esi
callq 0x2eca0
movq 0x8(%rax), %rdi
callq 0xef00
jmp 0x15588
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
xorl %esi, %esi
callq 0x2eca0
movq 0x10(%rax), %rdi
callq 0xef00
movq -0x10(%rbp), %rdi
addq $0x17f8, %rdi           # imm = 0x17F8
movl -0x4(%rbp), %esi
callq 0x2e4c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupModal(char const*, bool*, int)
bool ImGui::BeginPopupModal(const char* name, bool* p_opened, ImGuiWindowFlags extra_flags)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(name);
    if (!IsPopupOpen(id))
    {
        ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
        return false;
    }

    ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_Modal|ImGuiWindowFlags_NoCollapse|ImGuiWindowFlags_NoSavedSettings;
    bool opened = ImGui::Begin(name, p_opened, ImVec2(0.0f, 0.0f), -1.0f, flags);
    if (!opened || (p_opened && !*p_opened)) // Opened can be 'false' when the popup is completely clipped (e.g. zero size display)
    {
        ImGui::EndPopup();
        if (opened)
            ClosePopup(id);
        return false;
    }

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq 0x63d66(%rip), %rax     # 0x794c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1758(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbc60
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x15840
testb $0x1, %al
jne 0x1579b
callq 0x158b0
movb $0x0, -0x1(%rbp)
jmp 0x1582a
movl -0x1c(%rbp), %eax
orl $0x2000000, %eax        # imm = 0x2000000
orl $0x4000000, %eax        # imm = 0x4000000
orl $0x20, %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x44(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2d280
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x38(%rbp), %ecx
leaq -0x44(%rbp), %rdx
movss 0x45893(%rip), %xmm0    # 0x5b07c
callq 0x12020
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
je 0x15809
cmpq $0x0, -0x18(%rbp)
je 0x15822
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x15822
callq 0x15910
testb $0x1, -0x39(%rbp)
je 0x1581c
movl -0x34(%rbp), %edi
callq 0x159b0
movb $0x0, -0x1(%rbp)
jmp 0x1582a
movb -0x39(%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::EndPopup()
void ImGui::EndPopup()
{
    ImGuiWindow* window = GetCurrentWindow();
    IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup);
    IM_ASSERT(GImGui->CurrentPopupStack.Size > 0);
    ImGui::End();
    if (!(window->Flags & ImGuiWindowFlags_Modal))
        ImGui::PopStyleVar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x2e220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0x15934
jmp 0x15953
leaq 0x45f57(%rip), %rdi     # 0x5b892
leaq 0x45983(%rip), %rsi     # 0x5b2c5
movl $0xc71, %edx            # imm = 0xC71
leaq 0x45f6b(%rip), %rcx     # 0x5b8b9
callq 0x7160
movq 0x63b66(%rip), %rax     # 0x794c0
cmpl $0x0, 0x1808(%rax)
jle 0x15965
jmp 0x15984
leaq 0x45f64(%rip), %rdi     # 0x5b8d0
leaq 0x45952(%rip), %rsi     # 0x5b2c5
movl $0xc72, %edx            # imm = 0xC72
leaq 0x45f3a(%rip), %rcx     # 0x5b8b9
callq 0x7160
callq 0xee30
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
jne 0x159a4
movl $0x1, %edi
callq 0x159f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: donfreiday[P]gb/./imgui/imgui.cpp
// Function: ClosePopup(unsigned int)
static void ClosePopup(ImGuiID id)
{
    if (!IsPopupOpen(id))
        return;
    ImGuiState& g = *GImGui;
    ClosePopupToLevel(g.OpenedPopupStack.Size - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x15840
testb $0x1, %al
jne 0x159c9
jmp 0x159e6
movq 0x63af0(%rip), %rax     # 0x794c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x17f8(%rax), %edi
subl $0x1, %edi
callq 0x15530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)