LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x769a2
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x425d4
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x769bb
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
callq 0x425d4
movq %r14, 0x18(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x769d4
xorl %r14d, %r14d
movq %r14, 0x20(%rbx)
callq 0x425d4
movq %r14, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x769fc
xorl %r14d, %r14d
movq %r14, 0x58(%rbx)
callq 0x425d4
movq %r14, 0x60(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x76a15
xorl %r14d, %r14d
movq %r14, 0x68(%rbx)
callq 0x425d4
movq %r14, 0x70(%rbx)
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x76a34
xorl %r14d, %r14d
movq %r14, 0x78(%rbx)
callq 0x425d4
movq %r14, 0x80(%rbx)
addq $0xa8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x76a48
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x8(%rdi)
jle 0x76ae5
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rbx), %eax
cmpq %rax, %r12
jne 0x76a85
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x76b1a
movq 0x10(%rbx), %r13
movq 0x8(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x76aaf
movq %r14, (%r13,%r15)
callq 0x425d4
movq %r14, 0x8(%r13,%r15)
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x76b1a
movq 0x10(%rbx), %r13
movq 0x18(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x76ad5
movq %r14, 0x10(%r13,%r15)
callq 0x425d4
movq %r14, 0x18(%r13,%r15)
incq %r12
movslq 0x8(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x76a6c
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x76b0b
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
callq 0x425d4
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x44b57(%rip), %rdi     # 0xbb678
leaq 0x44b63(%rip), %rsi     # 0xbb68b
leaq 0x5a050(%rip), %rcx     # 0xd0b7f
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76ec3
movq %rdi, %rbx
movss 0x8c(%rdi), %xmm3
movss 0x94(%rdi), %xmm2
ucomiss %xmm3, %xmm2
jb 0x76ec3
movq 0x98(%rbx), %r15
movl 0xa0(%rbx), %r12d
movl 0x10(%rbx), %r13d
movl (%rbx), %r14d
movl 0x4(%rbx), %eax
cmpl %eax, %r14d
jne 0x76e70
incl %r14d
testl %eax, %eax
je 0x76df9
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x76dfe
movl $0x8, %ecx
cmpl %r14d, %ecx
cmovgl %ecx, %r14d
cmpl %r14d, %eax
jge 0x76e70
movss %xmm3, -0x2c(%rbp)
movss %xmm2, -0x30(%rbp)
movss %xmm1, -0x34(%rbp)
movss %xmm0, -0x38(%rbp)
movslq %r14d, %rax
imulq $0x38, %rax, %rdi
callq 0x424fb
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x76e54
movslq (%rbx), %rcx
imulq $0x38, %rcx, %rdx
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xc080
movq 0x8(%rbx), %rdi
callq 0x425d4
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movl %r14d, 0x4(%rbx)
movss -0x38(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss -0x2c(%rbp), %xmm3
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
imulq $0x38, %rcx, %rcx
movss %xmm1, (%rax,%rcx)
movss %xmm3, 0x4(%rax,%rcx)
movss %xmm0, 0x8(%rax,%rcx)
movss %xmm2, 0xc(%rax,%rcx)
movq %r15, 0x10(%rax,%rcx)
movl %r12d, 0x18(%rax,%rcx)
movl %r13d, 0x1c(%rax,%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax,%rcx)
movq $0x0, 0x30(%rax,%rcx)
incl (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x582b3(%rip), %rdi     # 0xcf17d
leaq 0x58305(%rip), %rsi     # 0xcf1d6
leaq 0x5831b(%rip), %rcx     # 0xcf1f3
movl $0x1bc, %edx            # imm = 0x1BC
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76ef9
movq 0x8(%rdi), %rcx
imulq $0x38, %rax, %rdx
cmpl $0x0, -0x18(%rcx,%rdx)
je 0x76efa
retq
addq %rdx, %rcx
cmpq $0x0, -0x10(%rcx)
jne 0x76ef9
testl %eax, %eax
jle 0x76f0d
decl %eax
movl %eax, (%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x58ac2(%rip), %rdi     # 0xcf9da
leaq 0x4476c(%rip), %rsi     # 0xbb68b
leaq 0x59b14(%rip), %rcx     # 0xd0a3a
movl $0x672, %edx            # imm = 0x672
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76f8c
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
addq %rcx, %rax
cmpl $0x0, -0x18(%rax)
je 0x76f72
movq %r14, %rdi
callq 0x76d7e
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 0x76d7e
leaq 0x5827e(%rip), %rdi     # 0xcf211
leaq 0x5823c(%rip), %rsi     # 0xcf1d6
leaq 0x58291(%rip), %rcx     # 0xcf232
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76fe8
movdqu (%rcx), %xmm0
movdqu 0x88(%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r9d
cmpl $0xffff, %r9d           # imm = 0xFFFF
jne 0x76d7e
addq %r8, %rdx
cmpq $0x0, -0x10(%rdx)
jne 0x77044
cmpl $0x2, %eax
jl 0x77034
testl %esi, %esi
jne 0x77034
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 0x77034
cmpq $0x0, -0x48(%rdx)
je 0x7703f
movups 0x88(%rdi), %xmm0
movups %xmm0, (%rcx)
retq
decl %eax
movl %eax, (%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x581c2(%rip), %rdi     # 0xcf211
leaq 0x58180(%rip), %rsi     # 0xcf1d6
leaq 0x5820a(%rip), %rcx     # 0xcf267
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x77090
movq -0x28(%rcx), %rsi
cmpq 0x98(%rdi), %rsi
jne 0x76d7e
cmpq $0x0, -0x10(%rcx)
jne 0x770ea
cmpl $0x2, %eax
jl 0x770d9
testl %edx, %edx
jne 0x770d9
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 0x770d9
cmpq $0x0, -0x48(%rcx)
je 0x770e5
movq 0x98(%rdi), %rax
movq %rax, -0x28(%rcx)
retq
decl %eax
movl %eax, (%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5811c(%rip), %rdi     # 0xcf211
leaq 0x580da(%rip), %rsi     # 0xcf1d6
leaq 0x5818a(%rip), %rcx     # 0xcf28d
movl $0x200, %edx            # imm = 0x200
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76d7e
addq %rcx, %rax
cmpq $0x0, -0x10(%rax)
jne 0x7713f
movl 0xa0(%rdi), %ecx
movl %ecx, -0x20(%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x580c7(%rip), %rdi     # 0xcf211
leaq 0x58085(%rip), %rsi     # 0xcf1d6
leaq 0x5815c(%rip), %rcx     # 0xcf2b4
movl $0x218, %edx            # imm = 0x218
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x771ba
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 0x771c3
movaps %xmm3, %xmm6
jmp 0x771c3
movaps %xmm1, %xmm7
movaps %xmm2, %xmm4
movaps %xmm0, %xmm5
movl 0x58(%rbx), %r15d
movl 0x5c(%rbx), %eax
cmpl %eax, %r15d
jne 0x7724d
incl %r15d
testl %eax, %eax
je 0x771e3
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x771e8
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
cmpl %r15d, %eax
jge 0x7724d
movaps %xmm7, -0x30(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm4, -0x60(%rbp)
movslq %r15d, %rdi
shlq $0x4, %rdi
callq 0x424fb
movq %rax, %r14
movq 0x60(%rbx), %rsi
testq %rsi, %rsi
je 0x77235
movslq 0x58(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
callq 0xc080
movq 0x60(%rbx), %rdi
callq 0x425d4
movq %r14, 0x60(%rbx)
movl %r15d, 0x5c(%rbx)
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
movq 0x60(%rbx), %rax
movslq 0x58(%rbx), %rcx
shlq $0x4, %rcx
movss %xmm5, (%rax,%rcx)
movss %xmm4, 0x4(%rax,%rcx)
movss %xmm1, 0x8(%rax,%rcx)
movss %xmm0, 0xc(%rax,%rcx)
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 0x76fac
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x775cb
subl %edx, 0x20(%rdi)
testl %esi, %esi
js 0x775e2
subl %esi, 0x10(%rdi)
popq %rbp
retq
leaq 0x594fb(%rip), %rdi     # 0xd0acd
leaq 0x440b2(%rip), %rsi     # 0xbb68b
leaq 0x594fe(%rip), %rcx     # 0xd0ade
jmp 0x775f7
leaq 0x594e4(%rip), %rdi     # 0xd0acd
leaq 0x4409b(%rip), %rsi     # 0xbb68b
leaq 0x5951f(%rip), %rcx     # 0xd0b16
movl $0x66d, %edx            # imm = 0x66D
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimRect(ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)
{
    ImVec2 b(c.x, a.y), d(a.x, c.y), uv(_Data->TexUvWhitePixel);
    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %eax
movl 0x4(%rsi), %r10d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
movq 0x38(%rdi), %r9
movq (%r9), %r9
movl 0x34(%rdi), %ebx
movq 0x50(%rdi), %r14
movw %bx, (%r14)
leal 0x1(%rbx), %r15d
movw %r15w, 0x2(%r14)
leal 0x2(%rbx), %r15d
movw %r15w, 0x4(%r14)
movw %bx, 0x6(%r14)
movw %r15w, 0x8(%r14)
addl $0x3, %ebx
movw %bx, 0xa(%r14)
movq 0x48(%rdi), %rbx
movq (%rsi), %rsi
movq %rsi, (%rbx)
movq 0x48(%rdi), %rsi
movq %r9, 0x8(%rsi)
movq 0x48(%rdi), %rsi
movl %ecx, 0x10(%rsi)
movl %r11d, 0x14(%rsi)
movl %r10d, 0x18(%rsi)
movq 0x48(%rdi), %rsi
movq %r9, 0x1c(%rsi)
movq 0x48(%rdi), %rsi
movl %ecx, 0x24(%rsi)
movq (%rdx), %rdx
movq %rdx, 0x28(%rsi)
movq 0x48(%rdi), %rdx
movq %r9, 0x30(%rdx)
movq 0x48(%rdi), %rdx
movl %ecx, 0x38(%rdx)
movl %eax, 0x3c(%rdx)
movl %r8d, 0x40(%rdx)
movq 0x48(%rdi), %rax
movq %r9, 0x44(%rax)
movq 0x48(%rdi), %rax
movl %ecx, 0x4c(%rax)
addq $0x50, %rax
movq %rax, 0x48(%rdi)
addl $0x4, 0x34(%rdi)
addq $0xc, 0x50(%rdi)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimRectUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col)
{
    ImVec2 b(c.x, a.y), d(a.x, c.y), uv_b(uv_c.x, uv_a.y), uv_d(uv_a.x, uv_c.y);
    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r10
movq %rcx, %r8
movl (%rsi), %eax
movl %eax, -0x34(%rbp)
movl 0x4(%rsi), %r14d
movl (%rdx), %r12d
movl 0x4(%rdx), %eax
movl %eax, -0x2c(%rbp)
movl (%rcx), %eax
movl %eax, -0x30(%rbp)
movl 0x4(%rcx), %r15d
movl (%r10), %r13d
movl 0x4(%r10), %ebx
movl 0x34(%rdi), %eax
movq 0x50(%rdi), %rcx
movw %ax, (%rcx)
leal 0x1(%rax), %r11d
movw %r11w, 0x2(%rcx)
leal 0x2(%rax), %r11d
movw %r11w, 0x4(%rcx)
movw %ax, 0x6(%rcx)
movw %r11w, 0x8(%rcx)
addl $0x3, %eax
movw %ax, 0xa(%rcx)
movq (%rsi), %rax
movq 0x48(%rdi), %rcx
movq %rax, (%rcx)
movq (%r8), %rax
movq 0x48(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x48(%rdi), %rax
movl %r9d, 0x10(%rax)
movl %r12d, 0x14(%rax)
movl %r14d, 0x18(%rax)
movq 0x48(%rdi), %rax
movl %r13d, 0x1c(%rax)
movl %r15d, 0x20(%rax)
movq 0x48(%rdi), %rax
movl %r9d, 0x24(%rax)
movq (%rdx), %rcx
movq %rcx, 0x28(%rax)
movq 0x48(%rdi), %rax
movq (%r10), %rcx
movq %rcx, 0x30(%rax)
movq 0x48(%rdi), %rax
movl %r9d, 0x38(%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x40(%rax)
movq 0x48(%rdi), %rax
movl -0x30(%rbp), %ecx
movl %ecx, 0x44(%rax)
movl %ebx, 0x48(%rax)
movq 0x48(%rdi), %rax
movl %r9d, 0x4c(%rax)
addq $0x50, %rax
movq %rax, 0x48(%rdi)
addl $0x4, 0x34(%rdi)
addq $0xc, 0x50(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::PrimQuadUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimQuadUV(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& d, const ImVec2& uv_a, const ImVec2& uv_b, const ImVec2& uv_c, const ImVec2& uv_d, ImU32 col)
{
    ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
    _IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr[2] = (ImDrawIdx)(idx+2);
    _IdxWritePtr[3] = idx; _IdxWritePtr[4] = (ImDrawIdx)(idx+2); _IdxWritePtr[5] = (ImDrawIdx)(idx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %r11
movq 0x10(%rbp), %rbx
movl 0x28(%rbp), %r10d
movl 0x34(%rdi), %r14d
movq 0x50(%rdi), %r15
movw %r14w, (%r15)
leal 0x1(%r14), %r12d
movw %r12w, 0x2(%r15)
leal 0x2(%r14), %r12d
movw %r12w, 0x4(%r15)
movw %r14w, 0x6(%r15)
movw %r12w, 0x8(%r15)
addl $0x3, %r14d
movw %r14w, 0xa(%r15)
movq 0x48(%rdi), %r14
movq (%rsi), %rsi
movq %rsi, (%r14)
movq 0x48(%rdi), %rsi
movq (%r9), %r9
movq %r9, 0x8(%rsi)
movq 0x48(%rdi), %rsi
movl %r10d, 0x10(%rsi)
movq (%rdx), %rdx
movq %rdx, 0x14(%rsi)
movq 0x48(%rdi), %rdx
movq (%rbx), %rsi
movq %rsi, 0x1c(%rdx)
movq 0x48(%rdi), %rdx
movl %r10d, 0x24(%rdx)
movq (%rcx), %rcx
movq %rcx, 0x28(%rdx)
movq 0x48(%rdi), %rcx
movq (%r11), %rdx
movq %rdx, 0x30(%rcx)
movq 0x48(%rdi), %rcx
movl %r10d, 0x38(%rcx)
movq (%r8), %rdx
movq %rdx, 0x3c(%rcx)
movq 0x48(%rdi), %rcx
movq (%rax), %rax
movq %rax, 0x44(%rcx)
movq 0x48(%rdi), %rax
movl %r10d, 0x4c(%rax)
addq $0x50, %rax
movq %rax, 0x48(%rdi)
addl $0x4, 0x34(%rdi)
addq $0xc, 0x50(%rdi)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e36a(%rip), %xmm3    # 0xb6fe4
subss %xmm0, %xmm3
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
mulss %xmm3, %xmm1
movss 0x3e35f(%rip), %xmm2    # 0xb6ff0
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_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImBezierQuadraticCalc(ImVec2 const&, ImVec2 const&, ImVec2 const&, float)
ImVec2 ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, float t)
{
    float u = 1.0f - t;
    float w1 = u * u;
    float w2 = 2 * u * t;
    float w3 = t * t;
    return ImVec2(w1 * p1.x + w2 * p2.x + w3 * p3.x, w1 * p1.y + w2 * p2.y + w3 * p3.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss 0x3e2d7(%rip), %xmm2    # 0xb6fe4
subss %xmm0, %xmm2
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
addss %xmm2, %xmm2
mulss %xmm0, %xmm2
mulss %xmm0, %xmm0
movss (%rsi), %xmm1
mulss %xmm2, %xmm1
movss (%rdi), %xmm4
mulss %xmm3, %xmm4
addss %xmm1, %xmm4
movss (%rdx), %xmm1
mulss %xmm0, %xmm1
addss %xmm4, %xmm1
mulss 0x4(%rsi), %xmm2
mulss 0x4(%rdi), %xmm3
mulss 0x4(%rdx), %xmm0
addss %xmm2, %xmm3
addss %xmm3, %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, %xmm0
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x79c7e
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 0x3d51a(%rip), %xmm2    # 0xb7004
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), %r13d
movl 0x7c(%rdi), %eax
cmpl %eax, %r13d
jne 0x79b8f
incl %r13d
testl %eax, %eax
je 0x79b22
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x79b27
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x79b8f
movaps %xmm3, -0x40(%rbp)
movss %xmm0, -0x2c(%rbp)
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq %rax, %r12
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x79b73
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x425d4
movq %r12, 0x80(%rbx)
movl %r13d, 0x7c(%rbx)
movss -0x2c(%rbp), %xmm0
movss 0x3d479(%rip), %xmm2    # 0xb7004
movaps -0x40(%rbp), %xmm3
movq 0x80(%rbx), %rax
movslq 0x78(%rbx), %rcx
movlps %xmm3, (%rax,%rcx,8)
movl 0x78(%rbx), %r12d
movl 0x7c(%rbx), %eax
leal 0x1(%r12), %ecx
movl %ecx, 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 %eax, %ecx
jne 0x79c3d
addl $0x2, %r12d
testl %eax, %eax
je 0x79bd8
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x79bdd
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x79c3d
movaps %xmm1, -0x40(%rbp)
movss %xmm0, -0x2c(%rbp)
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq %rax, %r15
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x79c29
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x425d4
movq %r15, 0x80(%rbx)
movl %r12d, 0x7c(%rbx)
movss -0x2c(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movq 0x80(%rbx), %rax
movslq 0x78(%rbx), %rcx
movlps %xmm1, (%rax,%rcx,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 0x77886
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_O1/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 0x79d49
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 0x79cd1
movss 0x3d354(%rip), %xmm1    # 0xb7004
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 0x4ecb9(%rip), %xmm1    # 0xc8988
jmp 0x79cf8
movss 0x3d32b(%rip), %xmm1    # 0xb7004
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 0x3dbcc(%rip), %xmm1    # 0xb78c4
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 0x79698
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x14(%rbp), %xmm0
callq 0x77886
movl $0x0, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x79d9b
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x79da4
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0x79698
movq 0x80(%r14), %rsi
movl 0x78(%r14), %edx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x78432
movl $0x0, 0x78(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x6, %esi
movl $0x4, %edx
callq 0x77438
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x77602
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x79f11
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 0x77438
movl 0x34(%rbx), %eax
movq 0x50(%rbx), %rcx
movw %ax, (%rcx)
leaq 0x2(%rcx), %rdx
movq %rdx, 0x50(%rbx)
leal 0x1(%rax), %edx
movw %dx, 0x2(%rcx)
leaq 0x4(%rcx), %rdx
movq %rdx, 0x50(%rbx)
leal 0x2(%rax), %edx
movw %dx, 0x4(%rcx)
leaq 0x6(%rcx), %rsi
movq %rsi, 0x50(%rbx)
movw %ax, 0x6(%rcx)
leaq 0x8(%rcx), %rsi
movq %rsi, 0x50(%rbx)
movw %dx, 0x8(%rcx)
leaq 0xa(%rcx), %rdx
movq %rdx, 0x50(%rbx)
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_O1/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 0x7a920
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), %r15d
movl 0x7c(%rdi), %eax
cmpl %eax, %r15d
jne 0x7a7b0
incl %r15d
testl %eax, %eax
je 0x7a750
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x7a755
movl $0x8, %edx
cmpl %r15d, %edx
cmovgl %edx, %r15d
cmpl %r15d, %eax
jge 0x7a7b0
movq %rcx, -0x30(%rbp)
movslq %r15d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x7a7a1
movslq 0x78(%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %rax, -0x38(%rbp)
callq 0xc080
movq 0x80(%r14), %rdi
callq 0x425d4
movq -0x38(%rbp), %rax
movq %rax, 0x80(%r14)
movl %r15d, 0x7c(%r14)
movq -0x30(%rbp), %rcx
movq 0x80(%r14), %rax
movslq 0x78(%r14), %rsi
movq (%r13), %rdx
movq %rdx, (%rax,%rsi,8)
movl 0x78(%r14), %r13d
movl 0x7c(%r14), %eax
leal 0x1(%r13), %edx
movl %edx, 0x78(%r14)
cmpl %eax, %edx
jne 0x7a847
addl $0x2, %r13d
testl %eax, %eax
je 0x7a7ec
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x7a7f1
movl $0x8, %edx
cmpl %r13d, %edx
cmovgl %edx, %r13d
cmpl %r13d, %eax
jge 0x7a847
movq %rcx, -0x30(%rbp)
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq %rax, %r15
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x7a838
movslq 0x78(%r14), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%r14), %rdi
callq 0x425d4
movq %r15, 0x80(%r14)
movl %r13d, 0x7c(%r14)
movq -0x30(%rbp), %rcx
movq 0x80(%r14), %rax
movslq 0x78(%r14), %rsi
movq (%r12), %rdx
movq %rdx, (%rax,%rsi,8)
movl 0x78(%r14), %r12d
movl 0x7c(%r14), %eax
leal 0x1(%r12), %edx
movl %edx, 0x78(%r14)
cmpl %eax, %edx
jne 0x7a8dd
addl $0x2, %r12d
testl %eax, %eax
je 0x7a884
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x7a889
movl $0x8, %edx
cmpl %r12d, %edx
cmovgl %edx, %r12d
cmpl %r12d, %eax
jge 0x7a8dd
movq %rcx, %r13
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq %rax, %r15
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x7a8cf
movslq 0x78(%r14), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x80(%r14), %rdi
callq 0x425d4
movq %r15, 0x80(%r14)
movl %r12d, 0x7c(%r14)
movq %r13, %rcx
movq 0x80(%r14), %rax
movslq 0x78(%r14), %rsi
movq (%rcx), %rdx
movq %rdx, (%rax,%rsi,8)
movl 0x78(%r14), %edx
incl %edx
movl %edx, 0x78(%r14)
movq 0x80(%r14), %rsi
movq %r14, %rdi
movl %ebx, %ecx
callq 0x78432
movl $0x0, 0x78(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7aa49
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
movss %xmm1, -0x20(%rbp)
jle 0x7a972
movl $0x200, %eax            # imm = 0x200
cmpl %eax, %ecx
cmovll %ecx, %eax
cmpl $0x4, %eax
movl $0x3, %edx
cmovgel %eax, %edx
jmp 0x7a9cc
cvttss2si %xmm3, %ecx
movq 0x38(%rbx), %rax
cmpl $0x3f, %ecx
jg 0x7a98c
movslq %ecx, %rcx
movzbl 0x90(%rax,%rcx), %edx
jmp 0x7a9cc
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, -0x1c(%rbp)
callq 0xc4d0
movss -0x1c(%rbp), %xmm3
movss 0x4dfd5(%rip), %xmm1    # 0xc8984
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0x200, %ecx            # imm = 0x200
cmpl %ecx, %eax
cmovll %eax, %ecx
cmpl $0xd, %ecx
movl $0xc, %edx
cmovgel %ecx, %edx
cmpl $0xc, %edx
jne 0x7a9f0
addss 0x3ceeb(%rip), %xmm3    # 0xb78c4
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
movl $0xb, %ecx
callq 0x787a2
jmp 0x7aa22
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
decl %edx
cvtsi2ss %edx, %xmm2
mulss 0x4df7f(%rip), %xmm2    # 0xc8984
divss %xmm0, %xmm2
addss 0x3ceb3(%rip), %xmm3    # 0xb78c4
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
callq 0x789ee
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x20(%rbp), %xmm0
callq 0x77886
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ab5b
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
jle 0x7aa9f
movl $0x200, %eax            # imm = 0x200
cmpl %eax, %ecx
cmovll %ecx, %eax
cmpl $0x4, %eax
movl $0x3, %edx
cmovgel %eax, %edx
jmp 0x7aaf9
cvttss2si %xmm3, %ecx
movq 0x38(%rbx), %rax
cmpl $0x3f, %ecx
jg 0x7aab9
movslq %ecx, %rcx
movzbl 0x90(%rax,%rcx), %edx
jmp 0x7aaf9
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, -0x1c(%rbp)
callq 0xc4d0
movss -0x1c(%rbp), %xmm3
movss 0x4dea8(%rip), %xmm1    # 0xc8984
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0x200, %ecx            # imm = 0x200
cmpl %ecx, %eax
cmovll %eax, %ecx
cmpl $0xd, %ecx
movl $0xc, %edx
cmovgel %ecx, %edx
cmpl $0xc, %edx
jne 0x7ab15
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
movl $0xb, %ecx
callq 0x787a2
jmp 0x7ab3f
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
decl %edx
cvtsi2ss %edx, %xmm2
mulss 0x4de5a(%rip), %xmm2    # 0xc8984
divss %xmm0, %xmm2
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm3, %xmm0
callq 0x789ee
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x78432
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7abe9
movq %rdi, %rbx
movss %xmm1, -0x14(%rbp)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss 0x3c432(%rip), %xmm2    # 0xb6fd0
addss %xmm1, %xmm2
mulss 0x4ddda(%rip), %xmm2    # 0xc8984
divss %xmm1, %xmm2
addss 0x3cd0e(%rip), %xmm0    # 0xb78c4
decl %ecx
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x789ee
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movss -0x14(%rbp), %xmm0
callq 0x77886
movl $0x0, 0x78(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ac56
movq %rdi, %rbx
cvtsi2ss %ecx, %xmm1
movss 0x3c3b2(%rip), %xmm2    # 0xb6fd0
addss %xmm1, %xmm2
mulss 0x4dd5a(%rip), %xmm2    # 0xc8984
divss %xmm1, %xmm2
decl %ecx
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x789ee
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x78432
movl $0x0, 0x78(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ad7a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r14d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movss %xmm0, -0x2c(%rbp)
movl 0x10(%rbp), %r9d
movl 0x78(%rdi), %r12d
movl 0x7c(%rdi), %eax
cmpl %eax, %r12d
jne 0x7ad1f
incl %r12d
testl %eax, %eax
je 0x7acb3
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x7acb8
movl $0x8, %edx
cmpl %r12d, %edx
cmovgl %edx, %r12d
cmpl %r12d, %eax
jge 0x7ad1f
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x7ad08
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
movq %rax, -0x38(%rbp)
callq 0xc080
movq 0x80(%rbx), %rdi
callq 0x425d4
movq -0x38(%rbp), %rax
movq %rax, 0x80(%rbx)
movl %r12d, 0x7c(%rbx)
movq -0x48(%rbp), %r8
movq -0x40(%rbp), %rcx
movl 0x10(%rbp), %r9d
movq 0x80(%rbx), %rax
movslq 0x78(%rbx), %rsi
movq (%r15), %rdx
movq %rdx, (%rax,%rsi,8)
incl 0x78(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x78d64
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movss -0x2c(%rbp), %xmm0
callq 0x77886
movl $0x0, 0x78(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop