LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierQuadratic(ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierQuadratic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, ImU32 col, float thickness, int num_segments)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

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

// Assembly:
cmpl $0x1000000, %r8d        # imm = 0x1000000
jb 0x7963e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
movss %xmm0, -0x30(%rbp)
jne 0x79589
leal 0x1(%rax), %r13d
testl %eax, %eax
movl %r9d, -0x2c(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
je 0x79592
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x79597
movq 0x80(%rbx), %r12
jmp 0x795ef
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 0x795d5
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
movl -0x2c(%rbp), %r9d
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
cltq
movq (%r15), %rsi
movq %rsi, (%r12,%rax,8)
incl 0x78(%rbx)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl %r9d, %ecx
callq 0x77b08
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movss -0x30(%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::AddImage(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

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

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

    if (push_texture_id)
        PopTextureID();
}

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

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

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

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x30(%rbp), %r14d
cmpl $0x1000000, %r14d       # imm = 0x1000000
jae 0x79f89
addq $0x28, %rsp
jmp 0x7a054
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movq %r9, -0x50(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rsi, 0x98(%rdi)
je 0x7a01a
movq %rbx, %rdi
callq 0x75d6a
movq %rbx, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x75e52
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq -0x50(%rbp), %r8
movq -0x30(%rbp), %r9
pushq %r14
pushq -0x38(%rbp)
pushq -0x40(%rbp)
pushq -0x48(%rbp)
callq 0x761c4
addq $0x20, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x75e06
movq %rbx, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x75e52
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq -0x50(%rbp), %r8
movq -0x30(%rbp), %r9
pushq %r14
pushq -0x38(%rbp)
pushq -0x40(%rbp)
pushq -0x48(%rbp)
callq 0x761c4
addq $0x48, %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::AddImageRounded(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddImageRounded(ImTextureID user_texture_id, const ImVec2& p_min, const ImVec2& p_max, const ImVec2& uv_min, const ImVec2& uv_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners)
{
    if ((col & IM_COL32_A_MASK) == 0)
        return;

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

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

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

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rbp), %ebx
cmpl $0x1000000, %ebx        # imm = 0x1000000
jae 0x7a082
addq $0x18, %rsp
jmp 0x7a0ba
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r12
movl 0x18(%rbp), %r14d
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
setb %al
testb $0xf, %r14b
setne %cl
testb %cl, %al
jne 0x7a0c5
subq $0x8, %rsp
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
pushq %rbx
callq 0x79e9e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl 0x68(%r12), %eax
testq %rax, %rax
je 0x7a0ef
testl %eax, %eax
jle 0x7a1d0
movq 0x70(%r12), %rcx
cmpq %rsi, -0x8(%rcx,%rax,8)
je 0x7a173
movq %r12, %rdi
movss %xmm0, -0x30(%rbp)
callq 0x75d6a
movl 0x20(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movss -0x30(%rbp), %xmm0
movl %r14d, %ecx
callq 0x77f54
movq 0x80(%r12), %rsi
movl 0x78(%r12), %edx
movq %r12, %rdi
movl %ebx, %ecx
callq 0x76d34
movl $0x0, 0x78(%r12)
movl 0x20(%r12), %edx
movq %r12, %rdi
movl -0x2c(%rbp), %esi
movq %r13, %rcx
movq %r15, %r8
movq -0x38(%rbp), %r9
pushq $0x1
pushq -0x40(%rbp)
callq 0x7a1ef
addq $0x10, %rsp
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x75e06
movl 0x20(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x77f54
movq 0x80(%r12), %rsi
movl 0x78(%r12), %edx
movq %r12, %rdi
movl %ebx, %ecx
callq 0x76d34
movl $0x0, 0x78(%r12)
movl 0x20(%r12), %edx
movq %r12, %rdi
movl -0x2c(%rbp), %esi
movq %r13, %rcx
movq %r15, %r8
movq -0x38(%rbp), %r9
pushq $0x1
pushq -0x40(%rbp)
callq 0x7a1ef
jmp 0x7a0b6
leaq 0x537d3(%rip), %rdi     # 0xcd9aa
leaq 0x3f4ad(%rip), %rsi     # 0xb968b
leaq 0x5490d(%rip), %rcx     # 0xceaf2
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSplitter::SetCurrentChannel(ImDrawList*, int)
void ImDrawListSplitter::SetCurrentChannel(ImDrawList* draw_list, int idx)
{
    IM_ASSERT(idx >= 0 && idx < _Count);
    if (_Current == idx)
        return;

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

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

// Assembly:
testl %edx, %edx
js 0x7aa6f
cmpl %edx, 0x4(%rdi)
jle 0x7aa6f
movslq (%rdi), %rax
cmpl %edx, %eax
jne 0x7a9b1
retq
movq 0x10(%rdi), %rcx
shlq $0x5, %rax
movups (%rsi), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0x10(%rdi), %rax
movslq (%rdi), %rcx
shlq $0x5, %rcx
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
movl %edx, (%rdi)
movq 0x10(%rdi), %rax
movl %edx, %ecx
shlq $0x5, %rcx
movups (%rax,%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x10(%rdi), %rax
movdqu 0x10(%rax,%rcx), %xmm0
movdqu %xmm0, 0x10(%rsi)
movslq 0x10(%rsi), %rax
addq %rax, %rax
addq 0x18(%rsi), %rax
movq %rax, 0x50(%rsi)
movslq (%rsi), %rax
testq %rax, %rax
je 0x7aa58
imulq $0x38, %rax, %rdx
addq 0x8(%rsi), %rdx
movq %rdx, %rax
addq $-0x38, %rax
je 0x7aa58
leaq 0x88(%rsi), %rcx
cmpl $0x0, -0x18(%rdx)
je 0x7aa60
movdqu (%rax), %xmm0
movdqu 0xc(%rax), %xmm1
movdqu (%rcx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu 0xc(%rcx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x7a9b0
movq %rsi, %rdi
jmp 0x757a8
movups (%rcx), %xmm0
movups 0xc(%rcx), %xmm1
movups %xmm1, 0xc(%rax)
movups %xmm0, (%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x52993(%rip), %rdi     # 0xcd40d
leaq 0x52725(%rip), %rsi     # 0xcd1a6
leaq 0x5299e(%rip), %rcx     # 0xcd426
movl $0x639, %edx            # imm = 0x639
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawData::ScaleClipRects(ImVec2 const&)
void ImDrawData::ScaleClipRects(const ImVec2& fb_scale)
{
    for (int i = 0; i < CmdListsCount; i++)
    {
        ImDrawList* cmd_list = CmdLists[i];
        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            ImDrawCmd* cmd = &cmd_list->CmdBuffer[cmd_i];
            cmd->ClipRect = ImVec4(cmd->ClipRect.x * fb_scale.x, cmd->ClipRect.y * fb_scale.y, cmd->ClipRect.z * fb_scale.x, cmd->ClipRect.w * fb_scale.y);
        }
    }
}

// Assembly:
movslq 0x10(%rdi), %rax
testq %rax, %rax
jle 0x7ad29
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movslq (%rdi), %r8
testq %r8, %r8
jle 0x7ad20
movq 0x8(%rdi), %rdi
imulq $0x38, %r8, %r8
xorl %r9d, %r9d
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss (%rdi,%r9), %xmm2
mulss %xmm0, %xmm2
movss 0x4(%rdi,%r9), %xmm3
mulss %xmm1, %xmm3
mulss 0x8(%rdi,%r9), %xmm0
mulss 0xc(%rdi,%r9), %xmm1
movss %xmm2, (%rdi,%r9)
movss %xmm3, 0x4(%rdi,%r9)
movss %xmm0, 0x8(%rdi,%r9)
movss %xmm1, 0xc(%rdi,%r9)
addq $0x38, %r9
cmpq %r9, %r8
jne 0x7acd0
incq %rdx
cmpq %rax, %rdx
jne 0x7acb9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontConfig::ImFontConfig()
ImFontConfig::ImFontConfig()
{
    FontData = NULL;
    FontDataSize = 0;
    FontDataOwnedByAtlas = true;
    FontNo = 0;
    SizePixels = 0.0f;
    OversampleH = 3; // FIXME: 2 may be a better default?
    OversampleV = 1;
    PixelSnapH = false;
    GlyphExtraSpacing = ImVec2(0.0f, 0.0f);
    GlyphOffset = ImVec2(0.0f, 0.0f);
    GlyphRanges = NULL;
    GlyphMinAdvanceX = 0.0f;
    GlyphMaxAdvanceX = FLT_MAX;
    MergeMode = false;
    RasterizerFlags = 0x00;
    RasterizerMultiply = 1.0f;
    EllipsisChar = (ImWchar)-1;
    memset(Name, 0, sizeof(Name));
    DstFont = NULL;
}

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
jne 0x7b11b
movq %rdi, %rbx
movl 0x60(%rdi), %eax
testl %eax, %eax
jle 0x7b042
movq 0x68(%rbx), %rcx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x7b030
cmpb $0x1, 0xc(%rcx,%r14)
jne 0x7b030
callq 0x41d3c
movslq 0x60(%rbx), %rax
cmpq %rax, %r15
jge 0x7b0fc
movq 0x68(%rbx), %rcx
movq $0x0, (%rcx,%r14)
incq %r15
movslq %eax, %rdx
addq $0x88, %r14
cmpq %rdx, %r15
jl 0x7b001
movslq 0x40(%rbx), %rcx
testq %rcx, %rcx
jle 0x7b09d
movq 0x48(%rbx), %rdx
movq 0x68(%rbx), %rdi
cltq
movq %rax, %rsi
shlq $0x7, %rsi
leaq (%rsi,%rax,8), %rax
addq %rdi, %rax
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
movq 0x48(%r8), %r9
cmpq %rdi, %r9
jb 0x7b093
cmpq %rax, %r9
jae 0x7b093
movq $0x0, 0x48(%r8)
movslq 0x40(%rbx), %r8
cmpq %r8, %rsi
jge 0x7b0e5
movq (%rdx,%rsi,8), %r8
movw $0x0, 0x50(%r8)
incq %rsi
cmpq %rsi, %rcx
jne 0x7b065
jmp 0x7b0a1
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x7b0b6
xorl %r14d, %r14d
movq %r14, 0x60(%rbx)
callq 0x41d3c
movq %r14, 0x68(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7b0cf
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
callq 0x41d3c
movq %r14, 0x58(%rbx)
movq $-0x1, 0x470(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e58c(%rip), %rdi     # 0xb9678
leaq 0x3e598(%rip), %rsi     # 0xb968b
leaq 0x3e5a7(%rip), %rcx     # 0xb96a1
jmp 0x7b111
leaq 0x3e575(%rip), %rdi     # 0xb9678
leaq 0x3e581(%rip), %rsi     # 0xb968b
leaq 0x53abc(%rip), %rcx     # 0xcebcd
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
leaq 0x52342(%rip), %rdi     # 0xcd464
leaq 0x5207d(%rip), %rsi     # 0xcd1a6
leaq 0x523aa(%rip), %rcx     # 0xcd4da
movl $0x712, %edx            # imm = 0x712
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearTexData()
void    ImFontAtlas::ClearTexData()
{
    IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
    if (TexPixelsAlpha8)
        IM_FREE(TexPixelsAlpha8);
    if (TexPixelsRGBA32)
        IM_FREE(TexPixelsRGBA32);
    TexPixelsAlpha8 = NULL;
    TexPixelsRGBA32 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
je 0x7b175
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x7b156
callq 0x41d3c
movq 0x20(%rbx), %rdi
addq $0x18, %rbx
testq %rdi, %rdi
je 0x7b168
callq 0x41d3c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x522e8(%rip), %rdi     # 0xcd464
leaq 0x52023(%rip), %rsi     # 0xcd1a6
leaq 0x52373(%rip), %rcx     # 0xcd4fd
movl $0x728, %edx            # imm = 0x728
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearFonts()
void    ImFontAtlas::ClearFonts()
{
    IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
    for (int i = 0; i < Fonts.Size; i++)
        IM_DELETE(Fonts[i]);
    Fonts.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
jne 0x7b1ff
movq %rdi, %rbx
movl 0x40(%rdi), %eax
testl %eax, %eax
jle 0x7b1db
xorl %r15d, %r15d
movq 0x48(%rbx), %rcx
movq (%rcx,%r15,8), %r14
testq %r14, %r14
je 0x7b1d0
movq %r14, %rdi
callq 0x81542
movq %r14, %rdi
callq 0x41d3c
movl 0x40(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x7b1b0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x7b1f4
xorl %r14d, %r14d
movq %r14, 0x40(%rbx)
callq 0x41d3c
movq %r14, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5225e(%rip), %rdi     # 0xcd464
leaq 0x51f99(%rip), %rsi     # 0xcd1a6
leaq 0x5230a(%rip), %rcx     # 0xcd51e
movl $0x733, %edx            # imm = 0x733
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::GetTexDataAsAlpha8(unsigned char**, int*, int*, int*)
void    ImFontAtlas::GetTexDataAsAlpha8(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
    // Build atlas on demand
    if (TexPixelsAlpha8 == NULL)
    {
        if (ConfigData.empty())
            AddFontDefault();
        Build();
    }

    *out_pixels = TexPixelsAlpha8;
    if (out_width) *out_width = TexWidth;
    if (out_height) *out_height = TexHeight;
    if (out_bytes_per_pixel) *out_bytes_per_pixel = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x18(%rdi), %rax
testq %rax, %rax
jne 0x7b261
cmpl $0x0, 0x60(%r15)
jne 0x7b255
movq %r15, %rdi
xorl %esi, %esi
callq 0x7b298
movq %r15, %rdi
callq 0x7b3d2
movq 0x18(%r15), %rax
movq %rax, (%r13)
testq %r12, %r12
je 0x7b272
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x7b27e
movl 0x2c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x7b289
movl $0x1, (%rbx)
addq $0x8, %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: ImFontAtlas::AddFontDefault(ImFontConfig const*)
ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template)
{
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    if (!font_cfg_template)
    {
        font_cfg.OversampleH = font_cfg.OversampleV = 1;
        font_cfg.PixelSnapH = true;
    }
    if (font_cfg.SizePixels <= 0.0f)
        font_cfg.SizePixels = 13.0f * 1.0f;
    if (font_cfg.Name[0] == '\0')
        ImFormatString(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "ProggyClean.ttf, %dpx", (int)font_cfg.SizePixels);
    font_cfg.EllipsisChar = (ImWchar)0x0085;
    font_cfg.GlyphOffset.y = 1.0f * IM_FLOOR(font_cfg.SizePixels / 13.0f);  // Add +1 offset per 13 units

    const char* ttf_compressed_base85 = GetDefaultCompressedFontDataTTFBase85();
    const ImWchar* glyph_ranges = font_cfg.GlyphRanges != NULL ? font_cfg.GlyphRanges : GetGlyphRangesDefault();
    ImFont* font = AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, font_cfg.SizePixels, &font_cfg, glyph_ranges);
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7b2d5
leaq -0x98(%rbp), %r14
movl $0x88, %edx
movq %r14, %rdi
callq 0xc080
movss 0x14(%r14), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7b344
jmp 0x7b356
xorl %eax, %eax
movq %rax, -0x98(%rbp)
movl %eax, -0x90(%rbp)
movb $0x1, %cl
movb %cl, -0x8c(%rbp)
movl %eax, -0x88(%rbp)
movq %rax, -0x60(%rbp)
movabsq $0x7f7fffff00000000, %rdx # imm = 0x7F7FFFFF00000000
movq %rdx, -0x58(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x74(%rbp)
movb $0x0, -0x50(%rbp)
movabsq $0x3f80000000000000, %rdx # imm = 0x3F80000000000000
movq %rdx, -0x4c(%rbp)
movw $0xffff, -0x44(%rbp)    # imm = 0xFFFF
movups %xmm0, -0x42(%rbp)
movups %xmm0, -0x32(%rbp)
movq %rax, -0x22(%rbp)
movq %rax, -0x18(%rbp)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, -0x80(%rbp)
movb %cl, -0x78(%rbp)
movl $0x41500000, -0x84(%rbp) # imm = 0x41500000
movss 0x4b606(%rip), %xmm0    # 0xc695c
cmpb $0x0, -0x42(%rbp)
jne 0x7b380
leaq -0x42(%rbp), %r14
cvttss2si %xmm0, %ecx
leaq 0x52298(%rip), %rdx     # 0xcd603
movl $0x28, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x41f22
movss -0x42(%r14), %xmm0
leaq -0x98(%rbp), %rdx
movw $0x85, 0x54(%rdx)
movaps %xmm0, %xmm1
divss 0x4b5c4(%rip), %xmm1    # 0xc695c
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, 0x30(%rdx)
movq 0x38(%rdx), %rax
testq %rax, %rax
leaq 0x4b7b6(%rip), %rcx     # 0xc6b68
cmovneq %rax, %rcx
leaq 0x4eec3(%rip), %rsi     # 0xca280
movq %rbx, %rdi
callq 0x7b7e2
addq $0x90, %rsp
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: ImFontAtlas::GetTexDataAsRGBA32(unsigned char**, int*, int*, int*)
void    ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
    // Convert to RGBA32 format on demand
    // Although it is likely to be the most commonly used format, our font rendering is 1 channel / 8 bpp
    if (!TexPixelsRGBA32)
    {
        unsigned char* pixels = NULL;
        GetTexDataAsAlpha8(&pixels, NULL, NULL);
        if (pixels)
        {
            TexPixelsRGBA32 = (unsigned int*)IM_ALLOC((size_t)TexWidth * (size_t)TexHeight * 4);
            const unsigned char* src = pixels;
            unsigned int* dst = TexPixelsRGBA32;
            for (int n = TexWidth * TexHeight; n > 0; n--)
                *dst++ = IM_COL32(255, 255, 255, (unsigned int)(*src++));
        }
    }

    *out_pixels = (unsigned char*)TexPixelsRGBA32;
    if (out_width) *out_width = TexWidth;
    if (out_height) *out_height = TexHeight;
    if (out_bytes_per_pixel) *out_bytes_per_pixel = 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x7b49f
movq %rsi, -0x30(%rbp)
leaq -0x38(%rbp), %r13
movq $0x0, (%r13)
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7b21e
movq (%r13), %r13
testq %r13, %r13
je 0x7b497
movslq 0x28(%r15), %rax
movslq 0x2c(%r15), %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x41c63
movq %rax, 0x20(%r15)
movl 0x2c(%r15), %ecx
imull 0x28(%r15), %ecx
testl %ecx, %ecx
jle 0x7b49b
incl %ecx
xorl %edx, %edx
movzbl (%r13,%rdx), %esi
shll $0x18, %esi
orl $0xffffff, %esi         # imm = 0xFFFFFF
movl %esi, (%rax,%rdx,4)
decl %ecx
incq %rdx
cmpl $0x1, %ecx
ja 0x7b479
jmp 0x7b49b
movq 0x20(%r15), %rax
movq -0x30(%rbp), %rsi
movq %rax, (%rsi)
testq %r12, %r12
je 0x7b4af
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x7b4bb
movl 0x2c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x7b4c6
movl $0x4, (%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: ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(char const*, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    int compressed_ttf_size = (((int)strlen(compressed_ttf_data_base85) + 4) / 5) * 4;
    void* compressed_ttf = IM_ALLOC((size_t)compressed_ttf_size);
    Decode85((const unsigned char*)compressed_ttf_data_base85, (unsigned char*)compressed_ttf);
    ImFont* font = AddFontFromMemoryCompressedTTF(compressed_ttf, compressed_ttf_size, size_pixels, font_cfg, glyph_ranges);
    IM_FREE(compressed_ttf);
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movss %xmm0, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
callq 0xc350
addl $0x4, %eax
cltq
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x21, %rax
addl %ecx, %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x41c63
movq %rax, %r13
movb (%r12), %cl
testb %cl, %cl
je 0x7b8d4
addq $0x5, %r12
movq %r13, %rax
movsbl %cl, %edx
xorl %ecx, %ecx
cmpb $0x5c, %dl
setge %cl
xorl $-0x23, %ecx
addl %edx, %ecx
movsbl -0x4(%r12), %esi
xorl %edx, %edx
cmpl $0x5c, %esi
setge %dl
xorl $-0x23, %edx
addl %esi, %edx
movsbl -0x3(%r12), %edi
xorl %esi, %esi
cmpl $0x5c, %edi
setge %sil
xorl $-0x23, %esi
addl %edi, %esi
movsbl -0x2(%r12), %edi
xorl %r8d, %r8d
cmpl $0x5c, %edi
setge %r8b
xorl $-0x23, %r8d
addl %edi, %r8d
movsbl -0x1(%r12), %edi
xorl %r9d, %r9d
cmpl $0x5c, %edi
setge %r9b
xorl $-0x23, %r9d
addl %edi, %r9d
imull $0x55, %r9d, %edi
addl %r8d, %edi
imull $0x55, %edi, %edi
addl %esi, %edi
imull $0x55, %edi, %esi
addl %edx, %esi
imull $0x55, %esi, %edx
addl %ecx, %edx
movl %edx, (%rax)
addq $0x4, %rax
movb (%r12), %cl
addq $0x5, %r12
testb %cl, %cl
jne 0x7b843
movq %r15, %rdi
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movq %r14, %rcx
movq %rbx, %r8
callq 0x7bbfa
movq %rax, %rbx
movq %r13, %rdi
callq 0x41d3c
movq %rbx, %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: ImFontAtlas::AddFontFromMemoryTTF(void*, int, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    IM_ASSERT(font_cfg.FontData == NULL);
    font_cfg.FontData = ttf_data;
    font_cfg.FontDataSize = ttf_size;
    font_cfg.SizePixels = size_pixels;
    if (glyph_ranges)
        font_cfg.GlyphRanges = glyph_ranges;
    return AddFont(&font_cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpb $0x1, (%rdi)
je 0x7bbdb
movq %r8, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x7bb25
leaq -0xb8(%rbp), %r13
movl $0x88, %edx
movq %r13, %rdi
movq %rcx, %rsi
movss %xmm0, -0x2c(%rbp)
callq 0xc080
movss -0x2c(%rbp), %xmm0
cmpq $0x0, (%r13)
je 0x7bb9b
leaq 0x51c03(%rip), %rdi     # 0xcd710
leaq 0x51692(%rip), %rsi     # 0xcd1a6
leaq 0x51b90(%rip), %rcx     # 0xcd6ab
movl $0x7c7, %edx            # imm = 0x7C7
callq 0xc140
xorl %eax, %eax
movq %rax, -0xb8(%rbp)
movl %eax, -0xb0(%rbp)
movb $0x1, -0xac(%rbp)
movl %eax, -0xa8(%rbp)
movabsq $0x100000003, %rcx      # imm = 0x100000003
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
movq %rax, -0x80(%rbp)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, -0x78(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, -0x94(%rbp)
movb %al, -0x70(%rbp)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, -0x6c(%rbp)
movw $0xffff, -0x64(%rbp)    # imm = 0xFFFF
movups %xmm1, -0x62(%rbp)
movups %xmm1, -0x52(%rbp)
movq %rax, -0x42(%rbp)
movq %rax, -0x38(%rbp)
movq %r12, -0xb8(%rbp)
movl %r15d, -0xb0(%rbp)
movss %xmm0, -0xa4(%rbp)
testq %rbx, %rbx
je 0x7bbba
movq %rbx, -0x80(%rbp)
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x7b4d6
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51882(%rip), %rdi     # 0xcd464
leaq 0x515bd(%rip), %rsi     # 0xcd1a6
leaq 0x51abb(%rip), %rcx     # 0xcd6ab
movl $0x7c5, %edx            # imm = 0x7C5
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddCustomRectRegular(int, int)
int ImFontAtlas::AddCustomRectRegular(int width, int height)
{
    IM_ASSERT(width > 0 && width <= 0xFFFF);
    IM_ASSERT(height > 0 && height <= 0xFFFF);
    ImFontAtlasCustomRect r;
    r.Width = (unsigned short)width;
    r.Height = (unsigned short)height;
    CustomRects.push_back(r);
    return CustomRects.Size - 1; // Return index
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
leal -0x1(%r15), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7c0a2
movl %edx, %r14d
leal -0x1(%r14), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7c0c1
movq %rdi, %rbx
movl 0x50(%rdi), %eax
cmpl 0x54(%rdi), %eax
jne 0x7c010
leal 0x1(%rax), %r13d
testl %eax, %eax
je 0x7c016
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7c01b
movq 0x58(%rbx), %r12
jmp 0x7c05e
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x5, %rdi
callq 0x41c63
movq %rax, %r12
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x7c053
movslq 0x50(%rbx), %rdx
shlq $0x5, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x58(%rbx), %rdi
callq 0x41d3c
movq %r12, 0x58(%rbx)
movl %r13d, 0x54(%rbx)
movl 0x50(%rbx), %eax
cltq
shlq $0x5, %rax
movw %r15w, (%r12,%rax)
movw %r14w, 0x2(%r12,%rax)
movl $0xffffffff, 0x4(%r12,%rax) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12,%rax)
movq $0x0, 0x18(%r12,%rax)
movl 0x50(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x516f8(%rip), %rdi     # 0xcd7a1
leaq 0x510f6(%rip), %rsi     # 0xcd1a6
leaq 0x51707(%rip), %rcx     # 0xcd7be
movl $0x7e8, %edx            # imm = 0x7E8
callq 0xc140
leaq 0x51726(%rip), %rdi     # 0xcd7ee
leaq 0x510d7(%rip), %rsi     # 0xcd1a6
leaq 0x516e8(%rip), %rcx     # 0xcd7be
movl $0x7e9, %edx            # imm = 0x7E9
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddCustomRectFontGlyph(ImFont*, unsigned short, int, int, float, ImVec2 const&)
int ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset)
{
#ifdef IMGUI_USE_WCHAR32
    IM_ASSERT(id <= IM_UNICODE_CODEPOINT_MAX);
#endif
    IM_ASSERT(font != NULL);
    IM_ASSERT(width > 0 && width <= 0xFFFF);
    IM_ASSERT(height > 0 && height <= 0xFFFF);
    ImFontAtlasCustomRect r;
    r.Width = (unsigned short)width;
    r.Height = (unsigned short)height;
    r.GlyphID = id;
    r.GlyphAdvanceX = advance_x;
    r.GlyphOffset = offset;
    r.Font = font;
    CustomRects.push_back(r);
    return CustomRects.Size - 1; // Return index
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x7c1fc
movl %ecx, %r12d
leal -0x1(%r12), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7c21b
movl %r8d, %r15d
leal -0x1(%r15), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7c23a
movq %rdi, %rbx
movq (%r9), %rdi
movl 0x50(%rbx), %eax
cmpl 0x54(%rbx), %eax
jne 0x7c152
leal 0x1(%rax), %r14d
testl %eax, %eax
movss %xmm0, -0x30(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
je 0x7c158
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7c15d
movq 0x58(%rbx), %r13
jmp 0x7c1b0
movl $0x8, %ecx
cmpl %r14d, %ecx
cmovgl %ecx, %r14d
movslq %r14d, %rdi
shlq $0x5, %rdi
callq 0x41c63
movq %rax, %r13
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x7c195
movslq 0x50(%rbx), %rdx
shlq $0x5, %rdx
movq %r13, %rdi
callq 0xc080
movq 0x58(%rbx), %rdi
callq 0x41d3c
movq %r13, 0x58(%rbx)
movl %r14d, 0x54(%rbx)
movl 0x50(%rbx), %eax
movss -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rdi
movzwl %dx, %ecx
cltq
shlq $0x5, %rax
movw %r12w, (%r13,%rax)
movw %r15w, 0x2(%r13,%rax)
movl $0xffffffff, 0x4(%r13,%rax) # imm = 0xFFFFFFFF
movl %ecx, 0x8(%r13,%rax)
movss %xmm0, 0xc(%r13,%rax)
movq %rdi, 0x10(%r13,%rax)
movq %rsi, 0x18(%r13,%rax)
movl 0x50(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x50(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5160a(%rip), %rdi     # 0xcd80d
leaq 0x50f9c(%rip), %rsi     # 0xcd1a6
leaq 0x5160b(%rip), %rcx     # 0xcd81c
movl $0x7f6, %edx            # imm = 0x7F6
callq 0xc140
leaq 0x5157f(%rip), %rdi     # 0xcd7a1
leaq 0x50f7d(%rip), %rsi     # 0xcd1a6
leaq 0x515ec(%rip), %rcx     # 0xcd81c
movl $0x7f7, %edx            # imm = 0x7F7
callq 0xc140
leaq 0x515ad(%rip), %rdi     # 0xcd7ee
leaq 0x50f5e(%rip), %rsi     # 0xcd1a6
leaq 0x515cd(%rip), %rcx     # 0xcd81c
movl $0x7f8, %edx            # imm = 0x7F8
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::CalcCustomRectUV(ImFontAtlasCustomRect const*, ImVec2*, ImVec2*) const
void ImFontAtlas::CalcCustomRectUV(const ImFontAtlasCustomRect* rect, ImVec2* out_uv_min, ImVec2* out_uv_max) const
{
    IM_ASSERT(TexWidth > 0 && TexHeight > 0);   // Font atlas needs to be built before we can calculate UV coordinates
    IM_ASSERT(rect->IsPacked());                // Make sure the rectangle has been packed
    *out_uv_min = ImVec2((float)rect->X * TexUvScale.x, (float)rect->Y * TexUvScale.y);
    *out_uv_max = ImVec2((float)(rect->X + rect->Width) * TexUvScale.x, (float)(rect->Y + rect->Height) * TexUvScale.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x28(%rdi)
jle 0x7c2cc
cmpl $0x0, 0x2c(%rdi)
jle 0x7c2cc
movzwl 0x4(%rsi), %eax
cmpw $-0x1, %ax
je 0x7c2eb
movzwl %ax, %eax
cvtsi2ss %eax, %xmm0
movzwl 0x6(%rsi), %eax
cvtsi2ss %eax, %xmm1
mulss 0x30(%rdi), %xmm0
mulss 0x34(%rdi), %xmm1
movss %xmm0, (%rdx)
movss %xmm1, 0x4(%rdx)
movzwl 0x4(%rsi), %eax
movzwl (%rsi), %edx
addl %eax, %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
mulss 0x30(%rdi), %xmm0
movzwl 0x6(%rsi), %eax
movzwl 0x2(%rsi), %edx
addl %eax, %edx
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
mulss 0x34(%rdi), %xmm1
movss %xmm0, (%rcx)
movss %xmm1, 0x4(%rcx)
popq %rbp
retq
leaq 0x515a5(%rip), %rdi     # 0xcd878
leaq 0x50ecc(%rip), %rsi     # 0xcd1a6
leaq 0x515b5(%rip), %rcx     # 0xcd896
movl $0x806, %edx            # imm = 0x806
callq 0xc140
leaq 0x51600(%rip), %rdi     # 0xcd8f2
leaq 0x50ead(%rip), %rsi     # 0xcd1a6
leaq 0x51596(%rip), %rcx     # 0xcd896
movl $0x807, %edx            # imm = 0x807
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::GetMouseCursorTexData(int, ImVec2*, ImVec2*, ImVec2*, ImVec2*)
bool ImFontAtlas::GetMouseCursorTexData(ImGuiMouseCursor cursor_type, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2])
{
    if (cursor_type <= ImGuiMouseCursor_None || cursor_type >= ImGuiMouseCursor_COUNT)
        return false;
    if (Flags & ImFontAtlasFlags_NoMouseCursors)
        return false;

    IM_ASSERT(PackIdMouseCursors != -1);
    ImFontAtlasCustomRect* r = GetCustomRectByIndex(PackIdMouseCursors);
    ImVec2 pos = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][0] + ImVec2((float)r->X, (float)r->Y);
    ImVec2 size = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][1];
    *out_size = size;
    *out_offset = FONT_ATLAS_DEFAULT_TEX_CURSOR_DATA[cursor_type][2];
    out_uv_border[0] = (pos) * TexUvScale;
    out_uv_border[1] = (pos + size) * TexUvScale;
    pos.x += FONT_ATLAS_DEFAULT_TEX_DATA_W + 1;
    out_uv_fill[0] = (pos) * TexUvScale;
    out_uv_fill[1] = (pos + size) * TexUvScale;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x8, %esi
ja 0x7c416
movq %rdi, %r14
testb $0x2, 0x4(%rdi)
jne 0x7c416
movl %esi, %ebx
movq %r9, -0x30(%rbp)
movl 0x470(%r14), %esi
cmpl $-0x1, %esi
je 0x7c427
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %r14, %rdi
callq 0x85f1e
movl %ebx, %ecx
movzwl 0x4(%rax), %edx
cvtsi2ss %edx, %xmm0
movzwl 0x6(%rax), %eax
cvtsi2ss %eax, %xmm1
leaq (%rcx,%rcx,2), %rax
leaq 0x4a71e(%rip), %rcx     # 0xc6a90
addss (%rcx,%rax,8), %xmm0
addss 0x4(%rcx,%rax,8), %xmm1
movss 0x8(%rcx,%rax,8), %xmm2
movq 0x8(%rcx,%rax,8), %rdx
movq 0x10(%rcx,%rax,8), %rsi
movq %rdx, (%r13)
movq %rsi, (%r12)
movss 0x30(%r14), %xmm3
mulss %xmm0, %xmm3
movss 0x34(%r14), %xmm4
mulss %xmm1, %xmm4
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
movlps %xmm3, (%r15)
movaps %xmm0, %xmm3
addss %xmm2, %xmm3
movss 0xc(%rcx,%rax,8), %xmm4
addss %xmm1, %xmm4
mulss 0x30(%r14), %xmm3
movss 0x34(%r14), %xmm5
mulss %xmm4, %xmm5
unpcklps %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
addss 0x4a584(%rip), %xmm0    # 0xc6960
movlps %xmm3, 0x8(%r15)
movss 0x30(%r14), %xmm3
mulss 0x34(%r14), %xmm1
mulss %xmm0, %xmm3
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movq -0x30(%rbp), %rax
movlps %xmm3, (%rax)
addss %xmm2, %xmm0
mulss 0x30(%r14), %xmm0
mulss 0x34(%r14), %xmm4
unpcklps %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movlps %xmm0, 0x8(%rax)
movb $0x1, %al
jmp 0x7c418
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x514d5(%rip), %rdi     # 0xcd903
leaq 0x50d71(%rip), %rsi     # 0xcd1a6
leaq 0x514e0(%rip), %rcx     # 0xcd91c
movl $0x813, %edx            # imm = 0x813
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlasBuildMultiplyRectAlpha8(unsigned char const*, unsigned char*, int, int, int, int, int)
void    ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride)
{
    unsigned char* data = pixels + x + y * stride;
    for (int j = h; j > 0; j--, data += stride)
        for (int i = 0; i < w; i++)
            data[i] = table[data[i]];
}

// Assembly:
testl %r9d, %r9d
jle 0x7f7c9
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %r10d
movslq %edx, %rax
addq %rax, %rsi
imull %r10d, %ecx
movslq %ecx, %rax
addq %rsi, %rax
movslq %r10d, %rcx
movl %r8d, %edx
testl %r8d, %r8d
jle 0x7f7b8
xorl %esi, %esi
movzbl (%rax,%rsi), %r10d
movb (%rdi,%r10), %r10b
movb %r10b, (%rax,%rsi)
incq %rsi
cmpq %rsi, %rdx
jne 0x7f7a3
leal -0x1(%r9), %esi
addq %rcx, %rax
cmpl $0x1, %r9d
movl %esi, %r9d
jg 0x7f79c
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlasBuildInit(ImFontAtlas*)
void ImFontAtlasBuildInit(ImFontAtlas* atlas)
{
    // Register texture region for mouse cursors or standard white pixels
    if (atlas->PackIdMouseCursors < 0)
    {
        if (!(atlas->Flags & ImFontAtlasFlags_NoMouseCursors))
            atlas->PackIdMouseCursors = atlas->AddCustomRectRegular(FONT_ATLAS_DEFAULT_TEX_DATA_W * 2 + 1, FONT_ATLAS_DEFAULT_TEX_DATA_H);
        else
            atlas->PackIdMouseCursors = atlas->AddCustomRectRegular(2, 2);
    }

    // Register texture region for thick lines
    // The +2 here is to give space for the end caps, whilst height +1 is to accommodate the fact we have a zero-width row
    if (atlas->PackIdLines < 0)
    {
        if (!(atlas->Flags & ImFontAtlasFlags_NoBakedLines))
            atlas->PackIdLines = atlas->AddCustomRectRegular(IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 2, IM_DRAWLIST_TEX_LINES_WIDTH_MAX + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x470(%rdi)
jns 0x7f809
testb $0x2, 0x4(%rbx)
jne 0x7f7f1
movq %rbx, %rdi
movl $0xd9, %esi
movl $0x1b, %edx
jmp 0x7f7fe
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x7bfbe
movl %eax, 0x470(%rbx)
cmpl $0x0, 0x474(%rbx)
jns 0x7f830
testb $0x4, 0x4(%rbx)
jne 0x7f830
movq %rbx, %rdi
movl $0x41, %esi
movl $0x40, %edx
callq 0x7bfbe
movl %eax, 0x474(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlasBuildSetupFont(ImFontAtlas*, ImFont*, ImFontConfig*, float, float)
void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent)
{
    if (!font_config->MergeMode)
    {
        font->ClearOutputData();
        font->FontSize = font_config->SizePixels;
        font->ConfigData = font_config;
        font->ConfigDataCount = 0;
        font->ContainerAtlas = atlas;
        font->Ascent = ascent;
        font->Descent = descent;
    }
    font->ConfigDataCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x1, 0x48(%rdx)
jne 0x8033b
movl 0x50(%rbx), %eax
incl %eax
jmp 0x8037e
movq %rdx, %r14
movq %rdi, %r15
movq %rbx, %rdi
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
callq 0x80b54
movss 0x14(%r14), %xmm0
movss %xmm0, 0x14(%rbx)
movq %r14, 0x48(%rbx)
movq %r15, 0x40(%rbx)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x5c(%rbx)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x60(%rbx)
movw $0x1, %ax
movw %ax, 0x50(%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: ImFont::ClearOutputData()
void    ImFont::ClearOutputData()
{
    FontSize = 0.0f;
    FallbackAdvanceX = 0.0f;
    Glyphs.clear();
    IndexAdvanceX.clear();
    IndexLookup.clear();
    FallbackGlyph = NULL;
    ContainerAtlas = NULL;
    DirtyLookupTables = true;
    Ascent = Descent = 0.0f;
    MetricsTotalSurface = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x10(%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x80b7f
xorl %r14d, %r14d
movq %r14, 0x28(%rbx)
callq 0x41d3c
movq %r14, 0x30(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x80b97
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x41d3c
movq %r14, 0x8(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x80bb0
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
callq 0x41d3c
movq %r14, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movb $0x1, 0x56(%rbx)
movq $0x0, 0x5c(%rbx)
movl $0x0, 0x64(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlasBuildRender1bppRectFromString(ImFontAtlas*, int, int, int, int, char const*, char, unsigned char)
void ImFontAtlasBuildRender1bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned char in_marker_pixel_value)
{
    IM_ASSERT(x >= 0 && x + w <= atlas->TexWidth);
    IM_ASSERT(y >= 0 && y + h <= atlas->TexHeight);
    unsigned char* out_pixel = atlas->TexPixelsAlpha8 + x + (y * atlas->TexWidth);
    for (int off_y = 0; off_y < h; off_y++, out_pixel += atlas->TexWidth, in_str += w)
        for (int off_x = 0; off_x < w; off_x++)
            out_pixel[off_x] = (in_str[off_x] == in_marker_char) ? in_marker_pixel_value : 0x00;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x80c65
leal (%rcx,%rsi), %r10d
movl 0x28(%rdi), %eax
cmpl %eax, %r10d
jg 0x80c65
testl %edx, %edx
js 0x80c84
leal (%r8,%rdx), %r10d
cmpl 0x2c(%rdi), %r10d
jg 0x80c84
testl %r8d, %r8d
jle 0x80c5a
movl %esi, %r10d
addq 0x18(%rdi), %r10
movb 0x10(%rbp), %sil
imull %eax, %edx
movslq %edx, %rdx
addq %r10, %rdx
movslq %ecx, %r10
movl %r10d, %r11d
xorl %ebx, %ebx
movzbl 0x18(%rbp), %r14d
testl %ecx, %ecx
jle 0x80c4a
xorl %eax, %eax
movl %r14d, %r15d
cmpb %sil, (%r9,%rax)
je 0x80c3b
xorl %r15d, %r15d
movb %r15b, (%rdx,%rax)
incq %rax
cmpq %rax, %r11
jne 0x80c2f
movl 0x28(%rdi), %eax
incl %ebx
movslq %eax, %r15
addq %r15, %rdx
addq %r10, %r9
cmpl %r8d, %ebx
jne 0x80c29
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4cf2e(%rip), %rdi     # 0xcdb9a
leaq 0x4c533(%rip), %rsi     # 0xcd1a6
leaq 0x4cf43(%rip), %rcx     # 0xcdbbd
movl $0x986, %edx            # imm = 0x986
callq 0xc140
leaq 0x4cfa6(%rip), %rdi     # 0xcdc31
leaq 0x4c514(%rip), %rsi     # 0xcd1a6
leaq 0x4cf24(%rip), %rcx     # 0xcdbbd
movl $0x987, %edx            # imm = 0x987
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontGlyphRangesBuilder::AddText(char const*, char const*)
void ImFontGlyphRangesBuilder::AddText(const char* text, const char* text_end)
{
    while (text_end ? (text < text_end) : *text)
    {
        unsigned int c = 0;
        int c_len = ImTextCharFromUtf8(&c, text, text_end);
        text += c_len;
        if (c_len == 0)
            break;
        AddChar((ImWchar)c);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x24(%rbp), %r12
testq %rbx, %rbx
je 0x81207
xorl %eax, %eax
cmpq %rbx, %r14
setb %al
jmp 0x8120b
movsbl (%r14), %eax
testl %eax, %eax
je 0x8124e
movl $0x0, -0x24(%rbp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x40f80
testl %eax, %eax
je 0x8124e
movl -0x24(%rbp), %ecx
movzwl %cx, %edx
shrl $0x5, %edx
cmpl %edx, (%r15)
jle 0x8125b
cltq
addq %rax, %r14
movl $0x1, %eax
shll %cl, %eax
movq 0x8(%r15), %rcx
movzwl %dx, %edx
orl %eax, (%rcx,%rdx,4)
jmp 0x811f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38416(%rip), %rdi     # 0xb9678
leaq 0x38422(%rip), %rsi     # 0xb968b
leaq 0x4d533(%rip), %rcx     # 0xce7a3
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140