LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ResetMouseDragDelta(int)
void ImGui::ResetMouseDragDelta(ImGuiMouseButton button)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    // NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
    g.IO.MouseClickedPos[button] = g.IO.MousePos;
}

// Assembly:
cmpl $0x5, %edi
jae 0x404ba
movq 0xa3838(%rip), %rax     # 0xe3ce0
movl %edi, %ecx
movq 0x128(%rax), %rdx
movq %rdx, 0x3cc(%rax,%rcx,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5d8b1(%rip), %rdi     # 0x9dd76
leaq 0x5ccc9(%rip), %rsi     # 0x9d195
leaq 0x5da9e(%rip), %rcx     # 0x9df71
movl $0x122c, %edx           # imm = 0x122C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemActive()
bool ImGui::IsItemActive()
{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = g.CurrentWindow;
        return g.ActiveId == window->DC.LastItemId;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa37ac(%rip), %rax     # 0xe3ce0
movl 0x1b30(%rax), %ecx
testl %ecx, %ecx
je 0x40550
movq 0x1ae0(%rax), %rax
cmpl 0x124(%rax), %ecx
sete %al
jmp 0x40552
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemActivated()
bool ImGui::IsItemActivated()
{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = g.CurrentWindow;
        if (g.ActiveId == window->DC.LastItemId && g.ActiveIdPreviousFrame != window->DC.LastItemId)
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa3781(%rip), %rcx     # 0xe3ce0
movl 0x1b30(%rcx), %edx
testl %edx, %edx
je 0x40582
movq 0x1ae0(%rcx), %rax
cmpl 0x124(%rax), %edx
jne 0x40582
movb $0x1, %al
cmpl %edx, 0x1b70(%rcx)
jne 0x40584
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemDeactivated()
bool ImGui::IsItemDeactivated()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HasDeactivated)
        return (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_Deactivated) != 0;
    return (g.ActiveIdPreviousFrame == window->DC.LastItemId && g.ActiveIdPreviousFrame != 0 && g.ActiveId != window->DC.LastItemId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa374f(%rip), %rcx     # 0xe3ce0
movq 0x1ae0(%rcx), %rdx
movl 0x128(%rdx), %eax
testb $0x20, %al
jne 0x405c1
movl 0x1b70(%rcx), %esi
xorl %eax, %eax
testl %esi, %esi
je 0x405c7
cmpl 0x124(%rdx), %esi
jne 0x405c7
cmpl %esi, 0x1b30(%rcx)
setne %al
jmp 0x405c7
andl $0x40, %eax
shrl $0x6, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetItemAllowOverlap()
void ImGui::SetItemAllowOverlap()
{
    ImGuiContext& g = *GImGui;
    ImGuiID id = g.CurrentWindow->DC.LastItemId;
    if (g.HoveredId == id)
        g.HoveredIdAllowOverlap = true;
    if (g.ActiveId == id)
        g.ActiveIdAllowOverlap = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa35d8(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rcx
movl 0x124(%rcx), %ecx
cmpl %ecx, 0x1b1c(%rax)
jne 0x40724
movb $0x1, 0x1b24(%rax)
cmpl %ecx, 0x1b30(%rax)
jne 0x40733
movb $0x1, 0x1b3d(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetItemUsingMouseWheel()
void ImGui::SetItemUsingMouseWheel()
{
    ImGuiContext& g = *GImGui;
    ImGuiID id = g.CurrentWindow->DC.LastItemId;
    if (g.HoveredId == id)
        g.HoveredIdUsingMouseWheel = true;
    if (g.ActiveId == id)
        g.ActiveIdUsingMouseWheel = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa35a0(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rcx
movl 0x124(%rcx), %ecx
cmpl %ecx, 0x1b1c(%rax)
jne 0x4075c
movb $0x1, 0x1b25(%rax)
cmpl %ecx, 0x1b30(%rax)
jne 0x4076b
movb $0x1, 0x1b42(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavInitWindow(ImGuiWindow*, bool)
void ImGui::NavInitWindow(ImGuiWindow* window, bool force_reinit)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(window == g.NavWindow);
    bool init_for_nav = false;
    if (!(window->Flags & ImGuiWindowFlags_NoNavInputs))
        if (!(window->Flags & ImGuiWindowFlags_ChildWindow) || (window->Flags & ImGuiWindowFlags_Popup) || (window->NavLastIds[0] == 0) || force_reinit)
            init_for_nav = true;
    IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: from NavInitWindow(), init_for_nav=%d, window=\"%s\", layer=%d\n", init_for_nav, window->Name, g.NavLayer);
    if (init_for_nav)
    {
        SetNavID(0, g.NavLayer, 0);
        g.NavInitRequest = true;
        g.NavInitRequestFromMove = false;
        g.NavInitResultId = 0;
        g.NavInitResultRectRel = ImRect();
        NavUpdateAnyRequestFlag();
    }
    else
    {
        g.NavId = window->NavLastIds[0];
        g.NavFocusScopeId = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xa32c0(%rip), %rbx     # 0xe3ce0
cmpq %rdi, 0x1c90(%rbx)
jne 0x40aa0
movl 0xc(%rdi), %eax
btl $0x12, %eax
jb 0x40a86
andl $0x5000000, %eax        # imm = 0x5000000
cmpl $0x1000000, %eax        # imm = 0x1000000
jne 0x40a52
movl 0x3b0(%rdi), %eax
testl %eax, %eax
setne %cl
xorb $0x1, %sil
testb %sil, %cl
jne 0x40a8c
movl 0x1cdc(%rbx), %esi
xorl %edi, %edi
xorl %edx, %edx
callq 0x45409
movw $0x1, 0x1ce9(%rbx)
andl $0x0, 0x1cec(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1cf0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42d8a
movl 0x3b0(%rdi), %eax
movl %eax, 0x1c98(%rbx)
andl $0x0, 0x1c9c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5e970(%rip), %rdi     # 0x9f417
leaq 0x5c6e7(%rip), %rsi     # 0x9d195
leaq 0x5e978(%rip), %rcx     # 0x9f42d
movl $0x2207, %edx           # imm = 0x2207
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginChildFrame(unsigned int, ImVec2 const&, int)
bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags)
{
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);
    PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
    PushStyleVar(ImGuiStyleVar_ChildBorderSize, style.FrameBorderSize);
    PushStyleVar(ImGuiStyleVar_WindowPadding, style.FramePadding);
    bool ret = BeginChild(id, size, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysUseWindowPadding | extra_flags);
    PopStyleVar(3);
    PopStyleColor();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movl %edi, %r12d
movq 0xa2abf(%rip), %r13     # 0xe3ce0
leaq 0x1694(%r13), %rsi
pushq $0x3
popq %rdi
callq 0x35e60
movss 0x15a0(%r13), %xmm0
pushq $0x6
popq %rdi
callq 0x35f08
movss 0x15a4(%r13), %xmm0
pushq $0x7
popq %rdi
callq 0x35f08
addq $0x1598, %r13           # imm = 0x1598
pushq $0x1
popq %r14
movl %r14d, %edi
movq %r13, %rsi
callq 0x35fca
orl $0x10004, %ebx          # imm = 0x10004
movl %r12d, %edi
movq %r15, %rsi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x40b0f
movl %eax, %ebx
pushq $0x3
popq %rdi
callq 0x3605c
movl %r14d, %edi
callq 0x35eb4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcWindowNextAutoFitSize(ImGuiWindow*)
ImVec2 ImGui::CalcWindowNextAutoFitSize(ImGuiWindow* window)
{
    ImVec2 size_contents_current;
    ImVec2 size_contents_ideal;
    CalcWindowContentSizes(window, &size_contents_current, &size_contents_ideal);
    ImVec2 size_auto_fit = CalcWindowAutoFitSize(window, size_contents_ideal);
    ImVec2 size_final = CalcWindowSizeAfterConstraint(window, size_auto_fit);
    return size_final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
andq $0x0, (%r14)
leaq -0x20(%rbp), %rsi
movq %r14, %rdx
callq 0x41315
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41443
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41618
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: CalcWindowContentSizes(ImGuiWindow*, ImVec2*, ImVec2*)
static void CalcWindowContentSizes(ImGuiWindow* window, ImVec2* content_size_current, ImVec2* content_size_ideal)
{
    bool preserve_old_content_sizes = false;
    if (window->Collapsed && window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0)
        preserve_old_content_sizes = true;
    else if (window->Hidden && window->HiddenFramesCannotSkipItems == 0 && window->HiddenFramesCanSkipItems > 0)
        preserve_old_content_sizes = true;
    if (preserve_old_content_sizes)
    {
        *content_size_current = window->ContentSize;
        *content_size_ideal = window->ContentSizeIdeal;
        return;
    }

    content_size_current->x = (window->ContentSizeExplicit.x != 0.0f) ? window->ContentSizeExplicit.x : IM_FLOOR(window->DC.CursorMaxPos.x - window->DC.CursorStartPos.x);
    content_size_current->y = (window->ContentSizeExplicit.y != 0.0f) ? window->ContentSizeExplicit.y : IM_FLOOR(window->DC.CursorMaxPos.y - window->DC.CursorStartPos.y);
    content_size_ideal->x = (window->ContentSizeExplicit.x != 0.0f) ? window->ContentSizeExplicit.x : IM_FLOOR(ImMax(window->DC.CursorMaxPos.x, window->DC.IdealMaxPos.x) - window->DC.CursorStartPos.x);
    content_size_ideal->y = (window->ContentSizeExplicit.y != 0.0f) ? window->ContentSizeExplicit.y : IM_FLOOR(ImMax(window->DC.CursorMaxPos.y, window->DC.IdealMaxPos.y) - window->DC.CursorStartPos.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x91(%rdi)
jne 0x41338
cmpb $0x0, 0xa4(%rdi)
jg 0x41338
cmpb $0x0, 0xa5(%rdi)
jle 0x41433
cmpb $0x1, 0x95(%rdi)
jne 0x4134e
cmpb $0x0, 0xad(%rdi)
je 0x41426
movss 0x38(%rdi), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x41374
jp 0x41374
movss 0xf0(%rdi), %xmm1
subss 0xe8(%rdi), %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, (%rsi)
movss 0x3c(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jne 0x4139b
jp 0x4139b
movss 0xf4(%rdi), %xmm0
subss 0xec(%rdi), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm1
movss %xmm1, 0x4(%rsi)
movss 0x38(%rdi), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x413df
jp 0x413df
movss 0xf0(%rdi), %xmm1
movss 0xf8(%rdi), %xmm2
movaps %xmm2, %xmm3
cmpless %xmm1, %xmm3
andps %xmm3, %xmm1
andnps %xmm2, %xmm3
orps %xmm1, %xmm3
subss 0xe8(%rdi), %xmm3
cvttps2dq %xmm3, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, (%rdx)
movss 0x3c(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jne 0x4141f
jp 0x4141f
movss 0xf4(%rdi), %xmm0
movss 0xfc(%rdi), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
subss 0xec(%rdi), %xmm2
cvttps2dq %xmm2, %xmm0
cvtdq2ps %xmm0, %xmm1
movss %xmm1, 0x4(%rdx)
popq %rbp
retq
cmpb $0x0, 0xac(%rdi)
jle 0x4134e
movq 0x28(%rdi), %rax
movq %rax, (%rsi)
movq 0x30(%rdi), %rax
movq %rax, (%rdx)
jmp 0x41424
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetWindowResizeID(ImGuiWindow*, int)
ImGuiID ImGui::GetWindowResizeID(ImGuiWindow* window, int n)
{
    IM_ASSERT(n >= 0 && n <= 7);
    ImGuiID id = window->ID;
    id = ImHashStr("#RESIZE", 0, id);
    id = ImHashData(&n, sizeof(int), id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %esi, -0x4(%rbp)
cmpl $0x8, %esi
jae 0x41802
movl 0x8(%rdi), %edx
leaq 0x5c8bb(%rip), %rdi     # 0x9e0a2
xorl %esi, %esi
callq 0x3479a
leaq -0x4(%rbp), %rdi
pushq $0x4
popq %rsi
movl %eax, %edx
callq 0x34768
addq $0x10, %rsp
popq %rbp
retq
leaq 0x5c853(%rip), %rdi     # 0x9e05c
leaq 0x5b985(%rip), %rsi     # 0x9d195
leaq 0x5c856(%rip), %rcx     # 0x9e06d
movl $0x1440, %edx           # imm = 0x1440
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow*, int, ImGuiWindow*)
void ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window)
{
    window->ParentWindow = parent_window;
    window->RootWindow = window->RootWindowForTitleBarHighlight = window->RootWindowForNav = window;
    if (parent_window && (flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Tooltip))
        window->RootWindow = parent_window->RootWindow;
    if (parent_window && !(flags & ImGuiWindowFlags_Modal) && (flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)))
        window->RootWindowForTitleBarHighlight = parent_window->RootWindowForTitleBarHighlight;
    while (window->RootWindowForNav->Flags & ImGuiWindowFlags_NavFlattened)
    {
        IM_ASSERT(window->RootWindowForNav->ParentWindow != NULL);
        window->RootWindowForNav = window->RootWindowForNav->ParentWindow;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, 0x388(%rdi)
movq %rdi, 0x3a0(%rdi)
movq %rdi, 0x398(%rdi)
movq %rdi, 0x390(%rdi)
testq %rdx, %rdx
sete %al
movl %esi, %ecx
andl $0x3000000, %ecx        # imm = 0x3000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
setne %cl
orb %al, %cl
jne 0x4186a
movq 0x390(%rdx), %rax
movq %rax, 0x390(%rdi)
testq %rdx, %rdx
je 0x4188e
movl %esi, %eax
andl $0x8000000, %eax        # imm = 0x8000000
jne 0x4188e
andl $0x5000000, %esi        # imm = 0x5000000
je 0x4188e
movq 0x398(%rdx), %rax
movq %rax, 0x398(%rdi)
movq %rdi, %rax
testb $-0x80, 0xe(%rax)
je 0x418ac
movq 0x388(%rax), %rax
testq %rax, %rax
je 0x418ae
movq %rax, 0x3a0(%rdi)
jmp 0x41891
popq %rbp
retq
leaq 0x5c7f5(%rip), %rdi     # 0x9e0aa
leaq 0x5b8d9(%rip), %rsi     # 0x9d195
leaq 0x5c818(%rip), %rcx     # 0x9e0db
movl $0x159b, %edx           # imm = 0x159B
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStackSizes::SetToCurrentState()
void ImGuiStackSizes::SetToCurrentState()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    SizeOfIDStack = (short)window->IDStack.Size;
    SizeOfColorStack = (short)g.ColorStack.Size;
    SizeOfStyleVarStack = (short)g.StyleVarStack.Size;
    SizeOfFontStack = (short)g.FontStack.Size;
    SizeOfFocusScopeStack = (short)g.FocusScopeStack.Size;
    SizeOfGroupStack = (short)g.GroupStack.Size;
    SizeOfBeginPopupStack = (short)g.BeginPopupStack.Size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa2399(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rcx
movzwl 0xc8(%rcx), %ecx
movw %cx, (%rdi)
movzwl 0x1c10(%rax), %ecx
movw %cx, 0x2(%rdi)
movzwl 0x1c20(%rax), %ecx
movw %cx, 0x4(%rdi)
movzwl 0x1c30(%rax), %ecx
movw %cx, 0x6(%rdi)
movzwl 0x1c40(%rax), %ecx
movw %cx, 0x8(%rdi)
movzwl 0x1c60(%rax), %ecx
movw %cx, 0xa(%rdi)
movzwl 0x1c80(%rax), %eax
movw %ax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowSize(ImGuiWindow*, ImVec2 const&, int)
void ImGui::SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
        return;

    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    window->SetWindowSizeAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);

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

// Assembly:
movl 0xaf(%rdi), %eax
testl %edx, %edx
je 0x419b9
movl %eax, %ecx
shrl $0x8, %ecx
movsbl %cl, %ecx
testl %edx, %ecx
je 0x41a1b
leal -0x1(%rdx), %ecx
testl %ecx, %edx
jne 0x41a1c
andl $0xfffff1ff, %eax       # imm = 0xFFFFF1FF
movl %eax, 0xaf(%rdi)
movss (%rsi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x419e0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0x20(%rdi)
xorl %eax, %eax
jmp 0x419e9
movb $0x0, 0xa7(%rdi)
movb $0x2, %al
movb %al, 0xa4(%rdi)
movss 0x4(%rsi), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x41a0d
movb $0x0, 0xa5(%rdi)
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0x24(%rdi)
retq
movb $0x2, 0xa5(%rdi)
movb $0x0, 0xa7(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5cb25(%rip), %rdi     # 0x9e54c
leaq 0x5b767(%rip), %rsi     # 0x9d195
leaq 0x5cb7c(%rip), %rcx     # 0x9e5b1
movl $0x19b3, %edx           # imm = 0x19B3
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: SetCurrentWindow(ImGuiWindow*)
static void SetCurrentWindow(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    g.CurrentWindow = window;
    g.CurrentTable = window && window->DC.CurrentTableIdx != -1 ? g.Tables.GetByIndex(window->DC.CurrentTableIdx) : NULL;
    if (window)
        g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa2265(%rip), %r14     # 0xe3ce0
movq %rdi, 0x1ae0(%r14)
testq %rdi, %rdi
je 0x41aa3
movq %rdi, %rbx
movl 0x1b8(%rdi), %esi
cmpl $-0x1, %esi
je 0x41aad
leaq 0x20b0(%r14), %rdi
callq 0x4c6b6
jmp 0x41aaf
andq $0x0, 0x20a8(%r14)
jmp 0x41ad0
xorl %eax, %eax
movq %rax, 0x20a8(%r14)
movq %rbx, %rdi
callq 0x4b6fc
movss %xmm0, 0x1998(%r14)
movss %xmm0, 0x1980(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa1de3(%rip), %rbx     # 0xe3ce0
cmpb $0x1, 0x3138(%rbx)
jne 0x41f3e
leaq 0x66cba(%rip), %rdi     # 0xa8bc7
xorl %eax, %eax
callq 0x462f3
movl 0x313c(%rbx), %eax
cmpq $0x4, %rax
ja 0x41f70
leaq 0x5aa2d(%rip), %rcx     # 0x9c954
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x3140(%rbx), %rdi
callq 0xc480
jmp 0x41f70
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x3140(%rbx), %rdi
callq 0x3483a
jmp 0x41f70
cmpl $0x2, 0x3148(%rbx)
jl 0x41f70
leaq 0x3148(%rbx), %rdi
callq 0x4b9e8
movq %rax, %rdi
callq 0x37a0c
movb $0x0, 0x3138(%rbx)
andl $0x0, 0x313c(%rbx)
andq $0x0, 0x3140(%rbx)
addq $0x3148, %rbx           # imm = 0x3148
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b1ac
leaq 0x5d17a(%rip), %rdi     # 0x9f11c
leaq 0x5b1ec(%rip), %rsi     # 0x9d195
leaq 0x5d893(%rip), %rcx     # 0x9f843
movl $0x26fa, %edx           # imm = 0x26FA
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa1d1b(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rcx
movswl (%rdi), %edx
cmpl %edx, 0xc8(%rcx)
jne 0x42035
movswl 0xa(%rdi), %ecx
cmpl %ecx, 0x1c60(%rax)
jne 0x42054
movswl 0xc(%rdi), %ecx
cmpl %ecx, 0x1c80(%rax)
jne 0x42073
movswl 0x2(%rdi), %ecx
cmpl %ecx, 0x1c10(%rax)
jg 0x42092
movswl 0x4(%rdi), %ecx
cmpl %ecx, 0x1c20(%rax)
jg 0x420b1
movswl 0x6(%rdi), %ecx
cmpl %ecx, 0x1c30(%rax)
jg 0x420d0
movswl 0x8(%rdi), %ecx
cmpl %ecx, 0x1c40(%rax)
jne 0x420ef
popq %rbp
retq
leaq 0x5cbe4(%rip), %rdi     # 0x9ec20
leaq 0x5b152(%rip), %rsi     # 0x9d195
leaq 0x5cc2c(%rip), %rcx     # 0x9ec76
movl $0x1bcd, %edx           # imm = 0x1BCD
callq 0xc140
leaq 0x5cc4b(%rip), %rdi     # 0x9eca6
leaq 0x5b133(%rip), %rsi     # 0x9d195
leaq 0x5cc0d(%rip), %rcx     # 0x9ec76
movl $0x1bd1, %edx           # imm = 0x1BD1
callq 0xc140
leaq 0x5cc75(%rip), %rdi     # 0x9ecef
leaq 0x5b114(%rip), %rsi     # 0x9d195
leaq 0x5cbee(%rip), %rcx     # 0x9ec76
movl $0x1bd2, %edx           # imm = 0x1BD2
callq 0xc140
leaq 0x5ccbe(%rip), %rdi     # 0x9ed57
leaq 0x5b0f5(%rip), %rsi     # 0x9d195
leaq 0x5cbcf(%rip), %rcx     # 0x9ec76
movl $0x1bd3, %edx           # imm = 0x1BD3
callq 0xc140
leaq 0x5ccf1(%rip), %rdi     # 0x9eda9
leaq 0x5b0d6(%rip), %rsi     # 0x9d195
leaq 0x5cbb0(%rip), %rcx     # 0x9ec76
movl $0x1bd4, %edx           # imm = 0x1BD4
callq 0xc140
leaq 0x5cd26(%rip), %rdi     # 0x9edfd
leaq 0x5b0b7(%rip), %rsi     # 0x9d195
leaq 0x5cb91(%rip), %rcx     # 0x9ec76
movl $0x1bd5, %edx           # imm = 0x1BD5
callq 0xc140
leaq 0x5cd4b(%rip), %rdi     # 0x9ee41
leaq 0x5b098(%rip), %rsi     # 0x9d195
leaq 0x5cb72(%rip), %rcx     # 0x9ec76
movl $0x1bd6, %edx           # imm = 0x1BD6
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1a98, %r14d          # imm = 0x1A98
addq 0xa1bb7(%rip), %r14     # 0xe3ce0
movq %r14, %rdi
callq 0x4b3bc
cmpq %rbx, (%rax)
je 0x4219b
movl (%r14), %r15d
decl %r15d
movl %r15d, %r12d
decl %r12d
js 0x4219b
movq %r14, %rdi
movl %r12d, %esi
callq 0x4ad62
cmpq %rbx, (%rax)
je 0x42159
movl %r12d, %r15d
jmp 0x4213f
leal -0x1(%r15), %esi
movq %r14, %rdi
callq 0x4ad62
movq %rax, %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x4ad62
movl (%r14), %ecx
subl %r15d, %ecx
movslq %ecx, %rdx
shlq $0x3, %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0xc130
movl (%r14), %esi
decl %esi
movq %r14, %rdi
callq 0x4ad62
movq %rbx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1a88, %r14d          # imm = 0x1A88
addq 0xa1b21(%rip), %r14     # 0xe3ce0
movq %r14, %rdi
callq 0x4b3bc
movq (%rax), %rax
cmpq %rbx, %rax
je 0x4223d
cmpq %rbx, 0x390(%rax)
je 0x4223d
movl (%r14), %r15d
decl %r15d
movl %r15d, %r12d
decl %r12d
js 0x4223d
movq %r14, %rdi
movl %r12d, %esi
callq 0x4ad62
cmpq %rbx, (%rax)
je 0x421fb
movl %r12d, %r15d
jmp 0x421e1
leal -0x1(%r15), %esi
movq %r14, %rdi
callq 0x4ad62
movq %rax, %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x4ad62
movl (%r14), %ecx
subl %r15d, %ecx
movslq %ecx, %rdx
shlq $0x3, %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0xc130
movl (%r14), %esi
decl %esi
movq %r14, %rdi
callq 0x4ad62
movq %rbx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1a88, %r14d          # imm = 0x1A88
addq 0xa1a7f(%rip), %r14     # 0xe3ce0
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0x4ad62
cmpq %rbx, (%rax)
je 0x422c7
xorl %r15d, %r15d
cmpl (%r14), %r12d
jge 0x422c7
movq %r14, %rdi
movl %r12d, %esi
callq 0x4ad62
cmpq %rbx, (%rax)
je 0x42294
incl %r12d
addq $0x8, %r15
jmp 0x42276
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4ad62
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0x4ad62
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xc130
movq %r14, %rdi
xorl %esi, %esi
callq 0x4ad62
movq %rbx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindWindowFocusIndex(ImGuiWindow*)
static int ImGui::FindWindowFocusIndex(ImGuiWindow* window) // FIXME-OPT O(N)
{
    ImGuiContext& g = *GImGui;
    for (int i = g.WindowsFocusOrder.Size - 1; i >= 0; i--)
        if (g.WindowsFocusOrder[i] == window)
            return i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xa19fb(%rip), %r15     # 0xe3ce0
movl 0x1a98(%r15), %ebx
addq $0x1a98, %r15           # imm = 0x1A98
pushq $-0x1
popq %r12
testl %ebx, %ebx
jle 0x4230e
decl %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x4ad62
cmpq %r14, (%rax)
jne 0x422f7
jmp 0x42311
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, -0x18(%rbp)
movq 0xa19ae(%rip), %r14     # 0xe3ce0
testq %rdi, %rdi
jne 0x42343
callq 0x4ad33
movq %rax, %rdi
movq %rax, -0x18(%rbp)
callq 0x3b8f4
leaq 0x1c30(%r14), %rdi
leaq -0x18(%rbp), %rbx
movq %rbx, %rsi
callq 0x4b72e
movq 0x1ae0(%r14), %rax
movq 0x2b8(%rax), %rdi
movq (%rbx), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x6233e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq 0xa1950(%rip), %r14     # 0xe3ce0
movq 0x1ae0(%r14), %rax
movq 0x2b8(%rax), %rdi
callq 0x6237a
leaq 0x1c30(%r14), %rbx
movq %rbx, %rdi
callq 0x4b77c
cmpl $0x0, 0x1c30(%r14)
je 0x423c9
movq %rbx, %rdi
callq 0x4b7aa
movq (%rax), %rdi
jmp 0x423d1
callq 0x4ad33
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3b8f4
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %r15d
movq 0xa18eb(%rip), %rbx     # 0xe3ce0
movq 0x1ae0(%rbx), %r12
movl 0x1cc(%r12), %r13d
addq $0x1c50, %rbx           # imm = 0x1C50
movq %rbx, %rdi
callq 0x4b668
cmpl (%rax), %r13d
jne 0x42450
movl %r15d, %eax
notl %eax
andl %r13d, %eax
orl %r15d, %r13d
testb %r14b, %r14b
cmovel %eax, %r13d
leaq -0x2c(%rbp), %rsi
movl %r13d, (%rsi)
movl %r13d, 0x1cc(%r12)
movq %rbx, %rdi
callq 0x4ae88
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5bfd9(%rip), %rdi     # 0x9e430
leaq 0x5ad37(%rip), %rsi     # 0x9d195
leaq 0x5bff1(%rip), %rcx     # 0x9e456
movl $0x18df, %edx           # imm = 0x18DF
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa1863(%rip), %rbx     # 0xe3ce0
cmpl $0x1, 0x1c50(%rbx)
jle 0x424b2
movq 0x1ae0(%rbx), %r14
addq $0x1c50, %rbx           # imm = 0x1C50
movq %rbx, %rdi
callq 0x4b7e2
movq %rbx, %rdi
callq 0x4b668
movl (%rax), %eax
movl %eax, 0x1cc(%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5bfcc(%rip), %rdi     # 0x9e485
leaq 0x5acd5(%rip), %rsi     # 0x9d195
leaq 0x5bfd8(%rip), %rcx     # 0x9e49f
movl $0x18ec, %edx           # imm = 0x18EC
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testb $0x40, %bl
jne 0x426a1
movq 0xa171e(%rip), %r15     # 0xe3ce0
testb $0x4, %bl
jne 0x425f2
movl %ebx, %eax
andl $0x3, %eax
leaq 0x5a395(%rip), %rcx     # 0x9c968
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x1ae8(%r15), %r14
cmpq 0x1ae0(%r15), %r14
jne 0x42694
jmp 0x42602
movq 0x1ae8(%r15), %r14
testq %r14, %r14
je 0x42694
movq %r14, %rdi
movl %ebx, %esi
callq 0x37606
testb %al, %al
je 0x42694
testb $0x20, %bl
jne 0x42634
movl 0x1b30(%r15), %eax
testl %eax, %eax
je 0x42634
cmpb $0x0, 0x1b3d(%r15)
jne 0x42634
cmpl 0x54(%r14), %eax
jne 0x42694
movb $0x1, %al
jmp 0x42696
movq 0x1ae0(%r15), %rax
movq 0x1ae8(%r15), %r14
cmpq 0x390(%rax), %r14
jne 0x42694
jmp 0x42602
movq 0x1ae0(%r15), %rax
movq 0x1af0(%r15), %rcx
cmpq 0x390(%rax), %rcx
jne 0x42694
movq 0x1ae8(%r15), %r14
jmp 0x42602
movq 0x1ae8(%r15), %r14
testq %r14, %r14
je 0x42694
movq 0x1ae0(%r15), %rsi
movq %r14, %rdi
callq 0x38af8
testb %al, %al
jne 0x42602
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5be11(%rip), %rdi     # 0x9e4b9
leaq 0x5aae6(%rip), %rsi     # 0x9d195
leaq 0x5be38(%rip), %rcx     # 0x9e4ee
movl $0x1931, %edx           # imm = 0x1931
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edi, %eax
movq 0xa1617(%rip), %rcx     # 0xe3ce0
testb $0x4, %al
jne 0x426f8
movq 0x1ae0(%rcx), %rsi
testq %rsi, %rsi
je 0x42731
andl $0x3, %eax
movq 0x1c90(%rcx), %rdi
leaq 0x5a28e(%rip), %rcx     # 0x9c978
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq %rsi, %rdi
jmp 0x42720
cmpq $0x0, 0x1c90(%rcx)
setne %al
retq
cmpq 0x390(%rsi), %rdi
jmp 0x42720
testq %rdi, %rdi
je 0x4272e
movq 0x390(%rdi), %rax
cmpq 0x390(%rsi), %rax
sete %al
retq
testq %rdi, %rdi
je 0x4272e
jmp 0x38af8
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x73d78(%rip), %rdi     # 0xb64b4
leaq 0x5aa52(%rip), %rsi     # 0x9d195
leaq 0x5bdd3(%rip), %rcx     # 0x9e51d
movl $0x195f, %edx           # imm = 0x195F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4298f
pushq %rbp
movq %rsp, %rbp
callq 0x412c3
testq %rax, %rax
popq %rbp
je 0x42996
movq %rax, %rdi
jmp 0x37fa1
xorl %edi, %edi
jmp 0x37fa1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x429cd
movq 0xa133b(%rip), %rax     # 0xe3ce0
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 0x5bb74(%rip), %rdi     # 0x9e54c
leaq 0x5a7b6(%rip), %rsi     # 0x9d195
leaq 0x5bc7e(%rip), %rcx     # 0x9e664
movl $0x1a16, %edx           # imm = 0x1A16
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa12e5(%rip), %rax     # 0xe3ce0
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_O2/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 0x42aa5
movq 0xa1256(%rip), %rax     # 0xe3ce0
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 0x5ba9c(%rip), %rdi     # 0x9e54c
leaq 0x5a6de(%rip), %rsi     # 0x9d195
leaq 0x5bc27(%rip), %rcx     # 0x9e6e5
movl $0x1a42, %edx           # imm = 0x1A42
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x42b9f
movq 0xa1173(%rip), %rbx     # 0xe3ce0
movq 0x1ae0(%rbx), %rdi
movb $0x1, 0x90(%rdi)
movss %xmm0, 0x2b0(%rdi)
callq 0x4b6fc
movss %xmm0, 0x1998(%rbx)
movss %xmm0, 0x1980(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5bb73(%rip), %rdi     # 0x9e719
leaq 0x5a5e8(%rip), %rsi     # 0x9d195
leaq 0x5bb72(%rip), %rcx     # 0x9e726
movl $0x1a6c, %edx           # imm = 0x1A6C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movl %edi, %ebx
movq 0xa10ff(%rip), %rdi     # 0xe3ce0
movq 0x1ae0(%rdi), %r14
addq $0x1c40, %rdi           # imm = 0x1C40
leaq 0x158(%r14), %rsi
callq 0x49fbe
movl %ebx, 0x158(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa10cb(%rip), %rbx     # 0xe3ce0
cmpl $0x0, 0x1c40(%rbx)
jle 0x42c49
movq 0x1ae0(%rbx), %r14
addq $0x1c40, %rbx           # imm = 0x1C40
movq %rbx, %rdi
callq 0x4a148
movl (%rax), %eax
movl %eax, 0x158(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4b8c4
leaq 0x5bafc(%rip), %rdi     # 0x9e74c
leaq 0x5a53e(%rip), %rsi     # 0x9d195
leaq 0x5bb09(%rip), %rcx     # 0x9e767
movl $0x1a85, %edx           # imm = 0x1A85
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x42c9d
movq 0xa106c(%rip), %rax     # 0xe3ce0
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 0x5badb(%rip), %rdi     # 0x9e783
leaq 0x5a4e6(%rip), %rsi     # 0x9d195
leaq 0x5bada(%rip), %rcx     # 0x9e790
movl $0x1a8c, %edx           # imm = 0x1A8C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa1015(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rdx
cmpb $0x1, 0x94(%rdx)
jne 0x42ceb
movq 0x1c90(%rax), %rcx
cmpq 0x3a0(%rdx), %rcx
je 0x42ced
popq %rbp
retq
cmpb $0x0, 0x1ce9(%rax)
jne 0x42cff
cmpl $0x0, 0x1cec(%rax)
je 0x42ceb
movl 0x1cdc(%rax), %edx
cmpl 0x14c(%rcx), %edx
jne 0x42ceb
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)
callq 0x42d8a
callq 0x406b8
testb %al, %al
jne 0x42ceb
movss 0x59294(%rip), %xmm0    # 0x9c018
popq %rbp
jmp 0x42de1
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavUpdateAnyRequestFlag()
static inline void ImGui::NavUpdateAnyRequestFlag()
{
    ImGuiContext& g = *GImGui;
    g.NavAnyRequest = g.NavMoveRequest || g.NavInitRequest || (IMGUI_DEBUG_NAV_SCORING && g.NavWindow != NULL);
    if (g.NavAnyRequest)
        IM_ASSERT(g.NavWindow != NULL);
}

// Assembly:
movq 0xa0f4f(%rip), %rax     # 0xe3ce0
cmpb $0x0, 0x1d00(%rax)
je 0x42da3
movb $0x1, 0x1ce8(%rax)
jmp 0x42db3
movb 0x1ce9(%rax), %cl
movb %cl, 0x1ce8(%rax)
testb %cl, %cl
je 0x42dbd
cmpq $0x0, 0x1c90(%rax)
je 0x42dbe
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5e495(%rip), %rdi     # 0xa125e
leaq 0x5a3c5(%rip), %rsi     # 0x9d195
leaq 0x5e49d(%rip), %rcx     # 0xa1274
movl $0x2200, %edx           # imm = 0x2200
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa0eef(%rip), %rax     # 0xe3ce0
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 0x442f7
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_O2/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 %rbx
pushq %rax
movq %rdi, %rsi
movq 0xa0e2c(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x37198
leaq -0xc(%rbp), %rsi
movl %eax, (%rsi)
addq $0xc8, %rbx
movq %rbx, %rdi
callq 0x49fbe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
movq 0xa0dec(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x37198
leaq -0xc(%rbp), %rsi
movl %eax, (%rsi)
addq $0xc8, %rbx
movq %rbx, %rdi
callq 0x49fbe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq