LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMouseClicked(int, bool)
bool ImGui::IsMouseClicked(ImGuiMouseButton button, bool repeat)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    const float t = g.IO.MouseDownDuration[button];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        // FIXME: 2019/05/03: Our old repeat code was wrong here and led to doubling the repeat rate, which made it an ok rate for repeat on mouse hold.
        int amount = CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate * 0.50f);
        if (amount > 0)
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x13e1c6(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x21(%rbp)
jl 0xd4d93
cmpl $0x5, -0x8(%rbp)
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xd4d9c
jmp 0xd4d9e
jmp 0xd4dbd
leaq 0x9ee40(%rip), %rdi     # 0x173be5
leaq 0x9e15d(%rip), %rsi     # 0x172f09
movl $0x11c5, %edx           # imm = 0x11C5
leaq 0x9eeab(%rip), %rcx     # 0x173c63
callq 0xd180
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0x43c(%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xd4de8
jp 0xd4de8
movb $0x1, -0x1(%rbp)
jmp 0xd4e4d
testb $0x1, -0x9(%rbp)
je 0xd4e49
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x94(%rax), %xmm0
jbe 0xd4e49
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x18(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
movq -0x18(%rbp), %rax
movss 0x94(%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0x9d1ad(%rip), %xmm3    # 0x171fd8
mulss 0x98(%rax), %xmm3
callq 0xd49f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0xd4e47
movb $0x1, -0x1(%rbp)
jmp 0xd4e4d
jmp 0xd4e49
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMouseDragPastThreshold(int, float)
bool ImGui::IsMouseDragPastThreshold(ImGuiMouseButton button, float lock_threshold)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    return g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq 0x13dfe9(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x11(%rbp)
jl 0xd4f70
cmpl $0x5, -0x4(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xd4f79
jmp 0xd4f7b
jmp 0xd4f9a
leaq 0x9ec63(%rip), %rdi     # 0x173be5
leaq 0x9df80(%rip), %rsi     # 0x172f09
movl $0x11e7, %edx           # imm = 0x11E7
leaq 0x9ed62(%rip), %rcx     # 0x173cf7
callq 0xd180
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0xd4fb1
movq -0x10(%rbp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movss 0x48c(%rax,%rcx,4), %xmm0
movss -0x8(%rbp), %xmm1
mulss -0x8(%rbp), %xmm1
ucomiss %xmm1, %xmm0
setae %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMouseDragging(int, float)
bool ImGui::IsMouseDragging(ImGuiMouseButton button, float lock_threshold)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (!g.IO.MouseDown[button])
        return false;
    return IsMouseDragPastThreshold(button, lock_threshold);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq 0x13df49(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
jl 0xd5010
cmpl $0x5, -0x8(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd5019
jmp 0xd501b
jmp 0xd503a
leaq 0x9ebc3(%rip), %rdi     # 0x173be5
leaq 0x9dee0(%rip), %rsi     # 0x172f09
movl $0x11f0, %edx           # imm = 0x11F0
leaq 0x9ed00(%rip), %rcx     # 0x173d35
callq 0xd180
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
testb $0x1, 0x130(%rax,%rcx)
jne 0xd5052
movb $0x0, -0x1(%rbp)
jmp 0xd5064
movl -0x8(%rbp), %edi
movss -0xc(%rbp), %xmm0
callq 0xd4f40
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetMousePosOnOpeningCurrentPopup()
ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup()
{
    ImGuiContext& g = *GImGui;
    if (g.BeginPopupStack.Size > 0)
        return g.OpenPopupStack[g.BeginPopupStack.Size - 1].OpenMousePos;
    return g.IO.MousePos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x13de91(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c80(%rax)
jle 0xd50e7
movq -0x10(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movq -0x10(%rbp), %rax
movl 0x1c80(%rax), %esi
subl $0x1, %esi
callq 0xeb4c0
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xd50f6
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsAnyMouseDown()
bool ImGui::IsAnyMouseDown()
{
    ImGuiContext& g = *GImGui;
    for (int n = 0; n < IM_ARRAYSIZE(g.IO.MouseDown); n++)
        if (g.IO.MouseDown[n])
            return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x13de25(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0xd5151
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, 0x130(%rax,%rcx)
je 0xd5144
movb $0x1, -0x1(%rbp)
jmp 0xd5155
jmp 0xd5146
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd5126
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetMouseDragDelta(int, float)
ImVec2 ImGui::GetMouseDragDelta(ImGuiMouseButton button, float lock_threshold)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    if (g.IO.MouseDown[button] || g.IO.MouseReleased[button])
        if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
            if (IsMousePosValid(&g.IO.MousePos) && IsMousePosValid(&g.IO.MouseClickedPos[button]))
                return g.IO.MousePos - g.IO.MouseClickedPos[button];
    return ImVec2(0.0f, 0.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movq 0x13ddc9(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jl 0xd5190
cmpl $0x5, -0xc(%rbp)
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd5199
jmp 0xd519b
jmp 0xd51ba
leaq 0x9ea43(%rip), %rdi     # 0x173be5
leaq 0x9dd60(%rip), %rsi     # 0x172f09
movl $0x121f, %edx           # imm = 0x121F
leaq 0x9ebf2(%rip), %rcx     # 0x173da7
callq 0xd180
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0xd51d1
movq -0x18(%rbp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
testb $0x1, 0x130(%rax,%rcx)
jne 0xd51f9
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
testb $0x1, 0x42a(%rax,%rcx)
je 0xd5282
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x48c(%rax,%rcx,4), %xmm0
movss -0x10(%rbp), %xmm1
mulss -0x10(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0xd5280
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0xcb710
testb $0x1, %al
jne 0xd5233
jmp 0xd527e
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x3c4, %rdi            # imm = 0x3C4
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xcb710
testb $0x1, %al
jne 0xd5258
jmp 0xd527e
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
movslq -0xc(%rbp), %rcx
leaq 0x3cc(%rax,%rcx,8), %rsi
callq 0xc3c00
movlpd %xmm0, -0x8(%rbp)
jmp 0xd5291
jmp 0xd5280
jmp 0xd5282
leaq -0x8(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ResetMouseDragDelta(int)
void ImGui::ResetMouseDragDelta(ImGuiMouseButton button)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    // NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
    g.IO.MouseClickedPos[button] = g.IO.MousePos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x13dc8e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x11(%rbp)
jl 0xd52cb
cmpl $0x5, -0x4(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xd52d4
jmp 0xd52d6
jmp 0xd52f5
leaq 0x9e908(%rip), %rdi     # 0x173be5
leaq 0x9dc25(%rip), %rsi     # 0x172f09
movl $0x122c, %edx           # imm = 0x122C
leaq 0x9eaf0(%rip), %rcx     # 0x173de0
callq 0xd180
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0x128(%rdx), %rdx
movq %rdx, 0x3cc(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemActive()
bool ImGui::IsItemActive()
{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = g.CurrentWindow;
        return g.ActiveId == window->DC.LastItemId;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x13db75(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1b30(%rax)
je 0xd5409
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1b30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x124(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd540d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemActivated()
bool ImGui::IsItemActivated()
{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = g.CurrentWindow;
        if (g.ActiveId == window->DC.LastItemId && g.ActiveIdPreviousFrame != window->DC.LastItemId)
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x13db15(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1b30(%rax)
je 0xd547f
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1b30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x124(%rcx), %eax
jne 0xd547d
movq -0x10(%rbp), %rax
movl 0x1b70(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x124(%rcx), %eax
je 0xd547d
movb $0x1, -0x1(%rbp)
jmp 0xd5483
jmp 0xd547f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemDeactivated()
bool ImGui::IsItemDeactivated()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HasDeactivated)
        return (window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_Deactivated) != 0;
    return (g.ActiveIdPreviousFrame == window->DC.LastItemId && g.ActiveIdPreviousFrame != 0 && g.ActiveId != window->DC.LastItemId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x13daa5(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x128(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xd54da
movq -0x18(%rbp), %rax
movl 0x128(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd5529
movq -0x10(%rbp), %rax
movl 0x1b70(%rax), %ecx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpl 0x124(%rdx), %ecx
movb %al, -0x19(%rbp)
jne 0xd5521
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x1b70(%rcx)
movb %al, -0x19(%rbp)
je 0xd5521
movq -0x10(%rbp), %rax
movl 0x1b30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x124(%rcx), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetItemAllowOverlap()
void ImGui::SetItemAllowOverlap()
{
    ImGuiContext& g = *GImGui;
    ImGuiID id = g.CurrentWindow->DC.LastItemId;
    if (g.HoveredId == id)
        g.HoveredIdAllowOverlap = true;
    if (g.ActiveId == id)
        g.ActiveIdAllowOverlap = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x13d7d5(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movl 0x124(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1b1c(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd579d
movq -0x8(%rbp), %rax
movb $0x1, 0x1b24(%rax)
movq -0x8(%rbp), %rax
movl 0x1b30(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd57b7
movq -0x8(%rbp), %rax
movb $0x1, 0x1b3d(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetItemUsingMouseWheel()
void ImGui::SetItemUsingMouseWheel()
{
    ImGuiContext& g = *GImGui;
    ImGuiID id = g.CurrentWindow->DC.LastItemId;
    if (g.HoveredId == id)
        g.HoveredIdUsingMouseWheel = true;
    if (g.ActiveId == id)
        g.ActiveIdUsingMouseWheel = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x13d775(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movl 0x124(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1b1c(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd57fd
movq -0x8(%rbp), %rax
movb $0x1, 0x1b25(%rax)
movq -0x8(%rbp), %rax
movl 0x1b30(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd5817
movq -0x8(%rbp), %rax
movb $0x1, 0x1b42(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavInitWindow(ImGuiWindow*, bool)
void ImGui::NavInitWindow(ImGuiWindow* window, bool force_reinit)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(window == g.NavWindow);
    bool init_for_nav = false;
    if (!(window->Flags & ImGuiWindowFlags_NoNavInputs))
        if (!(window->Flags & ImGuiWindowFlags_ChildWindow) || (window->Flags & ImGuiWindowFlags_Popup) || (window->NavLastIds[0] == 0) || force_reinit)
            init_for_nav = true;
    IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: from NavInitWindow(), init_for_nav=%d, window=\"%s\", layer=%d\n", init_for_nav, window->Name, g.NavLayer);
    if (init_for_nav)
    {
        SetNavID(0, g.NavLayer, 0);
        g.NavInitRequest = true;
        g.NavInitRequestFromMove = false;
        g.NavInitResultId = 0;
        g.NavInitResultRectRel = ImRect();
        NavUpdateAnyRequestFlag();
    }
    else
    {
        g.NavId = window->NavLastIds[0];
        g.NavFocusScopeId = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x13d395(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x1c90(%rcx), %rax
jne 0xd5bc2
jmp 0xd5be1
leaq 0x9f83c(%rip), %rdi     # 0x175405
leaq 0x9d339(%rip), %rsi     # 0x172f09
movl $0x2207, %edx           # imm = 0x2207
leaq 0x9f83f(%rip), %rcx     # 0x17541b
callq 0xd180
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
jne 0xd5c31
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0xd5c2b
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
jne 0xd5c2b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3b0(%rax)
je 0xd5c2b
testb $0x1, -0x9(%rbp)
je 0xd5c2f
movb $0x1, -0x19(%rbp)
jmp 0xd5c31
testb $0x1, -0x19(%rbp)
je 0xd5c98
movq -0x18(%rbp), %rax
movl 0x1cdc(%rax), %esi
xorl %edx, %edx
movl %edx, %edi
callq 0xdf300
movq -0x18(%rbp), %rax
movb $0x1, 0x1ce9(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1cea(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1cec(%rax)
leaq -0x2c(%rbp), %rdi
callq 0xe8c60
movq -0x18(%rbp), %rax
movq -0x2c(%rbp), %rcx
movq %rcx, 0x1cf0(%rax)
movq -0x24(%rbp), %rcx
movq %rcx, 0x1cf8(%rax)
callq 0xdb260
jmp 0xd5cba
movq -0x8(%rbp), %rax
movl 0x3b0(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c98(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1c9c(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginChildFrame(unsigned int, ImVec2 const&, int)
bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags)
{
    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);
    PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
    PushStyleVar(ImGuiStyleVar_ChildBorderSize, style.FrameBorderSize);
    PushStyleVar(ImGuiStyleVar_WindowPadding, style.FramePadding);
    bool ret = BeginChild(id, size, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysUseWindowPadding | extra_flags);
    PopStyleVar(3);
    PopStyleColor();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x13cb27(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
addq $0xc4, %rsi
addq $0x70, %rsi
movl $0x3, %edi
callq 0xc78f0
movq -0x28(%rbp), %rax
movss 0x40(%rax), %xmm0
movl $0x6, %edi
callq 0xc7a20
movq -0x28(%rbp), %rax
movss 0x44(%rax), %xmm0
movl $0x7, %edi
callq 0xc7a20
movq -0x28(%rbp), %rsi
addq $0x38, %rsi
movl $0x1, %edi
callq 0xc7b50
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
orl $0x10004, %ecx          # imm = 0x10004
movl $0x1, %edx
callq 0xd5d20
andb $0x1, %al
movb %al, -0x29(%rbp)
movl $0x3, %edi
callq 0xc7c10
movl $0x1, %edi
callq 0xc7990
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcWindowNextAutoFitSize(ImGuiWindow*)
ImVec2 ImGui::CalcWindowNextAutoFitSize(ImGuiWindow* window)
{
    ImVec2 size_contents_current;
    ImVec2 size_contents_ideal;
    CalcWindowContentSizes(window, &size_contents_current, &size_contents_ideal);
    ImVec2 size_auto_fit = CalcWindowAutoFitSize(window, size_contents_ideal);
    ImVec2 size_final = CalcWindowSizeAfterConstraint(window, size_auto_fit);
    return size_final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xe7de0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe7de0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rdi
callq 0xd65a0
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xd67d0
movlpd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xd6ac0
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetWindowResizeID(ImGuiWindow*, int)
ImGuiID ImGui::GetWindowResizeID(ImGuiWindow* window, int n)
{
    IM_ASSERT(n >= 0 && n <= 7);
    ImGuiID id = window->ID;
    id = ImHashStr("#RESIZE", 0, id);
    id = ImHashData(&n, sizeof(int), id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0xd6d14
cmpl $0x7, -0xc(%rbp)
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xd6d1d
jmp 0xd6d1f
jmp 0xd6d3e
leaq 0x9d1a5(%rip), %rdi     # 0x173ecb
leaq 0x9c1dc(%rip), %rsi     # 0x172f09
movl $0x1440, %edx           # imm = 0x1440
leaq 0x9d1a3(%rip), %rcx     # 0x173edc
callq 0xd180
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
leaq 0x9d1bf(%rip), %rdi     # 0x173f11
xorl %eax, %eax
movl %eax, %esi
callq 0xc4f20
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
callq 0xc4ea0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow*, int, ImGuiWindow*)
void ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window)
{
    window->ParentWindow = parent_window;
    window->RootWindow = window->RootWindowForTitleBarHighlight = window->RootWindowForNav = window;
    if (parent_window && (flags & ImGuiWindowFlags_ChildWindow) && !(flags & ImGuiWindowFlags_Tooltip))
        window->RootWindow = parent_window->RootWindow;
    if (parent_window && !(flags & ImGuiWindowFlags_Modal) && (flags & (ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_Popup)))
        window->RootWindowForTitleBarHighlight = parent_window->RootWindowForTitleBarHighlight;
    while (window->RootWindowForNav->Flags & ImGuiWindowFlags_NavFlattened)
    {
        IM_ASSERT(window->RootWindowForNav->ParentWindow != NULL);
        window->RootWindowForNav = window->RootWindowForNav->ParentWindow;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x388(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3a0(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x398(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x390(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xd6dfe
movl -0xc(%rbp), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0xd6dfe
movl -0xc(%rbp), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
jne 0xd6dfe
movq -0x18(%rbp), %rax
movq 0x390(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x390(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xd6e35
movl -0xc(%rbp), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
jne 0xd6e35
movl -0xc(%rbp), %eax
andl $0x5000000, %eax        # imm = 0x5000000
cmpl $0x0, %eax
je 0xd6e35
movq -0x18(%rbp), %rax
movq 0x398(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x398(%rax)
jmp 0xd6e37
movq -0x8(%rbp), %rax
movq 0x3a0(%rax), %rax
movl 0xc(%rax), %eax
andl $0x800000, %eax         # imm = 0x800000
cmpl $0x0, %eax
je 0xd6ea4
movq -0x8(%rbp), %rax
movq 0x3a0(%rax), %rax
cmpq $0x0, 0x388(%rax)
je 0xd6e66
jmp 0xd6e85
leaq 0x9d0ac(%rip), %rdi     # 0x173f19
leaq 0x9c095(%rip), %rsi     # 0x172f09
movl $0x159b, %edx           # imm = 0x159B
leaq 0x9d0ca(%rip), %rcx     # 0x173f4a
callq 0xd180
movq -0x8(%rbp), %rax
movq 0x3a0(%rax), %rax
movq 0x388(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3a0(%rax)
jmp 0xd6e37
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiStackSizes::SetToCurrentState()
void ImGuiStackSizes::SetToCurrentState()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    SizeOfIDStack = (short)window->IDStack.Size;
    SizeOfColorStack = (short)g.ColorStack.Size;
    SizeOfStyleVarStack = (short)g.StyleVarStack.Size;
    SizeOfFontStack = (short)g.FontStack.Size;
    SizeOfFocusScopeStack = (short)g.FocusScopeStack.Size;
    SizeOfGroupStack = (short)g.GroupStack.Size;
    SizeOfBeginPopupStack = (short)g.BeginPopupStack.Size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x13bd0d(%rip), %rcx    # 0x212f40
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq 0x1ae0(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl 0xc8(%rcx), %ecx
movw %cx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x1c10(%rcx), %ecx
movw %cx, 0x2(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c20(%rcx), %ecx
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c30(%rcx), %ecx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c40(%rcx), %ecx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c60(%rcx), %ecx
movw %cx, 0xa(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c80(%rcx), %ecx
movw %cx, 0xc(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowSize(ImGuiWindow*, ImVec2 const&, int)
void ImGui::SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
        return;

    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    window->SetWindowSizeAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);

    // Set
    if (size.x > 0.0f)
    {
        window->AutoFitFramesX = 0;
        window->SizeFull.x = IM_FLOOR(size.x);
    }
    else
    {
        window->AutoFitFramesX = 2;
        window->AutoFitOnlyGrows = false;
    }
    if (size.y > 0.0f)
    {
        window->AutoFitFramesY = 0;
        window->SizeFull.y = IM_FLOOR(size.y);
    }
    else
    {
        window->AutoFitFramesY = 2;
        window->AutoFitOnlyGrows = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xd72e6
movq -0x8(%rbp), %rax
movl 0xaf(%rax), %eax
shll $0x10, %eax
sarl $0x18, %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0xd72e6
jmp 0xd73e8
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0xd72fc
movl -0x14(%rbp), %edi
callq 0xda7c0
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xd7305
jmp 0xd7307
jmp 0xd7326
leaq 0x9d0ef(%rip), %rdi     # 0x1743fd
leaq 0x9bbf4(%rip), %rsi     # 0x172f09
movl $0x19b3, %edx           # imm = 0x19B3
leaq 0x9d141(%rip), %rcx     # 0x174462
callq 0xd180
movq -0x8(%rbp), %rax
movl 0xaf(%rax), %edx
shll $0x10, %edx
sarl $0x18, %edx
andl $-0xf, %edx
movl 0xaf(%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, 0xaf(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xd7388
movq -0x8(%rbp), %rax
movb $0x0, 0xa4(%rax)
movq -0x10(%rbp), %rax
cvttss2si (%rax), %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x20(%rax)
jmp 0xd739e
movq -0x8(%rbp), %rax
movb $0x2, 0xa4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa7(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xd73d2
movq -0x8(%rbp), %rax
movb $0x0, 0xa5(%rax)
movq -0x10(%rbp), %rax
cvttss2si 0x4(%rax), %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x24(%rax)
jmp 0xd73e8
movq -0x8(%rbp), %rax
movb $0x2, 0xa5(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa7(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowCollapsed(ImGuiWindow*, bool, int)
void ImGui::SetWindowCollapsed(ImGuiWindow* window, bool collapsed, ImGuiCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowCollapsedAllowFlags & cond) == 0)
        return;
    window->SetWindowCollapsedAllowFlags &= ~(ImGuiCond_Once | ImGuiCond_FirstUseEver | ImGuiCond_Appearing);

    // Set
    window->Collapsed = collapsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xd7423
movq -0x8(%rbp), %rax
movl 0xaf(%rax), %eax
shll $0x8, %eax
sarl $0x18, %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0xd7423
jmp 0xd7463
movq -0x8(%rbp), %rax
movl 0xaf(%rax), %edx
shll $0x8, %edx
sarl $0x18, %edx
andl $-0xf, %edx
movl 0xaf(%rax), %ecx
andl $0xff, %edx
shll $0x10, %edx
andl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
orl %edx, %ecx
movl %ecx, 0xaf(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x91(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: SetCurrentWindow(ImGuiWindow*)
static void SetCurrentWindow(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    g.CurrentWindow = window;
    g.CurrentTable = window && window->DC.CurrentTableIdx != -1 ? g.Tables.GetByIndex(window->DC.CurrentTableIdx) : NULL;
    if (window)
        g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x13babd(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1ae0(%rax)
cmpq $0x0, -0x8(%rbp)
je 0xd74ca
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x1b8(%rax)
je 0xd74ca
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movq -0x8(%rbp), %rax
movl 0x1b8(%rax), %esi
callq 0xea9d0
movq %rax, -0x18(%rbp)
jmp 0xd74d2
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xd74d2
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20a8(%rax)
cmpq $0x0, -0x8(%rbp)
je 0xd7509
movq -0x8(%rbp), %rdi
callq 0xebbf0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1998(%rax)
movq -0x10(%rbp), %rax
movss %xmm0, 0x1980(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ClampWindowRect(ImGuiWindow*, ImRect const&)
static inline void ClampWindowRect(ImGuiWindow* window, const ImRect& visibility_rect)
{
    ImGuiContext& g = *GImGui;
    ImVec2 size_for_clamping = window->Size;
    if (g.IO.ConfigWindowsMoveFromTitleBarOnly && !(window->Flags & ImGuiWindowFlags_NoTitleBar))
        size_for_clamping.y = window->TitleBarHeight();
    window->Pos = ImClamp(window->Pos, visibility_rect.Min - size_for_clamping, visibility_rect.Max);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x13b529(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0xcd(%rax)
je 0xd7a51
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xd7a51
movq -0x8(%rbp), %rdi
callq 0xeb6f0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc3c00
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
leaq -0x30(%rbp), %rsi
callq 0xdf120
movlpd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::LogFinish()
void ImGui::LogFinish()
{
    ImGuiContext& g = *GImGui;
    if (!g.LogEnabled)
        return;

    LogText(IM_NEWLINE);
    switch (g.LogType)
    {
    case ImGuiLogType_TTY:
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
        fflush(g.LogFile);
#endif
        break;
    case ImGuiLogType_File:
        ImFileClose(g.LogFile);
        break;
    case ImGuiLogType_Buffer:
        break;
    case ImGuiLogType_Clipboard:
        if (!g.LogBuffer.empty())
            SetClipboardText(g.LogBuffer.begin());
        break;
    case ImGuiLogType_None:
        IM_ASSERT(0);
        break;
    }

    g.LogEnabled = false;
    g.LogType = ImGuiLogType_None;
    g.LogFile = NULL;
    g.LogBuffer.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x139661(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x3138(%rax)
jne 0xd98f5
jmp 0xd99da
leaq 0xa55c8(%rip), %rdi     # 0x17eec4
xorl %eax, %eax
callq 0xe0a30
movq -0x8(%rbp), %rax
movl 0x313c(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0xd99a2
movq -0x10(%rbp), %rax
leaq 0x98fe6(%rip), %rcx     # 0x17290c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x3140(%rax), %rdi
callq 0xd510
jmp 0xd99a2
movq -0x8(%rbp), %rax
movq 0x3140(%rax), %rdi
callq 0xc5080
jmp 0xd99a2
jmp 0xd99a2
movq -0x8(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
callq 0xec2e0
testb $0x1, %al
jne 0xd9981
movq -0x8(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
callq 0xec300
movq %rax, %rdi
callq 0xcaaa0
jmp 0xd99a2
leaq 0x9b780(%rip), %rdi     # 0x17510a
leaq 0x99578(%rip), %rsi     # 0x172f09
movl $0x26fa, %edx           # imm = 0x26FA
leaq 0x9bee6(%rip), %rcx     # 0x175883
callq 0xd180
movq -0x8(%rbp), %rax
movb $0x0, 0x3138(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x313c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x3140(%rax)
movq -0x8(%rbp), %rdi
addq $0x3148, %rdi           # imm = 0x3148
callq 0xeb160
addq $0x10, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BringWindowToFocusFront(ImGuiWindow*)
void ImGui::BringWindowToFocusFront(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    if (g.WindowsFocusOrder.back() == window)
        return;
    for (int i = g.WindowsFocusOrder.Size - 2; i >= 0; i--) // We can ignore the top-most window
        if (g.WindowsFocusOrder[i] == window)
        {
            memmove(&g.WindowsFocusOrder[i], &g.WindowsFocusOrder[i + 1], (size_t)(g.WindowsFocusOrder.Size - i - 1) * sizeof(ImGuiWindow*));
            g.WindowsFocusOrder[g.WindowsFocusOrder.Size - 1] = window;
            break;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x13930d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
callq 0xeb5c0
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd9c55
jmp 0xd9d19
movq -0x10(%rbp), %rax
movl 0x1a98(%rax), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xd9d19
movq -0x10(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x14(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd9d09
movq -0x10(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x14(%rbp), %esi
callq 0xea8d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0xea8d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x1a98(%rax), %eax
subl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0xd170
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movq -0x10(%rbp), %rax
movl 0x1a98(%rax), %esi
subl $0x1, %esi
callq 0xea8d0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xd9d19
jmp 0xd9d0b
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd9c65
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BringWindowToDisplayFront(ImGuiWindow*)
void ImGui::BringWindowToDisplayFront(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* current_front_window = g.Windows.back();
    if (current_front_window == window || current_front_window->RootWindow == window) // Cheap early out (could be better)
        return;
    for (int i = g.Windows.Size - 2; i >= 0; i--) // We can ignore the top-most window
        if (g.Windows[i] == window)
        {
            memmove(&g.Windows[i], &g.Windows[i + 1], (size_t)(g.Windows.Size - i - 1) * sizeof(ImGuiWindow*));
            g.Windows[g.Windows.Size - 1] = window;
            break;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x13920d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
callq 0xeb5c0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xd9d69
movq -0x18(%rbp), %rax
movq 0x390(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd9d6e
jmp 0xd9e32
movq -0x10(%rbp), %rax
movl 0x1a88(%rax), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xd9e32
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x1c(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd9e22
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x1c(%rbp), %esi
callq 0xea8d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x1c(%rbp), %esi
addl $0x1, %esi
callq 0xea8d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x1a88(%rax), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0xd170
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movq -0x10(%rbp), %rax
movl 0x1a88(%rax), %esi
subl $0x1, %esi
callq 0xea8d0
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xd9e32
jmp 0xd9e24
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd9d7e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BringWindowToDisplayBack(ImGuiWindow*)
void ImGui::BringWindowToDisplayBack(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    if (g.Windows[0] == window)
        return;
    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i] == window)
        {
            memmove(&g.Windows[1], &g.Windows[0], (size_t)i * sizeof(ImGuiWindow*));
            g.Windows[0] = window;
            break;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1390ed(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
xorl %esi, %esi
callq 0xea8d0
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd9e77
jmp 0xd9f1f
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1a88(%rcx), %eax
jge 0xd9f1f
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x14(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0xd9f0f
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl $0x1, %esi
callq 0xea8d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
xorl %esi, %esi
callq 0xea8d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0xd170
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
xorl %esi, %esi
callq 0xea8d0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xd9f1f
jmp 0xd9f11
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd9e7e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindWindowFocusIndex(ImGuiWindow*)
static int ImGui::FindWindowFocusIndex(ImGuiWindow* window) // FIXME-OPT O(N)
{
    ImGuiContext& g = *GImGui;
    for (int i = g.WindowsFocusOrder.Size - 1; i >= 0; i--)
        if (g.WindowsFocusOrder[i] == window)
            return i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x138ffd(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1a98(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xd9f8e
movq -0x18(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x1c(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xd9f81
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd9f95
jmp 0xd9f83
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd9f57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushFont(ImFont*)
void ImGui::PushFont(ImFont* font)
{
    ImGuiContext& g = *GImGui;
    if (!font)
        font = GetDefaultFont();
    SetCurrentFont(font);
    g.FontStack.push_back(font);
    g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x138f3d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xda017
callq 0xea7e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcd800
movq -0x10(%rbp), %rdi
addq $0x1c30, %rdi           # imm = 0x1C30
leaq -0x8(%rbp), %rsi
callq 0xebc60
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq 0x2b8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10f740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopFont()
void  ImGui::PopFont()
{
    ImGuiContext& g = *GImGui;
    g.CurrentWindow->DrawList->PopTextureID();
    g.FontStack.pop_back();
    SetCurrentFont(g.FontStack.empty() ? GetDefaultFont() : g.FontStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x138ed1(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq 0x2b8(%rax), %rdi
callq 0x10f780
movq -0x8(%rbp), %rdi
addq $0x1c30, %rdi           # imm = 0x1C30
callq 0xebcc0
movq -0x8(%rbp), %rdi
addq $0x1c30, %rdi           # imm = 0x1C30
callq 0xebd10
testb $0x1, %al
jne 0xda0b0
jmp 0xda0bb
callq 0xea7e0
movq %rax, -0x10(%rbp)
jmp 0xda0d2
movq -0x8(%rbp), %rdi
addq $0x1c30, %rdi           # imm = 0x1C30
callq 0xebd30
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd800
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushItemFlag(int, bool)
void ImGui::PushItemFlag(ImGuiItemFlags option, bool enabled)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiItemFlags item_flags = window->DC.ItemFlags;
    IM_ASSERT(item_flags == g.ItemFlagsStack.back());
    if (enabled)
        item_flags |= option;
    else
        item_flags &= ~option;
    window->DC.ItemFlags = item_flags;
    g.ItemFlagsStack.push_back(item_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movq 0x138e36(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1cc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c50, %rdi           # imm = 0x1C50
callq 0xebad0
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jne 0xda14c
jmp 0xda16b
leaq 0x9a18e(%rip), %rdi     # 0x1742e1
leaq 0x98daf(%rip), %rsi     # 0x172f09
movl $0x18df, %edx           # imm = 0x18DF
leaq 0x9a1a1(%rip), %rcx     # 0x174307
callq 0xd180
testb $0x1, -0x5(%rbp)
je 0xda17c
movl -0x4(%rbp), %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xda188
movl -0x4(%rbp), %eax
xorl $-0x1, %eax
andl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1cc(%rax)
movq -0x10(%rbp), %rdi
addq $0x1c50, %rdi           # imm = 0x1C50
leaq -0x1c(%rbp), %rsi
callq 0xeaaf0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopItemFlag()
void ImGui::PopItemFlag()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.ItemFlagsStack.Size > 1); // Too many calls to PopItemFlag() - we always leave a 0 at the bottom of the stack.
    g.ItemFlagsStack.pop_back();
    window->DC.ItemFlags = g.ItemFlagsStack.back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x138d81(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x1c50(%rax)
jle 0xda1e1
jmp 0xda200
leaq 0x9a14e(%rip), %rdi     # 0x174336
leaq 0x98d1a(%rip), %rsi     # 0x172f09
movl $0x18ec, %edx           # imm = 0x18EC
leaq 0x9a155(%rip), %rcx     # 0x174350
callq 0xd180
movq -0x8(%rbp), %rdi
addq $0x1c50, %rdi           # imm = 0x1C50
callq 0xebd90
movq -0x8(%rbp), %rdi
addq $0x1c50, %rdi           # imm = 0x1C50
callq 0xebad0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1cc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsWindowFocused(int)
bool ImGui::IsWindowFocused(ImGuiFocusedFlags flags)
{
    ImGuiContext& g = *GImGui;

    if (flags & ImGuiFocusedFlags_AnyWindow)
        return g.NavWindow != NULL;

    IM_ASSERT(g.CurrentWindow);     // Not inside a Begin()/End()
    switch (flags & (ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows))
    {
    case ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows:
        return g.NavWindow && g.NavWindow->RootWindow == g.CurrentWindow->RootWindow;
    case ImGuiFocusedFlags_RootWindow:
        return g.NavWindow == g.CurrentWindow->RootWindow;
    case ImGuiFocusedFlags_ChildWindows:
        return g.NavWindow && IsWindowChildOf(g.NavWindow, g.CurrentWindow);
    default:
        return g.NavWindow == g.CurrentWindow;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0x1389ce(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xda59a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xda6bf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1ae0(%rax)
je 0xda5aa
jmp 0xda5c9
leaq 0xb1e1f(%rip), %rdi     # 0x18c3d0
leaq 0x98951(%rip), %rsi     # 0x172f09
movl $0x195f, %edx           # imm = 0x195F
leaq 0x99e0a(%rip), %rcx     # 0x1743ce
callq 0xd180
movl -0x8(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0xda666
jmp 0xda5dd
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xda63f
jmp 0xda5e7
movl -0x14(%rbp), %eax
subl $0x3, %eax
jne 0xda6a1
jmp 0xda5f5
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x1c90(%rcx)
movb %al, -0x15(%rbp)
je 0xda632
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rax
movq 0x390(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x1ae0(%rcx), %rcx
cmpq 0x390(%rcx), %rax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xda6bf
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x1ae0(%rcx), %rcx
cmpq 0x390(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xda6bf
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x1c90(%rcx)
movb %al, -0x16(%rbp)
je 0xda697
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rsi
callq 0xcc5a0
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xda6bf
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1ae0(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowFocus(char const*)
void ImGui::SetWindowFocus(const char* name)
{
    if (name)
    {
        if (ImGuiWindow* window = FindWindowByName(name))
            FocusWindow(window);
    }
    else
    {
        FocusWindow(NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdab22
movq -0x8(%rbp), %rdi
callq 0xd6500
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdab20
movq -0x10(%rbp), %rdi
callq 0xcb380
jmp 0xdab2b
xorl %eax, %eax
movl %eax, %edi
callq 0xcb380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)