LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x65deb
cmpl $0x0, 0x60(%r15)
jne 0x65ddf
movq %r15, %rdi
xorl %esi, %esi
callq 0x65e22
movq %r15, %rdi
callq 0x65f5c
movq 0x18(%r15), %rax
movq %rax, (%r13)
testq %r12, %r12
je 0x65dfc
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x65e08
movl 0x2c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x65e13
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_O2/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 0x65e5f
leaq -0x98(%rbp), %r14
movl $0x88, %edx
movq %r14, %rdi
callq 0xc080
movss 0x14(%r14), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x65ed1
jmp 0x65ee3
andq $0x0, -0x98(%rbp)
andl $0x0, -0x90(%rbp)
movb $0x1, %al
movb %al, -0x8c(%rbp)
andl $0x0, -0x88(%rbp)
andq $0x0, -0x60(%rbp)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, -0x58(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x74(%rbp)
movb $0x0, -0x50(%rbp)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, -0x4c(%rbp)
orw $-0x1, -0x44(%rbp)
movups %xmm0, -0x42(%rbp)
andq $0x0, -0x22(%rbp)
movups %xmm0, -0x32(%rbp)
andq $0x0, -0x18(%rbp)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
movl $0x41500000, -0x84(%rbp) # imm = 0x41500000
movss 0x47da9(%rip), %xmm0    # 0xadc8c
cmpb $0x0, -0x42(%rbp)
jne 0x65f0b
leaq -0x42(%rbp), %r14
cvttss2si %xmm0, %ecx
leaq 0x4ea3b(%rip), %rdx     # 0xb4933
pushq $0x28
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3468c
movss -0x42(%r14), %xmm0
leaq -0x98(%rbp), %rdx
movw $0x85, 0x54(%rdx)
movaps %xmm0, %xmm1
divss 0x47d69(%rip), %xmm1    # 0xadc8c
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, 0x30(%rdx)
movq 0x38(%rdx), %rax
testq %rax, %rax
leaq 0x47f5b(%rip), %rcx     # 0xade98
cmovneq %rax, %rcx
leaq 0x4b668(%rip), %rsi     # 0xb15b0
movq %rbx, %rdi
callq 0x6620e
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: 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 0x6601f
movq %rsi, -0x30(%rbp)
leaq -0x38(%rbp), %r13
andq $0x0, (%r13)
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x65da8
movq (%r13), %r13
testq %r13, %r13
je 0x66017
movslq 0x28(%r15), %rax
movslq 0x2c(%r15), %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x3440d
movq %rax, 0x20(%r15)
movl 0x2c(%r15), %ecx
imull 0x28(%r15), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x6601b
movzbl (%r13,%rdx), %esi
shll $0x18, %esi
orl $0xffffff, %esi         # imm = 0xFFFFFF
movl %esi, (%rax,%rdx,4)
decl %ecx
incq %rdx
jmp 0x65ffa
movq 0x20(%r15), %rax
movq -0x30(%rbp), %rsi
movq %rax, (%rsi)
testq %r12, %r12
je 0x6602f
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x6603b
movl 0x2c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x66046
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_O2/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 0xc380
addl $0x4, %eax
pushq $0x5
popq %rcx
cltd
idivl %ecx
shll $0x2, %eax
movslq %eax, %rdi
callq 0x3440d
movq %rax, %r13
movsbl (%r12), %edx
testl %edx, %edx
je 0x662e0
xorl %ecx, %ecx
cmpb $0x5c, %dl
setge %cl
xorl $-0x23, %ecx
addl %edx, %ecx
movsbl 0x1(%r12), %esi
xorl %edx, %edx
cmpl $0x5c, %esi
setge %dl
xorl $-0x23, %edx
addl %esi, %edx
movsbl 0x2(%r12), %edi
xorl %esi, %esi
cmpl $0x5c, %edi
setge %sil
xorl $-0x23, %esi
addl %edi, %esi
movsbl 0x3(%r12), %edi
xorl %r8d, %r8d
cmpl $0x5c, %edi
setge %r8b
xorl $-0x23, %r8d
addl %edi, %r8d
movsbl 0x4(%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 $0x5, %r12
addq $0x4, %rax
jmp 0x6624c
movq %r15, %rdi
movq %r13, %rsi
movss -0x2c(%rbp), %xmm0
movq %r14, %rcx
movq %rbx, %r8
callq 0x66604
movq %rax, %rbx
movq %r13, %rdi
callq 0x344ad
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_O2/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 0x665e4
movq %r8, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x66529
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 0x665a4
leaq 0x4e52f(%rip), %rdi     # 0xb4a40
leaq 0x4dfbe(%rip), %rsi     # 0xb44d6
leaq 0x4e4bc(%rip), %rcx     # 0xb49db
movl $0x7c7, %edx            # imm = 0x7C7
callq 0xc140
andq $0x0, -0xb8(%rbp)
andl $0x0, -0xb0(%rbp)
movb $0x1, -0xac(%rbp)
andl $0x0, -0xa8(%rbp)
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, -0xa0(%rbp)
xorl %eax, %eax
movb %al, -0x98(%rbp)
andq $0x0, -0x80(%rbp)
movabsq $0x7f7fffff00000000, %rcx # imm = 0x7F7FFFFF00000000
movq %rcx, -0x78(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, -0x94(%rbp)
movb %al, -0x70(%rbp)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, -0x6c(%rbp)
orw $-0x1, -0x64(%rbp)
movups %xmm1, -0x62(%rbp)
andq $0x0, -0x42(%rbp)
movups %xmm1, -0x52(%rbp)
andq $0x0, -0x38(%rbp)
movq %r12, -0xb8(%rbp)
movl %r15d, -0xb0(%rbp)
movss %xmm0, -0xa4(%rbp)
testq %rbx, %rbx
je 0x665c3
movq %rbx, -0x80(%rbp)
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x66056
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e1a9(%rip), %rdi     # 0xb4794
leaq 0x4dee4(%rip), %rsi     # 0xb44d6
leaq 0x4e3e2(%rip), %rcx     # 0xb49db
movl $0x7c5, %edx            # imm = 0x7C5
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leal -0x1(%rsi), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x66a2b
leal -0x1(%rdx), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x66a4a
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
orl $-0x1, 0x4(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movw %si, (%rax)
movw %dx, 0x2(%rax)
addq $0x50, %rdi
movq %rax, %rsi
callq 0x6f796
movl 0x50(%rbx), %eax
decl %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4e09f(%rip), %rdi     # 0xb4ad1
leaq 0x4da9d(%rip), %rsi     # 0xb44d6
leaq 0x4e0ae(%rip), %rcx     # 0xb4aee
movl $0x7e8, %edx            # imm = 0x7E8
callq 0xc140
leaq 0x4e0cd(%rip), %rdi     # 0xb4b1e
leaq 0x4da7e(%rip), %rsi     # 0xb44d6
leaq 0x4e08f(%rip), %rcx     # 0xb4aee
movl $0x7e9, %edx            # imm = 0x7E9
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x66ace
leal -0x1(%rcx), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x66aed
leal -0x1(%r8), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x66b0c
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
orl $-0x1, 0x4(%rax)
movw %cx, (%rax)
movw %r8w, 0x2(%rax)
movzwl %dx, %ecx
movl %ecx, 0x8(%rax)
movss %xmm0, 0xc(%rax)
movq (%r9), %rcx
movq %rcx, 0x10(%rax)
movq %rsi, 0x18(%rax)
addq $0x50, %rdi
movq %rax, %rsi
callq 0x6f796
movl 0x50(%rbx), %eax
decl %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4e068(%rip), %rdi     # 0xb4b3d
leaq 0x4d9fa(%rip), %rsi     # 0xb44d6
leaq 0x4e069(%rip), %rcx     # 0xb4b4c
movl $0x7f6, %edx            # imm = 0x7F6
callq 0xc140
leaq 0x4dfdd(%rip), %rdi     # 0xb4ad1
leaq 0x4d9db(%rip), %rsi     # 0xb44d6
leaq 0x4e04a(%rip), %rcx     # 0xb4b4c
movl $0x7f7, %edx            # imm = 0x7F7
callq 0xc140
leaq 0x4e00b(%rip), %rdi     # 0xb4b1e
leaq 0x4d9bc(%rip), %rsi     # 0xb44d6
leaq 0x4e02b(%rip), %rcx     # 0xb4b4c
movl $0x7f8, %edx            # imm = 0x7F8
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66b98
cmpl $0x0, 0x2c(%rdi)
jle 0x66b98
movzwl 0x4(%rsi), %eax
cmpw $-0x1, %ax
je 0x66bb7
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
cvtsi2ss %edx, %xmm0
mulss 0x30(%rdi), %xmm0
movzwl 0x6(%rsi), %eax
movzwl 0x2(%rsi), %edx
addl %eax, %edx
cvtsi2ss %edx, %xmm1
mulss 0x34(%rdi), %xmm1
movss %xmm0, (%rcx)
movss %xmm1, 0x4(%rcx)
popq %rbp
retq
leaq 0x4e009(%rip), %rdi     # 0xb4ba8
leaq 0x4d930(%rip), %rsi     # 0xb44d6
leaq 0x4e019(%rip), %rcx     # 0xb4bc6
movl $0x806, %edx            # imm = 0x806
callq 0xc140
leaq 0x4e064(%rip), %rdi     # 0xb4c22
leaq 0x4d911(%rip), %rsi     # 0xb44d6
leaq 0x4dffa(%rip), %rcx     # 0xb4bc6
movl $0x807, %edx            # imm = 0x807
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x66ce2
movq %rdi, %r14
testb $0x2, 0x4(%rdi)
jne 0x66ce2
movl %esi, %ebx
movq %r9, -0x30(%rbp)
movl 0x470(%r14), %esi
cmpl $-0x1, %esi
je 0x66cf3
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %r14, %rdi
callq 0x6f7f4
movl %ebx, %ecx
movzwl 0x4(%rax), %edx
cvtsi2ss %edx, %xmm0
movzwl 0x6(%rax), %eax
cvtsi2ss %eax, %xmm1
imulq $0x18, %rcx, %rax
leaq 0x47182(%rip), %rcx     # 0xaddc0
addss (%rax,%rcx), %xmm0
addss 0x4(%rax,%rcx), %xmm1
movss 0x8(%rax,%rcx), %xmm2
movq 0x8(%rax,%rcx), %rdx
movq 0x10(%rax,%rcx), %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(%rax,%rcx), %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 0x46fe8(%rip), %xmm0    # 0xadc90
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 0x66ce4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4df39(%rip), %rdi     # 0xb4c33
leaq 0x4d7d5(%rip), %rsi     # 0xb44d6
leaq 0x4df44(%rip), %rcx     # 0xb4c4c
movl $0x813, %edx            # imm = 0x813
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movslq 0x10(%rbp), %rax
movslq %edx, %rdx
addq %rsi, %rdx
imull %eax, %ecx
movslq %ecx, %rcx
addq %rdx, %rcx
xorl %edx, %edx
testl %r8d, %r8d
cmovlel %edx, %r8d
testl %r9d, %r9d
jle 0x69905
xorl %edx, %edx
cmpq %rdx, %r8
je 0x698fd
movzbl (%rcx,%rdx), %esi
movb (%rdi,%rsi), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
jmp 0x698e7
decl %r9d
addq %rax, %rcx
jmp 0x698e0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6993f
testb $0x2, 0x4(%rbx)
jne 0x6992c
pushq $0x1b
popq %rdx
movq %rbx, %rdi
movl $0xd9, %esi
jmp 0x69934
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x669d8
movl %eax, 0x470(%rbx)
cmpl $0x0, 0x474(%rbx)
jns 0x69962
testb $0x4, 0x4(%rbx)
jne 0x69962
pushq $0x41
popq %rsi
pushq $0x40
popq %rdx
movq %rbx, %rdi
callq 0x669d8
movl %eax, 0x474(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a483
movl 0x50(%rbx), %eax
incl %eax
jmp 0x6a4c6
movq %rdx, %r14
movq %rdi, %r15
movq %rbx, %rdi
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
callq 0x6ab7c
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_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
addq $0x28, %rdi
callq 0x6fc12
movq %rbx, %rdi
callq 0x4a220
leaq 0x18(%rbx), %rdi
callq 0x4c100
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movb $0x1, 0x56(%rbx)
andq $0x0, 0x5c(%rbx)
andl $0x0, 0x64(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
testl %esi, %esi
js 0x6ac47
leal (%rcx,%rsi), %eax
movl 0x28(%rdi), %r10d
cmpl %r10d, %eax
jg 0x6ac47
testl %edx, %edx
js 0x6ac66
leal (%r8,%rdx), %eax
cmpl 0x2c(%rdi), %eax
jg 0x6ac66
movb 0x10(%rbp), %al
movl %esi, %esi
addq 0x18(%rdi), %rsi
imull %edx, %r10d
movslq %r10d, %rdx
addq %rsi, %rdx
movslq %ecx, %rsi
xorl %r10d, %r10d
testl %esi, %esi
cmovlel %r10d, %ecx
testl %r8d, %r8d
cmovlel %r10d, %r8d
movzbl 0x18(%rbp), %r11d
cmpl %r8d, %r10d
je 0x6ac42
xorl %ebx, %ebx
cmpq %rbx, %rcx
je 0x6ac33
movl %r11d, %r14d
cmpb %al, (%r9,%rbx)
je 0x6ac2a
xorl %r14d, %r14d
movb %r14b, (%rdx,%rbx)
incq %rbx
jmp 0x6ac19
incl %r10d
movslq 0x28(%rdi), %rbx
addq %rbx, %rdx
addq %rsi, %r9
jmp 0x6ac12
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4a27c(%rip), %rdi     # 0xb4eca
leaq 0x49881(%rip), %rsi     # 0xb44d6
leaq 0x4a291(%rip), %rcx     # 0xb4eed
movl $0x986, %edx            # imm = 0x986
callq 0xc140
leaq 0x4a2f4(%rip), %rdi     # 0xb4f61
leaq 0x49862(%rip), %rsi     # 0xb44d6
leaq 0x4a272(%rip), %rcx     # 0xb4eed
movl $0x987, %edx            # imm = 0x987
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::FindGlyphNoFallback(unsigned short) const
const ImFontGlyph* ImFont::FindGlyphNoFallback(ImWchar c) const
{
    if (c >= (size_t)IndexLookup.Size)
        return NULL;
    const ImWchar i = IndexLookup.Data[c];
    if (i == (ImWchar)-1)
        return NULL;
    return &Glyphs.Data[i];
}

// Assembly:
movl %esi, %eax
movslq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jae 0x6af20
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rcx
movzwl (%rcx,%rax,2), %ecx
imulq $0x28, %rcx, %rdx
addq 0x30(%rdi), %rdx
xorl %eax, %eax
cmpq $0xffff, %rcx           # imm = 0xFFFF
cmovneq %rdx, %rax
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: UnpackAccumulativeOffsetsIntoRanges(int, short const*, int, unsigned short*)
static void UnpackAccumulativeOffsetsIntoRanges(int base_codepoint, const short* accumulative_offsets, int accumulative_offsets_count, ImWchar* out_ranges)
{
    for (int n = 0; n < accumulative_offsets_count; n++, out_ranges += 2)
    {
        out_ranges[0] = out_ranges[1] = (ImWchar)(base_codepoint + accumulative_offsets[n]);
        base_codepoint += accumulative_offsets[n];
    }
    out_ranges[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movw $0x4e00, %cx            # imm = 0x4E00
cmpq %rax, %rsi
je 0x6afb8
movzwl (%rdi,%rax,2), %r8d
addw %cx, %r8w
movw %r8w, 0x2(%rdx,%rax,4)
movw %r8w, (%rdx,%rax,4)
addw (%rdi,%rax,2), %cx
incq %rax
jmp 0x6af96
andw $0x0, (%rdx,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b053
xorl %eax, %eax
cmpq %rbx, %r14
setb %al
jmp 0x6b057
movsbl (%r14), %eax
testl %eax, %eax
je 0x6b084
andl $0x0, -0x24(%rbp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33a81
testl %eax, %eax
je 0x6b084
cltq
addq %rax, %r14
movzwl -0x24(%rbp), %esi
movq %r15, %rdi
callq 0x6fbc8
jmp 0x6b044
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontGlyphRangesBuilder::BuildRanges(ImVector<unsigned short>*)
void ImFontGlyphRangesBuilder::BuildRanges(ImVector<ImWchar>* out_ranges)
{
    const int max_codepoint = IM_UNICODE_CODEPOINT_MAX;
    for (int n = 0; n <= max_codepoint; n++)
        if (GetBit(n))
        {
            out_ranges->push_back((ImWchar)n);
            while (n < max_codepoint && GetBit(n + 1))
                n++;
            out_ranges->push_back((ImWchar)n);
        }
    out_ranges->push_back(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0x2a(%rbp), %r12
cmpl $0x10000, %r15d         # imm = 0x10000
jge 0x6b15e
movslq %r15d, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x6fbd4
testb %al, %al
je 0x6b159
movw %r15w, -0x2c(%rbp)
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x499c0
decl %r15d
incq %r13
cmpq $0x10000, %r13          # imm = 0x10000
je 0x6b143
movq %r14, %rdi
movq %r13, %rsi
callq 0x6fbd4
incl %r15d
incq %r13
testb %al, %al
jne 0x6b123
jmp 0x6b149
movl $0xffff, %r15d          # imm = 0xFFFF
movw %r15w, -0x2a(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x499c0
incl %r15d
jmp 0x6b0f1
leaq -0x2e(%rbp), %rsi
andw $0x0, (%rsi)
movq %rbx, %rdi
callq 0x499c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::ImFont()
ImFont::ImFont()
{
    FontSize = 0.0f;
    FallbackAdvanceX = 0.0f;
    FallbackChar = (ImWchar)'?';
    EllipsisChar = (ImWchar)-1;
    FallbackGlyph = NULL;
    ContainerAtlas = NULL;
    ConfigData = NULL;
    ConfigDataCount = 0;
    DirtyLookupTables = false;
    Scale = 1.0f;
    Ascent = Descent = 0.0f;
    MetricsTotalSurface = 0;
    memset(Used4kPagesMap, 0, sizeof(Used4kPagesMap));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x30(%rdi)
movl $0xffff003f, 0x52(%rdi) # imm = 0xFFFF003F
movb $0x0, 0x56(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x42(%rdi)
movl $0x3f800000, 0x58(%rdi) # imm = 0x3F800000
andq $0x0, 0x5c(%rdi)
andq $0x0, 0x62(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::GrowIndex(int)
void ImFont::GrowIndex(int new_size)
{
    IM_ASSERT(IndexAdvanceX.Size == IndexLookup.Size);
    if (new_size <= IndexLookup.Size)
        return;
    IndexAdvanceX.resize(new_size, -1.0f);
    IndexLookup.resize(new_size, (ImWchar)-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %eax
cmpl 0x18(%rdi), %eax
jne 0x6b23a
movl %esi, %ebx
cmpl %esi, %eax
jge 0x6b231
leaq 0x18(%rdi), %r14
leaq -0x18(%rbp), %rdx
movl $0xbf800000, (%rdx)     # imm = 0xBF800000
movl %ebx, %esi
callq 0x6fcea
leaq -0x12(%rbp), %rdx
orw $-0x1, (%rdx)
movq %r14, %rdi
movl %ebx, %esi
callq 0x6fd52
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x49de6(%rip), %rdi     # 0xb5027
leaq 0x4928e(%rip), %rsi     # 0xb44d6
leaq 0x49dff(%rip), %rcx     # 0xb504e
movl $0xb9d, %edx            # imm = 0xB9D
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::FindGlyph(unsigned short) const
const ImFontGlyph* ImFont::FindGlyph(ImWchar c) const
{
    if (c >= (size_t)IndexLookup.Size)
        return FallbackGlyph;
    const ImWchar i = IndexLookup.Data[c];
    if (i == (ImWchar)-1)
        return FallbackGlyph;
    return &Glyphs.Data[i];
}

// Assembly:
movl %esi, %eax
movslq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jae 0x6b27f
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rcx
movzwl (%rcx,%rax,2), %eax
cmpq $0xffff, %rax           # imm = 0xFFFF
jne 0x6b284
movq 0x38(%rdi), %rax
jmp 0x6b28c
movq 0x38(%rdi), %rax
retq
imulq $0x28, %rax, %rax
addq 0x30(%rdi), %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::IsGlyphRangeUnused(unsigned int, unsigned int)
bool ImFont::IsGlyphRangeUnused(unsigned int c_begin, unsigned int c_last)
{
    unsigned int page_begin = (c_begin / 4096);
    unsigned int page_last = (c_last / 4096);
    for (unsigned int page_n = page_begin; page_n <= page_last; page_n++)
        if ((page_n >> 3) < sizeof(Used4kPagesMap))
            if (Used4kPagesMap[page_n >> 3] & (1 << (page_n & 7)))
                return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
shrl $0xc, %esi
shrl $0xc, %edx
cmpl %edx, %esi
ja 0x6b2e3
cmpl $0xf, %esi
ja 0x6b2df
movl %esi, %eax
shrl $0x3, %eax
movzbl 0x68(%rdi,%rax), %eax
movl %esi, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jb 0x6b2e3
incl %esi
jmp 0x6b2c2
cmpl %edx, %esi
seta %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::AddRemapChar(unsigned short, unsigned short, bool)
void ImFont::AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst)
{
    IM_ASSERT(IndexLookup.Size > 0);    // Currently this can only be called AFTER the font has been built, aka after calling ImFontAtlas::GetTexDataAs*() function.
    unsigned int index_size = (unsigned int)IndexLookup.Size;

    if (dst < index_size && IndexLookup.Data[dst] == (ImWchar)-1 && !overwrite_dst) // 'dst' already exists
        return;
    if (src >= index_size && dst >= index_size) // both 'dst' and 'src' don't exist -> no-op
        return;

    GrowIndex(dst + 1);
    IndexLookup[dst] = (src < index_size) ? IndexLookup.Data[src] : (ImWchar)-1;
    IndexAdvanceX[dst] = (src < index_size) ? IndexAdvanceX.Data[src] : 1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x18(%rdi), %r13d
testl %r13d, %r13d
jle 0x6b3c0
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movzwl %si, %r14d
movzwl %dx, %r12d
cmpl %r14d, %r13d
jbe 0x6b365
movq 0x20(%rbx), %rax
cmpw $-0x1, (%rax,%r14,2)
sete %al
xorb $0x1, %cl
testb %cl, %al
jne 0x6b3b1
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x6b1f2
cmpl %r12d, %r13d
ja 0x6b376
movq %r15, %rdi
movl %r14d, %esi
callq 0x5f790
orw $-0x1, (%rax)
movss 0x30c95(%rip), %xmm0    # 0x9bff8
jmp 0x6b398
cmpl %r12d, %r13d
jbe 0x6b3b1
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x6b1f2
movq 0x20(%rbx), %rax
movzwl (%rax,%r12,2), %r13d
movq %r15, %rdi
movl %r14d, %esi
callq 0x5f790
movw %r13w, (%rax)
movq 0x8(%rbx), %rax
movss (%rax,%r12,4), %xmm0
movss %xmm0, -0x2c(%rbp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4ad98
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49ca3(%rip), %rdi     # 0xb506a
leaq 0x49108(%rip), %rsi     # 0xb44d6
leaq 0x49caa(%rip), %rcx     # 0xb507f
movl $0xbd4, %edx            # imm = 0xBD4
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFont::RenderChar(ImDrawList*, float, ImVec2, unsigned int, unsigned short) const
void ImFont::RenderChar(ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, ImWchar c) const
{
    const ImFontGlyph* glyph = FindGlyph(c);
    if (!glyph || !glyph->Visible)
        return;
    float scale = (size >= 0.0f) ? (size / FontSize) : 1.0f;
    pos.x = IM_FLOOR(pos.x);
    pos.y = IM_FLOOR(pos.y);
    draw_list->PrimReserve(6, 4);
    draw_list->PrimRectUV(ImVec2(pos.x + glyph->X0 * scale, pos.y + glyph->Y0 * scale), ImVec2(pos.x + glyph->X1 * scale, pos.y + glyph->Y1 * scale), ImVec2(glyph->U0, glyph->V0), ImVec2(glyph->U1, glyph->V1), col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movaps %xmm1, -0x40(%rbp)
movss %xmm0, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r12
movl %ecx, %esi
callq 0x6b25a
testq %rax, %rax
je 0x6b8a3
movq %rax, %r15
cmpl $0x0, (%rax)
jns 0x6b8a3
movss -0x30(%rbp), %xmm2
movaps %xmm2, %xmm0
divss 0x14(%r12), %xmm0
xorps %xmm1, %xmm1
cmpnless %xmm2, %xmm1
movss 0x30809(%rip), %xmm2    # 0x9bff8
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm1, %xmm2
movaps %xmm2, -0x30(%rbp)
movaps -0x40(%rbp), %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x623b8
movss 0x8(%r15), %xmm0
movaps -0x30(%rbp), %xmm2
mulss %xmm2, %xmm0
movaps -0x50(%rbp), %xmm3
addss %xmm3, %xmm0
movss 0xc(%r15), %xmm1
mulss %xmm2, %xmm1
movaps -0x40(%rbp), %xmm4
addss %xmm4, %xmm1
leaq -0x70(%rbp), %rsi
movss %xmm0, (%rsi)
movss %xmm1, 0x4(%rsi)
movss 0x10(%r15), %xmm0
mulss %xmm2, %xmm0
addss %xmm3, %xmm0
mulss 0x14(%r15), %xmm2
addss %xmm4, %xmm2
leaq -0x68(%rbp), %rdx
movss %xmm0, (%rdx)
movss %xmm2, 0x4(%rdx)
movq 0x18(%r15), %rax
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq 0x20(%r15), %rax
leaq -0x58(%rbp), %r8
movq %rax, (%r8)
movq %r14, %rdi
movl %ebx, %r9d
callq 0x62546
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImGui::RenderCheckMark(ImDrawList*, ImVec2, unsigned int, float)
void ImGui::RenderCheckMark(ImDrawList* draw_list, ImVec2 pos, ImU32 col, float sz)
{
    float thickness = ImMax(sz / 5.0f, 1.0f);
    sz -= thickness * 0.5f;
    pos += ImVec2(thickness * 0.25f, thickness * 0.25f);

    float third = sz / 3.0f;
    float bx = pos.x + third;
    float by = pos.y + sz - third * 0.5f;
    draw_list->PathLineTo(ImVec2(bx - third, by - third));
    draw_list->PathLineTo(ImVec2(bx, by));
    draw_list->PathLineTo(ImVec2(bx + third * 2.0f, by - third * 2.0f));
    draw_list->PathStroke(col, false, thickness);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movaps %xmm1, %xmm3
divss 0x30e5f(%rip), %xmm3    # 0x9c8c0
movq %rdi, %r14
maxss 0x3058c(%rip), %xmm3    # 0x9bff8
movss %xmm3, -0x28(%rbp)
movss 0x3059f(%rip), %xmm4    # 0x9c018
movaps %xmm3, %xmm2
mulss %xmm4, %xmm2
subss %xmm2, %xmm1
movss 0x30574(%rip), %xmm2    # 0x9c000
mulss %xmm3, %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
addss %xmm2, %xmm3
addss %xmm1, %xmm3
movaps %xmm1, %xmm5
divss 0x3055a(%rip), %xmm5    # 0x9c004
movss %xmm5, -0x24(%rbp)
addss %xmm2, %xmm0
addss %xmm5, %xmm0
movaps %xmm0, -0x50(%rbp)
mulss %xmm5, %xmm4
subss %xmm4, %xmm3
movaps %xmm3, -0x40(%rbp)
subss %xmm5, %xmm0
movaps %xmm3, %xmm1
subss %xmm5, %xmm1
leaq -0x30(%rbp), %r15
movss %xmm0, (%r15)
movss %xmm1, 0x4(%r15)
leaq 0x78(%rdi), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c382
movaps -0x50(%rbp), %xmm0
movss %xmm0, (%r15)
movaps -0x40(%rbp), %xmm0
movss %xmm0, 0x4(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c382
movss -0x24(%rbp), %xmm1
addss %xmm1, %xmm1
movaps -0x50(%rbp), %xmm0
addss %xmm1, %xmm0
movaps %xmm1, %xmm2
movaps -0x40(%rbp), %xmm1
subss %xmm2, %xmm1
movss %xmm0, (%r15)
movss %xmm1, 0x4(%r15)
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
callq 0x4c382
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movss -0x28(%rbp), %xmm0
callq 0x4c428
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImGui::RenderArrowPointingAt(ImDrawList*, ImVec2, ImVec2, int, unsigned int)
void ImGui::RenderArrowPointingAt(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, ImGuiDir direction, ImU32 col)
{
    switch (direction)
    {
    case ImGuiDir_Left:  draw_list->AddTriangleFilled(ImVec2(pos.x + half_sz.x, pos.y - half_sz.y), ImVec2(pos.x + half_sz.x, pos.y + half_sz.y), pos, col); return;
    case ImGuiDir_Right: draw_list->AddTriangleFilled(ImVec2(pos.x - half_sz.x, pos.y + half_sz.y), ImVec2(pos.x - half_sz.x, pos.y - half_sz.y), pos, col); return;
    case ImGuiDir_Up:    draw_list->AddTriangleFilled(ImVec2(pos.x + half_sz.x, pos.y + half_sz.y), ImVec2(pos.x - half_sz.x, pos.y + half_sz.y), pos, col); return;
    case ImGuiDir_Down:  draw_list->AddTriangleFilled(ImVec2(pos.x - half_sz.x, pos.y - half_sz.y), ImVec2(pos.x + half_sz.x, pos.y - half_sz.y), pos, col); return;
    case ImGuiDir_None: case ImGuiDir_COUNT: break; // Fix warnings
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movlps %xmm0, -0x8(%rbp)
cmpl $0x3, %esi
ja 0x6bec8
movl %edx, %r8d
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movl %esi, %eax
leaq 0x41f0f(%rip), %rcx     # 0xadd24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movaps %xmm1, %xmm3
addss %xmm0, %xmm3
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm2, %xmm0
subss %xmm1, %xmm0
leaq -0x18(%rbp), %rsi
movss %xmm3, (%rsi)
movss %xmm0, 0x4(%rsi)
addss %xmm2, %xmm1
leaq -0x10(%rbp), %rdx
movss %xmm3, (%rdx)
movss %xmm1, 0x4(%rdx)
jmp 0x6bebf
movaps %xmm1, %xmm2
addps %xmm0, %xmm2
leaq -0x18(%rbp), %rsi
movss %xmm2, (%rsi)
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
movss %xmm2, 0x4(%rsi)
subss %xmm1, %xmm0
jmp 0x6beb2
movaps %xmm0, %xmm2
subps %xmm1, %xmm2
leaq -0x18(%rbp), %rsi
movss %xmm2, (%rsi)
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
movss %xmm2, 0x4(%rsi)
addss %xmm0, %xmm1
leaq -0x10(%rbp), %rdx
movss %xmm1, (%rdx)
jmp 0x6beba
subss %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
leaq -0x18(%rbp), %rsi
movss %xmm0, (%rsi)
movss %xmm3, 0x4(%rsi)
subss %xmm1, %xmm2
leaq -0x10(%rbp), %rdx
movss %xmm0, (%rdx)
movss %xmm2, 0x4(%rdx)
leaq -0x8(%rbp), %rcx
callq 0x6430c
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__find_table(unsigned char*, unsigned int, char const*)
static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
{
   stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
   stbtt_uint32 tabledir = fontstart + 12;
   stbtt_int32 i;
   for (i=0; i < num_tables; ++i) {
      stbtt_uint32 loc = tabledir + 16*i;
      if (stbtt_tag(data+loc+0, tag))
         return ttULONG(data+loc+8);
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
movzwl 0x4(%rdi,%rax), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
addl $0xc, %esi
subq $0x1, %rcx
jb 0x6c996
movl %esi, %eax
movzbl (%rdi,%rax), %r8d
movsbl (%rdx), %r9d
cmpl %r9d, %r8d
jne 0x6c991
addq %rdi, %rax
movzbl 0x1(%rax), %r8d
movsbl 0x1(%rdx), %r9d
cmpl %r9d, %r8d
jne 0x6c991
movzbl 0x2(%rax), %r8d
movsbl 0x2(%rdx), %r9d
cmpl %r9d, %r8d
jne 0x6c991
movzbl 0x3(%rax), %r8d
movsbl 0x3(%rdx), %r9d
cmpl %r9d, %r8d
je 0x6c99a
addl $0x10, %esi
jmp 0x6c94b
xorl %eax, %eax
popq %rbp
retq
addq $0x8, %rax
movq %rax, %rdi
popq %rbp
jmp 0x6c92c
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__cff_get_index(stbtt__buf*)
static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
{
   int count, start, offsize;
   start = b->cursor;
   count = stbtt__buf_get16(b);
   if (count) {
      offsize = stbtt__buf_get8(b);
      STBTT_assert(offsize >= 1 && offsize <= 4);
      stbtt__buf_skip(b, offsize * count);
      stbtt__buf_skip(b, stbtt__buf_get(b, offsize) - 1);
   }
   return stbtt__buf_range(b, start, b->cursor - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ebx
pushq $0x2
popq %rsi
callq 0x6cd9a
testl %eax, %eax
je 0x6ca55
movl %eax, %r15d
movq %r14, %rdi
callq 0x6c9de
leal -0x1(%rax), %ecx
cmpb $0x4, %cl
jae 0x6ca6d
movzbl %al, %r12d
imull %r12d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x6c9a4
movq %r14, %rdi
movl %r12d, %esi
callq 0x6cd9a
leal -0x1(%rax), %esi
movq %r14, %rdi
callq 0x6c9a4
movl 0x8(%r14), %edx
subl %ebx, %edx
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6cd5f
leaq 0x4880d(%rip), %rdi     # 0xb5281
leaq 0x487a7(%rip), %rsi     # 0xb5222
leaq 0x4881c(%rip), %rcx     # 0xb529e
movl $0x49c, %edx            # imm = 0x49C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__cff_index_get(stbtt__buf, int)
static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
{
   int count, offsize, start, end;
   stbtt__buf_seek(&b, 0);
   count = stbtt__buf_get16(&b);
   offsize = stbtt__buf_get8(&b);
   STBTT_assert(i >= 0 && i < count);
   STBTT_assert(offsize >= 1 && offsize <= 4);
   stbtt__buf_skip(&b, i*offsize);
   start = stbtt__buf_get(&b, offsize);
   end = stbtt__buf_get(&b, offsize);
   return stbtt__buf_range(&b, 2+(count+1)*offsize+start, end - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
leaq -0x30(%rbp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x6c9ae
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x6cd9a
movl %eax, %ebx
movslq 0x8(%r15), %rax
cmpl 0xc(%r15), %eax
jge 0x6cadb
movq -0x30(%rbp), %rcx
leal 0x1(%rax), %edx
movl %edx, -0x28(%rbp)
movb (%rcx,%rax), %r12b
testl %r14d, %r14d
js 0x6cb45
cmpl %r14d, %ebx
jle 0x6cb45
leal -0x1(%r12), %eax
cmpb $0x4, %al
jae 0x6cb64
movzbl %r12b, %r15d
imull %r15d, %r14d
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x6c9a4
movq %r12, %rdi
movl %r15d, %esi
callq 0x6cd9a
movl %eax, %r14d
movq %r12, %rdi
movl %r15d, %esi
callq 0x6cd9a
incl %ebx
imull %r15d, %ebx
leal (%rbx,%r14), %esi
addl $0x2, %esi
subl %r14d, %eax
movq %r12, %rdi
movl %eax, %edx
callq 0x6cd5f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48780(%rip), %rdi     # 0xb52cc
leaq 0x486cf(%rip), %rsi     # 0xb5222
leaq 0x48786(%rip), %rcx     # 0xb52e0
movl $0x4e1, %edx            # imm = 0x4E1
callq 0xc140
leaq 0x48716(%rip), %rdi     # 0xb5281
leaq 0x486b0(%rip), %rsi     # 0xb5222
leaq 0x48767(%rip), %rcx     # 0xb52e0
movl $0x4e2, %edx            # imm = 0x4E2
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__dict_get_ints(stbtt__buf*, int, int, unsigned int*)
static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, stbtt_uint32 *out)
{
   int i;
   stbtt__buf operands = stbtt__dict_get(b, key);
   for (i = 0; i < outcount && operands.cursor < operands.size; i++)
      out[i] = stbtt__cff_int(&operands);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
movq %rdi, %r15
xorl %esi, %esi
callq 0x6c9ae
pushq $0x1
popq %r14
movl 0x8(%r15), %r12d
movl 0xc(%r15), %eax
cmpl %eax, %r12d
jge 0x6cc56
movl %r12d, %r13d
cmpl %eax, %r13d
jge 0x6cc19
movq (%r15), %rax
movslq %r13d, %rcx
movb (%rax,%rcx), %al
cmpb $0x1c, %al
jb 0x6cc19
movq %r15, %rdi
cmpb $0x1e, %al
jne 0x6cc0a
movl %r14d, %esi
callq 0x6c9a4
movl 0x8(%r15), %eax
cmpl 0xc(%r15), %eax
jge 0x6cc0f
movq %r15, %rdi
callq 0x6c9de
movzbl %al, %eax
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
je 0x6cc0f
andl $-0x10, %eax
cmpl $0xf0, %eax
jne 0x6cbe0
jmp 0x6cc0f
callq 0x6cdd9
movl 0x8(%r15), %r13d
movl 0xc(%r15), %eax
jmp 0x6cbbf
movq %r15, %rdi
callq 0x6c9de
cmpb $0xc, %al
jne 0x6cc37
movq %r15, %rdi
callq 0x6c9de
movzbl %al, %eax
orl $0x100, %eax            # imm = 0x100
jmp 0x6cc3a
movzbl %al, %eax
cmpl -0x30(%rbp), %eax
jne 0x6cbab
subl %r12d, %r13d
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x6cd5f
jmp 0x6cc63
testl %eax, %eax
js 0x6cc5f
movq (%r15), %rax
jmp 0x6cc61
xorl %eax, %eax
xorl %edx, %edx
movl -0x2c(%rbp), %ecx
leaq -0x40(%rbp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movslq %ecx, %r15
movq %rdx, %rax
shrq $0x20, %rax
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x6cc9e
cmpl %eax, %edx
jge 0x6cc9e
movq %r14, %rdi
callq 0x6cdd9
movl %eax, (%rbx,%r12,4)
incq %r12
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %eax
jmp 0x6cc7e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq