LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogBegin(ImGuiLogType, int)
void ImGui::LogBegin(ImGuiLogType type, int auto_open_depth)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.LogEnabled == false);
    IM_ASSERT(g.LogFile == NULL);
    IM_ASSERT(g.LogBuffer.empty());
    g.LogEnabled = true;
    g.LogType = type;
    g.LogDepthRef = window->DC.TreeDepth;
    g.LogDepthToExpand = ((auto_open_depth >= 0) ? auto_open_depth : g.LogDepthToExpandDefault);
    g.LogLinePosY = FLT_MAX;
    g.LogLineFirstItem = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xa3ca6(%rip), %rax     # 0xfdcd0
cmpb $0x0, 0x3138(%rax)
jne 0x5a08d
cmpq $0x0, 0x3140(%rax)
jne 0x5a0ac
cmpl $0x2, 0x3148(%rax)
jge 0x5a0cb
movq 0x1ae0(%rax), %rcx
movb $0x1, 0x3138(%rax)
movl %edi, 0x313c(%rax)
movl 0x18c(%rcx), %ecx
movl %ecx, 0x3160(%rax)
testl %esi, %esi
jns 0x5a074
movl 0x3168(%rax), %esi
movl %esi, 0x3164(%rax)
movl $0x7f7fffff, 0x3158(%rax) # imm = 0x7F7FFFFF
movb $0x1, 0x315c(%rax)
popq %rbp
retq
leaq 0x606f0(%rip), %rdi     # 0xba784
leaq 0x5e0ca(%rip), %rsi     # 0xb8165
leaq 0x606f8(%rip), %rcx     # 0xba79a
movl $0x26a1, %edx           # imm = 0x26A1
callq 0xc140
leaq 0x6070f(%rip), %rdi     # 0xba7c2
leaq 0x5e0ab(%rip), %rsi     # 0xb8165
leaq 0x606d9(%rip), %rcx     # 0xba79a
movl $0x26a2, %edx           # imm = 0x26A2
callq 0xc140
leaq 0x60704(%rip), %rdi     # 0xba7d6
leaq 0x5e08c(%rip), %rsi     # 0xb8165
leaq 0x606ba(%rip), %rcx     # 0xba79a
movl $0x26a3, %edx           # imm = 0x26A3
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogToTTY(int)
void ImGui::LogToTTY(int auto_open_depth)
{
    ImGuiContext& g = *GImGui;
    if (g.LogEnabled)
        return;
    IM_UNUSED(auto_open_depth);
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
    LogBegin(ImGuiLogType_TTY, auto_open_depth);
    g.LogFile = stdout;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xa3bd9(%rip), %rbx     # 0xfdcd0
cmpb $0x0, 0x3138(%rbx)
jne 0x5a11d
movl %edi, %esi
movl $0x1, %edi
callq 0x5a01f
movq 0x9eded(%rip), %rax     # 0xf8f00
movq (%rax), %rax
movq %rax, 0x3140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: 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 0xa3b9b(%rip), %r15     # 0xfdcd0
cmpb $0x0, 0x3138(%r15)
jne 0x5a181
movl %edi, %ebx
testq %rsi, %rsi
jne 0x5a14a
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x5a181
cmpb $0x0, (%rsi)
je 0x5a181
leaq 0x5e59f(%rip), %rax     # 0xb86fa
movq %rsi, %rdi
movq %rax, %rsi
callq 0xc9a0
testq %rax, %rax
je 0x5a18c
movq %rax, %r14
movl $0x2, %edi
movl %ebx, %esi
callq 0x5a01f
movq %r14, 0x3140(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ff59(%rip), %rdi     # 0xba0ec
leaq 0x5dfcb(%rip), %rsi     # 0xb8165
leaq 0x60649(%rip), %rcx     # 0xba7ea
movl $0x26c9, %edx           # imm = 0x26C9
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa3838(%rip), %r14     # 0xfdcd0
leaq 0x603cd(%rip), %rsi     # 0xba86c
callq 0xc400
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0xc350
movq %rax, %r15
leaq 0x11(%rax), %rsi
movq %r14, %rdi
callq 0x5f572
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x428dc
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_O1/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 0xa37c7(%rip), %r14     # 0xfdcd0
movq 0x3110(%r14), %rcx
leaq 0x4(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
je 0x5a53a
movl %edi, %ebx
addq $0x3108, %r14           # imm = 0x3108
cmpl %ebx, (%rax)
je 0x5a53a
movq %r14, %rdi
movq %rax, %rsi
callq 0x5f656
testq %rax, %rax
jne 0x5a526
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa3750(%rip), %r14     # 0xfdcd0
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x428dc
movslq 0x30f8(%r14), %rcx
testq %rcx, %rcx
jle 0x5a5ae
movq 0x3100(%r14), %rbx
cmpl %eax, 0x8(%rbx)
je 0x5a5ae
addq $0x48, %rbx
decq %rcx
jne 0x5a59e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa3709(%rip), %rbx     # 0xfdcd0
leaq 0x30e8(%rbx), %rdi
callq 0x5f36e
cmpl $0x0, 0x30f8(%rbx)
jle 0x5a60e
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x3100(%rbx), %rsi
movq 0x10(%rsi,%r14), %rax
testq %rax, %rax
je 0x5a5fb
addq %r14, %rsi
movq %rbx, %rdi
callq *%rax
incq %r15
movslq 0x30f8(%rbx), %rax
addq $0x48, %r14
cmpq %rax, %r15
jl 0x5a5e2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: 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 0x6023f(%rip), %rsi     # 0xba870
xorl %ecx, %ecx
callq 0x42a14
testq %rax, %rax
je 0x5a66e
movq %rax, %rbx
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x5a675
movq 0xa367d(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x5a65e
decl 0x3b4(%rax)
movq 0xa367b(%rip), %rsi     # 0xfdce0
movq %rbx, %rdi
callq *0x9eeaa(%rip)          # 0xf9518
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa334c(%rip), %rbx     # 0xfdcd0
movl $0x0, 0x30e4(%rbx)
movl 0x30ec(%rbx), %eax
testl %eax, %eax
jns 0x5aa22
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
testq %rbx, %rbx
je 0x5a9bb
incl 0x3b4(%rbx)
movq 0xa331e(%rip), %rsi     # 0xfdce0
movq %r15, %rdi
callq *0x9eb45(%rip)          # 0xf9510
movq %rax, %r12
movq 0x30f0(%rbx), %rsi
testq %rsi, %rsi
je 0x5aa14
movslq 0x30e8(%rbx), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x30f0(%rbx), %rdi
testq %rdi, %rdi
je 0x5aa07
movq 0xa32d4(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x5aa07
decl 0x3b4(%rax)
movq 0xa32d2(%rip), %rsi     # 0xfdce0
callq *0x9eb04(%rip)          # 0xf9518
movq %r12, 0x30f0(%rbx)
movl %r15d, 0x30ec(%rbx)
movl $0x0, 0x30e8(%rbx)
cmpl $0x0, 0x30ec(%rbx)
jne 0x5aab3
movq 0xa3294(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x5aa47
incl 0x3b4(%rax)
movq 0xa3292(%rip), %rsi     # 0xfdce0
movl $0x8, %edi
callq *0x9eab7(%rip)          # 0xf9510
movq %rax, %r15
movq 0x30f0(%rbx), %rsi
testq %rsi, %rsi
je 0x5aaa2
movslq 0x30e8(%rbx), %rdx
movq %r15, %rdi
callq 0xc080
movq 0x30f0(%rbx), %rdi
testq %rdi, %rdi
je 0x5aa95
movq 0xa3246(%rip), %rax     # 0xfdcd0
testq %rax, %rax
je 0x5aa95
decl 0x3b4(%rax)
movq 0xa3244(%rip), %rsi     # 0xfdce0
callq *0x9ea76(%rip)          # 0xf9518
movq %r15, 0x30f0(%rbx)
movl $0x8, 0x30ec(%rbx)
movq 0x30f0(%rbx), %rax
movslq 0x30e8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
incl 0x30e8(%rbx)
leaq 0x30e8(%rbx), %r15
cmpl $0x0, 0x30f8(%rbx)
jle 0x5ab0a
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 0x5aae1
testq %r14, %r14
je 0x5ab1f
movl (%r15), %eax
xorl %ecx, %ecx
subl $0x1, %eax
cmovbl %ecx, %eax
cltq
movq %rax, (%r14)
movq 0x30f0(%rbx), %rcx
testq %rcx, %rcx
leaq 0xa31a8(%rip), %rax     # 0xfdcd8
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_O1/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 0x5c263
movl %esi, %eax
leaq 0x5b802(%rip), %rcx     # 0xb797c
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 0x5c25f
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 0x5de7e(%rip), %rdi     # 0xba0ec
leaq 0x5bef0(%rip), %rsi     # 0xb8165
leaq 0x60387(%rip), %rcx     # 0xbc603
movl $0x2963, %edx           # imm = 0x2963
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61f26(%rip), %rsi     # 0xbe43b
movq %rdx, %rdi
xorl %eax, %eax
callq 0xa20b9
testb %al, %al
je 0x5c590
leaq 0x5f09d(%rip), %rdi     # 0xbb5c7
xorl %eax, %eax
callq 0x92024
movslq (%rbx), %r15
testq %r15, %r15
jle 0x5c581
leaq 0x5fe80(%rip), %r14     # 0xbc3c0
movslq (%rbx), %rax
cmpq %rax, %r15
jg 0x5c59b
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdi
callq 0x55e4b
movslq (%rbx), %rax
cmpq %rax, %r15
jg 0x5c59b
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdi
decq %r15
movq %r14, %rsi
callq 0x5d426
callq 0x56188
leaq 0x1(%r15), %rax
cmpq $0x1, %rax
jg 0x5c540
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa2f4e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f0d6(%rip), %rdi     # 0xbb678
leaq 0x5f0e2(%rip), %rsi     # 0xbb68b
leaq 0x604b7(%rip), %rcx     # 0xbca67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e037(%rip), %rsi     # 0xbb024
movl %edi, %edx
xorl %eax, %eax
callq 0xa21c9
testb %al, %al
je 0x5d091
movss 0x14(%rbx), %xmm1
movss 0x18(%rbx), %xmm0
cvtss2sd %xmm0, %xmm2
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0x5e032(%rip), %rdi     # 0xbb051
movb $0x3, %al
callq 0x92645
cmpl $0x0, 0x60(%rbx)
jle 0x5d080
xorl %r12d, %r12d
leaq 0x5e040(%rip), %r14     # 0xbb076
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 0x90210
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movq %r14, %rdi
movl %r15d, %esi
movsd -0x28(%rbp), %xmm0
movb $0x2, %al
callq 0x92645
incq %r15
movslq 0x60(%rbx), %rax
addq $0x1c, %r12
cmpq %rax, %r15
jl 0x5d039
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa2f4e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5dec7(%rip), %rsi     # 0xbb28e
movq %rdx, %rdi
xorl %eax, %eax
callq 0xa20b9
testb %al, %al
je 0x5d41d
cmpl $0x0, (%rbx)
jle 0x5d410
movl $0x8, %r15d
leaq 0x5dec0(%rip), %r14     # 0xbb2a7
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movl -0x8(%rax,%r15), %esi
movl (%rax,%r15), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x92645
incq %r12
movslq (%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x5d3ea
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa2f4e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5d8eb
movl $0x2000000, %r8d        # imm = 0x2000000
andl %r8d, %esi
andl %r8d, %edi
subl %edi, %esi
cmovnel %esi, %eax
jne 0x5d8eb
movswl 0x9c(%rcx), %eax
movswl 0x9c(%rdx), %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa03cc(%rip), %rax     # 0xfdcd0
incl 0x3ac(%rax)
movq 0x2b8(%rsi), %rsi
callq 0x5228c
cmpl $0x0, 0x198(%rbx)
jle 0x5d956
xorl %r15d, %r15d
movq 0x1a0(%rbx), %rax
movq (%rax,%r15,8), %rsi
cmpb $0x1, 0x8e(%rsi)
jne 0x5d947
cmpb $0x0, 0x95(%rsi)
jne 0x5d947
movq %r14, %rdi
callq 0x5d8ed
incq %r15
movslq 0x198(%rbx), %rax
cmpq %rax, %r15
jl 0x5d922
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: 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 $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movss (%rsi), %xmm6
movss 0x4(%rsi), %xmm5
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
movaps %xmm0, %xmm4
subss %xmm6, %xmm4
movss (%rdx), %xmm2
movss 0x4(%rdx), %xmm3
mulss %xmm2, %xmm4
addss %xmm6, %xmm4
movaps %xmm4, %xmm7
movaps %xmm1, %xmm4
subss %xmm5, %xmm4
mulss %xmm3, %xmm4
addss 0x18(%rdi), %xmm0
addss 0x1c(%rdi), %xmm1
addss %xmm5, %xmm4
subss %xmm0, %xmm6
mulss %xmm2, %xmm6
addss %xmm0, %xmm6
subss %xmm1, %xmm5
mulss %xmm3, %xmm5
addss %xmm1, %xmm5
subss %xmm7, %xmm6
unpcklps %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0],xmm7[1],xmm4[1]
movaps %xmm7, -0x50(%rbp)
subss %xmm4, %xmm5
movaps %xmm6, -0x30(%rbp)
movaps %xmm6, %xmm0
movaps %xmm5, -0x40(%rbp)
unpcklps %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1]
callq 0x53cbf
movaps -0x50(%rbp), %xmm1
movlps %xmm1, (%r14)
movss (%r15), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jne 0x5da25
jp 0x5da25
movaps %xmm0, %xmm2
subss -0x30(%rbp), %xmm2
movss (%r14), %xmm3
subss %xmm2, %xmm3
movss %xmm3, (%r14)
movss 0x4(%r15), %xmm2
ucomiss %xmm1, %xmm2
jne 0x5da4e
jp 0x5da4e
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
subss -0x40(%rbp), %xmm1
movss 0x4(%r14), %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x4(%r14)
movlps %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: 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 0x5daa4
jp 0x5daa4
movss 0x5953a(%rip), %xmm1    # 0xb6fd0
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 0x5db26
movl %esi, %eax
leaq 0x59f1e(%rip), %rcx     # 0xb79d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addss %xmm2, %xmm0
jmp 0x5dacc
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 0x5db1f
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 0x5db1f
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 0x5c5bb(%rip), %rdi     # 0xba0ec
leaq 0x5a62d(%rip), %rsi     # 0xb8165
leaq 0x5de9f(%rip), %rcx     # 0xbb9de
movl $0x1438, %edx           # imm = 0x1438
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x9fcf9(%rip), %rcx     # 0xfdcd0
movl %edi, 0x1cdc(%rcx)
testl %edi, %edi
jne 0x5e007
movq 0x1c90(%rcx), %rdx
movq 0x3a8(%rdx), %rax
testq %rax, %rax
je 0x5dffd
cmpb $0x0, 0x8f(%rax)
jne 0x5e000
movq %rdx, %rax
movq %rax, 0x1c90(%rcx)
movq 0x1c90(%rcx), %rax
testl %edi, %edi
je 0x5e01f
movq %rax, %rdi
movl $0x1, %esi
jmp 0x52f7a
movl 0x3b0(%rax), %edx
testl %edx, %edx
je 0x5e012
testq %rax, %rax
je 0x5e055
movl %edx, 0x1c98(%rcx)
movl $0x0, 0x1c9c(%rcx)
movl %edx, 0x3b0(%rax)
movw $0x1, 0x1ce5(%rcx)
movb $0x1, 0x1ce7(%rcx)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5c391(%rip), %rdi     # 0xba3f1
leaq 0x5a0fe(%rip), %rsi     # 0xb8165
leaq 0x5c274(%rip), %rcx     # 0xba2e2
movl $0x20a6, %edx           # imm = 0x20A6
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
js 0x5e0c6
movq 0x9fc49(%rip), %r8      # 0xfdcd0
movl 0x1a98(%r8), %ecx
xorl %eax, %eax
cmpl %edi, %esi
je 0x5e0c8
cmpl %ecx, %edi
jge 0x5e0c8
movq 0x1aa0(%r8), %r9
movl %edi, %r10d
movq (%r9,%r10,8), %r9
cmpb $0x1, 0x8f(%r9)
jne 0x5e0c0
cmpq %r9, 0x390(%r9)
jne 0x5e0c0
testb $0x8, 0xe(%r9)
je 0x5e0ca
addl %edx, %edi
jns 0x5e090
jmp 0x5e0c8
xorl %eax, %eax
popq %rbp
retq
movq %r9, %rax
cmpl %edi, %ecx
jg 0x5e0c8
leaq 0x5d5a0(%rip), %rdi     # 0xbb678
leaq 0x5d5ac(%rip), %rsi     # 0xbb68b
leaq 0x5e981(%rip), %rcx     # 0xbca67
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq 0x9fbcf(%rip), %r15     # 0xfdcd0
movq 0x1dc0(%r15), %rax
testq %rax, %rax
je 0x5e19c
testb $0x8, 0xf(%rax)
jne 0x5e191
movl %edi, %ebx
movl 0x1a98(%r15), %r14d
movq %r14, %rcx
decq %rcx
testl %r14d, %r14d
jle 0x5e142
movq 0x1aa0(%r15), %rdx
movl %ecx, %esi
decl %r14d
decq %rcx
cmpq %rax, (%rdx,%rsi,8)
jne 0x5e126
jmp 0x5e148
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leal (%r14,%rbx), %edi
movl $0x80000001, %esi       # imm = 0x80000001
movl %ebx, %edx
callq 0x5e078
testq %rax, %rax
jne 0x5e176
xorl %edi, %edi
testl %ebx, %ebx
jns 0x5e16c
movl 0x1a98(%r15), %edi
decl %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x5e078
testq %rax, %rax
je 0x5e189
movq %rax, 0x1dc8(%r15)
movq %rax, 0x1dc0(%r15)
movb $0x0, 0x1de0(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e246(%rip), %rdi     # 0xbc3e9
leaq 0x59fbb(%rip), %rsi     # 0xb8165
leaq 0x5e24d(%rip), %rcx     # 0xbc3fe
movl $0x2459, %edx           # imm = 0x2459
callq 0xc140
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x557b9(%rip), %rdi     # 0xbc5ff
xorl %eax, %eax
callq 0x921f2
xorl %edi, %edi
callq 0x46d03
testb %al, %al
je 0x66e89
callq 0x57b87
callq 0x55801
mulss 0x50a96(%rip), %xmm0    # 0xb7900
callq 0x55008
movq %rbx, %rdi
xorl %esi, %esi
callq 0x92015
callq 0x5511a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x57cdf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x863d9(%rip), %rsi     # 0xf9520
leaq 0x49fce(%rip), %rdx     # 0xbd11c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x967e7
movl %eax, %ebx
testb %al, %al
je 0x7318b
movl 0x863bc(%rip), %eax     # 0xf9520
cmpl $0x2, %eax
je 0x73184
cmpl $0x1, %eax
je 0x7317b
testl %eax, %eax
jne 0x7318b
xorl %edi, %edi
callq 0x75a38
jmp 0x7318b
xorl %edi, %edi
callq 0x7619b
jmp 0x7318b
xorl %edi, %edi
callq 0x75dd0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47c7c
movq %rax, %rbx
callq 0x557ed
movq %rax, %r14
movq 0x48(%rax), %rax
leaq 0x56(%rax), %rsi
testq %rax, %rax
leaq 0x53cfb(%rip), %rax     # 0xc6ec2
cmoveq %rax, %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x95a09
testb %al, %al
je 0x73257
movq 0xa0(%rbx), %rax
cmpl $0x0, 0x40(%rax)
jle 0x73252
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
movq 0x48(%rax), %rax
movq (%rax,%r13,8), %r12
movq %r12, %rdi
callq 0x55e4b
movq 0x48(%r12), %rax
leaq 0x56(%rax), %rdi
testq %rax, %rax
leaq 0x53cb2(%rip), %rax     # 0xc6ec2
cmoveq %rax, %rdi
xorl %esi, %esi
cmpq %r14, %r12
sete %sil
movq $0x0, -0x30(%rbp)
xorl %edx, %edx
movq %r15, %rcx
callq 0x962c5
testb %al, %al
je 0x7323a
movq %r12, 0xb0(%rbx)
callq 0x56188
incq %r13
movq 0xa0(%rbx), %rax
movslq 0x40(%rax), %rcx
cmpq %rcx, %r13
jl 0x731ed
callq 0x9610f
movss 0x43d71(%rip), %xmm1    # 0xb6fd0
xorps %xmm0, %xmm0
callq 0x569e1
leaq 0x4b4cf(%rip), %rdi     # 0xbe73d
callq 0x66e36
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_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 0x73325
cmpl $0x80, %eax
je 0x73302
cmpl $0x40, %eax
jne 0x73376
movl 0x2c(%rbx), %esi
leaq 0x53401(%rip), %rdx     # 0xc66f7
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x9e0e2
jmp 0x73376
movl 0x14(%rbx), %eax
cmpl $0x4, %eax
je 0x73349
cmpl $0x3, %eax
jne 0x73376
movl 0x20(%rbx), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9e06a
leaq 0x4f180(%rip), %rdx     # 0xc24a3
jmp 0x7335d
movq 0x18(%rbx), %rax
movb (%rax), %cl
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x7333d
xorb $0x20, %cl
movb %cl, (%rax)
movb $0x1, 0x28(%rbx)
movq 0x8(%rbx), %rax
incl (%rax)
jmp 0x73376
movl 0x20(%rbx), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9e06a
leaq 0x4f152(%rip), %rdx     # 0xc24af
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x9e0e2
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_O1/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 0x73451
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x8(%r15), %rax
cmpq 0x18(%rdi), %rax
jne 0x73462
movl 0x24(%rbx), %r12d
movl 0x4(%r15), %eax
cmpl %r12d, %eax
jge 0x73446
testl %eax, %eax
je 0x73404
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x7340a
movl $0x8, %r13d
cmpl %r12d, %r13d
cmovlel %r12d, %r13d
cmpl %r13d, %eax
jge 0x73446
movslq %r13d, %rdi
callq 0x424fb
movq %rax, %r14
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x7343e
movslq (%r15), %rdx
movq %r14, %rdi
callq 0xc080
movq 0x8(%r15), %rdi
callq 0x425d4
movq %r14, 0x8(%r15)
movl %r13d, 0x4(%r15)
movl %r12d, (%r15)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f054(%rip), %rdi     # 0xc24bd
leaq 0x4a247(%rip), %rsi     # 0xbd6b7
leaq 0x4f063(%rip), %rcx     # 0xc24da
movl $0x52f, %edx            # imm = 0x52F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8d51e
callq 0x8da6e
cmpl $0x0, 0x18(%rbx)
movq (%rbx), %rdi
jle 0x73723
movl $0x1000, %esi           # imm = 0x1000
callq 0xa2bd7
movl %eax, %r14d
callq 0x8da6e
leaq 0x5fda2(%rip), %rdi     # 0xd346e
xorl %eax, %eax
callq 0x921f2
callq 0x8da6e
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x92015
testb %r14b, %r14b
je 0x7375d
cmpl $0x0, 0x18(%rbx)
jle 0x73714
xorl %r14d, %r14d
leaq 0x84fd8(%rip), %r15     # 0xf86d0
movslq 0x14(%rbx), %rdi
addq %r14, %rdi
shlq $0x5, %rdi
addq %r15, %rdi
callq 0x7368e
incq %r14
cmpl 0x18(%rbx), %r14d
jl 0x736f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa2f4e
movl $0x1308, %esi           # imm = 0x1308
callq 0xa2bd7
callq 0x8da6e
movl 0x10(%rbx), %esi
leaq 0x4ad46(%rip), %rdi     # 0xbe482
xorl %eax, %eax
callq 0x92024
callq 0x8da6e
movq 0x8(%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x92015
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_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 0x5875f
testb %al, %al
je 0x75939
movq (%rbx), %rdx
leaq 0x52924(%rip), %rsi     # 0xc8209
leaq -0x110(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0xc880
movzbl 0x8(%rbx), %ecx
leaq 0x52910(%rip), %rsi     # 0xc8211
movq %r14, %rdi
xorl %edx, %edx
callq 0xa5164
testb %al, %al
je 0x75913
movb $0x0, 0xa(%rbx)
movzbl 0x8(%rbx), %ecx
leaq 0x4cafa(%rip), %rdi     # 0xc2418
leaq 0x528f3(%rip), %rsi     # 0xc8218
xorl %edx, %edx
callq 0xa5164
testb %al, %al
je 0x75934
movb $0x1, 0xb(%rbx)
callq 0x5847b
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55e4b
movq (%rbx), %rsi
leaq 0x528bc(%rip), %rdi     # 0xc821f
xorl %eax, %eax
callq 0x92024
leaq 0xc(%rbx), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x4481b
leaq 0x528ae(%rip), %rdi     # 0xc822d
xorl %eax, %eax
callq 0x922f0
movl $0x1, %edi
callq 0x44964
leaq -0x18(%rbp), %rsi
movq $0x42c80000, (%rsi)     # imm = 0x42C80000
leaq 0x52907(%rip), %rdi     # 0xc82a9
callq 0x93128
testb %al, %al
je 0x759af
movb $0x1, 0xa(%rbx)
movss 0x41619(%rip), %xmm1    # 0xb6fd0
xorps %xmm0, %xmm0
callq 0x569e1
leaq -0x18(%rbp), %rsi
movq $0x42c80000, (%rsi)     # imm = 0x42C80000
leaq 0x4936c(%rip), %rdi     # 0xbed3d
callq 0x93128
testb %al, %al
je 0x759de
movb $0x0, 0xa(%rbx)
leaq 0x4f973(%rip), %rdi     # 0xc5358
movq %r14, %rsi
xorl %edx, %edx
callq 0x9e6aa
callq 0x56188
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
xorl %r14d, %r14d
movl $0xd8, %edx
xorl %esi, %esi
callq 0xc260
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
addss %xmm0, %xmm0
mulss 0x523da(%rip), %xmm0    # 0xc8980
divss 0x41356(%rip), %xmm0    # 0xb7904
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 0x76592
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x765f9
jp 0x765f9
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 0x52358(%rip), %xmm1    # 0xc8984
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl $0x200, %ecx            # imm = 0x200
cmpl %ecx, %eax
jl 0x76642
movl $0x200, %eax            # imm = 0x200
cmpl $0xd, %eax
jge 0x7664c
movl $0xc, %eax
movl $0xff, %ecx
cmpl %ecx, %eax
jl 0x7665a
movl $0xff, %eax
movb %al, 0x90(%rbx,%r14)
incq %r14
cmpq $0x40, %r14
jne 0x7660b
popq %rbx
popq %r14
popq %rbp
retq