LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0x9(%rbp)
jne 0x1160f5
movb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x1160f5
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x1160fe
jmp 0x116100
jmp 0x11611f
leaq 0x743da(%rip), %rdi     # 0x18a4e1
leaq 0x74068(%rip), %rsi     # 0x18a176
movl $0x728, %edx            # imm = 0x728
leaq 0x74460(%rip), %rcx     # 0x18a57a
callq 0xd180
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x116137
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc4920
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x11614f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xc4920
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0xd(%rbp)
jne 0x116195
movb $0x1, %al
movb %al, -0xd(%rbp)
jmp 0x116195
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x11619e
jmp 0x1161a0
jmp 0x1161bf
leaq 0x7433a(%rip), %rdi     # 0x18a4e1
leaq 0x73fc8(%rip), %rsi     # 0x18a176
movl $0x733, %edx            # imm = 0x733
leaq 0x743e1(%rip), %rcx     # 0x18a59b
callq 0xd180
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x40(%rcx), %eax
jge 0x1161f5
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0xc(%rbp), %esi
callq 0xede60
movq (%rax), %rdi
callq 0x1279d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1161c6
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0xead60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x116264
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
callq 0x127a00
testb $0x1, %al
jne 0x11624e
jmp 0x11625b
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1162c0
movq -0x30(%rbp), %rdi
callq 0x116420
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x116287
movq -0x30(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x11629b
movq -0x30(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x1162ac
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1162fc
movq -0x10(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movl $0x88, %edx
callq 0xd0a0
jmp 0x116308
leaq -0x98(%rbp), %rdi
callq 0x115bc0
cmpq $0x0, -0x10(%rbp)
jne 0x116321
movl $0x1, -0x7c(%rbp)
movl $0x1, -0x80(%rbp)
movb $0x1, -0x78(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x84(%rbp), %xmm0
jb 0x11633d
movss 0x6d6ef(%rip), %xmm0    # 0x183a24
movss %xmm0, -0x84(%rbp)
movsbl -0x42(%rbp), %eax
cmpl $0x0, %eax
jne 0x11636c
leaq -0x98(%rbp), %rdi
addq $0x56, %rdi
cvttss2si -0x84(%rbp), %ecx
movl $0x28, %esi
leaq 0x74343(%rip), %rdx     # 0x18a6a8
movb $0x0, %al
callq 0xc4d30
movw $0x85, -0x44(%rbp)
movss -0x84(%rbp), %xmm0
movss 0x6d6a2(%rip), %xmm1    # 0x183a24
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm1
movss 0x5a8a6(%rip), %xmm0    # 0x170c3c
mulss %xmm1, %xmm0
movss %xmm0, -0x68(%rbp)
callq 0x116830
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x1163bf
movq -0x60(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x1163d2
movq -0xb8(%rbp), %rdi
callq 0x116840
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rsi
movss -0x84(%rbp), %xmm0
movq -0xa8(%rbp), %rcx
leaq -0x98(%rbp), %rdx
callq 0x116860
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x116562
movq -0x50(%rbp), %rdi
movq $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x116210
cmpq $0x0, -0x30(%rbp)
je 0x116560
movq -0x50(%rbp), %rax
movslq 0x28(%rax), %rdi
movslq 0x2c(%rax), %rax
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0xc4820
movq -0x50(%rbp), %rcx
movq %rax, 0x20(%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x20(%rcx), %rax
movq %rax, -0x40(%rbp)
movl 0x28(%rcx), %eax
imull 0x2c(%rcx), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jle 0x11655e
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movzbl (%rax), %ecx
shll $0x18, %ecx
orl $0xff0000, %ecx         # imm = 0xFF0000
orl $0xff00, %ecx           # imm = 0xFF00
orl $0xff, %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x116515
jmp 0x116560
jmp 0x116562
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x116585
movq -0x50(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x116599
movq -0x50(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x1165aa
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd410
addl $0x4, %eax
movl $0x5, %ecx
cltd
idivl %ecx
shll $0x2, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
callq 0xc4820
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x116f70
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movss -0x14(%rbp), %xmm0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x116bf0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xc4920
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0xb1(%rbp)
jne 0x116b15
movb $0x1, %al
movb %al, -0xb1(%rbp)
jmp 0x116b15
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x116b21
jmp 0x116b23
jmp 0x116b42
leaq 0x739b7(%rip), %rdi     # 0x18a4e1
leaq 0x73645(%rip), %rsi     # 0x18a176
movl $0x7c5, %edx            # imm = 0x7C5
leaq 0x73c13(%rip), %rcx     # 0x18a750
callq 0xd180
cmpq $0x0, -0x20(%rbp)
je 0x116b60
movq -0x20(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movl $0x88, %edx
callq 0xd0a0
jmp 0x116b6c
leaq -0xb0(%rbp), %rdi
callq 0x115bc0
cmpq $0x0, -0xb0(%rbp)
jne 0x116b78
jmp 0x116b97
leaq 0x73c36(%rip), %rdi     # 0x18a7b5
leaq 0x735f0(%rip), %rsi     # 0x18a176
movl $0x7c7, %edx            # imm = 0x7C7
leaq 0x73bbe(%rip), %rcx     # 0x18a750
callq 0xd180
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xa8(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x9c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x116bc7
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1165b0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromMemoryCompressedTTF(void const*, int, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    const unsigned int buf_decompressed_size = stb_decompress_length((const unsigned char*)compressed_ttf_data);
    unsigned char* buf_decompressed_data = (unsigned char*)IM_ALLOC(buf_decompressed_size);
    stb_decompress(buf_decompressed_data, (const unsigned char*)compressed_ttf_data, (unsigned int)compressed_ttf_size);

    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    IM_ASSERT(font_cfg.FontData == NULL);
    font_cfg.FontDataOwnedByAtlas = true;
    return AddFontFromMemoryTTF(buf_decompressed_data, (int)buf_decompressed_size, size_pixels, &font_cfg, glyph_ranges);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116cd0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %edi
callq 0xc4820
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x116d10
cmpq $0x0, -0x20(%rbp)
je 0x116c66
movq -0x20(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x88, %edx
callq 0xd0a0
jmp 0x116c72
leaq -0xc0(%rbp), %rdi
callq 0x115bc0
cmpq $0x0, -0xc0(%rbp)
jne 0x116c7e
jmp 0x116c9d
leaq 0x73b30(%rip), %rdi     # 0x18a7b5
leaq 0x734ea(%rip), %rsi     # 0x18a176
movl $0x7d7, %edx            # imm = 0x7D7
leaq 0x73b39(%rip), %rcx     # 0x18a7d1
callq 0xd180
movq -0xc8(%rbp), %rdi
movb $0x1, -0xb4(%rbp)
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movss -0x18(%rbp), %xmm0
movq -0x28(%rbp), %r8
leaq -0xc0(%rbp), %rcx
callq 0x116ad0
addq $0xd0, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: Decode85(unsigned char const*, unsigned char*)
static void         Decode85(const unsigned char* src, unsigned char* dst)
{
    while (*src)
    {
        unsigned int tmp = Decode85Byte(src[0]) + 85 * (Decode85Byte(src[1]) + 85 * (Decode85Byte(src[2]) + 85 * (Decode85Byte(src[3]) + 85 * Decode85Byte(src[4]))));
        dst[0] = ((tmp >> 0) & 0xFF); dst[1] = ((tmp >> 8) & 0xFF); dst[2] = ((tmp >> 16) & 0xFF); dst[3] = ((tmp >> 24) & 0xFF);   // We can't assume little-endianness.
        src += 5;
        dst += 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x11706a
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x11e4e0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x11e4e0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %edi
callq 0x11e4e0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %edi
callq 0x11e4e0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %edi
callq 0x11e4e0
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl %eax, %edi
movl -0x18(%rbp), %eax
imull $0x55, %edi, %edi
addl %edi, %esi
imull $0x55, %esi, %esi
addl %esi, %edx
imull $0x55, %edx, %edx
addl %edx, %ecx
imull $0x55, %ecx, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x116f80
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x31(%rbp)
jle 0x1170a2
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
setle %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1170ab
jmp 0x1170ad
jmp 0x1170cc
leaq 0x73792(%rip), %rdi     # 0x18a846
leaq 0x730bb(%rip), %rsi     # 0x18a176
movl $0x7e8, %edx            # imm = 0x7E8
leaq 0x7379c(%rip), %rcx     # 0x18a863
callq 0xd180
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x41(%rbp)
jle 0x1170e4
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
setle %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1170ed
jmp 0x1170ef
jmp 0x11710e
leaq 0x7379d(%rip), %rdi     # 0x18a893
leaq 0x73079(%rip), %rsi     # 0x18a176
movl $0x7e9, %edx            # imm = 0x7E9
leaq 0x7375a(%rip), %rcx     # 0x18a863
callq 0xd180
leaq -0x30(%rbp), %rdi
callq 0x127af0
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movw %ax, -0x30(%rbp)
movl -0x10(%rbp), %eax
movw %ax, -0x2e(%rbp)
addq $0x50, %rdi
leaq -0x30(%rbp), %rsi
callq 0x127b60
movq -0x40(%rbp), %rax
movl 0x50(%rax), %eax
subl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x117188
jmp 0x1171a7
leaq 0x73723(%rip), %rdi     # 0x18a8b2
leaq 0x72fe0(%rip), %rsi     # 0x18a176
movl $0x7f6, %edx            # imm = 0x7F6
leaq 0x7371f(%rip), %rcx     # 0x18a8c1
callq 0xd180
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x51(%rbp)
jle 0x1171bf
cmpl $0xffff, -0x18(%rbp)    # imm = 0xFFFF
setle %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1171c8
jmp 0x1171ca
jmp 0x1171e9
leaq 0x73675(%rip), %rdi     # 0x18a846
leaq 0x72f9e(%rip), %rsi     # 0x18a176
movl $0x7f7, %edx            # imm = 0x7F7
leaq 0x736dd(%rip), %rcx     # 0x18a8c1
callq 0xd180
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x52(%rbp)
jle 0x117201
cmpl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
setle %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x11720a
jmp 0x11720c
jmp 0x11722b
leaq 0x73680(%rip), %rdi     # 0x18a893
leaq 0x72f5c(%rip), %rsi     # 0x18a176
movl $0x7f8, %edx            # imm = 0x7F8
leaq 0x7369b(%rip), %rcx     # 0x18a8c1
callq 0xd180
leaq -0x48(%rbp), %rdi
callq 0x127af0
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
movw %ax, -0x48(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, -0x46(%rbp)
movzwl -0x12(%rbp), %eax
movl %eax, -0x40(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x50, %rdi
leaq -0x48(%rbp), %rsi
callq 0x127b60
movq -0x50(%rbp), %rax
movl 0x50(%rax), %eax
subl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x28(%rcx)
movb %al, -0x31(%rbp)
jle 0x1172c9
movq -0x40(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1172d2
jmp 0x1172d4
jmp 0x1172f3
leaq 0x73642(%rip), %rdi     # 0x18a91d
leaq 0x72e94(%rip), %rsi     # 0x18a176
movl $0x806, %edx            # imm = 0x806
leaq 0x7364d(%rip), %rcx     # 0x18a93b
callq 0xd180
movq -0x10(%rbp), %rdi
callq 0x127be0
testb $0x1, %al
jne 0x117302
jmp 0x117304
jmp 0x117323
leaq 0x7368c(%rip), %rdi     # 0x18a997
leaq 0x72e64(%rip), %rsi     # 0x18a176
movl $0x807, %edx            # imm = 0x807
leaq 0x7361d(%rip), %rcx     # 0x18a93b
callq 0xd180
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x4(%rcx), %edx
cvtsi2ss %edx, %xmm0
movss 0x30(%rax), %xmm1
mulss %xmm1, %xmm0
movzwl 0x6(%rcx), %ecx
cvtsi2ss %ecx, %xmm1
mulss 0x34(%rax), %xmm1
leaq -0x28(%rbp), %rdi
callq 0xbf4c0
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
movq -0x10(%rbp), %rdx
movzwl (%rdx), %edx
addl %edx, %ecx
cvtsi2ss %ecx, %xmm0
mulss 0x30(%rax), %xmm0
movq -0x10(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
movq -0x10(%rbp), %rdx
movzwl 0x2(%rdx), %edx
addl %edx, %ecx
cvtsi2ss %ecx, %xmm1
mulss 0x34(%rax), %xmm1
leaq -0x30(%rbp), %rdi
callq 0xbf4c0
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movl -0x18(%rbp), %ecx
imull 0x10(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x118edb
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x118ebd
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x118e8c
jmp 0x118ebf
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
movl 0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x118e7f
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x470(%rax)
jge 0x118f47
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x118f29
movq -0x8(%rbp), %rdi
movl $0xd9, %esi
movl $0x1b, %edx
callq 0x117070
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x470(%rax)
jmp 0x118f45
movq -0x8(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x117070
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x470(%rax)
jmp 0x118f47
movq -0x8(%rbp), %rax
cmpl $0x0, 0x474(%rax)
jge 0x118f84
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x118f82
movq -0x8(%rbp), %rdi
movl $0x41, %esi
movl $0x40, %edx
callq 0x117070
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x474(%rax)
jmp 0x118f84
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: UnpackBitVectorToFlatIndexList(ImBitVector const*, ImVector<int>*)
static void UnpackBitVectorToFlatIndexList(const ImBitVector* in, ImVector<int>* out)
{
    IM_ASSERT(sizeof(in->Storage.Data[0]) == sizeof(int));
    const ImU32* it_begin = in->Storage.begin();
    const ImU32* it_end = in->Storage.end();
    for (const ImU32* it = it_begin; it < it_end; it++)
        if (ImU32 entries_32 = *it)
            for (ImU32 bit_n = 0; bit_n < 32; bit_n++)
                if (entries_32 & ((ImU32)1 << bit_n))
                    out->push_back((int)(((it - it_begin) << 5) + bit_n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1288b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1288d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x119619
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x119606
movl $0x0, -0x30(%rbp)
cmpl $0x20, -0x30(%rbp)
jae 0x119604
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1195f7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
shlq $0x5, %rax
movl -0x30(%rbp), %ecx
addq %rcx, %rax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0xeaaf0
jmp 0x1195f9
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1195b2
jmp 0x119606
jmp 0x119608
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x119592
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_GetGlyphBitmapBoxSubpixel(stbtt_fontinfo const*, int, float, float, float, float, int*, int*, int*, int*)
STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
{
   int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning
   if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) {
      // e.g. space character
      if (ix0) *ix0 = 0;
      if (iy0) *iy0 = 0;
      if (ix1) *ix1 = 0;
      if (iy1) *iy1 = 0;
   } else {
      // move to integral bboxes (treating pixels as little squares, what pixels get touched)?
      if (ix0) *ix0 = STBTT_ifloor( x0 * scale_x + shift_x);
      if (iy0) *iy0 = STBTT_ifloor(-y1 * scale_y + shift_y);
      if (ix1) *ix1 = STBTT_iceil ( x1 * scale_x + shift_x);
      if (iy1) *iy1 = STBTT_iceil (-y0 * scale_y + shift_y);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movss %xmm3, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x44(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x4c(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x11f980
cmpl $0x0, %eax
jne 0x11978b
cmpq $0x0, -0x28(%rbp)
je 0x119753
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x119764
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x119775
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x40(%rbp)
je 0x119786
movq -0x40(%rbp), %rax
movl $0x0, (%rax)
jmp 0x119849
cmpq $0x0, -0x28(%rbp)
je 0x1197b8
cvtsi2ssl -0x44(%rbp), %xmm0
movss -0x10(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xd750
cvttss2si %xmm0, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x1197e9
xorl %eax, %eax
subl -0x50(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0x14(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xd750
cvttss2si %xmm0, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x119816
cvtsi2ssl -0x4c(%rbp), %xmm0
movss -0x10(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xd3b0
cvttss2si %xmm0, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x40(%rbp)
je 0x119847
xorl %eax, %eax
subl -0x48(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss -0x14(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0xd3b0
cvttss2si %xmm0, %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
jmp 0x119849
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_PackBegin(stbtt_pack_context*, unsigned char*, int, int, int, int, void*)
STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pixels, int pw, int ph, int stride_in_bytes, int padding, void *alloc_context)
{
   stbrp_context *context = (stbrp_context *) STBTT_malloc(sizeof(*context)            ,alloc_context);
   int            num_nodes = pw - padding;
   stbrp_node    *nodes   = (stbrp_node    *) STBTT_malloc(sizeof(*nodes  ) * num_nodes,alloc_context);

   if (context == NULL || nodes == NULL) {
      if (context != NULL) STBTT_free(context, alloc_context);
      if (nodes   != NULL) STBTT_free(nodes  , alloc_context);
      return 0;
   }

   spc->user_allocator_context = alloc_context;
   spc->width = pw;
   spc->height = ph;
   spc->pixels = pixels;
   spc->pack_info = context;
   spc->nodes = nodes;
   spc->padding = padding;
   spc->stride_in_bytes = stride_in_bytes != 0 ? stride_in_bytes : pw;
   spc->h_oversample = 1;
   spc->v_oversample = 1;
   spc->skip_missing = 0;

   stbrp_init_target(context, pw-padding, ph-padding, nodes, num_nodes);

   if (pixels)
      STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x48, %edi
callq 0xc4820
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rdi
shlq $0x4, %rdi
callq 0xc4820
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1198a8
cmpq $0x0, -0x40(%rbp)
jne 0x1198d4
cmpq $0x0, -0x30(%rbp)
je 0x1198b8
movq -0x30(%rbp), %rdi
callq 0xc4920
cmpq $0x0, -0x40(%rbp)
je 0x1198c8
movq -0x40(%rbp), %rdi
callq 0xc4920
movl $0x0, -0x4(%rbp)
jmp 0x1199a0
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x11992f
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x119935
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl -0x28(%rbp), %esi
movl -0x20(%rbp), %edx
subl -0x28(%rbp), %edx
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %r8d
callq 0x121520
cmpq $0x0, -0x18(%rbp)
je 0x119999
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull -0x20(%rbp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0xd2f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x48(%rax)
jne 0x11a761
movq -0x10(%rbp), %rdi
callq 0x11aef0
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x50(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x5c(%rax)
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x60(%rax)
movq -0x10(%rbp), %rax
movw 0x50(%rax), %cx
addw $0x1, %cx
movw %cx, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rdi)
addq $0x28, %rdi
callq 0x128590
movq -0x10(%rbp), %rdi
callq 0xe92d0
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xedfe0
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movb $0x1, 0x56(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x60(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x5c(%rax)
movl $0x0, 0x64(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movb 0x18(%rbp), %al
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x31(%rbp)
jl 0x11afb1
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
setle %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11afba
jmp 0x11afbc
jmp 0x11afdb
leaq 0x6fcae(%rip), %rdi     # 0x18ac71
leaq 0x6f1ac(%rip), %rsi     # 0x18a176
movl $0x986, %edx            # imm = 0x986
leaq 0x6fcbe(%rip), %rcx     # 0x18ac94
callq 0xd180
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x32(%rbp)
jl 0x11aff9
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
setle %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x11b002
jmp 0x11b004
jmp 0x11b023
leaq 0x6fcfd(%rip), %rdi     # 0x18ad08
leaq 0x6f164(%rip), %rsi     # 0x18a176
movl $0x987, %edx            # imm = 0x987
leaq 0x6fc76(%rip), %rcx     # 0x18ac94
callq 0xd180
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x28(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x11b0de
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11b0a8
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x10(%rbp), %ecx
cmpl %ecx, %eax
jne 0x11b086
movzbl 0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x11b08d
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x11b08d
movl -0x38(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x11b061
jmp 0x11b0aa
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x11b04e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
jb 0x11b94e
movq $0x0, -0x8(%rbp)
jmp 0x11b98e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movzwl -0x12(%rbp), %ecx
movw (%rax,%rcx,2), %ax
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x11b977
movq $0x0, -0x8(%rbp)
jmp 0x11b98e
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movzwl -0x14(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11babd
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x11ba69
movq -0x20(%rbp), %rax
movw $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11bbc8
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11bbd2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl $0x0, %eax
je 0x11bc1f
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rdi
callq 0xc36d0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x11bc0e
jmp 0x11bc1f
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movzwl %ax, %esi
callq 0x1284a0
jmp 0x11bbac
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
movl $0x0, -0x18(%rbp)
cmpl $0xffff, -0x18(%rbp)    # imm = 0xFFFF
jg 0x11bd55
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x1284d0
testb $0x1, %al
jne 0x11bce6
jmp 0x11bd45
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movw %ax, -0x1a(%rbp)
leaq -0x1a(%rbp), %rsi
callq 0xe7ea0
xorl %eax, %eax
cmpl $0xffff, -0x18(%rbp)    # imm = 0xFFFF
movb %al, -0x29(%rbp)
jge 0x11bd1d
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1284d0
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x11bd26
jmp 0x11bd31
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11bcfa
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movw %ax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xe7ea0
jmp 0x11bd47
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11bcc6
movq -0x10(%rbp), %rdi
movw $0x0, -0x1e(%rbp)
leaq -0x1e(%rbp), %rsi
callq 0xe7ea0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xeccd0
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x20(%rbp)
callq 0xe7e30
jmp 0x11bda3
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x128520
jmp 0x11bdb2
movq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rdi)
movw $0x3f, 0x52(%rdi)
movw $0xffff, 0x54(%rdi)     # imm = 0xFFFF
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x48(%rdi)
movw $0x0, 0x50(%rdi)
movb $0x0, 0x56(%rdi)
movss 0x54e40(%rip), %xmm0    # 0x170c3c
movss %xmm0, 0x58(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x60(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x5c(%rdi)
movl $0x0, 0x64(%rdi)
addq $0x68, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd2f0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x11be51
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe7e60
movq -0x28(%rbp), %rdi
callq 0xecd30
movq -0x10(%rbp), %rdi
callq 0xd620
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl (%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x11bee0
jmp 0x11beff
leaq 0x6eee7(%rip), %rdi     # 0x18adce
leaq 0x6e288(%rip), %rsi     # 0x18a176
movl $0xb9d, %edx            # imm = 0xB9D
leaq 0x6eefb(%rip), %rcx     # 0x18adf5
callq 0xd180
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jg 0x11bf0d
jmp 0x11bf44
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movss 0x56064(%rip), %xmm0    # 0x171f80
movss %xmm0, -0x10(%rbp)
leaq -0x10(%rbp), %rdx
callq 0x128710
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0xc(%rbp), %esi
movw $0xffff, -0x12(%rbp)    # imm = 0xFFFF
leaq -0x12(%rbp), %rdx
callq 0x1287a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)