LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImTextCountCharsFromUtf8(char const*, char const*)
int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end)
{
    int char_count = 0;
    while ((!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c;
        in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
        if (c == 0)
            break;
        char_count++;
    }
    return char_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc547d
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0xc548a
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xc5493
jmp 0xc54c7
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xc36d0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xc54bc
jmp 0xc54c7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc5467
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImTextStrToUtf8(char*, int, unsigned short const*, unsigned short const*)
int ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end)
{
    char* buf_out = buf;
    const char* buf_end = buf + buf_size;
    while (buf_out < buf_end - 1 && (!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c = (unsigned int)(*in_text++);
        if (c < 0x80)
            *buf_out++ = (char)c;
        else
            buf_out += ImTextCharToUtf8(buf_out, (int)(buf_end - buf_out - 1), c);
    }
    *buf_out = 0;
    return (int)(buf_out - buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
addq $-0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x35(%rbp)
jae 0xc5568
cmpq $0x0, -0x20(%rbp)
je 0xc555a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x35(%rbp)
jae 0xc5568
movq -0x18(%rbp), %rax
cmpw $0x0, (%rax)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xc5571
jmp 0xc55d9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x18(%rbp)
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x80, -0x34(%rbp)
jae 0xc55a7
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0xc55d4
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, %esi
movl -0x34(%rbp), %edx
callq 0xc5600
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xc552e
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImTextCharToUtf8(char*, int, unsigned int)
static inline int ImTextCharToUtf8(char* buf, int buf_size, unsigned int c)
{
    if (c < 0x80)
    {
        buf[0] = (char)c;
        return 1;
    }
    if (c < 0x800)
    {
        if (buf_size < 2) return 0;
        buf[0] = (char)(0xc0 + (c >> 6));
        buf[1] = (char)(0x80 + (c & 0x3f));
        return 2;
    }
    if (c < 0x10000)
    {
        if (buf_size < 3) return 0;
        buf[0] = (char)(0xe0 + (c >> 12));
        buf[1] = (char)(0x80 + ((c >> 6) & 0x3f));
        buf[2] = (char)(0x80 + ((c ) & 0x3f));
        return 3;
    }
    if (c <= 0x10FFFF)
    {
        if (buf_size < 4) return 0;
        buf[0] = (char)(0xf0 + (c >> 18));
        buf[1] = (char)(0x80 + ((c >> 12) & 0x3f));
        buf[2] = (char)(0x80 + ((c >> 6) & 0x3f));
        buf[3] = (char)(0x80 + ((c ) & 0x3f));
        return 4;
    }
    // Invalid code point, the max unicode is 0x10FFFF
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jae 0xc562e
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xc575b
cmpl $0x800, -0x18(%rbp)     # imm = 0x800
jae 0xc567c
cmpl $0x2, -0x14(%rbp)
jge 0xc5649
movl $0x0, -0x4(%rbp)
jmp 0xc575b
movl -0x18(%rbp), %eax
shrl $0x6, %eax
addl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0xc575b
cmpl $0x10000, -0x18(%rbp)   # imm = 0x10000
jae 0xc56de
cmpl $0x3, -0x14(%rbp)
jge 0xc5697
movl $0x0, -0x4(%rbp)
jmp 0xc575b
movl -0x18(%rbp), %eax
shrl $0xc, %eax
addl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
jmp 0xc575b
cmpl $0x10ffff, -0x18(%rbp)  # imm = 0x10FFFF
ja 0xc5754
cmpl $0x4, -0x14(%rbp)
jge 0xc56f6
movl $0x0, -0x4(%rbp)
jmp 0xc575b
movl -0x18(%rbp), %eax
shrl $0x12, %eax
addl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x18(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
jmp 0xc575b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImTextCountUtf8BytesFromStr(unsigned short const*, unsigned short const*)
int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end)
{
    int bytes_count = 0;
    while ((!in_text_end || in_text < in_text_end) && *in_text)
    {
        unsigned int c = (unsigned int)(*in_text++);
        if (c < 0x80)
            bytes_count++;
        else
            bytes_count += ImTextCountUtf8BytesFromChar(c);
    }
    return bytes_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc578d
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0xc579b
movq -0x8(%rbp), %rax
cmpw $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xc57a4
jmp 0xc57dd
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jae 0xc57cd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc57db
movl -0x18(%rbp), %edi
callq 0xc57f0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xc5777
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImTextCountUtf8BytesFromChar(unsigned int)
static inline int ImTextCountUtf8BytesFromChar(unsigned int c)
{
    if (c < 0x80) return 1;
    if (c < 0x800) return 2;
    if (c < 0x10000) return 3;
    if (c <= 0x10FFFF) return 4;
    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0xc5809
movl $0x1, -0x4(%rbp)
jmp 0xc5846
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jae 0xc581b
movl $0x2, -0x4(%rbp)
jmp 0xc5846
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0xc582d
movl $0x3, -0x4(%rbp)
jmp 0xc5846
cmpl $0x10ffff, -0x8(%rbp)   # imm = 0x10FFFF
ja 0xc583f
movl $0x4, -0x4(%rbp)
jmp 0xc5846
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImAlphaBlendColors(unsigned int, unsigned int)
IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b)
{
    float t = ((col_b >> IM_COL32_A_SHIFT) & 0xFF) / 255.f;
    int r = ImLerp((int)(col_a >> IM_COL32_R_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_R_SHIFT) & 0xFF, t);
    int g = ImLerp((int)(col_a >> IM_COL32_G_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_G_SHIFT) & 0xFF, t);
    int b = ImLerp((int)(col_a >> IM_COL32_B_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_B_SHIFT) & 0xFF, t);
    return IM_COL32(r, g, b, 0xFF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movzbl -0x5(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss 0xaceee(%rip), %xmm1    # 0x17275c
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x4(%rbp), %edi
shrl $0x0, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x0, %esi
andl $0xff, %esi
movss -0xc(%rbp), %xmm0
callq 0xc5910
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
shrl $0x8, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
movss -0xc(%rbp), %xmm0
callq 0xc5910
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edi
shrl $0x10, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x10, %esi
andl $0xff, %esi
movss -0xc(%rbp), %xmm0
callq 0xc5910
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x10, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x10(%rbp), %ecx
shll $0x0, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ColorConvertU32ToFloat4(unsigned int)
ImVec4 ImGui::ColorConvertU32ToFloat4(ImU32 in)
{
    float s = 1.0f / 255.0f;
    return ImVec4(
        ((in >> IM_COL32_R_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_G_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_B_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_A_SHIFT) & 0xFF) * s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x14(%rbp)
movl $0x3b808081, -0x18(%rbp) # imm = 0x3B808081
movl -0x14(%rbp), %eax
movb %al, %cl
movzbl %cl, %ecx
cvtsi2ss %ecx, %xmm0
movss -0x18(%rbp), %xmm4
mulss %xmm4, %xmm0
movb %ah, %cl
movzbl %cl, %ecx
cvtsi2ss %ecx, %xmm1
mulss %xmm4, %xmm1
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
cvtsi2ss %ecx, %xmm2
mulss %xmm4, %xmm2
shrl $0x18, %eax
cvtsi2ss %eax, %xmm3
mulss %xmm4, %xmm3
leaq -0x10(%rbp), %rdi
callq 0xbf4f0
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ColorConvertFloat4ToU32(ImVec4 const&)
ImU32 ImGui::ColorConvertFloat4ToU32(const ImVec4& in)
{
    ImU32 out;
    out  = ((ImU32)IM_F32_TO_INT8_SAT(in.x)) << IM_COL32_R_SHIFT;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.y)) << IM_COL32_G_SHIFT;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.z)) << IM_COL32_B_SHIFT;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.w)) << IM_COL32_A_SHIFT;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
callq 0xc5aa0
movss 0xacd7b(%rip), %xmm1    # 0x17275c
mulss %xmm1, %xmm0
movss 0xac5eb(%rip), %xmm1    # 0x171fd8
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
shll $0x0, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
callq 0xc5aa0
movss 0xacd4b(%rip), %xmm1    # 0x17275c
mulss %xmm1, %xmm0
movss 0xac5bb(%rip), %xmm1    # 0x171fd8
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
callq 0xc5aa0
movss 0xacd18(%rip), %xmm1    # 0x17275c
mulss %xmm1, %xmm0
movss 0xac588(%rip), %xmm1    # 0x171fd8
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
callq 0xc5aa0
movss 0xacce5(%rip), %xmm1    # 0x17275c
mulss %xmm1, %xmm0
movss 0xac555(%rip), %xmm1    # 0x171fd8
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ColorConvertRGBtoHSV(float, float, float, float&, float&, float&)
void ImGui::ColorConvertRGBtoHSV(float r, float g, float b, float& out_h, float& out_s, float& out_v)
{
    float K = 0.f;
    if (g < b)
    {
        ImSwap(g, b);
        K = -1.f;
    }
    if (r < g)
    {
        ImSwap(r, g);
        K = -2.f / 6.f - K;
    }

    const float chroma = r - (g < b ? g : b);
    out_h = ImFabs(K + (g - b) / (6.f * chroma + 1e-20f));
    out_s = chroma / (r + 1e-20f);
    out_v = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc5b54
leaq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xc5c40
movss 0xac431(%rip), %xmm0    # 0x171f80
movss %xmm0, -0x2c(%rbp)
movss -0x4(%rbp), %xmm1
movss -0x8(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc5b82
leaq -0x4(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0xc5c40
movss 0xacbe8(%rip), %xmm0    # 0x172760
subss -0x2c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xc5ba7
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0xc5bb1
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
movss -0x38(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
subss -0xc(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movss 0xac400(%rip), %xmm3    # 0x171fe0
mulss %xmm3, %xmm2
movss 0xacb78(%rip), %xmm3    # 0x172764
addss %xmm3, %xmm2
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movaps 0xacc01(%rip), %xmm1    # 0x172800
pand %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x30(%rbp), %xmm0
movss 0xacb4c(%rip), %xmm1    # 0x172764
addss -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x4(%rbp), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::GetInt(unsigned int, int) const
int ImGuiStorage::GetInt(ImGuiID key, int default_val) const
{
    ImGuiStoragePair* it = LowerBound(const_cast<ImVector<ImGuiStoragePair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return default_val;
    return it->val_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xc5fb0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xe7f50
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xc5f8e
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xc5f96
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc5fa0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>&, unsigned int)
static ImGuiStorage::ImGuiStoragePair* LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>& data, ImGuiID key)
{
    ImGuiStorage::ImGuiStoragePair* first = data.Data;
    ImGuiStorage::ImGuiStoragePair* last = data.Data + data.Size;
    size_t count = (size_t)(last - first);
    while (count > 0)
    {
        size_t count2 = count >> 1;
        ImGuiStorage::ImGuiStoragePair* mid = first + count2;
        if (mid->key < key)
        {
            first = ++mid;
            count -= count2 + 1;
        }
        else
        {
            count = count2;
        }
    }
    return first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0xc6053
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jae 0xc6049
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xc6051
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xc5ff4
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::GetFloat(unsigned int, float) const
float ImGuiStorage::GetFloat(ImGuiID key, float default_val) const
{
    ImGuiStoragePair* it = LowerBound(const_cast<ImVector<ImGuiStoragePair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return default_val;
    return it->val_f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xc5fb0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xe7f50
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xc60f0
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xc60fc
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xc610a
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::GetVoidPtr(unsigned int) const
void* ImGuiStorage::GetVoidPtr(ImGuiID key) const
{
    ImGuiStoragePair* it = LowerBound(const_cast<ImVector<ImGuiStoragePair>&>(Data), key);
    if (it == Data.end() || it->key != key)
        return NULL;
    return it->val_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xc5fb0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xe7f50
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0xc616b
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xc6175
movq $0x0, -0x8(%rbp)
jmp 0xc6181
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::GetIntRef(unsigned int, int)
int* ImGuiStorage::GetIntRef(ImGuiID key, int default_val)
{
    ImGuiStoragePair* it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
        it = Data.insert(it, ImGuiStoragePair(key, default_val));
    return &it->val_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xc5fb0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xe7f70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xc61de
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc620a
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0xe80d0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xe7f90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::GetFloatRef(unsigned int, float)
float* ImGuiStorage::GetFloatRef(ImGuiID key, float default_val)
{
    ImGuiStoragePair* it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
        it = Data.insert(it, ImGuiStoragePair(key, default_val));
    return &it->val_f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xc5fb0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xe7f70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xc62b0
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc62de
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movss -0x10(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0xe80f0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xe7f90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::GetVoidPtrRef(unsigned int, void*)
void** ImGuiStorage::GetVoidPtrRef(ImGuiID key, void* default_val)
{
    ImGuiStoragePair* it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
        it = Data.insert(it, ImGuiStoragePair(key, default_val));
    return &it->val_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0xc5fb0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xe7f70
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xc633f
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc636c
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xe8120
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xe7f90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::SetInt(unsigned int, int)
void ImGuiStorage::SetInt(ImGuiID key, int val)
{
    ImGuiStoragePair* it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
    {
        Data.insert(it, ImGuiStoragePair(key, val));
        return;
    }
    it->val_i = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xc5fb0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xe7f70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xc63ce
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc63f8
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0xe80d0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xe7f90
jmp 0xc6402
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::SetFloat(unsigned int, float)
void ImGuiStorage::SetFloat(ImGuiID key, float val)
{
    ImGuiStoragePair* it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
    {
        Data.insert(it, ImGuiStoragePair(key, val));
        return;
    }
    it->val_f = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xc5fb0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xe7f70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xc64a0
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc64cc
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movss -0x10(%rbp), %xmm0
leaq -0x28(%rbp), %rdi
callq 0xe80f0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xe7f90
jmp 0xc64da
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStorage::SetVoidPtr(unsigned int, void*)
void ImGuiStorage::SetVoidPtr(ImGuiID key, void* val)
{
    ImGuiStoragePair* it = LowerBound(Data, key);
    if (it == Data.end() || it->key != key)
    {
        Data.insert(it, ImGuiStoragePair(key, val));
        return;
    }
    it->val_p = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0xc5fb0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xe7f70
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0xc652f
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xc655a
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xe8120
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xe7f90
jmp 0xc6566
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextFilter::ImGuiTextFilter(char const*)
ImGuiTextFilter::ImGuiTextFilter(const char* default_filter)
{
    if (default_filter)
    {
        ImStrncpy(InputBuf, default_filter, IM_ARRAYSIZE(InputBuf));
        Build();
    }
    else
    {
        InputBuf[0] = 0;
        CountGrep = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x100, %rdi            # imm = 0x100
movq %rdi, -0x28(%rbp)
callq 0xe81d0
cmpq $0x0, -0x10(%rbp)
je 0xc6635
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xc4780
movq -0x30(%rbp), %rdi
callq 0xc6660
jmp 0xc661c
jmp 0xc6646
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xe8200
jmp 0xc664c
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, 0x110(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xd620
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextFilter::Build()
void ImGuiTextFilter::Build()
{
    Filters.resize(0);
    ImGuiTextRange input_range(InputBuf, InputBuf + strlen(InputBuf));
    input_range.split(',', &Filters);

    CountGrep = 0;
    for (int i = 0; i != Filters.Size; i++)
    {
        ImGuiTextRange& f = Filters[i];
        while (f.b < f.e && ImCharIsBlankA(f.b[0]))
            f.b++;
        while (f.e > f.b && ImCharIsBlankA(f.e[-1]))
            f.e--;
        if (f.empty())
            continue;
        if (Filters[i].b[0] != '-')
            CountGrep += 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x100, %rdi            # imm = 0x100
xorl %esi, %esi
callq 0xe8240
movq -0x30(%rbp), %rdi
callq 0xd410
movq -0x30(%rbp), %rsi
movq %rsi, %rdx
addq %rax, %rdx
leaq -0x18(%rbp), %rdi
callq 0xe8300
movq -0x30(%rbp), %rdx
addq $0x100, %rdx            # imm = 0x100
leaq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0xc68a0
movq -0x30(%rbp), %rax
movl $0x0, 0x110(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x100(%rcx), %eax
je 0xc67d0
movq -0x30(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x1c(%rbp), %esi
callq 0xe8330
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x31(%rbp)
jae 0xc671e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xc6970
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc6727
jmp 0xc6737
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xc66f6
jmp 0xc6739
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x32(%rbp)
jbe 0xc6763
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movsbl -0x1(%rax), %edi
callq 0xc6970
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0xc676c
jmp 0xc677e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0xc6739
movq -0x28(%rbp), %rdi
callq 0xe83b0
testb $0x1, %al
jne 0xc678d
jmp 0xc678f
jmp 0xc67c2
movq -0x30(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x1c(%rbp), %esi
callq 0xe8330
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xc67c0
movq -0x30(%rbp), %rax
movl 0x110(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x110(%rax)
jmp 0xc67c2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc66cc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextFilter::Draw(char const*, float)
bool ImGuiTextFilter::Draw(const char* label, float width)
{
    if (width != 0.0f)
        ImGui::SetNextItemWidth(width);
    bool value_changed = ImGui::InputText(label, InputBuf, IM_ARRAYSIZE(InputBuf));
    if (value_changed)
        Build();
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xc680e
jp 0xc680e
jmp 0xc6818
movss -0x14(%rbp), %xmm0
callq 0xc6860
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x149cd0
andb $0x1, %al
movb %al, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
je 0xc6848
movq -0x20(%rbp), %rdi
callq 0xc6660
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextFilter::ImGuiTextRange::split(char, ImVector<ImGuiTextFilter::ImGuiTextRange>*) const
void ImGuiTextFilter::ImGuiTextRange::split(char separator, ImVector<ImGuiTextRange>* out) const
{
    out->resize(0);
    const char* wb = b;
    const char* we = wb;
    while (we < e)
    {
        if (*we == separator)
        {
            out->push_back(ImGuiTextRange(wb, we));
            wb = we + 1;
        }
        we++;
    }
    if (wb != we)
        out->push_back(ImGuiTextRange(wb, we));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xe8240
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xc6939
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xc692b
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe8300
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xe8290
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc68dc
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xc6969
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xe8300
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe8290
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextFilter::PassFilter(char const*, char const*) const
bool ImGuiTextFilter::PassFilter(const char* text, const char* text_end) const
{
    if (Filters.empty())
        return true;

    if (text == NULL)
        text = "";

    for (int i = 0; i != Filters.Size; i++)
    {
        const ImGuiTextRange& f = Filters[i];
        if (f.empty())
            continue;
        if (f.b[0] == '-')
        {
            // Subtract
            if (ImStristr(text, text_end, f.b + 1, f.e) != NULL)
                return false;
        }
        else
        {
            // Grep
            if (ImStristr(text, text_end, f.b, f.e) != NULL)
                return true;
        }
    }

    // Implicit * grep
    if (CountGrep == 0)
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0xe83d0
testb $0x1, %al
jne 0xc69ce
jmp 0xc69d7
movb $0x1, -0x1(%rbp)
jmp 0xc6ab9
cmpq $0x0, -0x18(%rbp)
jne 0xc69e9
leaq 0xab524(%rip), %rax     # 0x171f09
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x100(%rcx), %eax
je 0xc6aa2
movq -0x38(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl -0x24(%rbp), %esi
callq 0xe83f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe83b0
testb $0x1, %al
jne 0xc6a29
jmp 0xc6a2b
jmp 0xc6a94
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xc6a68
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
addq $0x1, %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0xc4aa0
cmpq $0x0, %rax
je 0xc6a66
movb $0x0, -0x1(%rbp)
jmp 0xc6ab9
jmp 0xc6a92
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0xc4aa0
cmpq $0x0, %rax
je 0xc6a90
movb $0x1, -0x1(%rbp)
jmp 0xc6ab9
jmp 0xc6a92
jmp 0xc6a94
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc69f0
movq -0x38(%rbp), %rax
cmpl $0x0, 0x110(%rax)
jne 0xc6ab5
movb $0x1, -0x1(%rbp)
jmp 0xc6ab9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextBuffer::append(char const*, char const*)
void ImGuiTextBuffer::append(const char* str, const char* str_end)
{
    int len = str_end ? (int)(str_end - str) : (int)strlen(str);

    // Add zero-terminator the first time
    const int write_off = (Buf.Size != 0) ? Buf.Size : 1;
    const int needed_sz = write_off + len;
    if (write_off + len >= Buf.Capacity)
    {
        int new_capacity = Buf.Capacity * 2;
        Buf.reserve(needed_sz > new_capacity ? needed_sz : new_capacity);
    }

    Buf.resize(needed_sz);
    memcpy(&Buf[write_off - 1], str, (size_t)len);
    Buf[write_off - 1 + len] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc6b03
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0xc6b0f
movq -0x10(%rbp), %rdi
callq 0xd410
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, (%rax)
je 0xc6b29
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0xc6b33
movl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xc6b33
movq -0x30(%rbp), %rcx
movl -0x38(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0xc6b7f
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0xc6b6d
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xc6b73
movl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0xe8470
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0xe84f0
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
callq 0xe8540
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0xd0a0
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
addl -0x1c(%rbp), %esi
callq 0xe8540
movb $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiTextBuffer::appendfv(char const*, __va_list_tag*)
void ImGuiTextBuffer::appendfv(const char* fmt, va_list args)
{
    va_list args_copy;
    va_copy(args_copy, args);

    int len = ImFormatStringV(NULL, 0, fmt, args);         // FIXME-OPT: could do a first pass write attempt, likely successful on first pass.
    if (len <= 0)
    {
        va_end(args_copy);
        return;
    }

    // Add zero-terminator the first time
    const int write_off = (Buf.Size != 0) ? Buf.Size : 1;
    const int needed_sz = write_off + len;
    if (write_off + len >= Buf.Capacity)
    {
        int new_capacity = Buf.Capacity * 2;
        Buf.reserve(needed_sz > new_capacity ? needed_sz : new_capacity);
    }

    Buf.resize(needed_sz);
    ImFormatStringV(&Buf[write_off - 1], (size_t)len + 1, fmt, args_copy);
    va_end(args_copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0xc4e20
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jg 0xc6cc8
leaq -0x30(%rbp), %rax
jmp 0xc6d69
movq -0x48(%rbp), %rax
cmpl $0x0, (%rax)
je 0xc6cdc
movq -0x48(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xc6ce6
movl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xc6ce6
movq -0x48(%rbp), %rcx
movl -0x4c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0xc6d32
movq -0x48(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jle 0xc6d20
movl -0x3c(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0xc6d26
movl -0x40(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movl -0x50(%rbp), %esi
callq 0xe8470
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0xe84f0
movq -0x48(%rbp), %rdi
movl -0x38(%rbp), %esi
subl $0x1, %esi
callq 0xe8540
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xc4e20
leaq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiListClipper::Begin(int, float)
void ImGuiListClipper::Begin(int items_count, float items_height)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    if (ImGuiTable* table = g.CurrentTable)
        if (table->IsInsideRow)
            ImGui::TableEndRow(table);

    StartPosY = window->DC.CursorPos.y;
    ItemsHeight = items_height;
    ItemsCount = items_count;
    ItemsFrozen = 0;
    StepNo = 0;
    DisplayStart = -1;
    DisplayEnd = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x14be8d(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc70f4
movq -0x28(%rbp), %rax
testb $0x1, 0x249(%rax)
je 0xc70f2
movq -0x28(%rbp), %rdi
callq 0x12e9d0
jmp 0xc70f4
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movss 0xdc(%rcx), %xmm0
movss %xmm0, 0x18(%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x14(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0xc(%rax)
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiListClipper::End()
void ImGuiListClipper::End()
{
    if (ItemsCount < 0) // Already ended
        return;

    // In theory here we should assert that ImGui::GetCursorPosY() == StartPosY + DisplayEnd * ItemsHeight, but it feels saner to just seek at the end and not assert/crash the user.
    if (ItemsCount < INT_MAX && DisplayStart >= 0)
        SetCursorPosYAndSetupForPrevLine(StartPosY + (ItemsCount - ItemsFrozen) * ItemsHeight, ItemsHeight);
    ItemsCount = -1;
    StepNo = 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
jge 0xc715c
jmp 0xc71ae
movq -0x10(%rbp), %rax
cmpl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
jge 0xc719c
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jl 0xc719c
movq -0x10(%rbp), %rax
movss 0x18(%rax), %xmm1
movl 0x8(%rax), %ecx
subl 0x10(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movss 0x14(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x14(%rax), %xmm1
callq 0xc71c0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0x3, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetColorU32(int, float)
ImU32 ImGui::GetColorU32(ImGuiCol idx, float alpha_mul)
{
    ImGuiStyle& style = GImGui->Style;
    ImVec4 c = style.Colors[idx];
    c.w *= style.Alpha * alpha_mul;
    return ColorConvertFloat4ToU32(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq 0x14b849(%rip), %rax    # 0x212f40
addq $0x1560, %rax           # imm = 0x1560
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xc4, %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
mulss -0x8(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc59c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetColorU32(ImVec4 const&)
ImU32 ImGui::GetColorU32(const ImVec4& col)
{
    ImGuiStyle& style = GImGui->Style;
    ImVec4 c = col;
    c.w *= style.Alpha;
    return ColorConvertFloat4ToU32(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x14b7dd(%rip), %rax    # 0x212f40
addq $0x1560, %rax           # imm = 0x1560
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc59c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetColorU32(unsigned int)
ImU32 ImGui::GetColorU32(ImU32 col)
{
    ImGuiStyle& style = GImGui->Style;
    if (style.Alpha >= 1.0f)
        return col;
    ImU32 a = (col & IM_COL32_A_MASK) >> IM_COL32_A_SHIFT;
    a = (ImU32)(a * style.Alpha); // We don't need to clamp 0..255 because Style.Alpha is in 0..1 range.
    return (col & ~IM_COL32_A_MASK) | (a << IM_COL32_A_SHIFT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq 0x14b752(%rip), %rax    # 0x212f40
addq $0x1560, %rax           # imm = 0x1560
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss 0xa9434(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
jb 0xc7815
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc784b
movzbl -0x5(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cvtsi2ss %rax, %xmm0
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl -0x14(%rbp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleColor(int, unsigned int)
void ImGui::PushStyleColor(ImGuiCol idx, ImU32 col)
{
    ImGuiContext& g = *GImGui;
    ImGuiColorMod backup;
    backup.Col = idx;
    backup.BackupValue = g.Style.Colors[idx];
    g.ColorStack.push_back(backup);
    g.Style.Colors[idx] = ColorConvertU32ToFloat4(col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x14b6db(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
leaq -0x24(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xe8690
movq -0x40(%rbp), %rsi
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
movups 0x1624(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c10, %rdi           # imm = 0x1C10
callq 0xe86b0
movl -0x8(%rbp), %edi
callq 0xc5950
movlpd %xmm0, -0x34(%rbp)
movlpd %xmm1, -0x2c(%rbp)
movq -0x10(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
addq $0xc4, %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x34(%rbp), %rcx
movq %rcx, (%rax)
movq -0x2c(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleColor(int, ImVec4 const&)
void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
    ImGuiContext& g = *GImGui;
    ImGuiColorMod backup;
    backup.Col = idx;
    backup.BackupValue = g.Style.Colors[idx];
    g.ColorStack.push_back(backup);
    g.Style.Colors[idx] = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x14b63a(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0xe8690
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
addq $0xc4, %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1c10, %rdi           # imm = 0x1C10
leaq -0x2c(%rbp), %rsi
callq 0xe86b0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
addq $0xc4, %rax
movslq -0x4(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopStyleColor(int)
void ImGui::PopStyleColor(int count)
{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        ImGuiColorMod& backup = g.ColorStack.back();
        g.Style.Colors[backup.Col] = backup.BackupValue;
        g.ColorStack.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x14b59e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xc7a0c
movq -0x10(%rbp), %rdi
addq $0x1c10, %rdi           # imm = 0x1C10
callq 0xe8720
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
addq $0xc4, %rax
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x4(%rcx), %rdx
movq %rdx, (%rax)
movq 0xc(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x1c10, %rdi           # imm = 0x1C10
callq 0xe8780
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc79a6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)