LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderTextClipped(ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*)
void ImGui::RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
    // Hide anything after a '##' string
    const char* text_display_end = FindRenderedTextEnd(text, text_end);
    const int text_len = (int)(text_display_end - text);
    if (text_len == 0)
        return;

    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    RenderTextClippedEx(window->DrawList, pos_min, pos_max, text, text_display_end, text_size_if_known, align, clip_rect);
    if (g.LogEnabled)
        LogRenderedText(&pos_min, text, text_display_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rax
movq %r8, %r9
movq %rdx, %rbx
movq %rsi, %rdx
xorl %esi, %esi
cmpq $0x1, %rcx
sbbq %rsi, %rsi
movq %rdi, %r14
orq %rcx, %rsi
movq %rbx, %r15
cmpq %rbx, %rsi
jbe 0x45579
movq %rbx, %r15
movzbl (%r15), %ecx
cmpl $0x23, %ecx
je 0x45567
testl %ecx, %ecx
jne 0x4556e
jmp 0x45579
cmpb $0x23, 0x1(%r15)
je 0x45579
incq %r15
cmpq %rsi, %r15
jne 0x45558
movq %rsi, %r15
cmpl %ebx, %r15d
je 0x455cb
movq 0xb874b(%rip), %r12     # 0xfdcd0
movq 0x1ae0(%r12), %rcx
movq 0x2b8(%rcx), %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %r15, %r8
pushq 0x10(%rbp)
pushq %rax
callq 0x4526d
addq $0x10, %rsp
cmpb $0x1, 0x3138(%r12)
jne 0x455cb
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x44fd9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderFrame(ImVec2, ImVec2, unsigned int, bool, float)
void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
    const float border_size = g.Style.FrameBorderSize;
    if (border && border_size > 0.0f)
    {
        window->DrawList->AddRect(p_min + ImVec2(1, 1), p_max + ImVec2(1, 1), GetColorU32(ImGuiCol_BorderShadow), rounding, ImDrawCornerFlags_All, border_size);
        window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, ImDrawCornerFlags_All, border_size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ecx
leaq -0x40(%rbp), %rsi
movlps %xmm0, (%rsi)
leaq -0x38(%rbp), %rdx
movlps %xmm1, (%rdx)
movq 0xb82c1(%rip), %r15     # 0xfdcd0
movq 0x1ae0(%r15), %r14
movq 0x2b8(%r14), %rdi
movss %xmm2, -0x30(%rbp)
movaps %xmm2, %xmm0
movl $0xf, %r8d
callq 0x79d4a
testl %ebx, %ebx
je 0x45b4d
movss 0x15a4(%r15), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jbe 0x45b4d
movq 0x2b8(%r14), %r15
movss 0x71588(%rip), %xmm0    # 0xb6fe4
leaq -0x40(%rbp), %rax
movss %xmm1, -0x2c(%rbp)
movss (%rax), %xmm1
addss %xmm0, %xmm1
movss 0x4(%rax), %xmm2
addss %xmm0, %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
leaq -0x60(%rbp), %r13
leaq -0x38(%rbp), %rax
movss (%rax), %xmm2
addss %xmm0, %xmm2
addss 0x4(%rax), %xmm0
movlps %xmm1, (%r13)
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
leaq -0x58(%rbp), %rbx
movlps %xmm2, (%rbx)
movq 0xb822c(%rip), %rax     # 0xfdcd0
movups 0x1684(%rax), %xmm0
leaq -0x50(%rbp), %r12
movaps %xmm0, (%r12)
movss 0x1560(%rax), %xmm0
mulss 0xc(%r12), %xmm0
movss %xmm0, 0xc(%r12)
movq %r12, %rdi
callq 0x42e9e
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movl %eax, %ecx
movss -0x30(%rbp), %xmm0
movl $0xf, %r8d
movss -0x2c(%rbp), %xmm1
callq 0x79c80
movq 0x2b8(%r14), %rbx
movq 0xb81d0(%rip), %rax     # 0xfdcd0
movups 0x1674(%rax), %xmm0
movaps %xmm0, (%r12)
movss 0x1560(%rax), %xmm0
mulss 0xc(%r12), %xmm0
movss %xmm0, 0xc(%r12)
leaq -0x50(%rbp), %rdi
callq 0x42e9e
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %eax, %ecx
movss -0x30(%rbp), %xmm0
movl $0xf, %r8d
movss -0x2c(%rbp), %xmm1
callq 0x79c80
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderFrameBorder(ImVec2, ImVec2, float)
void ImGui::RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const float border_size = g.Style.FrameBorderSize;
    if (border_size > 0.0f)
    {
        window->DrawList->AddRect(p_min + ImVec2(1, 1), p_max + ImVec2(1, 1), GetColorU32(ImGuiCol_BorderShadow), rounding, ImDrawCornerFlags_All, border_size);
        window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, ImDrawCornerFlags_All, border_size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movlps %xmm0, -0x40(%rbp)
movlps %xmm1, -0x38(%rbp)
movq 0xb8154(%rip), %rax     # 0xfdcd0
movss 0x15a4(%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jbe 0x45c95
movq 0x1ae0(%rax), %r14
movq 0x2b8(%r14), %r15
movss 0x7143e(%rip), %xmm0    # 0xb6fe4
leaq -0x40(%rbp), %rcx
movss %xmm1, -0x30(%rbp)
movss (%rcx), %xmm1
addss %xmm0, %xmm1
movss %xmm2, -0x2c(%rbp)
movss 0x4(%rcx), %xmm2
addss %xmm0, %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
leaq -0x60(%rbp), %r13
movlps %xmm1, (%r13)
leaq -0x38(%rbp), %rcx
movss (%rcx), %xmm1
addss %xmm0, %xmm1
addss 0x4(%rcx), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
leaq -0x58(%rbp), %rbx
movlps %xmm1, (%rbx)
movups 0x1684(%rax), %xmm0
leaq -0x50(%rbp), %r12
movaps %xmm0, (%r12)
movss 0x1560(%rax), %xmm0
mulss 0xc(%r12), %xmm0
movss %xmm0, 0xc(%r12)
movq %r12, %rdi
callq 0x42e9e
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl $0xf, %r8d
movss -0x30(%rbp), %xmm1
callq 0x79c80
movq 0x2b8(%r14), %rbx
movq 0xb8088(%rip), %rax     # 0xfdcd0
movups 0x1674(%rax), %xmm0
movaps %xmm0, (%r12)
movss 0x1560(%rax), %xmm0
mulss 0xc(%r12), %xmm0
movss %xmm0, 0xc(%r12)
leaq -0x50(%rbp), %rdi
callq 0x42e9e
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl $0xf, %r8d
movss -0x30(%rbp), %xmm1
callq 0x79c80
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetID(char const*, char const*)
ImGuiID ImGuiWindow::GetID(const char* str, const char* str_end)
{
    ImGuiID seed = IDStack.back();
    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
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x462b3
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
movq %rdx, %rcx
subq %rsi, %rcx
testq %rdx, %rdx
cmoveq %rdx, %rcx
movq %rsi, %rdi
movq %rcx, %rsi
movl %eax, %edx
callq 0x428dc
movq 0xb7a3c(%rip), %rcx     # 0xfdcd0
cmpl %eax, 0x1b30(%rcx)
jne 0x462a2
movl %eax, 0x1b34(%rcx)
cmpl %eax, 0x1b70(%rcx)
jne 0x462b1
movb $0x1, 0x1b74(%rcx)
popq %rbp
retq
leaq 0x89720(%rip), %rdi     # 0xcf9da
leaq 0x753ca(%rip), %rsi     # 0xbb68b
leaq 0x76730(%rip), %rcx     # 0xbc9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::KeepAliveID(unsigned int)
void ImGui::KeepAliveID(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId == id)
        g.ActiveIdIsAlive = id;
    if (g.ActiveIdPreviousFrame == id)
        g.ActiveIdPreviousFrameIsAlive = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb7795(%rip), %rax     # 0xfdcd0
cmpl %edi, 0x1b30(%rax)
jne 0x46549
movl %edi, 0x1b34(%rax)
cmpl %edi, 0x1b70(%rax)
jne 0x46558
movb $0x1, 0x1b74(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetID(void const*)
ImGuiID ImGuiWindow::GetID(const void* ptr)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashData(&ptr, sizeof(void*), seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO(id, ImGuiDataType_Pointer, ptr);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x465cd
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
notl %eax
xorl %ecx, %ecx
leaq 0x71458(%rip), %rdx     # 0xb79e0
movzbl %al, %esi
shrl $0x8, %eax
movzbl -0x8(%rbp,%rcx), %edi
xorl %esi, %edi
xorl (%rdx,%rdi,4), %eax
incq %rcx
cmpq $0x8, %rcx
jne 0x46588
notl %eax
movq 0xb7726(%rip), %rcx     # 0xfdcd0
cmpl %eax, 0x1b30(%rcx)
jne 0x465b8
movl %eax, 0x1b34(%rcx)
cmpl %eax, 0x1b70(%rcx)
jne 0x465c7
movb $0x1, 0x1b74(%rcx)
addq $0x10, %rsp
popq %rbp
retq
leaq 0x89406(%rip), %rdi     # 0xcf9da
leaq 0x750b0(%rip), %rsi     # 0xbb68b
leaq 0x76416(%rip), %rcx     # 0xbc9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetID(int)
ImGuiID ImGuiWindow::GetID(int n)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashData(&n, sizeof(n), seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO(id, ImGuiDataType_S32, (intptr_t)n);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %esi, -0x4(%rbp)
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x4665e
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
notl %eax
xorl %ecx, %ecx
leaq 0x713c7(%rip), %rdx     # 0xb79e0
movzbl %al, %esi
shrl $0x8, %eax
movzbl -0x4(%rbp,%rcx), %edi
xorl %esi, %edi
xorl (%rdx,%rdi,4), %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x46619
notl %eax
movq 0xb7695(%rip), %rcx     # 0xfdcd0
cmpl %eax, 0x1b30(%rcx)
jne 0x46649
movl %eax, 0x1b34(%rcx)
cmpl %eax, 0x1b70(%rcx)
jne 0x46658
movb $0x1, 0x1b74(%rcx)
addq $0x10, %rsp
popq %rbp
retq
leaq 0x89375(%rip), %rdi     # 0xcf9da
leaq 0x7501f(%rip), %rsi     # 0xbb68b
leaq 0x76385(%rip), %rcx     # 0xbc9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetIDNoKeepAlive(void const*)
ImGuiID ImGuiWindow::GetIDNoKeepAlive(const void* ptr)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashData(&ptr, sizeof(void*), seed);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO(id, ImGuiDataType_Pointer, ptr);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x4671f
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
notl %eax
xorl %ecx, %ecx
leaq 0x712e2(%rip), %rdx     # 0xb79e0
movzbl %al, %esi
shrl $0x8, %eax
movzbl -0x8(%rbp,%rcx), %edi
xorl %esi, %edi
xorl (%rdx,%rdi,4), %eax
incq %rcx
cmpq $0x8, %rcx
jne 0x466fe
notl %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x892b4(%rip), %rdi     # 0xcf9da
leaq 0x74f5e(%rip), %rsi     # 0xbb68b
leaq 0x762c4(%rip), %rcx     # 0xbc9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetIDNoKeepAlive(int)
ImGuiID ImGuiWindow::GetIDNoKeepAlive(int n)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashData(&n, sizeof(n), seed);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO(id, ImGuiDataType_S32, (intptr_t)n);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %esi, -0x4(%rbp)
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x4678c
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
notl %eax
xorl %ecx, %ecx
leaq 0x71275(%rip), %rdx     # 0xb79e0
movzbl %al, %esi
shrl $0x8, %eax
movzbl -0x4(%rbp,%rcx), %edi
xorl %esi, %edi
xorl (%rdx,%rdi,4), %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x4676b
notl %eax
addq $0x10, %rsp
popq %rbp
retq
leaq 0x89247(%rip), %rdi     # 0xcf9da
leaq 0x74ef1(%rip), %rsi     # 0xbb68b
leaq 0x76257(%rip), %rcx     # 0xbc9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetIDFromRectangle(ImRect const&)
ImGuiID ImGuiWindow::GetIDFromRectangle(const ImRect& r_abs)
{
    ImGuiID seed = IDStack.back();
    const int r_rel[4] = { (int)(r_abs.Min.x - Pos.x), (int)(r_abs.Min.y - Pos.y), (int)(r_abs.Max.x - Pos.x), (int)(r_abs.Max.y - Pos.y) };
    ImGuiID id = ImHashData(&r_rel, sizeof(r_rel), seed);
    ImGui::KeepAliveID(id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0xc8(%rdi), %rax
testq %rax, %rax
jle 0x46868
movq 0xd0(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %eax
movss (%rsi), %xmm0
movss 0x10(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x10(%rbp)
movss 0x4(%rsi), %xmm0
movss 0x14(%rdi), %xmm2
subss %xmm2, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0xc(%rbp)
movss 0x8(%rsi), %xmm0
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x8(%rbp)
movss 0xc(%rsi), %xmm0
subss %xmm2, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x4(%rbp)
notl %eax
xorl %ecx, %ecx
leaq 0x711bd(%rip), %rdx     # 0xb79e0
movzbl %al, %esi
shrl $0x8, %eax
movzbl -0x10(%rbp,%rcx), %edi
xorl %esi, %edi
xorl (%rdx,%rdi,4), %eax
incq %rcx
cmpq $0x10, %rcx
jne 0x46823
notl %eax
movq 0xb748b(%rip), %rcx     # 0xfdcd0
cmpl %eax, 0x1b30(%rcx)
jne 0x46853
movl %eax, 0x1b34(%rcx)
cmpl %eax, 0x1b70(%rcx)
jne 0x46862
movb $0x1, 0x1b74(%rcx)
addq $0x10, %rsp
popq %rbp
retq
leaq 0x8916b(%rip), %rdi     # 0xcf9da
leaq 0x74e15(%rip), %rsi     # 0xbb68b
leaq 0x7617b(%rip), %rcx     # 0xbc9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GcCompactTransientMiscBuffers()
void ImGui::GcCompactTransientMiscBuffers()
{
    ImGuiContext& g = *GImGui;
    g.ItemFlagsStack.clear();
    g.GroupStack.clear();
    TableGcCompactSettings();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xb743c(%rip), %rbx     # 0xfdcd0
movq 0x1c58(%rbx), %rdi
testq %rdi, %rdi
je 0x468ce
movq $0x0, 0x1c50(%rbx)
testq %rbx, %rbx
je 0x468b6
decl 0x3b4(%rbx)
movq 0xb7423(%rip), %rsi     # 0xfdce0
callq *0xb2c55(%rip)          # 0xf9518
movq $0x0, 0x1c58(%rbx)
movq 0x1c68(%rbx), %rdi
testq %rdi, %rdi
je 0x4690f
movq $0x0, 0x1c60(%rbx)
movq 0xb73e4(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x468f7
decl 0x3b4(%rax)
movq 0xb73e2(%rip), %rsi     # 0xfdce0
callq *0xb2c14(%rip)          # 0xf9518
movq $0x0, 0x1c68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8f848
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GcCompactTransientWindowBuffers(ImGuiWindow*)
void ImGui::GcCompactTransientWindowBuffers(ImGuiWindow* window)
{
    window->MemoryCompacted = true;
    window->MemoryDrawListIdxCapacity = window->DrawList->IdxBuffer.Capacity;
    window->MemoryDrawListVtxCapacity = window->DrawList->VtxBuffer.Capacity;
    window->IDStack.clear();
    window->DrawList->_ClearFreeMemory();
    window->DC.ChildWindows.clear();
    window->DC.ItemWidthStack.clear();
    window->DC.TextWrapPosStack.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x3e0(%rdi)
movq 0xd0(%rdi), %rdi
movq 0x2b8(%rbx), %rax
movl 0x14(%rax), %ecx
movl %ecx, 0x3d8(%rbx)
movl 0x24(%rax), %eax
movl %eax, 0x3dc(%rbx)
testq %rdi, %rdi
je 0x46984
movq $0x0, 0xc8(%rbx)
movq 0xb736f(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x4696c
decl 0x3b4(%rax)
movq 0xb736d(%rip), %rsi     # 0xfdce0
callq *0xb2b9f(%rip)          # 0xf9518
movq $0x0, 0xd0(%rbx)
movq 0x2b8(%rbx), %rdi
callq 0x76980
movq 0x1a0(%rbx), %rdi
testq %rdi, %rdi
je 0x469d1
movq $0x0, 0x198(%rbx)
movq 0xb7322(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x469b9
decl 0x3b4(%rax)
movq 0xb7320(%rip), %rsi     # 0xfdce0
callq *0xb2b52(%rip)          # 0xf9518
movq $0x0, 0x1a0(%rbx)
movq 0x1e0(%rbx), %rdi
testq %rdi, %rdi
je 0x46a12
movq $0x0, 0x1d8(%rbx)
movq 0xb72e1(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x469fa
decl 0x3b4(%rax)
movq 0xb72df(%rip), %rsi     # 0xfdce0
callq *0xb2b11(%rip)          # 0xf9518
movq $0x0, 0x1e0(%rbx)
movq 0x1f0(%rbx), %rdi
testq %rdi, %rdi
je 0x46a53
movq $0x0, 0x1e8(%rbx)
movq 0xb72a0(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x46a3b
decl 0x3b4(%rax)
movq 0xb729e(%rip), %rsi     # 0xfdce0
callq *0xb2ad0(%rip)          # 0xf9518
movq $0x0, 0x1f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GcAwakeTransientWindowBuffers(ImGuiWindow*)
void ImGui::GcAwakeTransientWindowBuffers(ImGuiWindow* window)
{
    // We stored capacity of the ImDrawList buffer to reduce growth-caused allocation/copy when awakening.
    // The other buffers tends to amortize much faster.
    window->MemoryCompacted = false;
    window->DrawList->IdxBuffer.reserve(window->MemoryDrawListIdxCapacity);
    window->DrawList->VtxBuffer.reserve(window->MemoryDrawListVtxCapacity);
    window->MemoryDrawListIdxCapacity = window->MemoryDrawListVtxCapacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x3e0(%rdi)
movq 0x2b8(%rdi), %r15
movl 0x3d8(%rdi), %r12d
cmpl %r12d, 0x14(%r15)
jge 0x46af3
movslq %r12d, %rdi
addq %rdi, %rdi
movq 0xb7240(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x46a9b
incl 0x3b4(%rax)
movq 0xb723e(%rip), %rsi     # 0xfdce0
callq *0xb2a68(%rip)          # 0xf9510
movq %rax, %r14
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0x46aeb
movslq 0x10(%r15), %rdx
addq %rdx, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x46ade
movq 0xb71fd(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x46ade
decl 0x3b4(%rax)
movq 0xb71fb(%rip), %rsi     # 0xfdce0
callq *0xb2a2d(%rip)          # 0xf9518
movq %r14, 0x18(%r15)
movl %r12d, 0x14(%r15)
movq 0x2b8(%rbx), %r15
movl 0x3dc(%rbx), %r12d
cmpl %r12d, 0x24(%r15)
jge 0x46b81
movslq %r12d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
movq 0xb71b7(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x46b24
incl 0x3b4(%rax)
movq 0xb71b5(%rip), %rsi     # 0xfdce0
callq *0xb29df(%rip)          # 0xf9510
movq %rax, %r14
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x46b79
movslq 0x20(%r15), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
callq 0xc080
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x46b6c
movq 0xb716f(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x46b6c
decl 0x3b4(%rax)
movq 0xb716d(%rip), %rsi     # 0xfdce0
callq *0xb299f(%rip)          # 0xf9518
movq %r14, 0x28(%r15)
movl %r12d, 0x24(%r15)
movq $0x0, 0x3d8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetActiveID(unsigned int, ImGuiWindow*)
void ImGui::SetActiveID(ImGuiID id, ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    g.ActiveIdIsJustActivated = (g.ActiveId != id);
    if (g.ActiveIdIsJustActivated)
    {
        g.ActiveIdTimer = 0.0f;
        g.ActiveIdHasBeenPressedBefore = false;
        g.ActiveIdHasBeenEditedBefore = false;
        if (id != 0)
        {
            g.LastActiveId = id;
            g.LastActiveIdTimer = 0.0f;
        }
    }
    g.ActiveId = id;
    g.ActiveIdAllowOverlap = false;
    g.ActiveIdNoClearOnFocusLoss = false;
    g.ActiveIdWindow = window;
    g.ActiveIdHasBeenEditedThisFrame = false;
    if (id)
    {
        g.ActiveIdIsAlive = id;
        g.ActiveIdSource = (g.NavActivateId == id || g.NavInputId == id || g.NavJustTabbedId == id || g.NavJustMovedToId == id) ? ImGuiInputSource_Nav : ImGuiInputSource_Mouse;
    }

    // Clear declaration of inputs claimed by the widget
    // (Please note that this is WIP and not all keys/inputs are thoroughly declared by all widgets yet)
    g.ActiveIdUsingMouseWheel = false;
    g.ActiveIdUsingNavDirMask = 0x00;
    g.ActiveIdUsingNavInputMask = 0x00;
    g.ActiveIdUsingKeyInputMask = 0x00;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb7130(%rip), %rax     # 0xfdcd0
cmpl %edi, 0x1b30(%rax)
setne 0x1b3c(%rax)
je 0x46bd6
movl $0x0, 0x1b38(%rax)
movw $0x0, 0x1b3f(%rax)
testl %edi, %edi
je 0x46bd6
movl %edi, 0x1b80(%rax)
movl $0x0, 0x1b84(%rax)
movl %edi, 0x1b30(%rax)
movw $0x0, 0x1b3d(%rax)
movq %rsi, 0x1b60(%rax)
movb $0x0, 0x1b41(%rax)
testl %edi, %edi
je 0x46c2d
movl %edi, 0x1b34(%rax)
movl $0x2, %ecx
cmpl %edi, 0x1ca0(%rax)
je 0x46c27
cmpl %edi, 0x1cac(%rax)
je 0x46c27
cmpl %edi, 0x1cb0(%rax)
je 0x46c27
xorl %ecx, %ecx
cmpl %edi, 0x1cb4(%rax)
sete %cl
incl %ecx
movl %ecx, 0x1b68(%rax)
movb $0x0, 0x1b42(%rax)
xorl %ecx, %ecx
movq %rcx, 0x1b44(%rax)
movq %rcx, 0x1b50(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetHoveredID(unsigned int)
void ImGui::SetHoveredID(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    g.HoveredId = id;
    g.HoveredIdAllowOverlap = false;
    g.HoveredIdUsingMouseWheel = false;
    if (id != 0 && g.HoveredIdPreviousFrame != id)
        g.HoveredIdTimer = g.HoveredIdNotActiveTimer = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb7071(%rip), %rax     # 0xfdcd0
movl %edi, 0x1b1c(%rax)
movw $0x0, 0x1b24(%rax)
testl %edi, %edi
je 0x46c85
cmpl %edi, 0x1b20(%rax)
je 0x46c85
movq $0x0, 0x1b28(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::MarkItemEdited(unsigned int)
void ImGui::MarkItemEdited(ImGuiID id)
{
    // This marking is solely to be able to provide info for IsItemDeactivatedAfterEdit().
    // ActiveId might have been released by the time we call this (as in the typical press/release button behavior) but still need need to fill the data.
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.ActiveId == id || g.ActiveId == 0 || g.DragDropActive);
    IM_UNUSED(id); // Avoid unused variable warnings when asserts are compiled out.
    //IM_ASSERT(g.CurrentWindow->DC.LastItemId == id);
    g.ActiveIdHasBeenEditedThisFrame = true;
    g.ActiveIdHasBeenEditedBefore = true;
    g.CurrentWindow->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_Edited;
}

// Assembly:
movq 0xb7025(%rip), %rax     # 0xfdcd0
movl 0x1b30(%rax), %ecx
cmpl %edi, %ecx
sete %dl
testl %ecx, %ecx
sete %cl
orb %dl, %cl
jne 0x46cc8
cmpb $0x0, 0x2004(%rax)
je 0x46ce0
movw $0x101, 0x1b40(%rax)    # imm = 0x101
movq 0x1ae0(%rax), %rax
orl $0x4, 0x128(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x71b9e(%rip), %rdi     # 0xb8889
leaq 0x71473(%rip), %rsi     # 0xb8165
leaq 0x71bc8(%rip), %rcx     # 0xb88c1
movl $0xbfe, %edx            # imm = 0xBFE
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemFocused()
bool ImGui::IsItemFocused()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    if (g.NavId != window->DC.LastItemId || g.NavId == 0)
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb6eaa(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rcx
movl 0x1c98(%rax), %eax
cmpl 0x124(%rcx), %eax
sete %cl
testl %eax, %eax
setne %al
andb %cl, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMouseHoveringRect(ImVec2 const&, ImVec2 const&, bool)
bool ImGui::IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip)
{
    ImGuiContext& g = *GImGui;

    // Clip
    ImRect rect_clipped(r_min, r_max);
    if (clip)
        rect_clipped.ClipWith(g.CurrentWindow->ClipRect);

    // Expand for touch input
    const ImRect rect_for_touch(rect_clipped.Min - g.Style.TouchExtraPadding, rect_clipped.Max + g.Style.TouchExtraPadding);
    if (!rect_for_touch.Contains(g.IO.MousePos))
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb6d18(%rip), %rax     # 0xfdcd0
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
testl %edx, %edx
je 0x4702b
movq 0x1ae0(%rax), %rcx
movss 0x258(%rcx), %xmm3
movss 0x25c(%rcx), %xmm4
movaps %xmm3, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm5
andps %xmm0, %xmm5
andnps %xmm3, %xmm2
orps %xmm5, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm4, %xmm3
cmpless %xmm0, %xmm3
andps %xmm3, %xmm0
andnps %xmm4, %xmm3
orps %xmm0, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movss 0x260(%rcx), %xmm0
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
minss 0x264(%rcx), %xmm1
minss %xmm0, %xmm3
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movaps %xmm2, %xmm0
movaps %xmm3, %xmm1
movss 0x15c0(%rax), %xmm3
movaps %xmm0, %xmm4
subss %xmm3, %xmm4
movss 0x128(%rax), %xmm2
ucomiss %xmm4, %xmm2
jae 0x4704b
xorl %eax, %eax
jmp 0x47089
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
movss 0x15c4(%rax), %xmm5
addss %xmm5, %xmm4
addss %xmm1, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
subss %xmm5, %xmm0
movss 0x12c(%rax), %xmm1
cmpltps %xmm3, %xmm2
cmpleps %xmm1, %xmm0
andps %xmm2, %xmm0
ucomiss %xmm1, %xmm4
movd %xmm0, %ecx
seta %al
andb %cl, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsClippedEx(ImRect const&, unsigned int, bool)
bool ImGui::IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (!bb.Overlaps(window->ClipRect))
        if (id == 0 || (id != g.ActiveId && id != g.NavId))
            if (clip_even_when_logged || !g.LogEnabled)
                return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb6c28(%rip), %rcx     # 0xfdcd0
movq 0x1ae0(%rcx), %rax
movss 0xc(%rdi), %xmm0
ucomiss 0x25c(%rax), %xmm0
jbe 0x470e6
movss 0x264(%rax), %xmm0
ucomiss 0x4(%rdi), %xmm0
jbe 0x470e6
movss 0x8(%rdi), %xmm0
ucomiss 0x258(%rax), %xmm0
jbe 0x470e6
movss 0x260(%rax), %xmm0
ucomiss (%rdi), %xmm0
ja 0x47109
testl %esi, %esi
je 0x470fa
cmpl %esi, 0x1b30(%rcx)
je 0x47109
cmpl %esi, 0x1c98(%rcx)
je 0x47109
movb $0x1, %al
testb %dl, %dl
jne 0x4710b
cmpb $0x1, 0x3138(%rcx)
jne 0x4710b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FocusableItemRegister(ImGuiWindow*, unsigned int)
bool ImGui::FocusableItemRegister(ImGuiWindow* window, ImGuiID id)
{
    ImGuiContext& g = *GImGui;

    // Increment counters
    const bool is_tab_stop = (window->DC.ItemFlags & (ImGuiItemFlags_NoTabStop | ImGuiItemFlags_Disabled)) == 0;
    window->DC.FocusCounterRegular++;
    if (is_tab_stop)
        window->DC.FocusCounterTabStop++;

    // Process TAB/Shift-TAB to tab *OUT* of the currently focused item.
    // (Note that we can always TAB out of a widget that doesn't allow tabbing in)
    if (g.ActiveId == id && g.FocusTabPressed && !IsActiveIdUsingKey(ImGuiKey_Tab) && g.FocusRequestNextWindow == NULL)
    {
        g.FocusRequestNextWindow = window;
        g.FocusRequestNextCounterTabStop = window->DC.FocusCounterTabStop + (g.IO.KeyShift ? (is_tab_stop ? -1 : 0) : +1); // Modulo on index will be applied at the end of frame once we've got the total counter of items.
    }

    // Handle focus requests
    if (g.FocusRequestCurrWindow == window)
    {
        if (window->DC.FocusCounterRegular == g.FocusRequestCurrCounterRegular)
            return true;
        if (is_tab_stop && window->DC.FocusCounterTabStop == g.FocusRequestCurrCounterTabStop)
        {
            g.NavJustTabbedId = id;
            return true;
        }

        // If another item is about to be focused, we clear our own active id
        if (g.ActiveId == id)
            ClearActiveID();
    }

    return false;
}

// Assembly:
movq 0xb6ba0(%rip), %rax     # 0xfdcd0
movl 0x1c4(%rdi), %edx
movl 0x1cc(%rdi), %ecx
incl %edx
movl %edx, 0x1c4(%rdi)
testb $0x5, %cl
jne 0x4714f
incl 0x1c8(%rdi)
movl 0x1b30(%rax), %r8d
cmpl %esi, %r8d
jne 0x471ae
cmpb $0x1, 0x1e08(%rax)
jne 0x471ae
testb $0x1, 0x1b50(%rax)
jne 0x471ae
cmpq $0x0, 0x1df0(%rax)
jne 0x471ae
movl %ecx, %r9d
andl $0x5, %r9d
movq %rdi, 0x1df0(%rax)
xorl %r10d, %r10d
cmpl $0x1, %r9d
sbbl %r10d, %r10d
cmpb $0x0, 0x141(%rax)
movl $0x1, %r9d
cmovnel %r10d, %r9d
addl 0x1c8(%rdi), %r9d
movl %r9d, 0x1e04(%rax)
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq %rdi, 0x1de8(%rax)
je 0x471c1
xorl %ebx, %ebx
jmp 0x471f6
movb $0x1, %bl
cmpl 0x1df8(%rax), %edx
je 0x471f6
testb $0x5, %cl
jne 0x471e6
movl 0x1c8(%rdi), %ecx
cmpl 0x1dfc(%rax), %ecx
jne 0x471e6
movl %esi, 0x1cb0(%rax)
jmp 0x471f6
cmpl %esi, %r8d
jne 0x471bd
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x46b95
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcWrapWidthForPos(ImVec2 const&, float)
float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
    if (wrap_pos_x < 0.0f)
        return 0.0f;

    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (wrap_pos_x == 0.0f)
    {
        // We could decide to setup a default wrapping max point for auto-resizing windows,
        // or have auto-wrap (with unspecified wrapping pos) behave as a ContentSize extending function?
        //if (window->Hidden && (window->Flags & ImGuiWindowFlags_AlwaysAutoResize))
        //    wrap_pos_x = ImMax(window->WorkRect.Min.x + g.FontSize * 10.0f, window->WorkRect.Max.x);
        //else
        wrap_pos_x = window->WorkRect.Max.x;
    }
    else if (wrap_pos_x > 0.0f)
    {
        wrap_pos_x += window->Pos.x - window->Scroll.x; // wrap_pos_x is provided is window local space
    }

    return ImMax(wrap_pos_x - pos.x, 1.0f);
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x4725f
pushq %rbp
movq %rsp, %rbp
movq 0xb6aac(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %rax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4723f
jp 0x4723f
movss 0x240(%rax), %xmm0
jmp 0x4724f
jbe 0x4724f
movss 0x10(%rax), %xmm1
subss 0x5c(%rax), %xmm1
addss %xmm1, %xmm0
subss (%rdi), %xmm0
maxss 0x6fd89(%rip), %xmm0    # 0xb6fe4
movaps %xmm0, %xmm1
popq %rbp
movaps %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CreateContext(ImFontAtlas*)
ImGuiContext* ImGui::CreateContext(ImFontAtlas* shared_font_atlas)
{
    ImGuiContext* ctx = IM_NEW(ImGuiContext)(shared_font_atlas);
    if (GImGui == NULL)
        SetCurrentContext(ctx);
    Initialize(ctx);
    return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb69ca(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x47311
incl 0x3b4(%rax)
movq 0xb69c8(%rip), %rsi     # 0xfdce0
movl $0x3f80, %edi           # imm = 0x3F80
callq *0xb21ed(%rip)          # 0xf9510
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5e5da
cmpq $0x0, 0xb6997(%rip)     # 0xfdcd0
jne 0x47342
movq %r14, 0xb698e(%rip)     # 0xfdcd0
movq %r14, %rdi
callq 0x47352
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::Initialize(ImGuiContext*)
void ImGui::Initialize(ImGuiContext* context)
{
    ImGuiContext& g = *context;
    IM_ASSERT(!g.Initialized && !g.SettingsLoaded);

    // Add .ini handle for ImGuiWindow type
    {
        ImGuiSettingsHandler ini_handler;
        ini_handler.TypeName = "Window";
        ini_handler.TypeHash = ImHashStr("Window");
        ini_handler.ClearAllFn = WindowSettingsHandler_ClearAll;
        ini_handler.ReadOpenFn = WindowSettingsHandler_ReadOpen;
        ini_handler.ReadLineFn = WindowSettingsHandler_ReadLine;
        ini_handler.ApplyAllFn = WindowSettingsHandler_ApplyAll;
        ini_handler.WriteAllFn = WindowSettingsHandler_WriteAll;
        g.SettingsHandlers.push_back(ini_handler);
    }

#ifdef IMGUI_HAS_TABLE
    // Add .ini handle for ImGuiTable type
    TableSettingsInstallHandler(context);
#endif // #ifdef IMGUI_HAS_TABLE

#ifdef IMGUI_HAS_DOCK
#endif // #ifdef IMGUI_HAS_DOCK

    g.Initialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
jne 0x474e2
movq %rdi, %rbx
cmpb $0x1, 0x30e1(%rdi)
je 0x474e2
leaq 0x75040(%rip), %r14     # 0xbc3c0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x428dc
movl %eax, %r15d
movl 0x30f8(%rbx), %r13d
movl 0x30fc(%rbx), %eax
cmpl %eax, %r13d
jne 0x47457
incl %r13d
testl %eax, %eax
je 0x473b9
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x473be
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x47457
movslq %r13d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rdi
movq 0xb68f0(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x473eb
incl 0x3b4(%rax)
movq 0xb68ee(%rip), %rsi     # 0xfdce0
callq *0xb2118(%rip)          # 0xf9510
movq %rax, %r12
movq 0x3100(%rbx), %rsi
testq %rsi, %rsi
je 0x47449
movslq 0x30f8(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x3100(%rbx), %rdi
testq %rdi, %rdi
je 0x4743c
movq 0xb689f(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x4743c
decl 0x3b4(%rax)
movq 0xb689d(%rip), %rsi     # 0xfdce0
callq *0xb20cf(%rip)          # 0xf9518
movq %r12, 0x3100(%rbx)
movl %r13d, 0x30fc(%rbx)
movq 0x3100(%rbx), %rax
movslq 0x30f8(%rbx), %rcx
leaq (%rcx,%rcx,8), %rcx
movq %r14, (%rax,%rcx,8)
movl %r15d, 0x8(%rax,%rcx,8)
movl $0x0, 0xc(%rax,%rcx,8)
leaq 0x939a(%rip), %rdx      # 0x5081b
movq %rdx, 0x10(%rax,%rcx,8)
xorl %edx, %edx
movq %rdx, 0x18(%rax,%rcx,8)
leaq 0x93f0(%rip), %rsi      # 0x50884
movq %rsi, 0x20(%rax,%rcx,8)
leaq 0x9403(%rip), %rsi      # 0x508a3
movq %rsi, 0x28(%rax,%rcx,8)
leaq 0x9491(%rip), %rsi      # 0x5093d
movq %rsi, 0x30(%rax,%rcx,8)
leaq 0x9553(%rip), %rsi      # 0x50a0b
movq %rsi, 0x38(%rax,%rcx,8)
movq %rdx, 0x40(%rax,%rcx,8)
incl 0x30f8(%rbx)
movq %rbx, %rdi
callq 0x8ef1b
movb $0x1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x715d7(%rip), %rdi     # 0xb8ac0
leaq 0x70c75(%rip), %rsi     # 0xb8165
leaq 0x715ed(%rip), %rcx     # 0xb8ae4
movl $0xf9e, %edx            # imm = 0xF9E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::DestroyContext(ImGuiContext*)
void ImGui::DestroyContext(ImGuiContext* ctx)
{
    if (ctx == NULL)
        ctx = GImGui;
    Shutdown(ctx);
    if (GImGui == ctx)
        SetCurrentContext(NULL);
    IM_DELETE(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x47516
movq 0xb67ba(%rip), %rbx     # 0xfdcd0
movq %rbx, %rdi
callq 0x47540
cmpq %rbx, 0xb67ab(%rip)     # 0xfdcd0
jne 0x47532
movq $0x0, 0xb679e(%rip) # 0xfdcd0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5eea5
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CallContextHooks(ImGuiContext*, ImGuiContextHookType)
void ImGui::CallContextHooks(ImGuiContext* ctx, ImGuiContextHookType hook_type)
{
    ImGuiContext& g = *ctx;
    for (int n = 0; n < g.Hooks.Size; n++)
        if (g.Hooks[n].Type == hook_type)
            g.Hooks[n].Callback(&g, &g.Hooks[n]);
}

// Assembly:
cmpl $0x0, 0x3128(%rdi)
jle 0x47c7b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x3130(%r14), %rax
cmpl %ebx, (%rax,%r15)
jne 0x47c60
leaq (%rax,%r15), %rsi
movq %r14, %rdi
callq *0x8(%rax,%r15)
incq %r12
movslq 0x3128(%r14), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x47c47
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::StartMouseMovingWindow(ImGuiWindow*)
void ImGui::StartMouseMovingWindow(ImGuiWindow* window)
{
    // Set ActiveId even if the _NoMove flag is set. Without it, dragging away from a window with _NoMove would activate hover on other windows.
    // We _also_ call this when clicking in a window empty space when io.ConfigWindowsMoveFromTitleBarOnly is set, but clear g.MovingWindow afterward.
    // This is because we want ActiveId to be set even when the window is not permitted to move.
    ImGuiContext& g = *GImGui;
    FocusWindow(window);
    SetActiveID(window->MoveId, window);
    g.NavDisableHighlight = true;
    g.ActiveIdNoClearOnFocusLoss = true;
    g.ActiveIdClickOffset = g.IO.MousePos - window->RootWindow->Pos;

    bool can_move_window = true;
    if ((window->Flags & ImGuiWindowFlags_NoMove) || (window->RootWindow->Flags & ImGuiWindowFlags_NoMove))
        can_move_window = false;
    if (can_move_window)
        g.MovingWindow = window;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb5fa2(%rip), %r14     # 0xfdcd0
callq 0x47d9b
movl 0x54(%rbx), %edi
movq %rbx, %rsi
callq 0x46b95
movb $0x1, %al
movb %al, 0x1ce6(%r14)
movb %al, 0x1b3e(%r14)
movq 0x390(%rbx), %rax
movss 0x128(%r14), %xmm0
movss 0x12c(%r14), %xmm1
subss 0x10(%rax), %xmm0
subss 0x14(%rax), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x1b58(%r14)
testb $0x4, 0xc(%rbx)
jne 0x47d96
movq 0x390(%rbx), %rax
testb $0x4, 0xc(%rax)
jne 0x47d96
movq %rbx, 0x1b00(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMousePosValid(ImVec2 const*)
bool ImGui::IsMousePosValid(const ImVec2* mouse_pos)
{
    // The assert is only to silence a false-positive in XCode Static Analysis.
    // Because GImGui is not dereferenced in every code path, the static analyzer assume that it may be NULL (which it doesn't for other functions).
    IM_ASSERT(GImGui != NULL);
    const float MOUSE_INVALID = -256000.0f;
    ImVec2 p = mouse_pos ? *mouse_pos : GImGui->IO.MousePos;
    return p.x >= MOUSE_INVALID && p.y >= MOUSE_INVALID;
}

// Assembly:
movq 0xb5c5e(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x480aa
addq $0x128, %rax            # imm = 0x128
testq %rdi, %rdi
cmovneq %rdi, %rax
movss 0x4(%rax), %xmm0
movss (%rax), %xmm1
movss 0x6f7d7(%rip), %xmm2    # 0xb786c
movaps %xmm2, %xmm3
cmpleps %xmm1, %xmm3
cmpleps %xmm0, %xmm2
andps %xmm3, %xmm2
movd %xmm2, %eax
andb $0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x70e16(%rip), %rdi     # 0xb8ecb
leaq 0x700a9(%rip), %rsi     # 0xb8165
leaq 0x70e19(%rip), %rcx     # 0xb8edc
movl $0x120a, %edx           # imm = 0x120A
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowPos(ImGuiWindow*, ImVec2 const&, int)
void ImGui::SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
        return;

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

    // Set
    const ImVec2 old_pos = window->Pos;
    window->Pos = ImFloor(pos);
    ImVec2 offset = window->Pos - old_pos;
    window->DC.CursorPos += offset;         // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
    window->DC.CursorMaxPos += offset;      // And more importantly we need to offset CursorMaxPos/CursorStartPos this so ContentSize calculation doesn't get affected.
    window->DC.CursorStartPos += offset;
}

// Assembly:
testl %edx, %edx
je 0x48117
movsbl 0xaf(%rdi), %eax
testl %edx, %eax
je 0x481d9
leal -0x1(%rdx), %eax
testl %eax, %edx
jne 0x481da
andb $-0xf, 0xaf(%rdi)
movabsq $0x7f7fffff7f7fffff, %rax # imm = 0x7F7FFFFF7F7FFFFF
movq %rax, 0xb4(%rdi)
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
movss (%rsi), %xmm2
movss 0x4(%rsi), %xmm3
cvttps2dq %xmm2, %xmm2
cvtdq2ps %xmm2, %xmm2
cvttps2dq %xmm3, %xmm3
cvtdq2ps %xmm3, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movlps %xmm2, 0x10(%rdi)
movss 0x10(%rdi), %xmm2
subss %xmm0, %xmm2
movss 0x14(%rdi), %xmm0
subss %xmm1, %xmm0
movss 0xd8(%rdi), %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0xd8(%rdi)
movss 0xdc(%rdi), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xdc(%rdi)
movss 0xf0(%rdi), %xmm1
addss %xmm2, %xmm1
movss %xmm1, 0xf0(%rdi)
movss 0xf4(%rdi), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xf4(%rdi)
addss 0xe8(%rdi), %xmm2
movss %xmm2, 0xe8(%rdi)
addss 0xec(%rdi), %xmm0
movss %xmm0, 0xec(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x71337(%rip), %rdi     # 0xb951c
leaq 0x6ff79(%rip), %rsi     # 0xb8165
leaq 0x7134b(%rip), %rcx     # 0xb953e
movl $0x198e, %edx           # imm = 0x198E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsPopupOpen(unsigned int, int)
bool ImGui::IsPopupOpen(ImGuiID id, ImGuiPopupFlags popup_flags)
{
    ImGuiContext& g = *GImGui;
    if (popup_flags & ImGuiPopupFlags_AnyPopupId)
    {
        // Return true if any popup is open at the current BeginPopup() level of the popup stack
        // This may be used to e.g. test for another popups already opened to handle popups priorities at the same level.
        IM_ASSERT(id == 0);
        if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
            return g.OpenPopupStack.Size > 0;
        else
            return g.OpenPopupStack.Size > g.BeginPopupStack.Size;
    }
    else
    {
        if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
        {
            // Return true if the popup is open anywhere in the popup stack
            for (int n = 0; n < g.OpenPopupStack.Size; n++)
                if (g.OpenPopupStack[n].PopupId == id)
                    return true;
            return false;
        }
        else
        {
            // Return true if the popup is open at the current BeginPopup() level of the popup stack (this is the most-common query)
            return g.OpenPopupStack.Size > g.BeginPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].PopupId == id;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb5904(%rip), %rdx     # 0xfdcd0
testb %sil, %sil
js 0x48406
btl $0x8, %esi
movl 0x1c70(%rdx), %ecx
jb 0x4841e
movl 0x1c80(%rdx), %eax
cmpl %eax, %ecx
jle 0x4845f
testl %eax, %eax
js 0x48482
movq 0x1c78(%rdx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
cmpl %edi, (%rcx,%rax)
sete %al
jmp 0x48461
testl %edi, %edi
jne 0x48463
btl $0x8, %esi
movl 0x1c70(%rdx), %eax
jb 0x48458
cmpl 0x1c80(%rdx), %eax
jmp 0x4845a
testl %ecx, %ecx
setg %al
jle 0x48461
movq 0x1c78(%rdx), %rdx
cmpl %edi, (%rdx)
je 0x48461
addq $0x30, %rdx
movl $0x1, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x48450
leaq 0x1(%rax), %rsi
leaq 0x30(%rdx), %r8
cmpl %edi, (%rdx)
movq %r8, %rdx
jne 0x48439
cmpq %rcx, %rax
setb %al
jmp 0x48461
testl %eax, %eax
setg %al
jmp 0x48461
xorl %eax, %eax
popq %rbp
retq
leaq 0x71b8b(%rip), %rdi     # 0xb9ff5
leaq 0x6fcf4(%rip), %rsi     # 0xb8165
leaq 0x71b85(%rip), %rcx     # 0xb9ffd
movl $0x1ec4, %edx           # imm = 0x1EC4
callq 0xc140
leaq 0x731ef(%rip), %rdi     # 0xbb678
leaq 0x731fb(%rip), %rsi     # 0xbb68b
leaq 0x746b3(%rip), %rcx     # 0xbcb4a
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetTopMostPopupModal()
ImGuiWindow* ImGui::GetTopMostPopupModal()
{
    ImGuiContext& g = *GImGui;
    for (int n = g.OpenPopupStack.Size - 1; n >= 0; n--)
        if (ImGuiWindow* popup = g.OpenPopupStack.Data[n].Window)
            if (popup->Flags & ImGuiWindowFlags_Modal)
                return popup;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb5824(%rip), %rcx     # 0xfdcd0
movl 0x1c70(%rcx), %eax
leal 0x1(%rax), %edx
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq $-0x28, %rsi
decl %edx
testl %edx, %edx
jle 0x484f3
movq 0x1c78(%rcx), %rdi
movq (%rdi,%rsi), %r8
testq %r8, %r8
je 0x484de
testb $0x8, 0xf(%r8)
jne 0x484e3
movb $0x1, %dil
jmp 0x484e8
xorl %edi, %edi
movq %r8, %rax
addq $-0x30, %rsi
testb %dil, %dil
jne 0x484c1
jmp 0x484f5
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsWindowAbove(ImGuiWindow*, ImGuiWindow*)
bool ImGui::IsWindowAbove(ImGuiWindow* potential_above, ImGuiWindow* potential_below)
{
    ImGuiContext& g = *GImGui;
    for (int i = g.Windows.Size - 1; i >= 0; i--)
    {
        ImGuiWindow* candidate_window = g.Windows[i];
        if (candidate_window == potential_above)
            return true;
        if (candidate_window == potential_below)
            return false;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb57ce(%rip), %rcx     # 0xfdcd0
movl 0x1a88(%rcx), %edx
testl %edx, %edx
jle 0x4853b
movq 0x1a90(%rcx), %r8
movq -0x8(%r8,%rdx,8), %r8
cmpq %rdi, %r8
sete %r9b
cmpq %rsi, %r8
setne %r10b
andb %r10b, %al
orb %r9b, %al
cmpq %rsi, %r8
je 0x4853d
decq %rdx
cmpq %rdi, %r8
jne 0x48508
jmp 0x4853d
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsWindowChildOf(ImGuiWindow*, ImGuiWindow*)
bool ImGui::IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent)
{
    if (window->RootWindow == potential_parent)
        return true;
    while (window != NULL)
    {
        if (window == potential_parent)
            return true;
        window = window->ParentWindow;
    }
    return false;
}

// Assembly:
cmpq %rsi, 0x390(%rdi)
je 0x48a7e
testq %rdi, %rdi
je 0x48a81
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
sete %al
je 0x48a7c
movq 0x388(%rdi), %rdi
testq %rdi, %rdi
jne 0x48a68
popq %rbp
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetMergedKeyModFlags()
ImGuiKeyModFlags ImGui::GetMergedKeyModFlags()
{
    ImGuiContext& g = *GImGui;
    ImGuiKeyModFlags key_mod_flags = ImGuiKeyModFlags_None;
    if (g.IO.KeyCtrl)   { key_mod_flags |= ImGuiKeyModFlags_Ctrl; }
    if (g.IO.KeyShift)  { key_mod_flags |= ImGuiKeyModFlags_Shift; }
    if (g.IO.KeyAlt)    { key_mod_flags |= ImGuiKeyModFlags_Alt; }
    if (g.IO.KeySuper)  { key_mod_flags |= ImGuiKeyModFlags_Super; }
    return key_mod_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb5241(%rip), %rax     # 0xfdcd0
movzbl 0x140(%rax), %ecx
leal 0x2(%rcx), %edx
cmpb $0x0, 0x141(%rax)
cmovel %ecx, %edx
leal 0x4(%rdx), %ecx
cmpb $0x0, 0x142(%rax)
cmovel %edx, %ecx
cmpb $0x0, 0x143(%rax)
leal 0x8(%rcx), %eax
cmovel %ecx, %eax
popq %rbp
retq