LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ae8b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movss %xmm0, -0x30(%rbp)
movl 0x78(%rdi), %r12d
movl 0x7c(%rdi), %eax
cmpl %eax, %r12d
jne 0x7ae33
incl %r12d
testl %eax, %eax
je 0x7adcb
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x7add0
movl $0x8, %edx
cmpl %r12d, %edx
cmovgl %edx, %r12d
cmpl %r12d, %eax
jge 0x7ae33
movq %rcx, -0x40(%rbp)
movl %r9d, -0x2c(%rbp)
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x424fb
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x7ae20
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)
movl -0x2c(%rbp), %r9d
movq -0x40(%rbp), %rcx
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
movl %r9d, %ecx
callq 0x7929c
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movss -0x30(%rbp), %xmm0
callq 0x77886
movl $0x0, 0x78(%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::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 0x7b728
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 0x7b789
movq %r12, %rdi
callq 0x77348
movq %r12, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x77438
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
callq 0x776c2
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x773ea
movq %r12, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x77438
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 0x776c2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b7e9
addq $0x28, %rsp
jmp 0x7b8b4
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 0x7b87a
movq %rbx, %rdi
callq 0x77348
movq %rbx, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x77438
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 0x777b4
addq $0x20, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x773ea
movq %rbx, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x77438
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 0x777b4
addq $0x48, %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::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 0x7b8e2
addq $0x18, %rsp
jmp 0x7b91a
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 0x7b925
subq $0x8, %rsp
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
pushq %rbx
callq 0x7b6fe
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 0x7b94f
testl %eax, %eax
jle 0x7ba30
movq 0x70(%r12), %rcx
cmpq %rsi, -0x8(%rcx,%rax,8)
je 0x7b9d3
movq %r12, %rdi
movss %xmm0, -0x30(%rbp)
callq 0x77348
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 0x79698
movq 0x80(%r12), %rsi
movl 0x78(%r12), %edx
movq %r12, %rdi
movl %ebx, %ecx
callq 0x78432
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 0x7ba4f
addq $0x10, %rsp
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x773ea
movl 0x20(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x79698
movq 0x80(%r12), %rsi
movl 0x78(%r12), %edx
movq %r12, %rdi
movl %ebx, %ecx
callq 0x78432
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 0x7ba4f
jmp 0x7b916
leaq 0x53fa3(%rip), %rdi     # 0xcf9da
leaq 0x3fc4d(%rip), %rsi     # 0xbb68b
leaq 0x55111(%rip), %rcx     # 0xd0b56
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImGui::ShadeVertsLinearUV(ImDrawList*, int, int, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, bool)
void ImGui::ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp)
{
    const ImVec2 size = b - a;
    const ImVec2 uv_size = uv_b - uv_a;
    const ImVec2 scale = ImVec2(
        size.x != 0.0f ? (uv_size.x / size.x) : 0.0f,
        size.y != 0.0f ? (uv_size.y / size.y) : 0.0f);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movss (%r8), %xmm0
movss 0x4(%r8), %xmm1
subss (%rcx), %xmm0
subss 0x4(%rcx), %xmm1
movss (%rax), %xmm7
movss 0x4(%rax), %xmm5
movss (%r9), %xmm8
movss 0x4(%r9), %xmm6
movaps %xmm7, %xmm2
subss %xmm8, %xmm2
movaps %xmm5, %xmm3
subss %xmm6, %xmm3
divss %xmm0, %xmm2
xorps %xmm4, %xmm4
cmpneqss %xmm4, %xmm0
andps %xmm2, %xmm0
divss %xmm1, %xmm3
cmpneqss %xmm4, %xmm1
andps %xmm3, %xmm1
movq 0x28(%rdi), %rdi
movslq %esi, %rax
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,4), %rax
movslq %edx, %r8
leaq (%r8,%r8,4), %r8
leaq (%rdi,%r8,4), %rdi
cmpb $0x0, 0x18(%rbp)
je 0x7bb7a
cmpl %edx, %esi
jge 0x7bbb3
movaps %xmm8, %xmm2
minss %xmm7, %xmm2
movaps %xmm6, %xmm3
minss %xmm5, %xmm3
movaps %xmm7, %xmm4
cmpless %xmm8, %xmm4
andps %xmm4, %xmm8
andnps %xmm7, %xmm4
orps %xmm8, %xmm4
movaps %xmm5, %xmm7
cmpless %xmm6, %xmm7
andps %xmm7, %xmm6
andnps %xmm5, %xmm7
orps %xmm6, %xmm7
movss (%rax), %xmm5
movss 0x4(%rax), %xmm6
subss (%rcx), %xmm5
subss 0x4(%rcx), %xmm6
mulss %xmm0, %xmm5
mulss %xmm1, %xmm6
addss (%r9), %xmm5
addss 0x4(%r9), %xmm6
movaps %xmm7, %xmm8
minss %xmm6, %xmm8
cmpltss %xmm3, %xmm6
movaps %xmm6, %xmm9
andnps %xmm8, %xmm9
andps %xmm3, %xmm6
orps %xmm9, %xmm6
movaps %xmm4, %xmm8
minss %xmm5, %xmm8
cmpltss %xmm2, %xmm5
movaps %xmm5, %xmm9
andnps %xmm8, %xmm9
andps %xmm2, %xmm5
orps %xmm9, %xmm5
unpcklps %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1]
movlps %xmm5, 0x8(%rax)
addq $0x14, %rax
cmpq %rdi, %rax
jb 0x7bb09
jmp 0x7bbb3
cmpl %edx, %esi
jge 0x7bbb3
movss (%rax), %xmm2
movss 0x4(%rax), %xmm3
subss (%rcx), %xmm2
subss 0x4(%rcx), %xmm3
mulss %xmm0, %xmm2
mulss %xmm1, %xmm3
addss (%r9), %xmm2
addss 0x4(%r9), %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movlps %xmm2, 0x8(%rax)
addq $0x14, %rax
cmpq %rdi, %rax
jb 0x7bb7e
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c38c
cmpl %edx, 0x4(%rdi)
jle 0x7c38c
movslq (%rdi), %rax
cmpl %edx, %eax
jne 0x7c2c7
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 0x7c334
movq 0x8(%rsi), %rcx
imulq $0x38, %rax, %rax
addq %rcx, %rax
addq $-0x38, %rax
jmp 0x7c336
xorl %eax, %eax
testq %rax, %rax
je 0x7c375
leaq 0x88(%rsi), %rcx
cmpl $0x0, 0x20(%rax)
je 0x7c37d
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 0x7c2c6
movq %rsi, %rdi
jmp 0x76d7e
movups (%rcx), %xmm0
movups 0xc(%rcx), %xmm1
movups %xmm1, 0xc(%rax)
movups %xmm0, (%rax)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x530a6(%rip), %rdi     # 0xcf43d
leaq 0x52e38(%rip), %rsi     # 0xcf1d6
leaq 0x530b1(%rip), %rcx     # 0xcf456
movl $0x639, %edx            # imm = 0x639
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c63d
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movslq (%rdi), %r8
testq %r8, %r8
jle 0x7c634
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 0x7c5e4
incq %rdx
cmpq %rax, %rdx
jne 0x7c5cd
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movb $0x1, 0xc(%rdi)
movaps 0x4c19e(%rip), %xmm1    # 0xc8950
movups %xmm1, 0x10(%rdi)
movb %al, 0x20(%rdi)
movq %rax, 0x38(%rdi)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, 0x40(%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_O1/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
addq $0x30, %rdi
movl $0x440, %edx            # imm = 0x440
xorl %esi, %esi
callq 0xc260
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movl $0x1, 0x14(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movq $0x0, 0x38(%rbx)
movq $-0x1, 0x470(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ca2b
movq %rdi, %rbx
movl 0x60(%rdi), %esi
testl %esi, %esi
jle 0x7c953
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x7c940
cmpb $0x1, 0xc(%rax,%r14)
jne 0x7c940
callq 0x425d4
movslq 0x60(%rbx), %rax
cmpq %rax, %r15
jge 0x7ca0c
movq 0x68(%rbx), %rax
movq $0x0, (%rax,%r14)
incq %r15
movslq 0x60(%rbx), %rsi
addq $0x88, %r14
cmpq %rsi, %r15
jl 0x7c90d
movslq 0x40(%rbx), %rax
testq %rax, %rax
jle 0x7c9ad
movq 0x48(%rbx), %rcx
movq 0x68(%rbx), %rdx
movslq %esi, %rsi
movq %rsi, %rdi
shlq $0x7, %rdi
leaq (%rdi,%rsi,8), %rsi
addq %rdx, %rsi
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
movq 0x48(%r8), %r9
cmpq %rdx, %r9
jb 0x7c9a5
cmpq %rsi, %r9
jae 0x7c9a5
movq $0x0, 0x48(%r8)
movslq 0x40(%rbx), %r8
cmpq %r8, %rdi
jge 0x7c9f5
movq (%rcx,%rdi,8), %r8
movw $0x0, 0x50(%r8)
incq %rdi
cmpq %rdi, %rax
jne 0x7c977
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x7c9c6
xorl %r14d, %r14d
movq %r14, 0x60(%rbx)
callq 0x425d4
movq %r14, 0x68(%rbx)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7c9df
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
callq 0x425d4
movq %r14, 0x58(%rbx)
movq $-0x1, 0x470(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ec7c(%rip), %rdi     # 0xbb678
leaq 0x3ec88(%rip), %rsi     # 0xbb68b
leaq 0x3ec97(%rip), %rcx     # 0xbb6a1
jmp 0x7ca21
leaq 0x3ec65(%rip), %rdi     # 0xbb678
leaq 0x3ec71(%rip), %rsi     # 0xbb68b
leaq 0x54210(%rip), %rcx     # 0xd0c31
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
leaq 0x52a62(%rip), %rdi     # 0xcf494
leaq 0x5279d(%rip), %rsi     # 0xcf1d6
leaq 0x52aca(%rip), %rcx     # 0xcf50a
movl $0x712, %edx            # imm = 0x712
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ca85
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x7ca66
callq 0x425d4
movq 0x20(%rbx), %rdi
addq $0x18, %rbx
testq %rdi, %rdi
je 0x7ca78
callq 0x425d4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x52a08(%rip), %rdi     # 0xcf494
leaq 0x52743(%rip), %rsi     # 0xcf1d6
leaq 0x52a93(%rip), %rcx     # 0xcf52d
movl $0x728, %edx            # imm = 0x728
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7cb0c
movq %rdi, %rbx
cmpl $0x0, 0x40(%rdi)
jle 0x7cae8
xorl %r15d, %r15d
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x7cadc
movq %r14, %rdi
callq 0x8307c
movq %r14, %rdi
callq 0x425d4
incq %r15
movslq 0x40(%rbx), %rax
cmpq %rax, %r15
jl 0x7cabf
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x7cb01
xorl %r14d, %r14d
movq %r14, 0x40(%rbx)
callq 0x425d4
movq %r14, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52981(%rip), %rdi     # 0xcf494
leaq 0x526bc(%rip), %rsi     # 0xcf1d6
leaq 0x52a2d(%rip), %rcx     # 0xcf54e
movl $0x733, %edx            # imm = 0x733
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x18(%rdi)
jne 0x7cb69
cmpl $0x0, 0x60(%r15)
jne 0x7cb61
movq %r15, %rdi
xorl %esi, %esi
callq 0x7cba4
movq %r15, %rdi
callq 0x7cce4
movq 0x18(%r15), %rax
movq %rax, (%r13)
testq %r12, %r12
je 0x7cb7e
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x7cb8a
movl 0x2c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x7cb95
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_O1/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 %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x7cbd3
leaq -0x98(%rbp), %rdi
movl $0x88, %edx
movq %r14, %rsi
callq 0xc080
jmp 0x7cc3e
xorl %eax, %eax
movq %rax, -0x98(%rbp)
movl $0x0, -0x90(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x74(%rbp)
movb $0x1, -0x8c(%rbp)
movaps 0x4bd55(%rip), %xmm1    # 0xc8950
movups %xmm1, -0x88(%rbp)
movb %al, -0x78(%rbp)
movq %rax, -0x60(%rbp)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, -0x4c(%rbp)
movw $0xffff, -0x44(%rbp)    # imm = 0xFFFF
movups %xmm0, -0x42(%rbp)
movups %xmm0, -0x32(%rbp)
movq %rax, -0x22(%rbp)
movq %rax, -0x18(%rbp)
testq %r14, %r14
jne 0x7cc55
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, -0x80(%rbp)
movb $0x1, -0x78(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x84(%rbp), %xmm0
jb 0x7cc6b
movl $0x41500000, -0x84(%rbp) # imm = 0x41500000
cmpb $0x0, -0x42(%rbp)
jne 0x7cc8d
leaq -0x42(%rbp), %rdi
cvttss2si -0x42(%rdi), %ecx
leaq 0x529b2(%rip), %rdx     # 0xcf633
movl $0x28, %esi
xorl %eax, %eax
callq 0x427cb
leaq -0x98(%rbp), %rdx
movw $0x85, 0x54(%rdx)
movss 0x14(%rdx), %xmm0
movaps %xmm0, %xmm1
divss 0x4bce2(%rip), %xmm1    # 0xc898c
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, 0x30(%rdx)
movq 0x38(%rdx), %rax
testq %rax, %rax
leaq 0x4bed4(%rip), %rcx     # 0xc8b98
cmovneq %rax, %rcx
leaq 0x4f5e1(%rip), %rsi     # 0xcc2b0
movq %rbx, %rdi
callq 0x7d0f4
addq $0x90, %rsp
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: 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
cmpq $0x0, 0x20(%rdi)
jne 0x7cda9
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 0x7cb2c
movq (%r13), %r13
testq %r13, %r13
je 0x7cda5
movslq 0x28(%r15), %rax
movslq 0x2c(%r15), %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x424fb
movq %rax, 0x20(%r15)
movl 0x2c(%r15), %ecx
imull 0x28(%r15), %ecx
testl %ecx, %ecx
jle 0x7cda5
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
jg 0x7cd89
movq -0x30(%rbp), %rsi
movq 0x20(%r15), %rax
movq %rax, (%rsi)
testq %r12, %r12
je 0x7cdbd
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x7cdc9
movl 0x2c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x7cdd4
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_O1/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 0x424fb
movq %rax, %r13
movb (%r12), %cl
testb %cl, %cl
je 0x7d1e6
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 0x7d155
movq %r15, %rdi
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movq %r14, %rcx
movq %rbx, %r8
callq 0x7d4fe
movq %rax, %rbx
movq %r13, %rdi
callq 0x425d4
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_O1/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 %r12
pushq %rbx
subq $0x90, %rsp
cmpb $0x1, (%rdi)
je 0x7d4bf
movq %r8, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x7d406
leaq -0xb0(%rbp), %rdi
movl $0x88, %edx
movq %rcx, %rsi
movss %xmm0, -0x24(%rbp)
callq 0xc080
movss -0x24(%rbp), %xmm0
jmp 0x7d477
xorl %eax, %eax
movq %rax, -0xb0(%rbp)
movl $0x0, -0xa8(%rbp)
xorps %xmm2, %xmm2
movups %xmm2, -0x8c(%rbp)
movb $0x1, -0xa4(%rbp)
movaps 0x4b51f(%rip), %xmm1    # 0xc8950
movups %xmm1, -0xa0(%rbp)
movb %al, -0x90(%rbp)
movq %rax, -0x78(%rbp)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, -0x64(%rbp)
movw $0xffff, -0x5c(%rbp)    # imm = 0xFFFF
movups %xmm2, -0x5a(%rbp)
movups %xmm2, -0x4a(%rbp)
movq %rax, -0x3a(%rbp)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x7d4de
movq %r12, -0xb0(%rbp)
movl %r15d, -0xa8(%rbp)
movss %xmm0, -0x9c(%rbp)
testq %rbx, %rbx
je 0x7d4a0
movq %rbx, -0x78(%rbp)
leaq -0xb0(%rbp), %rsi
movq %r14, %rdi
callq 0x7cde4
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51fce(%rip), %rdi     # 0xcf494
leaq 0x51d09(%rip), %rsi     # 0xcf1d6
leaq 0x52207(%rip), %rcx     # 0xcf6db
movl $0x7c5, %edx            # imm = 0x7C5
callq 0xc140
leaq 0x5225b(%rip), %rdi     # 0xcf740
leaq 0x51cea(%rip), %rsi     # 0xcf1d6
leaq 0x521e8(%rip), %rcx     # 0xcf6db
movl $0x7c7, %edx            # imm = 0x7C7
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d9c1
movl %edx, %r14d
leal -0x1(%r14), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7d9e0
movq %rdi, %rbx
movl 0x50(%rdi), %r13d
movl 0x54(%rdi), %eax
cmpl %eax, %r13d
jne 0x7d979
incl %r13d
testl %eax, %eax
je 0x7d92f
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7d934
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x7d979
movslq %r13d, %rdi
shlq $0x5, %rdi
callq 0x424fb
movq %rax, %r12
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x7d971
movslq 0x50(%rbx), %rdx
shlq $0x5, %rdx
movq %r12, %rdi
callq 0xc080
movq 0x58(%rbx), %rdi
callq 0x425d4
movq %r12, 0x58(%rbx)
movl %r13d, 0x54(%rbx)
movq 0x58(%rbx), %rax
movslq 0x50(%rbx), %rcx
shlq $0x5, %rcx
movw %r15w, (%rax,%rcx)
movw %r14w, 0x2(%rax,%rcx)
movl $0xffffffff, 0x4(%rax,%rcx) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax,%rcx)
movq $0x0, 0x18(%rax,%rcx)
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 0x51e09(%rip), %rdi     # 0xcf7d1
leaq 0x51807(%rip), %rsi     # 0xcf1d6
leaq 0x51e18(%rip), %rcx     # 0xcf7ee
movl $0x7e8, %edx            # imm = 0x7E8
callq 0xc140
leaq 0x51e37(%rip), %rdi     # 0xcf81e
leaq 0x517e8(%rip), %rsi     # 0xcf1d6
leaq 0x51df9(%rip), %rcx     # 0xcf7ee
movl $0x7e9, %edx            # imm = 0x7E9
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7db3c
movl %ecx, %r12d
leal -0x1(%r12), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7db5b
movl %r8d, %r15d
leal -0x1(%r15), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x7db7a
movq %rsi, %r14
movq %rdi, %rbx
movss (%r9), %xmm1
movss 0x4(%r9), %xmm2
movl 0x50(%rdi), %r13d
movl 0x54(%rdi), %eax
cmpl %eax, %r13d
jne 0x7dae7
incl %r13d
testl %eax, %eax
je 0x7da74
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x7da79
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x7dae7
movss %xmm2, -0x2c(%rbp)
movss %xmm1, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movss %xmm0, -0x38(%rbp)
movslq %r13d, %rdi
shlq $0x5, %rdi
callq 0x424fb
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x7dacd
movslq 0x50(%rbx), %rdx
shlq $0x5, %rdx
movq %rax, %rdi
movq %rax, -0x40(%rbp)
callq 0xc080
movq 0x58(%rbx), %rdi
callq 0x425d4
movq -0x40(%rbp), %rax
movq %rax, 0x58(%rbx)
movl %r13d, 0x54(%rbx)
movss -0x38(%rbp), %xmm0
movl -0x34(%rbp), %edx
movss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
movzwl %dx, %eax
movq 0x58(%rbx), %rcx
movslq 0x50(%rbx), %rdx
shlq $0x5, %rdx
movw %r12w, (%rcx,%rdx)
movw %r15w, 0x2(%rcx,%rdx)
movl $0xffffffff, 0x4(%rcx,%rdx) # imm = 0xFFFFFFFF
movl %eax, 0x8(%rcx,%rdx)
movss %xmm0, 0xc(%rcx,%rdx)
movss %xmm1, 0x10(%rcx,%rdx)
movss %xmm2, 0x14(%rcx,%rdx)
movq %r14, 0x18(%rcx,%rdx)
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 0x51cfa(%rip), %rdi     # 0xcf83d
leaq 0x5168c(%rip), %rsi     # 0xcf1d6
leaq 0x51cfb(%rip), %rcx     # 0xcf84c
movl $0x7f6, %edx            # imm = 0x7F6
callq 0xc140
leaq 0x51c6f(%rip), %rdi     # 0xcf7d1
leaq 0x5166d(%rip), %rsi     # 0xcf1d6
leaq 0x51cdc(%rip), %rcx     # 0xcf84c
movl $0x7f7, %edx            # imm = 0x7F7
callq 0xc140
leaq 0x51c9d(%rip), %rdi     # 0xcf81e
leaq 0x5164e(%rip), %rsi     # 0xcf1d6
leaq 0x51cbd(%rip), %rcx     # 0xcf84c
movl $0x7f8, %edx            # imm = 0x7F8
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7dc0c
cmpl $0x0, 0x2c(%rdi)
jle 0x7dc0c
movzwl 0x4(%rsi), %eax
cmpw $-0x1, %ax
je 0x7dc2b
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 0x51c95(%rip), %rdi     # 0xcf8a8
leaq 0x515bc(%rip), %rsi     # 0xcf1d6
leaq 0x51ca5(%rip), %rcx     # 0xcf8c6
movl $0x806, %edx            # imm = 0x806
callq 0xc140
leaq 0x51cf0(%rip), %rdi     # 0xcf922
leaq 0x5159d(%rip), %rsi     # 0xcf1d6
leaq 0x51c86(%rip), %rcx     # 0xcf8c6
movl $0x807, %edx            # imm = 0x807
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7dd56
movq %rdi, %r14
testb $0x2, 0x4(%rdi)
jne 0x7dd56
movl %esi, %ebx
movq %r9, -0x30(%rbp)
movl 0x470(%r14), %esi
cmpl $-0x1, %esi
je 0x7dd67
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %r14, %rdi
callq 0x87c1e
movl %ebx, %ecx
movzwl 0x4(%rax), %edx
cvtsi2ss %edx, %xmm0
movzwl 0x6(%rax), %eax
cvtsi2ss %eax, %xmm1
leaq (%rcx,%rcx,2), %rax
leaq 0x4ae0e(%rip), %rcx     # 0xc8ac0
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 0x4ac74(%rip), %xmm0    # 0xc8990
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 0x7dd58
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51bc5(%rip), %rdi     # 0xcf933
leaq 0x51461(%rip), %rsi     # 0xcf1d6
leaq 0x51bd0(%rip), %rcx     # 0xcf94c
movl $0x813, %edx            # imm = 0x813
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81227
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 0x81216
xorl %esi, %esi
movzbl (%rax,%rsi), %r10d
movb (%rdi,%r10), %r10b
movb %r10b, (%rax,%rsi)
incq %rsi
cmpq %rsi, %rdx
jne 0x81201
leal -0x1(%r9), %esi
addq %rcx, %rax
cmpl $0x1, %r9d
movl %esi, %r9d
jg 0x811fa
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81267
testb $0x2, 0x4(%rbx)
jne 0x8124f
movq %rbx, %rdi
movl $0xd9, %esi
movl $0x1b, %edx
jmp 0x8125c
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x7d8da
movl %eax, 0x470(%rbx)
cmpl $0x0, 0x474(%rbx)
jns 0x8128e
testb $0x4, 0x4(%rbx)
jne 0x8128e
movq %rbx, %rdi
movl $0x41, %esi
movl $0x40, %edx
callq 0x7d8da
movl %eax, 0x474(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x0, 0x48(%rdx)
jne 0x81e8b
movq %rdx, %r15
movq %rdi, %r14
movq %rbx, %rdi
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
callq 0x82638
movss 0x14(%r15), %xmm0
movss %xmm0, 0x14(%rbx)
movq %r15, 0x48(%rbx)
movw $0x0, 0x50(%rbx)
movq %r14, 0x40(%rbx)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x5c(%rbx)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x60(%rbx)
incw 0x50(%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: 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 0x82663
xorl %r14d, %r14d
movq %r14, 0x28(%rbx)
callq 0x425d4
movq %r14, 0x30(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x8267b
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x425d4
movq %r14, 0x8(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x82694
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
callq 0x425d4
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