LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
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 0x11bf82
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11bfc6
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 0x11bfaf
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11bfc6
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
nopl (%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
shrl $0xc, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
shrl $0xc, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
ja 0x11c0b0
movl -0x24(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
cmpq $0x2, %rax
jae 0x11c0a3
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movzbl 0x68(%rax,%rcx), %eax
movl -0x24(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x11c0a1
movb $0x0, -0x1(%rbp)
jmp 0x11c0b4
jmp 0x11c0a3
jmp 0x11c0a5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x11c05e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %cl, %al
movw %dx, %cx
movw %si, %dx
movq %rdi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
movw %cx, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x18(%rax)
jle 0x11c121
jmp 0x11c140
leaq 0x6ece9(%rip), %rdi     # 0x18ae11
leaq 0x6e047(%rip), %rsi     # 0x18a176
movl $0xbd4, %edx            # imm = 0xBD4
leaq 0x6eceb(%rip), %rcx     # 0x18ae26
callq 0xd180
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movzwl -0xa(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11c175
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movzwl -0xa(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x11c175
testb $0x1, -0xd(%rbp)
jne 0x11c175
jmp 0x11c235
movzwl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jb 0x11c18c
movzwl -0xa(%rbp), %eax
cmpl -0x14(%rbp), %eax
jb 0x11c18c
jmp 0x11c235
movq -0x20(%rbp), %rdi
movzwl -0xa(%rbp), %esi
addl $0x1, %esi
callq 0x11bec0
movzwl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11c1bb
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movzwl -0xc(%rbp), %ecx
movw (%rax,%rcx,2), %ax
movw %ax, -0x22(%rbp)
jmp 0x11c1c5
movw $0xffff, %ax            # imm = 0xFFFF
movw %ax, -0x22(%rbp)
jmp 0x11c1c5
movq -0x20(%rbp), %rdi
movw -0x22(%rbp), %ax
movw %ax, -0x24(%rbp)
addq $0x18, %rdi
movzwl -0xa(%rbp), %esi
callq 0x1094a0
movw -0x24(%rbp), %cx
movw %cx, (%rax)
movzwl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11c206
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0xc(%rbp), %ecx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x11c215
movss 0x54a2e(%rip), %xmm0    # 0x170c3c
movss %xmm0, -0x28(%rbp)
jmp 0x11c215
movq -0x20(%rbp), %rdi
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movzwl -0xa(%rbp), %esi
callq 0xea950
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movw %cx, %ax
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movzwl -0x22(%rbp), %esi
callq 0x11bf50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x11c8be
movq -0x30(%rbp), %rax
movl (%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x11c8c3
jmp 0x11ca06
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x11c8e5
movq -0x60(%rbp), %rax
movss -0x1c(%rbp), %xmm0
divss 0x14(%rax), %xmm0
movss %xmm0, -0x64(%rbp)
jmp 0x11c8f4
movss 0x5434f(%rip), %xmm0    # 0x170c3c
movss %xmm0, -0x64(%rbp)
jmp 0x11c8f4
movss -0x64(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
cvttss2si -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x8(%rbp)
cvttss2si -0x4(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x4(%rbp)
movq -0x18(%rbp), %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x10f7f0
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movss -0x8(%rbp), %xmm1
movq -0x30(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x34(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x4(%rbp), %xmm2
movq -0x30(%rbp), %rax
movss 0xc(%rax), %xmm1
movss -0x34(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x3c(%rbp), %rdi
callq 0xbf4c0
movss -0x8(%rbp), %xmm1
movq -0x30(%rbp), %rax
movss 0x10(%rax), %xmm0
movss -0x34(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x4(%rbp), %xmm2
movq -0x30(%rbp), %rax
movss 0x14(%rax), %xmm1
movss -0x34(%rbp), %xmm3
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x44(%rbp), %rdi
callq 0xbf4c0
movq -0x30(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x30(%rbp), %rax
movss 0x1c(%rax), %xmm1
leaq -0x4c(%rbp), %rdi
callq 0xbf4c0
movq -0x30(%rbp), %rax
movss 0x20(%rax), %xmm0
movq -0x30(%rbp), %rax
movss 0x24(%rax), %xmm1
leaq -0x54(%rbp), %rdi
callq 0xbf4c0
movq -0x70(%rbp), %rdi
movl -0x20(%rbp), %r9d
leaq -0x3c(%rbp), %rsi
leaq -0x44(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
leaq -0x54(%rbp), %r8
callq 0x10fab0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movlpd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss 0x5594a(%rip), %xmm1    # 0x172750
divss %xmm1, %xmm0
movss 0x53e2a(%rip), %xmm1    # 0x170c3c
callq 0x10f610
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0x5519d(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x55168(%rip), %xmm0    # 0x171fb8
mulss -0x1c(%rbp), %xmm0
movss 0x5515b(%rip), %xmm1    # 0x171fb8
mulss -0x1c(%rbp), %xmm1
leaq -0x24(%rbp), %rdi
callq 0xbf4c0
leaq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x11cf90
movss -0x18(%rbp), %xmm0
movss 0x5513b(%rip), %xmm1    # 0x171fc0
divss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x8(%rbp), %xmm0
addss -0x28(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x4(%rbp), %xmm1
addss -0x18(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0x55117(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movss -0x2c(%rbp), %xmm0
subss -0x28(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
subss -0x28(%rbp), %xmm1
leaq -0x38(%rbp), %rdi
callq 0xbf4c0
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xee560
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
leaq -0x40(%rbp), %rdi
callq 0xbf4c0
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xee560
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movss -0x2c(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss -0x30(%rbp), %xmm2
movss -0x28(%rbp), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
addss %xmm1, %xmm1
addss %xmm2, %xmm1
leaq -0x48(%rbp), %rdi
callq 0xbf4c0
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xee560
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movss -0x1c(%rbp), %xmm0
xorl %edx, %edx
callq 0xee720
addq $0x60, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_GetFontOffsetForIndex_internal(unsigned char*, int)
static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_collection, int index)
{
   // if it's just a font, there's only one valid index
   if (stbtt__isfont(font_collection))
      return index == 0 ? 0 : -1;

   // check if it's a TTC
   if (stbtt_tag(font_collection, "ttcf")) {
      // version 1?
      if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) {
         stbtt_int32 n = ttLONG(font_collection+8);
         if (index >= n)
            return -1;
         return ttULONG(font_collection+12+index*4);
      }
   }
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11e610
cmpl $0x0, %eax
je 0x11e545
movl -0x14(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x11e607
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x6ca44(%rip), %ecx     # 0x18af97
cmpl %ecx, %eax
jne 0x11e600
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x6ca2e(%rip), %ecx     # 0x18af98
cmpl %ecx, %eax
jne 0x11e600
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x6ca18(%rip), %ecx     # 0x18af99
cmpl %ecx, %eax
jne 0x11e600
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x6ca06(%rip), %ecx     # 0x18af9a
cmpl %ecx, %eax
jne 0x11e600
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x11e7b0
cmpl $0x10000, %eax          # imm = 0x10000
je 0x11e5c0
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x11e7b0
cmpl $0x20000, %eax          # imm = 0x20000
jne 0x11e5fe
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x11e7f0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x11e5e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11e607
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movl -0x14(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rdi
callq 0x11e7b0
movl %eax, -0x4(%rbp)
jmp 0x11e607
jmp 0x11e600
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__isfont(unsigned char*)
static int stbtt__isfont(stbtt_uint8 *font)
{
   // check the version number
   if (stbtt_tag4(font, '1',0,0,0))  return 1; // TrueType 1
   if (stbtt_tag(font, "typ1"))   return 1; // TrueType with type 1 font -- we don't support this!
   if (stbtt_tag(font, "OTTO"))   return 1; // OpenType with CFF
   if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
   if (stbtt_tag(font, "true"))   return 1; // Apple specification for TrueType fonts
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x31, %eax
jne 0x11e657
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x11e657
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x11e657
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x11e657
movl $0x1, -0x4(%rbp)
jmp 0x11e79c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x6c937(%rip), %ecx     # 0x18af9c
cmpl %ecx, %eax
jne 0x11e6ae
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x6c925(%rip), %ecx     # 0x18af9d
cmpl %ecx, %eax
jne 0x11e6ae
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x6c913(%rip), %ecx     # 0x18af9e
cmpl %ecx, %eax
jne 0x11e6ae
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x6c901(%rip), %ecx     # 0x18af9f
cmpl %ecx, %eax
jne 0x11e6ae
movl $0x1, -0x4(%rbp)
jmp 0x11e79c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x6c8e5(%rip), %ecx     # 0x18afa1
cmpl %ecx, %eax
jne 0x11e705
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x6c8d3(%rip), %ecx     # 0x18afa2
cmpl %ecx, %eax
jne 0x11e705
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x6c8c1(%rip), %ecx     # 0x18afa3
cmpl %ecx, %eax
jne 0x11e705
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x6c8af(%rip), %ecx     # 0x18afa4
cmpl %ecx, %eax
jne 0x11e705
movl $0x1, -0x4(%rbp)
jmp 0x11e79c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11e741
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x11e741
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x11e741
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x11e741
movl $0x1, -0x4(%rbp)
jmp 0x11e79c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x551e9(%rip), %ecx     # 0x173938
cmpl %ecx, %eax
jne 0x11e795
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x551d7(%rip), %ecx     # 0x173939
cmpl %ecx, %eax
jne 0x11e795
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x551c5(%rip), %ecx     # 0x17393a
cmpl %ecx, %eax
jne 0x11e795
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x551b3(%rip), %ecx     # 0x17393b
cmpl %ecx, %eax
jne 0x11e795
movl $0x1, -0x4(%rbp)
jmp 0x11e79c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__new_buf(void const*, unsigned long)
static stbtt__buf stbtt__new_buf(const void *p, size_t size)
{
   stbtt__buf r;
   STBTT_assert(size < 0x40000000);
   r.data = (stbtt_uint8*) p;
   r.size = (int) size;
   r.cursor = 0;
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
cmpq $0x40000000, -0x20(%rbp) # imm = 0x40000000
jae 0x11ef5c
jmp 0x11ef7b
leaq 0x6c075(%rip), %rdi     # 0x18afd8
leaq 0x6c080(%rip), %rsi     # 0x18afea
movl $0x482, %edx            # imm = 0x482
leaq 0x6c093(%rip), %rcx     # 0x18b009
callq 0xd180
jmp 0x11ef7d
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x11f5b0
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0xc, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x11f07c
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x11f06c
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl 0x1(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11f06c
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl 0x2(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11f06c
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
movzbl 0x3(%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11f06c
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %eax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x11e7b0
movl %eax, -0x4(%rbp)
jmp 0x11f083
jmp 0x11f06e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11efdc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x11f5d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x11f253
movq -0x18(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x24(%rbp)
movb %al, -0x25(%rbp)
jl 0x11f1f5
cmpl $0x4, -0x24(%rbp)
setle %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x11f1fe
jmp 0x11f200
jmp 0x11f21f
leaq 0x6be72(%rip), %rdi     # 0x18b079
leaq 0x6bddc(%rip), %rsi     # 0x18afea
movl $0x49c, %edx            # imm = 0x49C
leaq 0x6be7c(%rip), %rcx     # 0x18b096
callq 0xd180
jmp 0x11f221
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
imull -0x1c(%rbp), %esi
callq 0x11f090
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x11f5d0
movq -0x30(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x11f090
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movl 0x8(%rdi), %edx
subl %esi, %edx
callq 0x11f530
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x11f0c0
leaq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x11f5d0
movl %eax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x35(%rbp)
jl 0x11f2d5
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
setl %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x11f2de
jmp 0x11f2e0
jmp 0x11f2ff
leaq 0x6be1d(%rip), %rdi     # 0x18b104
leaq 0x6bcfc(%rip), %rsi     # 0x18afea
movl $0x4e1, %edx            # imm = 0x4E1
leaq 0x6be1e(%rip), %rcx     # 0x18b118
callq 0xd180
jmp 0x11f301
jmp 0x11f303
xorl %eax, %eax
cmpl $0x1, -0x2c(%rbp)
movb %al, -0x36(%rbp)
jl 0x11f318
cmpl $0x4, -0x2c(%rbp)
setle %al
movb %al, -0x36(%rbp)
movb -0x36(%rbp), %al
testb $0x1, %al
jne 0x11f321
jmp 0x11f323
jmp 0x11f342
leaq 0x6bd4f(%rip), %rdi     # 0x18b079
leaq 0x6bcb9(%rip), %rsi     # 0x18afea
movl $0x4e2, %edx            # imm = 0x4E2
leaq 0x6bddb(%rip), %rcx     # 0x18b118
callq 0xd180
jmp 0x11f344
movl -0x24(%rbp), %esi
movl -0x2c(%rbp), %eax
imull %eax, %esi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x11f090
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x11f5d0
movq -0x40(%rbp), %rdi
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %esi
callq 0x11f5d0
movq -0x40(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %esi
incl %esi
movl -0x2c(%rbp), %eax
imull %eax, %esi
movl -0x30(%rbp), %eax
movl %eax, %edx
movl %esi, %ecx
leal 0x2(%rcx,%rdx), %esi
movl -0x34(%rbp), %edx
subl %eax, %edx
callq 0x11f530
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x11f670
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x11f40a
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x11f413
jmp 0x11f434
leaq -0x30(%rbp), %rdi
callq 0x11f750
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11f3f1
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__get_subrs(stbtt__buf, stbtt__buf)
static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
{
   stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
   stbtt__buf pdict;
   stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
   if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
   pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
   stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
   if (!subrsoff) return stbtt__new_buf(NULL, 0);
   stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
   return stbtt__cff_get_index(&cff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xd2f0
leaq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x11f3c0
cmpl $0x0, -0x38(%rbp)
je 0x11f492
cmpl $0x0, -0x3c(%rbp)
jne 0x11f4a8
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x11ef40
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x11f522
movl -0x38(%rbp), %esi
movl -0x3c(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0x11f530
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x13, %esi
movl $0x1, %edx
leaq -0x34(%rbp), %rcx
callq 0x11f3c0
cmpl $0x0, -0x34(%rbp)
jne 0x11f502
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x11ef40
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x11f522
movl -0x38(%rbp), %esi
addl -0x34(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x11f0c0
leaq -0x20(%rbp), %rdi
callq 0x11f1a0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__buf_range(stbtt__buf const*, int, int)
static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)
{
   stbtt__buf r = stbtt__new_buf(NULL, 0);
   if (o < 0 || s < 0 || o > b->size || s > b->size - o) return r;
   r.data = b->data + o;
   r.size = s;
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x11ef40
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x11f57f
cmpl $0x0, -0x20(%rbp)
jl 0x11f57f
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x11f57f
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jle 0x11f581
jmp 0x11f599
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__buf_get(stbtt__buf*, int)
static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)
{
   stbtt_uint32 v = 0;
   int i;
   STBTT_assert(n >= 1 && n <= 4);
   for (i = 0; i < n; i++)
      v = (v << 8) | stbtt__buf_get8(b);
   return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jl 0x11f5fb
cmpl $0x4, -0xc(%rbp)
setle %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x11f604
jmp 0x11f606
jmp 0x11f625
leaq 0x6bab7(%rip), %rdi     # 0x18b0c4
leaq 0x6b9d6(%rip), %rsi     # 0x18afea
movl $0x479, %edx            # imm = 0x479
leaq 0x6bab5(%rip), %rcx     # 0x18b0d5
callq 0xd180
jmp 0x11f627
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11f660
movl -0x10(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11f150
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11f62e
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__dict_get(stbtt__buf*, int)
static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)
{
   stbtt__buf_seek(b, 0);
   while (b->cursor < b->size) {
      int start = b->cursor, end, op;
      while (stbtt__buf_peek8(b) >= 28)
         stbtt__cff_skip_operand(b);
      end = b->cursor;
      op = stbtt__buf_get8(b);
      if (op == 12)  op = stbtt__buf_get8(b) | 0x100;
      if (op == key) return stbtt__buf_range(b, start, end-start);
   }
   return stbtt__buf_range(b, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x11f0c0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x11f720
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11f870
movzbl %al, %eax
cmpl $0x1c, %eax
jl 0x11f6c4
movq -0x18(%rbp), %rdi
callq 0x11f8b0
jmp 0x11f6a8
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0xc, -0x28(%rbp)
jne 0x11f6f7
movq -0x18(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x11f71b
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
subl -0x20(%rbp), %edx
callq 0x11f530
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x11f735
jmp 0x11f68a
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x11f530
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__cff_int(stbtt__buf*)
static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
{
   int b0 = stbtt__buf_get8(b);
   if (b0 >= 32 && b0 <= 246)       return b0 - 139;
   else if (b0 >= 247 && b0 <= 250) return (b0 - 247)*256 + stbtt__buf_get8(b) + 108;
   else if (b0 >= 251 && b0 <= 254) return -(b0 - 251)*256 - stbtt__buf_get8(b) - 108;
   else if (b0 == 28)               return stbtt__buf_get16(b);
   else if (b0 == 29)               return stbtt__buf_get32(b);
   STBTT_assert(0);
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jl 0x11f78a
cmpl $0xf6, -0x14(%rbp)
jg 0x11f78a
movl -0x14(%rbp), %eax
subl $0x8b, %eax
movl %eax, -0x4(%rbp)
jmp 0x11f863
cmpl $0xf7, -0x14(%rbp)
jl 0x11f7c8
cmpl $0xfa, -0x14(%rbp)
jg 0x11f7c8
movl -0x14(%rbp), %eax
subl $0xf7, %eax
shll $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f150
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
addl %ecx, %eax
addl $0x6c, %eax
movl %eax, -0x4(%rbp)
jmp 0x11f863
cmpl $0xfb, -0x14(%rbp)
jl 0x11f808
cmpl $0xfe, -0x14(%rbp)
jg 0x11f808
movl -0x14(%rbp), %ecx
subl $0xfb, %ecx
xorl %eax, %eax
subl %ecx, %eax
shll $0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f150
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
subl $0x6c, %eax
movl %eax, -0x4(%rbp)
jmp 0x11f863
cmpl $0x1c, -0x14(%rbp)
jne 0x11f821
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11f5d0
movl %eax, -0x4(%rbp)
jmp 0x11f863
cmpl $0x1d, -0x14(%rbp)
jne 0x11f83a
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x11f5d0
movl %eax, -0x4(%rbp)
jmp 0x11f863
jmp 0x11f83c
jmp 0x11f83e
jmp 0x11f840
jmp 0x11f842
jmp 0x11f844
leaq 0x558bf(%rip), %rdi     # 0x17510a
leaq 0x6b798(%rip), %rsi     # 0x18afea
movl $0x4ab, %edx            # imm = 0x4AB
leaq 0x6b91f(%rip), %rcx     # 0x18b17d
callq 0xd180
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__cff_skip_operand(stbtt__buf*)
static void stbtt__cff_skip_operand(stbtt__buf *b) {
   int v, b0 = stbtt__buf_peek8(b);
   STBTT_assert(b0 >= 28);
   if (b0 == 30) {
      stbtt__buf_skip(b, 1);
      while (b->cursor < b->size) {
         v = stbtt__buf_get8(b);
         if ((v & 0xF) == 0xF || (v >> 4) == 0xF)
            break;
      }
   } else {
      stbtt__cff_int(b);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11f870
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x1c, -0x10(%rbp)
jl 0x11f8d3
jmp 0x11f8f2
leaq 0x6b86f(%rip), %rdi     # 0x18b149
leaq 0x6b709(%rip), %rsi     # 0x18afea
movl $0x4b1, %edx            # imm = 0x4B1
leaq 0x6b865(%rip), %rcx     # 0x18b152
callq 0xd180
jmp 0x11f8f4
cmpl $0x1e, -0x10(%rbp)
jne 0x11f943
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x11f090
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x11f941
movq -0x8(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf, %eax
cmpl $0xf, %eax
je 0x11f93d
movl -0xc(%rbp), %eax
sarl $0x4, %eax
cmpl $0xf, %eax
jne 0x11f93f
jmp 0x11f941
jmp 0x11f908
jmp 0x11f94c
movq -0x8(%rbp), %rdi
callq 0x11f750
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt_GetGlyphBox(stbtt_fontinfo const*, int, int*, int*, int*, int*)
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   if (info->cff.size) {
      stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
   } else {
      int g = stbtt__GetGlyfOffset(info, glyph_index);
      if (g < 0) return 0;

      if (x0) *x0 = ttSHORT(info->data + g + 2);
      if (y0) *y0 = ttSHORT(info->data + g + 4);
      if (x1) *x1 = ttSHORT(info->data + g + 6);
      if (y1) *y1 = ttSHORT(info->data + g + 8);
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x11f9ca
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x11faa0
jmp 0x11fa8d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x11fbb0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x11f9eb
movl $0x0, -0x4(%rbp)
jmp 0x11fa94
cmpq $0x0, -0x20(%rbp)
je 0x11fa13
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x2, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x11fa3b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x11fa63
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x6, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x11fa8b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x11f960
movswl %ax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0x11fa8d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__GetGlyphInfoT2(stbtt_fontinfo const*, int, int*, int*, int*, int*)
static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   stbtt__csctx c = STBTT__CSCTX_INIT(1);
   int r = stbtt__run_charstring(info, glyph_index, &c);
   if (x0)  *x0 = r ? c.min_x : 0;
   if (y0)  *y0 = r ? c.min_y : 0;
   if (x1)  *x1 = r ? c.max_x : 0;
   if (y1)  *y1 = r ? c.max_y : 0;
   return r ? c.num_vertices : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xd2f0
movl $0x1, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x68(%rbp), %rdx
callq 0x11fd50
movl %eax, -0x6c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11fb11
cmpl $0x0, -0x6c(%rbp)
je 0x11fb01
movl -0x50(%rbp), %eax
movl %eax, -0x70(%rbp)
jmp 0x11fb08
xorl %eax, %eax
movl %eax, -0x70(%rbp)
jmp 0x11fb08
movl -0x70(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x11fb36
cmpl $0x0, -0x6c(%rbp)
je 0x11fb26
movl -0x48(%rbp), %eax
movl %eax, -0x74(%rbp)
jmp 0x11fb2d
xorl %eax, %eax
movl %eax, -0x74(%rbp)
jmp 0x11fb2d
movl -0x74(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x11fb5b
cmpl $0x0, -0x6c(%rbp)
je 0x11fb4b
movl -0x4c(%rbp), %eax
movl %eax, -0x78(%rbp)
jmp 0x11fb52
xorl %eax, %eax
movl %eax, -0x78(%rbp)
jmp 0x11fb52
movl -0x78(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x11fb80
cmpl $0x0, -0x6c(%rbp)
je 0x11fb70
movl -0x44(%rbp), %eax
movl %eax, -0x7c(%rbp)
jmp 0x11fb77
xorl %eax, %eax
movl %eax, -0x7c(%rbp)
jmp 0x11fb77
movl -0x7c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x6c(%rbp)
je 0x11fb8e
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
jmp 0x11fb95
xorl %eax, %eax
movl %eax, -0x80(%rbp)
jmp 0x11fb95
movl -0x80(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__csctx_rmove_to(stbtt__csctx*, float, float)
static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)
{
   stbtt__csctx_close_shape(ctx);
   ctx->first_x = ctx->x = ctx->x + dx;
   ctx->first_y = ctx->y = ctx->y + dy;
   stbtt__csctx_v(ctx, STBTT_vmove, (int)ctx->x, (int)ctx->y, 0, 0, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x121280
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
addss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
addss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
cvttss2si 0x10(%rax), %edx
movq -0x8(%rbp), %rax
cvttss2si 0x14(%rax), %ecx
movl $0x1, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x121300
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__csctx_rccurve_to(stbtt__csctx*, float, float, float, float, float, float)
static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float dy1, float dx2, float dy2, float dx3, float dy3)
{
   float cx1 = ctx->x + dx1;
   float cy1 = ctx->y + dy1;
   float cx2 = cx1 + dx2;
   float cy2 = cy1 + dy2;
   ctx->x = cx2 + dx3;
   ctx->y = cy2 + dy3;
   stbtt__csctx_v(ctx, STBTT_vcubic, (int)ctx->x, (int)ctx->y, (int)cx1, (int)cy1, (int)cx2, (int)cy2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss %xmm4, -0x1c(%rbp)
movss %xmm5, -0x20(%rbp)
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
addss -0xc(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
addss -0x10(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
addss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x30(%rbp), %xmm0
addss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
cvttss2si 0x10(%rax), %edx
movq -0x8(%rbp), %rax
cvttss2si 0x14(%rax), %ecx
cvttss2si -0x24(%rbp), %r8d
cvttss2si -0x28(%rbp), %r9d
cvttss2si -0x2c(%rbp), %r10d
cvttss2si -0x30(%rbp), %eax
movl $0x4, %esi
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x121300
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__cid_get_glyph_subrs(stbtt_fontinfo const*, int)
static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info, int glyph_index)
{
   stbtt__buf fdselect = info->fdselect;
   int nranges, start, end, v, fmt, fdselector = -1, i;

   stbtt__buf_seek(&fdselect, 0);
   fmt = stbtt__buf_get8(&fdselect);
   if (fmt == 0) {
      // untested
      stbtt__buf_skip(&fdselect, glyph_index);
      fdselector = stbtt__buf_get8(&fdselect);
   } else if (fmt == 3) {
      nranges = stbtt__buf_get16(&fdselect);
      start = stbtt__buf_get16(&fdselect);
      for (i = 0; i < nranges; i++) {
         v = stbtt__buf_get8(&fdselect);
         end = stbtt__buf_get16(&fdselect);
         if (glyph_index >= start && glyph_index < end) {
            fdselector = v;
            break;
         }
         start = end;
      }
   }
   if (fdselector == -1) stbtt__new_buf(NULL, 0);
   return stbtt__get_subrs(info->cff, stbtt__cff_index_get(info->fontdicts, fdselector));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x11f0c0
leaq -0x30(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x1210c3
movl -0x1c(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x11f090
leaq -0x30(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x48(%rbp)
jmp 0x121147
cmpl $0x3, -0x44(%rbp)
jne 0x121145
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x11f5d0
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x11f5d0
movl %eax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x121143
leaq -0x30(%rbp), %rdi
callq 0x11f150
movzbl %al, %eax
movl %eax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x11f5d0
movl %eax, -0x3c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jl 0x121132
movl -0x1c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x121132
movl -0x40(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x121143
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1210f2
jmp 0x121145
jmp 0x121147
cmpl $-0x1, -0x48(%rbp)
jne 0x121161
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x11ef40
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x18(%rbp), %rax
movups 0x40(%rax), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x18(%rbp), %rax
movups 0x80(%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x48(%rbp), %edx
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x11f280
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
callq 0x11f440
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__get_subr(stbtt__buf, int)
static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
{
   int count = stbtt__cff_index_count(&idx);
   int bias = 107;
   if (count >= 33900)
      bias = 32768;
   else if (count >= 1240)
      bias = 1131;
   n += bias;
   if (n < 0 || n >= count)
      return stbtt__new_buf(NULL, 0);
   return stbtt__cff_index_get(idx, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1214f0
movl %eax, -0x28(%rbp)
movl $0x6b, -0x2c(%rbp)
cmpl $0x846c, -0x28(%rbp)    # imm = 0x846C
jl 0x121208
movl $0x8000, -0x2c(%rbp)    # imm = 0x8000
jmp 0x12121a
cmpl $0x4d8, -0x28(%rbp)     # imm = 0x4D8
jl 0x121218
movl $0x46b, -0x2c(%rbp)     # imm = 0x46B
jmp 0x12121a
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x121231
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x121247
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x11ef40
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x12126f
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %edx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11f280
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__csctx_v(stbtt__csctx*, unsigned char, int, int, int, int, int, int)
static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)
{
   if (c->bounds) {
      stbtt__track_vertex(c, x, y);
      if (type == STBTT_vcubic) {
         stbtt__track_vertex(c, cx, cy);
         stbtt__track_vertex(c, cx1, cy1);
      }
   } else {
      stbtt_setvertex(&c->pvertices[c->num_vertices], type, x, y, cx, cy);
      c->pvertices[c->num_vertices].cx1 = (stbtt_int16) cx1;
      c->pvertices[c->num_vertices].cy1 = (stbtt_int16) cy1;
   }
   c->num_vertices++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl 0x18(%rbp), %esi
movl 0x10(%rbp), %esi
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x121367
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x1213f0
movzbl -0x9(%rbp), %eax
cmpl $0x4, %eax
jne 0x121365
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x1213f0
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %esi
movl 0x18(%rbp), %edx
callq 0x1213f0
jmp 0x1213d9
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rax
imulq $0xe, %rax, %rax
addq %rax, %rdi
movb -0x9(%rbp), %al
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movzbl %al, %esi
callq 0x121490
movl 0x10(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0xe, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movl 0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x30(%rdx), %rdx
imulq $0xe, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0xa(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imstb_truetype.h
// Function: stbtt__track_vertex(stbtt__csctx*, int, int)
static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_int32 y)
{
   if (x > c->max_x || !c->started) c->max_x = x;
   if (y > c->max_y || !c->started) c->max_y = y;
   if (x < c->min_x || !c->started) c->min_x = x;
   if (y < c->min_y || !c->started) c->min_y = y;
   c->started = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jg 0x121414
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x12141e
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jg 0x121434
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x12143e
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x121454
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x12145e
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0x121474
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x12147e
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
popq %rbp
retq
nopl (%rax,%rax)