LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_ClearFreeMemory()
void ImDrawList::_ClearFreeMemory()
{
    CmdBuffer.clear();
    IdxBuffer.clear();
    VtxBuffer.clear();
    Flags = ImDrawListFlags_None;
    _VtxCurrentIdx = 0;
    _VtxWritePtr = NULL;
    _IdxWritePtr = NULL;
    _ClipRectStack.clear();
    _TextureIdStack.clear();
    _Path.clear();
    _Splitter.ClearFreeMemory();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x75414
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x41d3c
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x7542d
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
callq 0x41d3c
movq %r14, 0x18(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x75446
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
callq 0x41d3c
movq %r14, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x7546e
xorl %r14d, %r14d
movq %r14, 0x58(%rbx)
callq 0x41d3c
movq %r14, 0x60(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x75487
xorl %r14d, %r14d
movq %r14, 0x68(%rbx)
callq 0x41d3c
movq %r14, 0x70(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x754a6
xorl %r14d, %r14d
movq %r14, 0x78(%rbx)
callq 0x41d3c
movq %r14, 0x80(%rbx)
addq $0xa8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x754ba
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSplitter::ClearFreeMemory()
void ImDrawListSplitter::ClearFreeMemory()
{
    for (int i = 0; i < _Channels.Size; i++)
    {
        if (i == _Current)
            memset(&_Channels[i], 0, sizeof(_Channels[i]));  // Current channel is a copy of CmdBuffer/IdxBuffer, don't destruct again
        _Channels[i]._CmdBuffer.clear();
        _Channels[i]._IdxBuffer.clear();
    }
    _Current = 0;
    _Count = 1;
    _Channels.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x7555e
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rbx), %ecx
cmpq %rcx, %r12
jne 0x754fb
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
movl 0x8(%rbx), %eax
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x75593
movq 0x10(%rbx), %r13
movq 0x8(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x7552a
movq %r14, (%r13,%r15)
callq 0x41d3c
movq %r14, 0x8(%r13,%r15)
movl 0x8(%rbx), %eax
movslq %eax, %rcx
cmpq %r12, %rcx
jle 0x75593
movq 0x10(%rbx), %r13
movq 0x18(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x75552
movq %r14, 0x10(%r13,%r15)
callq 0x41d3c
movq %r14, 0x18(%r13,%r15)
movl 0x8(%rbx), %eax
movslq %eax, %rcx
incq %r12
addq $0x20, %r15
cmpq %rcx, %r12
jl 0x754df
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x75584
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
callq 0x41d3c
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x440de(%rip), %rdi     # 0xb9678
leaq 0x440ea(%rip), %rsi     # 0xb968b
leaq 0x59573(%rip), %rcx     # 0xceb1b
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::CloneOutput() const
ImDrawList* ImDrawList::CloneOutput() const
{
    ImDrawList* dst = IM_NEW(ImDrawList(_Data));
    dst->CmdBuffer = CmdBuffer;
    dst->IdxBuffer = IdxBuffer;
    dst->VtxBuffer = VtxBuffer;
    dst->Flags = Flags;
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movl $0xc8, %edi
callq 0x41c63
movq %rax, %r14
movq 0x38(%r13), %rbx
xorl %r15d, %r15d
movl $0xc8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0xc260
movq %rbx, 0x38(%r14)
movslq (%r13), %rbx
testq %rbx, %rbx
jle 0x75635
cmpl $0x9, %ebx
movl $0x8, %r12d
cmovael %ebx, %r12d
imulq $0x38, %r12, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x7562d
movslq (%r14), %rax
imulq $0x38, %rax, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x8(%r14), %rdi
callq 0x41d3c
movq %r15, 0x8(%r14)
movl %r12d, 0x4(%r14)
movl %ebx, (%r14)
movq 0x8(%r13), %rsi
imulq $0x38, %rbx, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x75660
xorl %ebx, %ebx
movq %rbx, 0x10(%r14)
callq 0x41d3c
movq %rbx, 0x18(%r14)
movq %r13, -0x30(%rbp)
movl 0x10(%r13), %r13d
movslq %r13d, %r15
movl 0x14(%r14), %eax
cmpl %r15d, %eax
jge 0x75685
testl %eax, %eax
je 0x7568a
movl %eax, %ebx
shrl $0x1f, %ebx
addl %eax, %ebx
sarl %ebx
addl %eax, %ebx
jmp 0x7568f
xorl %r12d, %r12d
jmp 0x756cd
movl $0x8, %ebx
cmpl %r13d, %ebx
cmovlel %r13d, %ebx
movslq %ebx, %rdi
addq %rdi, %rdi
callq 0x41c63
movq %rax, %r12
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x756c5
movslq 0x10(%r14), %rdx
addq %rdx, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x18(%r14), %rdi
callq 0x41d3c
movq %r12, 0x18(%r14)
movl %ebx, 0x14(%r14)
movl %r13d, 0x10(%r14)
movq -0x30(%rbp), %r13
movq 0x18(%r13), %rsi
addq %r15, %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0xc080
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x756ff
xorl %ebx, %ebx
movq %rbx, 0x20(%r14)
callq 0x41d3c
movq %rbx, 0x28(%r14)
movl 0x20(%r13), %r13d
movslq %r13d, %r12
movl 0x24(%r14), %eax
cmpl %r12d, %eax
jge 0x75720
testl %eax, %eax
je 0x75725
movl %eax, %ebx
shrl $0x1f, %ebx
addl %eax, %ebx
sarl %ebx
addl %eax, %ebx
jmp 0x7572a
xorl %r15d, %r15d
jmp 0x75772
movl $0x8, %ebx
cmpl %r13d, %ebx
cmovlel %r13d, %ebx
movslq %ebx, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
callq 0x41c63
movq %rax, %r15
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x7576a
movslq 0x20(%r14), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r15, %rdi
callq 0xc080
movq 0x28(%r14), %rdi
callq 0x41d3c
movq %r15, 0x28(%r14)
movl %ebx, 0x24(%r14)
movl %r13d, 0x20(%r14)
movq -0x30(%rbp), %rbx
movq 0x28(%rbx), %rsi
shlq $0x2, %r12
leaq (%r12,%r12,4), %rdx
movq %r15, %rdi
callq 0xc080
movl 0x30(%rbx), %eax
movl %eax, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddDrawCmd()
void ImDrawList::AddDrawCmd()
{
    ImDrawCmd draw_cmd;
    draw_cmd.ClipRect = _CmdHeader.ClipRect;    // Same as calling ImDrawCmd_HeaderCopy()
    draw_cmd.TextureId = _CmdHeader.TextureId;
    draw_cmd.VtxOffset = _CmdHeader.VtxOffset;
    draw_cmd.IdxOffset = IdxBuffer.Size;

    IM_ASSERT(draw_cmd.ClipRect.x <= draw_cmd.ClipRect.z && draw_cmd.ClipRect.y <= draw_cmd.ClipRect.w);
    CmdBuffer.push_back(draw_cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss 0x88(%rdi), %xmm1
movss 0x90(%rdi), %xmm0
ucomiss %xmm1, %xmm0
jb 0x758eb
movq %rdi, %rbx
movss 0x8c(%rdi), %xmm3
movss 0x94(%rdi), %xmm2
ucomiss %xmm3, %xmm2
jb 0x758eb
movq 0x98(%rbx), %rcx
movl 0xa0(%rbx), %r12d
movl 0x10(%rbx), %r13d
movl (%rbx), %eax
cmpl 0x4(%rbx), %eax
jne 0x75834
movq %rcx, -0x40(%rbp)
leal 0x1(%rax), %r15d
testl %eax, %eax
movss %xmm0, -0x38(%rbp)
movss %xmm1, -0x34(%rbp)
movss %xmm2, -0x30(%rbp)
movss %xmm3, -0x2c(%rbp)
je 0x7583a
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7583f
movq 0x8(%rbx), %r14
jmp 0x75898
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
movslq %r15d, %rax
imulq $0x38, %rax, %rdi
callq 0x41c63
movq %rax, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x75876
movslq (%rbx), %rax
imulq $0x38, %rax, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x8(%rbx), %rdi
callq 0x41d3c
movq %r14, 0x8(%rbx)
movl %r15d, 0x4(%rbx)
movl (%rbx), %eax
movss -0x38(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movq -0x40(%rbp), %rcx
cltq
imulq $0x38, %rax, %rax
movss %xmm1, (%r14,%rax)
movss %xmm3, 0x4(%r14,%rax)
movss %xmm0, 0x8(%r14,%rax)
movss %xmm2, 0xc(%r14,%rax)
movq %rcx, 0x10(%r14,%rax)
movl %r12d, 0x18(%r14,%rax)
movl %r13d, 0x1c(%r14,%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14,%rax)
movq $0x0, 0x30(%r14,%rax)
incl (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5785b(%rip), %rdi     # 0xcd14d
leaq 0x578ad(%rip), %rsi     # 0xcd1a6
leaq 0x578c3(%rip), %rcx     # 0xcd1c3
movl $0x1bc, %edx            # imm = 0x1BC
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_PopUnusedDrawCmd()
void ImDrawList::_PopUnusedDrawCmd()
{
    if (CmdBuffer.Size == 0)
        return;
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount == 0 && curr_cmd->UserCallback == NULL)
        CmdBuffer.pop_back();
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
je 0x75921
movq 0x8(%rdi), %rcx
imulq $0x38, %rax, %rdx
cmpl $0x0, -0x18(%rcx,%rdx)
je 0x75922
retq
addq %rdx, %rcx
cmpq $0x0, -0x10(%rcx)
jne 0x75921
testl %eax, %eax
jle 0x75935
decl %eax
movl %eax, (%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5806a(%rip), %rdi     # 0xcd9aa
leaq 0x43d44(%rip), %rsi     # 0xb968b
leaq 0x59088(%rip), %rcx     # 0xce9d6
movl $0x672, %edx            # imm = 0x672
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddCallback(void (*)(ImDrawList const*, ImDrawCmd const*), void*)
void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
{
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    IM_ASSERT(curr_cmd->UserCallback == NULL);
    if (curr_cmd->ElemCount != 0)
    {
        AddDrawCmd();
        curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    }
    curr_cmd->UserCallback = callback;
    curr_cmd->UserCallbackData = callback_data;

    AddDrawCmd(); // Force a new command after us (see comment below)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x38, %rcx, %rcx
cmpq $0x0, -0x10(%rax,%rcx)
jne 0x759b4
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq %rcx, %rax
cmpl $0x0, -0x18(%rax)
je 0x7599a
movq %r14, %rdi
callq 0x757a8
movslq (%r14), %rax
imulq $0x38, %rax, %rax
addq 0x8(%r14), %rax
movq %r15, -0x10(%rax)
movq %rbx, -0x8(%rax)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x757a8
leaq 0x57826(%rip), %rdi     # 0xcd1e1
leaq 0x577e4(%rip), %rsi     # 0xcd1a6
leaq 0x57839(%rip), %rcx     # 0xcd202
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_OnChangedClipRect()
void ImDrawList::_OnChangedClipRect()
{
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, sizeof(ImVec4)) != 0)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);

    // Try to merge with previous command if it matches, else use current command
    ImDrawCmd* prev_cmd = curr_cmd - 1;
    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
    {
        CmdBuffer.pop_back();
        return;
    }

    curr_cmd->ClipRect = _CmdHeader.ClipRect;
}

// Assembly:
movq 0x8(%rdi), %rdx
movslq (%rdi), %rax
imulq $0x38, %rax, %r8
leaq (%rdx,%r8), %rcx
addq $-0x38, %rcx
movl 0x20(%rcx), %esi
testl %esi, %esi
je 0x75a10
movdqu (%rcx), %xmm0
movdqu 0x88(%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r9d
cmpl $0xffff, %r9d           # imm = 0xFFFF
jne 0x757a8
addq %r8, %rdx
cmpq $0x0, -0x10(%rdx)
jne 0x75a6c
cmpl $0x2, %eax
jl 0x75a5c
testl %esi, %esi
jne 0x75a5c
movdqu 0x88(%rdi), %xmm0
movdqu 0x94(%rdi), %xmm1
movdqu -0x70(%rdx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu -0x64(%rdx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
jne 0x75a5c
cmpq $0x0, -0x48(%rdx)
je 0x75a67
movups 0x88(%rdi), %xmm0
movups %xmm0, (%rcx)
retq
decl %eax
movl %eax, (%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5776a(%rip), %rdi     # 0xcd1e1
leaq 0x57728(%rip), %rsi     # 0xcd1a6
leaq 0x577b2(%rip), %rcx     # 0xcd237
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_OnChangedTextureID()
void ImDrawList::_OnChangedTextureID()
{
    // If current command is used with different settings we need to add a new command
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    if (curr_cmd->ElemCount != 0 && curr_cmd->TextureId != _CmdHeader.TextureId)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);

    // Try to merge with previous command if it matches, else use current command
    ImDrawCmd* prev_cmd = curr_cmd - 1;
    if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
    {
        CmdBuffer.pop_back();
        return;
    }

    curr_cmd->TextureId = _CmdHeader.TextureId;
}

// Assembly:
movq 0x8(%rdi), %rdx
movslq (%rdi), %rax
imulq $0x38, %rax, %rsi
leaq (%rdx,%rsi), %rcx
movl -0x18(%rdx,%rsi), %edx
testl %edx, %edx
je 0x75ab8
movq -0x28(%rcx), %rsi
cmpq 0x98(%rdi), %rsi
jne 0x757a8
cmpq $0x0, -0x10(%rcx)
jne 0x75b12
cmpl $0x2, %eax
jl 0x75b01
testl %edx, %edx
jne 0x75b01
movdqu 0x88(%rdi), %xmm0
movdqu 0x94(%rdi), %xmm1
movdqu -0x70(%rcx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu -0x64(%rcx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
jne 0x75b01
cmpq $0x0, -0x48(%rcx)
je 0x75b0d
movq 0x98(%rdi), %rax
movq %rax, -0x28(%rcx)
retq
decl %eax
movl %eax, (%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x576c4(%rip), %rdi     # 0xcd1e1
leaq 0x57682(%rip), %rsi     # 0xcd1a6
leaq 0x57732(%rip), %rcx     # 0xcd25d
movl $0x200, %edx            # imm = 0x200
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::_OnChangedVtxOffset()
void ImDrawList::_OnChangedVtxOffset()
{
    // We don't need to compare curr_cmd->VtxOffset != _CmdHeader.VtxOffset because we know it'll be different at the time we call this.
    _VtxCurrentIdx = 0;
    ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    //IM_ASSERT(curr_cmd->VtxOffset != _CmdHeader.VtxOffset); // See #3349
    if (curr_cmd->ElemCount != 0)
    {
        AddDrawCmd();
        return;
    }
    IM_ASSERT(curr_cmd->UserCallback == NULL);
    curr_cmd->VtxOffset = _CmdHeader.VtxOffset;
}

// Assembly:
movl $0x0, 0x34(%rdi)
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x38, %rcx, %rcx
cmpl $0x0, -0x18(%rax,%rcx)
jne 0x757a8
addq %rcx, %rax
cmpq $0x0, -0x10(%rax)
jne 0x75b67
movl 0xa0(%rdi), %ecx
movl %ecx, -0x20(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5766f(%rip), %rdi     # 0xcd1e1
leaq 0x5762d(%rip), %rsi     # 0xcd1a6
leaq 0x57704(%rip), %rcx     # 0xcd284
movl $0x218, %edx            # imm = 0x218
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PushClipRect(ImVec2, ImVec2, bool)
void ImDrawList::PushClipRect(ImVec2 cr_min, ImVec2 cr_max, bool intersect_with_current_clip_rect)
{
    ImVec4 cr(cr_min.x, cr_min.y, cr_max.x, cr_max.y);
    if (intersect_with_current_clip_rect)
    {
        ImVec4 current = _CmdHeader.ClipRect;
        if (cr.x < current.x) cr.x = current.x;
        if (cr.y < current.y) cr.y = current.y;
        if (cr.z > current.z) cr.z = current.z;
        if (cr.w > current.w) cr.w = current.w;
    }
    cr.z = ImMax(cr.x, cr.z);
    cr.w = ImMax(cr.y, cr.w);

    _ClipRectStack.push_back(cr);
    _CmdHeader.ClipRect = cr;
    _OnChangedClipRect();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movaps %xmm1, %xmm6
shufps $0x55, %xmm1, %xmm6     # xmm6 = xmm6[1,1],xmm1[1,1]
testl %esi, %esi
je 0x75be2
movss 0x88(%rbx), %xmm5
movss 0x8c(%rbx), %xmm4
movss 0x90(%rbx), %xmm7
movss 0x94(%rbx), %xmm3
maxss %xmm0, %xmm5
maxss %xmm2, %xmm4
minss %xmm1, %xmm7
ucomiss %xmm3, %xmm6
jbe 0x75beb
movaps %xmm3, %xmm6
jmp 0x75beb
movaps %xmm1, %xmm7
movaps %xmm2, %xmm4
movaps %xmm0, %xmm5
movl 0x58(%rbx), %eax
cmpl 0x5c(%rbx), %eax
jne 0x75c18
leal 0x1(%rax), %r15d
testl %eax, %eax
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
je 0x75c1e
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x75c23
movq 0x60(%rbx), %r14
jmp 0x75c76
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
movslq %r15d, %rdi
shlq $0x4, %rdi
callq 0x41c63
movq %rax, %r14
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0x75c5b
movslq 0x58(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x60(%rbx), %rdi
callq 0x41d3c
movq %r14, 0x60(%rbx)
movl %r15d, 0x5c(%rbx)
movl 0x58(%rbx), %eax
movaps -0x60(%rbp), %xmm4
movaps -0x50(%rbp), %xmm5
movaps -0x40(%rbp), %xmm6
movaps -0x30(%rbp), %xmm7
movaps %xmm6, %xmm0
cmpless %xmm4, %xmm0
movaps %xmm0, %xmm1
andps %xmm4, %xmm1
andnps %xmm6, %xmm0
orps %xmm1, %xmm0
movaps %xmm7, %xmm1
cmpless %xmm5, %xmm1
movaps %xmm1, %xmm2
andps %xmm5, %xmm2
andnps %xmm7, %xmm1
orps %xmm2, %xmm1
cltq
shlq $0x4, %rax
movss %xmm5, (%r14,%rax)
movss %xmm4, 0x4(%r14,%rax)
movss %xmm1, 0x8(%r14,%rax)
movss %xmm0, 0xc(%r14,%rax)
incl 0x58(%rbx)
movss %xmm5, 0x88(%rbx)
movss %xmm4, 0x8c(%rbx)
movss %xmm1, 0x90(%rbx)
movss %xmm0, 0x94(%rbx)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x759d4
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimReserve(int, int)
void ImDrawList::PrimReserve(int idx_count, int vtx_count)
{
    // Large mesh support (when enabled)
    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);
    if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))
    {
        // FIXME: In theory we should be testing that vtx_count <64k here.
        // In practice, RenderText() relies on reserving ahead for a worst case scenario so it is currently useful for us
        // to not make that check until we rework the text functions to handle clipping and large horizontal lines better.
        _CmdHeader.VtxOffset = VtxBuffer.Size;
        _OnChangedVtxOffset();
    }

    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    draw_cmd->ElemCount += idx_count;

    int vtx_buffer_old_size = VtxBuffer.Size;
    VtxBuffer.resize(vtx_buffer_old_size + vtx_count);
    _VtxWritePtr = VtxBuffer.Data + vtx_buffer_old_size;

    int idx_buffer_old_size = IdxBuffer.Size;
    IdxBuffer.resize(idx_buffer_old_size + idx_count);
    _IdxWritePtr = IdxBuffer.Data + idx_buffer_old_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movl 0x34(%rdi), %eax
addl %edx, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x75e8c
testb $0x8, 0x30(%rbx)
je 0x75e8c
movl 0x20(%rbx), %eax
movl %eax, 0xa0(%rbx)
movq %rbx, %rdi
callq 0x75b36
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
imulq $0x38, %rcx, %rcx
addl %r14d, -0x18(%rax,%rcx)
movslq 0x20(%rbx), %rcx
addl %ecx, %r15d
movl 0x24(%rbx), %eax
cmpl %r15d, %eax
jge 0x75ec5
testl %eax, %eax
movq %rcx, -0x30(%rbp)
je 0x75ecb
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x75ed1
movq 0x28(%rbx), %r12
jmp 0x75f1d
movl $0x8, %r13d
cmpl %r15d, %r13d
cmovlel %r15d, %r13d
movslq %r13d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
callq 0x41c63
movq %rax, %r12
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x75f11
movslq 0x20(%rbx), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x28(%rbx), %rdi
callq 0x41d3c
movq %r12, 0x28(%rbx)
movl %r13d, 0x24(%rbx)
movq -0x30(%rbp), %rcx
movl %r15d, 0x20(%rbx)
leaq (%rcx,%rcx,4), %rax
leaq (%r12,%rax,4), %rax
movq %rax, 0x48(%rbx)
movslq 0x10(%rbx), %r12
addl %r12d, %r14d
movl 0x14(%rbx), %eax
cmpl %r14d, %eax
jge 0x75f52
testl %eax, %eax
je 0x75f58
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x75f5e
movq 0x18(%rbx), %r15
jmp 0x75f9c
movl $0x8, %r13d
cmpl %r14d, %r13d
cmovlel %r14d, %r13d
movslq %r13d, %rdi
addq %rdi, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x75f94
movslq 0x10(%rbx), %rdx
addq %rdx, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x18(%rbx), %rdi
callq 0x41d3c
movq %r15, 0x18(%rbx)
movl %r13d, 0x14(%rbx)
movl %r14d, 0x10(%rbx)
leaq (%r15,%r12,2), %rax
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimUnreserve(int, int)
void ImDrawList::PrimUnreserve(int idx_count, int vtx_count)
{
    IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);

    ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
    draw_cmd->ElemCount -= idx_count;
    VtxBuffer.shrink(VtxBuffer.Size - vtx_count);
    IdxBuffer.shrink(IdxBuffer.Size - idx_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x38, %rcx, %rcx
subl %esi, -0x18(%rax,%rcx)
testl %edx, %edx
js 0x75fdb
subl %edx, 0x20(%rdi)
testl %esi, %esi
js 0x75ff2
subl %esi, 0x10(%rdi)
popq %rbp
retq
leaq 0x58a87(%rip), %rdi     # 0xcea69
leaq 0x436a2(%rip), %rsi     # 0xb968b
leaq 0x58a8a(%rip), %rcx     # 0xcea7a
jmp 0x76007
leaq 0x58a70(%rip), %rdi     # 0xcea69
leaq 0x4368b(%rip), %rsi     # 0xb968b
leaq 0x58aab(%rip), %rcx     # 0xceab2
movl $0x66d, %edx            # imm = 0x66D
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImBezierCubicCalc(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, float)
ImVec2 ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, float t)
{
    float u = 1.0f - t;
    float w1 = u * u * u;
    float w2 = 3 * u * u * t;
    float w3 = 3 * u * t * t;
    float w4 = t * t * t;
    return ImVec2(w1 * p1.x + w2 * p2.x + w3 * p3.x + w4 * p4.x, w1 * p1.y + w2 * p2.y + w3 * p3.y + w4 * p4.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss 0x3db1c(%rip), %xmm3    # 0xb4fe4
subss %xmm0, %xmm3
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
mulss %xmm3, %xmm1
movss 0x3db11(%rip), %xmm2    # 0xb4ff0
mulss %xmm3, %xmm2
mulss %xmm2, %xmm3
mulss %xmm0, %xmm3
mulss %xmm0, %xmm2
mulss %xmm0, %xmm2
movaps %xmm0, %xmm4
mulss %xmm0, %xmm4
mulss %xmm0, %xmm4
movss (%rsi), %xmm0
mulss %xmm3, %xmm0
movss (%rdi), %xmm5
mulss %xmm1, %xmm5
addss %xmm0, %xmm5
movss (%rdx), %xmm6
mulss %xmm2, %xmm6
addss %xmm5, %xmm6
movss (%rcx), %xmm0
mulss %xmm4, %xmm0
mulss 0x4(%rsi), %xmm3
addss %xmm6, %xmm0
mulss 0x4(%rdi), %xmm1
addss %xmm3, %xmm1
mulss 0x4(%rdx), %xmm2
mulss 0x4(%rcx), %xmm4
addss %xmm1, %xmm2
addss %xmm2, %xmm4
unpcklps %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7851a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movss 0x3cc6e(%rip), %xmm2    # 0xb5004
movss (%rsi), %xmm3
addss %xmm2, %xmm3
movss 0x4(%rsi), %xmm1
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
movss %xmm0, -0x2c(%rbp)
jne 0x783d0
leal 0x1(%rax), %r13d
testl %eax, %eax
movaps %xmm3, -0x40(%rbp)
je 0x783d9
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x783de
movq 0x80(%rbx), %r12
jmp 0x7843b
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r12
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x7841c
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x41d3c
movq %r12, 0x80(%rbx)
movl %r13d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
movss -0x2c(%rbp), %xmm0
movss 0x3cbcd(%rip), %xmm2    # 0xb5004
movaps -0x40(%rbp), %xmm3
cltq
movlps %xmm3, (%r12,%rax,8)
movl 0x78(%rbx), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x78(%rbx)
movss (%r15), %xmm1
addss %xmm2, %xmm1
addss 0x4(%r15), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
cmpl 0x7c(%rbx), %eax
jne 0x7847e
addl $0x2, %r12d
testl %eax, %eax
movaps %xmm1, -0x40(%rbp)
je 0x78487
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7848c
movq 0x80(%rbx), %r15
jmp 0x784e1
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x784ca
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x41d3c
movq %r15, 0x80(%rbx)
movl %r12d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
movss -0x2c(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
cltq
movlps %xmm1, (%r15,%rax,8)
movl 0x78(%rbx), %edx
incl %edx
movl %edx, 0x78(%rbx)
movq 0x80(%rbx), %rsi
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x76296
movl $0x0, 0x78(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x785e5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movq %rdi, %rbx
movss %xmm1, -0x14(%rbp)
testb $0x1, 0x30(%rdi)
jne 0x7856d
movss 0x3cab8(%rip), %xmm1    # 0xb5004
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 0x4e3ed(%rip), %xmm1    # 0xc6958
jmp 0x78594
movss 0x3ca8f(%rip), %xmm1    # 0xb5004
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 0x3d330(%rip), %xmm1    # 0xb58c4
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 %rbx, %rdi
movl %r8d, %ecx
callq 0x77f54
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x14(%rbp), %xmm0
callq 0x76296
movl $0x0, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
jb 0x78637
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x78640
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0x77f54
movq 0x80(%r14), %rsi
movl 0x78(%r14), %edx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x76d34
movl $0x0, 0x78(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x6, %esi
movl $0x4, %edx
callq 0x75e52
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x76012
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x78785
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq (%rax), %r15
movq %rsi, -0x30(%rbp)
movl $0x6, %esi
movq %rdx, -0x38(%rbp)
movl $0x4, %edx
callq 0x75e52
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 0x48(%rbx), %rax
movq -0x30(%rbp), %rdi
movq (%rdi), %rcx
movq %rcx, (%rax)
movq 0x48(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x48(%rbx), %rax
movl %r14d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x48(%rbx)
incl 0x34(%rbx)
movq -0x38(%rbp), %rsi
movl (%rsi), %ecx
movl 0x4(%rdi), %edx
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movq 0x48(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x48(%rbx), %rax
movl %r13d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x48(%rbx)
incl 0x34(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x14(%rax)
movq 0x48(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x48(%rbx), %rax
movl %r12d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x48(%rbx)
incl 0x34(%rbx)
movl (%rdi), %ecx
movl 0x4(%rsi), %edx
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movq 0x48(%rbx), %rax
movq %r15, 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
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddTriangle(ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float)
void ImDrawList::AddTriangle(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, -0x2c(%rbp)
cmpl $0x1000000, %r8d        # imm = 0x1000000
jb 0x78ec6
movl %r8d, %r14d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
movq %rcx, -0x38(%rbp)
jne 0x78d1c
movq %r12, -0x40(%rbp)
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x78d25
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x78d2a
movq 0x80(%rbx), %r15
jmp 0x78d7a
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x78d68
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x41d3c
movq %r15, 0x80(%rbx)
movl %r12d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
movq -0x40(%rbp), %r12
cltq
movq (%r13), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x78(%rbx), %r13d
leal 0x1(%r13), %eax
movl %eax, 0x78(%rbx)
cmpl 0x7c(%rbx), %eax
jne 0x78da9
addl $0x2, %r13d
testl %eax, %eax
je 0x78db2
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x78db7
movq 0x80(%rbx), %r15
jmp 0x78e03
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x78df5
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x41d3c
movq %r15, 0x80(%rbx)
movl %r13d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
cltq
movq (%r12), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x78(%rbx), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x78(%rbx)
cmpl 0x7c(%rbx), %eax
jne 0x78e33
addl $0x2, %r12d
testl %eax, %eax
je 0x78e3c
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x78e41
movq 0x80(%rbx), %r15
jmp 0x78e8d
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x78e7f
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x41d3c
movq %r15, 0x80(%rbx)
movl %r12d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
movq -0x38(%rbp), %rcx
cltq
movq (%rcx), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x78(%rbx), %edx
incl %edx
movl %edx, 0x78(%rbx)
movq 0x80(%rbx), %rsi
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x2c(%rbp), %xmm0
callq 0x76296
movl $0x0, 0x78(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddTriangleFilled(ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddTriangleFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

    PathLineTo(p1);
    PathLineTo(p2);
    PathLineTo(p3);
    PathFillConvex(col);
}

// Assembly:
cmpl $0x1000000, %r8d        # imm = 0x1000000
jb 0x790db
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
movq %rcx, -0x30(%rbp)
jne 0x78f25
movq %r12, -0x38(%rbp)
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x78f2e
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x78f33
movq 0x80(%r14), %r15
jmp 0x78f84
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x78f71
movslq 0x78(%r14), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%r14), %rdi
callq 0x41d3c
movq %r15, 0x80(%r14)
movl %r12d, 0x7c(%r14)
movl 0x78(%r14), %eax
movq -0x38(%rbp), %r12
cltq
movq (%r13), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x78(%r14), %r13d
leal 0x1(%r13), %eax
movl %eax, 0x78(%r14)
cmpl 0x7c(%r14), %eax
jne 0x78fb5
addl $0x2, %r13d
testl %eax, %eax
je 0x78fbe
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x78fc3
movq 0x80(%r14), %r15
jmp 0x79010
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x79001
movslq 0x78(%r14), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%r14), %rdi
callq 0x41d3c
movq %r15, 0x80(%r14)
movl %r13d, 0x7c(%r14)
movl 0x78(%r14), %eax
cltq
movq (%r12), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x78(%r14), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x78(%r14)
cmpl 0x7c(%r14), %eax
jne 0x79042
addl $0x2, %r12d
testl %eax, %eax
je 0x7904b
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x79050
movq 0x80(%r14), %r15
jmp 0x7909d
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r15
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x7908e
movslq 0x78(%r14), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%r14), %rdi
callq 0x41d3c
movq %r15, 0x80(%r14)
movl %r12d, 0x7c(%r14)
movl 0x78(%r14), %eax
movq -0x30(%rbp), %rcx
cltq
movq (%rcx), %rcx
movq %rcx, (%r15,%rax,8)
movl 0x78(%r14), %edx
incl %edx
movl %edx, 0x78(%r14)
movq 0x80(%r14), %rsi
movq %r14, %rdi
movl %ebx, %ecx
callq 0x76d34
movl $0x0, 0x78(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
movaps %xmm0, %xmm3
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
setae %dl
orb %al, %dl
jne 0x79206
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
movss %xmm1, -0x20(%rbp)
jle 0x7912b
movl $0x200, %eax            # imm = 0x200
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl $0x3, %edx
cmpl $0x3, %ecx
jae 0x7917f
jmp 0x791a5
cvttss2si %xmm3, %ecx
movq 0x38(%rbx), %rax
cmpl $0x3f, %ecx
jg 0x79145
movslq %ecx, %rcx
movzbl 0x90(%rax,%rcx), %eax
jmp 0x7917f
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, -0x1c(%rbp)
callq 0xc4d0
movss -0x1c(%rbp), %xmm3
movss 0x4d7ec(%rip), %xmm1    # 0xc6954
divss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movl $0x200, %eax            # imm = 0x200
cmpl %eax, %ecx
cmovbl %ecx, %eax
cmpl $0xc, %ecx
jl 0x79186
movl %eax, %edx
cmpl $0xc, %eax
jne 0x791a5
addss 0x3c736(%rip), %xmm3    # 0xb58c4
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
movl $0xb, %ecx
callq 0x7700e
jmp 0x791df
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss 0x3be1c(%rip), %xmm2    # 0xb4fd0
addss %xmm0, %xmm2
mulss 0x4d794(%rip), %xmm2    # 0xc6954
divss %xmm0, %xmm2
addss 0x3c6f8(%rip), %xmm3    # 0xb58c4
decl %edx
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
callq 0x7724e
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x20(%rbp), %xmm0
callq 0x76296
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
movaps %xmm0, %xmm3
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
setae %dl
orb %al, %dl
jne 0x7931c
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
jle 0x7925c
movl $0x200, %eax            # imm = 0x200
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl $0x3, %edx
cmpl $0x3, %ecx
jae 0x792b0
jmp 0x792ce
cvttss2si %xmm3, %ecx
movq 0x38(%rbx), %rax
cmpl $0x3f, %ecx
jg 0x79276
movslq %ecx, %rcx
movzbl 0x90(%rax,%rcx), %eax
jmp 0x792b0
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, -0x1c(%rbp)
callq 0xc4d0
movss -0x1c(%rbp), %xmm3
movss 0x4d6bb(%rip), %xmm1    # 0xc6954
divss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movl $0x200, %eax            # imm = 0x200
cmpl %eax, %ecx
cmovbl %ecx, %eax
cmpl $0xc, %ecx
jl 0x792b7
movl %eax, %edx
cmpl $0xc, %eax
jne 0x792ce
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
movl $0xb, %ecx
callq 0x7700e
jmp 0x79300
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss 0x3bcf3(%rip), %xmm2    # 0xb4fd0
addss %xmm0, %xmm2
mulss 0x4d66b(%rip), %xmm2    # 0xc6954
divss %xmm0, %xmm2
decl %edx
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
callq 0x7724e
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x76d34
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
cmpl $0x3, %ecx
setl %dl
orb %al, %dl
jne 0x793ab
movq %rdi, %rbx
movss %xmm1, -0x14(%rbp)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss 0x3bc70(%rip), %xmm2    # 0xb4fd0
addss %xmm1, %xmm2
mulss 0x4d5e8(%rip), %xmm2    # 0xc6954
divss %xmm1, %xmm2
addss 0x3c54c(%rip), %xmm0    # 0xb58c4
decl %ecx
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x7724e
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x14(%rbp), %xmm0
callq 0x76296
movl $0x0, 0x78(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
cmpl $0x1000000, %edx        # imm = 0x1000000
setb %al
cmpl $0x3, %ecx
setl %dl
orb %al, %dl
jne 0x79418
movq %rdi, %rbx
cvtsi2ss %ecx, %xmm1
movss 0x3bbf0(%rip), %xmm2    # 0xb4fd0
addss %xmm1, %xmm2
mulss 0x4d568(%rip), %xmm2    # 0xc6954
divss %xmm1, %xmm2
decl %ecx
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x7724e
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x76d34
movl $0x0, 0x78(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
jb 0x79533
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x10(%rbp), %r9d
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
movss %xmm0, -0x2c(%rbp)
jne 0x79477
leal 0x1(%rax), %r13d
testl %eax, %eax
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
je 0x79480
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x79485
movq 0x80(%rbx), %r12
jmp 0x794e1
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x41c63
movq %rax, %r12
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x794c3
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x41d3c
movq %r12, 0x80(%rbx)
movl %r13d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movl 0x10(%rbp), %r9d
cltq
movq (%r15), %rsi
movq %rsi, (%r12,%rax,8)
incl 0x78(%rbx)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x775b2
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movss -0x2c(%rbp), %xmm0
callq 0x76296
movl $0x0, 0x78(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq