LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupModal(char const*, bool*, int)
bool ImGui::BeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags flags)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(name);
    if (!IsPopupOpen(id, ImGuiPopupFlags_None))
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }

    // Center modal windows by default for increased visibility
    // (this won't really last as settings will kick in, and is mostly for backward compatibility. user may do the same themselves)
    // FIXME: Should test for (PosCond & window->SetWindowPosAllowFlags) with the upcoming window.
    if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)
        SetNextWindowPos(g.IO.DisplaySize * 0.5f, ImGuiCond_FirstUseEver, ImVec2(0.5f, 0.5f));

    flags |= ImGuiWindowFlags_Popup | ImGuiWindowFlags_Modal | ImGuiWindowFlags_NoCollapse;
    const bool is_open = Begin(name, p_open, flags);
    if (!is_open || (p_open && !*p_open)) // NB: is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
    {
        EndPopup();
        if (is_open)
            ClosePopupToLevel(g.BeginPopupStack.Size, true);
        return false;
    }
    return is_open;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq 0x1348a6(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
xorl %esi, %esi
callq 0xcbb60
testb $0x1, %al
jne 0xde6e8
movq -0x28(%rbp), %rdi
addq $0x1b88, %rdi           # imm = 0x1B88
callq 0xebb30
movb $0x0, -0x1(%rbp)
jmp 0xde79d
movq -0x28(%rbp), %rax
movl 0x1b88(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xde73a
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movss 0x938ce(%rip), %xmm0    # 0x171fd8
callq 0xc2f50
movlpd %xmm0, -0x3c(%rbp)
leaq -0x44(%rbp), %rdi
movss 0x938b8(%rip), %xmm1    # 0x171fd8
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x3c(%rbp), %rdi
movl $0x4, %esi
leaq -0x44(%rbp), %rdx
callq 0xdab40
movl -0x1c(%rbp), %eax
orl $0xc000020, %eax        # imm = 0xC000020
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xd0170
andb $0x1, %al
movb %al, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
je 0xde770
cmpq $0x0, -0x18(%rbp)
je 0xde795
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0xde795
callq 0xde4e0
testb $0x1, -0x45(%rbp)
je 0xde78f
movq -0x28(%rbp), %rax
movl 0x1c80(%rax), %edi
movl $0x1, %esi
callq 0xde1b0
movb $0x0, -0x1(%rbp)
jmp 0xde79d
movb -0x45(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::OpenPopupOnItemClick(char const*, int)
void ImGui::OpenPopupOnItemClick(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
    {
        ImGuiID id = str_id ? window->GetID(str_id) : window->DC.LastItemId; // If user hasn't passed an ID, we can use the LastItemID. Using LastItemID as a Popup ID won't conflict!
        IM_ASSERT(id != 0);                                                  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a Text() item)
        OpenPopupEx(id, popup_flags);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x13473a(%rip), %rax    # 0x212f40
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xd4e60
testb $0x1, %al
jne 0xde828
jmp 0xde89a
movl $0x8, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xde838
jmp 0xde89a
cmpq $0x0, -0x8(%rbp)
je 0xde855
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x24(%rbp)
jmp 0xde862
movq -0x18(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xde870
jmp 0xde88f
leaq 0x96c1c(%rip), %rdi     # 0x175493
leaq 0x9468b(%rip), %rsi     # 0x172f09
movl $0x1fef, %edx           # imm = 0x1FEF
leaq 0x96988(%rip), %rcx     # 0x175212
callq 0xd180
movl -0x20(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xdde50
addq $0x30, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupContextItem(char const*, int)
bool ImGui::BeginPopupContextItem(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (window->SkipItems)
        return false;
    ImGuiID id = str_id ? window->GetID(str_id) : window->DC.LastItemId; // If user hasn't passed an ID, we can use the LastItemID. Using LastItemID as a Popup ID won't conflict!
    IM_ASSERT(id != 0);                                                  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a Text() item)
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
        OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x13468a(%rip), %rax    # 0x212f40
movq 0x1ae0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0xde8d7
movb $0x0, -0x1(%rbp)
jmp 0xde972
cmpq $0x0, -0x10(%rbp)
je 0xde8f4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x2c(%rbp)
jmp 0xde901
movq -0x20(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xde90f
jmp 0xde92e
leaq 0x96b7d(%rip), %rdi     # 0x175493
leaq 0x945ec(%rip), %rsi     # 0x172f09
movl $0x1fff, %edx           # imm = 0x1FFF
leaq 0x96929(%rip), %rcx     # 0x175252
callq 0xd180
movl -0x14(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0xd4e60
testb $0x1, %al
jne 0xde945
jmp 0xde960
movl $0x8, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xde955
jmp 0xde960
movl -0x24(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0xdde50
movl -0x24(%rbp), %edi
movl $0x141, %esi            # imm = 0x141
callq 0xde410
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupContextWindow(char const*, int)
bool ImGui::BeginPopupContextWindow(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (!str_id)
        str_id = "window_context";
    ImGuiID id = window->GetID(str_id);
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
        if (!(popup_flags & ImGuiPopupFlags_NoOpenOverItems) || !IsAnyItemHovered())
            OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x1345aa(%rip), %rax    # 0x212f40
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xde9b3
leaq 0x968e4(%rip), %rax     # 0x175293
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0xd4e60
testb $0x1, %al
jne 0xde9de
jmp 0xdea0f
movl $0x8, %edi
callq 0xda3a0
testb $0x1, %al
jne 0xde9ee
jmp 0xdea0f
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xdea02
callq 0xd5640
testb $0x1, %al
jne 0xdea0d
movl -0x1c(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xdde50
jmp 0xdea0f
movl -0x1c(%rbp), %edi
movl $0x141, %esi            # imm = 0x141
callq 0xde410
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupContextVoid(char const*, int)
bool ImGui::BeginPopupContextVoid(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (!str_id)
        str_id = "void_context";
    ImGuiID id = window->GetID(str_id);
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && !IsWindowHovered(ImGuiHoveredFlags_AnyWindow))
        if (GetTopMostPopupModal() == NULL)
            OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x1344fa(%rip), %rax    # 0x212f40
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xdea63
leaq 0x96843(%rip), %rax     # 0x1752a2
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0xd4e60
testb $0x1, %al
jne 0xdea8e
jmp 0xdeab4
movl $0x4, %edi
callq 0xda3a0
testb $0x1, %al
jne 0xdeab4
callq 0xcbca0
cmpq $0x0, %rax
jne 0xdeab2
movl -0x1c(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xdde50
jmp 0xdeab4
movl -0x1c(%rbp), %edi
movl $0x141, %esi            # imm = 0x141
callq 0xde410
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetWindowAllowedExtentRect(ImGuiWindow*)
ImRect ImGui::GetWindowAllowedExtentRect(ImGuiWindow* window)
{
    IM_UNUSED(window);
    ImVec2 padding = GImGui->Style.DisplaySafeAreaPadding;
    ImRect r_screen = GetViewportRect();
    r_screen.Expand(ImVec2((r_screen.GetWidth() > padding.x * 2) ? -padding.x : 0.0f, (r_screen.GetHeight() > padding.y * 2) ? -padding.y : 0.0f));
    return r_screen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq 0x133d1d(%rip), %rax    # 0x212f40
movq 0x160c(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0xd7920
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xeb840
movss 0x92d7e(%rip), %xmm1    # 0x171fcc
mulss -0x20(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0xdf271
movss -0x20(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xdf27b
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0xdf27b
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xeb860
movss 0x92d36(%rip), %xmm1    # 0x171fcc
mulss -0x1c(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0xdf2b9
movss -0x1c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0xdf2c3
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0xdf2c3
movss -0x30(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xbf4c0
movq -0x40(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xe89d0
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNavID(unsigned int, int, unsigned int)
void ImGui::SetNavID(ImGuiID id, int nav_layer, ImGuiID focus_scope_id)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavWindow);
    IM_ASSERT(nav_layer == 0 || nav_layer == 1);
    g.NavId = id;
    g.NavFocusScopeId = focus_scope_id;
    g.NavWindow->NavLastIds[nav_layer] = id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x133c28(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
je 0xdf32c
jmp 0xdf34b
leaq 0x960dc(%rip), %rdi     # 0x17540f
leaq 0x93bcf(%rip), %rsi     # 0x172f09
movl $0x20a6, %edx           # imm = 0x20A6
leaq 0x95fba(%rip), %rcx     # 0x175300
callq 0xd180
movb $0x1, %al
cmpl $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0xdf360
cmpl $0x1, -0x8(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xdf369
jmp 0xdf36b
jmp 0xdf38a
leaq 0x95fba(%rip), %rdi     # 0x17532c
leaq 0x93b90(%rip), %rsi     # 0x172f09
movl $0x20a7, %edx           # imm = 0x20A7
leaq 0x95f7b(%rip), %rcx     # 0x175300
callq 0xd180
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c98(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c9c(%rax)
movl -0x4(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x1c90(%rax), %rax
movslq -0x8(%rbp), %rcx
movl %edx, 0x3b0(%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNavIDWithRectRel(unsigned int, int, unsigned int, ImRect const&)
void ImGui::SetNavIDWithRectRel(ImGuiID id, int nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel)
{
    ImGuiContext& g = *GImGui;
    SetNavID(id, nav_layer, focus_scope_id);
    g.NavWindow->NavRectRel[nav_layer] = rect_rel;
    g.NavMousePosDirty = true;
    g.NavDisableHighlight = false;
    g.NavDisableMouseHover = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq 0x133b54(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0xdf300
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x1c90(%rax), %rax
addq $0x3b8, %rax            # imm = 0x3B8
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x1ce5(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x1ce6(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x1ce7(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetFocusID(unsigned int, ImGuiWindow*)
void ImGui::SetFocusID(ImGuiID id, ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(id != 0);

    // Assume that SetFocusID() is called in the context where its window->DC.NavLayerCurrent and window->DC.NavFocusScopeIdCurrent are valid.
    // Note that window may be != g.CurrentWindow (e.g. SetFocusID call in InputTextEx for multi-line text)
    const ImGuiNavLayer nav_layer = window->DC.NavLayerCurrent;
    if (g.NavWindow != window)
        g.NavInitRequest = false;
    g.NavWindow = window;
    g.NavId = id;
    g.NavLayer = nav_layer;
    g.NavFocusScopeId = window->DC.NavFocusScopeIdCurrent;
    window->NavLastIds[nav_layer] = id;
    if (window->DC.LastItemId == id)
        window->NavRectRel[nav_layer] = ImRect(window->DC.LastItemRect.Min - window->Pos, window->DC.LastItemRect.Max - window->Pos);

    if (g.ActiveIdSource == ImGuiInputSource_Nav)
        g.NavDisableMouseHover = true;
    else
        g.NavDisableHighlight = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x133aca(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xdf482
jmp 0xdf4a1
leaq 0x9600a(%rip), %rdi     # 0x175493
leaq 0x93a79(%rip), %rsi     # 0x172f09
movl $0x20ba, %edx           # imm = 0x20BA
leaq 0x95eb1(%rip), %rcx     # 0x17534d
callq 0xd180
movq -0x10(%rbp), %rax
movl 0x14c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x1c90(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xdf4ca
movq -0x18(%rbp), %rax
movb $0x0, 0x1ce9(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x1c90(%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c98(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1cdc(%rax)
movq -0x10(%rbp), %rax
movl 0x158(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c9c(%rax)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, 0x3b0(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl 0x124(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xdf593
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x12c, %rdi            # imm = 0x12C
addq $0x10, %rsi
callq 0xc3c00
movlpd %xmm0, -0x34(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x134, %rdi            # imm = 0x134
addq $0x10, %rsi
callq 0xc3c00
movlpd %xmm0, -0x3c(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xe8660
movq -0x10(%rbp), %rax
addq $0x3b8, %rax            # imm = 0x3B8
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x2c(%rbp), %rcx
movq %rcx, (%rax)
movq -0x24(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1b68(%rax)
jne 0xdf5ad
movq -0x18(%rbp), %rax
movb $0x1, 0x1ce7(%rax)
jmp 0xdf5b8
movq -0x18(%rbp), %rax
movb $0x1, 0x1ce6(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavMoveRequestForward(int, int, ImRect const&, int)
void ImGui::NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect& bb_rel, ImGuiNavMoveFlags move_flags)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavMoveRequestForward == ImGuiNavForward_None);
    NavMoveRequestCancel();
    g.NavMoveDir = move_dir;
    g.NavMoveClipDir = clip_dir;
    g.NavMoveRequestForward = ImGuiNavForward_ForwardQueued;
    g.NavMoveRequestFlags = move_flags;
    g.NavWindow->NavRectRel[g.NavLayer] = bb_rel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq 0x133874(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1d08(%rax)
jne 0xdf6df
jmp 0xdf6fe
leaq 0x95c96(%rip), %rdi     # 0x17537c
leaq 0x9381c(%rip), %rsi     # 0x172f09
movl $0x21c7, %edx           # imm = 0x21C7
leaq 0x95cb3(%rip), %rcx     # 0x1753ac
callq 0xd180
callq 0xdf680
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1d10(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1d18(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x1d08(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1d04(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x1c90(%rax), %rax
addq $0x3b8, %rax            # imm = 0x3B8
movq -0x20(%rbp), %rdx
movl 0x1cdc(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::EndDragDropSource()
void ImGui::EndDragDropSource()
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.DragDropActive);
    IM_ASSERT(g.DragDropWithinSource && "Not after a BeginDragDropSource()?");

    if (!(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
        EndTooltip();

    // Discard the drag if have not called SetDragDropPayload()
    if (g.DragDropPayload.DataFrameCount == -1)
        ClearDragDrop();
    g.DragDropWithinSource = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x132fc1(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2004(%rax)
je 0xdff92
jmp 0xdffb1
leaq 0x93794(%rip), %rdi     # 0x17372d
leaq 0x92f69(%rip), %rsi     # 0x172f09
movl $0x259d, %edx           # imm = 0x259D
leaq 0x954ef(%rip), %rcx     # 0x17549b
callq 0xd180
movq -0x8(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x2005(%rcx)
movb %al, -0x9(%rbp)
je 0xdffca
movb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0xdffca
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xdffd3
jmp 0xdffd5
jmp 0xdfff4
leaq 0x95502(%rip), %rdi     # 0x1754de
leaq 0x92f26(%rip), %rsi     # 0x172f09
movl $0x259e, %edx           # imm = 0x259E
leaq 0x954ac(%rip), %rcx     # 0x17549b
callq 0xd180
movq -0x8(%rbp), %rax
movl 0x2008(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe000b
callq 0xddce0
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x202c(%rax)
jne 0xe001d
callq 0xd40c0
movq -0x8(%rbp), %rax
movb $0x0, 0x2005(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginDragDropTargetCustom(ImRect const&, unsigned int)
bool ImGui::BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    if (!g.DragDropActive)
        return false;

    ImGuiWindow* window = g.CurrentWindow;
    ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
    if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
        return false;
    IM_ASSERT(id != 0);
    if (!IsMouseHoveringRect(bb.Min, bb.Max) || (id == g.DragDropPayload.SourceId))
        return false;
    if (window->SkipItems)
        return false;

    IM_ASSERT(g.DragDropWithinTarget == false);
    g.DragDropTargetRect = bb;
    g.DragDropTargetId = id;
    g.DragDropWithinTarget = true;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x132c4a(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x2004(%rax)
jne 0xe0310
movb $0x0, -0x1(%rbp)
jmp 0xe0432
movq -0x20(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x1af8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xe034d
movq -0x28(%rbp), %rax
movq 0x390(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x390(%rcx), %rax
je 0xe0356
movb $0x0, -0x1(%rbp)
jmp 0xe0432
cmpl $0x0, -0x14(%rbp)
je 0xe035e
jmp 0xe037d
leaq 0x9512e(%rip), %rdi     # 0x175493
leaq 0x92b9d(%rip), %rsi     # 0x172f09
movl $0x25df, %edx           # imm = 0x25DF
leaq 0x95345(%rip), %rcx     # 0x1756bd
callq 0xd180
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0xca5f0
testb $0x1, %al
jne 0xe0399
jmp 0xe03a8
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x2024(%rcx), %eax
jne 0xe03b1
movb $0x0, -0x1(%rbp)
jmp 0xe0432
movq -0x28(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0xe03c4
movb $0x0, -0x1(%rbp)
jmp 0xe0432
movq -0x20(%rbp), %rax
movb 0x2006(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xe03da
jmp 0xe03f9
leaq 0x9531b(%rip), %rdi     # 0x1756fc
leaq 0x92b21(%rip), %rsi     # 0x172f09
movl $0x25e5, %edx           # imm = 0x25E5
leaq 0x952c9(%rip), %rcx     # 0x1756bd
callq 0xd180
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x2058(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2060(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2068(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x2006(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginDragDropTarget()
bool ImGui::BeginDragDropTarget()
{
    ImGuiContext& g = *GImGui;
    if (!g.DragDropActive)
        return false;

    ImGuiWindow* window = g.CurrentWindow;
    if (!(window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect))
        return false;
    ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
    if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
        return false;

    const ImRect& display_rect = (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect) ? window->DC.LastItemDisplayRect : window->DC.LastItemRect;
    ImGuiID id = window->DC.LastItemId;
    if (id == 0)
        id = window->GetIDFromRectangle(display_rect);
    if (g.DragDropPayload.SourceId == id)
        return false;

    IM_ASSERT(g.DragDropWithinTarget == false);
    g.DragDropTargetRect = display_rect;
    g.DragDropTargetId = id;
    g.DragDropWithinTarget = true;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x132af1(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x2004(%rax)
jne 0xe0469
movb $0x0, -0x1(%rbp)
jmp 0xe05b0
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x128(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe0493
movb $0x0, -0x1(%rbp)
jmp 0xe05b0
movq -0x10(%rbp), %rax
movq 0x1af8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe04c1
movq -0x18(%rbp), %rax
movq 0x390(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x390(%rcx), %rax
je 0xe04ca
movb $0x0, -0x1(%rbp)
jmp 0xe05b0
movq -0x18(%rbp), %rax
movl 0x128(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xe04f0
movq -0x18(%rbp), %rax
addq $0xd8, %rax
addq $0x64, %rax
movq %rax, -0x38(%rbp)
jmp 0xe0502
movq -0x18(%rbp), %rax
addq $0xd8, %rax
addq $0x54, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x124(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xe052d
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc9c90
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x2024(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0xe0542
movb $0x0, -0x1(%rbp)
jmp 0xe05b0
movq -0x10(%rbp), %rax
movb 0x2006(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xe0558
jmp 0xe0577
leaq 0x9519d(%rip), %rdi     # 0x1756fc
leaq 0x929a3(%rip), %rsi     # 0x172f09
movl $0x2604, %edx           # imm = 0x2604
leaq 0x951aa(%rip), %rcx     # 0x17571c
callq 0xd180
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x2058(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x2060(%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2068(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x2006(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::EndDragDropTarget()
void ImGui::EndDragDropTarget()
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.DragDropActive);
    IM_ASSERT(g.DragDropWithinTarget);
    g.DragDropWithinTarget = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x132581(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x2004(%rax)
je 0xe09d2
jmp 0xe09f1
leaq 0x92d54(%rip), %rdi     # 0x17372d
leaq 0x92529(%rip), %rsi     # 0x172f09
movl $0x2646, %edx           # imm = 0x2646
leaq 0x94dc2(%rip), %rcx     # 0x1757ae
callq 0xd180
movq -0x8(%rbp), %rax
testb $0x1, 0x2006(%rax)
je 0xe0a00
jmp 0xe0a1f
leaq 0x94dc7(%rip), %rdi     # 0x1757ce
leaq 0x924fb(%rip), %rsi     # 0x172f09
movl $0x2647, %edx           # imm = 0x2647
leaq 0x94d94(%rip), %rcx     # 0x1757ae
callq 0xd180
movq -0x8(%rbp), %rax
movb $0x0, 0x2006(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogText(char const*, ...)
void ImGui::LogText(const char* fmt, ...)
{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;

    va_list args;
    va_start(args, fmt);
    if (g.LogFile)
    {
        g.LogBuffer.Buf.resize(0);
        g.LogBuffer.appendfv(fmt, args);
        ImFileWrite(g.LogBuffer.c_str(), sizeof(char), (ImU64)g.LogBuffer.size(), g.LogFile);
    }
    else
    {
        g.LogBuffer.appendfv(fmt, args);
    }
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xe0a68
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 0x1324aa(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x3138(%rax)
jne 0xe0aac
jmp 0xe0b6c
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, 0x3140(%rax)
je 0xe0b50
movq -0x10(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
xorl %esi, %esi
callq 0xe84f0
movq -0x10(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc6c70
movq -0x10(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
callq 0xec270
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
callq 0xec2b0
movq -0xe8(%rbp), %rdi
movslq %eax, %rdx
movq -0x10(%rbp), %rax
movq 0x3140(%rax), %rcx
movl $0x1, %esi
callq 0xc5180
jmp 0xe0b68
movq -0x10(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc6c70
leaq -0x30(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogBegin(ImGuiLogType, int)
void ImGui::LogBegin(ImGuiLogType type, int auto_open_depth)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.LogEnabled == false);
    IM_ASSERT(g.LogFile == NULL);
    IM_ASSERT(g.LogBuffer.empty());
    g.LogEnabled = true;
    g.LogType = type;
    g.LogDepthRef = window->DC.TreeDepth;
    g.LogDepthToExpand = ((auto_open_depth >= 0) ? auto_open_depth : g.LogDepthToExpandDefault);
    g.LogLinePosY = FLT_MAX;
    g.LogLineFirstItem = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x1323ab(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb 0x3138(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xe0bbe
jmp 0xe0bdd
leaq 0x94c2f(%rip), %rdi     # 0x1757f4
leaq 0x9233d(%rip), %rsi     # 0x172f09
movl $0x26a1, %edx           # imm = 0x26A1
leaq 0x94c32(%rip), %rcx     # 0x17580a
callq 0xd180
movq -0x10(%rbp), %rax
cmpq $0x0, 0x3140(%rax)
jne 0xe0bed
jmp 0xe0c0c
leaq 0x94c3e(%rip), %rdi     # 0x175832
leaq 0x9230e(%rip), %rsi     # 0x172f09
movl $0x26a2, %edx           # imm = 0x26A2
leaq 0x94c03(%rip), %rcx     # 0x17580a
callq 0xd180
movq -0x10(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
callq 0xec2e0
testb $0x1, %al
jne 0xe0c22
jmp 0xe0c24
jmp 0xe0c43
leaq 0x94c1b(%rip), %rdi     # 0x175846
leaq 0x922d7(%rip), %rsi     # 0x172f09
movl $0x26a3, %edx           # imm = 0x26A3
leaq 0x94bcc(%rip), %rcx     # 0x17580a
callq 0xd180
movq -0x10(%rbp), %rax
movb $0x1, 0x3138(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x313c(%rax)
movq -0x18(%rbp), %rax
movl 0x18c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3160(%rax)
cmpl $0x0, -0x8(%rbp)
jl 0xe0c7d
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xe0c8a
movq -0x10(%rbp), %rax
movl 0x3168(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3164(%rax)
movq -0x10(%rbp), %rax
movss 0x91311(%rip), %xmm0    # 0x171fb4
movss %xmm0, 0x3158(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x315c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogToTTY(int)
void ImGui::LogToTTY(int auto_open_depth)
{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    IM_UNUSED(auto_open_depth);
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
    LogBegin(ImGuiLogType_TTY, auto_open_depth);
    g.LogFile = stdout;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x13226e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xe0ce5
jmp 0xe0d07
movl -0x4(%rbp), %esi
movl $0x1, %edi
callq 0xe0b80
movq 0x12d20f(%rip), %rax    # 0x20df08
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3140(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogToFile(int, char const*)
void ImGui::LogToFile(int auto_open_depth, const char* filename)
{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;

    // FIXME: We could probably open the file in text mode "at", however note that clipboard/buffer logging will still
    // be subject to outputting OS-incompatible carriage return if within strings the user doesn't use IM_NEWLINE.
    // By opening the file in binary mode "ab" we have consistent output everywhere.
    if (!filename)
        filename = g.IO.LogFilename;
    if (!filename || !filename[0])
        return;
    ImFileHandle f = ImFileOpen(filename, "ab");
    if (!f)
    {
        IM_ASSERT(0);
        return;
    }

    LogBegin(ImGuiLogType_File, auto_open_depth);
    g.LogFile = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x13221a(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xe0d39
jmp 0xe0db4
cmpq $0x0, -0x10(%rbp)
jne 0xe0d4c
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe0d5c
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xe0d5e
jmp 0xe0db4
movq -0x10(%rbp), %rdi
leaq 0x9280e(%rip), %rsi     # 0x173577
callq 0xc5050
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe0d98
leaq 0x9438a(%rip), %rdi     # 0x17510a
leaq 0x92182(%rip), %rsi     # 0x172f09
movl $0x26c9, %edx           # imm = 0x26C9
leaq 0x94ac7(%rip), %rcx     # 0x17585a
callq 0xd180
movl -0x4(%rbp), %esi
movl $0x2, %edi
callq 0xe0b80
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x3140(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogToClipboard(int)
void ImGui::LogToClipboard(int auto_open_depth)
{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    LogBegin(ImGuiLogType_Clipboard, auto_open_depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x13216e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xe0de5
jmp 0xe0df2
movl -0x4(%rbp), %esi
movl $0x4, %edi
callq 0xe0b80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogToBuffer(int)
void ImGui::LogToBuffer(int auto_open_depth)
{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    LogBegin(ImGuiLogType_Buffer, auto_open_depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x13212e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xe0e25
jmp 0xe0e32
movl -0x4(%rbp), %esi
movl $0x3, %edi
callq 0xe0b80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogButtons()
void ImGui::LogButtons()
{
    ImGuiContext& g = *GImGui;

    PushID("LogButtons");
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
    const bool log_to_tty = Button("Log To TTY"); SameLine();
#else
    const bool log_to_tty = false;
#endif
    const bool log_to_file = Button("Log To File"); SameLine();
    const bool log_to_clipboard = Button("Log To Clipboard"); SameLine();
    PushAllowKeyboardFocus(false);
    SetNextItemWidth(80.0f);
    SliderInt("Default Depth", &g.LogDepthToExpandDefault, 0, 9, NULL);
    PopAllowKeyboardFocus();
    PopID();

    // Start logging at the end of the function so that the buttons don't appear in the log
    if (log_to_tty)
        LogToTTY();
    if (log_to_file)
        LogToFile();
    if (log_to_clipboard)
        LogToClipboard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x1320f1(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
leaq 0x94a41(%rip), %rdi     # 0x17589b
callq 0xdb440
leaq -0x14(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq 0x94a31(%rip), %rdi     # 0x1758a6
leaq -0x14(%rbp), %rsi
callq 0x13a930
andb $0x1, %al
movb %al, -0x9(%rbp)
xorps %xmm0, %xmm0
movss 0x910f2(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq 0x94a08(%rip), %rdi     # 0x1758b1
leaq -0x20(%rbp), %rsi
callq 0x13a930
andb $0x1, %al
movb %al, -0x15(%rbp)
xorps %xmm0, %xmm0
movss 0x910be(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq -0x2c(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq 0x949e0(%rip), %rdi     # 0x1758bd
leaq -0x2c(%rbp), %rsi
callq 0x13a930
andb $0x1, %al
movb %al, -0x21(%rbp)
xorps %xmm0, %xmm0
movss 0x9108a(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
xorl %edi, %edi
callq 0xda240
movss 0x918c6(%rip), %xmm0    # 0x1727d0
callq 0xc6860
movq -0x8(%rbp), %rsi
addq $0x3168, %rsi           # imm = 0x3168
leaq 0x949ad(%rip), %rdi     # 0x1758ce
xorl %r9d, %r9d
movl $0x9, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl %r9d, %edx
callq 0x144b30
callq 0xda270
callq 0xdb640
testb $0x1, -0x9(%rbp)
je 0xe0f50
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xe0cc0
testb $0x1, -0x15(%rbp)
je 0xe0f64
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %esi
callq 0xe0d10
testb $0x1, -0x21(%rbp)
je 0xe0f74
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xe0dc0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CreateNewWindowSettings(char const*)
ImGuiWindowSettings* ImGui::CreateNewWindowSettings(const char* name)
{
    ImGuiContext& g = *GImGui;

#if !IMGUI_DEBUG_INI_SETTINGS
    // Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
    // Preserve the full string when IMGUI_DEBUG_INI_SETTINGS is set to make .ini inspection easier.
    if (const char* p = strstr(name, "###"))
        name = p;
#endif
    const size_t name_len = strlen(name);

    // Allocate chunk
    const size_t chunk_size = sizeof(ImGuiWindowSettings) + name_len + 1;
    ImGuiWindowSettings* settings = g.SettingsWindows.alloc_chunk(chunk_size);
    IM_PLACEMENT_NEW(settings) ImGuiWindowSettings();
    settings->ID = ImHashStr(name, name_len);
    memcpy(settings->GetName(), name, name_len + 1);   // Store with zero terminator

    return settings;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq 0x131f6d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x948fa(%rip), %rsi     # 0x1758dc
callq 0xd4d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe0ffa
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd410
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x11, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
movq -0x28(%rbp), %rsi
callq 0xec350
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movl $0x10, %edi
callq 0xe9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xec3d0
jmp 0xe104e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0xc4f20
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
callq 0xec410
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0xd0a0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xea550
movq -0x40(%rbp), %rdi
callq 0xd620
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindWindowSettings(unsigned int)
ImGuiWindowSettings* ImGui::FindWindowSettings(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
        if (settings->ID == id)
            return settings;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq 0x131e7e(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
callq 0xec430
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe1112
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xe10f6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe111a
jmp 0xe10f8
movq -0x18(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
movq -0x20(%rbp), %rsi
callq 0xec470
movq %rax, -0x20(%rbp)
jmp 0xe10da
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindSettingsHandler(char const*)
ImGuiSettingsHandler* ImGui::FindSettingsHandler(const char* type_name)
{
    ImGuiContext& g = *GImGui;
    const ImGuiID type_hash = ImHashStr(type_name);
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].TypeHash == type_hash)
            return &g.SettingsHandlers[handler_n];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x131dad(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xc4f20
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30f8(%rcx), %eax
jge 0xe1200
movq -0x18(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0x20(%rbp), %esi
callq 0xec5a0
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xe11f3
movq -0x18(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0x20(%rbp), %esi
callq 0xec5a0
movq %rax, -0x8(%rbp)
jmp 0xe1208
jmp 0xe11f5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe11b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ClearIniSettings()
void ImGui::ClearIniSettings()
{
    ImGuiContext& g = *GImGui;
    g.SettingsIniData.clear();
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].ClearAllFn)
            g.SettingsHandlers[handler_n].ClearAllFn(&g, &g.SettingsHandlers[handler_n]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x131d11(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
callq 0xeb160
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30f8(%rcx), %eax
jge 0xe12c3
movq -0x8(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0xc(%rbp), %esi
callq 0xec5a0
cmpq $0x0, 0x10(%rax)
je 0xe12b6
movq -0x8(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0xc(%rbp), %esi
callq 0xec5a0
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0xc(%rbp), %esi
callq 0xec5a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
callq *%rax
jmp 0xe12b8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe124a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LoadIniSettingsFromDisk(char const*)
void ImGui::LoadIniSettingsFromDisk(const char* ini_filename)
{
    size_t file_data_size = 0;
    char* file_data = (char*)ImFileLoadToMemory(ini_filename, "rb", &file_data_size);
    if (!file_data)
        return;
    LoadIniSettingsFromMemory(file_data, (size_t)file_data_size);
    IM_FREE(file_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x945f1(%rip), %rsi     # 0x1758e0
leaq -0x10(%rbp), %rdx
xorl %ecx, %ecx
callq 0xc51c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe1307
jmp 0xe131d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe1330
movq -0x18(%rbp), %rdi
callq 0xc4920
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SaveIniSettingsToMemory(unsigned long*)
const char* ImGui::SaveIniSettingsToMemory(size_t* out_size)
{
    ImGuiContext& g = *GImGui;
    g.SettingsDirtyTimer = 0.0f;
    g.SettingsIniData.Buf.resize(0);
    g.SettingsIniData.Buf.push_back(0);
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
    {
        ImGuiSettingsHandler* handler = &g.SettingsHandlers[handler_n];
        handler->WriteAllFn(&g, handler, &g.SettingsIniData);
    }
    if (out_size)
        *out_size = (size_t)g.SettingsIniData.size();
    return g.SettingsIniData.c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1317dd(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30e4(%rax)
movq -0x10(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
xorl %esi, %esi
callq 0xe84f0
movq -0x10(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
movb $0x0, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xec620
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30f8(%rcx), %eax
jge 0xe17f5
movq -0x10(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0x18(%rbp), %esi
callq 0xec5a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x30e8, %rdx           # imm = 0x30E8
callq *%rax
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe17a7
cmpq $0x0, -0x8(%rbp)
je 0xe1816
movq -0x10(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
callq 0xec2b0
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
callq 0xec270
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: MetricsHelpMarker(char const*)
static void MetricsHelpMarker(const char* desc)
{
    ImGui::TextDisabled("(?)");
    if (ImGui::IsItemHovered())
    {
        ImGui::BeginTooltip();
        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
        ImGui::TextUnformatted(desc);
        ImGui::PopTextWrapPos();
        ImGui::EndTooltip();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x94794(%rip), %rdi     # 0x1779f7
movb $0x0, %al
callq 0x1393f0
xorl %edi, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xe3277
jmp 0xe32a9
callq 0xddb50
callq 0xdae90
movss 0x8f557(%rip), %xmm1    # 0x1727e0
mulss %xmm1, %xmm0
callq 0xda2c0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x139130
callq 0xda310
callq 0xddce0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>*, char const*)
void ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label)
{
    if (!TreeNode(label, "%s (%d)", label, windows->Size))
        return;
    Text("(In front-to-back order:)");
    for (int i = windows->Size - 1; i >= 0; i--) // Iterate front to back
    {
        PushID((*windows)[i]);
        DebugNodeWindow((*windows)[i], "Window");
        PopID();
    }
    TreePop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x9612b(%rip), %rsi     # 0x179980
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe3862
jmp 0xe38c6
leaq 0x92dce(%rip), %rdi     # 0x176637
movb $0x0, %al
callq 0x139160
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xe38c1
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xea8d0
movq (%rax), %rdi
callq 0xdb500
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xea8d0
movq (%rax), %rdi
leaq 0x93e93(%rip), %rsi     # 0x17773f
callq 0xe4bc0
callq 0xdb640
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe387c
callq 0x1523d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)