LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0x91984(%rip), %rsi     # 0x176094
movb $0x0, %al
callq 0x150f40
testb $0x1, %al
jne 0xe4720
jmp 0xe47e6
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x14(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0x9196a(%rip), %rdi     # 0x1760c1
movb $0x3, %al
callq 0x139ab0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0xe47e1
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
callq 0xec8a0
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
callq 0xec8a0
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
callq 0x135310
movl -0x1c(%rbp), %esi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
cvtss2sd %xmm1, %xmm1
leaq 0x91917(%rip), %rdi     # 0x1760e6
movb $0x2, %al
callq 0x139ab0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe4765
callq 0x1523d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0xecae0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl %eax, %r8d
leaq 0x917a7(%rip), %rsi     # 0x1762fe
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe4b64
jmp 0xe4bb1
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xe4bac
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xe8150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x9177d(%rip), %rdi     # 0x176317
movb $0x0, %al
callq 0x139ab0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe4b6b
callq 0x1523d0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rdi, -0x8(%rbp)
movq 0x12dc11(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b08(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xe5346
jmp 0xe537f
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b08(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x128(%rcx), %rcx
movq %rcx, 0x1b10(%rax)
movq -0x10(%rbp), %rax
movss 0x8cc55(%rip), %xmm0    # 0x171fcc
movss %xmm0, 0x1b18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
andl $0x4000000, %ecx        # imm = 0x4000000
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xe54ae
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe54f5
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000000, %eax        # imm = 0x2000000
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
andl $0x2000000, %ecx        # imm = 0x2000000
subl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xe54da
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe54f5
movq -0x20(%rbp), %rax
movswl 0x9c(%rax), %eax
movq -0x28(%rbp), %rcx
movswl 0x9c(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x12da29(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x3ac(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3ac(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x2b8(%rax), %rsi
callq 0xd45d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x198(%rcx), %eax
jge 0xe55a2
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
addq $0xc0, %rdi
movl -0x1c(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd4750
testb $0x1, %al
jne 0xe5588
jmp 0xe5595
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe5500
jmp 0xe5597
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe5549
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movswl 0x6(%rax), %eax
cvtsi2ss %eax, %xmm1
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xbf4c0
movq -0x38(%rbp), %rdi
callq 0xc2f10
movlpd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %eax
cmpl $0x0, %eax
jle 0xe565c
movq -0x10(%rbp), %rax
movswl 0xa(%rax), %eax
cmpl $0x0, %eax
jle 0xe565c
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movswl 0xa(%rax), %eax
cvtsi2ss %eax, %xmm1
leaq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xbf4c0
movq -0x40(%rbp), %rdi
callq 0xc2f10
movlpd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, 0x20(%rcx)
movq -0x8(%rbp), %rax
movq 0x20(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movb 0xc(%rax), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x91(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
callq 0xe5680
movlpd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, %rdi
addq $0x10, %rdi
addq $0x18, %rsi
callq 0xc41b0
movlpd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xe5680
movlpd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc3c00
movlpd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
callq 0xd6ac0
movlpd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe57b9
jp 0xe57b9
movss -0x50(%rbp), %xmm1
subss -0x48(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe57e8
jp 0xe57e8
movss -0x4c(%rbp), %xmm1
subss -0x44(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movss %xmm1, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xeb880
movlpd %xmm0, -0x34(%rbp)
movlpd %xmm1, -0x2c(%rbp)
movss -0x24(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe5860
jp 0xe5860
leaq -0x3c(%rbp), %rdi
movss 0x8b3f5(%rip), %xmm1    # 0x170c3c
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x34(%rbp), %rdi
addq $0x8, %rdi
leaq -0x3c(%rbp), %rsi
callq 0xe5980
cmpl $0x0, -0x1c(%rbp)
jne 0xe589c
movss -0x34(%rbp), %xmm0
addss -0x20(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
subss -0x24(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
subss -0x20(%rbp), %xmm2
movss -0x30(%rbp), %xmm3
addss -0x24(%rbp), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
jmp 0xe5969
cmpl $0x1, -0x1c(%rbp)
jne 0xe58d8
movss -0x2c(%rbp), %xmm0
subss -0x24(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addss -0x20(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
addss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
subss -0x20(%rbp), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
jmp 0xe5969
cmpl $0x2, -0x1c(%rbp)
jne 0xe5911
movss -0x34(%rbp), %xmm0
addss -0x20(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
subss -0x24(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
subss -0x20(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
addss -0x24(%rbp), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
jmp 0xe5969
cmpl $0x3, -0x1c(%rbp)
jne 0xe594a
movss -0x34(%rbp), %xmm0
subss -0x24(%rbp), %xmm0
movss -0x30(%rbp), %xmm1
addss -0x20(%rbp), %xmm1
movss -0x34(%rbp), %xmm2
addss -0x24(%rbp), %xmm2
movss -0x28(%rbp), %xmm3
subss -0x20(%rbp), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
jmp 0xe5969
leaq 0x8f7b9(%rip), %rdi     # 0x17510a
leaq 0x8d5b1(%rip), %rsi     # 0x172f09
movl $0x1438, %edx           # imm = 0x1438
leaq 0x9114f(%rip), %rcx     # 0x176ab3
callq 0xd180
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: GetWindowBgColorIdxFromFlags(int)
static ImGuiCol GetWindowBgColorIdxFromFlags(ImGuiWindowFlags flags)
{
    if (flags & (ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_Popup))
        return ImGuiCol_PopupBg;
    if (flags & ImGuiWindowFlags_ChildWindow)
        return ImGuiCol_ChildBg;
    return ImGuiCol_WindowBg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x6000000, %eax        # imm = 0x6000000
cmpl $0x0, %eax
je 0xe59ed
movl $0x4, -0x4(%rbp)
jmp 0xe5a0a
movl -0x8(%rbp), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0xe5a03
movl $0x3, -0x4(%rbp)
jmp 0xe5a0a
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: CalcScrollEdgeSnap(float, float, float, float, float)
static float CalcScrollEdgeSnap(float target, float snap_min, float snap_max, float snap_threshold, float center_ratio)
{
    if (target <= snap_min + snap_threshold)
        return ImLerp(snap_min, target, center_ratio);
    if (target >= snap_max - snap_threshold)
        return ImLerp(target, snap_max, center_ratio);
    return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
movss %xmm3, -0x14(%rbp)
movss %xmm4, -0x18(%rbp)
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0xe5e60
movss -0xc(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
movss -0x18(%rbp), %xmm2
callq 0xddb10
movss %xmm0, -0x4(%rbp)
jmp 0xe5e99
movss -0x8(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
subss -0x14(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0xe5e8f
movss -0x8(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
movss -0x18(%rbp), %xmm2
callq 0xddb10
movss %xmm0, -0x4(%rbp)
jmp 0xe5e99
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavApplyItemToResult(ImGuiNavMoveResult*, ImGuiWindow*, unsigned int, ImRect const&)
static void ImGui::NavApplyItemToResult(ImGuiNavMoveResult* result, ImGuiWindow* window, ImGuiID id, const ImRect& nav_bb_rel)
{
    result->Window = window;
    result->ID = id;
    result->FocusScopeId = window->DC.NavFocusScopeIdCurrent;
    result->RectRel = nav_bb_rel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x158(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x1c(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x24(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: NavClampRectToVisibleAreaForMoveDir(int, ImRect&, ImRect const&)
static void inline NavClampRectToVisibleAreaForMoveDir(ImGuiDir move_dir, ImRect& r, const ImRect& clip_rect)
{
    if (move_dir == ImGuiDir_Left || move_dir == ImGuiDir_Right)
    {
        r.Min.y = ImClamp(r.Min.y, clip_rect.Min.y, clip_rect.Max.y);
        r.Max.y = ImClamp(r.Max.y, clip_rect.Min.y, clip_rect.Max.y);
    }
    else
    {
        r.Min.x = ImClamp(r.Min.x, clip_rect.Min.x, clip_rect.Max.x);
        r.Max.x = ImClamp(r.Max.x, clip_rect.Min.x, clip_rect.Max.x);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xe64bf
cmpl $0x1, -0x4(%rbp)
jne 0xe6513
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm2
callq 0xe5390
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm2
callq 0xe5390
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
jmp 0xe6561
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
callq 0xe5390
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
callq 0xe5390
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: NavScoreItemDistInterval(float, float, float, float)
static float inline NavScoreItemDistInterval(float a0, float a1, float b0, float b1)
{
    if (a1 < b0)
        return a1 - b0;
    if (b1 < a0)
        return a0 - b1;
    return 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
movss %xmm3, -0x14(%rbp)
movss -0xc(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xe65a8
movss -0xc(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xe65d0
movss -0x14(%rbp), %xmm1
movss -0x8(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xe65c8
movss -0x8(%rbp), %xmm0
subss -0x14(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xe65d0
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavUpdateInitResult()
static void ImGui::NavUpdateInitResult()
{
    // In very rare cases g.NavWindow may be null (e.g. clearing focus after requesting an init request, which does happen when releasing Alt while clicking on void)
    ImGuiContext& g = *GImGui;
    if (!g.NavWindow)
        return;

    // Apply result from previous navigation init request (will typically select the first item, unless SetItemDefaultFocus() has been called)
    IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: result NavID 0x%08X in Layer %d Window \"%s\"\n", g.NavInitResultId, g.NavLayer, g.NavWindow->Name);
    if (g.NavInitRequestFromMove)
        SetNavIDWithRectRel(g.NavInitResultId, g.NavLayer, 0, g.NavInitResultRectRel);
    else
        SetNavID(g.NavInitResultId, g.NavLayer, 0);
    g.NavWindow->NavRectRel[g.NavLayer] = g.NavInitResultRectRel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x12c951(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
jne 0xe6606
jmp 0xe6691
movq -0x8(%rbp), %rax
testb $0x1, 0x1cea(%rax)
je 0xe663b
movq -0x8(%rbp), %rax
movl 0x1cec(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x1cdc(%rax), %esi
movq -0x8(%rbp), %rcx
addq $0x1cf0, %rcx           # imm = 0x1CF0
xorl %edx, %edx
callq 0xdf3d0
jmp 0xe6656
movq -0x8(%rbp), %rax
movl 0x1cec(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x1cdc(%rax), %esi
xorl %edx, %edx
callq 0xdf300
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rax
addq $0x3b8, %rax            # imm = 0x3B8
movq -0x8(%rbp), %rdx
movl 0x1cdc(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x1cf0(%rcx), %rdx
movq %rdx, (%rax)
movq 0x1cf8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavSaveLastChildNavWindowIntoParent(ImGuiWindow*)
static void ImGui::NavSaveLastChildNavWindowIntoParent(ImGuiWindow* nav_window)
{
    ImGuiWindow* parent = nav_window;
    while (parent && (parent->Flags & ImGuiWindowFlags_ChildWindow) != 0 && (parent->Flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_ChildMenu)) == 0)
        parent = parent->ParentWindow;
    if (parent && parent != nav_window)
        parent->NavLastChildNavWindow = nav_window;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0xe6a68
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
andl $0x1000000, %ecx        # imm = 0x1000000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xe6a68
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x14000000, %eax       # imm = 0x14000000
cmpl $0x0, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xe6a71
jmp 0xe6a82
movq -0x10(%rbp), %rax
movq 0x388(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xe6a30
cmpq $0x0, -0x10(%rbp)
je 0xe6aa2
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xe6aa2
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3a8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x12bb5e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1cdc(%rax)
cmpl $0x0, -0x4(%rbp)
jne 0xe7417
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rdi
callq 0xd9fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1c90(%rax)
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xe745a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x3b0(%rax)
je 0xe745a
movq -0x18(%rbp), %rax
movl 0x3b0(%rax), %edi
movl -0x4(%rbp), %esi
movq -0x18(%rbp), %rcx
addq $0x3b8, %rcx            # imm = 0x3B8
xorl %edx, %edx
callq 0xdf3d0
jmp 0xe7468
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xd5b90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x12b5e8(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x25(%rbp)
jl 0xe798d
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rdx
xorl %eax, %eax
cmpl 0x1a98(%rdx), %ecx
movb %al, -0x25(%rbp)
jge 0xe798d
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xe7996
jmp 0xe79e0
movq -0x20(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x24(%rbp), %esi
callq 0xea8d0
movq (%rax), %rdi
callq 0xda6d0
testb $0x1, %al
jne 0xe79b7
jmp 0xe79d3
movq -0x20(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x24(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe79e8
jmp 0xe79d5
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xe7962
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x12b52e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1dc0(%rax)
je 0xe7a26
jmp 0xe7a45
leaq 0x8fd3b(%rip), %rdi     # 0x177768
leaq 0x8b4d5(%rip), %rsi     # 0x172f09
movl $0x2459, %edx           # imm = 0x2459
leaq 0x8fd3d(%rip), %rcx     # 0x17777d
callq 0xd180
movq -0x10(%rbp), %rax
movq 0x1dc0(%rax), %rax
movl 0xc(%rax), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
je 0xe7a62
jmp 0xe7af0
movq -0x10(%rbp), %rax
movq 0x1dc0(%rax), %rdi
callq 0xd9f30
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
addl -0x4(%rbp), %edi
movl -0x4(%rbp), %edx
movl $0x80000001, %esi       # imm = 0x80000001
callq 0xe7940
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe7ac4
cmpl $0x0, -0x4(%rbp)
jge 0xe7aab
movq -0x10(%rbp), %rax
movl 0x1a98(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe7ab2
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xe7ab2
movl -0x24(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0xe7940
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe7ae5
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1dc8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x1dc0(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1de0(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: GetFallbackWindowNameForWindowingList(ImGuiWindow*)
static const char* GetFallbackWindowNameForWindowingList(ImGuiWindow* window)
{
    if (window->Flags & ImGuiWindowFlags_Popup)
        return "(Popup)";
    if ((window->Flags & ImGuiWindowFlags_MenuBar) && strcmp(window->Name, "##MainMenuBar") == 0)
        return "(Main menu bar)";
    return "(Untitled)";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
je 0xe7d8a
leaq 0x8faaa(%rip), %rax     # 0x17782e
movq %rax, -0x8(%rbp)
jmp 0xe7dcb
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0xe7dc0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x8fa8d(%rip), %rsi     # 0x177836
callq 0xd7e0
cmpl $0x0, %eax
jne 0xe7dc0
leaq 0x8fa8a(%rip), %rax     # 0x177844
movq %rax, -0x8(%rbp)
jmp 0xe7dcb
leaq 0x8fa8d(%rip), %rax     # 0x177854
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_internal.h
// Function: ImGuiMetricsConfig::ImGuiMetricsConfig()
ImGuiMetricsConfig()
    {
        ShowWindowsRects = false;
        ShowWindowsBeginOrder = false;
        ShowTablesRects = false;
        ShowDrawCmdMesh = true;
        ShowDrawCmdBoundingBoxes = true;
        ShowWindowsRectsType = -1;
        ShowTablesRectsType = -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, 0x1(%rax)
movb $0x0, 0x2(%rax)
movb $0x1, 0x3(%rax)
movb $0x1, 0x4(%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowExampleAppMainMenuBar()
static void ShowExampleAppMainMenuBar()
{
    if (ImGui::BeginMainMenuBar())
    {
        if (ImGui::BeginMenu("File"))
        {
            ShowExampleMenuFile();
            ImGui::EndMenu();
        }
        if (ImGui::BeginMenu("Edit"))
        {
            if (ImGui::MenuItem("Undo", "CTRL+Z")) {}
            if (ImGui::MenuItem("Redo", "CTRL+Y", false, false)) {}  // Disabled item
            ImGui::Separator();
            if (ImGui::MenuItem("Cut", "CTRL+X")) {}
            if (ImGui::MenuItem("Copy", "CTRL+C")) {}
            if (ImGui::MenuItem("Paste", "CTRL+V")) {}
            ImGui::EndMenu();
        }
        ImGui::EndMainMenuBar();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1545a0
testb $0x1, %al
jne 0xf0992
jmp 0xf0a83
leaq 0x84f1f(%rip), %rdi     # 0x1758b8
movl $0x1, %esi
callq 0x154790
testb $0x1, %al
jne 0xf09a9
jmp 0xf09b3
callq 0xf5e80
callq 0x1552c0
leaq 0x8b20c(%rip), %rdi     # 0x17bbc6
movl $0x1, %esi
callq 0x154790
testb $0x1, %al
jne 0xf09cd
jmp 0xf0a7e
leaq 0x91e72(%rip), %rdi     # 0x182846
leaq 0x91e70(%rip), %rsi     # 0x18284b
xorl %edx, %edx
movl $0x1, %ecx
callq 0x155360
testb $0x1, %al
jne 0xf09ed
jmp 0xf09ef
jmp 0xf09ef
leaq 0x91e5c(%rip), %rdi     # 0x182852
leaq 0x91e5a(%rip), %rsi     # 0x182857
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x155360
testb $0x1, %al
jne 0xf0a0c
jmp 0xf0a0e
jmp 0xf0a0e
callq 0x13dec0
leaq 0x91e44(%rip), %rdi     # 0x18285e
leaq 0x91e41(%rip), %rsi     # 0x182862
xorl %edx, %edx
movl $0x1, %ecx
callq 0x155360
testb $0x1, %al
jne 0xf0a33
jmp 0xf0a35
jmp 0xf0a35
leaq 0x8c697(%rip), %rdi     # 0x17d0d3
leaq 0x91e26(%rip), %rsi     # 0x182869
xorl %edx, %edx
movl $0x1, %ecx
callq 0x155360
testb $0x1, %al
jne 0xf0a55
jmp 0xf0a57
jmp 0xf0a57
leaq 0x91e12(%rip), %rdi     # 0x182870
leaq 0x91e11(%rip), %rsi     # 0x182876
xorl %edx, %edx
movl $0x1, %ecx
callq 0x155360
testb $0x1, %al
jne 0xf0a77
jmp 0xf0a79
jmp 0xf0a79
callq 0x1552c0
callq 0x154720
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowExampleAppPropertyEditor(bool*)
static void ShowExampleAppPropertyEditor(bool* p_open)
{
    ImGui::SetNextWindowSize(ImVec2(430, 450), ImGuiCond_FirstUseEver);
    if (!ImGui::Begin("Example: Property editor", p_open))
    {
        ImGui::End();
        return;
    }

    HelpMarker(
        "This example shows how you may implement a property editor using two columns.\n"
        "All objects/fields data are dummies here.\n"
        "Remember that in many simple cases, you can use ImGui::SameLine(xxx) to position\n"
        "your cursor horizontally instead of using the Columns() API.");

    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(2, 2));
    if (ImGui::BeginTable("split", 2, ImGuiTableFlags_BordersOuter | ImGuiTableFlags_Resizable))
    {
        // Iterate placeholder objects (all the same data)
        for (int obj_i = 0; obj_i < 4; obj_i++)
        {
            ShowPlaceholderObject("Object", obj_i);
            //ImGui::Separator();
        }
        ImGui::EndTable();
    }
    ImGui::PopStyleVar();
    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movss 0x86da4(%rip), %xmm0    # 0x17857c
movss 0x86da0(%rip), %xmm1    # 0x178580
callq 0xbf4c0
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xd00c0
movq -0x8(%rbp), %rsi
leaq 0x91688(%rip), %rdi     # 0x182e86
xorl %edx, %edx
callq 0xd0170
testb $0x1, %al
jne 0xf1813
callq 0xd3b60
jmp 0xf18ae
leaq 0x91685(%rip), %rdi     # 0x182e9f
callq 0xf6290
leaq -0x18(%rbp), %rdi
movss 0x807a1(%rip), %xmm1    # 0x171fcc
movaps %xmm1, %xmm0
callq 0xbf4c0
movl $0xa, %edi
leaq -0x18(%rbp), %rsi
callq 0xc7b50
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq 0x87ff4(%rip), %rdi     # 0x17984b
movl $0x2, %esi
movl $0x501, %edx            # imm = 0x501
leaq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
callq 0x129500
testb $0x1, %al
jne 0xf1873
jmp 0xf189f
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0xf189a
movl -0x24(%rbp), %esi
leaq 0x9171b(%rip), %rdi     # 0x182fa5
callq 0x108c90
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf187a
callq 0x12dc40
movl $0x1, %edi
callq 0xc7c10
callq 0xd3b60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowExampleAppAutoResize(bool*)
static void ShowExampleAppAutoResize(bool* p_open)
{
    if (!ImGui::Begin("Example: Auto-resizing window", p_open, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::End();
        return;
    }

    static int lines = 10;
    ImGui::TextUnformatted(
        "Window will resize every-frame to the size of its content.\n"
        "Note that you probably don't want to query the window size to\n"
        "output your content because that would create a feedback loop.");
    ImGui::SliderInt("Number of lines", &lines, 1, 20);
    for (int i = 0; i < lines; i++)
        ImGui::Text("%*sThis is line %d", i * 4, "", i); // Pad with space to extend size horizontally
    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x91443(%rip), %rdi     # 0x1830ba
movl $0x40, %edx
callq 0xd0170
testb $0x1, %al
jne 0xf1c8c
callq 0xd3b60
jmp 0xf1d03
leaq 0x91445(%rip), %rdi     # 0x1830d8
xorl %eax, %eax
movl %eax, %esi
callq 0x139130
leaq 0x914ed(%rip), %rdi     # 0x183190
leaq 0x120fb6(%rip), %rsi    # 0x212c60
movl $0x1, %edx
movl $0x14, %ecx
leaq 0x87d0c(%rip), %r8      # 0x1799c7
xorl %r9d, %r9d
callq 0x144b30
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x120f8d(%rip), %eax    # 0x212c60
jge 0xf1cfe
movl -0xc(%rbp), %esi
shll $0x2, %esi
movl -0xc(%rbp), %ecx
leaq 0x914bb(%rip), %rdi     # 0x1831a0
leaq 0x8021d(%rip), %rdx     # 0x171f09
movb $0x0, %al
callq 0x139160
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf1cca
callq 0xd3b60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowExampleAppWindowTitles(bool*)
static void ShowExampleAppWindowTitles(bool*)
{
    // By default, Windows are uniquely identified by their title.
    // You can use the "##" and "###" markers to manipulate the display/ID.

    // Using "##" to display same title but have unique identifier.
    ImGui::SetNextWindowPos(ImVec2(100, 100), ImGuiCond_FirstUseEver);
    ImGui::Begin("Same title as another window##1");
    ImGui::Text("This is window 1.\nMy title is the same as window 2, but my identifier is unique.");
    ImGui::End();

    ImGui::SetNextWindowPos(ImVec2(100, 200), ImGuiCond_FirstUseEver);
    ImGui::Begin("Same title as another window##2");
    ImGui::Text("This is window 2.\nMy title is the same as window 1, but my identifier is unique.");
    ImGui::End();

    // Using "###" to display a changing title but keep a static identifier "AnimatedTitle"
    char buf[128];
    sprintf(buf, "Animated title %c %d###AnimatedTitle", "|/-\\"[(int)(ImGui::GetTime() / 0.25f) & 3], ImGui::GetFrameCount());
    ImGui::SetNextWindowPos(ImVec2(100, 300), ImGuiCond_FirstUseEver);
    ImGui::Begin(buf);
    ImGui::Text("This window has a changing title.");
    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movss 0x8028d(%rip), %xmm1    # 0x172778
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x18(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
leaq -0x18(%rbp), %rdx
callq 0xdab40
leaq 0x90e84(%rip), %rdi     # 0x18339f
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd0170
leaq 0x90e92(%rip), %rdi     # 0x1833bf
movb $0x0, %al
callq 0x139160
callq 0xd3b60
leaq -0x20(%rbp), %rdi
movss 0x80233(%rip), %xmm0    # 0x172778
movss 0x8603b(%rip), %xmm1    # 0x178588
callq 0xbf4c0
leaq -0x28(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x20(%rbp), %rdi
movl $0x4, %esi
leaq -0x28(%rbp), %rdx
callq 0xdab40
leaq 0x90e96(%rip), %rdi     # 0x183410
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd0170
leaq 0x90ea4(%rip), %rdi     # 0x183430
movb $0x0, %al
callq 0x139160
callq 0xd3b60
leaq -0xb0(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0xcb240
movsd 0x8608d(%rip), %xmm1    # 0x178640
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x90ede(%rip), %rax     # 0x1834a6
movsbl (%rax,%rcx), %eax
movl %eax, -0xc4(%rbp)
callq 0xcb260
movq -0xd0(%rbp), %rdi
movl -0xc4(%rbp), %edx
movl %eax, %ecx
leaq 0x90e94(%rip), %rsi     # 0x183481
movb $0x0, %al
callq 0xd990
leaq -0xb8(%rbp), %rdi
movss 0x80175(%rip), %xmm0    # 0x172778
movss 0x85f85(%rip), %xmm1    # 0x178590
callq 0xbf4c0
leaq -0xc0(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0xb8(%rbp), %rdi
movl $0x4, %esi
leaq -0xc0(%rbp), %rdx
callq 0xdab40
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xd0170
leaq 0x90e58(%rip), %rdi     # 0x1834ab
movb $0x0, %al
callq 0x139160
callq 0xd3b60
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x81754(%rip), %rdi     # 0x1779f7
movb $0x0, %al
callq 0x1393f0
xorl %edi, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xf62b7
jmp 0xf62e9
callq 0xddb50
callq 0xdae90
movss 0x7c517(%rip), %xmm1    # 0x1727e0
mulss %xmm1, %xmm0
callq 0xda2c0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x139130
callq 0xda310
callq 0xddce0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x107969(%rip), %rsi    # 0x20e5e0
leaq 0x71a1e(%rip), %rdx     # 0x17869c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x13fb50
testb $0x1, %al
jne 0x106c8e
jmp 0x106cd6
movl 0x10794c(%rip), %eax    # 0x20e5e0
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x106cb1
jmp 0x106c9d
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x106cbc
jmp 0x106ca7
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x106cc7
jmp 0x106cd0
xorl %eax, %eax
movl %eax, %edi
callq 0x10c3d0
jmp 0x106cd0
xorl %eax, %eax
movl %eax, %edi
callq 0x10de70
jmp 0x106cd0
xorl %eax, %eax
movl %eax, %edi
callq 0x10d190
movb $0x1, -0x1(%rbp)
jmp 0x106cda
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
callq 0xcb1a0
movq %rax, -0x10(%rbp)
callq 0xdae70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x108f80
movq -0x38(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x13e6c0
testb $0x1, %al
jne 0x106d36
jmp 0x106dea
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rcx
cmpl 0x40(%rcx), %eax
jge 0x106de5
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
addq $0x40, %rdi
movl -0x1c(%rbp), %esi
callq 0xede60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdb500
movq -0x28(%rbp), %rdi
callq 0x108f80
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
movb %al, -0x41(%rbp)
leaq -0x30(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
movb -0x41(%rbp), %al
movq -0x40(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
leaq -0x30(%rbp), %rcx
callq 0x13f2b0
testb $0x1, %al
jne 0x106dc3
jmp 0x106dd2
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb0(%rax)
callq 0xdb640
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x106d3d
callq 0x13f0d0
xorps %xmm0, %xmm0
movss 0x6b18b(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq 0x72e81(%rip), %rdi     # 0x179c82
callq 0xf6290
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x40000, (%rax)        # imm = 0x40000
jne 0x1077dc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xeea00
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x107799
jmp 0x1077b8
leaq 0x7631a(%rip), %rdi     # 0x17daba
leaq 0x71455(%rip), %rsi     # 0x178bfc
movl $0x52f, %edx            # imm = 0x52F
leaq 0x76324(%rip), %rcx     # 0x17dad7
callq 0xd180
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0xe84f0
movq -0x10(%rbp), %rdi
callq 0xeea00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowTableColumnsStatusFlags(int)
static void ShowTableColumnsStatusFlags(ImGuiTableColumnFlags flags)
{
    ImGui::CheckboxFlags("_IsEnabled", &flags, ImGuiTableColumnFlags_IsEnabled);
    ImGui::CheckboxFlags("_IsVisible", &flags, ImGuiTableColumnFlags_IsVisible);
    ImGui::CheckboxFlags("_IsSorted", &flags, ImGuiTableColumnFlags_IsSorted);
    ImGui::CheckboxFlags("_IsHovered", &flags, ImGuiTableColumnFlags_IsHovered);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x79d44(%rip), %rdi     # 0x1819f6
leaq -0x4(%rbp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x13cd30
leaq 0x79d3a(%rip), %rdi     # 0x181a01
leaq -0x4(%rbp), %rsi
movl $0x200000, %edx         # imm = 0x200000
callq 0x13cd30
leaq 0x79d30(%rip), %rdi     # 0x181a0c
leaq -0x4(%rbp), %rsi
movl $0x400000, %edx         # imm = 0x400000
callq 0x13cd30
leaq 0x79d25(%rip), %rdi     # 0x181a16
leaq -0x4(%rbp), %rsi
movl $0x800000, %edx         # imm = 0x800000
callq 0x13cd30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)