LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ColorConvertHSVtoRGB(float, float, float, float&, float&, float&)
void ImGui::ColorConvertHSVtoRGB(float h, float s, float v, float& out_r, float& out_g, float& out_b)
{
    if (s == 0.0f)
    {
        // gray
        out_r = out_g = out_b = v;
        return;
    }

    h = ImFmod(h, 1.0f) / (60.0f / 360.0f);
    int   i = (int)h;
    float f = h - (float)i;
    float p = v * (1.0f - s);
    float q = v * (1.0f - s * f);
    float t = v * (1.0f - s * (1.0f - f));

    switch (i)
    {
    case 0: out_r = v; out_g = t; out_b = p; break;
    case 1: out_r = q; out_g = v; out_b = p; break;
    case 2: out_r = p; out_g = v; out_b = t; break;
    case 3: out_r = p; out_g = q; out_b = v; break;
    case 4: out_r = t; out_g = p; out_b = v; break;
    case 5: default: out_r = v; out_g = p; out_b = q; break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movaps %xmm1, %xmm3
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm3
jne 0x4301f
jp 0x4301f
movss %xmm2, (%rbx)
movss %xmm2, (%r14)
movss %xmm2, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movss 0x73fbd(%rip), %xmm1    # 0xb6fe4
movss %xmm2, -0x20(%rbp)
movss %xmm3, -0x1c(%rbp)
callq 0xc9c0
movss -0x1c(%rbp), %xmm6
movss 0x73fa1(%rip), %xmm5    # 0xb6fe4
movss -0x20(%rbp), %xmm4
divss 0x74808(%rip), %xmm0    # 0xb7858
cvttss2si %xmm0, %eax
cvttps2dq %xmm0, %xmm1
cvtdq2ps %xmm1, %xmm1
subss %xmm1, %xmm0
movaps %xmm5, %xmm1
subss %xmm6, %xmm1
mulss %xmm4, %xmm1
movaps %xmm6, %xmm3
mulss %xmm0, %xmm3
movaps %xmm5, %xmm2
subss %xmm3, %xmm2
mulss %xmm4, %xmm2
cmpl $0x4, %eax
ja 0x430f5
movaps %xmm5, %xmm3
subss %xmm0, %xmm3
mulss %xmm3, %xmm6
subss %xmm6, %xmm5
mulss %xmm4, %xmm5
leaq 0x74875(%rip), %rcx     # 0xb7910
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss %xmm4, (%r15)
movss %xmm5, (%r14)
jmp 0x430ec
movss %xmm5, (%r15)
movss %xmm1, (%r14)
jmp 0x430d9
movss %xmm1, (%r15)
movss %xmm4, (%r14)
movss %xmm5, (%rbx)
jmp 0x43014
movss %xmm1, (%r15)
movss %xmm2, (%r14)
movss %xmm4, (%rbx)
jmp 0x43014
movss %xmm2, (%r15)
movss %xmm4, (%r14)
movss %xmm1, (%rbx)
jmp 0x43014
movss %xmm4, (%r15)
movss %xmm1, (%r14)
movss %xmm2, (%rbx)
jmp 0x43014
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edx, %eax
movq 0x8(%rdi), %rdx
movslq (%rdi), %rdi
movq %rdx, %rcx
testq %rdi, %rdi
je 0x4318b
movq %rdx, %rcx
movq %rdi, %r9
movq %rdi, %r8
shrq %r8
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rcx,%r10)
jae 0x43183
notq %r8
addq %r9, %r8
addq %r10, %rcx
addq $0x10, %rcx
movq %r8, %r9
testq %r8, %r8
jne 0x43166
shlq $0x4, %rdi
addq %rdi, %rdx
cmpq %rdx, %rcx
je 0x4319e
cmpl %esi, (%rcx)
jne 0x4319e
movl 0x8(%rcx), %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
je 0x431f1
movq %rcx, %rax
movq %rdx, %r8
movq %rdx, %rdi
shrq %rdi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0x431e9
notq %rdi
addq %r8, %rdi
addq %r9, %rax
addq $0x10, %rax
movq %rdi, %r8
testq %rdi, %rdi
jne 0x431cc
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x43206
cmpl %esi, (%rax)
jne 0x43206
movss 0x8(%rax), %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
je 0x43249
movq %rcx, %rax
movq %rdx, %r8
movq %rdx, %rdi
shrq %rdi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0x43241
notq %rdi
addq %r8, %rdi
addq %r9, %rax
addq $0x10, %rax
movq %rdi, %r8
testq %rdi, %rdi
jne 0x43224
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x4325f
cmpl %esi, (%rax)
jne 0x4325f
movq 0x8(%rax), %rax
jmp 0x43261
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0x8(%rdi), %rcx
movslq (%rdi), %r8
movq %rcx, %rax
testq %r8, %r8
je 0x432a9
movq %rcx, %rax
movq %r8, %r10
movq %r8, %r9
shrq %r9
movq %r9, %r11
shlq $0x4, %r11
cmpl %esi, (%rax,%r11)
jae 0x432a1
notq %r9
addq %r10, %r9
addq %r11, %rax
addq $0x10, %rax
movq %r9, %r10
testq %r9, %r9
jne 0x43284
shlq $0x4, %r8
addq %r8, %rcx
cmpq %rcx, %rax
je 0x432b9
cmpl %esi, (%rax)
je 0x432cd
leaq -0x10(%rbp), %rcx
movl %esi, (%rcx)
movl %edx, 0x8(%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x5e1bc
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
je 0x43327
movq %rcx, %rax
movq %rdx, %r9
movq %rdx, %r8
shrq %r8
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rax,%r10)
jae 0x4331f
notq %r8
addq %r9, %r8
addq %r10, %rax
addq $0x10, %rax
movq %r8, %r9
testq %r8, %r8
jne 0x43302
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x43337
cmpl %esi, (%rax)
je 0x4334a
leaq -0x10(%rbp), %rdx
movl %esi, (%rdx)
movss %xmm0, 0x8(%rdx)
movq %rax, %rsi
callq 0x5e1bc
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0x8(%rdi), %rcx
movslq (%rdi), %r8
movq %rcx, %rax
testq %r8, %r8
je 0x43399
movq %rcx, %rax
movq %r8, %r10
movq %r8, %r9
shrq %r9
movq %r9, %r11
shlq $0x4, %r11
cmpl %esi, (%rax,%r11)
jae 0x43391
notq %r9
addq %r10, %r9
addq %r11, %rax
addq $0x10, %rax
movq %r9, %r10
testq %r9, %r9
jne 0x43374
shlq $0x4, %r8
addq %r8, %rcx
cmpq %rcx, %rax
je 0x433a9
cmpl %esi, (%rax)
je 0x433be
leaq -0x10(%rbp), %rcx
movl %esi, (%rcx)
movq %rdx, 0x8(%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x5e1bc
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0x8(%rdi), %rcx
movslq (%rdi), %r8
movq %rcx, %rax
testq %r8, %r8
je 0x4340d
movq %rcx, %rax
movq %r8, %r10
movq %r8, %r9
shrq %r9
movq %r9, %r11
shlq $0x4, %r11
cmpl %esi, (%rax,%r11)
jae 0x43405
notq %r9
addq %r10, %r9
addq %r11, %rax
addq $0x10, %rax
movq %r9, %r10
testq %r9, %r9
jne 0x433e8
shlq $0x4, %r8
addq %r8, %rcx
cmpq %rcx, %rax
je 0x43422
cmpl %esi, (%rax)
jne 0x43422
movl %edx, 0x8(%rax)
jmp 0x43436
leaq -0x10(%rbp), %rcx
movl %esi, (%rcx)
movl %edx, 0x8(%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x5e1bc
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
je 0x4348b
movq %rcx, %rax
movq %rdx, %r9
movq %rdx, %r8
shrq %r8
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rax,%r10)
jae 0x43483
notq %r8
addq %r9, %r8
addq %r10, %rax
addq $0x10, %rax
movq %r8, %r9
testq %r8, %r8
jne 0x43466
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x434a2
cmpl %esi, (%rax)
jne 0x434a2
movss %xmm0, 0x8(%rax)
jmp 0x434b5
leaq -0x10(%rbp), %rdx
movl %esi, (%rdx)
movss %xmm0, 0x8(%rdx)
movq %rax, %rsi
callq 0x5e1bc
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0x8(%rdi), %rcx
movslq (%rdi), %r8
movq %rcx, %rax
testq %r8, %r8
je 0x43501
movq %rcx, %rax
movq %r8, %r10
movq %r8, %r9
shrq %r9
movq %r9, %r11
shlq $0x4, %r11
cmpl %esi, (%rax,%r11)
jae 0x434f9
notq %r9
addq %r10, %r9
addq %r11, %rax
addq $0x10, %rax
movq %r9, %r10
testq %r9, %r9
jne 0x434dc
shlq $0x4, %r8
addq %r8, %rcx
cmpq %rcx, %rax
je 0x43517
cmpl %esi, (%rax)
jne 0x43517
movq %rdx, 0x8(%rax)
jmp 0x4352c
leaq -0x10(%rbp), %rcx
movl %esi, (%rcx)
movq %rdx, 0x8(%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x5e1bc
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rdi)
testq %rsi, %rsi
je 0x43598
leaq 0x100(%rbx), %r14
movl $0xff, %edx
movq %rbx, %rdi
callq 0xc110
movb $0x0, 0xff(%rbx)
movq %rbx, %rdi
callq 0x435be
jmp 0x435a5
movb $0x0, (%rbx)
movl $0x0, 0x110(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e30c
movq %rbx, %rdi
callq 0xc560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
movl 0x104(%rdi), %eax
testl %eax, %eax
jns 0x4367a
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r12d, %r12d
testl %ecx, %ecx
cmovgl %ecx, %r12d
movq %r12, %rdi
shlq $0x4, %rdi
movq 0xba6c9(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x43612
incl 0x3b4(%rax)
movq 0xba6c7(%rip), %rsi     # 0xfdce0
callq *0xb5ef1(%rip)          # 0xf9510
movq %rax, %r15
movq 0x108(%rbx), %rsi
testq %rsi, %rsi
je 0x4366c
movslq 0x100(%rbx), %rdx
shlq $0x4, %rdx
movq %r15, %rdi
callq 0xc080
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x4365f
movq 0xba67c(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x4365f
decl 0x3b4(%rax)
movq 0xba67a(%rip), %rsi     # 0xfdce0
callq *0xb5eac(%rip)          # 0xf9518
movq %r15, 0x108(%rbx)
movl %r12d, 0x104(%rbx)
xorl %r15d, %r15d
movl %r15d, 0x100(%rbx)
movq %rbx, %rdi
callq 0xc350
addq %rbx, %rax
leaq -0x30(%rbp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2c, %esi
movq %r14, %rdx
callq 0x43810
movl %r15d, 0x110(%rbx)
movl 0x100(%rbx), %eax
testq %rax, %rax
je 0x4376e
movl 0x110(%rbx), %ecx
movq 0x108(%rbx), %rdx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
cmpq %rsi, %r15
je 0x4377b
movq %r15, %r9
shlq $0x4, %r9
leaq (%rdx,%r9), %r8
movq (%rdx,%r9), %rdi
movq 0x8(%rdx,%r9), %r9
cmpq %r9, %rdi
jae 0x43711
movzbl (%rdi), %r10d
cmpl $0x20, %r10d
je 0x43706
cmpl $0x9, %r10d
jne 0x43711
incq %rdi
movq %rdi, (%r8)
cmpq %r9, %rdi
jne 0x436f6
movq 0x8(%r8), %r9
cmpq %rdi, %r9
jbe 0x43748
decq %r9
movzbl (%r9), %r10d
cmpl $0x20, %r10d
je 0x4372d
cmpl $0x9, %r10d
jne 0x43745
movq %r9, 0x8(%r8)
leaq -0x1(%r9), %r10
cmpq %rdi, %r9
movq %r10, %r9
ja 0x4371d
incq %r10
movq %r10, %r9
jmp 0x43748
incq %r9
cmpq %r9, %rdi
je 0x43762
movslq (%r14), %r8
cmpq %r8, %r15
jge 0x4377b
cmpb $0x2d, (%rdi)
je 0x43762
incl %ecx
movl %ecx, 0x110(%rbx)
incq %r15
cmpq %rax, %r15
jne 0x436d4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x77ef6(%rip), %rdi     # 0xbb678
leaq 0x77f02(%rip), %rsi     # 0xbb68b
leaq 0x790a5(%rip), %rcx     # 0xbc835
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x437ae
jnp 0x437c4
movq 0xba51b(%rip), %rax     # 0xfdcd0
orl $0x1, 0x1bf8(%rax)
movss %xmm0, 0x1bfc(%rax)
movl $0x100, %edx            # imm = 0x100
movq %rsi, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x9cdd6
movl %eax, %r14d
testb %al, %al
je 0x437eb
movq %rbx, %rdi
callq 0x435be
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x40(%rbp)
movl 0x100(%rdi), %r13d
testq %r13, %r13
je 0x43b7b
testq %rsi, %rsi
leaq 0x73462(%rip), %rax     # 0xb6f1d
cmovneq %rsi, %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
testl %r13d, %r13d
movl $0x0, %r14d
cmovgl %r13d, %r14d
movq %rdi, -0x48(%rbp)
movq 0x108(%rdi), %r12
shlq $0x4, %r14
shlq $0x4, %r13
xorl %r15d, %r15d
movl %eax, -0x2c(%rbp)
cmpq %rbx, %r14
je 0x43b8e
movq (%r12,%rbx), %rdx
movq 0x8(%r12,%rbx), %rcx
cmpq %rcx, %rdx
je 0x43b2a
cmpb $0x2d, (%rdx)
jne 0x43b31
incq %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x42673
testq %rax, %rax
je 0x43b4f
movl $0x1, %eax
movl $0x0, -0x2c(%rbp)
jmp 0x43b51
movl $0x4, %eax
jmp 0x43b51
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x42673
testq %rax, %rax
je 0x43b4f
movb $0x1, %al
movl %eax, -0x2c(%rbp)
movl $0x1, %eax
jmp 0x43b51
xorl %eax, %eax
testb $0x3, %al
jne 0x43b62
addq $0x10, %rbx
cmpq %rbx, %r13
sete %r15b
jne 0x43aeb
testb $0x1, %r15b
movl -0x2c(%rbp), %eax
je 0x43b7d
movq -0x48(%rbp), %rax
cmpl $0x0, 0x110(%rax)
sete %al
jmp 0x43b7d
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x77ae3(%rip), %rdi     # 0xbb678
leaq 0x77aef(%rip), %rsi     # 0xbb68b
leaq 0x78cf6(%rip), %rcx     # 0xbc899
movl $0x65d, %edx            # imm = 0x65D
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcListClipping(int, float, int*, int*)
void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (g.LogEnabled)
    {
        // If logging is active, do not perform any clipping
        *out_items_display_start = 0;
        *out_items_display_end = items_count;
        return;
    }
    if (GetSkipItemForListClipping())
    {
        *out_items_display_start = *out_items_display_end = 0;
        return;
    }

    // We create the union of the ClipRect and the NavScoringRect which at worst should be 1 page away from ClipRect
    ImRect unclipped_rect = window->ClipRect;
    if (g.NavMoveRequest)
        unclipped_rect.Add(g.NavScoringRect);
    if (g.NavJustMovedToId && window->NavLastIds[0] == g.NavJustMovedToId)
        unclipped_rect.Add(ImRect(window->Pos + window->NavRectRel[0].Min, window->Pos + window->NavRectRel[0].Max));

    const ImVec2 pos = window->DC.CursorPos;
    int start = (int)((unclipped_rect.Min.y - pos.y) / items_height);
    int end = (int)((unclipped_rect.Max.y - pos.y) / items_height);

    // When performing a navigation request, ensure we have one item extra in the direction we are moving to
    if (g.NavMoveRequest && g.NavMoveClipDir == ImGuiDir_Up)
        start--;
    if (g.NavMoveRequest && g.NavMoveClipDir == ImGuiDir_Down)
        end++;

    start = ImClamp(start, 0, items_count);
    end = ImClamp(end + 1, start, items_count);
    *out_items_display_start = start;
    *out_items_display_end = end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb9cd4(%rip), %rax     # 0xfdcd0
cmpb $0x1, 0x3138(%rax)
jne 0x44010
movl $0x0, (%rsi)
jmp 0x4412c
movq 0x1ae0(%rax), %r8
movq 0x20a8(%rax), %rcx
leaq 0x256(%rcx), %r9
leaq 0x93(%r8), %r10
testq %rcx, %rcx
cmoveq %r10, %r9
cmpb $0x1, (%r9)
jne 0x44044
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rsi)
jmp 0x4412e
movss 0x25c(%r8), %xmm2
movss 0x264(%r8), %xmm1
movb 0x1d00(%rax), %cl
cmpb $0x1, %cl
jne 0x4407f
movss 0x1ccc(%rax), %xmm3
movss 0x1cd4(%rax), %xmm4
minss %xmm2, %xmm3
maxss %xmm1, %xmm4
movaps %xmm3, %xmm2
movaps %xmm4, %xmm1
movl 0x1cb4(%rax), %r9d
testl %r9d, %r9d
je 0x440be
cmpl %r9d, 0x3b0(%r8)
jne 0x440be
movss 0x14(%r8), %xmm3
movss 0x3bc(%r8), %xmm4
addss %xmm3, %xmm4
addss 0x3c4(%r8), %xmm3
minss %xmm2, %xmm4
maxss %xmm1, %xmm3
movaps %xmm4, %xmm2
movaps %xmm3, %xmm1
movss 0xdc(%r8), %xmm3
subss %xmm3, %xmm2
divss %xmm0, %xmm2
cvttss2si %xmm2, %r8d
subss %xmm3, %xmm1
divss %xmm0, %xmm1
testb %cl, %cl
je 0x440f1
xorl %r9d, %r9d
cmpl $0x2, 0x1d18(%rax)
sete %r9b
subl %r9d, %r8d
cvttss2si %xmm1, %r9d
testb %cl, %cl
je 0x44109
xorl %ecx, %ecx
cmpl $0x3, 0x1d18(%rax)
sete %cl
addl %ecx, %r9d
cmpl %edi, %r8d
movl %edi, %eax
cmovll %r8d, %eax
xorl %ecx, %ecx
testl %r8d, %r8d
cmovnsl %eax, %ecx
incl %r9d
cmpl %edi, %r9d
cmovll %r9d, %edi
cmpl %ecx, %r9d
cmovll %ecx, %edi
movl %ecx, (%rsi)
movl %edi, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0xb9b47(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %r15
movq 0x20a8(%rax), %rdi
testq %rdi, %rdi
je 0x441b4
cmpb $0x1, 0x249(%rdi)
jne 0x441b4
movss %xmm0, -0x1c(%rbp)
callq 0x8b7ea
movss -0x1c(%rbp), %xmm0
movss 0xdc(%r15), %xmm1
movss %xmm1, 0x18(%rbx)
movss %xmm0, 0x14(%rbx)
movl %r14d, 0x8(%rbx)
movq $0x0, 0xc(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.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:
movl 0x8(%rdi), %eax
testl %eax, %eax
js 0x44230
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x4421c
cmpl $0x0, (%rbx)
js 0x4421c
subl 0x10(%rbx), %eax
cvtsi2ss %eax, %xmm0
movss 0x14(%rbx), %xmm1
mulss %xmm1, %xmm0
addss 0x18(%rbx), %xmm0
callq 0x44231
movabsq $0x3ffffffff, %rax      # imm = 0x3FFFFFFFF
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: SetCursorPosYAndSetupForPrevLine(float, float)
static void SetCursorPosYAndSetupForPrevLine(float pos_y, float line_height)
{
    // Set cursor position and a few other things so that SetScrollHereY() and Columns() can work when seeking cursor.
    // FIXME: It is problematic that we have to do that here, because custom/equivalent end-user code would stumble on the same issue.
    // The clipper should probably have a 4th step to display the last item in a regular manner.
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float off_y = pos_y - window->DC.CursorPos.y;
    window->DC.CursorPos.y = pos_y;
    window->DC.CursorMaxPos.y = ImMax(window->DC.CursorMaxPos.y, pos_y);
    window->DC.CursorPosPrevLine.y = window->DC.CursorPos.y - line_height;  // Setting those fields so that SetScrollHereY() can properly function after the end of our clipper usage.
    window->DC.PrevLineSize.y = (line_height - g.Style.ItemSpacing.y);      // If we end up needing more accurate data (to e.g. use SameLine) we may as well make the clipper have a fourth step to let user process and display the last item in their list.
    if (ImGuiOldColumns* columns = window->DC.CurrentColumns)
        columns->LineMinY = window->DC.CursorPos.y;                         // Setting this so that cell Y position are set properly
    if (ImGuiTable* table = g.CurrentTable)
    {
        if (table->IsInsideRow)
            ImGui::TableEndRow(table);
        table->RowPosY2 = window->DC.CursorPos.y;
        const int row_increase = (int)((off_y / line_height) + 0.5f);
        //table->CurrentRow += row_increase; // Can't do without fixing TableEndRow()
        table->RowBgColorCounter += row_increase;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xb9a8d(%rip), %rax     # 0xfdcd0
movq 0x1ae0(%rax), %r14
movaps %xmm0, %xmm4
subss 0xdc(%r14), %xmm4
movss %xmm0, 0xdc(%r14)
movss 0xf4(%r14), %xmm3
movaps %xmm0, %xmm2
cmpless %xmm3, %xmm2
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
orps %xmm3, %xmm2
movss %xmm2, 0xf4(%r14)
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0xe4(%r14)
movaps %xmm1, %xmm2
subss 0x15ac(%rax), %xmm2
movss %xmm2, 0x10c(%r14)
movq 0x1b0(%r14), %rcx
testq %rcx, %rcx
je 0x442b7
movss %xmm0, 0x1c(%rcx)
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x4430d
cmpb $0x1, 0x249(%rbx)
jne 0x442e6
movq %rbx, %rdi
movss %xmm1, -0x14(%rbp)
movaps %xmm4, -0x30(%rbp)
callq 0x8b7ea
movaps -0x30(%rbp), %xmm4
movss -0x14(%rbp), %xmm1
movss 0xdc(%r14), %xmm0
divss %xmm1, %xmm4
addss 0x72d09(%rip), %xmm4    # 0xb7004
cvttss2si %xmm4, %eax
movss %xmm0, 0x80(%rbx)
addl %eax, 0x94(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0xb9704(%rip), %rax     # 0xfdcd0
movslq %edi, %rcx
shlq $0x4, %rcx
movups 0x1624(%rax,%rcx), %xmm1
leaq -0x10(%rbp), %rdi
movaps %xmm1, (%rdi)
mulss 0x1560(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x42e9e
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x10, %rsp
movq 0xb96c2(%rip), %rax     # 0xfdcd0
movups (%rdi), %xmm0
leaq -0x10(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x1560(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x42e9e
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %eax
movq 0xb9671(%rip), %rcx     # 0xfdcd0
movss 0x1560(%rcx), %xmm0
ucomiss 0x72976(%rip), %xmm0    # 0xb6fe4
jae 0x4468e
movl %eax, %ecx
shrl $0x18, %ecx
cvtsi2ss %ecx, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rcx
andl $0xffffff, %eax         # imm = 0xFFFFFF
shll $0x18, %ecx
orl %eax, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
movq 0xb9623(%rip), %r13     # 0xfdcd0
movslq %edi, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %r12
addq $0x1624, %r12           # imm = 0x1624
movups (%r12), %xmm0
movaps %xmm0, -0x40(%rbp)
movl 0x1c10(%r13), %r15d
movl 0x1c14(%r13), %eax
cmpl %eax, %r15d
jne 0x44790
incl %r15d
testl %eax, %eax
je 0x446f3
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x446f8
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
cmpl %r15d, %eax
jge 0x44790
movslq %r15d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
testq %r13, %r13
je 0x4471f
incl 0x3b4(%r13)
movq 0xb95ba(%rip), %rsi     # 0xfdce0
callq *0xb4de4(%rip)          # 0xf9510
movq 0x1c18(%r13), %rsi
testq %rsi, %rsi
je 0x44782
movslq 0x1c10(%r13), %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,4), %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0xc080
movq 0x1c18(%r13), %rdi
testq %rdi, %rdi
je 0x44771
movq 0xb956a(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x44771
decl 0x3b4(%rax)
movq 0xb9568(%rip), %rsi     # 0xfdce0
callq *0xb4d9a(%rip)          # 0xf9518
movq -0x30(%rbp), %rax
movq %rax, 0x1c18(%r13)
movl %r15d, 0x1c14(%r13)
movq 0x1c18(%r13), %rax
movslq 0x1c10(%r13), %rcx
leaq (%rcx,%rcx,4), %rcx
movl %r14d, (%rax,%rcx,4)
movaps -0x40(%rbp), %xmm0
movups %xmm0, 0x4(%rax,%rcx,4)
incl 0x1c10(%r13)
movl $0xff, %eax
movl %ebx, %ecx
andl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss 0x7307e(%rip), %xmm1    # 0xb784c
mulss %xmm1, %xmm0
movl %ebx, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
cvtsi2ss %ecx, %xmm2
mulss %xmm1, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movl %ebx, %ecx
shrl $0x10, %ecx
andl %eax, %ecx
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
mulss %xmm1, %xmm2
shrl $0x18, %ebx
cvtsi2ss %ebx, %xmm3
mulss %xmm1, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movlhps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
movups %xmm0, (%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq 0xb9497(%rip), %r12     # 0xfdcd0
movslq %edi, %rax
shlq $0x4, %rax
leaq (%r12,%rax), %r13
addq $0x1624, %r13           # imm = 0x1624
movups (%r13), %xmm0
movaps %xmm0, -0x40(%rbp)
movl 0x1c10(%r12), %r15d
movl 0x1c14(%r12), %eax
cmpl %eax, %r15d
jne 0x44924
incl %r15d
testl %eax, %eax
je 0x44881
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x44886
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
cmpl %r15d, %eax
jge 0x44924
movslq %r15d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
testq %r12, %r12
je 0x448ae
incl 0x3b4(%r12)
movq 0xb942b(%rip), %rsi     # 0xfdce0
callq *0xb4c55(%rip)          # 0xf9510
movq 0x1c18(%r12), %rsi
testq %rsi, %rsi
je 0x44914
movslq 0x1c10(%r12), %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,4), %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0xc080
movq 0x1c18(%r12), %rdi
testq %rdi, %rdi
je 0x44903
movq 0xb93d8(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x44903
decl 0x3b4(%rax)
movq 0xb93d6(%rip), %rsi     # 0xfdce0
callq *0xb4c08(%rip)          # 0xf9518
movq -0x30(%rbp), %rax
movq %rax, 0x1c18(%r12)
movl %r15d, 0x1c14(%r12)
movq 0x1c18(%r12), %rax
movslq 0x1c10(%r12), %rcx
leaq (%rcx,%rcx,4), %rcx
movl %r14d, (%rax,%rcx,4)
movaps -0x40(%rbp), %xmm0
movups %xmm0, 0x4(%rax,%rcx,4)
incl 0x1c10(%r12)
movups (%rbx), %xmm0
movups %xmm0, (%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.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
testl %edi, %edi
jle 0x449bf
movq 0xb935d(%rip), %rax     # 0xfdcd0
leaq 0x1624(%rax), %rcx
incl %edi
movslq 0x1c10(%rax), %rdx
testq %rdx, %rdx
jle 0x449e0
movq 0x1c18(%rax), %rsi
leaq (%rdx,%rdx,4), %rdx
movslq -0x14(%rsi,%rdx,4), %r8
shlq $0x4, %r8
movups -0x10(%rsi,%rdx,4), %xmm0
movups %xmm0, (%rcx,%r8)
movl 0x1c10(%rax), %edx
testl %edx, %edx
jle 0x449c1
decl %edx
movl %edx, 0x1c10(%rax)
decl %edi
cmpl $0x1, %edi
jg 0x4497c
popq %rbp
retq
leaq 0x8b012(%rip), %rdi     # 0xcf9da
leaq 0x76cbc(%rip), %rsi     # 0xbb68b
leaq 0x77f6a(%rip), %rcx     # 0xbc940
movl $0x672, %edx            # imm = 0x672
callq 0xc140
leaq 0x8aff3(%rip), %rdi     # 0xcf9da
leaq 0x76c9d(%rip), %rsi     # 0xbb68b
leaq 0x77f14(%rip), %rcx     # 0xbc909
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, float)
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1)
    {
        ImGuiContext& g = *GImGui;
        float* pvar = (float*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x18, %edi
jae 0x44b83
movl %edi, %ebx
movl %edi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x7350b(%rip), %rcx     # 0xb7f30
cmpl $0x8, (%rcx,%rax,4)
jne 0x44b64
leaq (%rcx,%rax,4), %rax
cmpl $0x1, 0x4(%rax)
jne 0x44b64
movq 0xb928c(%rip), %r15     # 0xfdcd0
movl 0x8(%rax), %r12d
movss 0x1560(%r15,%r12), %xmm1
movl 0x1c20(%r15), %r13d
movl 0x1c24(%r15), %eax
cmpl %eax, %r13d
jne 0x44b29
incl %r13d
testl %eax, %eax
je 0x44a7d
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x44a82
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x44b29
movss %xmm1, -0x2c(%rbp)
movss %xmm0, -0x30(%rbp)
movslq %r13d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
testq %r15, %r15
je 0x44ab3
incl 0x3b4(%r15)
movq 0xb9226(%rip), %rsi     # 0xfdce0
callq *0xb4a50(%rip)          # 0xf9510
movq %rax, %r14
movq 0x1c28(%r15), %rsi
testq %rsi, %rsi
je 0x44b11
movslq 0x1c20(%r15), %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
callq 0xc080
movq 0x1c28(%r15), %rdi
testq %rdi, %rdi
je 0x44b04
movq 0xb91d7(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x44b04
decl 0x3b4(%rax)
movq 0xb91d5(%rip), %rsi     # 0xfdce0
callq *0xb4a07(%rip)          # 0xf9518
movq %r14, 0x1c28(%r15)
movl %r13d, 0x1c24(%r15)
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
movq 0x1c28(%r15), %rax
movslq 0x1c20(%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
movl %ebx, (%rax,%rcx,4)
movss %xmm1, 0x4(%rax,%rcx,4)
incl 0x1c20(%r15)
movss %xmm0, 0x1560(%r15,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73914(%rip), %rdi     # 0xb847f
leaq 0x735f3(%rip), %rsi     # 0xb8165
leaq 0x7394e(%rip), %rcx     # 0xb84c7
movl $0x9c4, %edx            # imm = 0x9C4
callq 0xc140
leaq 0x76a57(%rip), %rdi     # 0xbb5e1
leaq 0x735d4(%rip), %rsi     # 0xb8165
leaq 0x76a6f(%rip), %rcx     # 0xbb607
movl $0x9b4, %edx            # imm = 0x9B4
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
    {
        ImGuiContext& g = *GImGui;
        ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x18, %edi
jae 0x44d40
movl %edi, %r14d
movl %edi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x73364(%rip), %rcx     # 0xb7f30
cmpl $0x8, (%rcx,%rax,4)
jne 0x44d21
leaq (%rcx,%rax,4), %rax
cmpl $0x2, 0x4(%rax)
jne 0x44d21
movq %rsi, %rbx
movq 0xb90e2(%rip), %r12     # 0xfdcd0
movl 0x8(%rax), %r13d
movsd 0x1560(%r12,%r13), %xmm1
movl 0x1c20(%r12), %r15d
movl 0x1c24(%r12), %eax
cmpl %eax, %r15d
jne 0x44cd4
incl %r15d
testl %eax, %eax
je 0x44c29
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x44c2e
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
cmpl %r15d, %eax
jge 0x44cd4
movaps %xmm1, -0x40(%rbp)
movslq %r15d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
testq %r12, %r12
je 0x44c5a
incl 0x3b4(%r12)
movq 0xb907f(%rip), %rsi     # 0xfdce0
callq *0xb48a9(%rip)          # 0xf9510
movq 0x1c28(%r12), %rsi
testq %rsi, %rsi
je 0x44cc0
movslq 0x1c20(%r12), %rcx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rdx
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0xc080
movq 0x1c28(%r12), %rdi
testq %rdi, %rdi
je 0x44caf
movq 0xb902c(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x44caf
decl 0x3b4(%rax)
movq 0xb902a(%rip), %rsi     # 0xfdce0
callq *0xb485c(%rip)          # 0xf9518
movq -0x30(%rbp), %rax
movq %rax, 0x1c28(%r12)
movl %r15d, 0x1c24(%r12)
movaps -0x40(%rbp), %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
movq 0x1c28(%r12), %rax
movslq 0x1c20(%r12), %rcx
leaq (%rcx,%rcx,2), %rcx
movl %r14d, (%rax,%rcx,4)
movss %xmm1, 0x4(%rax,%rcx,4)
movss %xmm0, 0x8(%rax,%rcx,4)
incl 0x1c20(%r12)
movq (%rbx), %rax
movq %rax, 0x1560(%r12,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x737ce(%rip), %rdi     # 0xb84f6
leaq 0x73436(%rip), %rsi     # 0xb8165
leaq 0x7380a(%rip), %rcx     # 0xb8540
movl $0x9d2, %edx            # imm = 0x9D2
callq 0xc140
leaq 0x7689a(%rip), %rdi     # 0xbb5e1
leaq 0x73417(%rip), %rsi     # 0xb8165
leaq 0x768b2(%rip), %rcx     # 0xbb607
movl $0x9b4, %edx            # imm = 0x9B4
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopStyleVar(int)
void ImGui::PopStyleVar(int count)
{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        // We avoid a generic memcpy(data, &backup.Backup.., GDataTypeSize[info->Type] * info->Count), the overhead in Debug is not worth it.
        ImGuiStyleMod& backup = g.StyleVarStack.back();
        const ImGuiStyleVarInfo* info = GetStyleVarInfo(backup.VarIdx);
        void* data = info->GetVarPtr(&g.Style);
        if (info->Type == ImGuiDataType_Float && info->Count == 1)      { ((float*)data)[0] = backup.BackupFloat[0]; }
        else if (info->Type == ImGuiDataType_Float && info->Count == 2) { ((float*)data)[0] = backup.BackupFloat[0]; ((float*)data)[1] = backup.BackupFloat[1]; }
        g.StyleVarStack.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x44e12
movq 0xb8f5e(%rip), %rax     # 0xfdcd0
movl 0x1c20(%rax), %ecx
incl %edi
leaq 0x731af(%rip), %rdx     # 0xb7f30
testl %ecx, %ecx
jle 0x44e33
movq 0x1c28(%rax), %rsi
movl %ecx, %r8d
leaq (%r8,%r8,2), %r8
movl -0xc(%rsi,%r8,4), %r9d
cmpq $0x18, %r9
jae 0x44e14
leaq (%r9,%r9,2), %r10
movl (%rdx,%r10,4), %r9d
cmpl $0x8, %r9d
jne 0x44dff
leaq (%rsi,%r8,4), %rsi
leaq (%rdx,%r10,4), %r10
movl 0x8(%r10), %r8d
cmpl $0x1, 0x4(%r10)
jne 0x44dd4
movss -0x8(%rsi), %xmm0
movss %xmm0, 0x1560(%rax,%r8)
jmp 0x44dff
cmpl $0x8, %r9d
jne 0x44dff
cmpl $0x2, 0x4(%r10)
jne 0x44dff
movss -0x8(%rsi), %xmm0
movss %xmm0, 0x1560(%rax,%r8)
movss -0x4(%rsi), %xmm0
movss %xmm0, 0x1564(%rax,%r8)
decl %ecx
movl %ecx, 0x1c20(%rax)
decl %edi
cmpl $0x1, %edi
jg 0x44d81
popq %rbp
retq
leaq 0x767c6(%rip), %rdi     # 0xbb5e1
leaq 0x73343(%rip), %rsi     # 0xb8165
leaq 0x767de(%rip), %rcx     # 0xbb607
movl $0x9b4, %edx            # imm = 0x9B4
callq 0xc140
leaq 0x8aba0(%rip), %rdi     # 0xcf9da
leaq 0x7684a(%rip), %rsi     # 0xbb68b
leaq 0x77b35(%rip), %rcx     # 0xbc97d
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindRenderedTextEnd(char const*, char const*)
const char* ImGui::FindRenderedTextEnd(const char* text, const char* text_end)
{
    const char* text_display_end = text;
    if (!text_end)
        text_end = (const char*)-1;

    while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
        text_display_end++;
    return text_display_end;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x1, %rsi
sbbq %rcx, %rcx
orq %rsi, %rcx
cmpq %rdi, %rcx
jbe 0x44ec3
pushq %rbp
movq %rsp, %rbp
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0x44eb1
testl %edx, %edx
jne 0x44eb7
jmp 0x44ec2
cmpb $0x23, 0x1(%rax)
je 0x44ec2
incq %rax
cmpq %rcx, %rax
jne 0x44ea3
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderText(ImVec2, char const*, char const*, bool)
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    // Hide anything after a '##' string
    const char* text_display_end;
    if (hide_text_after_hash)
    {
        text_display_end = FindRenderedTextEnd(text, text_end);
    }
    else
    {
        if (!text_end)
            text_end = text + strlen(text); // FIXME-OPT
        text_display_end = text_end;
    }

    if (text != text_display_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_display_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0xb8dea(%rip), %r13     # 0xfdcd0
movq 0x1ae0(%r13), %r15
testl %edx, %edx
je 0x44f2b
xorl %eax, %eax
cmpq $0x1, %r14
sbbq %rax, %rax
orq %r14, %rax
movq %rbx, %r14
cmpq %rbx, %rax
jbe 0x44f3e
movq %rbx, %r14
movzbl (%r14), %ecx
cmpl $0x23, %ecx
je 0x44f17
testl %ecx, %ecx
jne 0x44f1e
jmp 0x44f3e
cmpb $0x23, 0x1(%r14)
je 0x44f3e
incq %r14
cmpq %rax, %r14
jne 0x44f08
movq %rax, %r14
jmp 0x44f3e
testq %r14, %r14
jne 0x44f3e
movq %rbx, %rdi
callq 0xc350
movq %rax, %r14
addq %rbx, %r14
cmpq %rbx, %r14
je 0x44fca
movq 0x2b8(%r15), %r15
movq 0x1978(%r13), %r12
movss 0x1980(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movups 0x1624(%r13), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x1560(%r13), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x42e9e
movq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
xorps %xmm1, %xmm1
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x7ae8c
cmpb $0x1, 0x3138(%r13)
jne 0x44fca
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x44fd9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderTextWrapped(ImVec2, char const*, char const*, float)
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    if (!text_end)
        text_end = text + strlen(text); // FIXME-OPT

    if (text != text_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_end, wrap_width);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm1, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, -0x38(%rbp)
movq 0xb8b1a(%rip), %r13     # 0xfdcd0
movq 0x1ae0(%r13), %r15
testq %rsi, %rsi
jne 0x451d0
movq %rbx, %rdi
callq 0xc350
movq %rax, %r14
addq %rbx, %r14
cmpq %rbx, %r14
je 0x4525e
movq 0x2b8(%r15), %r15
movq 0x1978(%r13), %r12
movss 0x1980(%r13), %xmm0
movss %xmm0, -0x2c(%rbp)
movups 0x1624(%r13), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movss 0x1560(%r13), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x42e9e
movq $0x0, (%rsp)
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movss -0x2c(%rbp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
movss -0x30(%rbp), %xmm1
callq 0x7ae8c
cmpb $0x1, 0x3138(%r13)
jne 0x4525e
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x44fd9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcTextSize(char const*, char const*, bool, float)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
    ImGuiContext& g = *GImGui;

    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindRenderedTextEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;

    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    if (text == text_display_end)
        return ImVec2(0.0f, font_size);
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);

    // Round
    text_size.x = IM_FLOOR(text_size.x + 0.95f);

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps %xmm0, %xmm2
movq %rsi, %rax
movq %rdi, %rsi
movq 0xb882f(%rip), %rcx     # 0xfdcd0
testl %edx, %edx
je 0x454db
xorl %edx, %edx
cmpq $0x1, %rax
sbbq %rdx, %rdx
orq %rax, %rdx
movq %rsi, %rax
cmpq %rsi, %rdx
jbe 0x454db
movq %rsi, %rax
movzbl (%rax), %edi
cmpl $0x23, %edi
je 0x454ca
testl %edi, %edi
jne 0x454d0
jmp 0x454db
cmpb $0x23, 0x1(%rax)
je 0x454db
incq %rax
cmpq %rdx, %rax
jne 0x454bc
movq %rdx, %rax
movss 0x1980(%rcx), %xmm0
cmpq %rsi, %rax
je 0x4551a
movq 0x1978(%rcx), %rdi
movss 0x72349(%rip), %xmm1    # 0xb7840
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x8359c
movss 0x72353(%rip), %xmm1    # 0xb785c
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
jmp 0x45525
movq %xmm0, %xmm0            # xmm0 = xmm0[0],zero
xorps %xmm1, %xmm1
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
popq %rbp
retq