LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: float ImGui::RoundScalarWithFormatT<float, float>(char const*, int, float)
const char* ImParseFormatFindStart(const char* fmt)
{
    while (char c = fmt[0])
    {
        if (c == '%' && fmt[1] != '%')
            return fmt;
        else if (c == '%')
            fmt++;
        fmt++;
    }
    return fmt;
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0xad78d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %r14d
movq %rdi, %rdx
cmpb $0x25, %al
jne 0xad6d6
cmpb $0x25, 0x1(%rdx)
jne 0xad6ee
xorl %ecx, %ecx
cmpb $0x25, %al
sete %cl
addq %rcx, %rdx
incq %rdx
movb (%rdx), %al
testb %al, %al
jne 0xad6cc
jmp 0xad785
cvtss2sd %xmm0, %xmm0
leaq -0x50(%rbp), %rbx
movl $0x40, %esi
movq %rbx, %rdi
movb $0x1, %al
callq 0x41f22
movb (%rbx), %al
incq %rbx
cmpb $0x20, %al
je 0xad705
andl $-0x2, %r14d
cmpl $0x8, %r14d
jne 0xad729
decq %rbx
movq %rbx, %rdi
callq 0xc700
cvtsd2ss %xmm0, %xmm0
jmp 0xad785
xorl %ecx, %ecx
cmpb $0x2d, %al
sete %cl
xorl %edx, %edx
cmpb $0x2b, -0x1(%rbx,%rcx)
sete %dl
addq %rcx, %rdx
movb -0x1(%rbx,%rdx), %cl
leal -0x30(%rcx), %esi
xorps %xmm0, %xmm0
cmpb $0x9, %sil
ja 0xad77a
addq %rdx, %rbx
movss 0x78b0(%rip), %xmm1     # 0xb5008
addb $-0x30, %cl
movsbl %cl, %ecx
xorps %xmm2, %xmm2
cvtsi2ss %ecx, %xmm2
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
movb (%rbx), %cl
leal -0x30(%rcx), %edx
incq %rbx
cmpb $0xa, %dl
jb 0xad758
cmpb $0x2d, %al
jne 0xad785
xorps 0x783b(%rip), %xmm0     # 0xb4fc0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatFindEnd(char const*)
const char* ImParseFormatFindEnd(const char* fmt)
{
    // Printf/scanf types modifiers: I/L/h/j/l/t/w/z. Other uppercase letters qualify as types aka end of the format.
    if (fmt[0] != '%')
        return fmt;
    const unsigned int ignored_uppercase_mask = (1 << ('I'-'A')) | (1 << ('L'-'A'));
    const unsigned int ignored_lowercase_mask = (1 << ('h'-'a')) | (1 << ('j'-'a')) | (1 << ('l'-'a')) | (1 << ('t'-'a')) | (1 << ('w'-'a')) | (1 << ('z'-'a'));
    for (char c; (c = *fmt) != 0; fmt++)
    {
        if (c >= 'A' && c <= 'Z' && ((1 << (c - 'A')) & ignored_uppercase_mask) == 0)
            return fmt + 1;
        if (c >= 'a' && c <= 'z' && ((1 << (c - 'a')) & ignored_lowercase_mask) == 0)
            return fmt + 1;
    }
    return fmt;
}

// Assembly:
movq %rdi, %rax
cmpb $0x25, (%rdi)
jne 0x97b0d
pushq %rbp
movq %rsp, %rbp
incq %rax
movb $0x25, %dil
movl $0x25, %esi
movl $0x900, %ecx            # imm = 0x900
movl $0x2480a80, %edx        # imm = 0x2480A80
leal -0x41(%rdi), %r8d
cmpb $0x19, %r8b
ja 0x97ae7
decb %sil
movzbl %sil, %esi
btl %esi, %ecx
jb 0x97afd
jmp 0x97b0c
addb $-0x61, %dil
cmpb $0x19, %dil
ja 0x97afd
decb %sil
movzbl %sil, %esi
btl %esi, %edx
jae 0x97b0c
movsbl (%rax), %esi
incq %rax
movl %esi, %edi
testl %esi, %esi
jne 0x97acf
decq %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatTrimDecorations(char const*, char*, unsigned long)
const char* ImParseFormatTrimDecorations(const char* fmt, char* buf, size_t buf_size)
{
    const char* fmt_start = ImParseFormatFindStart(fmt);
    if (fmt_start[0] != '%')
        return fmt;
    const char* fmt_end = ImParseFormatFindEnd(fmt_start);
    if (fmt_end[0] == 0) // If we only have leading decoration, we don't need to copy the data.
        return fmt_start;
    ImStrncpy(buf, fmt_start, ImMin((size_t)(fmt_end - fmt_start) + 1, buf_size));
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb (%rdi), %al
testb %al, %al
je 0x97b46
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x25, %al
jne 0x97b32
cmpb $0x25, 0x1(%r15)
jne 0x97b57
xorl %ecx, %ecx
cmpb $0x25, %al
sete %cl
addq %rcx, %r15
incq %r15
movb (%r15), %al
testb %al, %al
jne 0x97b27
movq %rdi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x97aae
cmpb $0x0, (%rax)
je 0x97b81
subq %r15, %rax
incq %rax
cmpq %r14, %rax
cmovaeq %r14, %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x41beb
jmp 0x97b49
movq %r15, %rbx
jmp 0x97b49
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImParseFormatPrecision(char const*, int)
int ImParseFormatPrecision(const char* fmt, int default_precision)
{
    fmt = ImParseFormatFindStart(fmt);
    if (fmt[0] != '%')
        return default_precision;
    fmt++;
    while (*fmt >= '0' && *fmt <= '9')
        fmt++;
    int precision = INT_MAX;
    if (*fmt == '.')
    {
        fmt = ImAtoi<int>(fmt + 1, &precision);
        if (precision < 0 || precision > 99)
            precision = default_precision;
    }
    if (*fmt == 'e' || *fmt == 'E') // Maximum precision with scientific notation
        precision = -1;
    if ((*fmt == 'g' || *fmt == 'G') && precision == INT_MAX)
        precision = -1;
    return (precision == INT_MAX) ? default_precision : precision;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movb (%rdi), %al
testb %al, %al
je 0x97c17
cmpb $0x25, %al
jne 0x97ba3
cmpb $0x25, 0x1(%rdi)
jne 0x97bb2
xorl %ecx, %ecx
cmpb $0x25, %al
sete %cl
addq %rcx, %rdi
incq %rdi
jmp 0x97b93
incq %rdi
movb (%rdi), %al
leal -0x30(%rax), %ecx
incq %rdi
cmpb $0xa, %cl
jb 0x97bb5
movl $0x7fffffff, -0x14(%rbp) # imm = 0x7FFFFFFF
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpb $0x2e, %al
jne 0x97be9
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x97c2d
movl (%r14), %ecx
cmpl $0x64, %ecx
cmovael %ebx, %ecx
movb (%rax), %al
cmpb $0x45, %al
je 0x97c10
movzbl %al, %edx
cmpl $0x65, %edx
je 0x97c10
cmpl $0x67, %edx
jne 0x97c04
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0x97c10
jmp 0x97c15
cmpb $0x47, %al
jne 0x97c22
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
jne 0x97c22
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmovel %ebx, %ecx
jmp 0x97c15
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: char const* ImAtoi<int>(char const*, int*)
static const char* ImAtoi(const char* src, TYPE* output)
{
    int negative = 0;
    if (*src == '-') { negative = 1; src++; }
    if (*src == '+') { src++; }
    TYPE v = 0;
    while (*src >= '0' && *src <= '9')
        v = (v * 10) + (*src++ - '0');
    *output = negative ? -v : v;
    return src;
}

// Assembly:
movb (%rdi), %cl
xorl %eax, %eax
cmpb $0x2d, %cl
sete %al
leaq (%rdi,%rax), %rdx
xorl %r8d, %r8d
cmpb $0x2b, (%rdi,%rax)
sete %r8b
leaq (%rdx,%r8), %rax
movb (%r8,%rdx), %dil
leal -0x30(%rdi), %r8d
xorl %edx, %edx
cmpb $0x9, %r8b
ja 0x97c80
pushq %rbp
movq %rsp, %rbp
xorl %edx, %edx
leal (%rdx,%rdx,4), %edx
addb $-0x30, %dil
movzbl %dil, %edi
leal (%rdi,%rdx,2), %edx
movb 0x1(%rax), %dil
incq %rax
leal -0x30(%rdi), %r8d
cmpb $0xa, %r8b
jb 0x97c60
popq %rbp
movl %edx, %edi
negl %edi
cmpb $0x2d, %cl
cmovnel %edx, %edi
movl %edi, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TempInputText(ImRect const&, unsigned int, char const*, char*, int, int)
bool ImGui::TempInputText(const ImRect& bb, ImGuiID id, const char* label, char* buf, int buf_size, ImGuiInputTextFlags flags)
{
    // On the first frame, g.TempInputTextId == 0, then on subsequent frames it becomes == id.
    // We clear ActiveID on the first frame to allow the InputText() taking it back.
    ImGuiContext& g = *GImGui;
    const bool init = (g.TempInputId != id);
    if (init)
        ClearActiveID();

    g.CurrentWindow->DC.CursorPos = bb.Min;
    bool value_changed = InputTextEx(label, NULL, buf, buf_size, bb.GetSize(), flags);
    if (init)
    {
        // First frame we started displaying the InputText widget, we expect it to take the active id.
        IM_ASSERT(g.ActiveId == id);
        g.TempInputId = g.ActiveId;
    }
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r13d
movq %rdx, %r11
movl %esi, %ebx
movq %rdi, %r14
leaq 0x64020(%rip), %rax     # 0xfbcd0
movq (%rax), %r15
movl 0x3068(%r15), %r12d
cmpl %esi, %r12d
je 0x97cdc
movl %r9d, -0x2c(%rbp)
movq %rcx, -0x40(%rbp)
movq %r11, -0x38(%rbp)
callq 0x46130
movq -0x38(%rbp), %r11
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %r9d
movq 0x1ae0(%r15), %rax
movq (%r14), %rdx
movq %rdx, 0xd8(%rax)
movss 0x8(%r14), %xmm0
movss 0xc(%r14), %xmm1
subss (%r14), %xmm0
subss 0x4(%r14), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x48(%rbp), %r8
movlps %xmm0, (%r8)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %r11, %rdi
xorl %esi, %esi
movq %rcx, %rdx
movl %r13d, %ecx
callq 0x97d69
cmpl %ebx, %r12d
je 0x97d3b
cmpl %ebx, 0x1b30(%r15)
jne 0x97d4a
movl %ebx, 0x3068(%r15)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3a0a3(%rip), %rdi     # 0xd1df4
leaq 0x392c0(%rip), %rsi     # 0xd1018
leaq 0x3a0a6(%rip), %rcx     # 0xd1e05
movl $0xca9, %edx            # imm = 0xCA9
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::InputScalarN(char const*, int, void*, int, void const*, void const*, char const*, int)
bool ImGui::InputScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, const void* p_step, const void* p_step_fast, const char* format, ImGuiInputTextFlags flags)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiContext& g = *GImGui;
    bool value_changed = false;
    BeginGroup();
    PushID(label);
    PushMultiItemsWidths(components, CalcItemWidth());
    size_t type_size = GDataTypeInfo[data_type].Size;
    for (int i = 0; i < components; i++)
    {
        PushID(i);
        if (i > 0)
            SameLine(0, g.Style.ItemInnerSpacing.x);
        value_changed |= InputScalar("", data_type, p_data, p_step, p_step_fast, format, flags);
        PopID();
        PopItemWidth();
        p_data = (void*)((char*)p_data + type_size);
    }
    PopID();

    const char* label_end = FindRenderedTextEnd(label);
    if (label != label_end)
    {
        SameLine(0.0f, g.Style.ItemInnerSpacing.x);
        TextEx(label, label_end);
    }

    EndGroup();
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x50(%rbp)
movq %r8, -0x48(%rbp)
movl %esi, -0x2c(%rbp)
leaq 0x60adc(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq 0x1ae0(%rax), %rax
movb $0x1, 0x90(%rax)
cmpb $0x0, 0x93(%rax)
je 0x9b21a
xorl %r14d, %r14d
jmp 0x9b302
movl %ecx, %r13d
movq %rdx, %rbx
movq %rdi, %r14
callq 0x56428
movq %r14, -0x40(%rbp)
movq %r14, %rdi
callq 0x54b5f
callq 0x5614d
movl %r13d, %edi
callq 0x55e21
xorl %r12d, %r12d
testl %r13d, %r13d
jle 0x9b2be
movslq -0x2c(%rbp), %rax
shlq $0x5, %rax
leaq 0x5b7b8(%rip), %rcx     # 0xf6a10
movq (%rax,%rcx), %r15
xorl %r14d, %r14d
movl %r12d, %edi
callq 0x54e5e
testl %r12d, %r12d
je 0x9b280
movq -0x38(%rbp), %rax
movss 0x15b0(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0x5591d
movl 0x18(%rbp), %eax
movl %eax, (%rsp)
leaq 0x19c90(%rip), %rdi     # 0xb4f1d
movl -0x2c(%rbp), %esi
movq %rbx, %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x9ae5e
orb %al, %r14b
callq 0x55082
callq 0x560da
addq %r15, %rbx
incl %r12d
cmpl %r12d, %r13d
jne 0x9b25f
jmp 0x9b2c1
xorl %r14d, %r14d
callq 0x55082
movq -0x40(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4443d
cmpq %r15, %rax
je 0x9b2fd
movq %rax, %rbx
movq -0x38(%rbp), %rax
movss 0x15b0(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0x5591d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x8fe70
callq 0x55617
andb $0x1, %r14b
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGuiInputTextCallbackData::DeleteChars(int, int)
void ImGuiInputTextCallbackData::DeleteChars(int pos, int bytes_count)
{
    IM_ASSERT(pos + bytes_count <= BufTextLen);
    char* dst = Buf + pos;
    const char* src = Buf + pos + bytes_count;
    while (char c = *src++)
        *dst++ = c;
    *dst = '\0';

    if (CursorPos >= pos + bytes_count)
        CursorPos -= bytes_count;
    else if (CursorPos >= pos)
        CursorPos = pos;
    SelectionStart = SelectionEnd = CursorPos;
    BufDirty = true;
    BufTextLen -= bytes_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal (%rdx,%rsi), %eax
cmpl 0x20(%rdi), %eax
jg 0x9c643
movslq %esi, %rcx
addq 0x18(%rdi), %rcx
movslq %edx, %r8
movb (%r8,%rcx), %r9b
testb %r9b, %r9b
je 0x9c617
leaq 0x1(%rcx), %r10
movb %r9b, (%rcx)
movb 0x1(%rcx,%r8), %r9b
movq %r10, %rcx
testb %r9b, %r9b
jne 0x9c601
jmp 0x9c61a
movq %rcx, %r10
movb $0x0, (%r10)
movl 0x2c(%rdi), %ecx
cmpl %eax, %ecx
jge 0x9c62b
cmpl %esi, %ecx
jge 0x9c62f
jmp 0x9c634
subl %edx, %ecx
movl %ecx, %esi
movl %esi, 0x2c(%rdi)
movl %esi, %ecx
movl %ecx, 0x34(%rdi)
movl %ecx, 0x30(%rdi)
movb $0x1, 0x28(%rdi)
subl %edx, 0x20(%rdi)
popq %rbp
retq
leaq 0x3592f(%rip), %rdi     # 0xd1f79
leaq 0x349c7(%rip), %rsi     # 0xd1018
leaq 0x35941(%rip), %rcx     # 0xd1f99
movl $0xe56, %edx            # imm = 0xE56
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imstb_textedit.h
// Function: ImStb::stb_textedit_click(ImGuiInputTextState*, ImStb::STB_TexteditState*, float, float)
static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
{
   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
   // goes off the top or bottom of the text
   if( state->single_line )
   {
      StbTexteditRow r;
      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
      y = r.ymin;
   }

   state->cursor = stb_text_locate_coord(str, x, y);
   state->select_start = state->cursor;
   state->select_end = state->cursor;
   state->has_preferred_x = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x17(%rsi)
je 0x9c897
movslq 0x4(%r14), %rax
movq 0x18(%r14), %rdi
leaq (%rdi,%rax,2), %rsi
leaq -0x20(%rbp), %rdx
movl $0x1, %ecx
movss %xmm0, -0x14(%rbp)
callq 0x9cb91
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
movq %r14, %rdi
callq 0xa705e
movl %eax, (%rbx)
movl %eax, 0x4(%rbx)
movl %eax, 0x8(%rbx)
movb $0x0, 0x16(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imstb_textedit.h
// Function: ImStb::stb_textedit_drag(ImGuiInputTextState*, ImStb::STB_TexteditState*, float, float)
static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, float x, float y)
{
   int p = 0;

   // In single-line mode, just always make y = 0. This lets the drag keep working if the mouse
   // goes off the top or bottom of the text
   if( state->single_line )
   {
      StbTexteditRow r;
      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
      y = r.ymin;
   }

   if (state->select_start == state->select_end)
      state->select_start = state->cursor;

   p = stb_text_locate_coord(str, x, y);
   state->cursor = state->select_end = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x17(%rsi)
je 0x9c8f2
movslq 0x4(%r14), %rax
movq 0x18(%r14), %rdi
leaq (%rdi,%rax,2), %rsi
leaq -0x20(%rbp), %rdx
movl $0x1, %ecx
movss %xmm0, -0x14(%rbp)
callq 0x9cb91
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
movl 0x4(%rbx), %eax
cmpl 0x8(%rbx), %eax
jne 0x9c8ff
movl (%rbx), %eax
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0xa705e
movl %eax, 0x8(%rbx)
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: InputTextCalcTextSizeW(unsigned short const*, unsigned short const*, unsigned short const**, ImVec2*, bool)
static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining, ImVec2* out_offset, bool stop_on_new_line)
{
    ImGuiContext& g = *GImGui;
    ImFont* font = g.Font;
    const float line_height = g.FontSize;
    const float scale = line_height / font->FontSize;

    ImVec2 text_size = ImVec2(0, 0);
    float line_width = 0.0f;

    const ImWchar* s = text_begin;
    while (s < text_end)
    {
        unsigned int c = (unsigned int)(*s++);
        if (c == '\n')
        {
            text_size.x = ImMax(text_size.x, line_width);
            text_size.y += line_height;
            line_width = 0.0f;
            if (stop_on_new_line)
                break;
            continue;
        }
        if (c == '\r')
            continue;

        const float char_width = font->GetCharAdvance((ImWchar)c) * scale;
        line_width += char_width;
    }

    if (text_size.x < line_width)
        text_size.x = line_width;

    if (out_offset)
        *out_offset = ImVec2(line_width, text_size.y + line_height);  // offset allow for the possibility of sitting after a trailing \n

    if (line_width > 0 || text_size.y == 0.0f)                        // whereas size.y will ignore the trailing \n
        text_size.y += line_height;

    if (remaining)
        *remaining = s;

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5f134(%rip), %rax     # 0xfbcd0
movq (%rax), %r8
movq 0x1978(%r8), %rax
movss 0x1980(%r8), %xmm0
movaps %xmm0, %xmm3
divss 0x14(%rax), %xmm3
leaq 0x10(%rax), %r8
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpq %rsi, %rdi
jae 0x9cc28
movzwl (%rdi), %r9d
addq $0x2, %rdi
cmpl $0xd, %r9d
je 0x9cbc1
cmpl $0xa, %r9d
je 0x9cbfc
leal (,%r9,4), %r10d
addq 0x8(%rax), %r10
cmpl %r9d, (%rax)
cmovleq %r8, %r10
movss (%r10), %xmm4
mulss %xmm3, %xmm4
addss %xmm4, %xmm2
jmp 0x9cbc1
movaps %xmm2, %xmm4
cmpless %xmm1, %xmm4
movaps %xmm4, %xmm5
andps %xmm1, %xmm5
andnps %xmm2, %xmm4
orps %xmm5, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm1, %xmm2
addss %xmm0, %xmm2
movaps %xmm4, %xmm1
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
testb %cl, %cl
je 0x9cbbe
xorps %xmm2, %xmm2
testq %rdx, %rdx
je 0x9cc30
movq %rdi, (%rdx)
ucomiss %xmm1, %xmm2
jbe 0x9cc39
movss %xmm2, %xmm1            # xmm1 = xmm2[0],xmm1[1,2,3]
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
xorps %xmm4, %xmm4
movaps %xmm3, %xmm5
cmpeqps %xmm4, %xmm5
cmpltps %xmm2, %xmm4
orps %xmm5, %xmm4
movd %xmm4, %eax
testb $0x1, %al
jne 0x9cc5e
movaps %xmm1, %xmm0
jmp 0x9cc69
addss %xmm3, %xmm0
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: RenderArrowsForVerticalBar(ImDrawList*, ImVec2, ImVec2, float, float)
static void RenderArrowsForVerticalBar(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, float bar_w, float alpha)
{
    ImU32 alpha8 = IM_F32_TO_INT8_SAT(alpha);
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + half_sz.x + 1,         pos.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Right, IM_COL32(0,0,0,alpha8));
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + half_sz.x,             pos.y), half_sz,                              ImGuiDir_Right, IM_COL32(255,255,255,alpha8));
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + bar_w - half_sz.x - 1, pos.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Left,  IM_COL32(0,0,0,alpha8));
    ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + bar_w - half_sz.x,     pos.y), half_sz,                              ImGuiDir_Left,  IM_COL32(255,255,255,alpha8));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movaps %xmm2, -0x50(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, %xmm2
movq %rdi, %rbx
movss 0x14d18(%rip), %xmm0    # 0xb4fe4
movaps %xmm2, %xmm5
movaps %xmm2, %xmm6
movaps %xmm2, -0x30(%rbp)
addps %xmm1, %xmm5
movaps %xmm5, -0x70(%rbp)
addss %xmm0, %xmm5
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
addss %xmm0, %xmm2
minss %xmm3, %xmm0
xorps %xmm4, %xmm4
cmpltss %xmm4, %xmm3
andnps %xmm0, %xmm3
mulss 0x15545(%rip), %xmm3    # 0xb5848
addss 0x14cf9(%rip), %xmm3    # 0xb5004
cvttss2si %xmm3, %r14d
movss 0x15550(%rip), %xmm0    # 0xb5868
addss %xmm1, %xmm0
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movaps %xmm0, %xmm1
movaps %xmm0, -0x60(%rbp)
shll $0x18, %r14d
movaps %xmm6, %xmm0
movss %xmm5, %xmm0            # xmm0 = xmm5[0],xmm0[1,2,3]
movl $0x1, %esi
movl %r14d, %edx
callq 0x8249b
movaps -0x30(%rbp), %xmm0
movaps -0x70(%rbp), %xmm1
shufps $0x1, %xmm1, %xmm0      # xmm0 = xmm0[1,0],xmm1[0,0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
leal 0xffffff(%r14), %r15d
movq %rbx, %rdi
movaps -0x40(%rbp), %xmm1
movl $0x1, %esi
movl %r15d, %edx
callq 0x8249b
movaps -0x50(%rbp), %xmm0
movaps -0x30(%rbp), %xmm2
addss %xmm2, %xmm0
subss -0x40(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movss 0x14c4a(%rip), %xmm1    # 0xb4fd0
addss %xmm0, %xmm1
movaps %xmm2, %xmm0
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
movq %rbx, %rdi
movaps -0x60(%rbp), %xmm1
xorl %esi, %esi
movl %r14d, %edx
callq 0x8249b
movaps -0x30(%rbp), %xmm0
movaps -0x50(%rbp), %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
movq %rbx, %rdi
movaps -0x40(%rbp), %xmm1
xorl %esi, %esi
movl %r15d, %edx
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8249b
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SetColorEditOptions(int)
void ImGui::SetColorEditOptions(ImGuiColorEditFlags flags)
{
    ImGuiContext& g = *GImGui;
    if ((flags & ImGuiColorEditFlags__DisplayMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DisplayMask;
    if ((flags & ImGuiColorEditFlags__DataTypeMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DataTypeMask;
    if ((flags & ImGuiColorEditFlags__PickerMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__PickerMask;
    if ((flags & ImGuiColorEditFlags__InputMask) == 0)
        flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__InputMask;
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__DisplayMask));    // Check only 1 option is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__DataTypeMask));   // Check only 1 option is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__PickerMask));     // Check only 1 option is selected
    IM_ASSERT(ImIsPowerOfTwo(flags & ImGuiColorEditFlags__InputMask));      // Check only 1 option is selected
    g.ColorEditOptions = flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
orl $0x100000, %eax         # imm = 0x100000
testl $0x700000, %edi         # imm = 0x700000
cmovnel %edi, %eax
movl %eax, %ecx
orl $0x800000, %ecx         # imm = 0x800000
testl $0x1800000, %eax        # imm = 0x1800000
cmovnel %eax, %ecx
movl %ecx, %edx
orl $0x2000000, %edx        # imm = 0x2000000
testl $0x6000000, %ecx        # imm = 0x6000000
cmovnel %ecx, %edx
movl %edx, %eax
orl $0x8000000, %eax        # imm = 0x8000000
testl $0x18000000, %edx       # imm = 0x18000000
cmovnel %edx, %eax
movl %eax, %ecx
andl $0x700000, %ecx         # imm = 0x700000
leal -0x1(%rcx), %edx
xorl %edx, %ecx
cmpl %edx, %ecx
jbe 0xa06e2
movl %eax, %ecx
andl $0x1800000, %ecx        # imm = 0x1800000
leal -0x1(%rcx), %edx
xorl %edx, %ecx
cmpl %edx, %ecx
jbe 0xa0701
movl %eax, %ecx
andl $0x6000000, %ecx        # imm = 0x6000000
leal -0x1(%rcx), %edx
xorl %edx, %ecx
cmpl %edx, %ecx
jbe 0xa0720
movl %eax, %ecx
andl $0x18000000, %ecx       # imm = 0x18000000
leal -0x1(%rcx), %edx
xorl %edx, %ecx
cmpl %edx, %ecx
jbe 0xa073f
leaq 0x5b5f9(%rip), %rcx     # 0xfbcd0
movq (%rcx), %rcx
movl %eax, 0x306c(%rcx)
popq %rbp
retq
leaq 0x31ccb(%rip), %rdi     # 0xd23b4
leaq 0x30928(%rip), %rsi     # 0xd1018
leaq 0x31ee1(%rip), %rcx     # 0xd25d8
movl $0x14f4, %edx           # imm = 0x14F4
callq 0xc140
leaq 0x31f05(%rip), %rdi     # 0xd260d
leaq 0x30909(%rip), %rsi     # 0xd1018
leaq 0x31ec2(%rip), %rcx     # 0xd25d8
movl $0x14f5, %edx           # imm = 0x14F5
callq 0xc140
leaq 0x31df5(%rip), %rdi     # 0xd251c
leaq 0x308ea(%rip), %rsi     # 0xd1018
leaq 0x31ea3(%rip), %rcx     # 0xd25d8
movl $0x14f6, %edx           # imm = 0x14F6
callq 0xc140
leaq 0x31cea(%rip), %rdi     # 0xd2430
leaq 0x308cb(%rip), %rsi     # 0xd1018
leaq 0x31e84(%rip), %rcx     # 0xd25d8
movl $0x14f7, %edx           # imm = 0x14F7
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNodeExV(char const*, int, char const*, __va_list_tag*)
bool ImGui::TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiContext& g = *GImGui;
    const char* label_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    return TreeNodeBehavior(window->GetID(str_id), flags, g.TempBuffer, label_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5b4de(%rip), %rax     # 0xfbcd0
movq (%rax), %r13
movq 0x1ae0(%r13), %r15
movb $0x1, 0x90(%r15)
cmpb $0x0, 0x93(%r15)
je 0xa081f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3378(%r13), %r12
movl $0xc01, %esi            # imm = 0xC01
movq %r12, %rdi
callq 0x41fc7
cltq
addq %rax, %r13
addq $0x3378, %r13           # imm = 0x3378
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4570a
movl %eax, %edi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa09cd
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNodeExV(void const*, int, char const*, __va_list_tag*)
bool ImGui::TreeNodeExV(const void* ptr_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    ImGuiContext& g = *GImGui;
    const char* label_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    return TreeNodeBehavior(window->GetID(ptr_id), flags, g.TempBuffer, label_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5b3ce(%rip), %rax     # 0xfbcd0
movq (%rax), %r13
movq 0x1ae0(%r13), %r15
movb $0x1, 0x90(%r15)
cmpb $0x0, 0x93(%r15)
je 0xa092f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebx
movq %rdi, %r14
leaq 0x3378(%r13), %r12
movl $0xc01, %esi            # imm = 0xC01
movq %r12, %rdi
callq 0x41fc7
cltq
addq %rax, %r13
addq $0x3378, %r13           # imm = 0x3378
movq %r15, %rdi
movq %r14, %rsi
callq 0x45a0c
movl %eax, %edi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa09cd
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreeNodeBehaviorIsOpen(unsigned int, int)
bool ImGui::TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags)
{
    if (flags & ImGuiTreeNodeFlags_Leaf)
        return true;

    // We only write to the tree storage if the user clicks (or explicitly use the SetNextItemOpen function)
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiStorage* storage = window->DC.StateStorage;

    bool is_open;
    if (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasOpen)
    {
        if (g.NextItemData.OpenCond & ImGuiCond_Always)
        {
            is_open = g.NextItemData.OpenVal;
            storage->SetInt(id, is_open);
        }
        else
        {
            // We treat ImGuiCond_Once and ImGuiCond_FirstUseEver the same because tree node state are not saved persistently.
            const int stored_value = storage->GetInt(id, -1);
            if (stored_value == -1)
            {
                is_open = g.NextItemData.OpenVal;
                storage->SetInt(id, is_open);
            }
            else
            {
                is_open = stored_value != 0;
            }
        }
    }
    else
    {
        is_open = storage->GetInt(id, (flags & ImGuiTreeNodeFlags_DefaultOpen) ? 1 : 0) != 0;
    }

    // When logging is enabled, we automatically expand tree nodes (but *NOT* collapsing headers.. seems like sensible behavior).
    // NB- If we are above max depth we still allow manually opened nodes to be logged.
    if (g.LogEnabled && !(flags & ImGuiTreeNodeFlags_NoAutoOpenOnLog) && (window->DC.TreeDepth - g.LogDepthRef) < g.LogDepthToExpand)
        is_open = true;

    return is_open;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %r14b
btl $0x8, %esi
jb 0xa1499
movl %esi, %ebx
movl %edi, %r15d
leaq 0x5a8dd(%rip), %rax     # 0xfbcd0
movq (%rax), %r13
movq 0x1ae0(%r13), %rax
movq %rax, -0x30(%rbp)
movq 0x1a8(%rax), %r12
testb $0x2, 0x1bf8(%r13)
jne 0xa1427
movl %ebx, %edx
shrl $0x5, %edx
andl $0x1, %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x428ac
jmp 0xa1446
testb $0x1, 0x1c04(%r13)
jne 0xa144e
movq %r12, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x428ac
cmpl $-0x1, %eax
je 0xa144e
testl %eax, %eax
setne %r14b
jmp 0xa1464
movb 0x1c08(%r13), %r14b
movzbl %r14b, %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x42b48
testb $0x10, %bl
jne 0xa1499
cmpb $0x0, 0x3138(%r13)
je 0xa1499
movq -0x30(%rbp), %rax
movl 0x18c(%rax), %eax
subl 0x3160(%r13), %eax
cmpl 0x3164(%r13), %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePushOverrideID(unsigned int)
void ImGui::TreePushOverrideID(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    Indent();
    window->DC.TreeDepth++;
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
leaq 0x5a811(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %r15
xorps %xmm0, %xmm0
callq 0x55c62
incl 0x18c(%r15)
movl 0xc8(%r15), %eax
cmpl 0xcc(%r15), %eax
jne 0xa14fd
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0xa1506
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0xa150b
movq 0xd0(%r15), %r14
jmp 0xa1561
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
callq 0x41c63
movq %rax, %r14
movq 0xd0(%r15), %rsi
testq %rsi, %rsi
je 0xa154c
movslq 0xc8(%r15), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0xc080
movq 0xd0(%r15), %rdi
callq 0x41d3c
movq %r14, 0xd0(%r15)
movl %r12d, 0xcc(%r15)
movl 0xc8(%r15), %eax
cltq
movl %ebx, (%r14,%rax,4)
incl 0xc8(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePush(char const*)
void ImGui::TreePush(const char* str_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    Indent();
    window->DC.TreeDepth++;
    PushID(str_id ? str_id : "#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5a748(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %r14
movb $0x1, 0x90(%r14)
xorps %xmm0, %xmm0
callq 0x55c62
incl 0x18c(%r14)
testq %rbx, %rbx
leaq 0x3124e(%rip), %rdi     # 0xd2801
cmovneq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x54b5f
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePush(void const*)
void ImGui::TreePush(const void* ptr_id)
{
    ImGuiWindow* window = GetCurrentWindow();
    Indent();
    window->DC.TreeDepth++;
    PushID(ptr_id ? ptr_id : (const void*)"#TreePush");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5a6ff(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %r14
movb $0x1, 0x90(%r14)
xorps %xmm0, %xmm0
callq 0x55c62
incl 0x18c(%r14)
testq %rbx, %rbx
leaq 0x31205(%rip), %rdi     # 0xd2801
cmovneq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x54d60
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TreePop()
void ImGui::TreePop()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    Unindent();

    window->DC.TreeDepth--;
    ImU32 tree_depth_mask = (1 << window->DC.TreeDepth);

    // Handle Left arrow to move to parent tree node (when ImGuiTreeNodeFlags_NavLeftJumpsBackHere is enabled)
    if (g.NavMoveDir == ImGuiDir_Left && g.NavWindow == window && NavMoveRequestButNoResultYet())
        if (g.NavIdIsAlive && (window->DC.TreeJumpToParentOnPopMask & tree_depth_mask))
        {
            SetNavID(window->IDStack.back(), g.NavLayer, 0);
            NavMoveRequestCancel();
        }
    window->DC.TreeJumpToParentOnPopMask &= tree_depth_mask - 1;

    IM_ASSERT(window->IDStack.Size > 1); // There should always be 1 element in the IDStack (pushed during window creation). If this triggers you called TreePop/PopID too much.
    PopID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5a6b6(%rip), %rax     # 0xfbcd0
movq (%rax), %r15
movq 0x1ae0(%r15), %rbx
xorps %xmm0, %xmm0
callq 0x55cb4
movl 0x18c(%rbx), %ecx
decl %ecx
movl $0x1, %r14d
shll %cl, %r14d
movl %ecx, 0x18c(%rbx)
cmpl $0x0, 0x1d10(%r15)
jne 0xa169c
cmpq %rbx, 0x1c90(%r15)
jne 0xa169c
callq 0x57d7d
testb %al, %al
je 0xa169c
cmpb $0x1, 0x1ce4(%r15)
jne 0xa169c
testl %r14d, 0x190(%rbx)
je 0xa169c
movslq 0xc8(%rbx), %rax
testq %rax, %rax
jle 0xa16dd
movq 0xd0(%rbx), %rcx
movl -0x4(%rcx,%rax,4), %edi
movl 0x1cdc(%r15), %esi
xorl %edx, %edx
callq 0x57bad
callq 0x57daa
decl %r14d
andl %r14d, 0x190(%rbx)
cmpl $0x1, 0xc8(%rbx)
jle 0xa16be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x55082
leaq 0x160c1(%rip), %rdi     # 0xb7786
leaq 0x2f94c(%rip), %rsi     # 0xd1018
leaq 0x31138(%rip), %rcx     # 0xd280b
movl $0x16f8, %edx           # imm = 0x16F8
callq 0xc140
leaq 0x2c2c6(%rip), %rdi     # 0xcd9aa
leaq 0x17fa0(%rip), %rsi     # 0xb968b
leaq 0x19306(%rip), %rcx     # 0xba9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SetNextItemOpen(bool, int)
void ImGui::SetNextItemOpen(bool is_open, ImGuiCond cond)
{
    ImGuiContext& g = *GImGui;
    if (g.CurrentWindow->SkipItems)
        return;
    g.NextItemData.Flags |= ImGuiNextItemDataFlags_HasOpen;
    g.NextItemData.OpenVal = is_open;
    g.NextItemData.OpenCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5a5a5(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rcx
cmpb $0x0, 0x93(%rcx)
jne 0xa1758
orb $0x2, 0x1bf8(%rax)
movb %dil, 0x1c08(%rax)
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x1c04(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ListBoxHeader(char const*, int, int)
bool ImGui::ListBoxHeader(const char* label, int items_count, int height_in_items)
{
    // Size default to hold ~7.25 items.
    // We add +25% worth of item height to allow the user to see at a glance if there are more items up/down, without looking at the scrollbar.
    // We don't add this extra bit if items_count <= height_in_items. It is slightly dodgy, because it means a dynamic list of items will make the widget resize occasionally when it crosses that size.
    // I am expecting that someone will come and complain about this behavior in a remote future, then we can advise on a better solution.
    if (height_in_items < 0)
        height_in_items = ImMin(items_count, 7);
    const ImGuiStyle& style = GetStyle();
    float height_in_items_f = (height_in_items < items_count) ? (height_in_items + 0.25f) : (height_in_items + 0.00f);

    // We include ItemSpacing.y so that a list sized for the exact number of items doesn't make a scrollbar appears. We could also enforce that by passing a flag to BeginChild().
    ImVec2 size;
    size.x = 0.0f;
    size.y = ImFloor(GetTextLineHeightWithSpacing() * height_in_items_f + style.FramePadding.y * 2.0f);
    return ListBoxHeader(label, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r15d
cmpl $0x7, %esi
movl $0x7, %r12d
cmovll %esi, %r12d
movq %rdi, %rbx
testl %edx, %edx
cmovnsl %edx, %r12d
callq 0x43b94
movq %rax, %r14
cvtsi2ss %r12d, %xmm0
cmpl %r15d, %r12d
jge 0xa1bd2
addss 0x1341a(%rip), %xmm0    # 0xb4fec
movss %xmm0, -0x24(%rbp)
leaq -0x2c(%rbp), %r15
movl $0x0, (%r15)
callq 0x562e2
movss 0x3c(%r14), %xmm1
addss %xmm1, %xmm1
mulss -0x24(%rbp), %xmm0
addss %xmm1, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0x4(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa1963
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ListBoxFooter()
void ImGui::ListBoxFooter()
{
    ImGuiWindow * window = GetCurrentWindow();
    IM_ASSERT((window->Flags & ImGuiWindowFlags_ChildWindow) && "Mismatched ListBoxHeader/ListBoxFooter calls. Did you test the return value of ListBoxHeader()?");
    ImGuiWindow* parent_window = window->ParentWindow;
    const ImRect bb = parent_window->DC.LastItemRect;
    const ImGuiStyle& style = GetStyle();

    EndChildFrame();

    // Redeclare item size so that it includes the label (we have stored the full size in LastItemRect)
    // We call SameLine() to restore DC.CurrentLine* data
    SameLine();
    parent_window->DC.CursorPos = bb.Min;
    ItemSize(bb, style.FramePadding.y);
    EndGroup();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x5a09d(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movb $0x1, 0x90(%rax)
testb $0x1, 0xf(%rax)
je 0xa1ca5
movq 0x388(%rax), %r15
movups 0x12c(%r15), %xmm0
leaq -0x30(%rbp), %rbx
movaps %xmm0, (%rbx)
callq 0x43b94
movq %rax, %r14
callq 0x52905
movss 0x1335b(%rip), %xmm1    # 0xb4fd0
xorps %xmm0, %xmm0
callq 0x5591d
movq (%rbx), %rax
movq %rax, 0xd8(%r15)
movss 0x3c(%r14), %xmm0
movq %rbx, %rdi
callq 0x559be
callq 0x55617
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30b75(%rip), %rdi     # 0xd2821
leaq 0x2f365(%rip), %rsi     # 0xd1018
leaq 0x30bfb(%rip), %rcx     # 0xd28b5
movl $0x1829, %edx           # imm = 0x1829
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ListBox(char const*, int*, bool (*)(void*, int, char const**), void*, int, int)
bool ImGui::ListBox(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items)
{
    if (!ListBoxHeader(label, items_count, height_in_items))
        return false;

    // Assume all items have even height (= 1 line of text). If you need items of different or variable sizes you can create a custom version of ListBox() in your code without using the clipper.
    ImGuiContext& g = *GImGui;
    bool value_changed = false;
    ImGuiListClipper clipper;
    clipper.Begin(items_count, GetTextLineHeightWithSpacing()); // We know exactly our line height here so we pass it as a minor optimization, but generally you don't need to.
    while (clipper.Step())
        for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
        {
            const bool item_selected = (i == *current_item);
            const char* item_text;
            if (!items_getter(data, i, &item_text))
                item_text = "*Unknown item*";

            PushID(i);
            if (Selectable(item_text, item_selected))
            {
                *current_item = i;
                value_changed = true;
            }
            if (item_selected)
                SetItemDefaultFocus();
            PopID();
        }
    ListBoxFooter();
    if (value_changed)
        MarkItemEdited(g.CurrentWindow->DC.LastItemId);

    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %r8d, %esi
movl %r9d, %edx
callq 0xa1b90
testb %al, %al
je 0xa1dbb
leaq 0x59fbb(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x54(%rbp), %rdi
callq 0x4374c
callq 0x562e2
leaq -0x54(%rbp), %rdi
movl %r12d, %esi
callq 0x4378e
movl $0x0, -0x2c(%rbp)
leaq -0x54(%rbp), %rdi
callq 0x43932
testb %al, %al
je 0xa1dbf
movl -0x54(%rbp), %r13d
cmpl -0x50(%rbp), %r13d
jge 0xa1d3d
movl (%r15), %r12d
movq %rbx, %rdi
movl %r13d, %esi
leaq -0x38(%rbp), %rdx
callq *%r14
testb %al, %al
jne 0xa1d73
leaq 0x2f78f(%rip), %rax     # 0xd14fe
movq %rax, -0x38(%rbp)
movl %r13d, %edi
callq 0x54e5e
xorl %esi, %esi
cmpl %r12d, %r13d
sete %sil
movq -0x38(%rbp), %rdi
movq $0x0, -0x68(%rbp)
xorl %edx, %edx
leaq -0x68(%rbp), %rcx
callq 0x94650
testb %al, %al
je 0xa1da7
movl %r13d, (%r15)
movb $0x1, %al
movl %eax, -0x2c(%rbp)
cmpl %r12d, %r13d
jne 0xa1db1
callq 0x549cb
callq 0x55082
incl %r13d
jmp 0xa1d4e
xorl %ebx, %ebx
jmp 0xa1deb
callq 0xa1c1f
movl -0x2c(%rbp), %ebx
testb $0x1, %bl
je 0xa1de2
movq -0x60(%rbp), %rax
movq 0x1ae0(%rax), %rax
movl 0x124(%rax), %edi
callq 0x4618e
leaq -0x54(%rbp), %rdi
callq 0x43764
andb $0x1, %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa1e05
jmp 0xa1e05
jmp 0xa1e05
movq %rax, %rbx
leaq -0x54(%rbp), %rdi
callq 0x43764
movq %rbx, %rdi
callq 0xc560
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Value(char const*, float, char const*)
void ImGui::Value(const char* prefix, float v, const char* float_format)
{
    if (float_format)
    {
        char fmt[64];
        ImFormatString(fmt, IM_ARRAYSIZE(fmt), "%%s: %s", float_format);
        Text(fmt, prefix, v);
    }
    else
    {
        Text("%s: %.3f", prefix, v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa2892
movq %rsi, %rcx
leaq 0x30155(%rip), %rdx     # 0xd29b1
leaq -0x60(%rbp), %r14
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
movss %xmm0, -0x14(%rbp)
callq 0x41f22
xorps %xmm0, %xmm0
cvtss2sd -0x14(%rbp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
movb $0x1, %al
callq 0x90323
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cvtss2sd %xmm0, %xmm0
leaq 0x3011c(%rip), %rdi     # 0xd29b9
movq %rbx, %rsi
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x90323
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGuiMenuColumns::Update(int, float, bool)
void ImGuiMenuColumns::Update(int count, float spacing, bool clear)
{
    IM_ASSERT(count == IM_ARRAYSIZE(Pos));
    IM_UNUSED(count);
    Width = NextWidth = 0.0f;
    Spacing = spacing;
    if (clear)
        memset(NextWidths, 0, sizeof(NextWidths));
    for (int i = 0; i < IM_ARRAYSIZE(Pos); i++)
    {
        if (i > 0 && NextWidths[i] > 0.0f)
            Width += Spacing;
        Pos[i] = IM_FLOOR(Width);
        Width += NextWidths[i];
        NextWidths[i] = 0.0f;
    }
}

// Assembly:
cmpl $0x3, %esi
jne 0xa2924
movl $0x0, 0x8(%rdi)
movss %xmm0, (%rdi)
testb %dl, %dl
je 0xa28d3
movl $0x0, 0x20(%rdi)
movq $0x0, 0x18(%rdi)
xorps %xmm1, %xmm1
xorl %eax, %eax
xorps %xmm2, %xmm2
testq %rax, %rax
je 0xa28f1
movss 0x18(%rdi,%rax,4), %xmm3
ucomiss %xmm1, %xmm3
jbe 0xa28f6
addss %xmm0, %xmm2
jmp 0xa28f6
movss 0x18(%rdi), %xmm3
movaps %xmm2, %xmm4
cvttps2dq %xmm2, %xmm2
cvtdq2ps %xmm2, %xmm2
movss %xmm2, 0xc(%rdi,%rax,4)
movaps %xmm3, %xmm2
addss %xmm4, %xmm2
movl $0x0, 0x18(%rdi,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0xa28db
movss %xmm2, 0x4(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x30093(%rip), %rdi     # 0xd29c2
leaq 0x2e6e2(%rip), %rsi     # 0xd1018
leaq 0x300b4(%rip), %rcx     # 0xd29f1
movl $0x193d, %edx           # imm = 0x193D
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGuiMenuColumns::DeclColumns(float, float, float)
float ImGuiMenuColumns::DeclColumns(float w0, float w1, float w2) // not using va_arg because they promote float to double
{
    NextWidth = 0.0f;
    NextWidths[0] = ImMax(NextWidths[0], w0);
    NextWidths[1] = ImMax(NextWidths[1], w1);
    NextWidths[2] = ImMax(NextWidths[2], w2);
    for (int i = 0; i < IM_ARRAYSIZE(Pos); i++)
        NextWidth += NextWidths[i] + ((i > 0 && NextWidths[i] > 0.0f) ? Spacing : 0.0f);
    return ImMax(Width, NextWidth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm3
movss 0x18(%rdi), %xmm4
movaps %xmm0, %xmm5
cmpless %xmm4, %xmm5
andps %xmm5, %xmm4
andnps %xmm0, %xmm5
orps %xmm4, %xmm5
movss %xmm5, 0x18(%rdi)
movss 0x1c(%rdi), %xmm0
movaps %xmm1, %xmm4
cmpless %xmm0, %xmm4
andps %xmm4, %xmm0
andnps %xmm1, %xmm4
orps %xmm0, %xmm4
movss %xmm4, 0x1c(%rdi)
movss 0x20(%rdi), %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0x20(%rdi)
xorps %xmm1, %xmm1
xorl %eax, %eax
movss 0x18(%rdi,%rax,4), %xmm0
xorps %xmm2, %xmm2
testq %rax, %rax
je 0xa29bc
cmpltss %xmm0, %xmm2
andps %xmm3, %xmm2
addss %xmm2, %xmm0
addss %xmm0, %xmm1
incq %rax
cmpq $0x3, %rax
jne 0xa29a6
movss %xmm1, 0x8(%rdi)
movss 0x4(%rdi), %xmm2
movaps %xmm1, %xmm0
cmpless %xmm2, %xmm0
andps %xmm0, %xmm2
andnps %xmm1, %xmm0
orps %xmm2, %xmm0
popq %rbp
retq