LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa84c1(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rcx
movswl (%rdi), %edx
cmpl %edx, 0xc8(%rcx)
jne 0x5387f
movswl 0xa(%rdi), %ecx
cmpl %ecx, 0x1c60(%rax)
jne 0x5389e
movswl 0xc(%rdi), %ecx
cmpl %ecx, 0x1c80(%rax)
jne 0x538bd
movswl 0x2(%rdi), %ecx
cmpl %ecx, 0x1c10(%rax)
jg 0x538dc
movswl 0x4(%rdi), %ecx
cmpl %ecx, 0x1c20(%rax)
jg 0x538fb
movswl 0x6(%rdi), %ecx
cmpl %ecx, 0x1c30(%rax)
jg 0x5391a
movswl 0x8(%rdi), %ecx
cmpl %ecx, 0x1c40(%rax)
jne 0x53939
popq %rbp
retq
leaq 0x6436a(%rip), %rdi     # 0xb7bf0
leaq 0x628d8(%rip), %rsi     # 0xb6165
leaq 0x643b2(%rip), %rcx     # 0xb7c46
movl $0x1bcd, %edx           # imm = 0x1BCD
callq 0xc140
leaq 0x643d1(%rip), %rdi     # 0xb7c76
leaq 0x628b9(%rip), %rsi     # 0xb6165
leaq 0x64393(%rip), %rcx     # 0xb7c46
movl $0x1bd1, %edx           # imm = 0x1BD1
callq 0xc140
leaq 0x643fb(%rip), %rdi     # 0xb7cbf
leaq 0x6289a(%rip), %rsi     # 0xb6165
leaq 0x64374(%rip), %rcx     # 0xb7c46
movl $0x1bd2, %edx           # imm = 0x1BD2
callq 0xc140
leaq 0x64444(%rip), %rdi     # 0xb7d27
leaq 0x6287b(%rip), %rsi     # 0xb6165
leaq 0x64355(%rip), %rcx     # 0xb7c46
movl $0x1bd3, %edx           # imm = 0x1BD3
callq 0xc140
leaq 0x64477(%rip), %rdi     # 0xb7d79
leaq 0x6285c(%rip), %rsi     # 0xb6165
leaq 0x64336(%rip), %rcx     # 0xb7c46
movl $0x1bd4, %edx           # imm = 0x1BD4
callq 0xc140
leaq 0x644ac(%rip), %rdi     # 0xb7dcd
leaq 0x6283d(%rip), %rsi     # 0xb6165
leaq 0x64317(%rip), %rcx     # 0xb7c46
movl $0x1bd5, %edx           # imm = 0x1BD5
callq 0xc140
leaq 0x644d1(%rip), %rdi     # 0xb7e11
leaq 0x6281e(%rip), %rsi     # 0xb6165
leaq 0x642f8(%rip), %rcx     # 0xb7c46
movl $0x1bd6, %edx           # imm = 0x1BD6
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa836a(%rip), %r14     # 0xfbcd0
movslq 0x1a98(%r14), %rax
testq %rax, %rax
jle 0x539e3
movq %rdi, %rbx
movq 0x1aa0(%r14), %rcx
cmpq %rdi, -0x8(%rcx,%rax,8)
je 0x539de
cmpl $0x1, %eax
je 0x539de
leal -0x1(%rax), %esi
xorl %edx, %edx
leal -0x1(%rsi), %edi
cmpq %rbx, (%rcx,%rdi,8)
je 0x539a1
decq %rdx
movl %edi, %esi
testl %edi, %edi
jg 0x5398d
jmp 0x539de
cmpl %esi, %eax
jbe 0x53a02
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 0x53a02
movq 0x1aa0(%r14), %rcx
movq %rbx, -0x8(%rcx,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x79fc0(%rip), %rdi     # 0xcd9aa
leaq 0x65c9a(%rip), %rsi     # 0xb968b
leaq 0x67194(%rip), %rcx     # 0xbab8c
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x65c6f(%rip), %rdi     # 0xb9678
leaq 0x65c7b(%rip), %rsi     # 0xb968b
leaq 0x67050(%rip), %rcx     # 0xbaa67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa82a1(%rip), %r14     # 0xfbcd0
movslq 0x1a88(%r14), %rax
testq %rax, %rax
jle 0x53ab8
movq %rdi, %rbx
movq 0x1a90(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdx
cmpq %rdi, %rdx
je 0x53ab3
cmpq %rbx, 0x390(%rdx)
je 0x53ab3
cmpl $0x1, %eax
je 0x53ab3
leal -0x1(%rax), %esi
xorl %edx, %edx
leal -0x1(%rsi), %edi
cmpq %rbx, (%rcx,%rdi,8)
je 0x53a76
decq %rdx
movl %edi, %esi
testl %edi, %edi
jg 0x53a62
jmp 0x53ab3
cmpl %esi, %eax
jbe 0x53ad7
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 0x53ad7
movq 0x1a90(%r14), %rcx
movq %rbx, -0x8(%rcx,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x79eeb(%rip), %rdi     # 0xcd9aa
leaq 0x65bc5(%rip), %rsi     # 0xb968b
leaq 0x670bf(%rip), %rcx     # 0xbab8c
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x65b9a(%rip), %rdi     # 0xb9678
leaq 0x65ba6(%rip), %rsi     # 0xb968b
leaq 0x66f7b(%rip), %rcx     # 0xbaa67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa81cc(%rip), %r14     # 0xfbcd0
movl 0x1a88(%r14), %eax
testl %eax, %eax
jle 0x53b60
movq %rdi, %rbx
movq 0x1a90(%r14), %rsi
cmpq %rdi, (%rsi)
je 0x53b5b
leaq (,%rax,8), %rcx
xorl %edx, %edx
cmpq %rbx, (%rsi,%rdx)
je 0x53b39
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x53b28
jmp 0x53b5b
cmpl $0x1, %eax
je 0x53b60
leaq 0x8(%rsi), %rdi
callq 0xc130
cmpl $0x0, 0x1a88(%r14)
jle 0x53b60
movq 0x1a90(%r14), %rax
movq %rbx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x65b11(%rip), %rdi     # 0xb9678
leaq 0x65b1d(%rip), %rsi     # 0xb968b
leaq 0x66ef2(%rip), %rcx     # 0xbaa67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa813c(%rip), %r15     # 0xfbcd0
testq %rdi, %rdi
jne 0x53bbd
movq 0xb8(%r15), %rbx
testq %rbx, %rbx
jne 0x53bbd
movq 0xa8(%r15), %rax
cmpl $0x0, 0x40(%rax)
jle 0x53cba
movq 0x48(%rax), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x4b52a
movl 0x1c30(%r15), %eax
cmpl 0x1c34(%r15), %eax
jne 0x53bea
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x53bf6
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x53bfb
movq 0x1c38(%r15), %r14
jmp 0x53c8a
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0xa80c0(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x53c1b
incl 0x3b4(%rax)
movq 0xa80be(%rip), %rsi     # 0xfbce0
callq *0xa38e8(%rip)          # 0xf7510
movq %rax, %r14
movq 0x1c38(%r15), %rsi
testq %rsi, %rsi
je 0x53c75
movslq 0x1c30(%r15), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x1c38(%r15), %rdi
testq %rdi, %rdi
je 0x53c68
movq 0xa8073(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x53c68
decl 0x3b4(%rax)
movq 0xa8071(%rip), %rsi     # 0xfbce0
callq *0xa38a3(%rip)          # 0xf7518
movq %r14, 0x1c38(%r15)
movl %r12d, 0x1c34(%r15)
movl 0x1c30(%r15), %eax
cltq
movq %rbx, (%r14,%rax,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 0x75d6a
leaq 0x659b7(%rip), %rdi     # 0xb9678
leaq 0x659c3(%rip), %rsi     # 0xb968b
leaq 0x659d2(%rip), %rcx     # 0xb96a1
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7fea(%rip), %rbx     # 0xfbcd0
movq 0x1ae0(%rbx), %rax
movq 0x2b8(%rax), %rdi
callq 0x75e06
movl 0x1c30(%rbx), %eax
testl %eax, %eax
jle 0x53d54
decl %eax
movl %eax, 0x1c30(%rbx)
je 0x53d23
movq 0x1c38(%rbx), %rcx
movl %eax, %eax
leaq (%rcx,%rax,8), %rax
addq $-0x8, %rax
movq (%rax), %rdi
jmp 0x53d36
movq 0xa7fa6(%rip), %rax     # 0xfbcd0
movq 0xb8(%rax), %rdi
testq %rdi, %rdi
je 0x53d41
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b52a
movq 0xa8(%rax), %rax
cmpl $0x0, 0x40(%rax)
jle 0x53d73
movq 0x48(%rax), %rax
jmp 0x53d1e
leaq 0x79c4f(%rip), %rdi     # 0xcd9aa
leaq 0x65929(%rip), %rsi     # 0xb968b
leaq 0x66f61(%rip), %rcx     # 0xbacca
movl $0x672, %edx            # imm = 0x672
callq 0xc140
leaq 0x658fe(%rip), %rdi     # 0xb9678
leaq 0x6590a(%rip), %rsi     # 0xb968b
leaq 0x65919(%rip), %rcx     # 0xb96a1
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7f2c(%rip), %r14     # 0xfbcd0
movslq 0x1c50(%r14), %rax
testq %rax, %rax
jle 0x53ea0
movq 0x1ae0(%r14), %rcx
movl 0x1cc(%rcx), %r15d
movq 0x1c58(%r14), %rbx
cmpl -0x4(%rbx,%rax,4), %r15d
jne 0x53ebf
movl %edi, %edx
notl %edx
andl %r15d, %edx
orl %edi, %r15d
testb %sil, %sil
cmovel %edx, %r15d
movl %r15d, 0x1cc(%rcx)
cmpl 0x1c54(%r14), %eax
jne 0x53e8a
leal 0x1(%rax), %ecx
movl %eax, %r12d
shrl %r12d
addl %eax, %r12d
cmpl %ecx, %r12d
cmovbel %ecx, %r12d
leaq (,%r12,4), %rdi
incl 0x3b4(%r14)
movq 0xa7ebe(%rip), %rsi     # 0xfbce0
callq *0xa36e8(%rip)          # 0xf7510
movq %rax, %rbx
movq 0x1c58(%r14), %rsi
testq %rsi, %rsi
je 0x53e75
movslq 0x1c50(%r14), %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
callq 0xc080
movq 0x1c58(%r14), %rdi
testq %rdi, %rdi
je 0x53e68
movq 0xa7e73(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x53e68
decl 0x3b4(%rax)
movq 0xa7e71(%rip), %rsi     # 0xfbce0
callq *0xa36a3(%rip)          # 0xf7518
movq %rbx, 0x1c58(%r14)
movl %r12d, 0x1c54(%r14)
movl 0x1c50(%r14), %eax
cltq
movl %r15d, (%rbx,%rax,4)
incl 0x1c50(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x79b03(%rip), %rdi     # 0xcd9aa
leaq 0x657dd(%rip), %rsi     # 0xb968b
leaq 0x66d76(%rip), %rcx     # 0xbac2b
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x6353a(%rip), %rdi     # 0xb7400
leaq 0x62298(%rip), %rsi     # 0xb6165
leaq 0x63552(%rip), %rcx     # 0xb7426
movl $0x18df, %edx           # imm = 0x18DF
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7deb(%rip), %rcx     # 0xfbcd0
movl 0x1c50(%rcx), %eax
cmpl $0x1, %eax
jle 0x53f11
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 0x63539(%rip), %rdi     # 0xb7455
leaq 0x62242(%rip), %rsi     # 0xb6165
leaq 0x63545(%rip), %rcx     # 0xb746f
movl $0x18ec, %edx           # imm = 0x18EC
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x54223
movq 0xa7bd7(%rip), %rcx     # 0xfbcd0
testb $0x4, %dil
jne 0x5412a
movl %edi, %eax
andl $0x3, %eax
leaq 0x6182d(%rip), %rdx     # 0xb5938
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x1ae8(%rcx), %rdx
cmpq 0x1ae0(%rcx), %rdx
jne 0x5421f
jmp 0x5413a
movq 0x1ae8(%rcx), %rdx
testq %rdx, %rdx
je 0x5421f
movq 0x1c90(%rcx), %rax
testq %rax, %rax
je 0x54182
movq 0x390(%rax), %rax
testq %rax, %rax
je 0x54182
cmpb $0x1, 0x8f(%rax)
jne 0x54182
cmpq 0x390(%rdx), %rax
je 0x54182
movl 0xc(%rax), %eax
btl $0x1b, %eax
jb 0x5421f
testb $0x8, %dil
jne 0x54182
andl $0x4000000, %eax        # imm = 0x4000000
jne 0x5421f
testb $0x20, %dil
jne 0x541a0
movl 0x1b30(%rcx), %eax
testl %eax, %eax
je 0x541a0
cmpb $0x0, 0x1b3d(%rcx)
jne 0x541a0
cmpl 0x54(%rdx), %eax
jne 0x5421f
movb $0x1, %al
jmp 0x54221
movq 0x1ae0(%rcx), %rax
movq 0x1ae8(%rcx), %rdx
cmpq 0x390(%rax), %rdx
jne 0x5421f
jmp 0x5413a
movq 0x1ae0(%rcx), %rax
movq 0x1af0(%rcx), %rdx
cmpq 0x390(%rax), %rdx
jne 0x5421f
movq 0x1ae8(%rcx), %rdx
jmp 0x5413a
movq 0x1ae8(%rcx), %rdx
testq %rdx, %rdx
je 0x5421f
movq 0x1ae0(%rcx), %rsi
cmpq %rsi, 0x390(%rdx)
je 0x5413a
movq %rdx, %r8
xorl %eax, %eax
cmpq %rsi, %r8
je 0x5413a
movq 0x388(%r8), %r8
testq %r8, %r8
jne 0x54208
jmp 0x54221
xorl %eax, %eax
popq %rbp
retq
leaq 0x6325f(%rip), %rdi     # 0xb7489
leaq 0x61f34(%rip), %rsi     # 0xb6165
leaq 0x63286(%rip), %rcx     # 0xb74be
movl $0x1931, %edx           # imm = 0x1931
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7a83(%rip), %rax     # 0xfbcd0
testb $0x4, %dil
jne 0x5427e
movq 0x1ae0(%rax), %rcx
testq %rcx, %rcx
je 0x542d8
andl $0x3, %edi
movq 0x1c90(%rax), %rdx
leaq 0x616d8(%rip), %rax     # 0xb5948
movslq (%rax,%rdi,4), %rsi
addq %rax, %rsi
jmpq *%rsi
cmpq %rcx, %rdx
jmp 0x542a7
cmpq $0x0, 0x1c90(%rax)
setne %al
jmp 0x542d6
cmpq 0x390(%rcx), %rdx
jmp 0x542a7
testq %rdx, %rdx
je 0x542d0
movq 0x390(%rdx), %rax
cmpq 0x390(%rcx), %rax
sete %al
jmp 0x542d6
testq %rdx, %rdx
je 0x542d0
cmpq %rcx, 0x390(%rdx)
je 0x542d4
cmpq %rcx, %rdx
sete %al
je 0x542d6
movq 0x388(%rdx), %rdx
testq %rdx, %rdx
jne 0x542ba
jmp 0x542d6
xorl %eax, %eax
jmp 0x542d6
movb $0x1, %al
popq %rbp
retq
leaq 0x7af59(%rip), %rdi     # 0xcf238
leaq 0x61e7f(%rip), %rsi     # 0xb6165
leaq 0x63200(%rip), %rcx     # 0xb74ed
movl $0x195f, %edx           # imm = 0x195F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x545c7
pushq %rbp
movq %rsp, %rbp
xorl %esi, %esi
xorl %edx, %edx
callq 0x42033
movl $0x1ac8, %edi           # imm = 0x1AC8
addq 0xa771e(%rip), %rdi     # 0xfbcd0
movl %eax, %esi
callq 0x42976
testq %rax, %rax
popq %rbp
je 0x545ce
movq %rax, %rdi
jmp 0x4726c
xorl %edi, %edi
jmp 0x4726c
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x54605
movq 0xa76f3(%rip), %rax     # 0xfbcd0
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 0x62f0c(%rip), %rdi     # 0xb751c
leaq 0x61b4e(%rip), %rsi     # 0xb6165
leaq 0x63016(%rip), %rcx     # 0xb7634
movl $0x1a16, %edx           # imm = 0x1A16
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa769d(%rip), %rax     # 0xfbcd0
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_O3/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 0x546dd
movq 0xa760e(%rip), %rax     # 0xfbcd0
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 0x62e34(%rip), %rdi     # 0xb751c
leaq 0x61a76(%rip), %rsi     # 0xb6165
leaq 0x62fbf(%rip), %rcx     # 0xb76b5
movl $0x1a42, %edx           # imm = 0x1A42
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x547e2
movq 0xa7531(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rcx
movb $0x1, 0x90(%rcx)
movss %xmm0, 0x2b0(%rcx)
mulss 0x1984(%rax), %xmm0
movq 0x388(%rcx), %rcx
testq %rcx, %rcx
je 0x547d1
mulss 0x2b0(%rcx), %xmm0
movss %xmm0, 0x1998(%rax)
movss %xmm0, 0x1980(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x62efc(%rip), %rdi     # 0xb76e9
leaq 0x61971(%rip), %rsi     # 0xb6165
leaq 0x62efb(%rip), %rcx     # 0xb76f6
movl $0x1a6c, %edx           # imm = 0x1A6C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa74a1(%rip), %r15     # 0xfbcd0
movq 0x1ae0(%r15), %r12
movl 0x1c40(%r15), %eax
cmpl 0x1c44(%r15), %eax
jne 0x5485b
leal 0x1(%rax), %r13d
testl %eax, %eax
je 0x54867
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x5486c
movq 0x1c48(%r15), %r14
jmp 0x548f0
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x2, %rdi
incl 0x3b4(%r15)
movq 0xa7458(%rip), %rsi     # 0xfbce0
callq *0xa2c82(%rip)          # 0xf7510
movq %rax, %r14
movq 0x1c48(%r15), %rsi
testq %rsi, %rsi
je 0x548db
movslq 0x1c40(%r15), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x1c48(%r15), %rdi
testq %rdi, %rdi
je 0x548ce
movq 0xa740d(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x548ce
decl 0x3b4(%rax)
movq 0xa740b(%rip), %rsi     # 0xfbce0
callq *0xa2c3d(%rip)          # 0xf7518
movq %r14, 0x1c48(%r15)
movl %r13d, 0x1c44(%r15)
movl 0x1c40(%r15), %eax
cltq
movl 0x158(%r12), %ecx
movl %ecx, (%r14,%rax,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_O3/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 0xa73ad(%rip), %rax     # 0xfbcd0
movslq 0x1c40(%rax), %rcx
testq %rcx, %rcx
jle 0x54950
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 0x62dc1(%rip), %rdi     # 0xb771c
leaq 0x61803(%rip), %rsi     # 0xb6165
leaq 0x62dce(%rip), %rcx     # 0xb7737
movl $0x1a85, %edx           # imm = 0x1A85
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x549a8
movq 0xa7351(%rip), %rax     # 0xfbcd0
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 0x62da0(%rip), %rdi     # 0xb7753
leaq 0x617ab(%rip), %rsi     # 0xb6165
leaq 0x62d9f(%rip), %rcx     # 0xb7760
movl $0x1a8c, %edx           # imm = 0x1A8C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa72fa(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rdx
cmpb $0x1, 0x94(%rdx)
jne 0x549f6
movq 0x1c90(%rax), %rcx
cmpq 0x3a0(%rdx), %rcx
je 0x549f8
popq %rbp
retq
cmpb $0x0, 0x1ce9(%rax)
jne 0x54a0a
cmpl $0x0, 0x1cec(%rax)
je 0x549f6
movl 0x1cdc(%rax), %edx
cmpl 0x14c(%rcx), %edx
jne 0x549f6
movb $0x0, 0x1ce9(%rax)
movl 0x124(%rcx), %edx
movl %edx, 0x1cec(%rax)
movss 0x12c(%rcx), %xmm0
movss 0x130(%rcx), %xmm1
movss 0x10(%rcx), %xmm2
movss 0x14(%rcx), %xmm3
subss %xmm2, %xmm0
subss %xmm3, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movss 0x134(%rcx), %xmm1
movss 0x138(%rcx), %xmm4
subss %xmm2, %xmm1
subss %xmm3, %xmm4
unpcklps %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x1cf0(%rax)
movb 0x1d00(%rax), %cl
movb %cl, 0x1ce8(%rax)
callq 0x51ba6
testb %al, %al
jne 0x549f6
movss 0x6056e(%rip), %xmm0    # 0xb5004
popq %rbp
jmp 0x54a9c
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7224(%rip), %rax     # 0xfbcd0
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 0x5681c
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_O3/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 0xa715c(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x45b30
movl %eax, %r14d
movl 0xc8(%rbx), %eax
cmpl 0xcc(%rbx), %eax
jne 0x54bab
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x54bb7
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x54bbc
movq 0xd0(%rbx), %r15
jmp 0x54c4a
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa70ff(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54bdc
incl 0x3b4(%rax)
movq 0xa70fd(%rip), %rsi     # 0xfbce0
callq *0xa2927(%rip)          # 0xf7510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x54c36
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x54c29
movq 0xa70b2(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54c29
decl 0x3b4(%rax)
movq 0xa70b0(%rip), %rsi     # 0xfbce0
callq *0xa28e2(%rip)          # 0xf7518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movl 0xc8(%rbx), %eax
cltq
movl %r14d, (%r15,%rax,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa7059(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x45b30
movl %eax, %r14d
movl 0xc8(%rbx), %eax
cmpl 0xcc(%rbx), %eax
jne 0x54cac
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x54cb8
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x54cbd
movq 0xd0(%rbx), %r15
jmp 0x54d4b
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa6ffe(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54cdd
incl 0x3b4(%rax)
movq 0xa6ffc(%rip), %rsi     # 0xfbce0
callq *0xa2826(%rip)          # 0xf7510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x54d37
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x54d2a
movq 0xa6fb1(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54d2a
decl 0x3b4(%rax)
movq 0xa6faf(%rip), %rsi     # 0xfbce0
callq *0xa27e1(%rip)          # 0xf7518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movl 0xc8(%rbx), %eax
cltq
movl %r14d, (%r15,%rax,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa6f5b(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x45b82
movl %eax, %r14d
movl 0xc8(%rbx), %eax
cmpl 0xcc(%rbx), %eax
jne 0x54daa
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x54db6
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x54dbb
movq 0xd0(%rbx), %r15
jmp 0x54e49
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa6f00(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54ddb
incl 0x3b4(%rax)
movq 0xa6efe(%rip), %rsi     # 0xfbce0
callq *0xa2728(%rip)          # 0xf7510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x54e35
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x54e28
movq 0xa6eb3(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54e28
decl 0x3b4(%rax)
movq 0xa6eb1(%rip), %rsi     # 0xfbce0
callq *0xa26e3(%rip)          # 0xf7518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movl 0xc8(%rbx), %eax
cltq
movl %r14d, (%r15,%rax,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa6e5e(%rip), %rax     # 0xfbcd0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x45bf0
movl %eax, %r14d
movl 0xc8(%rbx), %eax
cmpl 0xcc(%rbx), %eax
jne 0x54ea7
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x54eb3
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x54eb8
movq 0xd0(%rbx), %r15
jmp 0x54f46
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
movq 0xa6e03(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54ed8
incl 0x3b4(%rax)
movq 0xa6e01(%rip), %rsi     # 0xfbce0
callq *0xa262b(%rip)          # 0xf7510
movq %rax, %r15
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x54f32
movslq 0xc8(%rbx), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
callq 0xc080
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x54f25
movq 0xa6db6(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x54f25
decl 0x3b4(%rax)
movq 0xa6db4(%rip), %rsi     # 0xfbce0
callq *0xa25e6(%rip)          # 0xf7518
movq %r15, 0xd0(%rbx)
movl %r12d, 0xcc(%rbx)
movl 0xc8(%rbx), %eax
cltq
movl %r14d, (%r15,%rax,4)
incl 0xc8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42033
movq 0xa6c6d(%rip), %rcx     # 0xfbcd0
cmpl %eax, 0x1b30(%rcx)
jne 0x55071
movl %eax, 0x1b34(%rcx)
cmpl %eax, 0x1b70(%rcx)
jne 0x55080
movb $0x1, 0x1b74(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fee5(%rip), %rsi     # 0xb50d3
callq 0xc720
testl %eax, %eax
jne 0x55243
cmpq $0x1558, %r13           # imm = 0x1558
jne 0x55262
cmpq $0x414, %r12            # imm = 0x414
jne 0x55281
cmpq $0x8, %r15
jne 0x552a0
cmpq $0x10, %r14
jne 0x552bf
cmpq $0x14, %rbx
jne 0x552de
cmpq $0x2, 0x10(%rbp)
jne 0x552fd
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x62569(%rip), %rdi     # 0xb77b3
leaq 0x60f14(%rip), %rsi     # 0xb6165
leaq 0x6259c(%rip), %rcx     # 0xb77f4
movl $0x1b19, %edx           # imm = 0x1B19
callq 0xc140
leaq 0x625f4(%rip), %rdi     # 0xb785d
leaq 0x60ef5(%rip), %rsi     # 0xb6165
leaq 0x6257d(%rip), %rcx     # 0xb77f4
movl $0x1b1a, %edx           # imm = 0x1B1A
callq 0xc140
leaq 0x6260d(%rip), %rdi     # 0xb7895
leaq 0x60ed6(%rip), %rsi     # 0xb6165
leaq 0x6255e(%rip), %rcx     # 0xb77f4
movl $0x1b1b, %edx           # imm = 0x1B1B
callq 0xc140
leaq 0x6262c(%rip), %rdi     # 0xb78d3
leaq 0x60eb7(%rip), %rsi     # 0xb6165
leaq 0x6253f(%rip), %rcx     # 0xb77f4
movl $0x1b1c, %edx           # imm = 0x1B1C
callq 0xc140
leaq 0x62646(%rip), %rdi     # 0xb790c
leaq 0x60e98(%rip), %rsi     # 0xb6165
leaq 0x62520(%rip), %rcx     # 0xb77f4
movl $0x1b1d, %edx           # imm = 0x1B1D
callq 0xc140
leaq 0x62660(%rip), %rdi     # 0xb7945
leaq 0x60e79(%rip), %rsi     # 0xb6165
leaq 0x62501(%rip), %rcx     # 0xb77f4
movl $0x1b1e, %edx           # imm = 0x1B1E
callq 0xc140
leaq 0x6267e(%rip), %rdi     # 0xb7982
leaq 0x60e5a(%rip), %rsi     # 0xb6165
leaq 0x624e2(%rip), %rcx     # 0xb77f4
movl $0x1b1f, %edx           # imm = 0x1B1F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa63a8(%rip), %rcx     # 0xfbcd0
movq 0x1ae0(%rcx), %rax
movb $0x1, 0x90(%rax)
cmpb $0x0, 0x93(%rax)
jne 0x559bc
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jne 0x55949
jnp 0x55971
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 0x55986
ucomiss %xmm1, %xmm2
jbe 0x5597e
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_O3/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 0xa6063(%rip), %rcx     # 0xfbcd0
movq 0x1ae0(%rcx), %rax
movb $0x1, 0x90(%rax)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x55c8d
jp 0x55c8d
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_O3/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 0xa5fb4(%rip), %r14     # 0xfbcd0
movq 0x1ae0(%r14), %r15
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x55d36
jp 0x55d36
movss 0x288(%r15), %xmm0
movss %xmm0, 0x1d0(%r15)
movl 0x1d8(%r15), %eax
cmpl 0x1dc(%r15), %eax
jne 0x55d64
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x55d70
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x55d75
movq 0x1e0(%r15), %rbx
jmp 0x55e02
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
incl 0x3b4(%r14)
movq 0xa5f4f(%rip), %rsi     # 0xfbce0
callq *0xa1779(%rip)          # 0xf7510
movq %rax, %rbx
movq 0x1e0(%r15), %rsi
testq %rsi, %rsi
je 0x55de4
movslq 0x1d8(%r15), %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
callq 0xc080
movq 0x1e0(%r15), %rdi
testq %rdi, %rdi
je 0x55dd7
movq 0xa5f04(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x55dd7
decl 0x3b4(%rax)
movq 0xa5f02(%rip), %rsi     # 0xfbce0
callq *0xa1734(%rip)          # 0xf7518
movq %rbx, 0x1e0(%r15)
movl %r12d, 0x1dc(%r15)
movl 0x1d8(%r15), %eax
movss 0x1d0(%r15), %xmm0
cltq
movss %xmm0, (%rbx,%rax,4)
incl 0x1d8(%r15)
andb $-0x2, 0x1bf8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcItemWidth()
float ImGui::CalcItemWidth()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float w;
    if (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasWidth)
        w = g.NextItemData.Width;
    else
        w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        float region_max_x = GetContentRegionMaxAbs().x;
        w = ImMax(1.0f, region_max_x - window->DC.CursorPos.x + w);
    }
    w = IM_FLOOR(w);
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa5b78(%rip), %rcx     # 0xfbcd0
movq 0x1ae0(%rcx), %rax
leaq 0x1bfc(%rcx), %rdx
leaq 0x1d0(%rax), %rsi
testb $0x1, 0x1bf8(%rcx)
cmoveq %rsi, %rdx
movss (%rdx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x561c7
movsd 0x270(%rax), %xmm1
cmpq $0x0, 0x1b0(%rax)
jne 0x561a0
cmpq $0x0, 0x20a8(%rcx)
je 0x561ac
movss 0x240(%rax), %xmm2
movss %xmm2, %xmm1            # xmm1 = xmm2[0],xmm1[1,2,3]
subss 0xd8(%rax), %xmm1
addss %xmm1, %xmm0
movss 0x5ee24(%rip), %xmm1    # 0xb4fe4
maxss %xmm0, %xmm1
movaps %xmm1, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetContentRegionMaxAbs()
ImVec2 ImGui::GetContentRegionMaxAbs()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x;
    return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa5af5(%rip), %rcx     # 0xfbcd0
movq 0x1ae0(%rcx), %rax
movsd 0x270(%rax), %xmm0
cmpq $0x0, 0x1b0(%rax)
jne 0x561fe
cmpq $0x0, 0x20a8(%rcx)
je 0x5620a
movss 0x240(%rax), %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcItemSize(ImVec2, float, float)
ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_w, float default_h)
{
    ImGuiWindow* window = GImGui->CurrentWindow;

    ImVec2 region_max;
    if (size.x < 0.0f || size.y < 0.0f)
        region_max = GetContentRegionMaxAbs();

    if (size.x == 0.0f)
        size.x = default_w;
    else if (size.x < 0.0f)
        size.x = ImMax(4.0f, region_max.x - window->DC.CursorPos.x + size.x);

    if (size.y == 0.0f)
        size.y = default_h;
    else if (size.y < 0.0f)
        size.y = ImMax(4.0f, region_max.y - window->DC.CursorPos.y + size.y);

    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa5ab9(%rip), %rcx     # 0xfbcd0
movq 0x1ae0(%rcx), %rax
xorps %xmm4, %xmm4
ucomiss %xmm0, %xmm4
ja 0x56235
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
xorps %xmm3, %xmm3
ucomiss %xmm5, %xmm4
jbe 0x5625d
movsd 0x270(%rax), %xmm3
cmpq $0x0, 0x1b0(%rax)
jne 0x56251
cmpq $0x0, 0x20a8(%rcx)
je 0x5625d
movss 0x240(%rax), %xmm4
movss %xmm4, %xmm3            # xmm3 = xmm4[0],xmm3[1,2,3]
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm0
jne 0x56267
jnp 0x5628b
ucomiss %xmm0, %xmm4
jbe 0x5628f
movss 0xd8(%rax), %xmm1
movaps %xmm3, %xmm4
subss %xmm1, %xmm4
addss %xmm0, %xmm4
movss 0x5f5dd(%rip), %xmm1    # 0xb5864
maxss %xmm4, %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm1
jne 0x562a0
jnp 0x562c1
ucomiss %xmm1, %xmm4
jbe 0x562cb
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
subss 0xdc(%rax), %xmm3
addss %xmm3, %xmm1
movss 0x5f5a7(%rip), %xmm2    # 0xb5864
maxss %xmm1, %xmm2
movlhps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm2     # xmm2 = xmm2[2,0],xmm0[2,3]
movaps %xmm2, %xmm0
popq %rbp
retq