LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavMoveRequestForward(int, int, ImRect const&, int)
void ImGui::NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, const ImRect& bb_rel, ImGuiNavMoveFlags move_flags)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.NavMoveRequestForward == ImGuiNavForward_None);
    NavMoveRequestCancel();
    g.NavMoveDir = move_dir;
    g.NavMoveClipDir = clip_dir;
    g.NavMoveRequestForward = ImGuiNavForward_ForwardQueued;
    g.NavMoveRequestFlags = move_flags;
    g.NavWindow->NavRectRel[g.NavLayer] = bb_rel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x9e6ad(%rip), %r13     # 0xe3ce0
cmpl $0x0, 0x1d08(%r13)
jne 0x4569a
movl %ecx, %r14d
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %r12d
callq 0x45606
movl %r12d, 0x1d10(%r13)
movl %r15d, 0x1d18(%r13)
movl $0x1, 0x1d08(%r13)
movl %r14d, 0x1d04(%r13)
movq 0x1c90(%r13), %rax
movl 0x1cdc(%r13), %ecx
shlq $0x4, %rcx
movups (%rbx), %xmm0
movups %xmm0, 0x3b8(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59ced(%rip), %rdi     # 0x9f38e
leaq 0x57aed(%rip), %rsi     # 0x9d195
leaq 0x59d0f(%rip), %rcx     # 0x9f3be
movl $0x21c7, %edx           # imm = 0x21C7
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetNavInputAmount(int, ImGuiInputReadMode)
float ImGui::GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode)
{
    ImGuiContext& g = *GImGui;
    if (mode == ImGuiInputReadMode_Down)
        return g.IO.NavInputs[n];                         // Instant, read analog input (0.0f..1.0f, as provided by user)

    const float t = g.IO.NavInputsDownDuration[n];
    if (t < 0.0f && mode == ImGuiInputReadMode_Released)  // Return 1.0f when just released, no repeat, ignore analog input.
        return (g.IO.NavInputsDownDurationPrev[n] >= 0.0f ? 1.0f : 0.0f);
    if (t < 0.0f)
        return 0.0f;
    if (mode == ImGuiInputReadMode_Pressed)               // Return 1.0f when just pressed, no repeat, ignore analog input.
        return (t == 0.0f) ? 1.0f : 0.0f;
    if (mode == ImGuiInputReadMode_Repeat)
        return (float)CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay * 0.72f, g.IO.KeyRepeatRate * 0.80f);
    if (mode == ImGuiInputReadMode_RepeatSlow)
        return (float)CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay * 1.25f, g.IO.KeyRepeatRate * 2.00f);
    if (mode == ImGuiInputReadMode_RepeatFast)
        return (float)CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay * 0.72f, g.IO.KeyRepeatRate * 0.30f);
    return 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x9e61c(%rip), %rax     # 0xe3ce0
movslq %edi, %rcx
testl %esi, %esi
je 0x456fb
movss 0x14a0(%rax,%rcx,4), %xmm1
cmpl $0x2, %esi
jne 0x45709
xorps %xmm2, %xmm2
ucomiss %xmm1, %xmm2
jbe 0x45709
cmpless 0x14f4(%rax,%rcx,4), %xmm2
movss 0x56905(%rip), %xmm0    # 0x9bff8
andps %xmm2, %xmm0
jmp 0x457c6
movss 0x344(%rax,%rcx,4), %xmm0
jmp 0x457c6
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
ja 0x457c6
decl %esi
cmpl $0x4, %esi
ja 0x457c6
leaq 0x57271(%rip), %rcx     # 0x9c998
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
cmpeqss %xmm0, %xmm1
movss 0x568bb(%rip), %xmm0    # 0x9bff8
andps %xmm1, %xmm0
jmp 0x457c6
movaps %xmm1, %xmm0
subss 0x18(%rax), %xmm0
movss 0x94(%rax), %xmm2
movss 0x98(%rax), %xmm3
mulss 0x571bf(%rip), %xmm2    # 0x9c924
addss %xmm3, %xmm3
jmp 0x457bd
movaps %xmm1, %xmm0
subss 0x18(%rax), %xmm0
movss 0x94(%rax), %xmm2
movss 0x98(%rax), %xmm3
mulss 0x57191(%rip), %xmm2    # 0x9c91c
mulss 0x57195(%rip), %xmm3    # 0x9c928
jmp 0x457bd
movaps %xmm1, %xmm0
subss 0x18(%rax), %xmm0
movss 0x94(%rax), %xmm2
movss 0x98(%rax), %xmm3
mulss 0x57167(%rip), %xmm2    # 0x9c91c
mulss 0x57163(%rip), %xmm3    # 0x9c920
callq 0x40041
cvtsi2ss %eax, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::EndDragDropSource()
void ImGui::EndDragDropSource()
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.DragDropActive);
    IM_ASSERT(g.DragDropWithinSource && "Not after a BeginDragDropSource()?");

    if (!(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
        EndTooltip();

    // Discard the drag if have not called SetDragDropPayload()
    if (g.DragDropPayload.DataFrameCount == -1)
        ClearDragDrop();
    g.DragDropWithinSource = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x9e0e3(%rip), %rbx     # 0xe3ce0
cmpb $0x0, 0x2004(%rbx)
je 0x45c39
cmpb $0x0, 0x2005(%rbx)
je 0x45c58
testb $0x1, 0x2008(%rbx)
jne 0x45c1d
callq 0x4463b
cmpl $-0x1, 0x202c(%rbx)
jne 0x45c2b
callq 0x3fab3
movb $0x0, 0x2005(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x57ca0(%rip), %rdi     # 0x9d8e0
leaq 0x5754e(%rip), %rsi     # 0x9d195
leaq 0x5985f(%rip), %rcx     # 0x9f4ad
movl $0x259d, %edx           # imm = 0x259D
callq 0xc140
leaq 0x5986e(%rip), %rdi     # 0x9f4cd
leaq 0x5752f(%rip), %rsi     # 0x9d195
leaq 0x59840(%rip), %rcx     # 0x9f4ad
movl $0x259e, %edx           # imm = 0x259E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginDragDropTargetCustom(ImRect const&, unsigned int)
bool ImGui::BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    if (!g.DragDropActive)
        return false;

    ImGuiWindow* window = g.CurrentWindow;
    ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
    if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
        return false;
    IM_ASSERT(id != 0);
    if (!IsMouseHoveringRect(bb.Min, bb.Max) || (id == g.DragDropPayload.SourceId))
        return false;
    if (window->SkipItems)
        return false;

    IM_ASSERT(g.DragDropWithinTarget == false);
    g.DragDropTargetRect = bb;
    g.DragDropTargetId = id;
    g.DragDropWithinTarget = true;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x9de91(%rip), %r15     # 0xe3ce0
cmpb $0x1, 0x2004(%r15)
jne 0x45eaa
movq 0x1af8(%r15), %rax
testq %rax, %rax
je 0x45eaa
movq 0x1ae0(%r15), %r12
movq 0x390(%r12), %rcx
cmpq 0x390(%rax), %rcx
jne 0x45eaa
movl %esi, %ebx
testl %esi, %esi
je 0x45ede
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
pushq $0x1
popq %rdx
callq 0x37779
testb %al, %al
je 0x45eaa
cmpl %ebx, 0x2024(%r15)
je 0x45eaa
cmpb $0x0, 0x93(%r12)
je 0x45eb5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x2006(%r15)
jne 0x45efd
movups (%r14), %xmm0
movups %xmm0, 0x2058(%r15)
movl %ebx, 0x2068(%r15)
movb $0x1, 0x2006(%r15)
movb $0x1, %al
jmp 0x45eac
leaq 0x595c0(%rip), %rdi     # 0x9f4a5
leaq 0x572a9(%rip), %rsi     # 0x9d195
leaq 0x5978a(%rip), %rcx     # 0x9f67d
movl $0x25df, %edx           # imm = 0x25DF
callq 0xc140
leaq 0x597b8(%rip), %rdi     # 0x9f6bc
leaq 0x5728a(%rip), %rsi     # 0x9d195
leaq 0x5976b(%rip), %rcx     # 0x9f67d
movl $0x25e5, %edx           # imm = 0x25E5
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginDragDropTarget()
bool ImGui::BeginDragDropTarget()
{
    ImGuiContext& g = *GImGui;
    if (!g.DragDropActive)
        return false;

    ImGuiWindow* window = g.CurrentWindow;
    if (!(window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect))
        return false;
    ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
    if (hovered_window == NULL || window->RootWindow != hovered_window->RootWindow)
        return false;

    const ImRect& display_rect = (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HasDisplayRect) ? window->DC.LastItemDisplayRect : window->DC.LastItemRect;
    ImGuiID id = window->DC.LastItemId;
    if (id == 0)
        id = window->GetIDFromRectangle(display_rect);
    if (g.DragDropPayload.SourceId == id)
        return false;

    IM_ASSERT(g.DragDropWithinTarget == false);
    g.DragDropTargetRect = display_rect;
    g.DragDropTargetId = id;
    g.DragDropWithinTarget = true;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x9ddb6(%rip), %r14     # 0xe3ce0
cmpb $0x1, 0x2004(%r14)
jne 0x45f8a
movq 0x1ae0(%r14), %rdi
movl 0x128(%rdi), %eax
testb $0x1, %al
je 0x45f8a
movq 0x1af8(%r14), %rcx
testq %rcx, %rcx
je 0x45f8a
movq 0x390(%rdi), %rdx
cmpq 0x390(%rcx), %rdx
jne 0x45f8a
andl $0x2, %eax
leaq (%rdi,%rax,8), %rbx
addq $0x12c, %rbx            # imm = 0x12C
movl 0x124(%rdi), %eax
testl %eax, %eax
jne 0x45f81
movq %rbx, %rsi
callq 0x37226
cmpl %eax, 0x2024(%r14)
jne 0x45f91
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x0, 0x2006(%r14)
jne 0x45fb9
movups (%rbx), %xmm0
movups %xmm0, 0x2058(%r14)
movl %eax, 0x2068(%r14)
movb $0x1, 0x2006(%r14)
movb $0x1, %al
jmp 0x45f8c
leaq 0x596fc(%rip), %rdi     # 0x9f6bc
leaq 0x571ce(%rip), %rsi     # 0x9d195
leaq 0x5970e(%rip), %rcx     # 0x9f6dc
movl $0x2604, %edx           # imm = 0x2604
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::EndDragDropTarget()
void ImGui::EndDragDropTarget()
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.DragDropActive);
    IM_ASSERT(g.DragDropWithinTarget);
    g.DragDropWithinTarget = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x9da46(%rip), %rax     # 0xe3ce0
cmpb $0x0, 0x2004(%rax)
je 0x462b5
cmpb $0x0, 0x2006(%rax)
je 0x462d4
movb $0x0, 0x2006(%rax)
popq %rbp
retq
leaq 0x57624(%rip), %rdi     # 0x9d8e0
leaq 0x56ed2(%rip), %rsi     # 0x9d195
leaq 0x594a4(%rip), %rcx     # 0x9f76e
movl $0x2646, %edx           # imm = 0x2646
callq 0xc140
leaq 0x594b3(%rip), %rdi     # 0x9f78e
leaq 0x56eb3(%rip), %rsi     # 0x9d195
leaq 0x59485(%rip), %rcx     # 0x9f76e
movl $0x2647, %edx           # imm = 0x2647
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogText(char const*, ...)
void ImGui::LogText(const char* fmt, ...)
{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;

    va_list args;
    va_start(args, fmt);
    if (g.LogFile)
    {
        g.LogBuffer.Buf.resize(0);
        g.LogBuffer.appendfv(fmt, args);
        ImFileWrite(g.LogBuffer.c_str(), sizeof(char), (ImU64)g.LogBuffer.size(), g.LogFile);
    }
    else
    {
        g.LogBuffer.appendfv(fmt, args);
    }
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
testb %al, %al
je 0x46335
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq 0x9d981(%rip), %r15     # 0xe3ce0
cmpb $0x1, 0x3138(%r15)
jne 0x46404
movq %rdi, %rbx
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, -0x40(%rbp)
leaq 0x3148(%r15), %r14
cmpq $0x0, 0x3140(%r15)
je 0x463f5
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0x49cb6
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x356b4
movq 0x3150(%r15), %rax
testq %rax, %rax
leaq 0x9d919(%rip), %rdi     # 0xe3ce8
cmovneq %rax, %rdi
movl 0x3148(%r15), %eax
subl $0x1, %eax
cmovbl %r12d, %eax
movslq %eax, %rdx
movq 0x3140(%r15), %rcx
pushq $0x1
popq %rsi
callq 0xc910
jmp 0x46404
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x356b4
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d8c1(%rip), %rax     # 0xe3ce0
cmpb $0x0, 0x3138(%rax)
jne 0x46482
cmpq $0x0, 0x3140(%rax)
jne 0x464a1
cmpl $0x2, 0x3148(%rax)
jge 0x464c0
movq 0x1ae0(%rax), %rcx
movb $0x1, 0x3138(%rax)
movl %edi, 0x313c(%rax)
movl 0x18c(%rcx), %ecx
movl %ecx, 0x3160(%rax)
testl %esi, %esi
jns 0x46469
movl 0x3168(%rax), %esi
movl %esi, 0x3164(%rax)
movl $0x7f7fffff, 0x3158(%rax) # imm = 0x7F7FFFFF
movb $0x1, 0x315c(%rax)
popq %rbp
retq
leaq 0x5932b(%rip), %rdi     # 0x9f7b4
leaq 0x56d05(%rip), %rsi     # 0x9d195
leaq 0x59333(%rip), %rcx     # 0x9f7ca
movl $0x26a1, %edx           # imm = 0x26A1
callq 0xc140
leaq 0x5934a(%rip), %rdi     # 0x9f7f2
leaq 0x56ce6(%rip), %rsi     # 0x9d195
leaq 0x59314(%rip), %rcx     # 0x9f7ca
movl $0x26a2, %edx           # imm = 0x26A2
callq 0xc140
leaq 0x5933f(%rip), %rdi     # 0x9f806
leaq 0x56cc7(%rip), %rsi     # 0x9d195
leaq 0x592f5(%rip), %rcx     # 0x9f7ca
movl $0x26a3, %edx           # imm = 0x26A3
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d7f4(%rip), %rbx     # 0xe3ce0
cmpb $0x0, 0x3138(%rbx)
jne 0x46510
movl %edi, %esi
pushq $0x1
popq %rdi
callq 0x46414
movq 0x98a12(%rip), %rax     # 0xdef18
movq (%rax), %rax
movq %rax, 0x3140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d7b8(%rip), %r15     # 0xe3ce0
cmpb $0x0, 0x3138(%r15)
jne 0x46572
movl %edi, %ebx
testq %rsi, %rsi
jne 0x46542
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x46572
cmpb $0x0, (%rsi)
je 0x46572
leaq 0x571dc(%rip), %rax     # 0x9d72a
movq %rsi, %rdi
movq %rax, %rsi
callq 0xc9d0
testq %rax, %rax
je 0x4657d
movq %rax, %r14
pushq $0x2
popq %rdi
movl %ebx, %esi
callq 0x46414
movq %r14, 0x3140(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58b98(%rip), %rdi     # 0x9f11c
leaq 0x56c0a(%rip), %rsi     # 0x9d195
leaq 0x59288(%rip), %rcx     # 0x9f81a
movl $0x26c9, %edx           # imm = 0x26C9
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogButtons()
void ImGui::LogButtons()
{
    ImGuiContext& g = *GImGui;

    PushID("LogButtons");
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
    const bool log_to_tty = Button("Log To TTY"); SameLine();
#else
    const bool log_to_tty = false;
#endif
    const bool log_to_file = Button("Log To File"); SameLine();
    const bool log_to_clipboard = Button("Log To Clipboard"); SameLine();
    PushAllowKeyboardFocus(false);
    SetNextItemWidth(80.0f);
    SliderInt("Default Depth", &g.LogDepthToExpandDefault, 0, 9, NULL);
    PopAllowKeyboardFocus();
    PopID();

    // Start logging at the end of the function so that the buttons don't appear in the log
    if (log_to_tty)
        LogToTTY();
    if (log_to_file)
        LogToFile();
    if (log_to_clipboard)
        LogToClipboard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x3168, %ebx           # imm = 0x3168
addq 0x9d6e3(%rip), %rbx     # 0xe3ce0
leaq 0x59257(%rip), %rdi     # 0x9f85b
callq 0x42ea4
leaq -0x28(%rbp), %r15
andq $0x0, (%r15)
leaq 0x5924e(%rip), %rdi     # 0x9f866
movq %r15, %rsi
callq 0x7a64b
movl %eax, %r14d
movss 0x559c5(%rip), %xmm1    # 0x9bff0
xorps %xmm0, %xmm0
callq 0x437ec
andq $0x0, (%r15)
leaq 0x59233(%rip), %rdi     # 0x9f871
leaq -0x28(%rbp), %r12
movq %r12, %rsi
callq 0x7a64b
movl %eax, %r15d
xorps %xmm0, %xmm0
movss 0x55998(%rip), %xmm1    # 0x9bff0
callq 0x437ec
andq $0x0, (%r12)
leaq 0x59214(%rip), %rdi     # 0x9f87d
leaq -0x28(%rbp), %rsi
callq 0x7a64b
movl %eax, %r12d
xorps %xmm0, %xmm0
movss 0x55970(%rip), %xmm1    # 0x9bff0
callq 0x437ec
xorl %edi, %edi
callq 0x424d1
movq 0x9d64d(%rip), %rax     # 0xe3ce0
orl $0x1, 0x1bf8(%rax)
movl $0x42a00000, 0x1bfc(%rax) # imm = 0x42A00000
leaq 0x591e3(%rip), %rdi     # 0x9f88e
pushq $0x9
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x804c2
callq 0x4246f
callq 0x42fea
testb %r14b, %r14b
je 0x466d5
pushq $-0x1
popq %rdi
callq 0x464df
testb %r15b, %r15b
je 0x466e4
pushq $-0x1
popq %rdi
xorl %esi, %esi
callq 0x46517
testb %r12b, %r12b
je 0x466f1
pushq $-0x1
popq %rdi
callq 0x4659c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d5a2(%rip), %r14     # 0xe3ce0
leaq 0x59157(%rip), %rsi     # 0x9f89c
callq 0xc440
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0xc380
movq %rax, %r15
leaq 0x11(%rax), %rsi
movq %r14, %rdi
callq 0x4ba02
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3479a
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_O2/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
movl %edi, %ebx
movq 0x9d52f(%rip), %r14     # 0xe3ce0
movq 0x3110(%r14), %rcx
addq $0x3108, %r14           # imm = 0x3108
leaq 0x4(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
testq %rax, %rax
je 0x467e0
cmpl %ebx, (%rax)
je 0x467e0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ba3e
jmp 0x467ca
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x30f8, %ebx           # imm = 0x30F8
addq 0x9d4b2(%rip), %rbx     # 0xe3ce0
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3479a
movl %eax, %r15d
cmpl (%rbx), %r14d
jge 0x46858
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4baa6
cmpl %r15d, 0x8(%rax)
je 0x46865
incl %r14d
jmp 0x4683d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4baa6
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq 0x9d454(%rip), %rbx     # 0xe3ce0
leaq 0x30e8(%rbx), %rdi
callq 0x4b1ac
leaq 0x30f8(%rbx), %r14
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x468e1
movq %r14, %rdi
movl %r15d, %esi
callq 0x4baa6
cmpq $0x0, 0x10(%rax)
je 0x468dc
movq %r14, %rdi
movl %r15d, %esi
callq 0x4baa6
movq 0x10(%rax), %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0x4baa6
movq %rbx, %rdi
movq %rax, %rsi
callq *%r12
incl %r15d
jmp 0x468a2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdx)
leaq 0x58fa1(%rip), %rsi     # 0x9f8a0
xorl %ecx, %ecx
callq 0x348c2
testq %rax, %rax
je 0x46922
movq %rax, %rbx
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x46929
movq %rbx, %rdi
callq 0x344ad
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d13d(%rip), %rbx     # 0xe3ce0
andl $0x0, 0x30e4(%rbx)
leaq 0x30e8(%rbx), %r15
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x49cb6
leaq -0x29(%rbp), %rsi
movb $0x0, (%rsi)
movq %r15, %rdi
callq 0x4badc
leaq 0x30f8(%rbx), %r13
cmpl (%r13), %r12d
jge 0x46bf6
movq %r13, %rdi
movl %r12d, %esi
callq 0x4baa6
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq *0x38(%rax)
incl %r12d
jmp 0x46bd4
testq %r14, %r14
je 0x46c0b
movl (%r15), %eax
xorl %ecx, %ecx
subl $0x1, %eax
cmovbl %ecx, %eax
cltq
movq %rax, (%r14)
movq 0x30f0(%rbx), %rcx
testq %rcx, %rcx
leaq 0x9d0cc(%rip), %rax     # 0xe3ce8
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_O2/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:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7, %esi
ja 0x47dfb
movl %esi, %eax
leaq 0x54c96(%rip), %rcx     # 0x9c9ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4b560
jmp 0x47df9
movsd 0x238(%rdi), %xmm0
movsd 0x240(%rdi), %xmm1
jmp 0x47df9
movsd 0x218(%rdi), %xmm0
movsd 0x220(%rdi), %xmm1
jmp 0x47df9
movsd 0x228(%rdi), %xmm0
movsd 0x230(%rdi), %xmm1
jmp 0x47df9
movsd 0x268(%rdi), %xmm0
movsd 0x270(%rdi), %xmm1
jmp 0x47df9
movsd 0x208(%rdi), %xmm0
movsd 0x210(%rdi), %xmm1
jmp 0x47df9
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 0x47df6
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]
popq %rbp
retq
leaq 0x5731a(%rip), %rdi     # 0x9f11c
leaq 0x5538c(%rip), %rsi     # 0x9d195
leaq 0x5983f(%rip), %rcx     # 0xa164f
movl $0x2963, %edx           # imm = 0x2963
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b72f(%rip), %rsi     # 0xa373b
movq %rdx, %rdi
xorl %eax, %eax
callq 0x88825
testb %al, %al
je 0x48079
leaq 0x585d6(%rip), %rdi     # 0xa05f7
xorl %eax, %eax
callq 0x795ac
movl (%rbx), %r14d
leaq 0x593a8(%rip), %r15     # 0xa13da
testl %r14d, %r14d
jle 0x4806a
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4ad62
movq (%rax), %rdi
callq 0x42f1f
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4ad62
movq (%rax), %rdi
movq %r15, %rsi
callq 0x48c69
callq 0x42fea
jmp 0x48032
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x89637
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x57764(%rip), %rsi     # 0xa0054
xorl %r14d, %r14d
movl %edi, %edx
xorl %eax, %eax
callq 0x88935
testb %al, %al
je 0x48993
movss 0x14(%rbx), %xmm1
movss 0x18(%rbx), %xmm0
cvtss2sd %xmm0, %xmm2
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0x5775c(%rip), %rdi     # 0xa0081
movb $0x3, %al
callq 0x79bb3
leaq 0x60(%rbx), %r15
leaq 0x5776f(%rip), %r12     # 0xa00a6
cmpl (%r15), %r14d
jge 0x48982
movq %r15, %rdi
movl %r14d, %esi
callq 0x4bb92
cvtss2sd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r15, %rdi
movl %r14d, %esi
callq 0x4bb92
movss (%rax), %xmm0
movq %rbx, %rdi
callq 0x775ab
cvtss2sd %xmm0, %xmm1
movq %r12, %rdi
movl %r14d, %esi
movsd -0x28(%rbp), %xmm0
movb $0x2, %al
callq 0x79bb3
incl %r14d
jmp 0x48937
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x89637
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
movl %ecx, %r8d
shll $0x4, %r8d
leaq 0x576ab(%rip), %rsi     # 0xa02be
movq %rdx, %rdi
xorl %eax, %eax
callq 0x88825
testb %al, %al
je 0x48c5e
leaq 0x576af(%rip), %r14     # 0xa02d7
xorl %r15d, %r15d
cmpl (%rbx), %r15d
jge 0x48c4f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x49b16
movl (%rax), %esi
movl 0x8(%rax), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x79bb3
incl %r15d
jmp 0x48c2b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x89637
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: StartLockWheelingWindow(ImGuiWindow*)
static void StartLockWheelingWindow(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    if (g.WheelingWindow == window)
        return;
    g.WheelingWindow = window;
    g.WheelingWindowRefMousePos = g.IO.MousePos;
    g.WheelingWindowTimer = WINDOWS_MOUSE_WHEEL_SCROLL_LOCK_TIMER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x9ac02(%rip), %rax     # 0xe3ce0
cmpq %rdi, 0x1b08(%rax)
je 0x49106
movq %rdi, 0x1b08(%rax)
movq 0x128(%rax), %rcx
movq %rcx, 0x1b10(%rax)
movl $0x40000000, 0x1b18(%rax) # imm = 0x40000000
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4914a
movl $0x2000000, %eax        # imm = 0x2000000
andl %eax, %esi
andl %eax, %edi
subl %edi, %esi
movl %esi, %eax
jne 0x4914a
movswl 0x9c(%rcx), %eax
movswl 0x9c(%rdx), %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9ab7d(%rip), %rax     # 0xe3ce0
incl 0x3ac(%rax)
movq 0x2b8(%rsi), %rsi
callq 0x3fea6
addq $0x198, %rbx            # imm = 0x198
xorl %r15d, %r15d
cmpl (%rbx), %r15d
jge 0x491b1
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4ad62
movq (%rax), %rsi
cmpb $0x1, 0x8e(%rsi)
jne 0x491ac
cmpb $0x0, 0x95(%rsi)
jne 0x491ac
movq %r14, %rdi
callq 0x4914c
incl %r15d
jmp 0x4917f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ApplyWindowSettings(ImGuiWindow*, ImGuiWindowSettings*)
static void ApplyWindowSettings(ImGuiWindow* window, ImGuiWindowSettings* settings)
{
    window->Pos = ImFloor(ImVec2(settings->Pos.x, settings->Pos.y));
    if (settings->Size.x > 0 && settings->Size.y > 0)
        window->Size = window->SizeFull = ImFloor(ImVec2(settings->Size.x, settings->Size.y));
    window->Collapsed = settings->Collapsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movswl 0x4(%rsi), %eax
cvtsi2ss %eax, %xmm0
movswl 0x6(%rsi), %eax
cvtsi2ss %eax, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x10(%rdi)
movzwl 0x8(%rsi), %eax
testw %ax, %ax
jle 0x491ff
movzwl 0xa(%rsi), %ecx
testw %cx, %cx
jle 0x491ff
cwtl
cvtsi2ss %eax, %xmm0
movswl %cx, %eax
cvtsi2ss %eax, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movups %xmm0, 0x18(%rdi)
movb 0xc(%rsi), %al
movb %al, 0x91(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
leaq 0x10(%rdi), %rsi
movq %r13, %rdi
callq 0x4920a
movaps %xmm0, %xmm2
movaps %xmm0, %xmm5
movaps %xmm0, -0x70(%rbp)
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
movss 0x10(%r12), %xmm0
movss 0x14(%r12), %xmm1
addss 0x18(%r12), %xmm0
addss 0x1c(%r12), %xmm1
movss (%r13), %xmm4
movss 0x4(%r13), %xmm3
subss %xmm0, %xmm4
mulss (%r15), %xmm4
addss %xmm0, %xmm4
subss %xmm1, %xmm3
mulss 0x4(%r15), %xmm3
addss %xmm1, %xmm3
subss %xmm5, %xmm4
movaps %xmm2, -0x60(%rbp)
subss %xmm2, %xmm3
movaps %xmm4, -0x40(%rbp)
movaps %xmm4, %xmm0
movaps %xmm3, -0x50(%rbp)
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movq %r12, %rdi
callq 0x41618
movaps -0x70(%rbp), %xmm3
movlps %xmm3, (%r14)
movss (%r15), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jne 0x49305
jp 0x49305
movaps %xmm0, %xmm2
subss -0x40(%rbp), %xmm2
subss %xmm2, %xmm3
movss %xmm3, (%r14)
movss 0x4(%r15), %xmm2
ucomiss %xmm1, %xmm2
jne 0x4932c
jp 0x4932c
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
subss -0x50(%rbp), %xmm1
movaps -0x60(%rbp), %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x4(%r14)
movlps %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movss %xmm1, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, %ebx
callq 0x4b560
movss -0x10(%rbp), %xmm4
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm4
jne 0x49381
jp 0x49381
movss 0x52c84(%rip), %xmm2    # 0x9bff0
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movaps %xmm3, %xmm1
cmpl $0x3, %ebx
ja 0x4942c
movl %ebx, %eax
leaq 0x5366d(%rip), %rcx     # 0x9ca00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movaps %xmm0, %xmm2
movss -0xc(%rbp), %xmm5
addss %xmm5, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
jmp 0x493c1
movss -0xc(%rbp), %xmm5
addss %xmm5, %xmm0
movaps %xmm0, %xmm2
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
movaps %xmm0, %xmm3
subss %xmm4, %xmm3
subss %xmm5, %xmm1
addss %xmm4, %xmm0
jmp 0x4941c
movaps %xmm0, %xmm2
subss %xmm4, %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss -0xc(%rbp), %xmm5
addss %xmm5, %xmm3
addss %xmm0, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
jmp 0x49412
movaps %xmm1, %xmm2
subss %xmm4, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss -0xc(%rbp), %xmm5
addss %xmm5, %xmm0
addss %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movaps %xmm0, %xmm3
movaps %xmm1, %xmm0
subss %xmm5, %xmm0
movaps %xmm4, %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movaps %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x55ce9(%rip), %rdi     # 0x9f11c
leaq 0x53d5b(%rip), %rsi     # 0x9d195
leaq 0x575b7(%rip), %rcx     # 0xa09f8
movl $0x1438, %edx           # imm = 0x1438
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9a4a9(%rip), %rdx     # 0xe3ce0
movl %edi, 0x1cdc(%rdx)
movq 0x1c90(%rdx), %rdi
testl %eax, %eax
je 0x49853
movl $0x1, %esi
popq %rbp
jmp 0x40a13
movq 0x3a8(%rdi), %rcx
testq %rcx, %rcx
je 0x49868
cmpb $0x0, 0x8f(%rcx)
jne 0x4986b
movq %rdi, %rcx
movq %rcx, 0x1c90(%rdx)
movl 0x3b0(%rcx), %edi
testl %edi, %edi
je 0x4988d
addq $0x3b8, %rcx            # imm = 0x3B8
xorl %esi, %esi
xorl %edx, %edx
popq %rbp
jmp 0x4547a
movq %rcx, %rdi
jmp 0x49848
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r13d
movl %edi, %r14d
movl $0x1a98, %r12d          # imm = 0x1A98
addq 0x9a42a(%rip), %r12     # 0xe3ce0
xorl %ebx, %ebx
testl %r14d, %r14d
js 0x498f2
cmpl %r14d, %r13d
je 0x498f2
cmpl (%r12), %r14d
jge 0x498f2
movq %r12, %rdi
movl %r14d, %esi
callq 0x4ad62
movq (%rax), %rdi
callq 0x42754
testb %al, %al
jne 0x498e4
addl %r15d, %r14d
jmp 0x498b8
movq %r12, %rdi
movl %r14d, %esi
callq 0x4ad62
movq (%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edi, %ebx
movq 0x9a3c9(%rip), %r15     # 0xe3ce0
movq 0x1dc0(%r15), %rdi
testq %rdi, %rdi
je 0x49985
testb $0x8, 0xf(%rdi)
jne 0x4997a
callq 0x422d0
movl %eax, %r14d
leal (%r14,%rbx), %edi
movl $0x80000001, %esi       # imm = 0x80000001
movl %ebx, %edx
callq 0x49892
testq %rax, %rax
jne 0x49964
xorl %edi, %edi
testl %ebx, %ebx
jns 0x49955
movl 0x1a98(%r15), %edi
decl %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x49892
testq %rax, %rax
je 0x49972
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 0x57a77(%rip), %rdi     # 0xa1403
leaq 0x53802(%rip), %rsi     # 0x9d195
leaq 0x57a7e(%rip), %rcx     # 0xa1418
movl $0x2459, %edx           # imm = 0x2459
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4e57f(%rip), %rdi     # 0xa164b
xorl %eax, %eax
callq 0x79774
xorl %edi, %edi
callq 0x374fd
testb %al, %al
je 0x5310f
callq 0x44503
callq 0x42b2e
mulss 0x49844(%rip), %xmm0    # 0x9c934
callq 0x4250d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7959d
callq 0x4254c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4463b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x808f9(%rip), %rsi     # 0xdf530
leaq 0x437de(%rip), %rdx     # 0xa241c
pushq $-0x1
popq %rcx
callq 0x7dd48
movl %eax, %ebx
testb %al, %al
je 0x5ec79
movl 0x808de(%rip), %eax     # 0xdf530
cmpl $0x2, %eax
je 0x5ec72
cmpl $0x1, %eax
je 0x5ec69
testl %eax, %eax
jne 0x5ec79
xorl %edi, %edi
callq 0x611d0
jmp 0x5ec79
xorl %edi, %edi
callq 0x618d2
jmp 0x5ec79
xorl %edi, %edi
callq 0x61579
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq