LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ClampWindowRect(ImGuiWindow*, ImRect const&)
static inline void ClampWindowRect(ImGuiWindow* window, const ImRect& visibility_rect)
{
    ImGuiContext& g = *GImGui;
    ImVec2 size_for_clamping = window->Size;
    if (g.IO.ConfigWindowsMoveFromTitleBarOnly && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
        size_for_clamping.y = window->TitleBarHeight();
    window->Pos = ImClamp(window->Pos, visibility_rect.Min - size_for_clamping, visibility_rect.Max);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa97be(%rip), %rax     # 0xfdcd0
movss 0x1c(%rdi), %xmm2
cmpb $0x1, 0xcd(%rax)
jne 0x5455a
testb $0x1, 0xc(%rdi)
jne 0x5455a
movss 0x1984(%rax), %xmm0
mulss 0x2b0(%rdi), %xmm0
movq 0x388(%rdi), %rcx
testq %rcx, %rcx
je 0x5454a
mulss 0x2b0(%rcx), %xmm0
movss 0x159c(%rax), %xmm2
addss %xmm2, %xmm2
addss %xmm0, %xmm2
movss 0x18(%rdi), %xmm4
movss (%rsi), %xmm1
movss 0x4(%rsi), %xmm0
subss %xmm2, %xmm0
movsd 0x8(%rsi), %xmm3
movss 0x10(%rdi), %xmm2
movss 0x14(%rdi), %xmm5
ucomiss %xmm5, %xmm0
ja 0x5458b
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
minss %xmm5, %xmm0
subss %xmm4, %xmm1
minss %xmm2, %xmm3
cmpltss %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm3, %xmm2
orps %xmm1, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movlps %xmm2, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogFinish()
void ImGui::LogFinish()
{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;

    LogText(IM_NEWLINE);
    switch (g.LogType)
    {
    case ImGuiLogType_TTY:
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
        fflush(g.LogFile);
#endif
        break;
    case ImGuiLogType_File:
        ImFileClose(g.LogFile);
        break;
    case ImGuiLogType_Buffer:
        break;
    case ImGuiLogType_Clipboard:
        if (!g.LogBuffer.empty())
            SetClipboardText(g.LogBuffer.begin());
        break;
    case ImGuiLogType_None:
        IM_ASSERT(0);
        break;
    }

    g.LogEnabled = false;
    g.LogType = ImGuiLogType_None;
    g.LogFile = NULL;
    g.LogBuffer.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xa9560(%rip), %rbx     # 0xfdcd0
cmpb $0x1, 0x3138(%rbx)
jne 0x547b1
leaq 0x6f147(%rip), %rdi     # 0xc38c7
xorl %eax, %eax
callq 0x59e5b
movl 0x313c(%rbx), %eax
cmpq $0x4, %rax
ja 0x54800
leaq 0x6318a(%rip), %rcx     # 0xb7924
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x3140(%rbx), %rdi
callq 0xc450
jmp 0x54800
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x3140(%rbx), %rdi
callq 0xc3b0
jmp 0x54800
cmpl $0x2, 0x3148(%rbx)
jl 0x54800
movq 0xa94fa(%rip), %rcx     # 0xfdcd0
movq 0x108(%rcx), %rax
testq %rax, %rax
je 0x54800
movq 0x3150(%rbx), %rdx
testq %rdx, %rdx
leaq 0xa94e5(%rip), %rsi     # 0xfdcd8
cmovneq %rdx, %rsi
movq 0x110(%rcx), %rdi
callq *%rax
movb $0x0, 0x3138(%rbx)
movl $0x0, 0x313c(%rbx)
movq $0x0, 0x3140(%rbx)
addq $0x3148, %rbx           # imm = 0x3148
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f36e
leaq 0x658b4(%rip), %rdi     # 0xba0ec
leaq 0x63926(%rip), %rsi     # 0xb8165
leaq 0x65fcd(%rip), %rcx     # 0xba813
movl $0x26fa, %edx           # imm = 0x26FA
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStackSizes::CompareWithCurrentState()
void ImGuiStackSizes::CompareWithCurrentState()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_UNUSED(window);

    // Window stacks
    // NOT checking: DC.ItemWidth, DC.TextWrapPos (per window) to allow user to conveniently push once and not pop (they are cleared on Begin)
    IM_ASSERT(SizeOfIDStack         == window->IDStack.Size     && "PushID/PopID or TreeNode/TreePop Mismatch!");

    // Global stacks
    // For color, style and font stacks there is an incentive to use Push/Begin/Pop/.../End patterns, so we relax our checks a little to allow them.
    IM_ASSERT(SizeOfGroupStack      == g.GroupStack.Size        && "BeginGroup/EndGroup Mismatch!");
    IM_ASSERT(SizeOfBeginPopupStack == g.BeginPopupStack.Size   && "BeginPopup/EndPopup or BeginMenu/EndMenu Mismatch!");
    IM_ASSERT(SizeOfColorStack      >= g.ColorStack.Size        && "PushStyleColor/PopStyleColor Mismatch!");
    IM_ASSERT(SizeOfStyleVarStack   >= g.StyleVarStack.Size     && "PushStyleVar/PopStyleVar Mismatch!");
    IM_ASSERT(SizeOfFontStack       >= g.FontStack.Size         && "PushFont/PopFont Mismatch!");
    IM_ASSERT(SizeOfFocusScopeStack == g.FocusScopeStack.Size   && "PushFocusScope/PopFocusScope Mismatch!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa9475(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rcx
movswl (%rdi), %edx
cmpl %edx, 0xc8(%rcx)
jne 0x548cb
movswl 0xa(%rdi), %ecx
cmpl %ecx, 0x1c60(%rax)
jne 0x548ea
movswl 0xc(%rdi), %ecx
cmpl %ecx, 0x1c80(%rax)
jne 0x54909
movswl 0x2(%rdi), %ecx
cmpl %ecx, 0x1c10(%rax)
jg 0x54928
movswl 0x4(%rdi), %ecx
cmpl %ecx, 0x1c20(%rax)
jg 0x54947
movswl 0x6(%rdi), %ecx
cmpl %ecx, 0x1c30(%rax)
jg 0x54966
movswl 0x8(%rdi), %ecx
cmpl %ecx, 0x1c40(%rax)
jne 0x54985
popq %rbp
retq
leaq 0x6531e(%rip), %rdi     # 0xb9bf0
leaq 0x6388c(%rip), %rsi     # 0xb8165
leaq 0x65366(%rip), %rcx     # 0xb9c46
movl $0x1bcd, %edx           # imm = 0x1BCD
callq 0xc140
leaq 0x65385(%rip), %rdi     # 0xb9c76
leaq 0x6386d(%rip), %rsi     # 0xb8165
leaq 0x65347(%rip), %rcx     # 0xb9c46
movl $0x1bd1, %edx           # imm = 0x1BD1
callq 0xc140
leaq 0x653af(%rip), %rdi     # 0xb9cbf
leaq 0x6384e(%rip), %rsi     # 0xb8165
leaq 0x65328(%rip), %rcx     # 0xb9c46
movl $0x1bd2, %edx           # imm = 0x1BD2
callq 0xc140
leaq 0x653f8(%rip), %rdi     # 0xb9d27
leaq 0x6382f(%rip), %rsi     # 0xb8165
leaq 0x65309(%rip), %rcx     # 0xb9c46
movl $0x1bd3, %edx           # imm = 0x1BD3
callq 0xc140
leaq 0x6542b(%rip), %rdi     # 0xb9d79
leaq 0x63810(%rip), %rsi     # 0xb8165
leaq 0x652ea(%rip), %rcx     # 0xb9c46
movl $0x1bd4, %edx           # imm = 0x1BD4
callq 0xc140
leaq 0x65460(%rip), %rdi     # 0xb9dcd
leaq 0x637f1(%rip), %rsi     # 0xb8165
leaq 0x652cb(%rip), %rcx     # 0xb9c46
movl $0x1bd5, %edx           # imm = 0x1BD5
callq 0xc140
leaq 0x65485(%rip), %rdi     # 0xb9e11
leaq 0x637d2(%rip), %rsi     # 0xb8165
leaq 0x652ac(%rip), %rcx     # 0xb9c46
movl $0x1bd6, %edx           # imm = 0x1BD6
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BringWindowToFocusFront(ImGuiWindow*)
void ImGui::BringWindowToFocusFront(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    if (g.WindowsFocusOrder.back() == window)
        return;
    for (int i = g.WindowsFocusOrder.Size - 2; i >= 0; i--) // We can ignore the top-most window
        if (g.WindowsFocusOrder[i] == window)
        {
            memmove(&g.WindowsFocusOrder[i], &g.WindowsFocusOrder[i + 1], (size_t)(g.WindowsFocusOrder.Size - i - 1) * sizeof(ImGuiWindow*));
            g.WindowsFocusOrder[g.WindowsFocusOrder.Size - 1] = window;
            break;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa931e(%rip), %r14     # 0xfdcd0
movslq 0x1a98(%r14), %rax
testq %rax, %rax
jle 0x54a2f
movq %rdi, %rbx
movq 0x1aa0(%r14), %rcx
cmpq %rdi, -0x8(%rcx,%rax,8)
je 0x54a2a
cmpl $0x1, %eax
je 0x54a2a
leal -0x1(%rax), %esi
xorl %edx, %edx
leal -0x1(%rsi), %edi
cmpq %rbx, (%rcx,%rdi,8)
je 0x549ed
decq %rdx
movl %edi, %esi
testl %edi, %edi
jg 0x549d9
jmp 0x54a2a
cmpl %esi, %eax
jle 0x54a4e
leaq (%rcx,%rdi,8), %rdi
decl %eax
leaq (%rcx,%rax,8), %rax
leaq (%rax,%rdx,8), %rsi
movl $0x1, %eax
subl %edx, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0xc130
movslq 0x1a98(%r14), %rax
testq %rax, %rax
jle 0x54a4e
movq 0x1aa0(%r14), %rcx
movq %rbx, -0x8(%rcx,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7afa4(%rip), %rdi     # 0xcf9da
leaq 0x66c4e(%rip), %rsi     # 0xbb68b
leaq 0x68148(%rip), %rcx     # 0xbcb8c
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x66c23(%rip), %rdi     # 0xbb678
leaq 0x66c2f(%rip), %rsi     # 0xbb68b
leaq 0x68004(%rip), %rcx     # 0xbca67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BringWindowToDisplayFront(ImGuiWindow*)
void ImGui::BringWindowToDisplayFront(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* current_front_window = g.Windows.back();
    if (current_front_window == window || current_front_window->RootWindow == window) // Cheap early out (could be better)
        return;
    for (int i = g.Windows.Size - 2; i >= 0; i--) // We can ignore the top-most window
        if (g.Windows[i] == window)
        {
            memmove(&g.Windows[i], &g.Windows[i + 1], (size_t)(g.Windows.Size - i - 1) * sizeof(ImGuiWindow*));
            g.Windows[g.Windows.Size - 1] = window;
            break;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa9255(%rip), %r14     # 0xfdcd0
movslq 0x1a88(%r14), %rax
testq %rax, %rax
jle 0x54b04
movq %rdi, %rbx
movq 0x1a90(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdx
cmpq %rdi, %rdx
je 0x54aff
cmpq %rbx, 0x390(%rdx)
je 0x54aff
cmpl $0x1, %eax
je 0x54aff
leal -0x1(%rax), %esi
xorl %edx, %edx
leal -0x1(%rsi), %edi
cmpq %rbx, (%rcx,%rdi,8)
je 0x54ac2
decq %rdx
movl %edi, %esi
testl %edi, %edi
jg 0x54aae
jmp 0x54aff
cmpl %esi, %eax
jle 0x54b23
leaq (%rcx,%rdi,8), %rdi
decl %eax
leaq (%rcx,%rax,8), %rax
leaq (%rax,%rdx,8), %rsi
movl $0x1, %eax
subl %edx, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0xc130
movslq 0x1a88(%r14), %rax
testq %rax, %rax
jle 0x54b23
movq 0x1a90(%r14), %rcx
movq %rbx, -0x8(%rcx,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7aecf(%rip), %rdi     # 0xcf9da
leaq 0x66b79(%rip), %rsi     # 0xbb68b
leaq 0x68073(%rip), %rcx     # 0xbcb8c
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x66b4e(%rip), %rdi     # 0xbb678
leaq 0x66b5a(%rip), %rsi     # 0xbb68b
leaq 0x67f2f(%rip), %rcx     # 0xbca67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BringWindowToDisplayBack(ImGuiWindow*)
void ImGui::BringWindowToDisplayBack(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    if (g.Windows[0] == window)
        return;
    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i] == window)
        {
            memmove(&g.Windows[1], &g.Windows[0], (size_t)i * sizeof(ImGuiWindow*));
            g.Windows[0] = window;
            break;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa9180(%rip), %r14     # 0xfdcd0
movl 0x1a88(%r14), %eax
testl %eax, %eax
jle 0x54bac
movq %rdi, %rbx
movq 0x1a90(%r14), %rsi
cmpq %rdi, (%rsi)
je 0x54ba7
leaq (,%rax,8), %rcx
xorl %edx, %edx
cmpq %rbx, (%rsi,%rdx)
je 0x54b85
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x54b74
jmp 0x54ba7
cmpl $0x1, %eax
je 0x54bac
leaq 0x8(%rsi), %rdi
callq 0xc130
cmpl $0x0, 0x1a88(%r14)
jle 0x54bac
movq 0x1a90(%r14), %rax
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x66ac5(%rip), %rdi     # 0xbb678
leaq 0x66ad1(%rip), %rsi     # 0xbb68b
leaq 0x67ea6(%rip), %rcx     # 0xbca67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushFont(ImFont*)
void ImGui::PushFont(ImFont* font)
{
    ImGuiContext& g = *GImGui;
    if (!font)
        font = GetDefaultFont();
    SetCurrentFont(font);
    g.FontStack.push_back(font);
    g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xa90f0(%rip), %r15     # 0xfdcd0
testq %rdi, %rdi
jne 0x54c09
movq 0xb8(%r15), %rbx
testq %rbx, %rbx
jne 0x54c09
movq 0xa8(%r15), %rax
cmpl $0x0, 0x40(%rax)
jle 0x54d0e
movq 0x48(%rax), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x4c185
movl 0x1c30(%r15), %r12d
movl 0x1c34(%r15), %eax
cmpl %eax, %r12d
jne 0x54cd2
incl %r12d
testl %eax, %eax
je 0x54c3c
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x54c41
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x54cd2
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0xa9071(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x54c6a
incl 0x3b4(%rax)
movq 0xa906f(%rip), %rsi     # 0xfdce0
callq *0xa4899(%rip)          # 0xf9510
movq %rax, %r14
movq 0x1c38(%r15), %rsi
testq %rsi, %rsi
je 0x54cc4
movslq 0x1c30(%r15), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x1c38(%r15), %rdi
testq %rdi, %rdi
je 0x54cb7
movq 0xa9024(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x54cb7
decl 0x3b4(%rax)
movq 0xa9022(%rip), %rsi     # 0xfdce0
callq *0xa4854(%rip)          # 0xf9518
movq %r14, 0x1c38(%r15)
movl %r12d, 0x1c34(%r15)
movq 0x1c38(%r15), %rax
movslq 0x1c30(%r15), %rcx
movq %rbx, (%rax,%rcx,8)
incl 0x1c30(%r15)
movq 0x1ae0(%r15), %rax
movq 0x2b8(%rax), %rdi
movq 0x40(%rbx), %rax
movq 0x8(%rax), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x77348
leaq 0x66963(%rip), %rdi     # 0xbb678
leaq 0x6696f(%rip), %rsi     # 0xbb68b
leaq 0x6697e(%rip), %rcx     # 0xbb6a1
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopFont()
void  ImGui::PopFont()
{
    ImGuiContext& g = *GImGui;
    g.CurrentWindow->DrawList->PopTextureID();
    g.FontStack.pop_back();
    SetCurrentFont(g.FontStack.empty() ? GetDefaultFont() : g.FontStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xa8f96(%rip), %rbx     # 0xfdcd0
movq 0x1ae0(%rbx), %rax
movq 0x2b8(%rax), %rdi
callq 0x773ea
movl 0x1c30(%rbx), %eax
testl %eax, %eax
jle 0x54daf
movl %eax, %ecx
decl %ecx
movl %ecx, 0x1c30(%rbx)
je 0x54d7e
cmpl $0x1, %eax
je 0x54dce
movq 0x1c38(%rbx), %rax
movl %ecx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
movq (%rax), %rdi
jmp 0x54d91
movq 0xa8f4b(%rip), %rax     # 0xfdcd0
movq 0xb8(%rax), %rdi
testq %rdi, %rdi
je 0x54d9c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4c185
movq 0xa8(%rax), %rax
cmpl $0x0, 0x40(%rax)
jle 0x54ded
movq 0x48(%rax), %rax
jmp 0x54d79
leaq 0x7ac24(%rip), %rdi     # 0xcf9da
leaq 0x668ce(%rip), %rsi     # 0xbb68b
leaq 0x67f06(%rip), %rcx     # 0xbccca
movl $0x672, %edx            # imm = 0x672
callq 0xc140
leaq 0x7ac05(%rip), %rdi     # 0xcf9da
leaq 0x668af(%rip), %rsi     # 0xbb68b
leaq 0x67f1a(%rip), %rcx     # 0xbccfd
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x66884(%rip), %rdi     # 0xbb678
leaq 0x66890(%rip), %rsi     # 0xbb68b
leaq 0x6689f(%rip), %rcx     # 0xbb6a1
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushItemFlag(int, bool)
void ImGui::PushItemFlag(ImGuiItemFlags option, bool enabled)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiItemFlags item_flags = window->DC.ItemFlags;
    IM_ASSERT(item_flags == g.ItemFlagsStack.back());
    if (enabled)
        item_flags |= option;
    else
        item_flags &= ~option;
    window->DC.ItemFlags = item_flags;
    g.ItemFlagsStack.push_back(item_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xa8eb2(%rip), %r14     # 0xfdcd0
movslq 0x1c50(%r14), %r15
testq %r15, %r15
jle 0x54f38
movq 0x1ae0(%r14), %rax
movl 0x1cc(%rax), %r12d
movq 0x1c58(%r14), %rcx
cmpl -0x4(%rcx,%r15,4), %r12d
jne 0x54f57
movl %edi, %ecx
notl %ecx
andl %r12d, %ecx
orl %edi, %r12d
testb %sil, %sil
cmovel %ecx, %r12d
movl %r12d, 0x1cc(%rax)
movl 0x1c54(%r14), %eax
cmpl %eax, %r15d
jne 0x54f16
incl %r15d
testl %eax, %eax
je 0x54e8a
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x54e8f
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
cmpl %r15d, %eax
jge 0x54f16
movl %r15d, %edi
shlq $0x2, %rdi
testq %r14, %r14
je 0x54eae
incl 0x3b4(%r14)
movq 0xa8e2b(%rip), %rsi     # 0xfdce0
callq *0xa4655(%rip)          # 0xf9510
movq %rax, %rbx
movq 0x1c58(%r14), %rsi
testq %rsi, %rsi
je 0x54f08
movslq 0x1c50(%r14), %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
callq 0xc080
movq 0x1c58(%r14), %rdi
testq %rdi, %rdi
je 0x54efb
movq 0xa8de0(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x54efb
decl 0x3b4(%rax)
movq 0xa8dde(%rip), %rsi     # 0xfdce0
callq *0xa4610(%rip)          # 0xf9518
movq %rbx, 0x1c58(%r14)
movl %r15d, 0x1c54(%r14)
movq 0x1c58(%r14), %rax
movslq 0x1c50(%r14), %rcx
movl %r12d, (%rax,%rcx,4)
incl 0x1c50(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7aa9b(%rip), %rdi     # 0xcf9da
leaq 0x66745(%rip), %rsi     # 0xbb68b
leaq 0x67cde(%rip), %rcx     # 0xbcc2b
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x644a2(%rip), %rdi     # 0xb9400
leaq 0x63200(%rip), %rsi     # 0xb8165
leaq 0x644ba(%rip), %rcx     # 0xb9426
movl $0x18df, %edx           # imm = 0x18DF
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopItemFlag()
void ImGui::PopItemFlag()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.ItemFlagsStack.Size > 1); // Too many calls to PopItemFlag() - we always leave a 0 at the bottom of the stack.
    g.ItemFlagsStack.pop_back();
    window->DC.ItemFlags = g.ItemFlagsStack.back();
}

// Assembly:
movq 0xa8d53(%rip), %rcx     # 0xfdcd0
movl 0x1c50(%rcx), %eax
cmpl $0x1, %eax
jle 0x54fa9
decl %eax
movl %eax, 0x1c50(%rcx)
movq 0x1ae0(%rcx), %rdx
movq 0x1c58(%rcx), %rcx
movl -0x4(%rcx,%rax,4), %eax
movl %eax, 0x1cc(%rdx)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x644a1(%rip), %rdi     # 0xb9455
leaq 0x631aa(%rip), %rsi     # 0xb8165
leaq 0x644ad(%rip), %rcx     # 0xb946f
movl $0x18ec, %edx           # imm = 0x18EC
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsWindowHovered(int)
bool ImGui::IsWindowHovered(ImGuiHoveredFlags flags)
{
    IM_ASSERT((flags & ImGuiHoveredFlags_AllowWhenOverlapped) == 0);   // Flags not supported by this function
    ImGuiContext& g = *GImGui;

    if (flags & ImGuiHoveredFlags_AnyWindow)
    {
        if (g.HoveredWindow == NULL)
            return false;
    }
    else
    {
        switch (flags & (ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows))
        {
        case ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows:
            if (g.HoveredRootWindow != g.CurrentWindow->RootWindow)
                return false;
            break;
        case ImGuiHoveredFlags_RootWindow:
            if (g.HoveredWindow != g.CurrentWindow->RootWindow)
                return false;
            break;
        case ImGuiHoveredFlags_ChildWindows:
            if (g.HoveredWindow == NULL || !IsWindowChildOf(g.HoveredWindow, g.CurrentWindow))
                return false;
            break;
        default:
            if (g.HoveredWindow != g.CurrentWindow)
                return false;
            break;
        }
    }

    if (!IsWindowContentHoverable(g.HoveredWindow, flags))
        return false;
    if (!(flags & ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))
        if (g.ActiveId != 0 && !g.ActiveIdAllowOverlap && g.ActiveId != g.HoveredWindow->MoveId)
            return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x40, %dil
jne 0x552d4
movq 0xa8b0c(%rip), %rcx     # 0xfdcd0
testb $0x4, %dil
jne 0x551f5
movl %edi, %eax
andl $0x3, %eax
leaq 0x62762(%rip), %rdx     # 0xb7938
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x1ae8(%rcx), %rax
cmpq 0x1ae0(%rcx), %rax
jne 0x552d0
jmp 0x55266
cmpq $0x0, 0x1ae8(%rcx)
jne 0x55266
jmp 0x552d0
movq 0x1ae0(%rcx), %rax
movq 0x1ae8(%rcx), %rdx
jmp 0x55222
movq 0x1ae0(%rcx), %rax
movq 0x1af0(%rcx), %rdx
cmpq 0x390(%rax), %rdx
jne 0x552d0
jmp 0x55266
movq 0x1ae8(%rcx), %rdx
testq %rdx, %rdx
je 0x552d0
movq 0x1ae0(%rcx), %rsi
cmpq %rsi, 0x390(%rdx)
je 0x55266
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x55266
movq 0x388(%rdx), %rdx
testq %rdx, %rdx
jne 0x55253
jmp 0x552d2
movq 0x1ae8(%rcx), %rax
movq 0x1c90(%rcx), %rdx
testq %rdx, %rdx
je 0x552ae
movq 0x390(%rdx), %rdx
testq %rdx, %rdx
je 0x552ae
cmpb $0x1, 0x8f(%rdx)
jne 0x552ae
cmpq 0x390(%rax), %rdx
je 0x552ae
movl 0xc(%rdx), %edx
btl $0x1b, %edx
jb 0x552d0
testb $0x8, %dil
jne 0x552ae
andl $0x4000000, %edx        # imm = 0x4000000
jne 0x552d0
testb $0x20, %dil
jne 0x552cc
movl 0x1b30(%rcx), %edx
testl %edx, %edx
je 0x552cc
cmpb $0x0, 0x1b3d(%rcx)
jne 0x552cc
cmpl 0x54(%rax), %edx
jne 0x552d0
movb $0x1, %al
jmp 0x552d2
xorl %eax, %eax
popq %rbp
retq
leaq 0x641ae(%rip), %rdi     # 0xb9489
leaq 0x62e83(%rip), %rsi     # 0xb8165
leaq 0x641d5(%rip), %rcx     # 0xb94be
movl $0x1931, %edx           # imm = 0x1931
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsWindowFocused(int)
bool ImGui::IsWindowFocused(ImGuiFocusedFlags flags)
{
    ImGuiContext& g = *GImGui;

    if (flags & ImGuiFocusedFlags_AnyWindow)
        return g.NavWindow != NULL;

    IM_ASSERT(g.CurrentWindow);     // Not inside a Begin()/End()
    switch (flags & (ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows))
    {
    case ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows:
        return g.NavWindow && g.NavWindow->RootWindow == g.CurrentWindow->RootWindow;
    case ImGuiFocusedFlags_RootWindow:
        return g.NavWindow == g.CurrentWindow->RootWindow;
    case ImGuiFocusedFlags_ChildWindows:
        return g.NavWindow && IsWindowChildOf(g.NavWindow, g.CurrentWindow);
    default:
        return g.NavWindow == g.CurrentWindow;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa89d2(%rip), %rax     # 0xfdcd0
testb $0x4, %dil
jne 0x5532f
movq 0x1ae0(%rax), %rcx
testq %rcx, %rcx
je 0x5538b
andl $0x3, %edi
movq 0x1c90(%rax), %rdx
leaq 0x62627(%rip), %rax     # 0xb7948
movslq (%rax,%rdi,4), %rsi
addq %rax, %rsi
jmpq *%rsi
cmpq %rcx, %rdx
jmp 0x55358
cmpq $0x0, 0x1c90(%rax)
setne %al
jmp 0x55389
cmpq 0x390(%rcx), %rdx
jmp 0x55358
testq %rdx, %rdx
je 0x55383
movq 0x390(%rdx), %rax
cmpq 0x390(%rcx), %rax
sete %al
jmp 0x55389
testq %rdx, %rdx
je 0x55383
cmpq %rcx, 0x390(%rdx)
je 0x55387
cmpq %rcx, %rdx
sete %al
je 0x55389
movq 0x388(%rdx), %rdx
xorl %eax, %eax
testq %rdx, %rdx
jne 0x5536b
jmp 0x55389
xorl %eax, %eax
jmp 0x55389
movb $0x1, %al
popq %rbp
retq
leaq 0x7bed6(%rip), %rdi     # 0xd1268
leaq 0x62dcc(%rip), %rsi     # 0xb8165
leaq 0x6414d(%rip), %rcx     # 0xb94ed
movl $0x195f, %edx           # imm = 0x195F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowFocus(char const*)
void ImGui::SetWindowFocus(const char* name)
{
    if (name)
    {
        if (ImGuiWindow* window = FindWindowByName(name))
            FocusWindow(window);
    }
    else
    {
        FocusWindow(NULL);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x55662
pushq %rbp
movq %rsp, %rbp
xorl %esi, %esi
xorl %edx, %edx
callq 0x428dc
movl $0x1ac8, %edi           # imm = 0x1AC8
addq 0xa8683(%rip), %rdi     # 0xfdcd0
movl %eax, %esi
callq 0x43208
testq %rax, %rax
popq %rbp
je 0x55669
movq %rax, %rdi
jmp 0x47d9b
xorl %edi, %edi
jmp 0x47d9b
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowPos(ImVec2 const&, int, ImVec2 const&)
void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiCond cond, const ImVec2& pivot)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasPos;
    g.NextWindowData.PosVal = pos;
    g.NextWindowData.PosPivotVal = pivot;
    g.NextWindowData.PosCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
leal -0x1(%rsi), %eax
testl %eax, %esi
jne 0x556a0
movq 0xa8658(%rip), %rax     # 0xfdcd0
orl $0x1, 0x1b88(%rax)
movq (%rdi), %rcx
movq %rcx, 0x1b98(%rax)
movq (%rdx), %rcx
movq %rcx, 0x1ba0(%rax)
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x1b8c(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x63e71(%rip), %rdi     # 0xb951c
leaq 0x62ab3(%rip), %rsi     # 0xb8165
leaq 0x63f7b(%rip), %rcx     # 0xb9634
movl $0x1a16, %edx           # imm = 0x1A16
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowSizeConstraints(ImVec2 const&, ImVec2 const&, void (*)(ImGuiSizeCallbackData*), void*)
void ImGui::SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback, void* custom_callback_user_data)
{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSizeConstraint;
    g.NextWindowData.SizeConstraintRect = ImRect(size_min, size_max);
    g.NextWindowData.SizeCallback = custom_callback;
    g.NextWindowData.SizeCallbackUserData = custom_callback_user_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa8602(%rip), %rax     # 0xfdcd0
orl $0x10, 0x1b88(%rax)
movq (%rdi), %rdi
movq (%rsi), %rsi
movq %rdi, 0x1bc4(%rax)
movq %rsi, 0x1bcc(%rax)
movq %rdx, 0x1bd8(%rax)
movq %rcx, 0x1be0(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowCollapsed(bool, int)
void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasCollapsed;
    g.NextWindowData.CollapsedVal = collapsed;
    g.NextWindowData.CollapsedCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
leal -0x1(%rsi), %eax
testl %eax, %esi
jne 0x55778
movq 0xa8573(%rip), %rax     # 0xfdcd0
orl $0x8, 0x1b88(%rax)
movb %dil, 0x1bc0(%rax)
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x1b94(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x63d99(%rip), %rdi     # 0xb951c
leaq 0x629db(%rip), %rsi     # 0xb8165
leaq 0x63f24(%rip), %rcx     # 0xb96b5
movl $0x1a42, %edx           # imm = 0x1A42
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowFontScale(float)
void ImGui::SetWindowFontScale(float scale)
{
    IM_ASSERT(scale > 0.0f);
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->FontWindowScale = scale;
    g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x5587d
movq 0xa8496(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rcx
movb $0x1, 0x90(%rcx)
movss %xmm0, 0x2b0(%rcx)
mulss 0x1984(%rax), %xmm0
movq 0x388(%rcx), %rcx
testq %rcx, %rcx
je 0x5586c
mulss 0x2b0(%rcx), %xmm0
movss %xmm0, 0x1998(%rax)
movss %xmm0, 0x1980(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x63e61(%rip), %rdi     # 0xb96e9
leaq 0x628d6(%rip), %rsi     # 0xb8165
leaq 0x63e60(%rip), %rcx     # 0xb96f6
movl $0x1a6c, %edx           # imm = 0x1A6C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushFocusScope(unsigned int)
void ImGui::PushFocusScope(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    g.FocusScopeStack.push_back(window->DC.NavFocusScopeIdCurrent);
    window->DC.NavFocusScopeIdCurrent = id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xa8406(%rip), %r15     # 0xfdcd0
movq 0x1ae0(%r15), %r12
movl 0x1c40(%r15), %r13d
movl 0x1c44(%r15), %eax
cmpl %eax, %r13d
jne 0x55988
incl %r13d
testl %eax, %eax
je 0x558fc
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x55901
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x55988
movslq %r13d, %rdi
shlq $0x2, %rdi
testq %r15, %r15
je 0x55920
incl 0x3b4(%r15)
movq 0xa83b9(%rip), %rsi     # 0xfdce0
callq *0xa3be3(%rip)          # 0xf9510
movq %rax, %r14
movq 0x1c48(%r15), %rsi
testq %rsi, %rsi
je 0x5597a
movslq 0x1c40(%r15), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x1c48(%r15), %rdi
testq %rdi, %rdi
je 0x5596d
movq 0xa836e(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x5596d
decl 0x3b4(%rax)
movq 0xa836c(%rip), %rsi     # 0xfdce0
callq *0xa3b9e(%rip)          # 0xf9518
movq %r14, 0x1c48(%r15)
movl %r13d, 0x1c44(%r15)
movq 0x1c48(%r15), %rax
movslq 0x1c40(%r15), %rcx
movl 0x158(%r12), %edx
movl %edx, (%rax,%rcx,4)
incl 0x1c40(%r15)
movl %ebx, 0x158(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopFocusScope()
void ImGui::PopFocusScope()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.FocusScopeStack.Size > 0); // Too many PopFocusScope() ?
    window->DC.NavFocusScopeIdCurrent = g.FocusScopeStack.back();
    g.FocusScopeStack.pop_back();
}

// Assembly:
movq 0xa830a(%rip), %rax     # 0xfdcd0
movslq 0x1c40(%rax), %rcx
testq %rcx, %rcx
jle 0x559f3
movq 0x1ae0(%rax), %rdx
movq 0x1c48(%rax), %rsi
movl -0x4(%rsi,%rcx,4), %esi
movl %esi, 0x158(%rdx)
decl %ecx
movl %ecx, 0x1c40(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x63d1e(%rip), %rdi     # 0xb971c
leaq 0x62760(%rip), %rsi     # 0xb8165
leaq 0x63d2b(%rip), %rcx     # 0xb9737
movl $0x1a85, %edx           # imm = 0x1A85
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetKeyboardFocusHere(int)
void ImGui::SetKeyboardFocusHere(int offset)
{
    IM_ASSERT(offset >= -1);    // -1 is allowed but not below
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    g.FocusRequestNextWindow = window;
    g.FocusRequestNextCounterRegular = window->DC.FocusCounterRegular + 1 + offset;
    g.FocusRequestNextCounterTabStop = INT_MAX;
}

// Assembly:
cmpl $-0x2, %edi
jle 0x55a4b
movq 0xa82ae(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rcx
movq %rcx, 0x1df0(%rax)
movl 0x1c4(%rcx), %ecx
addl %edi, %ecx
incl %ecx
movl %ecx, 0x1e00(%rax)
movl $0x7fffffff, 0x1e04(%rax) # imm = 0x7FFFFFFF
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x63cfd(%rip), %rdi     # 0xb9753
leaq 0x62708(%rip), %rsi     # 0xb8165
leaq 0x63cfc(%rip), %rcx     # 0xb9760
movl $0x1a8c, %edx           # imm = 0x1A8C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetItemDefaultFocus()
void ImGui::SetItemDefaultFocus()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (!window->Appearing)
        return;
    if (g.NavWindow == window->RootWindowForNav && (g.NavInitRequest || g.NavInitResultId != 0) && g.NavLayer == g.NavWindow->DC.NavLayerCurrent)
    {
        g.NavInitRequest = false;
        g.NavInitResultId = g.NavWindow->DC.LastItemId;
        g.NavInitResultRectRel = ImRect(g.NavWindow->DC.LastItemRect.Min - g.NavWindow->Pos, g.NavWindow->DC.LastItemRect.Max - g.NavWindow->Pos);
        NavUpdateAnyRequestFlag();
        if (!IsItemVisible())
            SetScrollHereY();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa8257(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rdx
cmpb $0x1, 0x94(%rdx)
jne 0x55a99
movq 0x1c90(%rax), %rcx
cmpq 0x3a0(%rdx), %rcx
je 0x55a9b
popq %rbp
retq
cmpb $0x0, 0x1ce9(%rax)
jne 0x55aad
cmpl $0x0, 0x1cec(%rax)
je 0x55a99
movl 0x1cdc(%rax), %edx
cmpl 0x14c(%rcx), %edx
jne 0x55a99
movb $0x0, 0x1ce9(%rax)
movl 0x124(%rcx), %edx
movl %edx, 0x1cec(%rax)
movss 0x12c(%rcx), %xmm0
movss 0x10(%rcx), %xmm1
movss 0x14(%rcx), %xmm2
subss %xmm1, %xmm0
movss 0x130(%rcx), %xmm3
subss %xmm2, %xmm3
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movss 0x134(%rcx), %xmm3
subss %xmm1, %xmm3
movss 0x138(%rcx), %xmm1
subss %xmm2, %xmm1
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movlhps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
movups %xmm0, 0x1cf0(%rax)
cmpb $0x0, 0x1d00(%rax)
je 0x55b51
movb $0x1, 0x1ce8(%rax)
cmpq $0x0, 0x1c90(%rax)
jne 0x55b58
leaq 0x6670b(%rip), %rdi     # 0xbc244
leaq 0x62625(%rip), %rsi     # 0xb8165
leaq 0x66713(%rip), %rcx     # 0xbc25a
movl $0x2200, %edx           # imm = 0x2200
callq 0xc140
movb $0x0, 0x1ce8(%rax)
callq 0x52ba2
testb %al, %al
jne 0x55a99
movss 0x61497(%rip), %xmm0    # 0xb7004
popq %rbp
jmp 0x55b73
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollHereY(float)
void ImGui::SetScrollHereY(float center_y_ratio)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float spacing_y = g.Style.ItemSpacing.y;
    float target_pos_y = ImLerp(window->DC.CursorPosPrevLine.y - spacing_y, window->DC.CursorPosPrevLine.y + window->DC.PrevLineSize.y + spacing_y, center_y_ratio);
    SetScrollFromPosY(window, target_pos_y - window->Pos.y, center_y_ratio); // Convert from absolute to local pos

    // Tweak: snap on edges when aiming at an item very close to the edge
    window->ScrollTargetEdgeSnapDist.y = ImMax(0.0f, window->WindowPadding.y - spacing_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movaps %xmm0, %xmm1
movq 0xa814d(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rbx
movss 0x15ac(%rax), %xmm3
movss %xmm3, -0xc(%rbp)
movss 0xe4(%rbx), %xmm0
movaps %xmm0, %xmm2
subss %xmm3, %xmm2
addss 0x10c(%rbx), %xmm0
addss %xmm3, %xmm0
subss %xmm2, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
subss 0x14(%rbx), %xmm0
movq %rbx, %rdi
callq 0x57931
movss 0x44(%rbx), %xmm0
subss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andnps %xmm0, %xmm2
movss %xmm2, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(char const*)
void ImGui::PushID(const char* str_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(str_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rsi
movq 0xa8085(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4667e
movl %eax, %r14d
movl 0xc8(%rbx), %r12d
movl 0xcc(%rbx), %eax
cmpl %eax, %r12d
jne 0x55d1f
incl %r12d
testl %eax, %eax
je 0x55c89
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x55c8e
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x55d1f
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa8024(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55cb7
incl 0x3b4(%rax)
movq 0xa8022(%rip), %rsi     # 0xfdce0
callq *0xa384c(%rip)          # 0xf9510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x55d11
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x55d04
movq 0xa7fd7(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55d04
decl 0x3b4(%rax)
movq 0xa7fd5(%rip), %rsi     # 0xfdce0
callq *0xa3807(%rip)          # 0xf9518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movq 0xd0(%rbx), %rax
movslq 0xc8(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(char const*, char const*)
void ImGui::PushID(const char* str_id_begin, const char* str_id_end)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(str_id_begin, str_id_end);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rsi
movq 0xa7f78(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x4667e
movl %eax, %r14d
movl 0xc8(%rbx), %r12d
movl 0xcc(%rbx), %eax
cmpl %eax, %r12d
jne 0x55e2a
incl %r12d
testl %eax, %eax
je 0x55d94
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x55d99
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x55e2a
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa7f19(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55dc2
incl 0x3b4(%rax)
movq 0xa7f17(%rip), %rsi     # 0xfdce0
callq *0xa3741(%rip)          # 0xf9510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x55e1c
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x55e0f
movq 0xa7ecc(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55e0f
decl 0x3b4(%rax)
movq 0xa7eca(%rip), %rsi     # 0xfdce0
callq *0xa36fc(%rip)          # 0xf9518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movq 0xd0(%rbx), %rax
movslq 0xc8(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(void const*)
void ImGui::PushID(const void* ptr_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(ptr_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rsi
movq 0xa7e70(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x466d0
movl %eax, %r14d
movl 0xc8(%rbx), %r12d
movl 0xcc(%rbx), %eax
cmpl %eax, %r12d
jne 0x55f32
incl %r12d
testl %eax, %eax
je 0x55e9c
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x55ea1
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x55f32
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa7e11(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55eca
incl 0x3b4(%rax)
movq 0xa7e0f(%rip), %rsi     # 0xfdce0
callq *0xa3639(%rip)          # 0xf9510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x55f24
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x55f17
movq 0xa7dc4(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55f17
decl 0x3b4(%rax)
movq 0xa7dc2(%rip), %rsi     # 0xfdce0
callq *0xa35f4(%rip)          # 0xf9518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movq 0xd0(%rbx), %rax
movslq 0xc8(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(int)
void ImGui::PushID(int int_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(int_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %esi
movq 0xa7d69(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x4673e
movl %eax, %r14d
movl 0xc8(%rbx), %r12d
movl 0xcc(%rbx), %eax
cmpl %eax, %r12d
jne 0x56039
incl %r12d
testl %eax, %eax
je 0x55fa3
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x55fa8
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x56039
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa7d0a(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x55fd1
incl 0x3b4(%rax)
movq 0xa7d08(%rip), %rsi     # 0xfdce0
callq *0xa3532(%rip)          # 0xf9510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x5602b
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5601e
movq 0xa7cbd(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x5601e
decl 0x3b4(%rax)
movq 0xa7cbb(%rip), %rsi     # 0xfdce0
callq *0xa34ed(%rip)          # 0xf9518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movq 0xd0(%rbx), %rax
movslq 0xc8(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetIDWithSeed(char const*, char const*, unsigned int)
ImGuiID ImGui::GetIDWithSeed(const char* str, const char* str_end, ImGuiID seed)
{
    ImGuiID id = ImHashStr(str, str_end ? (str_end - str) : 0, seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO2(id, ImGuiDataType_String, str, str_end);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
subq %rdi, %rax
testq %rsi, %rsi
cmovneq %rax, %rsi
callq 0x428dc
movq 0xa7b67(%rip), %rcx     # 0xfdcd0
cmpl %eax, 0x1b30(%rcx)
jne 0x56177
movl %eax, 0x1b34(%rcx)
cmpl %eax, 0x1b70(%rcx)
jne 0x56186
movb $0x1, 0x1b74(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::DebugCheckVersionAndDataLayout(char const*, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
bool ImGui::DebugCheckVersionAndDataLayout(const char* version, size_t sz_io, size_t sz_style, size_t sz_vec2, size_t sz_vec4, size_t sz_vert, size_t sz_idx)
{
    bool error = false;
    if (strcmp(version, IMGUI_VERSION) != 0) { error = true; IM_ASSERT(strcmp(version, IMGUI_VERSION) == 0 && "Mismatched version string!"); }
    if (sz_io != sizeof(ImGuiIO)) { error = true; IM_ASSERT(sz_io == sizeof(ImGuiIO) && "Mismatched struct layout!"); }
    if (sz_style != sizeof(ImGuiStyle)) { error = true; IM_ASSERT(sz_style == sizeof(ImGuiStyle) && "Mismatched struct layout!"); }
    if (sz_vec2 != sizeof(ImVec2)) { error = true; IM_ASSERT(sz_vec2 == sizeof(ImVec2) && "Mismatched struct layout!"); }
    if (sz_vec4 != sizeof(ImVec4)) { error = true; IM_ASSERT(sz_vec4 == sizeof(ImVec4) && "Mismatched struct layout!"); }
    if (sz_vert != sizeof(ImDrawVert)) { error = true; IM_ASSERT(sz_vert == sizeof(ImDrawVert) && "Mismatched struct layout!"); }
    if (sz_idx != sizeof(ImDrawIdx)) { error = true; IM_ASSERT(sz_idx == sizeof(ImDrawIdx) && "Mismatched struct layout!"); }
    return !error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
leaq 0x60ddb(%rip), %rsi     # 0xb70d3
callq 0xc720
testl %eax, %eax
jne 0x5634d
cmpq $0x1558, %r13           # imm = 0x1558
jne 0x5636c
cmpq $0x414, %r12            # imm = 0x414
jne 0x5638b
cmpq $0x8, %r15
jne 0x563aa
cmpq $0x10, %r14
jne 0x563c9
cmpq $0x14, %rbx
jne 0x563e8
cmpq $0x2, 0x10(%rbp)
jne 0x56407
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6345f(%rip), %rdi     # 0xb97b3
leaq 0x61e0a(%rip), %rsi     # 0xb8165
leaq 0x63492(%rip), %rcx     # 0xb97f4
movl $0x1b19, %edx           # imm = 0x1B19
callq 0xc140
leaq 0x634ea(%rip), %rdi     # 0xb985d
leaq 0x61deb(%rip), %rsi     # 0xb8165
leaq 0x63473(%rip), %rcx     # 0xb97f4
movl $0x1b1a, %edx           # imm = 0x1B1A
callq 0xc140
leaq 0x63503(%rip), %rdi     # 0xb9895
leaq 0x61dcc(%rip), %rsi     # 0xb8165
leaq 0x63454(%rip), %rcx     # 0xb97f4
movl $0x1b1b, %edx           # imm = 0x1B1B
callq 0xc140
leaq 0x63522(%rip), %rdi     # 0xb98d3
leaq 0x61dad(%rip), %rsi     # 0xb8165
leaq 0x63435(%rip), %rcx     # 0xb97f4
movl $0x1b1c, %edx           # imm = 0x1B1C
callq 0xc140
leaq 0x6353c(%rip), %rdi     # 0xb990c
leaq 0x61d8e(%rip), %rsi     # 0xb8165
leaq 0x63416(%rip), %rcx     # 0xb97f4
movl $0x1b1d, %edx           # imm = 0x1B1D
callq 0xc140
leaq 0x63556(%rip), %rdi     # 0xb9945
leaq 0x61d6f(%rip), %rsi     # 0xb8165
leaq 0x633f7(%rip), %rcx     # 0xb97f4
movl $0x1b1e, %edx           # imm = 0x1B1E
callq 0xc140
leaq 0x63574(%rip), %rdi     # 0xb9982
leaq 0x61d50(%rip), %rsi     # 0xb8165
leaq 0x633d8(%rip), %rcx     # 0xb97f4
movl $0x1b1f, %edx           # imm = 0x1B1F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SameLine(float, float)
void ImGui::SameLine(float offset_from_start_x, float spacing_w)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiContext& g = *GImGui;
    if (offset_from_start_x != 0.0f)
    {
        if (spacing_w < 0.0f) spacing_w = 0.0f;
        window->DC.CursorPos.x = window->Pos.x - window->Scroll.x + offset_from_start_x + spacing_w + window->DC.GroupOffset.x + window->DC.ColumnsOffset.x;
        window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
    }
    else
    {
        if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
        window->DC.CursorPos.x = window->DC.CursorPosPrevLine.x + spacing_w;
        window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
    }
    window->DC.CurrLineSize = window->DC.PrevLineSize;
    window->DC.CurrLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa72e4(%rip), %rcx     # 0xfdcd0
movq 0x1ae0(%rcx), %rax
movb $0x1, 0x90(%rax)
cmpb $0x0, 0x93(%rax)
jne 0x56a80
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jne 0x56a0d
jnp 0x56a35
maxss %xmm1, %xmm2
movss 0x10(%rax), %xmm1
subss 0x5c(%rax), %xmm1
addss %xmm0, %xmm1
addss %xmm2, %xmm1
addss 0x120(%rax), %xmm1
addss 0x11c(%rax), %xmm1
jmp 0x56a4a
ucomiss %xmm1, %xmm2
jbe 0x56a42
movss 0x15a8(%rcx), %xmm1
addss 0xe0(%rax), %xmm1
movss %xmm1, 0xd8(%rax)
movss 0xe4(%rax), %xmm0
movss %xmm0, 0xdc(%rax)
movq 0x108(%rax), %rcx
movq %rcx, 0x100(%rax)
movss 0x114(%rax), %xmm0
movss %xmm0, 0x110(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::Indent(float)
void ImGui::Indent(float indent_w)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.Indent.x += (indent_w != 0.0f) ? indent_w : g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa6f96(%rip), %rcx     # 0xfdcd0
movq 0x1ae0(%rcx), %rax
movb $0x1, 0x90(%rax)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x56d5a
jp 0x56d5a
movss 0x15c8(%rcx), %xmm0
addss 0x118(%rax), %xmm0
movss %xmm0, 0x118(%rax)
addss 0x10(%rax), %xmm0
addss 0x11c(%rax), %xmm0
movss %xmm0, 0xd8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushItemWidth(float)
void ImGui::PushItemWidth(float item_width)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->DC.ItemWidth = (item_width == 0.0f ? window->ItemWidthDefault : item_width);
    window->DC.ItemWidthStack.push_back(window->DC.ItemWidth);
    g.NextItemData.Flags &= ~ImGuiNextItemDataFlags_HasWidth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xa6ee7(%rip), %r14     # 0xfdcd0
movq 0x1ae0(%r14), %r15
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x56e03
jp 0x56e03
movss 0x288(%r15), %xmm0
movss %xmm0, 0x1d0(%r15)
movl 0x1d8(%r15), %r12d
movl 0x1dc(%r15), %eax
cmpl %eax, %r12d
jne 0x56ec3
incl %r12d
testl %eax, %eax
je 0x56e37
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x56e3c
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x56ec3
movslq %r12d, %rdi
shlq $0x2, %rdi
testq %r14, %r14
je 0x56e5b
incl 0x3b4(%r14)
movq 0xa6e7e(%rip), %rsi     # 0xfdce0
callq *0xa26a8(%rip)          # 0xf9510
movq %rax, %rbx
movq 0x1e0(%r15), %rsi
testq %rsi, %rsi
je 0x56eb5
movslq 0x1d8(%r15), %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
callq 0xc080
movq 0x1e0(%r15), %rdi
testq %rdi, %rdi
je 0x56ea8
movq 0xa6e33(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x56ea8
decl 0x3b4(%rax)
movq 0xa6e31(%rip), %rsi     # 0xfdce0
callq *0xa2663(%rip)          # 0xf9518
movq %rbx, 0x1e0(%r15)
movl %r12d, 0x1dc(%r15)
movq 0x1e0(%r15), %rax
movslq 0x1d8(%r15), %rcx
movl 0x1d0(%r15), %edx
movl %edx, (%rax,%rcx,4)
incl 0x1d8(%r15)
andb $-0x2, 0x1bf8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq