LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogToFile(int, char const*)
void ImGui::LogToFile(int auto_open_depth, const char* filename)
{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;

    // FIXME: We could probably open the file in text mode "at", however note that clipboard/buffer logging will still
    // be subject to outputting OS-incompatible carriage return if within strings the user doesn't use IM_NEWLINE.
    // By opening the file in binary mode "ab" we have consistent output everywhere.
    if (!filename)
        filename = g.IO.LogFilename;
    if (!filename || !filename[0])
        return;
    ImFileHandle f = ImFileOpen(filename, "ab");
    if (!f)
    {
        IM_ASSERT(0);
        return;
    }

    LogBegin(ImGuiLogType_File, auto_open_depth);
    g.LogFile = f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xa2d3e(%rip), %r15     # 0xfbcd0
cmpb $0x0, 0x3138(%r15)
jne 0x58fde
movl %edi, %ebx
testq %rsi, %rsi
jne 0x58fac
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x58fde
cmpb $0x0, (%rsi)
je 0x58fde
leaq 0x5d742(%rip), %rax     # 0xb66fa
movq %rsi, %rdi
movq %rax, %rsi
callq 0xc9a0
testq %rax, %rax
je 0x58fe9
movq %rax, %r14
movl $0x2, %edi
movl %ebx, %esi
callq 0x58e7c
movq %r14, 0x3140(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f0fc(%rip), %rdi     # 0xb80ec
leaq 0x5d16e(%rip), %rsi     # 0xb6165
leaq 0x5f7ec(%rip), %rcx     # 0xb87ea
movl $0x26c9, %edx           # imm = 0x26C9
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CreateNewWindowSettings(char const*)
ImGuiWindowSettings* ImGui::CreateNewWindowSettings(const char* name)
{
    ImGuiContext& g = *GImGui;

#if !IMGUI_DEBUG_INI_SETTINGS
    // Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
    // Preserve the full string when IMGUI_DEBUG_INI_SETTINGS is set to make .ini inspection easier.
    if (const char* p = strstr(name, "###"))
        name = p;
#endif
    const size_t name_len = strlen(name);

    // Allocate chunk
    const size_t chunk_size = sizeof(ImGuiWindowSettings) + name_len + 1;
    ImGuiWindowSettings* settings = g.SettingsWindows.alloc_chunk(chunk_size);
    IM_PLACEMENT_NEW(settings) ImGuiWindowSettings();
    settings->ID = ImHashStr(name, name_len);
    memcpy(settings->GetName(), name, name_len + 1);   // Store with zero terminator

    return settings;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3108, %r14d          # imm = 0x3108
addq 0xa29db(%rip), %r14     # 0xfbcd0
leaq 0x5f570(%rip), %rsi     # 0xb886c
callq 0xc400
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0xc350
movq %rax, %r15
leaq 0x11(%rax), %rsi
movq %r14, %rdi
callq 0x5e398
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x42033
movl %eax, (%r14)
leaq 0x10(%r14), %rdi
incq %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0xc080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindWindowSettings(unsigned int)
ImGuiWindowSettings* ImGui::FindWindowSettings(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
        if (settings->ID == id)
            return settings;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa296a(%rip), %r14     # 0xfbcd0
movq 0x3110(%r14), %rax
testq %rax, %rax
je 0x59393
movl %edi, %ebx
addq $0x3108, %r14           # imm = 0x3108
addq $0x4, %rax
cmpl %ebx, (%rax)
je 0x59395
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e478
testq %rax, %rax
jne 0x5937f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindSettingsHandler(char const*)
ImGuiSettingsHandler* ImGui::FindSettingsHandler(const char* type_name)
{
    ImGuiContext& g = *GImGui;
    const ImGuiID type_hash = ImHashStr(type_name);
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].TypeHash == type_hash)
            return &g.SettingsHandlers[handler_n];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xa28f5(%rip), %r14     # 0xfbcd0
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x42033
movslq 0x30f8(%r14), %rcx
testq %rcx, %rcx
jle 0x59409
movq 0x3100(%r14), %rbx
cmpl %eax, 0x8(%rbx)
je 0x59409
addq $0x48, %rbx
decq %rcx
jne 0x593f9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ClearIniSettings()
void ImGui::ClearIniSettings()
{
    ImGuiContext& g = *GImGui;
    g.SettingsIniData.clear();
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
        if (g.SettingsHandlers[handler_n].ClearAllFn)
            g.SettingsHandlers[handler_n].ClearAllFn(&g, &g.SettingsHandlers[handler_n]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xa28ae(%rip), %rbx     # 0xfbcd0
leaq 0x30e8(%rbx), %rdi
callq 0x5e1ae
movl 0x30f8(%rbx), %eax
testl %eax, %eax
jle 0x5946c
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x3100(%rbx), %rsi
movq 0x10(%rsi,%r14), %rcx
testq %rcx, %rcx
je 0x5945d
addq %r14, %rsi
movq %rbx, %rdi
callq *%rcx
movl 0x30f8(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x48, %r14
cmpq %rcx, %r15
jl 0x5943e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LoadIniSettingsFromDisk(char const*)
void ImGui::LoadIniSettingsFromDisk(const char* ini_filename)
{
    size_t file_data_size = 0;
    char* file_data = (char*)ImFileLoadToMemory(ini_filename, "rb", &file_data_size);
    if (!file_data)
        return;
    LoadIniSettingsFromMemory(file_data, (size_t)file_data_size);
    IM_FREE(file_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rdx
movq $0x0, (%rdx)
leaq 0x5f3e1(%rip), %rsi     # 0xb8870
xorl %ecx, %ecx
callq 0x42188
testq %rax, %rax
je 0x594cc
movq %rax, %rbx
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x594d3
movq 0xa281f(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x594bc
decl 0x3b4(%rax)
movq 0xa281d(%rip), %rsi     # 0xfbce0
movq %rbx, %rdi
callq *0x9e04c(%rip)          # 0xf7518
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SaveIniSettingsToMemory(unsigned long*)
const char* ImGui::SaveIniSettingsToMemory(size_t* out_size)
{
    ImGuiContext& g = *GImGui;
    g.SettingsDirtyTimer = 0.0f;
    g.SettingsIniData.Buf.resize(0);
    g.SettingsIniData.Buf.push_back(0);
    for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
    {
        ImGuiSettingsHandler* handler = &g.SettingsHandlers[handler_n];
        handler->WriteAllFn(&g, handler, &g.SettingsIniData);
    }
    if (out_size)
        *out_size = (size_t)g.SettingsIniData.size();
    return g.SettingsIniData.c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xa24d8(%rip), %rbx     # 0xfbcd0
movl $0x0, 0x30e4(%rbx)
leaq 0x30e8(%rbx), %r15
cmpl $0x0, 0x30ec(%rbx)
js 0x59829
movl $0x0, (%r15)
je 0x59899
movq 0x30f0(%rbx), %r12
xorl %eax, %eax
jmp 0x5991e
incl 0x3b4(%rbx)
movq 0xa24aa(%rip), %rsi     # 0xfbce0
xorl %edi, %edi
callq *0x9dcd2(%rip)          # 0xf7510
movq %rax, %r12
movq 0x30f0(%rbx), %rsi
testq %rsi, %rsi
je 0x59887
movslq 0x30e8(%rbx), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x30f0(%rbx), %rdi
testq %rdi, %rdi
je 0x5987a
movq 0xa2461(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x5987a
decl 0x3b4(%rax)
movq 0xa245f(%rip), %rsi     # 0xfbce0
callq *0x9dc91(%rip)          # 0xf7518
movq %r12, 0x30f0(%rbx)
movq $0x0, 0x30e8(%rbx)
movq 0xa2430(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x598ab
incl 0x3b4(%rax)
movq 0xa242e(%rip), %rsi     # 0xfbce0
movl $0x8, %edi
callq *0x9dc53(%rip)          # 0xf7510
movq %rax, %r12
movq 0x30f0(%rbx), %rsi
testq %rsi, %rsi
je 0x59906
movslq 0x30e8(%rbx), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x30f0(%rbx), %rdi
testq %rdi, %rdi
je 0x598f9
movq 0xa23e2(%rip), %rax     # 0xfbcd0
testq %rax, %rax
je 0x598f9
decl 0x3b4(%rax)
movq 0xa23e0(%rip), %rsi     # 0xfbce0
callq *0x9dc12(%rip)          # 0xf7518
movq %r12, 0x30f0(%rbx)
movl $0x8, 0x30ec(%rbx)
movslq 0x30e8(%rbx), %rax
movb $0x0, (%r12,%rax)
incl 0x30e8(%rbx)
cmpl $0x0, 0x30f8(%rbx)
jle 0x59961
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x3100(%rbx), %rax
leaq (%rax,%r12), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x38(%rax,%r12)
incq %r13
movslq 0x30f8(%rbx), %rax
addq $0x48, %r12
cmpq %rax, %r13
jl 0x59938
testq %r14, %r14
je 0x59976
movl (%r15), %eax
xorl %ecx, %ecx
subl $0x1, %eax
cmovbl %ecx, %eax
cltq
movq %rax, (%r14)
movq 0x30f0(%rbx), %rcx
testq %rcx, %rcx
leaq 0xa2351(%rip), %rax     # 0xfbcd8
cmovneq %rcx, %rax
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.cpp
// Function: ImGui::ShowMetricsWindow(bool*)::Funcs::GetWindowRect(ImGuiWindow*, int)
static ImRect GetWindowRect(ImGuiWindow* window, int rect_type)
        {
            if (rect_type == WRT_OuterRect)                 { return window->Rect(); }
            else if (rect_type == WRT_OuterRectClipped)     { return window->OuterRectClipped; }
            else if (rect_type == WRT_InnerRect)            { return window->InnerRect; }
            else if (rect_type == WRT_InnerClipRect)        { return window->InnerClipRect; }
            else if (rect_type == WRT_WorkRect)             { return window->WorkRect; }
            else if (rect_type == WRT_Content)       { ImVec2 min = window->InnerRect.Min - window->Scroll + window->WindowPadding; return ImRect(min, min + window->ContentSize); }
            else if (rect_type == WRT_ContentIdeal)         { ImVec2 min = window->InnerRect.Min - window->Scroll + window->WindowPadding; return ImRect(min, min + window->ContentSizeIdeal); }
            else if (rect_type == WRT_ContentRegionRect)    { return window->ContentRegionRect; }
            IM_ASSERT(0);
            return ImRect();
        }

// Assembly:
cmpl $0x7, %esi
ja 0x5b0b7
movl %esi, %eax
leaq 0x5a9ae(%rip), %rcx     # 0xb597c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss 0x10(%rdi), %xmm1
movss 0x14(%rdi), %xmm0
addss 0x18(%rdi), %xmm1
addss 0x1c(%rdi), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movsd 0x10(%rdi), %xmm0
retq
movsd 0x238(%rdi), %xmm0
movsd 0x240(%rdi), %xmm1
retq
movsd 0x218(%rdi), %xmm0
movsd 0x220(%rdi), %xmm1
retq
movsd 0x228(%rdi), %xmm0
movsd 0x230(%rdi), %xmm1
retq
movsd 0x268(%rdi), %xmm0
movsd 0x270(%rdi), %xmm1
retq
movsd 0x208(%rdi), %xmm0
movsd 0x210(%rdi), %xmm1
retq
movss 0x218(%rdi), %xmm1
movss 0x21c(%rdi), %xmm2
subss 0x5c(%rdi), %xmm1
subss 0x60(%rdi), %xmm2
addss 0x40(%rdi), %xmm1
addss 0x44(%rdi), %xmm2
movaps %xmm1, %xmm0
addss 0x28(%rdi), %xmm1
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
addss 0x2c(%rdi), %xmm2
jmp 0x5b0b3
movss 0x218(%rdi), %xmm1
movss 0x21c(%rdi), %xmm2
subss 0x5c(%rdi), %xmm1
subss 0x60(%rdi), %xmm2
addss 0x40(%rdi), %xmm1
addss 0x44(%rdi), %xmm2
movaps %xmm1, %xmm0
addss 0x30(%rdi), %xmm1
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
addss 0x34(%rdi), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5d02a(%rip), %rdi     # 0xb80ec
leaq 0x5b09c(%rip), %rsi     # 0xb6165
leaq 0x5f533(%rip), %rcx     # 0xba603
movl $0x2963, %edx           # imm = 0x2963
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>*, char const*)
void ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label)
{
    if (!TreeNode(label, "%s (%d)", label, windows->Size))
        return;
    Text("(In front-to-back order:)");
    for (int i = windows->Size - 1; i >= 0; i--) // Iterate front to back
    {
        PushID((*windows)[i]);
        DebugNodeWindow((*windows)[i], "Window");
        PopID();
    }
    TreePop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
leaq 0x610a2(%rip), %rsi     # 0xbc40b
movq %rdx, %rdi
xorl %eax, %eax
callq 0xa075e
testb %al, %al
je 0x5b3e4
leaq 0x5e249(%rip), %rdi     # 0xb95c7
xorl %eax, %eax
callq 0x90323
movslq (%rbx), %r15
testq %r15, %r15
jle 0x5b3d5
leaq 0x5f02c(%rip), %r14     # 0xba3c0
movslq (%rbx), %rax
cmpq %rax, %r15
jg 0x5b3ef
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdi
callq 0x54d60
movslq (%rbx), %rax
cmpq %rax, %r15
jg 0x5b3ef
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdi
decq %r15
movq %r14, %rsi
callq 0x5c27b
callq 0x55082
leaq 0x1(%r15), %rax
cmpq $0x1, %rax
ja 0x5b394
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa1609
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e282(%rip), %rdi     # 0xb9678
leaq 0x5e28e(%rip), %rsi     # 0xb968b
leaq 0x5f663(%rip), %rcx     # 0xbaa67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::DebugNodeColumns(ImGuiOldColumns*)
void ImGui::DebugNodeColumns(ImGuiOldColumns* columns)
{
    if (!TreeNode((void*)(uintptr_t)columns->ID, "Columns Id: 0x%08X, Count: %d, Flags: 0x%04X", columns->ID, columns->Count, columns->Flags))
        return;
    BulletText("Width: %.1f (MinX: %.1f, MaxX: %.1f)", columns->OffMaxX - columns->OffMinX, columns->OffMinX, columns->OffMaxX);
    for (int column_n = 0; column_n < columns->Columns.Size; column_n++)
        BulletText("Column %02d: OffsetNorm %.3f (= %.1f px)", column_n, columns->Columns[column_n].OffsetNorm, GetColumnOffsetFromNorm(columns, columns->Columns[column_n].OffsetNorm));
    TreePop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %r8d
movl 0x10(%rbx), %ecx
leaq 0x5d1d6(%rip), %rsi     # 0xb9024
movl %edi, %edx
xorl %eax, %eax
callq 0xa086e
testb %al, %al
je 0x5bef2
movss 0x14(%rbx), %xmm1
movss 0x18(%rbx), %xmm0
cvtss2sd %xmm0, %xmm2
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0x5d1d1(%rip), %rdi     # 0xb9051
movb $0x3, %al
callq 0x90944
cmpl $0x0, 0x60(%rbx)
jle 0x5bee1
xorl %r12d, %r12d
leaq 0x5d1df(%rip), %r14     # 0xb9076
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movss (%rax,%r12), %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movq %rbx, %rdi
callq 0x8e522
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movq %r14, %rdi
movl %r15d, %esi
movsd -0x28(%rbp), %xmm0
movb $0x2, %al
callq 0x90944
incq %r15
movslq 0x60(%rbx), %rax
addq $0x1c, %r12
cmpq %rax, %r15
jl 0x5be9a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa1609
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.cpp
// Function: ImGui::DebugNodeStorage(ImGuiStorage*, char const*)
void ImGui::DebugNodeStorage(ImGuiStorage* storage, const char* label)
{
    if (!TreeNode(label, "%s: %d entries, %d bytes", label, storage->Data.Size, storage->Data.size_in_bytes()))
        return;
    for (int n = 0; n < storage->Data.Size; n++)
    {
        const ImGuiStorage::ImGuiStoragePair& p = storage->Data[n];
        BulletText("Key 0x%08X Value { i: %d }", p.key, p.val_i); // Important: we currently don't store a type, real value may not be integer.
    }
    TreePop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
movl %ecx, %r8d
shll $0x4, %r8d
leaq 0x5d072(%rip), %rsi     # 0xb928e
movq %rdx, %rdi
xorl %eax, %eax
callq 0xa075e
testb %al, %al
je 0x5c272
cmpl $0x0, (%rbx)
jle 0x5c265
movl $0x8, %r15d
leaq 0x5d06b(%rip), %r14     # 0xb92a7
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movl -0x8(%rax,%r15), %esi
movl (%rax,%r15), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x90944
incq %r12
movslq (%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x5c23f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa1609
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.cpp
// Function: ChildWindowComparer(void const*, void const*)
static int IMGUI_CDECL ChildWindowComparer(const void* lhs, const void* rhs)
{
    const ImGuiWindow* const a = *(const ImGuiWindow* const *)lhs;
    const ImGuiWindow* const b = *(const ImGuiWindow* const *)rhs;
    if (int d = (a->Flags & ImGuiWindowFlags_Popup) - (b->Flags & ImGuiWindowFlags_Popup))
        return d;
    if (int d = (a->Flags & ImGuiWindowFlags_Tooltip) - (b->Flags & ImGuiWindowFlags_Tooltip))
        return d;
    return (a->BeginOrderWithinParent - b->BeginOrderWithinParent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq (%rsi), %rdx
movl 0xc(%rcx), %esi
movl $0x4000000, %r8d        # imm = 0x4000000
movl %esi, %eax
andl %r8d, %eax
movl 0xc(%rdx), %edi
andl %edi, %r8d
subl %r8d, %eax
jne 0x5c75a
movl $0x2000000, %eax        # imm = 0x2000000
andl %eax, %esi
andl %eax, %edi
subl %edi, %esi
movl %esi, %eax
jne 0x5c75a
movswl 0x9c(%rcx), %eax
movswl 0x9c(%rdx), %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: AddWindowToDrawData(ImVector<ImDrawList*>*, ImGuiWindow*)
static void AddWindowToDrawData(ImVector<ImDrawList*>* out_render_list, ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    g.IO.MetricsRenderWindows++;
    AddDrawListToDrawData(out_render_list, window->DrawList);
    for (int i = 0; i < window->DC.ChildWindows.Size; i++)
    {
        ImGuiWindow* child = window->DC.ChildWindows[i];
        if (IsWindowActiveAndVisible(child)) // clipped children may have been marked not active
            AddWindowToDrawData(out_render_list, child);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x9f55d(%rip), %rax     # 0xfbcd0
incl 0x3ac(%rax)
movq 0x2b8(%rsi), %rsi
callq 0x512a5
movl 0x198(%rbx), %eax
testl %eax, %eax
jle 0x5c7c8
xorl %r15d, %r15d
movq 0x1a0(%rbx), %rcx
movq (%rcx,%r15,8), %rsi
cmpb $0x1, 0x8e(%rsi)
jne 0x5c7bd
cmpb $0x0, 0x95(%rsi)
jne 0x5c7bd
movq %r14, %rdi
callq 0x5c75c
movl 0x198(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x5c792
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: CalcResizePosSizeFromAnyCorner(ImGuiWindow*, ImVec2 const&, ImVec2 const&, ImVec2*, ImVec2*)
static void CalcResizePosSizeFromAnyCorner(ImGuiWindow* window, const ImVec2& corner_target, const ImVec2& corner_norm, ImVec2* out_pos, ImVec2* out_size)
{
    ImVec2 pos_min = ImLerp(corner_target, window->Pos, corner_norm);                // Expected window upper-left
    ImVec2 pos_max = ImLerp(window->Pos + window->Size, corner_target, corner_norm); // Expected window lower-right
    ImVec2 size_expected = pos_max - pos_min;
    ImVec2 size_constrained = CalcWindowSizeAfterConstraint(window, size_expected);
    *out_pos = pos_min;
    if (corner_norm.x == 0.0f)
        out_pos->x -= (size_constrained.x - size_expected.x);
    if (corner_norm.y == 0.0f)
        out_pos->y -= (size_constrained.y - size_expected.y);
    *out_size = size_constrained;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movss 0x10(%rdi), %xmm6
movss 0x14(%rdi), %xmm4
movss (%rsi), %xmm2
movss 0x4(%rsi), %xmm3
movaps %xmm6, %xmm7
subss %xmm0, %xmm7
mulss %xmm2, %xmm7
addss %xmm0, %xmm7
movaps %xmm4, %xmm5
subss %xmm1, %xmm5
mulss %xmm3, %xmm5
addss %xmm1, %xmm5
movaps %xmm7, %xmm8
unpcklps %xmm5, %xmm8            # xmm8 = xmm8[0],xmm5[0],xmm8[1],xmm5[1]
movaps %xmm8, -0x70(%rbp)
addss 0x18(%rdi), %xmm6
addss 0x1c(%rdi), %xmm4
subss %xmm6, %xmm0
mulss %xmm2, %xmm0
addss %xmm6, %xmm0
subss %xmm4, %xmm1
mulss %xmm3, %xmm1
addss %xmm4, %xmm1
movaps %xmm7, -0x30(%rbp)
subss %xmm7, %xmm0
movaps %xmm5, -0x50(%rbp)
subss %xmm5, %xmm1
movaps %xmm0, -0x40(%rbp)
movaps %xmm1, -0x60(%rbp)
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
callq 0x52ced
movaps -0x70(%rbp), %xmm1
movlps %xmm1, (%r14)
movss (%r15), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jne 0x5c895
jp 0x5c895
movaps %xmm0, %xmm2
subss -0x40(%rbp), %xmm2
movaps -0x30(%rbp), %xmm3
subss %xmm2, %xmm3
movss %xmm3, (%r14)
movss 0x4(%r15), %xmm2
ucomiss %xmm1, %xmm2
jne 0x5c8bc
jp 0x5c8bc
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
subss -0x60(%rbp), %xmm1
movaps -0x50(%rbp), %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x4(%r14)
movlps %xmm0, (%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: GetResizeBorderRect(ImGuiWindow*, int, float, float)
static ImRect GetResizeBorderRect(ImGuiWindow* window, int border_n, float perp_padding, float thickness)
{
    ImRect rect = window->Rect();
    if (thickness == 0.0f) rect.Max -= ImVec2(1, 1);
    if (border_n == 0) { return ImRect(rect.Min.x + perp_padding, rect.Min.y - thickness,    rect.Max.x - perp_padding, rect.Min.y + thickness);    } // Top
    if (border_n == 1) { return ImRect(rect.Max.x - thickness,    rect.Min.y + perp_padding, rect.Max.x + thickness,    rect.Max.y - perp_padding); } // Right
    if (border_n == 2) { return ImRect(rect.Min.x + perp_padding, rect.Max.y - thickness,    rect.Max.x - perp_padding, rect.Max.y + thickness);    } // Bottom
    if (border_n == 3) { return ImRect(rect.Min.x - thickness,    rect.Min.y + perp_padding, rect.Min.x + thickness,    rect.Max.y - perp_padding); } // Left
    IM_ASSERT(0);
    return ImRect();
}

// Assembly:
movaps %xmm1, %xmm3
movaps %xmm0, %xmm2
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm4
movss 0x18(%rdi), %xmm5
addss %xmm0, %xmm5
movss 0x1c(%rdi), %xmm6
addss %xmm4, %xmm6
movaps %xmm5, %xmm1
unpcklps %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0],xmm1[1],xmm6[1]
xorps %xmm7, %xmm7
ucomiss %xmm7, %xmm3
jne 0x5c912
jp 0x5c912
movss 0x586cc(%rip), %xmm1    # 0xb4fd0
addss %xmm1, %xmm5
addss %xmm1, %xmm6
unpcklps %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1]
movaps %xmm5, %xmm1
cmpl $0x3, %esi
ja 0x5c994
movl %esi, %eax
leaq 0x590b0(%rip), %rcx     # 0xb59d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addss %xmm2, %xmm0
jmp 0x5c93a
addss %xmm2, %xmm0
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
movaps %xmm4, %xmm5
subss %xmm3, %xmm5
subss %xmm2, %xmm1
addss %xmm3, %xmm4
jmp 0x5c98d
movaps %xmm0, %xmm6
subss %xmm3, %xmm0
addss %xmm2, %xmm4
addss %xmm3, %xmm6
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm4, %xmm5
subss %xmm2, %xmm1
movaps %xmm1, %xmm4
movaps %xmm6, %xmm1
jmp 0x5c98d
movaps %xmm1, %xmm0
subss %xmm3, %xmm0
addss %xmm2, %xmm4
addss %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm4, %xmm5
subss %xmm2, %xmm1
movaps %xmm1, %xmm4
movaps %xmm3, %xmm1
unpcklps %xmm4, %xmm1            # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
unpcklps %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1]
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5b74d(%rip), %rdi     # 0xb80ec
leaq 0x597bf(%rip), %rsi     # 0xb6165
leaq 0x5d031(%rip), %rcx     # 0xb99de
movl $0x1438, %edx           # imm = 0x1438
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: NavRestoreLayer(ImGuiNavLayer)
static void NavRestoreLayer(ImGuiNavLayer layer)
{
    ImGuiContext& g = *GImGui;
    g.NavLayer = layer;
    if (layer == 0)
        g.NavWindow = ImGui::NavRestoreLastChildNavWindow(g.NavWindow);
    ImGuiWindow* window = g.NavWindow;
    if (layer == 0 && window->NavLastIds[0] != 0)
        ImGui::SetNavIDWithRectRel(window->NavLastIds[0], layer, 0, window->NavRectRel[0]);
    else
        ImGui::NavInitWindow(window, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
movq 0x9ee82(%rip), %rcx     # 0xfbcd0
movl %edi, 0x1cdc(%rcx)
movq 0x1c90(%rcx), %rdi
testl %eax, %eax
je 0x5ce6a
movl $0x1, %esi
popq %rbp
jmp 0x51f7e
movq 0x3a8(%rdi), %rax
testq %rax, %rax
je 0x5ce7f
cmpb $0x0, 0x8f(%rax)
jne 0x5ce82
movq %rdi, %rax
movq %rax, 0x1c90(%rcx)
movl 0x3b0(%rax), %edx
testl %edx, %edx
je 0x5cebb
movl %edx, 0x1c98(%rcx)
movl $0x0, 0x1c9c(%rcx)
movl %edx, 0x3b0(%rax)
movw $0x1, 0x1ce5(%rcx)
movb $0x1, 0x1ce7(%rcx)
popq %rbp
retq
movq %rax, %rdi
jmp 0x5ce5f
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: FindWindowNavFocusable(int, int, int)
static ImGuiWindow* FindWindowNavFocusable(int i_start, int i_stop, int dir) // FIXME-OPT O(N)
{
    ImGuiContext& g = *GImGui;
    for (int i = i_start; i >= 0 && i < g.WindowsFocusOrder.Size && i != i_stop; i += dir)
        if (ImGui::IsWindowNavFocusable(g.WindowsFocusOrder[i]))
            return g.WindowsFocusOrder[i];
    return NULL;
}

// Assembly:
testl %edi, %edi
js 0x5cf12
pushq %rbp
movq %rsp, %rbp
movq 0x9ee01(%rip), %rcx     # 0xfbcd0
movl 0x1a98(%rcx), %r8d
cmpl %edi, %esi
je 0x5cf0e
movl $0x0, %eax
cmpl %r8d, %edi
jge 0x5cf10
movq 0x1aa0(%rcx), %rax
movl %edi, %r9d
movq (%rax,%r9,8), %rax
cmpb $0x1, 0x8f(%rax)
jne 0x5cf0a
cmpq %rax, 0x390(%rax)
jne 0x5cf0a
testb $0x8, 0xe(%rax)
je 0x5cf10
addl %edx, %edi
jns 0x5ced6
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: NavUpdateWindowingHighlightWindow(int)
static void NavUpdateWindowingHighlightWindow(int focus_change_dir)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavWindowingTarget);
    if (g.NavWindowingTarget->Flags & ImGuiWindowFlags_Modal)
        return;

    const int i_current = ImGui::FindWindowFocusIndex(g.NavWindowingTarget);
    ImGuiWindow* window_target = FindWindowNavFocusable(i_current + focus_change_dir, -INT_MAX, focus_change_dir);
    if (!window_target)
        window_target = FindWindowNavFocusable((focus_change_dir < 0) ? (g.WindowsFocusOrder.Size - 1) : 0, i_current, focus_change_dir);
    if (window_target) // Don't reset windowing target if there's a single window in the list
        g.NavWindowingTarget = g.NavWindowingTargetAnim = window_target;
    g.NavWindowingToggleLayer = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x9eda9(%rip), %r15     # 0xfbcd0
movq 0x1dc0(%r15), %rax
testq %rax, %rax
je 0x5cfc0
testb $0x8, 0xf(%rax)
jne 0x5cfb7
movl %edi, %ebx
movl 0x1a98(%r15), %r12d
movq %r12, %rcx
decq %rcx
movl %r12d, %r14d
testl %r14d, %r14d
jle 0x5cf6b
movq 0x1aa0(%r15), %rdx
movl %ecx, %esi
decl %r14d
decq %rcx
cmpq %rax, (%rdx,%rsi,8)
jne 0x5cf4f
jmp 0x5cf71
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leal (%r14,%rbx), %edi
movl $0x80000001, %esi       # imm = 0x80000001
movl %ebx, %edx
callq 0x5cec0
testq %rax, %rax
jne 0x5cfa1
leal -0x1(%r12), %eax
movl %ebx, %edi
sarl $0x1f, %edi
andl %eax, %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x5cec0
testq %rax, %rax
je 0x5cfaf
movq %rax, 0x1dc8(%r15)
movq %rax, 0x1dc0(%r15)
movb $0x0, 0x1de0(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d422(%rip), %rdi     # 0xba3e9
leaq 0x59197(%rip), %rsi     # 0xb6165
leaq 0x5d429(%rip), %rcx     # 0xba3fe
movl $0x2459, %edx           # imm = 0x2459
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: HelpMarker(char const*)
static void HelpMarker(const char* desc)
{
    ImGui::TextDisabled("(?)");
    if (ImGui::IsItemHovered())
    {
        ImGui::BeginTooltip();
        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
        ImGui::TextUnformatted(desc);
        ImGui::PopTextWrapPos();
        ImGui::EndTooltip();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x548d7(%rip), %rdi     # 0xba5ff
xorl %eax, %eax
callq 0x904f1
xorl %edi, %edi
callq 0x461ed
testb %al, %al
je 0x65d6b
callq 0x56a72
callq 0x54766
mulss 0x4fbb4(%rip), %xmm0    # 0xb5900
callq 0x53f70
movq %rbx, %rdi
xorl %esi, %esi
callq 0x90314
callq 0x54076
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x56bca
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ImGui::ShowStyleSelector(char const*)
bool ImGui::ShowStyleSelector(const char* label)
{
    static int style_idx = -1;
    if (ImGui::Combo(label, &style_idx, "Dark\0Light\0Classic\0"))
    {
        switch (style_idx)
        {
        case 0: ImGui::StyleColorsDark(); break;
        case 1: ImGui::StyleColorsLight(); break;
        case 2: ImGui::StyleColorsClassic(); break;
        }
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x854ee(%rip), %rsi     # 0xf7520
leaq 0x490b3(%rip), %rdx     # 0xbb0ec
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x94b84
movl %eax, %ebx
testb %al, %al
je 0x72076
movl 0x854d1(%rip), %eax     # 0xf7520
cmpl $0x2, %eax
je 0x7206f
cmpl $0x1, %eax
je 0x72066
testl %eax, %eax
jne 0x72076
xorl %edi, %edi
callq 0x74828
jmp 0x72076
xorl %edi, %edi
callq 0x74db7
jmp 0x72076
xorl %edi, %edi
callq 0x74ae5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ImGui::ShowFontSelector(char const*)
void ImGui::ShowFontSelector(const char* label)
{
    ImGuiIO& io = ImGui::GetIO();
    ImFont* font_current = ImGui::GetFont();
    if (ImGui::BeginCombo(label, font_current->GetDebugName()))
    {
        for (int n = 0; n < io.Fonts->Fonts.Size; n++)
        {
            ImFont* font = io.Fonts->Fonts[n];
            ImGui::PushID((void*)font);
            if (ImGui::Selectable(font->GetDebugName(), font == font_current))
                io.FontDefault = font;
            ImGui::PopID();
        }
        ImGui::EndCombo();
    }
    ImGui::SameLine();
    HelpMarker(
        "- Load additional fonts with io.Fonts->AddFontFromFileTTF().\n"
        "- The font atlas is built when calling io.Fonts->GetTexDataAsXXXX() or io.Fonts->Build().\n"
        "- Read FAQ and docs/FONTS.md for more details.\n"
        "- If you need to add/remove fonts at runtime (e.g. for DPI change), do it before calling NewFrame().");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x4714d
movq %rax, %rbx
callq 0x54752
movq %rax, %r14
movq 0x48(%rax), %rax
leaq 0x56(%rax), %rsi
testq %rax, %rax
leaq 0x52de0(%rip), %rax     # 0xc4e92
cmoveq %rax, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x93d73
testb %al, %al
je 0x72142
movq 0xa0(%rbx), %rax
cmpl $0x0, 0x40(%rax)
jle 0x7213d
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
movq 0x48(%rax), %rax
movq (%rax,%r13,8), %r12
movq %r12, %rdi
callq 0x54d60
movq 0x48(%r12), %rax
leaq 0x56(%rax), %rdi
testq %rax, %rax
leaq 0x52d97(%rip), %rax     # 0xc4e92
cmoveq %rax, %rdi
xorl %esi, %esi
cmpq %r14, %r12
sete %sil
movq $0x0, -0x30(%rbp)
xorl %edx, %edx
movq %r15, %rcx
callq 0x94650
testb %al, %al
je 0x72125
movq %r12, 0xb0(%rbx)
callq 0x55082
incq %r13
movq 0xa0(%rbx), %rax
movslq 0x40(%rax), %rcx
cmpq %rcx, %r13
jl 0x720d8
callq 0x94489
movss 0x42e86(%rip), %xmm1    # 0xb4fd0
xorps %xmm0, %xmm0
callq 0x5591d
leaq 0x4a5b4(%rip), %rdi     # 0xbc70d
callq 0x65d18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowDemoWindowWidgets()::Funcs::MyCallback(ImGuiInputTextCallbackData*)
static int MyCallback(ImGuiInputTextCallbackData* data)
                {
                    if (data->EventFlag == ImGuiInputTextFlags_CallbackCompletion)
                    {
                        data->InsertChars(data->CursorPos, "..");
                    }
                    else if (data->EventFlag == ImGuiInputTextFlags_CallbackHistory)
                    {
                        if (data->EventKey == ImGuiKey_UpArrow)
                        {
                            data->DeleteChars(0, data->BufTextLen);
                            data->InsertChars(0, "Pressed Up!");
                            data->SelectAll();
                        }
                        else if (data->EventKey == ImGuiKey_DownArrow)
                        {
                            data->DeleteChars(0, data->BufTextLen);
                            data->InsertChars(0, "Pressed Down!");
                            data->SelectAll();
                        }
                    }
                    else if (data->EventFlag == ImGuiInputTextFlags_CallbackEdit)
                    {
                        // Toggle casing of first character
                        char c = data->Buf[0];
                        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) data->Buf[0] ^= 32;
                        data->BufDirty = true;

                        // Increment a counter
                        int* p_int = (int*)data->UserData;
                        *p_int = *p_int + 1;
                    }
                    return 0;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x80000, %eax          # imm = 0x80000
je 0x72211
cmpl $0x80, %eax
je 0x721ee
cmpl $0x40, %eax
jne 0x72262
movl 0x2c(%rbx), %esi
leaq 0x524e5(%rip), %rdx     # 0xc46c7
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x9c662
jmp 0x72262
movl 0x14(%rbx), %eax
cmpl $0x4, %eax
je 0x72235
cmpl $0x3, %eax
jne 0x72262
movl 0x20(%rbx), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9c5e2
leaq 0x4e264(%rip), %rdx     # 0xc0473
jmp 0x72249
movq 0x18(%rbx), %rax
movb (%rax), %cl
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x72229
xorb $0x20, %cl
movb %cl, (%rax)
movb $0x1, 0x28(%rbx)
movq 0x8(%rbx), %rax
incl (%rax)
jmp 0x72262
movl 0x20(%rbx), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9c5e2
leaq 0x4e236(%rip), %rdx     # 0xc047f
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x9c662
movl $0x0, 0x30(%rbx)
movl 0x20(%rbx), %eax
movl %eax, 0x34(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowDemoWindowWidgets()::Funcs::MyResizeCallback(ImGuiInputTextCallbackData*)
static int MyResizeCallback(ImGuiInputTextCallbackData* data)
                {
                    if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
                    {
                        ImVector<char>* my_str = (ImVector<char>*)data->UserData;
                        IM_ASSERT(my_str->begin() == data->Buf);
                        my_str->resize(data->BufSize); // NB: On resizing calls, generally data->BufSize == data->BufTextLen + 1
                        data->Buf = my_str->begin();
                    }
                    return 0;
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x40000, (%rdi)        # imm = 0x40000
jne 0x7232c
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x8(%r15), %r14
cmpq 0x18(%rdi), %r14
jne 0x7233d
movl 0x24(%rbx), %r12d
movl 0x4(%r15), %eax
cmpl %r12d, %eax
jge 0x72325
testl %eax, %eax
je 0x722e8
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x722ee
movl $0x8, %r13d
cmpl %r12d, %r13d
cmovlel %r12d, %r13d
movslq %r13d, %rdi
callq 0x41c63
movq %rax, %r14
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x7231d
movslq (%r15), %rdx
movq %r14, %rdi
callq 0xc080
movq 0x8(%r15), %rdi
callq 0x41d3c
movq %r14, 0x8(%r15)
movl %r13d, 0x4(%r15)
movl %r12d, (%r15)
movq %r14, 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e149(%rip), %rdi     # 0xc048d
leaq 0x4933c(%rip), %rsi     # 0xbb687
leaq 0x4e158(%rip), %rcx     # 0xc04aa
movl $0x52f, %edx            # imm = 0x52F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowDemoWindowTables()::MyTreeNode::DisplayNode(MyTreeNode const*, MyTreeNode const*)
static void DisplayNode(const MyTreeNode* node, const MyTreeNode* all_nodes)
                {
                    ImGui::TableNextRow();
                    ImGui::TableNextColumn();
                    const bool is_folder = (node->ChildCount > 0);
                    if (is_folder)
                    {
                        bool open = ImGui::TreeNodeEx(node->Name, ImGuiTreeNodeFlags_SpanFullWidth);
                        ImGui::TableNextColumn();
                        ImGui::TextDisabled("--");
                        ImGui::TableNextColumn();
                        ImGui::TextUnformatted(node->Type);
                        if (open)
                        {
                            for (int child_n = 0; child_n < node->ChildCount; child_n++)
                                DisplayNode(&all_nodes[node->ChildIdx + child_n], all_nodes);
                            ImGui::TreePop();
                        }
                    }
                    else
                    {
                        ImGui::TreeNodeEx(node->Name, ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_Bullet | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth);
                        ImGui::TableNextColumn();
                        ImGui::Text("%d", node->Size);
                        ImGui::TableNextColumn();
                        ImGui::TextUnformatted(node->Type);
                    }
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorl %edi, %edi
callq 0x8b850
callq 0x8bd84
cmpl $0x0, 0x18(%rbx)
movq (%rbx), %rdi
jle 0x725fd
movl $0x1000, %esi           # imm = 0x1000
callq 0xa1294
movl %eax, %r14d
callq 0x8bd84
leaq 0x5ed98(%rip), %rdi     # 0xd133e
xorl %eax, %eax
callq 0x904f1
callq 0x8bd84
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x90314
testb %r14b, %r14b
je 0x72637
cmpl $0x0, 0x18(%rbx)
jle 0x725ee
xorl %r14d, %r14d
leaq 0x840fe(%rip), %r15     # 0xf66d0
movslq 0x14(%rbx), %rdi
addq %r14, %rdi
shlq $0x5, %rdi
addq %r15, %rdi
callq 0x72568
incq %r14
cmpl 0x18(%rbx), %r14d
jl 0x725d2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa1609
movl $0x1308, %esi           # imm = 0x1308
callq 0xa1294
callq 0x8bd84
movl 0x10(%rbx), %esi
leaq 0x49e3c(%rip), %rdi     # 0xbc452
xorl %eax, %eax
callq 0x90323
callq 0x8bd84
movq 0x8(%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x90314
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: (anonymous namespace)::MyItem::CompareWithSortSpecs(void const*, void const*)
CompareWithSortSpecs(const void* lhs, const void* rhs)
    {
        const MyItem* a = (const MyItem*)lhs;
        const MyItem* b = (const MyItem*)rhs;
        for (int n = 0; n < s_current_sort_specs->SpecsCount; n++)
        {
            // Here we identify columns using the ColumnUserID value that we ourselves passed to TableSetupColumn()
            // We could also choose to identify columns based on their index (sort_spec->ColumnIndex), which is simpler!
            const ImGuiTableColumnSortSpecs* sort_spec = &s_current_sort_specs->Specs[n];
            int delta = 0;
            switch (sort_spec->ColumnUserID)
            {
            case MyItemColumnID_ID:             delta = (a->ID - b->ID);                break;
            case MyItemColumnID_Name:           delta = (strcmp(a->Name, b->Name));     break;
            case MyItemColumnID_Quantity:       delta = (a->Quantity - b->Quantity);    break;
            case MyItemColumnID_Description:    delta = (strcmp(a->Name, b->Name));     break;
            default: IM_ASSERT(0); break;
            }
            if (delta > 0)
                return (sort_spec->SortDirection == ImGuiSortDirection_Ascending) ? +1 : -1;
            if (delta < 0)
                return (sort_spec->SortDirection == ImGuiSortDirection_Ascending) ? -1 : +1;
        }

        // qsort() is instable so always return a way to differenciate items.
        // Your own compare function may want to avoid fallback on implicit sort specs e.g. a Name compare if it wasn't already part of the sort specs.
        return (a->ID - b->ID);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8a527(%rip), %rcx     # 0xfcba0
movslq 0x8(%rcx), %rax
testq %rax, %rax
jle 0x726df
movq (%rcx), %r15
shlq $0x2, %rax
leaq (%rax,%rax,2), %rcx
xorl %r12d, %r12d
leaq 0x48a41(%rip), %r13     # 0xbb0d8
movq %rcx, -0x30(%rbp)
movl (%r15,%r12), %eax
cmpq $0x4, %rax
ja 0x72714
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0xc720
movq -0x30(%rbp), %rcx
jmp 0x726d0
movl 0x10(%r14), %eax
subl 0x10(%rbx), %eax
jmp 0x726d0
movl (%r14), %eax
subl (%rbx), %eax
testl %eax, %eax
jg 0x726e6
js 0x726f3
addq $0xc, %r12
cmpq %r12, %rcx
jne 0x7269b
movl (%r14), %eax
subl (%rbx), %eax
jmp 0x72705
xorl %eax, %eax
cmpb $0x1, 0x8(%r15,%r12)
sete %al
jmp 0x726fe
xorl %eax, %eax
cmpb $0x1, 0x8(%r15,%r12)
setne %al
leal -0x1(,%rax,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x459d1(%rip), %rdi     # 0xb80ec
leaq 0x48f65(%rip), %rsi     # 0xbb687
leaq 0x51d28(%rip), %rcx     # 0xc4451
movl $0xd00, %edx            # imm = 0xD00
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: MyDocument::DisplayContextMenu(MyDocument*)
static void DisplayContextMenu(MyDocument* doc)
    {
        if (!ImGui::BeginPopupContextItem())
            return;

        char buf[256];
        sprintf(buf, "Save %s", doc->Name);
        if (ImGui::MenuItem(buf, "CTRL+S", false, doc->Open))
            doc->DoSave();
        if (ImGui::MenuItem("Close", "CTRL+W", false, doc->Open))
            doc->DoQueueClose();
        ImGui::EndPopup();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x5760b
testb %al, %al
je 0x7472b
movq (%rbx), %rdx
leaq 0x51ad1(%rip), %rsi     # 0xc61a8
leaq -0x110(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0xc880
movzbl 0x8(%rbx), %ecx
leaq 0x51abd(%rip), %rsi     # 0xc61b0
movq %r14, %rdi
xorl %edx, %edx
callq 0xa37af
testb %al, %al
je 0x74705
movb $0x0, 0xa(%rbx)
movzbl 0x8(%rbx), %ecx
leaq 0x4bcd8(%rip), %rdi     # 0xc03e8
leaq 0x51aa0(%rip), %rsi     # 0xc61b7
xorl %edx, %edx
callq 0xa37af
testb %al, %al
je 0x74726
movb $0x1, 0xb(%rbx)
callq 0x5732f
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: MyDocument::DisplayContents(MyDocument*)
static void DisplayContents(MyDocument* doc)
    {
        ImGui::PushID(doc);
        ImGui::Text("Document \"%s\"", doc->Name);
        ImGui::PushStyleColor(ImGuiCol_Text, doc->Color);
        ImGui::TextWrapped("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
        ImGui::PopStyleColor();
        if (ImGui::Button("Modify", ImVec2(100, 0)))
            doc->Dirty = true;
        ImGui::SameLine();
        if (ImGui::Button("Save", ImVec2(100, 0)))
            doc->DoSave();
        ImGui::ColorEdit3("color", &doc->Color.x);  // Useful to test drag and drop and hold-dragged-to-open-tab behavior.
        ImGui::PopID();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x54d60
movq (%rbx), %rsi
leaq 0x51a69(%rip), %rdi     # 0xc61be
xorl %eax, %eax
callq 0x90323
leaq 0xc(%rbx), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x43e1b
leaq 0x51a5b(%rip), %rdi     # 0xc61cc
xorl %eax, %eax
callq 0x905ef
movl $0x1, %edi
callq 0x43f55
leaq -0x18(%rbp), %rsi
movq $0x42c80000, (%rsi)     # imm = 0x42C80000
leaq 0x51ab4(%rip), %rdi     # 0xc6248
callq 0x9141e
testb %al, %al
je 0x747a1
movb $0x1, 0xa(%rbx)
movss 0x40827(%rip), %xmm1    # 0xb4fd0
xorps %xmm0, %xmm0
callq 0x5591d
leaq -0x18(%rbp), %rsi
movq $0x42c80000, (%rsi)     # imm = 0x42C80000
leaq 0x4854a(%rip), %rdi     # 0xbcd0d
callq 0x9141e
testb %al, %al
je 0x747d0
movb $0x0, 0xa(%rbx)
leaq 0x4eb51(%rip), %rdi     # 0xc3328
movq %r14, %rsi
xorl %edx, %edx
callq 0x9cc6b
callq 0x55082
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSharedData::ImDrawListSharedData()
ImDrawListSharedData::ImDrawListSharedData()
{
    memset(this, 0, sizeof(*this));
    for (int i = 0; i < IM_ARRAYSIZE(ArcFastVtx); i++)
    {
        const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(ArcFastVtx);
        ArcFastVtx[i] = ImVec2(ImCos(a), ImSin(a));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xd8, %edx
xorl %esi, %esi
callq 0xc260
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
addss %xmm0, %xmm0
mulss 0x518ab(%rip), %xmm0    # 0xc6950
divss 0x40857(%rip), %xmm0    # 0xb5904
movss %xmm0, -0x14(%rbp)
callq 0xc5d0
movss %xmm0, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
callq 0xc050
movss -0x18(%rbp), %xmm1
movss %xmm1, 0x30(%rbx,%r14,8)
movss %xmm0, 0x34(%rbx,%r14,8)
incq %r14
cmpq $0xc, %r14
jne 0x75091
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawListSharedData::SetCircleSegmentMaxError(float)
void ImDrawListSharedData::SetCircleSegmentMaxError(float max_error)
{
    if (CircleSegmentMaxError == max_error)
        return;
    CircleSegmentMaxError = max_error;
    for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++)
    {
        const float radius = (float)i;
        const int segment_count = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, CircleSegmentMaxError);
        CircleSegmentCounts[i] = (ImU8)ImMin(segment_count, 255);
    }
}

// Assembly:
movss 0x18(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jne 0x750f9
jp 0x750f9
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movss %xmm0, 0x18(%rdi)
xorl %r14d, %r14d
xorps %xmm1, %xmm1
cvtsi2ss %r14d, %xmm1
movaps %xmm1, %xmm0
subss 0x18(%rbx), %xmm0
divss %xmm1, %xmm0
callq 0xc4d0
movss 0x51828(%rip), %xmm1    # 0xc6954
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0x200, %ecx            # imm = 0x200
cmpl %ecx, %eax
jl 0x75142
movl $0x200, %eax            # imm = 0x200
cmpl $0xd, %eax
jge 0x7514c
movl $0xc, %eax
movl $0xff, %ecx
cmpl %ecx, %eax
jl 0x7515a
movl $0xff, %eax
movb %al, 0x90(%rbx,%r14)
incq %r14
cmpq $0x40, %r14
jne 0x7510b
popq %rbx
popq %r14
popq %rbp
retq