LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PathBezierQuadraticCurveTo(ImVec2 const&, ImVec2 const&, int)
void ImDrawList::PathBezierQuadraticCurveTo(const ImVec2& p2, const ImVec2& p3, int num_segments)
{
    ImVec2 p1 = _Path.back();
    if (num_segments == 0)
    {
        PathBezierQuadraticCurveToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, _Data->CurveTessellationTol, 0);// Auto-tessellated
    }
    else
    {
        float t_step = 1.0f / (float)num_segments;
        for (int i_step = 1; i_step <= num_segments; i_step++)
            _Path.push_back(ImBezierQuadraticCalc(p1, p2, p3, t_step * i_step));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x60c6c
movq (%rax), %rax
movq %rax, -0x40(%rbp)
testl %r13d, %r13d
je 0x63afc
cvtsi2ss %r13d, %xmm0
movss 0x3855c(%rip), %xmm1    # 0x9bff8
divss %xmm0, %xmm1
movss %xmm1, -0x2c(%rbp)
xorl %r12d, %r12d
testl %r13d, %r13d
cmovgl %r13d, %r12d
negl %r12d
pushq $0x1
popq %r13
leal (%r12,%r13), %eax
cmpl $0x1, %eax
je 0x63aed
cvtsi2ss %r13d, %xmm0
mulss -0x2c(%rbp), %xmm0
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x636ea
movlps %xmm0, -0x38(%rbp)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0x4c382
incl %r13d
jmp 0x63ab6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rcx
shrq $0x20, %rcx
movd %ecx, %xmm1
movd %eax, %xmm0
movss (%r15), %xmm2
movss 0x4(%r15), %xmm3
movss (%r14), %xmm4
movss 0x4(%r14), %xmm5
movq 0x38(%r12), %rax
movss 0x14(%rax), %xmm6
movq %rbx, %rdi
xorl %esi, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63b40
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: PathBezierQuadraticCurveToCasteljau(ImVector<ImVec2>*, float, float, float, float, float, float, float, int)
static void PathBezierQuadraticCurveToCasteljau(ImVector<ImVec2>* path, float x1, float y1, float x2, float y2, float x3, float y3, float tess_tol, int level)
{
    float dx = x3 - x1, dy = y3 - y1;
    float det = (x2 - x3) * dy - (y2 - y3) * dx;
    if (det * det * 4.0f < tess_tol * (dx * dx + dy * dy))
    {
        path->push_back(ImVec2(x3, y3));
    }
    else if (level < 10)
    {
        float x12 = (x1 + x2) * 0.5f, y12 = (y1 + y2) * 0.5f;
        float x23 = (x2 + x3) * 0.5f, y23 = (y2 + y3) * 0.5f;
        float x123 = (x12 + x23) * 0.5f, y123 = (y12 + y23) * 0.5f;
        PathBezierQuadraticCurveToCasteljau(path, x1, y1, x12, y12, x123, y123, tess_tol, level + 1);
        PathBezierQuadraticCurveToCasteljau(path, x123, y123, x23, y23, x3, y3, tess_tol, level + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movaps %xmm5, %xmm8
movaps %xmm4, %xmm7
movaps %xmm3, %xmm9
movaps %xmm2, %xmm10
movq %rdi, %r14
movss %xmm5, -0x1c(%rbp)
movss %xmm4, -0x18(%rbp)
movss %xmm6, -0x14(%rbp)
movaps %xmm7, %xmm2
subss %xmm0, %xmm2
movaps %xmm8, %xmm3
subss %xmm1, %xmm3
movaps %xmm10, %xmm4
subss %xmm7, %xmm4
movaps %xmm9, %xmm5
subss %xmm8, %xmm5
mulss %xmm2, %xmm5
mulss %xmm3, %xmm4
subss %xmm5, %xmm4
mulss %xmm4, %xmm4
mulss 0x38cea(%rip), %xmm4    # 0x9c890
mulss %xmm3, %xmm3
mulss %xmm2, %xmm2
addss %xmm3, %xmm2
mulss %xmm6, %xmm2
ucomiss %xmm4, %xmm2
ja 0x63c6b
cmpl $0x9, %ebx
jg 0x63c81
movaps %xmm0, %xmm2
addss %xmm10, %xmm2
movss 0x38440(%rip), %xmm4    # 0x9c018
mulss %xmm4, %xmm2
movaps %xmm1, %xmm3
addss %xmm9, %xmm3
mulss %xmm4, %xmm3
addss %xmm7, %xmm10
mulss %xmm4, %xmm10
movss %xmm10, -0x28(%rbp)
addss %xmm8, %xmm9
mulss %xmm4, %xmm9
movss %xmm9, -0x2c(%rbp)
movaps %xmm2, %xmm5
addss %xmm10, %xmm5
mulss %xmm4, %xmm5
movss %xmm5, -0x24(%rbp)
movaps %xmm3, %xmm10
addss %xmm9, %xmm10
mulss %xmm4, %xmm10
movss %xmm10, -0x20(%rbp)
incl %ebx
movq %r14, %rdi
movaps %xmm5, %xmm4
movaps %xmm10, %xmm5
movl %ebx, %esi
callq 0x63b40
movss -0x28(%rbp), %xmm10
movss -0x2c(%rbp), %xmm9
movss -0x14(%rbp), %xmm6
movss -0x18(%rbp), %xmm7
movss -0x1c(%rbp), %xmm8
movss -0x24(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
jmp 0x63b6e
leaq -0x34(%rbp), %rsi
movss %xmm7, (%rsi)
movss %xmm8, 0x4(%rsi)
movq %r14, %rdi
callq 0x4c382
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddLine(ImVec2 const&, ImVec2 const&, unsigned int, float)
void ImDrawList::AddLine(const ImVec2& p1, const ImVec2& p2, ImU32 col, float thickness)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
    PathLineTo(p1 + ImVec2(0.5f, 0.5f));
    PathLineTo(p2 + ImVec2(0.5f, 0.5f));
    PathStroke(col, false, thickness);
}

// Assembly:
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x63f6a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
movss 0x38129(%rip), %xmm2    # 0x9c018
movss %xmm0, -0x2c(%rbp)
movss (%rsi), %xmm0
addss %xmm2, %xmm0
movss 0x4(%rsi), %xmm1
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x38(%rbp), %r12
movlps %xmm0, (%r12)
leaq 0x78(%rdi), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x4c382
movss (%r15), %xmm0
movss 0x380eb(%rip), %xmm1    # 0x9c018
addss %xmm1, %xmm0
addss 0x4(%r15), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, (%r12)
leaq -0x38(%rbp), %rsi
movq %r13, %rdi
callq 0x4c382
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movss -0x2c(%rbp), %xmm0
callq 0x4c428
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddRect(ImVec2 const&, ImVec2 const&, unsigned int, float, int, float)
void ImDrawList::AddRect(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners, float thickness)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
    if (Flags & ImDrawListFlags_AntiAliasedLines)
        PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.50f, 0.50f), rounding, rounding_corners);
    else
        PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.49f, 0.49f), rounding, rounding_corners); // Better looking lower-right corner and rounded non-AA shapes.
    PathStroke(col, true, thickness);
}

// Assembly:
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x6401f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movq %rdi, %r14
movss %xmm1, -0x14(%rbp)
testb $0x1, 0x30(%rdi)
jne 0x63fbc
movss 0x3807d(%rip), %xmm1    # 0x9c018
movss (%rsi), %xmm2
addss %xmm1, %xmm2
addss 0x4(%rsi), %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x28(%rbp), %rsi
movlps %xmm2, (%rsi)
movss 0x49cce(%rip), %xmm1    # 0xadc88
jmp 0x63fe3
movss 0x38054(%rip), %xmm1    # 0x9c018
movss (%rsi), %xmm2
addss %xmm1, %xmm2
addss 0x4(%rsi), %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x28(%rbp), %rsi
movlps %xmm2, (%rsi)
movss 0x38911(%rip), %xmm1    # 0x9c8f4
movss (%rdx), %xmm2
addss %xmm1, %xmm2
addss 0x4(%rdx), %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x20(%rbp), %rdx
movlps %xmm2, (%rdx)
movq %r14, %rdi
movl %r8d, %ecx
callq 0x63c8a
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
movss -0x14(%rbp), %xmm0
callq 0x4c428
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRectFilled(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;
    if (rounding > 0.0f)
    {
        PathRect(p_min, p_max, rounding, rounding_corners);
        PathFillConvex(col);
    }
    else
    {
        PrimReserve(6, 4);
        PrimRect(p_min, p_max, col);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1000000, %ecx        # imm = 0x1000000
jae 0x6403c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x64072
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0x63c8a
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4c35c
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x623b8
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x62486
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilledMultiColor(ImVec2 const&, ImVec2 const&, unsigned int, unsigned int, unsigned int, unsigned int)
void ImDrawList::AddRectFilledMultiColor(const ImVec2& p_min, const ImVec2& p_max, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
{
    if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) & IM_COL32_A_MASK) == 0)
        return;

    const ImVec2 uv = _Data->TexUvWhitePixel;
    PrimReserve(6, 4);
    PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 1)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 2));
    PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 2)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx + 3));
    PrimWriteVtx(p_min, uv, col_upr_left);
    PrimWriteVtx(ImVec2(p_max.x, p_min.y), uv, col_upr_right);
    PrimWriteVtx(p_max, uv, col_bot_right);
    PrimWriteVtx(ImVec2(p_min.x, p_max.y), uv, col_bot_left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %eax
orl %ecx, %eax
orl %r9d, %eax
orl 0x10(%rbp), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x641a4
movl %r9d, %r15d
movl %r8d, %r13d
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rcx
movq %rax, (%rcx)
pushq $0x6
popq %rsi
movq %rdx, -0x38(%rbp)
pushq $0x4
popq %rdx
callq 0x623b8
movl 0x34(%rbx), %eax
movq 0x50(%rbx), %rcx
movw %ax, (%rcx)
leal 0x1(%rax), %edx
movw %dx, 0x2(%rcx)
leal 0x2(%rax), %edx
movw %dx, 0x4(%rcx)
movw %ax, 0x6(%rcx)
movw %dx, 0x8(%rcx)
addl $0x3, %eax
movw %ax, 0xa(%rcx)
addq $0xc, %rcx
movq %rcx, 0x50(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x30(%rbp), %rdx
movl %r14d, %ecx
callq 0x6f434
movq -0x38(%rbp), %rsi
movl (%rsi), %eax
movl 0x4(%r12), %ecx
movq 0x48(%rbx), %rdx
movl %eax, (%rdx)
movl %ecx, 0x4(%rdx)
movq 0x48(%rbx), %rax
leaq -0x30(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x48(%rbx), %rax
movl %r13d, 0x10(%rax)
addq $0x14, %rax
movq %rax, 0x48(%rbx)
incl 0x34(%rbx)
movq %rbx, %rdi
movq %rsi, %r13
movq %rdx, %r14
movl %r15d, %ecx
callq 0x6f434
movl (%r12), %eax
movl 0x4(%r13), %ecx
movq 0x48(%rbx), %rdx
movl %eax, (%rdx)
movl %ecx, 0x4(%rdx)
movq 0x48(%rbx), %rax
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq 0x48(%rbx), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x14, %rax
movq %rax, 0x48(%rbx)
incl 0x34(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddQuad(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float)
void ImDrawList::AddQuad(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    PathLineTo(p1);
    PathLineTo(p2);
    PathLineTo(p3);
    PathLineTo(p4);
    PathStroke(col, true, thickness);
}

// Assembly:
cmpl $0x1000000, %r9d        # imm = 0x1000000
jae 0x641be
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
leaq 0x78(%rdi), %r15
movq %r15, %rdi
movss %xmm0, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
callq 0x4c382
movq %r15, %rdi
movq %r13, %rsi
callq 0x4c382
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c382
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x4c382
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
movss -0x2c(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c428
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircle(ImVec2 const&, float, unsigned int, int, float)
void ImDrawList::AddCircle(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness)
{
    if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f)
        return;

    // Obtain segment count
    if (num_segments <= 0)
    {
        // Automatic segment count
        const int radius_idx = (int)radius;
        if (radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts))
            num_segments = _Data->CircleSegmentCounts[radius_idx]; // Use cached value
        else
            num_segments = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError);
    }
    else
    {
        // Explicit segment count (still clamp to avoid drawing insanely tessellated shapes)
        num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX);
    }

    // Because we are filling a closed shape we remove 1 from the count of segments/points
    const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
    if (num_segments == 12)
        PathArcToFast(center, radius - 0.5f, 0, 12 - 1);
    else
        PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1);
    PathStroke(col, true, thickness);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movaps %xmm0, %xmm3
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
setae %dl
orb %al, %dl
je 0x6439a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rdi, %r14
testl %ecx, %ecx
movss %xmm1, -0x20(%rbp)
jle 0x643bd
movl $0x200, %edx            # imm = 0x200
cmpl %edx, %ecx
cmovbl %ecx, %edx
cmpl $0x3, %ecx
jae 0x64411
pushq $0x3
popq %rdx
jmp 0x64433
cvttss2si %xmm3, %ecx
movq 0x38(%r14), %rax
cmpl $0x3f, %ecx
jg 0x643d7
movslq %ecx, %rcx
movzbl 0x90(%rax,%rcx), %edx
jmp 0x64411
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, -0x1c(%rbp)
callq 0xc4f0
movss -0x1c(%rbp), %xmm3
movss 0x4988a(%rip), %xmm1    # 0xadc84
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0x200, %edx            # imm = 0x200
cmpl %edx, %eax
cmovbl %eax, %edx
cmpl $0xc, %eax
jl 0x64416
cmpl $0xc, %edx
jne 0x64433
addss 0x384d6(%rip), %xmm3    # 0x9c8f4
pushq $0xb
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
callq 0x63484
jmp 0x6446a
cvtsi2ss %edx, %xmm0
movss 0x37bb1(%rip), %xmm2    # 0x9bff0
addss %xmm0, %xmm2
mulss 0x49839(%rip), %xmm2    # 0xadc84
divss %xmm0, %xmm2
addss 0x3849d(%rip), %xmm3    # 0x9c8f4
decl %edx
xorps %xmm1, %xmm1
movq %r14, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
callq 0x63550
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
movss -0x20(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c428
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircleFilled(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircleFilled(const ImVec2& center, float radius, ImU32 col, int num_segments)
{
    if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f)
        return;

    // Obtain segment count
    if (num_segments <= 0)
    {
        // Automatic segment count
        const int radius_idx = (int)radius;
        if (radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts))
            num_segments = _Data->CircleSegmentCounts[radius_idx]; // Use cached value
        else
            num_segments = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError);
    }
    else
    {
        // Explicit segment count (still clamp to avoid drawing insanely tessellated shapes)
        num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX);
    }

    // Because we are filling a closed shape we remove 1 from the count of segments/points
    const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
    if (num_segments == 12)
        PathArcToFast(center, radius, 0, 12 - 1);
    else
        PathArcTo(center, radius, 0.0f, a_max, num_segments - 1);
    PathFillConvex(col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movaps %xmm0, %xmm3
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
setae %dl
orb %al, %dl
je 0x644b6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rdi, %r14
testl %ecx, %ecx
jle 0x644d4
movl $0x200, %edx            # imm = 0x200
cmpl %edx, %ecx
cmovbl %ecx, %edx
cmpl $0x3, %ecx
jae 0x64528
pushq $0x3
popq %rdx
jmp 0x64542
cvttss2si %xmm3, %ecx
movq 0x38(%r14), %rax
cmpl $0x3f, %ecx
jg 0x644ee
movslq %ecx, %rcx
movzbl 0x90(%rax,%rcx), %edx
jmp 0x64528
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, -0x1c(%rbp)
callq 0xc4f0
movss -0x1c(%rbp), %xmm3
movss 0x49773(%rip), %xmm1    # 0xadc84
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0x200, %edx            # imm = 0x200
cmpl %edx, %eax
cmovbl %eax, %edx
cmpl $0xc, %eax
jl 0x6452d
cmpl $0xc, %edx
jne 0x64542
pushq $0xb
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
callq 0x63484
jmp 0x64571
cvtsi2ss %edx, %xmm0
movss 0x37aa2(%rip), %xmm2    # 0x9bff0
addss %xmm0, %xmm2
mulss 0x4972a(%rip), %xmm2    # 0xadc84
divss %xmm0, %xmm2
decl %edx
xorps %xmm1, %xmm1
movq %r14, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
callq 0x63550
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4c35c
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddNgon(ImVec2 const&, float, unsigned int, int, float)
void ImDrawList::AddNgon(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness)
{
    if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2)
        return;

    // Because we are filling a closed shape we remove 1 from the count of segments/points
    const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
    PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1);
    PathStroke(col, true, thickness);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
cmpl $0x3, %ecx
setl %dl
orb %al, %dl
je 0x645af
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
movss %xmm1, -0x14(%rbp)
cvtsi2ss %ecx, %xmm1
movss 0x37a2d(%rip), %xmm2    # 0x9bff0
addss %xmm1, %xmm2
mulss 0x496b5(%rip), %xmm2    # 0xadc84
divss %xmm1, %xmm2
addss 0x38319(%rip), %xmm0    # 0x9c8f4
decl %ecx
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x63550
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
movss -0x14(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4c428
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddNgonFilled(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddNgonFilled(const ImVec2& center, float radius, ImU32 col, int num_segments)
{
    if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2)
        return;

    // Because we are filling a closed shape we remove 1 from the count of segments/points
    const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
    PathArcTo(center, radius, 0.0f, a_max, num_segments - 1);
    PathFillConvex(col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
cmpl $0x3, %ecx
setl %dl
orb %al, %dl
je 0x64623
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
cvtsi2ss %ecx, %xmm1
movss 0x379be(%rip), %xmm2    # 0x9bff0
addss %xmm1, %xmm2
mulss 0x49646(%rip), %xmm2    # 0xadc84
divss %xmm1, %xmm2
decl %ecx
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x63550
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4c35c
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierCubic(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierCubic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness, int num_segments)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    PathLineTo(p1);
    PathBezierCubicCurveTo(p2, p3, p4, num_segments);
    PathStroke(col, false, thickness);
}

// Assembly:
cmpl $0x1000000, %r9d        # imm = 0x1000000
jae 0x64666
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
movl 0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x78, %rdi
movss %xmm0, -0x30(%rbp)
callq 0x4c382
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl -0x2c(%rbp), %r8d
callq 0x6374c
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movss -0x30(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c428
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierQuadratic(ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierQuadratic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness, int num_segments)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    PathLineTo(p1);
    PathBezierQuadraticCurveTo(p2, p3, num_segments);
    PathStroke(col, false, thickness);
}

// Assembly:
cmpl $0x1000000, %r8d        # imm = 0x1000000
jae 0x646d6
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %ebx
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
addq $0x78, %rdi
movss %xmm0, -0x2c(%rbp)
callq 0x4c382
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x63a5a
movq %r15, %rdi
movl %ebx, %esi
xorl %edx, %edx
movss -0x2c(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c428
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddImage(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
    if (push_texture_id)
        PushTextureID(user_texture_id);

    PrimReserve(6, 4);
    PrimRectUV(p_min, p_max, uv_min, uv_max, col);

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x10(%rbp), %r15d
cmpl $0x1000000, %r15d       # imm = 0x1000000
jae 0x64f0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movq %r9, -0x30(%rbp)
cmpq %rsi, 0x98(%rdi)
je 0x64f69
movq %r12, %rdi
callq 0x6233e
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x623b8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
callq 0x62546
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6237a
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x623b8
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62546
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddImageQuad(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddImageQuad(ImTextureID user_texture_id, const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, const ImVec2& uv1, const ImVec2& uv2, const ImVec2& uv3, const ImVec2& uv4, ImU32 col)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    const bool push_texture_id = user_texture_id != _CmdHeader.TextureId;
    if (push_texture_id)
        PushTextureID(user_texture_id);

    PrimReserve(6, 4);
    PrimQuadUV(p1, p2, p3, p4, uv1, uv2, uv3, uv4, col);

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x30(%rbp), %r14d
cmpl $0x1000000, %r14d       # imm = 0x1000000
jae 0x64fc5
addq $0x28, %rsp
jmp 0x65088
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movq %r9, -0x50(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rsi, 0x98(%rdi)
je 0x65052
movq %rbx, %rdi
callq 0x6233e
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x623b8
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq -0x50(%rbp), %r8
movq -0x30(%rbp), %r9
pushq %r14
pushq -0x38(%rbp)
pushq -0x40(%rbp)
pushq -0x48(%rbp)
callq 0x62638
addq $0x20, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6237a
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x623b8
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq -0x50(%rbp), %r8
movq -0x30(%rbp), %r9
pushq %r14
pushq -0x38(%rbp)
pushq -0x40(%rbp)
pushq -0x48(%rbp)
callq 0x62638
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddImageRounded(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddImageRounded(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    if (rounding <= 0.0f || (rounding_corners & ImDrawCornerFlags_All) == 0)
    {
        AddImage(user_texture_id, p_min, p_max, uv_min, uv_max, col);
        return;
    }

    const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back();
    if (push_texture_id)
        PushTextureID(user_texture_id);

    int vert_start_idx = VtxBuffer.Size;
    PathRect(p_min, p_max, rounding, rounding_corners);
    PathFillConvex(col);
    int vert_end_idx = VtxBuffer.Size;
    ImGui::ShadeVertsLinearUV(this, vert_start_idx, vert_end_idx, p_min, p_max, uv_min, uv_max, true);

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x10(%rbp), %ebx
cmpl $0x1000000, %ebx        # imm = 0x1000000
jb 0x650e6
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl 0x18(%rbp), %r14d
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
setb %al
testb $0xf, %r14b
setne %dl
testb %dl, %al
jne 0x650f5
subq $0x8, %rsp
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
pushq %rbx
callq 0x64ee2
popq %rax
popq %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movss %xmm0, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
cmpl $0x0, 0x68(%r12)
je 0x6511d
leaq 0x68(%r12), %rdi
callq 0x6f462
cmpq %r15, (%rax)
je 0x6518b
movq %r12, %rdi
movq %r15, %rsi
callq 0x6233e
movl 0x20(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %r15
movq %r15, %rdx
movss -0x30(%rbp), %xmm0
movl %r14d, %ecx
callq 0x63c8a
movq %r12, %rdi
movl %ebx, %esi
callq 0x4c35c
movl 0x20(%r12), %edx
movq %r12, %rdi
movl -0x2c(%rbp), %esi
movq %r13, %rcx
movq %r15, %r8
movq -0x40(%rbp), %r9
pushq $0x1
pushq -0x48(%rbp)
callq 0x651db
popq %rax
popq %rcx
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6237a
movl 0x20(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %r15
movq %r15, %rdx
movss -0x30(%rbp), %xmm0
movl %r14d, %ecx
callq 0x63c8a
movq %r12, %rdi
movl %ebx, %esi
callq 0x4c35c
movl 0x20(%r12), %edx
movq %r12, %rdi
movl -0x2c(%rbp), %esi
movq %r13, %rcx
movq %r15, %r8
movq -0x40(%rbp), %r9
pushq $0x1
pushq -0x48(%rbp)
callq 0x651db
jmp 0x650e4
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImGui::ShadeVertsLinearUV(ImDrawList*, int, int, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, bool)
void ImGui::ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp)
{
    const ImVec2 size = b - a;
    const ImVec2 uv_size = uv_b - uv_a;
    const ImVec2 scale = ImVec2(
        size.x != 0.0f ? (uv_size.x / size.x) : 0.0f,
        size.y != 0.0f ? (uv_size.y / size.y) : 0.0f);

    ImDrawVert* vert_start = draw_list->VtxBuffer.Data + vert_start_idx;
    ImDrawVert* vert_end = draw_list->VtxBuffer.Data + vert_end_idx;
    if (clamp)
    {
        const ImVec2 min = ImMin(uv_a, uv_b);
        const ImVec2 max = ImMax(uv_a, uv_b);
        for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
            vertex->uv = ImClamp(uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale), min, max);
    }
    else
    {
        for (ImDrawVert* vertex = vert_start; vertex < vert_end; ++vertex)
            vertex->uv = uv_a + ImMul(ImVec2(vertex->pos.x, vertex->pos.y) - a, scale);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movss (%r8), %xmm0
movss 0x4(%r8), %xmm1
subss (%rcx), %xmm0
subss 0x4(%rcx), %xmm1
movss (%rax), %xmm5
movss 0x4(%rax), %xmm6
movss (%r9), %xmm8
movss 0x4(%r9), %xmm7
movaps %xmm5, %xmm2
subss %xmm8, %xmm2
movaps %xmm6, %xmm3
subss %xmm7, %xmm3
divss %xmm0, %xmm2
xorps %xmm4, %xmm4
cmpneqss %xmm4, %xmm0
andps %xmm2, %xmm0
divss %xmm1, %xmm3
cmpneqss %xmm4, %xmm1
andps %xmm3, %xmm1
movq 0x28(%rdi), %rdi
movslq %esi, %rax
imulq $0x14, %rax, %rax
addq %rdi, %rax
movslq %edx, %rdx
imulq $0x14, %rdx, %rdx
addq %rdi, %rdx
cmpb $0x0, 0x18(%rbp)
je 0x65300
movaps %xmm8, %xmm2
minss %xmm5, %xmm2
movaps %xmm7, %xmm3
minss %xmm6, %xmm3
movaps %xmm5, %xmm4
cmpless %xmm8, %xmm4
andps %xmm4, %xmm8
andnps %xmm5, %xmm4
orps %xmm8, %xmm4
movaps %xmm6, %xmm5
cmpless %xmm7, %xmm5
andps %xmm5, %xmm7
andnps %xmm6, %xmm5
orps %xmm7, %xmm5
cmpq %rdx, %rax
jae 0x65337
movss (%rax), %xmm6
movss 0x4(%rax), %xmm7
subss (%rcx), %xmm6
subss 0x4(%rcx), %xmm7
mulss %xmm0, %xmm6
addss (%r9), %xmm6
mulss %xmm1, %xmm7
addss 0x4(%r9), %xmm7
movaps %xmm5, %xmm8
minss %xmm7, %xmm8
cmpltss %xmm3, %xmm7
movaps %xmm7, %xmm9
andnps %xmm8, %xmm9
andps %xmm3, %xmm7
orps %xmm9, %xmm7
movaps %xmm4, %xmm8
minss %xmm6, %xmm8
cmpltss %xmm2, %xmm6
movaps %xmm6, %xmm9
andnps %xmm8, %xmm9
andps %xmm2, %xmm6
orps %xmm9, %xmm6
unpcklps %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1]
movlps %xmm6, 0x8(%rax)
addq $0x14, %rax
jmp 0x6528b
cmpq %rdx, %rax
jae 0x65337
movss (%rax), %xmm2
movss 0x4(%rax), %xmm3
subss (%rcx), %xmm2
subss 0x4(%rcx), %xmm3
mulss %xmm0, %xmm2
mulss %xmm1, %xmm3
addss (%r9), %xmm2
addss 0x4(%r9), %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movlps %xmm2, 0x8(%rax)
addq $0x14, %rax
jmp 0x65300
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSplitter::Split(ImDrawList*, int)
void ImDrawListSplitter::Split(ImDrawList* draw_list, int channels_count)
{
    IM_UNUSED(draw_list);
    IM_ASSERT(_Current == 0 && _Count <= 1 && "Nested channel splitting is not supported. Please use separate instances of ImDrawListSplitter.");
    int old_channels_count = _Channels.Size;
    if (old_channels_count < channels_count)
    {
        _Channels.reserve(channels_count); // Avoid over reserving since this is likely to stay stable
        _Channels.resize(channels_count);
    }
    _Count = channels_count;

    // Channels[] (24/32 bytes each) hold storage that we'll swap with draw_list->_CmdBuffer/_IdxBuffer
    // The content of Channels[0] at this point doesn't matter. We clear it to make state tidy in a debugger but we don't strictly need to.
    // When we switch to the next channel, we'll copy draw_list->_CmdBuffer/_IdxBuffer into Channels[0] and then Channels[1] into draw_list->CmdBuffer/_IdxBuffer
    memset(&_Channels[0], 0, sizeof(ImDrawChannel));
    for (int i = 1; i < channels_count; i++)
    {
        if (i >= old_channels_count)
        {
            IM_PLACEMENT_NEW(&_Channels[i]) ImDrawChannel();
        }
        else
        {
            _Channels[i]._CmdBuffer.resize(0);
            _Channels[i]._IdxBuffer.resize(0);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, (%rdi)
jne 0x653e9
movq %rdi, %r15
cmpl $0x2, 0x4(%rdi)
jge 0x653e9
movl %edx, %ebx
leaq 0x8(%r15), %r14
movl 0x8(%r15), %r12d
cmpl %edx, %r12d
jge 0x6537e
movq %r14, %rdi
movl %ebx, %esi
callq 0x6f4d0
movq %r14, %rdi
movl %ebx, %esi
callq 0x6f528
movl %ebx, 0x4(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x6f49a
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
pushq $0x1
popq %r15
cmpl %ebx, %r15d
jge 0x653e0
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f49a
cmpl %r12d, %r15d
jge 0x653d1
movq %rax, %rdi
xorl %esi, %esi
callq 0x6f004
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f49a
leaq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x49a10
jmp 0x653db
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
incl %r15d
jmp 0x6539a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f299(%rip), %rdi     # 0xb4689
leaq 0x4f0df(%rip), %rsi     # 0xb44d6
leaq 0x4f30d(%rip), %rcx     # 0xb470b
movl $0x5d5, %edx            # imm = 0x5D5
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSplitter::SetCurrentChannel(ImDrawList*, int)
void ImDrawListSplitter::SetCurrentChannel(ImDrawList* draw_list, int idx)
{
    IM_ASSERT(idx >= 0 && idx < _Count);
    if (_Current == idx)
        return;

    // Overwrite ImVector (12/16 bytes), four times. This is merely a silly optimization instead of doing .swap()
    memcpy(&_Channels.Data[_Current]._CmdBuffer, &draw_list->CmdBuffer, sizeof(draw_list->CmdBuffer));
    memcpy(&_Channels.Data[_Current]._IdxBuffer, &draw_list->IdxBuffer, sizeof(draw_list->IdxBuffer));
    _Current = idx;
    memcpy(&draw_list->CmdBuffer, &_Channels.Data[idx]._CmdBuffer, sizeof(draw_list->CmdBuffer));
    memcpy(&draw_list->IdxBuffer, &_Channels.Data[idx]._IdxBuffer, sizeof(draw_list->IdxBuffer));
    draw_list->_IdxWritePtr = draw_list->IdxBuffer.Data + draw_list->IdxBuffer.Size;

    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = (draw_list->CmdBuffer.Size == 0) ? NULL : &draw_list->CmdBuffer.Data[draw_list->CmdBuffer.Size - 1];
    if (curr_cmd == NULL)
        draw_list->AddDrawCmd();
    else if (curr_cmd->ElemCount == 0)
        ImDrawCmd_HeaderCopy(curr_cmd, &draw_list->_CmdHeader); // Copy ClipRect, TextureId, VtxOffset
    else if (ImDrawCmd_HeaderCompare(curr_cmd, &draw_list->_CmdHeader) != 0)
        draw_list->AddDrawCmd();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x65793
cmpl %edx, 0x4(%rdi)
jle 0x65793
movslq (%rdi), %rax
cmpl %edx, %eax
jne 0x656e7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rbx
movq 0x10(%rdi), %rcx
shlq $0x5, %rax
movups (%rsi), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0x10(%rdi), %rax
movslq (%rdi), %rcx
shlq $0x5, %rcx
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
movl %edx, (%rdi)
movq 0x10(%rdi), %rax
movl %edx, %ecx
shlq $0x5, %rcx
movups (%rax,%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x10(%rdi), %rax
movups 0x10(%rax,%rcx), %xmm0
movups %xmm0, 0x10(%rsi)
movslq 0x10(%rsi), %rax
addq %rax, %rax
addq 0x18(%rsi), %rax
movq %rax, 0x50(%rsi)
movslq (%rsi), %rax
testq %rax, %rax
je 0x65772
imulq $0x38, %rax, %rax
addq 0x8(%rbx), %rax
movq %rax, %rdi
addq $-0x38, %rdi
je 0x65772
leaq 0x88(%rbx), %rsi
cmpl $0x0, -0x18(%rax)
je 0x65780
pushq $0x1c
popq %rdx
callq 0xc5f0
testl %eax, %eax
je 0x656e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x61f16
movups (%rsi), %xmm0
movups 0xc(%rsi), %xmm1
movups %xmm1, 0xc(%rdi)
movups %xmm0, (%rdi)
jmp 0x656e0
leaq 0x4efa3(%rip), %rdi     # 0xb473d
leaq 0x4ed35(%rip), %rsi     # 0xb44d6
leaq 0x4efae(%rip), %rcx     # 0xb4756
movl $0x639, %edx            # imm = 0x639
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawData::DeIndexAllBuffers()
void ImDrawData::DeIndexAllBuffers()
{
    ImVector<ImDrawVert> new_vtx_buffer;
    TotalVtxCount = TotalIdxCount = 0;
    for (int i = 0; i < CmdListsCount; i++)
    {
        ImDrawList* cmd_list = CmdLists[i];
        if (cmd_list->IdxBuffer.empty())
            continue;
        new_vtx_buffer.resize(cmd_list->IdxBuffer.Size);
        for (int j = 0; j < cmd_list->IdxBuffer.Size; j++)
            new_vtx_buffer[j] = cmd_list->VtxBuffer[cmd_list->IdxBuffer[j]];
        cmd_list->VtxBuffer.swap(new_vtx_buffer);
        cmd_list->IdxBuffer.resize(0);
        TotalVtxCount += cmd_list->VtxBuffer.Size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x14(%rdi)
xorl %ecx, %ecx
movq %rdi, -0x48(%rbp)
movslq 0x10(%rdi), %rax
cmpq %rax, %rcx
jge 0x6589b
movq 0x8(%rdi), %rax
movq (%rax,%rcx,8), %rbx
movl 0x10(%rbx), %esi
testl %esi, %esi
je 0x65893
movq %rcx, -0x58(%rbp)
movq %r14, %rdi
callq 0x6f042
leaq 0x10(%rbx), %r12
movq %rbx, -0x50(%rbp)
leaq 0x20(%rbx), %r15
xorl %r13d, %r13d
cmpl (%r12), %r13d
jge 0x6584f
movq %r12, %rdi
movl %r13d, %esi
callq 0x5f790
movzwl (%rax), %esi
movq %r15, %rdi
callq 0x6f5e0
movq %rax, %rbx
movq %r14, %rdi
movl %r13d, %esi
callq 0x6f5e0
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%rax)
incl %r13d
jmp 0x65814
movl -0x40(%rbp), %eax
movq -0x50(%rbp), %rdx
movl 0x20(%rdx), %ecx
movl %ecx, -0x40(%rbp)
movl %eax, 0x20(%rdx)
movl -0x3c(%rbp), %eax
movl 0x24(%rdx), %ecx
movl %ecx, -0x3c(%rbp)
movl %eax, 0x24(%rdx)
movq -0x38(%rbp), %rax
movq 0x28(%rdx), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, 0x28(%rdx)
movq %r12, %rdi
xorl %esi, %esi
callq 0x49a10
movl (%r15), %eax
movq -0x48(%rbp), %rdi
addl %eax, 0x18(%rdi)
movq -0x58(%rbp), %rcx
incq %rcx
jmp 0x657d9
leaq -0x40(%rbp), %rdi
callq 0x4bd4e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4bd4e
movq %rbx, %rdi
callq 0xc580
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawData::ScaleClipRects(ImVec2 const&)
void ImDrawData::ScaleClipRects(const ImVec2& fb_scale)
{
    for (int i = 0; i < CmdListsCount; i++)
    {
        ImDrawList* cmd_list = CmdLists[i];
        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            ImDrawCmd* cmd = &cmd_list->CmdBuffer[cmd_i];
            cmd->ClipRect = ImVec4(cmd->ClipRect.x * fb_scale.x, cmd->ClipRect.y * fb_scale.y, cmd->ClipRect.z * fb_scale.x, cmd->ClipRect.w * fb_scale.y);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jge 0x65944
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %r15
xorl %r12d, %r12d
cmpl (%r15), %r12d
jge 0x6593f
movq %r15, %rdi
movl %r12d, %esi
callq 0x4b5b8
movss (%rbx), %xmm0
movss 0x4(%rbx), %xmm1
movss (%rax), %xmm2
mulss %xmm0, %xmm2
movss 0x4(%rax), %xmm3
mulss 0x8(%rax), %xmm0
mulss %xmm1, %xmm3
mulss 0xc(%rax), %xmm1
movss %xmm2, (%rax)
movss %xmm3, 0x4(%rax)
movss %xmm0, 0x8(%rax)
movss %xmm1, 0xc(%rax)
incl %r12d
jmp 0x658f3
incq %r13
jmp 0x658df
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_draw.cpp
// Function: ImFontConfig::ImFontConfig()
ImFontConfig::ImFontConfig()
{
    FontData = NULL;
    FontDataSize = 0;
    FontDataOwnedByAtlas = true;
    FontNo = 0;
    SizePixels = 0.0f;
    OversampleH = 3; // FIXME: 2 may be a better default?
    OversampleV = 1;
    PixelSnapH = false;
    GlyphExtraSpacing = ImVec2(0.0f, 0.0f);
    GlyphOffset = ImVec2(0.0f, 0.0f);
    GlyphRanges = NULL;
    GlyphMinAdvanceX = 0.0f;
    GlyphMaxAdvanceX = FLT_MAX;
    MergeMode = false;
    RasterizerFlags = 0x00;
    RasterizerMultiply = 1.0f;
    EllipsisChar = (ImWchar)-1;
    memset(Name, 0, sizeof(Name));
    DstFont = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, (%rdi)
andl $0x0, 0x8(%rdi)
movb $0x1, 0xc(%rdi)
movaps 0x481ad(%rip), %xmm0    # 0xadc60
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
andq $0x0, 0x38(%rdi)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movb %al, 0x48(%rdi)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, 0x4c(%rdi)
orw $-0x1, 0x54(%rdi)
movups %xmm0, 0x56(%rdi)
andq $0x0, 0x76(%rdi)
movups %xmm0, 0x66(%rdi)
andq $0x0, 0x80(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::ImFontAtlas()
ImFontAtlas::ImFontAtlas()
{
    Locked = false;
    Flags = ImFontAtlasFlags_None;
    TexID = (ImTextureID)NULL;
    TexDesiredWidth = 0;
    TexGlyphPadding = 1;

    TexPixelsAlpha8 = NULL;
    TexPixelsRGBA32 = NULL;
    TexWidth = TexHeight = 0;
    TexUvScale = ImVec2(0.0f, 0.0f);
    TexUvWhitePixel = ImVec2(0.0f, 0.0f);
    PackIdMouseCursors = PackIdLines = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
addq $0x40, %rdi
movl $0x430, %edx            # imm = 0x430
xorl %esi, %esi
callq 0xc270
movl $0x1, 0x14(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
andq $0x0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
orq $-0x1, 0x470(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearInputData()
void    ImFontAtlas::ClearInputData()
{
    IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
    for (int i = 0; i < ConfigData.Size; i++)
        if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas)
        {
            IM_FREE(ConfigData[i].FontData);
            ConfigData[i].FontData = NULL;
        }

    // When clearing this we lose access to the font name and other information used to build the font.
    for (int i = 0; i < Fonts.Size; i++)
        if (Fonts[i]->ConfigData >= ConfigData.Data && Fonts[i]->ConfigData < ConfigData.Data + ConfigData.Size)
        {
            Fonts[i]->ConfigData = NULL;
            Fonts[i]->ConfigDataCount = 0;
        }
    ConfigData.clear();
    CustomRects.clear();
    PackIdMouseCursors = PackIdLines = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, (%rdi)
jne 0x65cd0
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x65c3c
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f64e
cmpq $0x0, (%rax)
je 0x65c37
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f64e
cmpb $0x1, 0xc(%rax)
jne 0x65c37
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f64e
movq (%rax), %rdi
callq 0x344ad
movq %r14, %rdi
movl %r15d, %esi
callq 0x6f64e
andq $0x0, (%rax)
incl %r15d
jmp 0x65bee
leaq 0x40(%rbx), %r15
xorl %r12d, %r12d
cmpl (%r15), %r12d
jge 0x65cae
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c056
movq (%rax), %rax
movq 0x48(%rax), %rax
cmpq 0x68(%rbx), %rax
jb 0x65ca9
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c056
movq (%rax), %rax
movslq 0x60(%rbx), %rcx
imulq $0x88, %rcx, %rcx
addq 0x68(%rbx), %rcx
cmpq %rcx, 0x48(%rax)
jae 0x65ca9
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c056
movq (%rax), %rax
andq $0x0, 0x48(%rax)
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c056
movq (%rax), %rax
andw $0x0, 0x50(%rax)
incl %r12d
jmp 0x65c43
movq %r14, %rdi
callq 0x6f688
leaq 0x50(%rbx), %rdi
callq 0x6f6b0
orq $-0x1, 0x470(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4eabd(%rip), %rdi     # 0xb4794
leaq 0x4e7f8(%rip), %rsi     # 0xb44d6
leaq 0x4eb25(%rip), %rcx     # 0xb480a
movl $0x712, %edx            # imm = 0x712
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearTexData()
void    ImFontAtlas::ClearTexData()
{
    IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
    if (TexPixelsAlpha8)
        IM_FREE(TexPixelsAlpha8);
    if (TexPixelsRGBA32)
        IM_FREE(TexPixelsRGBA32);
    TexPixelsAlpha8 = NULL;
    TexPixelsRGBA32 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
je 0x65d2b
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x65d0c
callq 0x344ad
movq 0x20(%rbx), %rdi
addq $0x18, %rbx
testq %rdi, %rdi
je 0x65d1e
callq 0x344ad
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4ea62(%rip), %rdi     # 0xb4794
leaq 0x4e79d(%rip), %rsi     # 0xb44d6
leaq 0x4eaed(%rip), %rcx     # 0xb482d
movl $0x728, %edx            # imm = 0x728
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearFonts()
void    ImFontAtlas::ClearFonts()
{
    IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
    for (int i = 0; i < Fonts.Size; i++)
        IM_DELETE(Fonts[i]);
    Fonts.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x0, (%rdi)
jne 0x65d89
movq %rdi, %rbx
addq $0x40, %rbx
xorl %r14d, %r14d
cmpl (%rbx), %r14d
jge 0x65d7d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4c056
movq (%rax), %rdi
callq 0x6f6d7
incl %r14d
jmp 0x65d60
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4affc
leaq 0x4ea04(%rip), %rdi     # 0xb4794
leaq 0x4e73f(%rip), %rsi     # 0xb44d6
leaq 0x4eab0(%rip), %rcx     # 0xb484e
movl $0x733, %edx            # imm = 0x733
callq 0xc140