LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(void const*)
void ImGui::PushID(const void* ptr_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(ptr_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rsi
movq 0xa0db1(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x371cc
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(int)
void ImGui::PushID(int int_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(int_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %esi
movq 0xa0d77(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
movq %rbx, %rdi
callq 0x371fa
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::DebugCheckVersionAndDataLayout(char const*, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
bool ImGui::DebugCheckVersionAndDataLayout(const char* version, size_t sz_io, size_t sz_style, size_t sz_vec2, size_t sz_vec4, size_t sz_vert, size_t sz_idx)
{
    bool error = false;
    if (strcmp(version, IMGUI_VERSION) != 0) { error = true; IM_ASSERT(strcmp(version, IMGUI_VERSION) == 0 && "Mismatched version string!"); }
    if (sz_io != sizeof(ImGuiIO)) { error = true; IM_ASSERT(sz_io == sizeof(ImGuiIO) && "Mismatched struct layout!"); }
    if (sz_style != sizeof(ImGuiStyle)) { error = true; IM_ASSERT(sz_style == sizeof(ImGuiStyle) && "Mismatched struct layout!"); }
    if (sz_vec2 != sizeof(ImVec2)) { error = true; IM_ASSERT(sz_vec2 == sizeof(ImVec2) && "Mismatched struct layout!"); }
    if (sz_vec4 != sizeof(ImVec4)) { error = true; IM_ASSERT(sz_vec4 == sizeof(ImVec4) && "Mismatched struct layout!"); }
    if (sz_vert != sizeof(ImDrawVert)) { error = true; IM_ASSERT(sz_vert == sizeof(ImDrawVert) && "Mismatched struct layout!"); }
    if (sz_idx != sizeof(ImDrawIdx)) { error = true; IM_ASSERT(sz_idx == sizeof(ImDrawIdx) && "Mismatched struct layout!"); }
    return !error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
leaq 0x58fa7(%rip), %rsi     # 0x9c0e7
callq 0xc760
testl %eax, %eax
jne 0x43195
cmpq $0x1558, %r13           # imm = 0x1558
jne 0x431b4
cmpq $0x414, %r12            # imm = 0x414
jne 0x431d3
cmpq $0x8, %r15
jne 0x431f2
cmpq $0x10, %r14
jne 0x43211
cmpq $0x14, %rbx
jne 0x43230
cmpq $0x2, 0x10(%rbp)
jne 0x4324f
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b647(%rip), %rdi     # 0x9e7e3
leaq 0x59ff2(%rip), %rsi     # 0x9d195
leaq 0x5b67a(%rip), %rcx     # 0x9e824
movl $0x1b19, %edx           # imm = 0x1B19
callq 0xc140
leaq 0x5b6d2(%rip), %rdi     # 0x9e88d
leaq 0x59fd3(%rip), %rsi     # 0x9d195
leaq 0x5b65b(%rip), %rcx     # 0x9e824
movl $0x1b1a, %edx           # imm = 0x1B1A
callq 0xc140
leaq 0x5b6eb(%rip), %rdi     # 0x9e8c5
leaq 0x59fb4(%rip), %rsi     # 0x9d195
leaq 0x5b63c(%rip), %rcx     # 0x9e824
movl $0x1b1b, %edx           # imm = 0x1B1B
callq 0xc140
leaq 0x5b70a(%rip), %rdi     # 0x9e903
leaq 0x59f95(%rip), %rsi     # 0x9d195
leaq 0x5b61d(%rip), %rcx     # 0x9e824
movl $0x1b1c, %edx           # imm = 0x1B1C
callq 0xc140
leaq 0x5b724(%rip), %rdi     # 0x9e93c
leaq 0x59f76(%rip), %rsi     # 0x9d195
leaq 0x5b5fe(%rip), %rcx     # 0x9e824
movl $0x1b1d, %edx           # imm = 0x1B1D
callq 0xc140
leaq 0x5b73e(%rip), %rdi     # 0x9e975
leaq 0x59f57(%rip), %rsi     # 0x9d195
leaq 0x5b5df(%rip), %rcx     # 0x9e824
movl $0x1b1e, %edx           # imm = 0x1B1E
callq 0xc140
leaq 0x5b75c(%rip), %rdi     # 0x9e9b2
leaq 0x59f38(%rip), %rsi     # 0x9d195
leaq 0x5b5c0(%rip), %rcx     # 0x9e824
movl $0x1b1f, %edx           # imm = 0x1B1F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SameLine(float, float)
void ImGui::SameLine(float offset_from_start_x, float spacing_w)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xa0147(%rip), %rbx     # 0xe3ce0
movq 0x1ae0(%rbx), %rdi
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x43bb2
jp 0x43bb2
movss 0x288(%rdi), %xmm0
leaq 0x1d0(%rdi), %rsi
movss %xmm0, 0x1d0(%rdi)
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x4b810
andb $-0x2, 0x1bf8(%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::PushMultiItemsWidths(int, float)
void ImGui::PushMultiItemsWidths(int components, float w_full)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiStyle& style = g.Style;
    const float w_item_one  = ImMax(1.0f, IM_FLOOR((w_full - (style.ItemInnerSpacing.x) * (components - 1)) / (float)components));
    const float w_item_last = ImMax(1.0f, IM_FLOOR(w_full - (w_item_one + style.ItemInnerSpacing.x) * (components - 1)));
    window->DC.ItemWidthStack.push_back(w_item_last);
    for (int i = 0; i < components - 1; i++)
        window->DC.ItemWidthStack.push_back(w_item_one);
    window->DC.ItemWidth = window->DC.ItemWidthStack.back();
    g.NextItemData.Flags &= ~ImGuiNextItemDataFlags_HasWidth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xa00ed(%rip), %r15     # 0xe3ce0
movq 0x1ae0(%r15), %rax
movss 0x15b0(%r15), %xmm1
leal -0x1(%rdi), %r13d
cvtsi2ss %r13d, %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
movaps %xmm0, %xmm4
subss %xmm3, %xmm4
cvtsi2ss %edi, %xmm3
divss %xmm3, %xmm4
cvttps2dq %xmm4, %xmm3
cvtdq2ps %xmm3, %xmm3
movss 0x583c7(%rip), %xmm4    # 0x9bff8
movaps %xmm4, %xmm5
maxss %xmm3, %xmm5
leaq -0x38(%rbp), %rbx
movss %xmm5, (%rbx)
addss %xmm1, %xmm5
mulss %xmm2, %xmm5
subss %xmm5, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
maxss %xmm0, %xmm4
leaq -0x34(%rbp), %rsi
movss %xmm4, (%rsi)
movq %rax, -0x30(%rbp)
leaq 0x1d8(%rax), %r14
movq %r14, %rdi
callq 0x4b810
xorl %r12d, %r12d
testl %r13d, %r13d
cmovgl %r13d, %r12d
subl $0x1, %r12d
jb 0x43c8f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b810
jmp 0x43c7c
movq %r14, %rdi
callq 0x4b88c
movss (%rax), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x1d0(%rax)
andb $-0x2, 0x1bf8(%r15)
addq $0x18, %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::CalcItemWidth()
float ImGui::CalcItemWidth()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float w;
    if (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasWidth)
        w = g.NextItemData.Width;
    else
        w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        float region_max_x = GetContentRegionMaxAbs().x;
        w = ImMax(1.0f, region_max_x - window->DC.CursorPos.x + w);
    }
    w = IM_FLOOR(w);
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq 0x9ffb9(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
leaq 0x1bfc(%rax), %rcx
leaq 0x1d0(%rbx), %rdx
testb $0x1, 0x1bf8(%rax)
cmoveq %rdx, %rcx
movss (%rcx), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x43d7b
movaps %xmm1, -0x20(%rbp)
callq 0x43d89
subss 0xd8(%rbx), %xmm0
movaps -0x20(%rbp), %xmm1
addss %xmm0, %xmm1
movss 0x58284(%rip), %xmm0    # 0x9bff8
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetContentRegionMaxAbs()
ImVec2 ImGui::GetContentRegionMaxAbs()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x;
    return mx;
}

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

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

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

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

    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movaps %xmm0, %xmm3
movq 0x9ff08(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
xorps %xmm5, %xmm5
ucomiss %xmm0, %xmm5
ja 0x43df6
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
xorps %xmm0, %xmm0
ucomiss %xmm4, %xmm5
jbe 0x43e13
movaps %xmm3, -0x40(%rbp)
movaps %xmm2, -0x30(%rbp)
movaps %xmm1, -0x20(%rbp)
callq 0x43d89
movaps -0x20(%rbp), %xmm1
movaps -0x30(%rbp), %xmm2
movaps -0x40(%rbp), %xmm3
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm3
jne 0x43e1d
jnp 0x43e41
ucomiss %xmm3, %xmm4
jbe 0x43e45
movss 0xd8(%rbx), %xmm1
movaps %xmm0, %xmm4
subss %xmm1, %xmm4
addss %xmm3, %xmm4
movss 0x58a53(%rip), %xmm1    # 0x9c890
maxss %xmm4, %xmm1
movss %xmm1, %xmm3            # xmm3 = xmm1[0],xmm3[1,2,3]
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1     # xmm1 = xmm1[1,1],xmm3[1,1]
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm1
jne 0x43e62
jp 0x43e62
movlhps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm2     # xmm2 = xmm2[2,0],xmm3[2,3]
movaps %xmm2, %xmm3
jmp 0x43e8d
ucomiss %xmm1, %xmm4
jbe 0x43e8d
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
subss 0xdc(%rbx), %xmm0
addss %xmm0, %xmm1
movss 0x58a11(%rip), %xmm0    # 0x9c890
maxss %xmm1, %xmm0
movlhps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm0     # xmm0 = xmm0[2,0],xmm3[2,3]
movaps %xmm0, %xmm3
movaps %xmm3, %xmm0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetContentRegionMax()
ImVec2 ImGui::GetContentRegionMax()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max - window->Pos;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x - window->Pos.x;
    return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x9fdc2(%rip), %rcx     # 0xe3ce0
movq 0x1ae0(%rcx), %rax
movss 0x270(%rax), %xmm0
movss 0x10(%rax), %xmm1
movss 0x274(%rax), %xmm2
subss 0x14(%rax), %xmm2
subss %xmm1, %xmm0
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
cmpq $0x0, 0x1b0(%rax)
jne 0x43f5a
cmpq $0x0, 0x20a8(%rcx)
je 0x43f6a
movss 0x240(%rax), %xmm2
subss %xmm1, %xmm2
movss %xmm2, %xmm0            # xmm0 = xmm2[0],xmm0[1,2,3]
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginGroup()
void ImGui::BeginGroup()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    g.GroupStack.resize(g.GroupStack.Size + 1);
    ImGuiGroupData& group_data = g.GroupStack.back();
    group_data.WindowID = window->ID;
    group_data.BackupCursorPos = window->DC.CursorPos;
    group_data.BackupCursorMaxPos = window->DC.CursorMaxPos;
    group_data.BackupIndent = window->DC.Indent;
    group_data.BackupGroupOffset = window->DC.GroupOffset;
    group_data.BackupCurrLineSize = window->DC.CurrLineSize;
    group_data.BackupCurrLineTextBaseOffset = window->DC.CurrLineTextBaseOffset;
    group_data.BackupActiveIdIsAlive = g.ActiveIdIsAlive;
    group_data.BackupActiveIdPreviousFrameIsAlive = g.ActiveIdPreviousFrameIsAlive;
    group_data.EmitItem = true;

    window->DC.GroupOffset.x = window->DC.CursorPos.x - window->Pos.x - window->DC.ColumnsOffset.x;
    window->DC.Indent = window->DC.GroupOffset;
    window->DC.CursorMaxPos = window->DC.CursorPos;
    window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
    if (g.LogEnabled)
        g.LogLinePosY = -FLT_MAX; // To enforce Log carriage return
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x9fcdd(%rip), %r14     # 0xe3ce0
movq 0x1ae0(%r14), %r15
leaq 0x1c60(%r14), %rbx
movl 0x1c60(%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x4aed6
movq %rbx, %rdi
callq 0x4b8f2
movl 0x8(%r15), %ecx
movl %ecx, (%rax)
movq 0xd8(%r15), %rcx
movq %rcx, 0x4(%rax)
movq 0xf0(%r15), %rcx
movq %rcx, 0xc(%rax)
movl 0x118(%r15), %ecx
movl %ecx, 0x14(%rax)
movl 0x120(%r15), %ecx
movl %ecx, 0x18(%rax)
movq 0x100(%r15), %rcx
movq %rcx, 0x1c(%rax)
movss 0x110(%r15), %xmm0
movss %xmm0, 0x24(%rax)
movl 0x1b34(%r14), %ecx
movl %ecx, 0x28(%rax)
movb 0x1b74(%r14), %cl
movb %cl, 0x2c(%rax)
movb $0x1, 0x2d(%rax)
movss 0xd8(%r15), %xmm0
subss 0x10(%r15), %xmm0
subss 0x11c(%r15), %xmm0
movss %xmm0, 0x120(%r15)
movss %xmm0, 0x118(%r15)
movq 0xd8(%r15), %rax
movq %rax, 0xf0(%r15)
andq $0x0, 0x100(%r15)
cmpb $0x1, 0x3138(%r14)
jne 0x440e0
movl $0xff7fffff, 0x3158(%r14) # imm = 0xFF7FFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollFromPosX(ImGuiWindow*, float, float)
void ImGui::SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio)
{
    IM_ASSERT(center_x_ratio >= 0.0f && center_x_ratio <= 1.0f);
    window->ScrollTarget.x = IM_FLOOR(local_x + window->Scroll.x); // Convert local position to scroll offset
    window->ScrollTargetCenterRatio.x = center_x_ratio;
    window->ScrollTargetEdgeSnapDist.x = 0.0f;
}

// Assembly:
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jb 0x442d4
movss 0x57d44(%rip), %xmm2    # 0x9bff8
ucomiss %xmm1, %xmm2
jb 0x442d4
addss 0x5c(%rdi), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0x6c(%rdi)
movss %xmm1, 0x74(%rdi)
andl $0x0, 0x7c(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5ac0d(%rip), %rdi     # 0x9eeec
leaq 0x58eaf(%rip), %rsi     # 0x9d195
leaq 0x5ac30(%rip), %rcx     # 0x9ef1d
movl $0x1e45, %edx           # imm = 0x1E45
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollFromPosY(ImGuiWindow*, float, float)
void ImGui::SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio)
{
    IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
    local_y -= window->TitleBarHeight() + window->MenuBarHeight(); // FIXME: Would be nice to have a more standardized access to our scrollable/client rect
    window->ScrollTarget.y = IM_FLOOR(local_y + window->Scroll.y); // Convert local position to scroll offset
    window->ScrollTargetCenterRatio.y = center_y_ratio;
    window->ScrollTargetEdgeSnapDist.y = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jb 0x44369
movss 0x57ce4(%rip), %xmm0    # 0x9bff8
ucomiss %xmm1, %xmm0
jb 0x44369
movq %rdi, %rbx
movss %xmm1, -0x10(%rbp)
callq 0x4b4aa
movss %xmm0, -0xc(%rbp)
movq %rbx, %rdi
callq 0x4b4de
addss -0xc(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
subss %xmm0, %xmm1
addss 0x60(%rbx), %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0x70(%rbx)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x78(%rbx)
andl $0x0, 0x80(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5abe8(%rip), %rdi     # 0x9ef58
leaq 0x58e1e(%rip), %rsi     # 0x9d195
leaq 0x5ac0b(%rip), %rcx     # 0x9ef89
movl $0x1e4d, %edx           # imm = 0x1E4D
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollHereX(float)
void ImGui::SetScrollHereX(float center_x_ratio)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float spacing_x = g.Style.ItemSpacing.x;
    float target_pos_x = ImLerp(window->DC.LastItemRect.Min.x - spacing_x, window->DC.LastItemRect.Max.x + spacing_x, center_x_ratio);
    SetScrollFromPosX(window, target_pos_x - window->Pos.x, center_x_ratio); // Convert from absolute to local pos

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movaps %xmm0, %xmm1
movq 0x9f846(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rbx
movss 0x15a8(%rax), %xmm3
movss %xmm3, -0xc(%rbp)
movss 0x12c(%rbx), %xmm2
subss %xmm3, %xmm2
movss 0x134(%rbx), %xmm0
addss %xmm3, %xmm0
subss %xmm2, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
subss 0x10(%rbx), %xmm0
movq %rbx, %rdi
callq 0x442a4
movss 0x40(%rbx), %xmm0
subss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andnps %xmm0, %xmm2
movss %xmm2, 0x7c(%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::IsPopupOpen(char const*, int)
bool ImGui::IsPopupOpen(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiContext& g = *GImGui;
    ImGuiID id = (popup_flags & ImGuiPopupFlags_AnyPopupId) ? 0 : g.CurrentWindow->GetID(str_id);
    if ((popup_flags & ImGuiPopupFlags_AnyPopupLevel) && id != 0)
        IM_ASSERT(0 && "Cannot use IsPopupOpen() with a string id and ImGuiPopupFlags_AnyPopupLevel."); // But non-string version is legal and used internally
    return IsPopupOpen(id, popup_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
xorl %edi, %edi
testb %bl, %bl
js 0x446c9
movq 0x9f627(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rdi
xorl %edx, %edx
callq 0x3700a
movl %eax, %edi
btl $0x8, %ebx
jae 0x446d3
testl %edi, %edi
jne 0x446e0
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x384af
leaq 0x5a978(%rip), %rdi     # 0x9f05f
leaq 0x58aa7(%rip), %rsi     # 0x9d195
leaq 0x5a9be(%rip), %rcx     # 0x9f0b3
movl $0x1ee1, %edx           # imm = 0x1EE1
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavCalcPreferredRefPos()
static ImVec2 ImGui::NavCalcPreferredRefPos()
{
    ImGuiContext& g = *GImGui;
    if (g.NavDisableHighlight || !g.NavDisableMouseHover || !g.NavWindow)
    {
        // Mouse (we need a fallback in case the mouse becomes invalid after being used)
        if (IsMousePosValid(&g.IO.MousePos))
            return g.IO.MousePos;
        return g.LastValidMousePos;
    }
    else
    {
        // When navigation is active and mouse is disabled, decide on an arbitrary position around the bottom left of the currently navigated item.
        const ImRect& rect_rel = g.NavWindow->NavRectRel[g.NavLayer];
        ImVec2 pos = g.NavWindow->Pos + ImVec2(rect_rel.Min.x + ImMin(g.Style.FramePadding.x * 4, rect_rel.GetWidth()), rect_rel.Max.y - ImMin(g.Style.FramePadding.y, rect_rel.GetHeight()));
        ImRect visible_rect = GetViewportRect();
        return ImFloor(ImClamp(pos, visible_rect.Min, visible_rect.Max));   // ImFloor() is important because non-integer mouse position application in backend might be lossy and result in undesirable non-zero delta.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x9f47a(%rip), %r14     # 0xe3ce0
cmpb $0x0, 0x1ce6(%r14)
jne 0x44938
cmpb $0x1, 0x1ce7(%r14)
jne 0x44938
movq 0x1c90(%r14), %rax
testq %rax, %rax
je 0x44938
movl 0x1cdc(%r14), %ecx
shlq $0x4, %rcx
movss 0x1598(%r14), %xmm0
mulss 0x57fe2(%rip), %xmm0    # 0x9c890
movss 0x159c(%r14), %xmm1
movss 0x3b8(%rax,%rcx), %xmm2
movss 0x3c0(%rax,%rcx), %xmm3
subss %xmm2, %xmm3
minss %xmm3, %xmm0
addss %xmm2, %xmm0
movss 0x3c4(%rax,%rcx), %xmm2
movaps %xmm2, %xmm3
subss 0x3bc(%rax,%rcx), %xmm3
minss %xmm3, %xmm1
subss %xmm1, %xmm2
addss 0x10(%rax), %xmm0
addss 0x14(%rax), %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
leaq -0x18(%rbp), %rdi
movlps %xmm0, (%rdi)
xorps %xmm1, %xmm1
movsd 0x10(%r14), %xmm0
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
leaq -0x28(%rbp), %rsi
movups %xmm1, (%rsi)
callq 0x45358
movaps %xmm0, %xmm1
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
jmp 0x4495a
leaq 0x128(%r14), %rbx
movq %rbx, %rdi
callq 0x381f3
testb %al, %al
je 0x44951
movsd (%rbx), %xmm0
jmp 0x4495a
movsd 0x2158(%r14), %xmm0
addq $0x20, %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::ClosePopupToLevel(int, bool)
void ImGui::ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup)
{
    ImGuiContext& g = *GImGui;
    IMGUI_DEBUG_LOG_POPUP("ClosePopupToLevel(%d), restore_focus_to_window_under_popup=%d\n", remaining, restore_focus_to_window_under_popup);
    IM_ASSERT(remaining >= 0 && remaining < g.OpenPopupStack.Size);

    // Trim open popup stack
    ImGuiWindow* focus_window = g.OpenPopupStack[remaining].SourceWindow;
    ImGuiWindow* popup_window = g.OpenPopupStack[remaining].Window;
    g.OpenPopupStack.resize(remaining);

    if (restore_focus_to_window_under_popup)
    {
        if (focus_window && !focus_window->WasActive && popup_window)
        {
            // Fallback
            FocusTopMostWindowUnderOne(popup_window, NULL);
        }
        else
        {
            if (g.NavLayer == ImGuiNavLayer_Main && focus_window)
                focus_window = NavRestoreLastChildNavWindow(focus_window);
            FocusWindow(focus_window);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x44a41
movl %edi, %r14d
movq 0x9f35d(%rip), %r15     # 0xe3ce0
cmpl %edi, 0x1c70(%r15)
jle 0x44a41
movl %esi, %ebx
leaq 0x1c70(%r15), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x4b386
movq 0x10(%rax), %r13
movq %r12, %rdi
movl %r14d, %esi
callq 0x4b386
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movl %r14d, %esi
callq 0x4ae0c
testb %bl, %bl
je 0x449f7
testq %r13, %r13
je 0x44a06
cmpb $0x0, 0x8f(%r13)
movq -0x30(%rbp), %rdi
jne 0x44a0a
testq %rdi, %rdi
je 0x44a0a
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b9e5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
jmp 0x44a17
cmpl $0x0, 0x1cdc(%r15)
je 0x44a2a
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x37fa1
movq 0x3a8(%r13), %rdi
testq %rdi, %rdi
je 0x44a14
cmpb $0x0, 0x8f(%rdi)
je 0x44a14
jmp 0x44a17
leaq 0x5a70d(%rip), %rdi     # 0x9f155
leaq 0x58746(%rip), %rsi     # 0x9d195
leaq 0x5a733(%rip), %rcx     # 0x9f189
movl $0x1f5a, %edx           # imm = 0x1F5A
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CloseCurrentPopup()
void ImGui::CloseCurrentPopup()
{
    ImGuiContext& g = *GImGui;
    int popup_idx = g.BeginPopupStack.Size - 1;
    if (popup_idx < 0 || popup_idx >= g.OpenPopupStack.Size || g.BeginPopupStack[popup_idx].PopupId != g.OpenPopupStack[popup_idx].PopupId)
        return;

    // Closing a menu closes its top-most parent popup (unless a modal)
    while (popup_idx > 0)
    {
        ImGuiWindow* popup_window = g.OpenPopupStack[popup_idx].Window;
        ImGuiWindow* parent_popup_window = g.OpenPopupStack[popup_idx - 1].Window;
        bool close_parent = false;
        if (popup_window && (popup_window->Flags & ImGuiWindowFlags_ChildMenu))
            if (parent_popup_window == NULL || !(parent_popup_window->Flags & ImGuiWindowFlags_Modal))
                close_parent = true;
        if (!close_parent)
            break;
        popup_idx--;
    }
    IMGUI_DEBUG_LOG_POPUP("CloseCurrentPopup %d -> %d\n", g.BeginPopupStack.Size - 1, popup_idx);
    ClosePopupToLevel(popup_idx, true);

    // A common pattern is to close a popup when selecting a menu item/selectable that will open another window.
    // To improve this usage pattern, we avoid nav highlight for a single frame in the parent window.
    // Similarly, we could avoid mouse hover highlight in this window but it is less visually problematic.
    if (ImGuiWindow* window = g.NavWindow)
        window->DC.NavHideHighlightOneFrame = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x9f26b(%rip), %r12     # 0xe3ce0
movl 0x1c80(%r12), %ebx
testl %ebx, %ebx
jle 0x44b1f
cmpl 0x1c70(%r12), %ebx
jg 0x44b1f
leaq 0x1c80(%r12), %rdi
decl %ebx
leaq 0x1c70(%r12), %r14
movl %ebx, %esi
callq 0x4b386
movl (%rax), %r15d
movq %r14, %rdi
movl %ebx, %esi
callq 0x4b386
cmpl (%rax), %r15d
jne 0x44b1f
testl %ebx, %ebx
jle 0x44aff
movq %r14, %rdi
movl %ebx, %esi
callq 0x4b386
movq 0x8(%rax), %r13
leal -0x1(%rbx), %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x4b386
testq %r13, %r13
je 0x44b01
testb $0x10, 0xf(%r13)
je 0x44b01
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x44afa
testb $0x8, 0xf(%rax)
jne 0x44b01
movl %r15d, %ebx
jmp 0x44abe
xorl %ebx, %ebx
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x44963
movq 0x1c90(%r12), %rax
testq %rax, %rax
je 0x44b1f
movb $0x1, 0x15c(%rax)
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::BeginPopupEx(unsigned int, int)
bool ImGui::BeginPopupEx(ImGuiID id, ImGuiWindowFlags flags)
{
    ImGuiContext& g = *GImGui;
    if (!IsPopupOpen(id, ImGuiPopupFlags_None))
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }

    char name[20];
    if (flags & ImGuiWindowFlags_ChildMenu)
        ImFormatString(name, IM_ARRAYSIZE(name), "##Menu_%02d", g.BeginPopupStack.Size); // Recycle windows based on depth
    else
        ImFormatString(name, IM_ARRAYSIZE(name), "##Popup_%08x", id); // Not recycling, so we can close/open during the same frame

    flags |= ImGuiWindowFlags_Popup;
    bool is_open = Begin(name, NULL, flags);
    if (!is_open) // NB: Begin can return false when the popup is completely clipped (e.g. zero size display)
        EndPopup();

    return is_open;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
movq 0x9f199(%rip), %r15     # 0xe3ce0
xorl %esi, %esi
callq 0x384af
testb %al, %al
je 0x44b6b
btl $0x1c, %ebx
jb 0x44b77
leaq 0x5a65f(%rip), %rdx     # 0x9f1be
leaq -0x30(%rbp), %rdi
pushq $0x14
popq %rsi
movl %r14d, %ecx
jmp 0x44b8c
andl $0x0, 0x1b88(%r15)
xorl %ebx, %ebx
jmp 0x44bb1
movl 0x1c80(%r15), %ecx
leaq 0x5a62d(%rip), %rdx     # 0x9f1b2
leaq -0x30(%rbp), %rdi
pushq $0x14
popq %rsi
xorl %eax, %eax
callq 0x3468c
orl $0x4000000, %ebx        # imm = 0x4000000
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x3bad8
movl %eax, %ebx
testb %al, %al
jne 0x44bb1
callq 0x44bbe
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::EndPopup()
void ImGui::EndPopup()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup);  // Mismatched BeginPopup()/EndPopup() calls
    IM_ASSERT(g.BeginPopupStack.Size > 0);

    // Make all menus and popups wrap around for now, may need to expose that policy.
    if (g.NavWindow == window)
        NavMoveRequestTryWrapping(window, ImGuiNavMoveFlags_LoopY);

    // Child-popups don't need to be laid out
    IM_ASSERT(g.WithinEndChild == false);
    if (window->Flags & ImGuiWindowFlags_ChildWindow)
        g.WithinEndChild = true;
    End();
    g.WithinEndChild = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x9f115(%rip), %rbx     # 0xe3ce0
movq 0x1ae0(%rbx), %rcx
movl 0xc(%rcx), %eax
btl $0x1a, %eax
jae 0x44c27
cmpl $0x0, 0x1c80(%rbx)
jle 0x44c46
cmpq %rcx, 0x1c90(%rbx)
jne 0x44bfe
movq %rcx, 0x1db0(%rbx)
movl $0x2, 0x1db8(%rbx)
cmpb $0x0, 0x1a76(%rbx)
jne 0x44c65
btl $0x18, %eax
jae 0x44c14
movb $0x1, 0x1a76(%rbx)
callq 0x3f958
movb $0x0, 0x1a76(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5a59d(%rip), %rdi     # 0x9f1cb
leaq 0x58560(%rip), %rsi     # 0x9d195
leaq 0x5a5b6(%rip), %rcx     # 0x9f1f2
movl $0x1fd7, %edx           # imm = 0x1FD7
callq 0xc140
leaq 0x5a5bc(%rip), %rdi     # 0x9f209
leaq 0x58541(%rip), %rsi     # 0x9d195
leaq 0x5a597(%rip), %rcx     # 0x9f1f2
movl $0x1fd8, %edx           # imm = 0x1FD8
callq 0xc140
leaq 0x59392(%rip), %rdi     # 0x9dffe
leaq 0x58522(%rip), %rsi     # 0x9d195
leaq 0x5a578(%rip), %rcx     # 0x9f1f2
movl $0x1fdf, %edx           # imm = 0x1FDF
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopup(char const*, int)
bool ImGui::BeginPopup(const char* str_id, ImGuiWindowFlags flags)
{
    ImGuiContext& g = *GImGui;
    if (g.OpenPopupStack.Size <= g.BeginPopupStack.Size) // Early out for performance
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }
    flags |= ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings;
    return BeginPopupEx(g.CurrentWindow->GetID(str_id), flags);
}

// Assembly:
movq 0x9f055(%rip), %rax     # 0xe3ce0
movl 0x1c70(%rax), %ecx
cmpl 0x1c80(%rax), %ecx
jle 0x44cc7
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
orl $0x141, %ebx            # imm = 0x141
movq 0x1ae0(%rax), %rdi
xorl %edx, %edx
callq 0x3700a
movl %eax, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x44b2e
andl $0x0, 0x1b88(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupModal(char const*, bool*, int)
bool ImGui::BeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags flags)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(name);
    if (!IsPopupOpen(id, ImGuiPopupFlags_None))
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x9eff4(%rip), %r12     # 0xe3ce0
movq 0x1ae0(%r12), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3700a
movl %eax, %edi
xorl %esi, %esi
callq 0x384af
testb %al, %al
je 0x44da3
testb $0x1, 0x1b88(%r12)
jne 0x44d67
movss 0x572f6(%rip), %xmm0    # 0x9c018
movss 0x10(%r12), %xmm1
mulss %xmm0, %xmm1
mulss 0x14(%r12), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq 0x9efa2(%rip), %rax     # 0xe3ce0
orl $0x1, 0x1b88(%rax)
movlps %xmm1, 0x1b98(%rax)
movabsq $0x3f0000003f000000, %rcx # imm = 0x3F0000003F000000
movq %rcx, 0x1ba0(%rax)
movl $0x4, 0x1b8c(%rax)
orl $0xc000020, %r14d       # imm = 0xC000020
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x3bad8
testb %al, %al
je 0x44dae
movb $0x1, %al
testq %rbx, %rbx
je 0x44db5
cmpb $0x0, (%rbx)
jne 0x44db5
callq 0x44bbe
movl 0x1c80(%r12), %edi
pushq $0x1
popq %rsi
callq 0x44963
jmp 0x44db3
andl $0x0, 0x1b88(%r12)
jmp 0x44db3
callq 0x44bbe
xorl %eax, %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::OpenPopupOnItemClick(char const*, int)
void ImGui::OpenPopupOnItemClick(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
    {
        ImGuiID id = str_id ? window->GetID(str_id) : window->DC.LastItemId; // If user hasn't passed an ID, we can use the LastItemID. Using LastItemID as a Popup ID won't conflict!
        IM_ASSERT(id != 0);                                                  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a Text() item)
        OpenPopupEx(id, popup_flags);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x9eef2(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %r15
movl %esi, %edi
andl $0x1f, %edi
callq 0x40253
testb %al, %al
je 0x44e25
pushq $0x8
popq %rdi
callq 0x374fd
testb %al, %al
je 0x44e25
testq %r14, %r14
je 0x44e30
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3700a
movl %eax, %edi
jmp 0x44e37
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x124(%r15), %edi
testl %edi, %edi
je 0x44e4c
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4472e
leaq 0x5a652(%rip), %rdi     # 0x9f4a5
leaq 0x5833b(%rip), %rsi     # 0x9d195
leaq 0x5a3c3(%rip), %rcx     # 0x9f224
movl $0x1fef, %edx           # imm = 0x1FEF
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupContextItem(char const*, int)
bool ImGui::BeginPopupContextItem(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (window->SkipItems)
        return false;
    ImGuiID id = str_id ? window->GetID(str_id) : window->DC.LastItemId; // If user hasn't passed an ID, we can use the LastItemID. Using LastItemID as a Popup ID won't conflict!
    IM_ASSERT(id != 0);                                                  // You cannot pass a NULL str_id if the last item has no identifier (e.g. a Text() item)
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
        OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %rsi
movq 0x9ee62(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rdi
cmpb $0x0, 0x93(%rdi)
je 0x44e95
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
testq %rsi, %rsi
je 0x44ea6
xorl %edx, %edx
callq 0x3700a
movl %eax, %r14d
jmp 0x44ead
movl 0x124(%rdi), %r14d
testl %r14d, %r14d
je 0x44ee7
movl %ebx, %edi
andl $0x1f, %edi
callq 0x40253
testb %al, %al
je 0x44ed6
pushq $0x8
popq %rdi
callq 0x374fd
testb %al, %al
je 0x44ed6
movl %r14d, %edi
movl %ebx, %esi
callq 0x4472e
movl %r14d, %edi
movl $0x141, %esi            # imm = 0x141
popq %rbx
popq %r14
popq %rbp
jmp 0x44b2e
leaq 0x5a5b7(%rip), %rdi     # 0x9f4a5
leaq 0x582a0(%rip), %rsi     # 0x9d195
leaq 0x5a368(%rip), %rcx     # 0x9f264
movl $0x1fff, %edx           # imm = 0x1FFF
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupContextWindow(char const*, int)
bool ImGui::BeginPopupContextWindow(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (!str_id)
        str_id = "window_context";
    ImGuiID id = window->GetID(str_id);
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && IsWindowHovered(ImGuiHoveredFlags_AllowWhenBlockedByPopup))
        if (!(popup_flags & ImGuiPopupFlags_NoOpenOverItems) || !IsAnyItemHovered())
            OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x9edca(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rax
testq %rdi, %rdi
leaq 0x5a37e(%rip), %rsi     # 0x9f2a5
cmovneq %rdi, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3700a
movl %eax, %r14d
movl %ebx, %edi
andl $0x1f, %edi
callq 0x40253
testb %al, %al
je 0x44f7c
pushq $0x8
popq %rdi
callq 0x425a6
testb %al, %al
je 0x44f7c
testb $0x40, %bl
jne 0x44f63
movl %r14d, %edi
movl %ebx, %esi
callq 0x4472e
jmp 0x44f7c
movq 0x9ed76(%rip), %rax     # 0xe3ce0
cmpl $0x0, 0x1b1c(%rax)
jne 0x44f7c
cmpl $0x0, 0x1b20(%rax)
je 0x44f57
movl %r14d, %edi
movl $0x141, %esi            # imm = 0x141
popq %rbx
popq %r14
popq %rbp
jmp 0x44b2e
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupContextVoid(char const*, int)
bool ImGui::BeginPopupContextVoid(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiWindow* window = GImGui->CurrentWindow;
    if (!str_id)
        str_id = "void_context";
    ImGuiID id = window->GetID(str_id);
    int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_);
    if (IsMouseReleased(mouse_button) && !IsWindowHovered(ImGuiHoveredFlags_AnyWindow))
        if (GetTopMostPopupModal() == NULL)
            OpenPopupEx(id, popup_flags);
    return BeginPopupEx(id, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x9ed43(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rax
testq %rdi, %rdi
leaq 0x5a306(%rip), %rsi     # 0x9f2b4
cmovneq %rdi, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3700a
movl %eax, %r14d
movl %ebx, %edi
andl $0x1f, %edi
callq 0x40253
testb %al, %al
je 0x44fed
pushq $0x4
popq %rdi
callq 0x425a6
testb %al, %al
jne 0x44fed
callq 0x38561
testq %rax, %rax
jne 0x44fed
movl %r14d, %edi
movl %ebx, %esi
callq 0x4472e
movl %r14d, %edi
movl $0x141, %esi            # imm = 0x141
popq %rbx
popq %r14
popq %rbp
jmp 0x44b2e
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetWindowAllowedExtentRect(ImGuiWindow*)
ImRect ImGui::GetWindowAllowedExtentRect(ImGuiWindow* window)
{
    IM_UNUSED(window);
    ImVec2 padding = GImGui->Style.DisplaySafeAreaPadding;
    ImRect r_screen = GetViewportRect();
    r_screen.Expand(ImVec2((r_screen.GetWidth() > padding.x * 2) ? -padding.x : 0.0f, (r_screen.GetHeight() > padding.y * 2) ? -padding.y : 0.0f));
    return r_screen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x9e93a(%rip), %rax     # 0xe3ce0
movss 0x160c(%rax), %xmm0
movss 0x1610(%rax), %xmm2
movss 0x10(%rax), %xmm3
movss 0x14(%rax), %xmm4
movaps %xmm0, %xmm1
addss %xmm0, %xmm1
movaps 0x56c12(%rip), %xmm5    # 0x9bfe0
xorps %xmm5, %xmm0
cmpltss %xmm3, %xmm1
andps %xmm0, %xmm1
movaps %xmm2, %xmm6
addss %xmm2, %xmm6
xorps %xmm5, %xmm2
cmpltss %xmm4, %xmm6
andps %xmm2, %xmm6
xorps %xmm2, %xmm2
xorps %xmm0, %xmm0
subss %xmm1, %xmm0
subss %xmm6, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
addss %xmm3, %xmm1
addss %xmm4, %xmm6
unpcklps %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0],xmm1[1],xmm6[1]
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNavID(unsigned int, int, unsigned int)
void ImGui::SetNavID(ImGuiID id, int nav_layer, ImGuiID focus_scope_id)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavWindow);
    IM_ASSERT(nav_layer == 0 || nav_layer == 1);
    g.NavId = id;
    g.NavFocusScopeId = focus_scope_id;
    g.NavWindow->NavLastIds[nav_layer] = id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x9e8cc(%rip), %rcx     # 0xe3ce0
movq 0x1c90(%rcx), %rax
testq %rax, %rax
je 0x4543c
cmpl $0x2, %esi
jae 0x4545b
movl %edi, 0x1c98(%rcx)
movl %edx, 0x1c9c(%rcx)
movl %esi, %ecx
movl %edi, 0x3b0(%rax,%rcx,4)
popq %rbp
retq
leaq 0x59fde(%rip), %rdi     # 0x9f421
leaq 0x57d4b(%rip), %rsi     # 0x9d195
leaq 0x59ec1(%rip), %rcx     # 0x9f312
movl $0x20a6, %edx           # imm = 0x20A6
callq 0xc140
leaq 0x59edc(%rip), %rdi     # 0x9f33e
leaq 0x57d2c(%rip), %rsi     # 0x9d195
leaq 0x59ea2(%rip), %rcx     # 0x9f312
movl $0x20a7, %edx           # imm = 0x20A7
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNavIDWithRectRel(unsigned int, int, unsigned int, ImRect const&)
void ImGui::SetNavIDWithRectRel(ImGuiID id, int nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel)
{
    ImGuiContext& g = *GImGui;
    SetNavID(id, nav_layer, focus_scope_id);
    g.NavWindow->NavRectRel[nav_layer] = rect_rel;
    g.NavMousePosDirty = true;
    g.NavDisableHighlight = false;
    g.NavDisableMouseHover = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %r14d
movq 0x9e84f(%rip), %r15     # 0xe3ce0
callq 0x45409
movq 0x1c90(%r15), %rax
movslq %r14d, %rcx
shlq $0x4, %rcx
movups (%rbx), %xmm0
movups %xmm0, 0x3b8(%rax,%rcx)
movw $0x1, 0x1ce5(%r15)
movb $0x1, 0x1ce7(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetFocusID(unsigned int, ImGuiWindow*)
void ImGui::SetFocusID(ImGuiID id, ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(id != 0);

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

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

// Assembly:
testl %edi, %edi
je 0x45587
movq 0x9e805(%rip), %rax     # 0xe3ce0
movl 0x14c(%rsi), %ecx
cmpq %rsi, 0x1c90(%rax)
je 0x454f1
movb $0x0, 0x1ce9(%rax)
movq %rsi, 0x1c90(%rax)
movl %edi, 0x1c98(%rax)
movl %ecx, 0x1cdc(%rax)
movl 0x158(%rsi), %edx
movl %edx, 0x1c9c(%rax)
movl %edi, 0x3b0(%rsi,%rcx,4)
cmpl %edi, 0x124(%rsi)
jne 0x4556e
movss 0x12c(%rsi), %xmm0
movss 0x10(%rsi), %xmm1
movss 0x14(%rsi), %xmm2
subss %xmm1, %xmm0
movss 0x130(%rsi), %xmm3
subss %xmm2, %xmm3
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movss 0x134(%rsi), %xmm3
subss %xmm1, %xmm3
movss 0x138(%rsi), %xmm1
subss %xmm2, %xmm1
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movlhps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
shlq $0x4, %rcx
movups %xmm0, 0x3b8(%rsi,%rcx)
cmpl $0x2, 0x1b68(%rax)
jne 0x4557f
movb $0x1, 0x1ce7(%rax)
retq
movb $0x1, 0x1ce6(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x59f13(%rip), %rdi     # 0x9f4a5
leaq 0x57bfc(%rip), %rsi     # 0x9d195
leaq 0x59dbf(%rip), %rcx     # 0x9f35f
movl $0x20ba, %edx           # imm = 0x20BA
callq 0xc140