LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: SetCursorPosYAndSetupForPrevLine(float, float)
static void SetCursorPosYAndSetupForPrevLine(float pos_y, float line_height)
{
    // Set cursor position and a few other things so that SetScrollHereY() and Columns() can work when seeking cursor.
    // FIXME: It is problematic that we have to do that here, because custom/equivalent end-user code would stumble on the same issue.
    // The clipper should probably have a 4th step to display the last item in a regular manner.
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float off_y = pos_y - window->DC.CursorPos.y;
    window->DC.CursorPos.y = pos_y;
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, pos_y);
    window->DC.CursorPosPrevLine.y = window->DC.CursorPos.y - line_height;  // Setting those fields so that SetScrollHereY() can properly function after the end of our clipper usage.
    window->DC.PrevLineSize.y = (line_height - g.Style.ItemSpacing.y);      // If we end up needing more accurate data (to e.g. use SameLine) we may as well make the clipper have a fourth step to let user process and display the last item in their list.
    if (ImGuiOldColumns* columns = window->DC.CurrentColumns)
        columns->LineMinY = window->DC.CursorPos.y;                         // Setting this so that cell Y position are set properly
    if (ImGuiTable* table = g.CurrentTable)
    {
        if (table->IsInsideRow)
            ImGui::TableEndRow(table);
        table->RowPosY2 = window->DC.CursorPos.y;
        const int row_increase = (int)((off_y / line_height) + 0.5f);
        //table->CurrentRow += row_increase; // Can't do without fixing TableEndRow()
        table->RowBgColorCounter += row_increase;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xae30d(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %r14
movaps %xmm0, %xmm4
subss 0xdc(%r14), %xmm4
movss %xmm0, 0xdc(%r14)
movss 0xf4(%r14), %xmm3
movaps %xmm0, %xmm2
cmpless %xmm3, %xmm2
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
orps %xmm3, %xmm2
movss %xmm2, 0xf4(%r14)
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0xe4(%r14)
movaps %xmm1, %xmm2
subss 0x15ac(%rax), %xmm2
movss %xmm2, 0x10c(%r14)
movq 0x1b0(%r14), %rcx
testq %rcx, %rcx
je 0x35a47
movss %xmm0, 0x1c(%rcx)
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x35a9d
cmpb $0x1, 0x249(%rbx)
jne 0x35a7f
movq %rbx, %rdi
movss %xmm1, -0x14(%rbp)
movaps %xmm4, -0x30(%rbp)
callq 0x733b7
movaps -0x30(%rbp), %xmm4
movss -0x14(%rbp), %xmm1
movss 0xdc(%r14), %xmm0
divss %xmm1, %xmm4
addss 0x6658d(%rip), %xmm4    # 0x9c018
cvttss2si %xmm4, %eax
movss %xmm0, 0x80(%rbx)
addl %eax, 0x94(%rbx)
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::GetColorU32(int, float)
ImU32 ImGui::GetColorU32(ImGuiCol idx, float alpha_mul)
{
    ImGuiStyle& style = GImGui->Style;
    ImVec4 c = style.Colors[idx];
    c.w *= style.Alpha * alpha_mul;
    return ColorConvertFloat4ToU32(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xadf9e(%rip), %rax     # 0xe3ce0
movslq %edi, %rcx
shlq $0x4, %rcx
movups 0x1624(%rax,%rcx), %xmm1
leaq -0x10(%rbp), %rdi
movaps %xmm1, (%rdi)
mulss 0x1560(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x34ce6
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetColorU32(ImVec4 const&)
ImU32 ImGui::GetColorU32(const ImVec4& col)
{
    ImGuiStyle& style = GImGui->Style;
    ImVec4 c = col;
    c.w *= style.Alpha;
    return ColorConvertFloat4ToU32(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xadf5c(%rip), %rax     # 0xe3ce0
movups (%rdi), %xmm0
leaq -0x10(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x1560(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x34ce6
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetColorU32(unsigned int)
ImU32 ImGui::GetColorU32(ImU32 col)
{
    ImGuiStyle& style = GImGui->Style;
    if (style.Alpha >= 1.0f)
        return col;
    ImU32 a = (col & IM_COL32_A_MASK) >> IM_COL32_A_SHIFT;
    a = (ImU32)(a * style.Alpha); // We don't need to clamp 0..255 because Style.Alpha is in 0..1 range.
    return (col & ~IM_COL32_A_MASK) | (a << IM_COL32_A_SHIFT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
movq 0xadf0b(%rip), %rcx     # 0xe3ce0
movss 0x1560(%rcx), %xmm0
ucomiss 0x66214(%rip), %xmm0    # 0x9bff8
jae 0x35e04
movl %eax, %ecx
shrl $0x18, %ecx
cvtsi2ss %ecx, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rcx
andl $0xffffff, %eax         # imm = 0xFFFFFF
shll $0x18, %ecx
orl %eax, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleColor(int, unsigned int)
void ImGui::PushStyleColor(ImGuiCol idx, ImU32 col)
{
    ImGuiContext& g = *GImGui;
    ImGuiColorMod backup;
    backup.Col = idx;
    backup.BackupValue = g.Style.Colors[idx];
    g.ColorStack.push_back(backup);
    g.Style.Colors[idx] = ColorConvertU32ToFloat4(col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq 0xadec4(%rip), %r14     # 0xe3ce0
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
movslq %edi, %r15
shlq $0x4, %r15
movups 0x1624(%r14,%r15), %xmm0
movups %xmm0, 0x4(%rsi)
leaq 0x1c10(%r14), %rdi
callq 0x49d72
movl %ebx, %edi
callq 0x34c98
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x1624(%r14,%r15)
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::PushStyleColor(int, ImVec4 const&)
void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
    ImGuiContext& g = *GImGui;
    ImGuiColorMod backup;
    backup.Col = idx;
    backup.BackupValue = g.Style.Colors[idx];
    g.ColorStack.push_back(backup);
    g.Style.Colors[idx] = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0xade69(%rip), %r14     # 0xe3ce0
leaq -0x2c(%rbp), %rsi
movl %edi, (%rsi)
movslq %edi, %r15
shlq $0x4, %r15
movups 0x1624(%r14,%r15), %xmm0
movups %xmm0, 0x4(%rsi)
leaq 0x1c10(%r14), %rdi
callq 0x49d72
movups (%rbx), %xmm0
movups %xmm0, 0x1624(%r14,%r15)
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::PopStyleColor(int)
void ImGui::PopStyleColor(int count)
{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        ImGuiColorMod& backup = g.ColorStack.back();
        g.Style.Colors[backup.Col] = backup.BackupValue;
        g.ColorStack.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xade19(%rip), %r15     # 0xe3ce0
leaq 0x1c10(%r15), %r14
addq $0x1624, %r15           # imm = 0x1624
testl %ebx, %ebx
jle 0x35efd
movq %r14, %rdi
callq 0x49dce
movslq (%rax), %rcx
shlq $0x4, %rcx
movups 0x4(%rax), %xmm0
movups %xmm0, (%r15,%rcx)
movq %r14, %rdi
callq 0x49e0a
decl %ebx
jmp 0x35ed5
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::PushStyleVar(int, float)
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1)
    {
        ImGuiContext& g = *GImGui;
        float* pvar = (float*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm0, -0x1c(%rbp)
movl %edi, %ebx
callq 0x35f91
cmpl $0x8, (%rax)
jne 0x35f72
cmpl $0x1, 0x4(%rax)
jne 0x35f72
movq 0xaddad(%rip), %r14     # 0xe3ce0
movl 0x8(%rax), %r15d
leaq 0x1c20(%r14), %rdi
movss 0x1560(%r14,%r15), %xmm0
leaq -0x28(%rbp), %rsi
movl %ebx, (%rsi)
movss %xmm0, 0x4(%rsi)
callq 0x49e38
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x1560(%r14,%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x67536(%rip), %rdi     # 0x9d4af
leaq 0x67215(%rip), %rsi     # 0x9d195
leaq 0x67570(%rip), %rcx     # 0x9d4f7
movl $0x9c4, %edx            # imm = 0x9C4
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
    {
        ImGuiContext& g = *GImGui;
        ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
callq 0x35f91
cmpl $0x8, (%rax)
jne 0x3603d
cmpl $0x2, 0x4(%rax)
jne 0x3603d
movq 0xadcea(%rip), %r15     # 0xe3ce0
movl 0x8(%rax), %r12d
leaq 0x1c20(%r15), %rdi
movsd 0x1560(%r15,%r12), %xmm0
leaq -0x2c(%rbp), %rsi
movl %r14d, (%rsi)
movss %xmm0, 0x4(%rsi)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x8(%rsi)
callq 0x49e38
movq (%rbx), %rax
movq %rax, 0x1560(%r15,%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x674e2(%rip), %rdi     # 0x9d526
leaq 0x6714a(%rip), %rsi     # 0x9d195
leaq 0x6751e(%rip), %rcx     # 0x9d570
movl $0x9d2, %edx            # imm = 0x9D2
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopStyleVar(int)
void ImGui::PopStyleVar(int count)
{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        // We avoid a generic memcpy(data, &backup.Backup.., GDataTypeSize[info->Type] * info->Count), the overhead in Debug is not worth it.
        ImGuiStyleMod& backup = g.StyleVarStack.back();
        const ImGuiStyleVarInfo* info = GetStyleVarInfo(backup.VarIdx);
        void* data = info->GetVarPtr(&g.Style);
        if (info->Type == ImGuiDataType_Float && info->Count == 1)      { ((float*)data)[0] = backup.BackupFloat[0]; }
        else if (info->Type == ImGuiDataType_Float && info->Count == 2) { ((float*)data)[0] = backup.BackupFloat[0]; ((float*)data)[1] = backup.BackupFloat[1]; }
        g.StyleVarStack.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0xadc70(%rip), %r12     # 0xe3ce0
leaq 0x1c20(%r12), %r14
testl %ebx, %ebx
jle 0x360e1
movq %r14, %rdi
callq 0x49e92
movq %rax, %r15
movl (%rax), %edi
callq 0x35f91
cmpl $0x8, (%rax)
jne 0x360d5
movl 0x8(%rax), %ecx
movl 0x4(%rax), %eax
cmpl $0x2, %eax
je 0x360b5
cmpl $0x1, %eax
jne 0x360d5
movss 0x4(%r15), %xmm0
movss %xmm0, 0x1560(%r12,%rcx)
jmp 0x360d5
movss 0x4(%r15), %xmm0
movss %xmm0, 0x1560(%r12,%rcx)
movss 0x8(%r15), %xmm0
movss %xmm0, 0x1564(%r12,%rcx)
movq %r14, %rdi
callq 0x49ece
decl %ebx
jmp 0x36078
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::FindRenderedTextEnd(char const*, char const*)
const char* ImGui::FindRenderedTextEnd(const char* text, const char* text_end)
{
    const char* text_display_end = text;
    if (!text_end)
        text_end = (const char*)-1;

    while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
        text_display_end++;
    return text_display_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x1, %rsi
sbbq %rcx, %rcx
orq %rsi, %rcx
cmpq %rcx, %rax
jae 0x36154
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0x36149
testl %edx, %edx
jne 0x3614f
jmp 0x36154
cmpb $0x23, 0x1(%rax)
je 0x36154
incq %rax
jmp 0x36136
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderText(ImVec2, char const*, char const*, bool)
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    // Hide anything after a '##' string
    const char* text_display_end;
    if (hide_text_after_hash)
    {
        text_display_end = FindRenderedTextEnd(text, text_end);
    }
    else
    {
        if (!text_end)
            text_end = text + strlen(text); // FIXME-OPT
        text_display_end = text_end;
    }

    if (text != text_display_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_display_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0xadb68(%rip), %r13     # 0xe3ce0
movq 0x1ae0(%r13), %r15
testl %edx, %edx
je 0x36193
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36123
movq %rax, %r14
jmp 0x361a6
testq %r14, %r14
jne 0x361a6
movq %rbx, %rdi
callq 0xc380
movq %rax, %r14
addq %rbx, %r14
cmpq %rbx, %r14
je 0x36213
movq 0x2b8(%r15), %r15
movq 0x1978(%r13), %r12
movss 0x1980(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x65e29(%rip), %xmm0    # 0x9bff8
xorl %edi, %edi
callq 0x35d33
andq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
xorps %xmm1, %xmm1
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x64732
cmpb $0x1, 0x3138(%r13)
jne 0x36213
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36222
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::RenderTextWrapped(ImVec2, char const*, char const*, float)
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    if (!text_end)
        text_end = text + strlen(text); // FIXME-OPT

    if (text != text_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_end, wrap_width);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm1, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0xad933(%rip), %r13     # 0xe3ce0
movq 0x1ae0(%r13), %r15
testq %rsi, %rsi
jne 0x363c7
movq %rbx, %rdi
callq 0xc380
movq %rax, %r14
addq %rbx, %r14
cmpq %rbx, %r14
je 0x36436
movq 0x2b8(%r15), %r15
movq 0x1978(%r13), %r12
movss 0x1980(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x65c08(%rip), %xmm0    # 0x9bff8
xorl %edi, %edi
callq 0x35d33
andq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
movss -0x30(%rbp), %xmm1
callq 0x64732
cmpb $0x1, 0x3138(%r13)
jne 0x36436
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36222
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::CalcTextSize(char const*, char const*, bool, float)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
    ImGuiContext& g = *GImGui;

    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindRenderedTextEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;

    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    if (text == text_display_end)
        return ImVec2(0.0f, font_size);
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);

    // Round
    text_size.x = IM_FLOOR(text_size.x + 0.95f);

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, %xmm2
movq %rsi, %rax
movq %rdi, %rbx
movq 0xad6dd(%rip), %r14     # 0xe3ce0
testl %edx, %edx
je 0x3661c
movq %rbx, %rdi
movq %rax, %rsi
movss %xmm2, -0x14(%rbp)
callq 0x36123
movss -0x14(%rbp), %xmm2
movss 0x1980(%r14), %xmm0
cmpq %rbx, %rax
je 0x3665f
movq 0x1978(%r14), %rdi
movss 0x66237(%rip), %xmm1    # 0x9c870
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x6b56a
movss 0x6623a(%rip), %xmm1    # 0x9c888
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
jmp 0x3666a
movq %xmm0, %xmm0            # xmm0 = xmm0[0],zero
xorps %xmm1, %xmm1
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %r8, -0x38(%rbp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x36123
movq %rax, %r12
cmpl %ebx, %r12d
je 0x36709
movq %r13, %r10
movq 0xad627(%rip), %r13     # 0xe3ce0
movq 0x1ae0(%r13), %rax
movq 0x2b8(%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq -0x38(%rbp), %r9
pushq -0x30(%rbp)
pushq %r10
callq 0x36445
popq %rax
popq %rcx
cmpb $0x1, 0x3138(%r13)
jne 0x36709
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36222
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::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 $0x28, %rsp
movl %esi, %ebx
movl %edi, %ecx
leaq -0x38(%rbp), %rsi
movlps %xmm0, (%rsi)
leaq -0x40(%rbp), %rdx
movlps %xmm1, (%rdx)
movq 0xad247(%rip), %r15     # 0xe3ce0
movq 0x1ae0(%r15), %r14
movq 0x2b8(%r14), %rdi
pushq $0xf
popq %r8
movss %xmm2, -0x30(%rbp)
movaps %xmm2, %xmm0
callq 0x64020
testl %ebx, %ebx
je 0x36b89
movss 0x15a4(%r15), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jbe 0x36b89
movq 0x2b8(%r14), %r15
movss 0x65514(%rip), %xmm0    # 0x9bff8
leaq -0x38(%rbp), %rax
movss (%rax), %xmm2
addss %xmm0, %xmm2
movss %xmm1, -0x2c(%rbp)
movss 0x4(%rax), %xmm1
addss %xmm0, %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x50(%rbp), %r12
movlps %xmm2, (%r12)
leaq -0x40(%rbp), %rbx
movss (%rbx), %xmm2
addss %xmm0, %xmm2
movss 0x4(%rbx), %xmm1
addss %xmm0, %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x48(%rbp), %r13
movlps %xmm2, (%r13)
pushq $0x6
popq %rdi
callq 0x35d33
pushq $0xf
popq %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %eax, %ecx
movss -0x30(%rbp), %xmm0
movl %r8d, %r12d
movss -0x2c(%rbp), %xmm1
callq 0x63f6c
movq 0x2b8(%r14), %r15
pushq $0x5
popq %rdi
movss 0x65492(%rip), %xmm0    # 0x9bff8
callq 0x35d33
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
movq %rbx, %rdx
movl %eax, %ecx
movss -0x30(%rbp), %xmm0
movl %r12d, %r8d
movss -0x2c(%rbp), %xmm1
callq 0x63f6c
addq $0x28, %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::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 $0x28, %rsp
movlps %xmm0, -0x40(%rbp)
movlps %xmm1, -0x38(%rbp)
movq 0xad128(%rip), %rax     # 0xe3ce0
movss 0x15a4(%rax), %xmm4
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm4
jbe 0x36c82
movss %xmm4, -0x30(%rbp)
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
movss %xmm2, -0x2c(%rbp)
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movq 0x1ae0(%rax), %r13
movq 0x2b8(%r13), %rbx
movss 0x653fe(%rip), %xmm2    # 0x9bff8
addss %xmm2, %xmm0
addss %xmm2, %xmm3
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
leaq -0x50(%rbp), %r14
movlps %xmm0, (%r14)
addss %xmm2, %xmm1
addss %xmm2, %xmm4
movaps %xmm2, %xmm0
unpcklps %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
leaq -0x48(%rbp), %r15
movlps %xmm1, (%r15)
pushq $0x6
popq %rdi
callq 0x35d33
pushq $0xf
popq %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl %r12d, %r8d
movss -0x30(%rbp), %xmm1
callq 0x63f6c
movq 0x2b8(%r13), %rbx
pushq $0x5
popq %rdi
movss 0x6539a(%rip), %xmm0    # 0x9bff8
callq 0x35d33
leaq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl %r12d, %r8d
movss -0x30(%rbp), %xmm1
callq 0x63f6c
addq $0x28, %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: ImGuiWindow::ImGuiWindow(ImGuiContext*, char const*)
ImGuiWindow::ImGuiWindow(ImGuiContext* context, const char* name) : DrawListInst(NULL)
{
    memset(this, 0, sizeof(*this));
    Name = ImStrdup(name);
    NameBufLen = (int)strlen(name) + 1;
    ID = ImHashStr(name);
    IDStack.push_back(ID);
    MoveId = GetID("#MOVE");
    ScrollTarget = ImVec2(FLT_MAX, FLT_MAX);
    ScrollTargetCenterRatio = ImVec2(0.5f, 0.5f);
    AutoFitFramesX = AutoFitFramesY = -1;
    AutoPosLastDirection = ImGuiDir_None;
    SetWindowPosAllowFlags = SetWindowSizeAllowFlags = SetWindowCollapsedAllowFlags = ImGuiCond_Always | ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing;
    SetWindowPosVal = SetWindowPosPivot = ImVec2(FLT_MAX, FLT_MAX);
    LastFrameActive = -1;
    LastTimeActive = -1.0f;
    FontWindowScale = 1.0f;
    SettingsOffset = -1;
    DrawList = &DrawListInst;
    DrawList->_Data = &context->DrawListSharedData;
    DrawList->_OwnerName = Name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc8(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0xc8(%rdi)
leaq 0xd8(%rdi), %r12
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movups %xmm0, 0x5c(%rdi)
movups %xmm0, 0x6c(%rdi)
movups %xmm0, 0x7c(%rdi)
movups %xmm0, 0xb4(%rdi)
movq %r12, %rdi
callq 0x49f62
leaq 0x290(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x2a0(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x2c0(%rbx), %r13
movl $0x3e8, %edx            # imm = 0x3E8
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc270
movq %r15, %rdi
callq 0x343e0
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xc380
incl %eax
movl %eax, 0x50(%rbx)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3479a
leaq 0x8(%rbx), %rsi
movl %eax, 0x8(%rbx)
movq -0x30(%rbp), %rdi
callq 0x49fbe
leaq 0x66952(%rip), %rsi     # 0x9d87d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3700a
movl %eax, 0x54(%rbx)
movaps 0x658c1(%rip), %xmm0    # 0x9c800
movups %xmm0, 0x6c(%rbx)
orw $-0x1, 0xa4(%rbx)
orl $-0x1, 0xa8(%rbx)
movzbl 0xb2(%rbx), %eax
shll $0x18, %eax
orl $0xf0f0f, %eax          # imm = 0xF0F0F
movl %eax, 0xaf(%rbx)
movabsq $0x7f7fffff7f7fffff, %rax # imm = 0x7F7FFFFF7F7FFFFF
movq %rax, 0xbc(%rbx)
movq %rax, 0xb4(%rbx)
movabsq $-0x407fffff00000001, %rax # imm = 0xBF800000FFFFFFFF
movq %rax, 0x280(%rbx)
movabsq $-0xc0800000, %rax      # imm = 0xFFFFFFFF3F800000
movq %rax, 0x2b0(%rbx)
movq %r13, 0x2b8(%rbx)
addq $0x1988, %r14           # imm = 0x1988
movq %r14, 0x2f8(%rbx)
movq (%rbx), %rax
movq %rax, 0x300(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x36ff9
movq %rax, %rbx
movq %r13, %rdi
callq 0x4a00c
movq -0x38(%rbp), %rdi
callq 0x4a06a
movq -0x40(%rbp), %rdi
callq 0x4bdca
movq %r12, %rdi
callq 0x4a086
movq -0x30(%rbp), %rdi
callq 0x4a0bc
movq %rbx, %rdi
callq 0xc580
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
addq $0xc8, %rdi
callq 0x4a148
movl (%rax), %edx
movq %rbx, %rsi
subq %r14, %rsi
testq %rbx, %rbx
cmoveq %rbx, %rsi
movq %r14, %rdi
callq 0x3479a
movl %eax, %ebx
movl %eax, %edi
callq 0x370fd
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::~ImGuiWindow()
ImGuiWindow::~ImGuiWindow()
{
    IM_ASSERT(DrawList == &DrawListInst);
    IM_DELETE(Name);
    for (int i = 0; i != ColumnsStorage.Size; i++)
        ColumnsStorage[i].~ImGuiOldColumns();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x2c0(%rdi), %r14
cmpq %r14, 0x2b8(%rdi)
jne 0x370d6
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4a0d8
leaq 0x2a0(%rbx), %r15
xorl %r12d, %r12d
cmpl (%r15), %r12d
je 0x37097
movq %r15, %rdi
movl %r12d, %esi
callq 0x4a0ea
movq %rax, %rdi
callq 0x4a124
incl %r12d
jmp 0x3707a
movq %r14, %rdi
callq 0x4a00c
movq %r15, %rdi
callq 0x4a06a
leaq 0x290(%rbx), %rdi
callq 0x4bdca
leaq 0xd8(%rbx), %rdi
callq 0x4a086
addq $0xc8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4a0bc
leaq 0x667a6(%rip), %rdi     # 0x9d883
leaq 0x660b1(%rip), %rsi     # 0x9d195
leaq 0x667b2(%rip), %rcx     # 0x9d89d
movl $0xb39, %edx            # imm = 0xB39
callq 0xc140
movq %rax, %rdi
callq 0x2d132
// File: /workspace/github_cpp_makefile_star2_O2/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 0xacbd8(%rip), %rax     # 0xe3ce0
cmpl %edi, 0x1b30(%rax)
jne 0x37116
movl %edi, 0x1b34(%rax)
cmpl %edi, 0x1b70(%rax)
jne 0x37125
movb $0x1, 0x1b74(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq %rsi, (%rbx)
addq $0xc8, %rdi
callq 0x4a148
movl (%rax), %edx
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x34768
movl %eax, %ebx
movl %eax, %edi
callq 0x370fd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq -0xc(%rbp), %rbx
movl %esi, (%rbx)
addq $0xc8, %rdi
callq 0x4a148
movl (%rax), %edx
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x34768
movl %eax, %ebx
movl %eax, %edi
callq 0x370fd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetIDNoKeepAlive(char const*, char const*)
ImGuiID ImGuiWindow::GetIDNoKeepAlive(const char* str, const char* str_end)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashStr(str, str_end ? (str_end - str) : 0, seed);
#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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
addq $0xc8, %rdi
callq 0x4a148
movq %rbx, %rsi
subq %r14, %rsi
testq %rbx, %rbx
cmoveq %rbx, %rsi
movl (%rax), %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3479a
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0xc8, %rdi
callq 0x4a148
movss (%rbx), %xmm0
movss 0x10(%r14), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl (%rax), %edx
leaq -0x20(%rbp), %rdi
movl %ecx, (%rdi)
movss 0x4(%rbx), %xmm0
movss 0x14(%r14), %xmm2
subss %xmm2, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x4(%rdi)
movss 0x8(%rbx), %xmm0
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x8(%rdi)
movss 0xc(%rbx), %xmm0
subss %xmm2, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0xc(%rdi)
pushq $0x10
popq %rsi
callq 0x34768
movl %eax, %ebx
movl %eax, %edi
callq 0x370fd
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::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 0xaca24(%rip), %rbx     # 0xe3ce0
leaq 0x1c50(%rbx), %rdi
callq 0x4a180
addq $0x1c60, %rbx           # imm = 0x1C60
movq %rbx, %rdi
callq 0x4a1a8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x76cbd
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b8(%rdi), %rax
movl 0x14(%rax), %ecx
movl %ecx, 0x3d8(%rdi)
movl 0x24(%rax), %eax
movl %eax, 0x3dc(%rdi)
addq $0xc8, %rdi
callq 0x4a1d0
movq 0x2b8(%rbx), %rdi
callq 0x61dd0
leaq 0x198(%rbx), %rdi
callq 0x4a1f8
leaq 0x1d8(%rbx), %rdi
callq 0x4a220
addq $0x1e8, %rbx            # imm = 0x1E8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4a220
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x3e0(%rdi)
movq 0x2b8(%rdi), %rdi
addq $0x10, %rdi
movl 0x3d8(%rbx), %esi
callq 0x4a248
movq 0x2b8(%rbx), %rdi
addq $0x20, %rdi
movl 0x3dc(%rbx), %esi
callq 0x4a29e
andq $0x0, 0x3d8(%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::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 0xac93a(%rip), %rax     # 0xe3ce0
cmpl %edi, 0x1b30(%rax)
setne 0x1b3c(%rax)
je 0x373d5
andl $0x0, 0x1b38(%rax)
andw $0x0, 0x1b3f(%rax)
testl %edi, %edi
je 0x373d5
movl %edi, 0x1b80(%rax)
andl $0x0, 0x1b84(%rax)
movl %edi, 0x1b30(%rax)
andw $0x0, 0x1b3d(%rax)
movq %rsi, 0x1b60(%rax)
movb $0x0, 0x1b41(%rax)
testl %edi, %edi
je 0x3742b
movl %edi, 0x1b34(%rax)
movl $0x2, %ecx
cmpl %edi, 0x1ca0(%rax)
je 0x37425
cmpl %edi, 0x1cac(%rax)
je 0x37425
cmpl %edi, 0x1cb0(%rax)
je 0x37425
xorl %ecx, %ecx
cmpl %edi, 0x1cb4(%rax)
sete %cl
incl %ecx
movl %ecx, 0x1b68(%rax)
movb $0x0, 0x1b42(%rax)
andq $0x0, 0x1b44(%rax)
andq $0x0, 0x1b50(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xac883(%rip), %rax     # 0xe3ce0
movl %edi, 0x1b1c(%rax)
andw $0x0, 0x1b24(%rax)
testl %edi, %edi
je 0x3747f
cmpl %edi, 0x1b20(%rax)
je 0x3747f
andq $0x0, 0x1b28(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xac83b(%rip), %rax     # 0xe3ce0
movl 0x1b30(%rax), %ecx
cmpl %edi, %ecx
sete %dl
testl %ecx, %ecx
sete %cl
orb %dl, %cl
jne 0x374c2
cmpb $0x0, 0x2004(%rax)
je 0x374da
movw $0x101, 0x1b40(%rax)    # imm = 0x101
movq 0x1ae0(%rax), %rax
orl $0x4, 0x128(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x663d4(%rip), %rdi     # 0x9d8b9
leaq 0x65ca9(%rip), %rsi     # 0x9d195
leaq 0x663fe(%rip), %rcx     # 0x9d8f1
movl $0xbfe, %edx            # imm = 0xBFE
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0xac6f9(%rip), %rax     # 0xe3ce0
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_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: IsWindowContentHoverable(ImGuiWindow*, int)
static inline bool IsWindowContentHoverable(ImGuiWindow* window, ImGuiHoveredFlags flags)
{
    // An active popup disable hovering on other windows (apart from its own children)
    // FIXME-OPT: This could be cached/stored within the window.
    ImGuiContext& g = *GImGui;
    if (g.NavWindow)
        if (ImGuiWindow* focused_root_window = g.NavWindow->RootWindow)
            if (focused_root_window->WasActive && focused_root_window != window->RootWindow)
            {
                // For the purpose of those flags we differentiate "standard popup" from "modal popup"
                // NB: The order of those two tests is important because Modal windows are also Popups.
                if (focused_root_window->Flags & ImGuiWindowFlags_Modal)
                    return false;
                if ((focused_root_window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiHoveredFlags_AllowWhenBlockedByPopup))
                    return false;
            }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xac6cf(%rip), %rax     # 0xe3ce0
movq 0x1c90(%rax), %rcx
movb $0x1, %al
testq %rcx, %rcx
je 0x37656
movq 0x390(%rcx), %rcx
testq %rcx, %rcx
je 0x37656
cmpb $0x1, 0x8f(%rcx)
jne 0x37656
cmpq 0x390(%rdi), %rcx
je 0x37656
movl 0xc(%rcx), %ecx
btl $0x1b, %ecx
jb 0x37654
testb $0x8, %sil
jne 0x37656
andl $0x4000000, %ecx        # imm = 0x4000000
je 0x37656
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xac555(%rip), %rbx     # 0xe3ce0
movq (%rdi), %rcx
movq %rcx, -0x20(%rbp)
movq (%rsi), %rax
movq %rax, -0x18(%rbp)
testl %edx, %edx
je 0x377ce
movl $0x258, %esi            # imm = 0x258
addq 0x1ae0(%rbx), %rsi
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x49efc
movd (%r14), %xmm0
movd 0x4(%r14), %xmm2
movd 0x8(%r14), %xmm1
movd 0xc(%r14), %xmm3
jmp 0x377e6
movd %ecx, %xmm0
shrq $0x20, %rcx
movd %ecx, %xmm2
movd %eax, %xmm1
shrq $0x20, %rax
movd %eax, %xmm3
movss 0x15c0(%rbx), %xmm4
movss 0x15c4(%rbx), %xmm5
subss %xmm4, %xmm0
subss %xmm5, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
addss %xmm4, %xmm1
addss %xmm5, %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
leaq -0x30(%rbp), %rdi
movups %xmm0, (%rdi)
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rsi
callq 0x4acc0
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::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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq 0xac48a(%rip), %r15     # 0xe3ce0
movl $0x258, %esi            # imm = 0x258
addq 0x1ae0(%r15), %rsi
callq 0x4a2f6
testb %al, %al
jne 0x37892
testl %r14d, %r14d
je 0x37882
cmpl %r14d, 0x1b30(%r15)
je 0x37892
cmpl %r14d, 0x1c98(%r15)
je 0x37892
movb $0x1, %al
testb %bl, %bl
jne 0x37894
cmpb $0x1, 0x3138(%r15)
jne 0x37894
xorl %eax, %eax
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::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 0xac41e(%rip), %rcx     # 0xe3ce0
movl 0x1c4(%rdi), %r8d
movl 0x1cc(%rdi), %edx
incl %r8d
movl %r8d, 0x1c4(%rdi)
testb $0x5, %dl
jne 0x378e4
incl 0x1c8(%rdi)
movl 0x1b30(%rcx), %r9d
cmpl %esi, %r9d
jne 0x3793b
cmpb $0x1, 0x1e08(%rcx)
jne 0x3793b
testb $0x1, 0x1b50(%rcx)
jne 0x3793b
cmpq $0x0, 0x1df0(%rcx)
jne 0x3793b
movl %edx, %eax
andl $0x5, %eax
movq %rdi, 0x1df0(%rcx)
xorl %r10d, %r10d
cmpl $0x1, %eax
sbbl %r10d, %r10d
cmpb $0x0, 0x141(%rcx)
pushq $0x1
popq %rax
cmovnel %r10d, %eax
addl 0x1c8(%rdi), %eax
movl %eax, 0x1e04(%rcx)
cmpq %rdi, 0x1de8(%rcx)
je 0x37947
xorl %eax, %eax
retq
movb $0x1, %al
cmpl 0x1df8(%rcx), %r8d
je 0x37946
testb $0x5, %dl
jne 0x3796c
movl 0x1c8(%rdi), %edx
cmpl 0x1dfc(%rcx), %edx
jne 0x3796c
movl %esi, 0x1cb0(%rcx)
retq
cmpl %esi, %r9d
jne 0x37944
pushq %rbp
movq %rsp, %rbp
callq 0x37444
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x379de
pushq %rbp
movq %rsp, %rbp
movq 0xac33d(%rip), %rax     # 0xe3ce0
movq 0x1ae0(%rax), %rax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x379be
jp 0x379be
movss 0x240(%rax), %xmm0
jmp 0x379ce
jbe 0x379ce
movss 0x10(%rax), %xmm1
subss 0x5c(%rax), %xmm1
addss %xmm1, %xmm0
subss (%rdi), %xmm0
maxss 0x6461e(%rip), %xmm0    # 0x9bff8
movaps %xmm0, %xmm1
popq %rbp
movaps %xmm1, %xmm0
retq