LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::StartMouseMovingWindow(ImGuiWindow*)
void ImGui::StartMouseMovingWindow(ImGuiWindow* window)
{
    // Set ActiveId even if the _NoMove flag is set. Without it, dragging away from a window with _NoMove would activate hover on other windows.
    // We _also_ call this when clicking in a window empty space when io.ConfigWindowsMoveFromTitleBarOnly is set, but clear g.MovingWindow afterward.
    // This is because we want ActiveId to be set even when the window is not permitted to move.
    ImGuiContext& g = *GImGui;
    FocusWindow(window);
    SetActiveID(window->MoveId, window);
    g.NavDisableHighlight = true;
    g.ActiveIdNoClearOnFocusLoss = true;
    g.ActiveIdClickOffset = g.IO.MousePos - window->RootWindow->Pos;

    bool can_move_window = true;
    if ((window->Flags & ImGuiWindowFlags_NoMove) || (window->RootWindow->Flags & ImGuiWindowFlags_NoMove))
        can_move_window = false;
    if (can_move_window)
        g.MovingWindow = window;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x147c6d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcb380
movq -0x8(%rbp), %rsi
movl 0x54(%rsi), %edi
callq 0xc9ec0
movq -0x10(%rbp), %rax
movb $0x1, 0x1ce6(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1b3e(%rax)
movq -0x10(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq -0x8(%rbp), %rax
movq 0x390(%rax), %rsi
addq $0x10, %rsi
callq 0xc3c00
movlpd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x1b58(%rax)
movb $0x1, -0x19(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xcb35e
movq -0x8(%rbp), %rax
movq 0x390(%rax), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xcb362
movb $0x0, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0xcb377
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b00(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMousePosValid(ImVec2 const*)
bool ImGui::IsMousePosValid(const ImVec2* mouse_pos)
{
    // The assert is only to silence a false-positive in XCode Static Analysis.
    // Because GImGui is not dereferenced in every code path, the static analyzer assume that it may be NULL (which it doesn't for other functions).
    IM_ASSERT(GImGui != NULL);
    const float MOUSE_INVALID = -256000.0f;
    ImVec2 p = mouse_pos ? *mouse_pos : GImGui->IO.MousePos;
    return p.x >= MOUSE_INVALID && p.y >= MOUSE_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x14781c(%rip)    # 0x212f40
je 0xcb728
jmp 0xcb747
leaq 0xa863b(%rip), %rdi     # 0x173d6a
leaq 0xa77d3(%rip), %rsi     # 0x172f09
movl $0x120a, %edx           # imm = 0x120A
leaq 0xa8639(%rip), %rcx     # 0x173d7b
callq 0xd180
movss 0xa7021(%rip), %xmm0    # 0x172770
movss %xmm0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcb765
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xcb77a
movq 0x1477d4(%rip), %rax    # 0x212f40
addq $0x8, %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
xorl %eax, %eax
movss 0xa6fdc(%rip), %xmm1    # 0x172770
ucomiss %xmm1, %xmm0
movb %al, -0x21(%rbp)
jb 0xcb7b2
movss -0x10(%rbp), %xmm0
movss 0xa6fc7(%rip), %xmm1    # 0x172770
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::MarkIniSettingsDirty(ImGuiWindow*)
void ImGui::MarkIniSettingsDirty(ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    if (!(window->Flags & ImGuiWindowFlags_NoSavedSettings))
        if (g.SettingsDirtyTimer <= 0.0f)
            g.SettingsDirtyTimer = g.IO.IniSavingRate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x147771(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0xcb80b
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
ucomiss 0x30e4(%rax), %xmm0
jb 0xcb809
movq -0x10(%rbp), %rax
movss 0x1c(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x30e4(%rax)
jmp 0xcb80b
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowPos(ImGuiWindow*, ImVec2 const&, int)
void ImGui::SetWindowPos(ImGuiWindow* window, const ImVec2& pos, ImGuiCond cond)
{
    // Test condition (NB: bit 0 is always true) and clear flags for next time
    if (cond && (window->SetWindowPosAllowFlags & cond) == 0)
        return;

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

    // Set
    const ImVec2 old_pos = window->Pos;
    window->Pos = ImFloor(pos);
    ImVec2 offset = window->Pos - old_pos;
    window->DC.CursorPos += offset;         // As we happen to move the window while it is being appended to (which is a bad idea - will smear) let's at least offset the cursor
    window->DC.CursorMaxPos += offset;      // And more importantly we need to offset CursorMaxPos/CursorStartPos this so ContentSize calculation doesn't get affected.
    window->DC.CursorStartPos += offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xcb846
movq -0x8(%rbp), %rax
movl 0xaf(%rax), %eax
shll $0x18, %eax
sarl $0x18, %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0xcb846
jmp 0xcb93c
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x39(%rbp)
je 0xcb85c
movl -0x14(%rbp), %edi
callq 0xda7c0
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xcb865
jmp 0xcb867
jmp 0xcb886
leaq 0xa8b8f(%rip), %rdi     # 0x1743fd
leaq 0xa7694(%rip), %rsi     # 0x172f09
movl $0x198e, %edx           # imm = 0x198E
leaq 0xa8b9e(%rip), %rcx     # 0x17441f
callq 0xd180
movq -0x8(%rbp), %rax
movl 0xaf(%rax), %ecx
andl $-0xf, %ecx
movl %ecx, 0xaf(%rax)
leaq -0x1c(%rbp), %rdi
movss 0xa670f(%rip), %xmm1    # 0x171fb4
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x8(%rbp), %rax
movq -0x1c(%rbp), %rcx
movq %rcx, 0xb4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc2f10
movlpd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0xc3c00
movlpd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
leaq -0x38(%rbp), %rsi
callq 0xda7f0
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
callq 0xda7f0
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0xda7f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsPopupOpen(unsigned int, int)
bool ImGui::IsPopupOpen(ImGuiID id, ImGuiPopupFlags popup_flags)
{
    ImGuiContext& g = *GImGui;
    if (popup_flags & ImGuiPopupFlags_AnyPopupId)
    {
        // Return true if any popup is open at the current BeginPopup() level of the popup stack
        // This may be used to e.g. test for another popups already opened to handle popups priorities at the same level.
        IM_ASSERT(id == 0);
        if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
            return g.OpenPopupStack.Size > 0;
        else
            return g.OpenPopupStack.Size > g.BeginPopupStack.Size;
    }
    else
    {
        if (popup_flags & ImGuiPopupFlags_AnyPopupLevel)
        {
            // Return true if the popup is open anywhere in the popup stack
            for (int n = 0; n < g.OpenPopupStack.Size; n++)
                if (g.OpenPopupStack[n].PopupId == id)
                    return true;
            return false;
        }
        else
        {
            // Return true if the popup is open at the current BeginPopup() level of the popup stack (this is the most-common query)
            return g.OpenPopupStack.Size > g.BeginPopupStack.Size && g.OpenPopupStack[g.BeginPopupStack.Size].PopupId == id;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x1473cb(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xcbbf3
cmpl $0x0, -0x8(%rbp)
jne 0xcbb8e
jmp 0xcbbad
leaq 0xa947e(%rip), %rdi     # 0x175013
leaq 0xa736d(%rip), %rsi     # 0x172f09
movl $0x1ec4, %edx           # imm = 0x1EC4
leaq 0xa9473(%rip), %rcx     # 0x17501b
callq 0xd180
movl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xcbbd2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c70(%rax)
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcbc91
movq -0x18(%rbp), %rax
movl 0x1c70(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c80(%rcx), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcbc91
movl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xcbc49
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c70(%rcx), %eax
jge 0xcbc43
movq -0x18(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movl -0x1c(%rbp), %esi
callq 0xeb4c0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xcbc36
movb $0x1, -0x1(%rbp)
jmp 0xcbc91
jmp 0xcbc38
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcbc07
movb $0x0, -0x1(%rbp)
jmp 0xcbc91
movq -0x18(%rbp), %rax
movl 0x1c70(%rax), %ecx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpl 0x1c80(%rdx), %ecx
movb %al, -0x1d(%rbp)
jle 0xcbc89
movq -0x18(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movq -0x18(%rbp), %rax
movl 0x1c80(%rax), %esi
callq 0xeb4c0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetTopMostPopupModal()
ImGuiWindow* ImGui::GetTopMostPopupModal()
{
    ImGuiContext& g = *GImGui;
    for (int n = g.OpenPopupStack.Size - 1; n >= 0; n--)
        if (ImGuiWindow* popup = g.OpenPopupStack.Data[n].Window)
            if (popup->Flags & ImGuiWindowFlags_Modal)
                return popup;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x147295(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c70(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xcbd14
movq -0x10(%rbp), %rax
movq 0x1c78(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcbd07
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
je 0xcbd05
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcbd1c
jmp 0xcbd07
jmp 0xcbd09
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcbcbf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsWindowAbove(ImGuiWindow*, ImGuiWindow*)
bool ImGui::IsWindowAbove(ImGuiWindow* potential_above, ImGuiWindow* potential_below)
{
    ImGuiContext& g = *GImGui;
    for (int i = g.Windows.Size - 1; i >= 0; i--)
    {
        ImGuiWindow* candidate_window = g.Windows[i];
        if (candidate_window == potential_above)
            return true;
        if (candidate_window == potential_below)
            return false;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x1471f9(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1a88(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xcbda8
movq -0x20(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x24(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xcbd8b
movb $0x1, -0x1(%rbp)
jmp 0xcbdac
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xcbd9b
movb $0x0, -0x1(%rbp)
jmp 0xcbdac
jmp 0xcbd9d
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcbd5b
movb $0x0, -0x1(%rbp)
movb -0x1(%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::IsWindowChildOf(ImGuiWindow*, ImGuiWindow*)
bool ImGui::IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent)
{
    if (window->RootWindow == potential_parent)
        return true;
    while (window != NULL)
    {
        if (window == potential_parent)
            return true;
        window = window->ParentWindow;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x390(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xcc5c3
movb $0x1, -0x1(%rbp)
jmp 0xcc5f1
jmp 0xcc5c5
cmpq $0x0, -0x10(%rbp)
je 0xcc5ed
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xcc5dc
movb $0x1, -0x1(%rbp)
jmp 0xcc5f1
movq -0x10(%rbp), %rax
movq 0x388(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcc5c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetMergedKeyModFlags()
ImGuiKeyModFlags ImGui::GetMergedKeyModFlags()
{
    ImGuiContext& g = *GImGui;
    ImGuiKeyModFlags key_mod_flags = ImGuiKeyModFlags_None;
    if (g.IO.KeyCtrl)   { key_mod_flags |= ImGuiKeyModFlags_Ctrl; }
    if (g.IO.KeyShift)  { key_mod_flags |= ImGuiKeyModFlags_Shift; }
    if (g.IO.KeyAlt)    { key_mod_flags |= ImGuiKeyModFlags_Alt; }
    if (g.IO.KeySuper)  { key_mod_flags |= ImGuiKeyModFlags_Super; }
    return key_mod_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x146935(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x140(%rax)
je 0xcc62c
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x141(%rax)
je 0xcc642
movl -0xc(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x142(%rax)
je 0xcc658
movl -0xc(%rbp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x143(%rax)
je 0xcc66e
movl -0xc(%rbp), %eax
orl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::UpdateSettings()
void ImGui::UpdateSettings()
{
    // Load settings on first frame (if not explicitly loaded manually before)
    ImGuiContext& g = *GImGui;
    if (!g.SettingsLoaded)
    {
        IM_ASSERT(g.SettingsWindows.empty());
        if (g.IO.IniFilename)
            LoadIniSettingsFromDisk(g.IO.IniFilename);
        g.SettingsLoaded = true;
    }

    // Save settings (with a delay after the last modification, so we don't spam disk too much)
    if (g.SettingsDirtyTimer > 0.0f)
    {
        g.SettingsDirtyTimer -= g.IO.DeltaTime;
        if (g.SettingsDirtyTimer <= 0.0f)
        {
            if (g.IO.IniFilename != NULL)
                SaveIniSettingsToDisk(g.IO.IniFilename);
            else
                g.IO.WantSaveIniSettings = true;  // Let user know they can call SaveIniSettingsToMemory(). user will need to clear io.WantSaveIniSettings themselves.
            g.SettingsDirtyTimer = 0.0f;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x145831(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x30e1(%rax)
jne 0xcd77a
movq -0x8(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
callq 0xee8f0
testb $0x1, %al
jne 0xcd736
jmp 0xcd738
jmp 0xcd757
leaq 0xaa152(%rip), %rdi     # 0x177891
leaq 0xa57c3(%rip), %rsi     # 0x172f09
movl $0x273a, %edx           # imm = 0x273A
leaq 0xaa159(%rip), %rcx     # 0x1778ab
callq 0xd180
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xcd76f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xe12d0
movq -0x8(%rbp), %rax
movb $0x1, 0x30e1(%rax)
movq -0x8(%rbp), %rax
movss 0x30e4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xcd7f5
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x30e4(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x30e4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomiss 0x30e4(%rax), %xmm0
jb 0xcd7f3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xcd7d9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xd3330
jmp 0xcd7e4
movq -0x8(%rbp), %rax
movb $0x1, 0x39c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30e4(%rax)
jmp 0xcd7f5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetCurrentFont(ImFont*)
void ImGui::SetCurrentFont(ImFont* font)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(font && font->IsLoaded());    // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
    IM_ASSERT(font->Scale > 0.0f);
    g.Font = font;
    g.FontBaseSize = ImMax(1.0f, g.IO.FontGlobalScale * g.Font->FontSize * g.Font->Scale);
    g.FontSize = g.CurrentWindow ? g.CurrentWindow->CalcFontSize() : 0.0f;

    ImFontAtlas* atlas = g.Font->ContainerAtlas;
    g.DrawListSharedData.TexUvWhitePixel = atlas->TexUvWhitePixel;
    g.DrawListSharedData.TexUvLines = atlas->TexUvLines;
    g.DrawListSharedData.Font = g.Font;
    g.DrawListSharedData.FontSize = g.FontSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x14572d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0xcd82f
movq -0x8(%rbp), %rdi
callq 0xea840
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xcd838
jmp 0xcd83a
jmp 0xcd859
leaq 0xa6a4f(%rip), %rdi     # 0x174290
leaq 0xa56c1(%rip), %rsi     # 0x172f09
movl $0x18bb, %edx           # imm = 0x18BB
leaq 0xa6a55(%rip), %rcx     # 0x1742a9
callq 0xd180
movq -0x8(%rbp), %rax
movss 0x58(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xcd86c
jmp 0xcd88b
leaq 0xa6a5b(%rip), %rdi     # 0x1742ce
leaq 0xa568f(%rip), %rsi     # 0x172f09
movl $0x18bc, %edx           # imm = 0x18BC
leaq 0xa6a23(%rip), %rcx     # 0x1742a9
callq 0xd180
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1978(%rax)
movq -0x10(%rbp), %rax
movss 0xb0(%rax), %xmm1
movq -0x10(%rbp), %rax
movq 0x1978(%rax), %rax
mulss 0x14(%rax), %xmm1
movq -0x10(%rbp), %rax
movq 0x1978(%rax), %rax
mulss 0x58(%rax), %xmm1
movss 0xa336e(%rip), %xmm0    # 0x170c3c
callq 0xc88c0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1984(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1ae0(%rax)
je 0xcd904
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rdi
callq 0xebbf0
movss %xmm0, -0x20(%rbp)
jmp 0xcd90e
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0xcd90e
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1980(%rax)
movq -0x10(%rbp), %rax
movq 0x1978(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rcx), %rcx
movq %rcx, 0x1988(%rax)
movq -0x18(%rbp), %rcx
addq $0x70, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1a58(%rax)
movq -0x10(%rbp), %rax
movq 0x1978(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1990(%rax)
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1998(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FocusTopMostWindowUnderOne(ImGuiWindow*, ImGuiWindow*)
void ImGui::FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window)
{
    ImGuiContext& g = *GImGui;

    int start_idx = g.WindowsFocusOrder.Size - 1;
    if (under_this_window != NULL)
    {
        int under_this_window_idx = FindWindowFocusIndex(under_this_window);
        if (under_this_window_idx != -1)
            start_idx = under_this_window_idx - 1;
    }
    for (int i = start_idx; i >= 0; i--)
    {
        // We may later decide to test for different NoXXXInputs based on the active navigation input (mouse vs nav) but that may feel more confusing to the user.
        ImGuiWindow* window = g.WindowsFocusOrder[i];
        if (window != ignore_window && window->WasActive && !(window->Flags & ImGuiWindowFlags_ChildWindow))
            if ((window->Flags & (ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs)) != (ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs))
            {
                ImGuiWindow* focus_window = NavRestoreLastChildNavWindow(window);
                FocusWindow(focus_window);
                return;
            }
    }
    FocusWindow(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x143059(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1a98(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcff1f
movq -0x8(%rbp), %rdi
callq 0xd9f30
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
je 0xcff1d
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcff1f
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xcffaa
movq -0x18(%rbp), %rdi
addq $0x1a98, %rdi           # imm = 0x1A98
movl -0x24(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0xcff9a
movq -0x30(%rbp), %rax
testb $0x1, 0x8f(%rax)
je 0xcff9a
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
jne 0xcff9a
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x40200, %eax          # imm = 0x40200
cmpl $0x40200, %eax          # imm = 0x40200
je 0xcff98
movq -0x30(%rbp), %rdi
callq 0xd9fa0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xcb380
jmp 0xcffb3
jmp 0xcff9a
jmp 0xcff9c
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcff25
xorl %eax, %eax
movl %eax, %edi
callq 0xcb380
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::UpdateDebugToolItemPicker()
void ImGui::UpdateDebugToolItemPicker()
{
    ImGuiContext& g = *GImGui;
    g.DebugItemPickerBreakId = 0;
    if (g.DebugItemPickerActive)
    {
        const ImGuiID hovered_id = g.HoveredIdPreviousFrame;
        ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
        if (ImGui::IsKeyPressedMap(ImGuiKey_Escape))
            g.DebugItemPickerActive = false;
        if (ImGui::IsMouseClicked(0) && hovered_id)
        {
            g.DebugItemPickerBreakId = hovered_id;
            g.DebugItemPickerActive = false;
        }
        ImGui::SetNextWindowBgAlpha(0.60f);
        ImGui::BeginTooltip();
        ImGui::Text("HoveredId: 0x%08X", hovered_id);
        ImGui::Text("Press ESC to abort picking.");
        ImGui::TextColored(GetStyleColorVec4(hovered_id ? ImGuiCol_Text : ImGuiCol_TextDisabled), "Click to break in debugger!");
        ImGui::EndTooltip();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x142f71(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x3170(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x316c(%rax)
je 0xd00b2
movq -0x8(%rbp), %rax
movl 0x1b20(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x7, %edi
callq 0xd5340
movl $0xe, %edi
movl $0x1, %esi
callq 0xedee0
testb $0x1, %al
jne 0xd001e
jmp 0xd0029
movq -0x8(%rbp), %rax
movb $0x0, 0x316c(%rax)
xorl %esi, %esi
movl %esi, %edi
callq 0xd4d60
testb $0x1, %al
jne 0xd0038
jmp 0xd0056
cmpl $0x0, -0xc(%rbp)
je 0xd0056
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3170(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x316c(%rax)
movss 0xa1f4a(%rip), %xmm0    # 0x171fa8
callq 0xdae00
callq 0xddb50
movl -0xc(%rbp), %esi
leaq 0xa66f1(%rip), %rdi     # 0x176763
movb $0x0, %al
callq 0x139160
leaq 0xa66f5(%rip), %rdi     # 0x176775
movb $0x0, %al
callq 0x139160
movl -0xc(%rbp), %ecx
movl $0x1, %edi
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0xc77b0
movq %rax, %rdi
leaq 0xa66eb(%rip), %rsi     # 0x176791
movb $0x0, %al
callq 0x139290
callq 0xddce0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowSize(ImVec2 const&, int)
void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)
{
    ImGuiContext& g = *GImGui;
    IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSize;
    g.NextWindowData.SizeVal = size;
    g.NextWindowData.SizeCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x142e6a(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
je 0xd00f0
movl -0xc(%rbp), %edi
callq 0xda7c0
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xd00f9
jmp 0xd00fb
jmp 0xd011a
leaq 0xa42fb(%rip), %rdi     # 0x1743fd
leaq 0xa2e00(%rip), %rsi     # 0x172f09
movl $0x1a20, %edx           # imm = 0x1A20
leaq 0xa4448(%rip), %rcx     # 0x17455d
callq 0xd180
movq -0x18(%rbp), %rax
movl 0x1b88(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1b88(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x1ba8(%rax)
cmpl $0x0, -0xc(%rbp)
je 0xd014d
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xd0157
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd0157
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1b90(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: WindowSettingsHandler_ClearAll(ImGuiContext*, ImGuiSettingsHandler*)
static void WindowSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
{
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Windows.Size; i++)
        g.Windows[i]->SettingsOffset = -1;
    g.SettingsWindows.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1a88(%rcx), %eax
je 0xd2e99
movq -0x18(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x1c(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movl $0xffffffff, 0x2b4(%rax) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd2e5f
movq -0x18(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
callq 0xeb0f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: WindowSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, char const*)
static void* WindowSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name)
{
    ImGuiWindowSettings* settings = ImGui::FindOrCreateWindowSettings(name);
    ImGuiID id = settings->ID;
    *settings = ImGuiWindowSettings(); // Clear existing if recycling previous entry
    settings->ID = id;
    settings->WantApply = true;
    return (void*)settings;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe1130
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq -0x34(%rbp), %rdi
callq 0xec3d0
movq -0x20(%rbp), %rax
movq -0x34(%rbp), %rcx
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movw -0x28(%rbp), %cx
movw %cx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0xd(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: WindowSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void*, char const*)
static void WindowSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line)
{
    ImGuiWindowSettings* settings = (ImGuiWindowSettings*)entry;
    int x, y;
    int i;
    if (sscanf(line, "Pos=%i,%i", &x, &y) == 2)         { settings->Pos = ImVec2ih((short)x, (short)y); }
    else if (sscanf(line, "Size=%i,%i", &x, &y) == 2)   { settings->Size = ImVec2ih((short)x, (short)y); }
    else if (sscanf(line, "Collapsed=%d", &i) == 1)     { settings->Collapsed = (i != 0); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xa497d(%rip), %rsi     # 0x1778c8
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movb $0x0, %al
callq 0xd0d0
cmpl $0x2, %eax
jne 0xd2f83
movl -0x2c(%rbp), %eax
movw %ax, %cx
movl -0x30(%rbp), %eax
leaq -0x38(%rbp), %rdi
movswl %cx, %esi
movswl %ax, %edx
callq 0xee910
movq -0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0xd2ff6
movq -0x20(%rbp), %rdi
leaq 0xa4944(%rip), %rsi     # 0x1778d2
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movb $0x0, %al
callq 0xd0d0
cmpl $0x2, %eax
jne 0xd2fc6
movl -0x2c(%rbp), %eax
movw %ax, %cx
movl -0x30(%rbp), %eax
leaq -0x3c(%rbp), %rdi
movswl %cx, %esi
movswl %ax, %edx
callq 0xee910
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0xd2ff4
movq -0x20(%rbp), %rdi
leaq 0xa3659(%rip), %rsi     # 0x17662a
leaq -0x34(%rbp), %rdx
movb $0x0, %al
callq 0xd0d0
cmpl $0x1, %eax
jne 0xd2ff2
cmpl $0x0, -0x34(%rbp)
setne %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, 0xc(%rax)
jmp 0xd2ff4
jmp 0xd2ff6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: WindowSettingsHandler_ApplyAll(ImGuiContext*, ImGuiSettingsHandler*)
static void WindowSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
{
    ImGuiContext& g = *ctx;
    for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
        if (settings->WantApply)
        {
            if (ImGuiWindow* window = ImGui::FindWindowByID(settings->ID))
                ApplyWindowSettings(window, settings);
            settings->WantApply = false;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
callq 0xec430
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd3084
movq -0x20(%rbp), %rax
testb $0x1, 0xd(%rax)
je 0xd3068
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0xd64d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd3060
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe55b0
movq -0x20(%rbp), %rax
movb $0x0, 0xd(%rax)
jmp 0xd306a
movq -0x18(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
movq -0x20(%rbp), %rsi
callq 0xec470
movq %rax, -0x20(%rbp)
jmp 0xd302c
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SaveIniSettingsToDisk(char const*)
void ImGui::SaveIniSettingsToDisk(const char* ini_filename)
{
    ImGuiContext& g = *GImGui;
    g.SettingsDirtyTimer = 0.0f;
    if (!ini_filename)
        return;

    size_t ini_data_size = 0;
    const char* ini_data = SaveIniSettingsToMemory(&ini_data_size);
    ImFileHandle f = ImFileOpen(ini_filename, "wt");
    if (!f)
        return;
    ImFileWrite(ini_data, sizeof(char), ini_data_size, f);
    ImFileClose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x13fbfd(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x30e4(%rax)
cmpq $0x0, -0x8(%rbp)
jne 0xd335f
jmp 0xd33b0
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xe1750
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa25a0(%rip), %rsi     # 0x17591f
callq 0xc5050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd3391
jmp 0xd33b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0xc5180
movq -0x28(%rbp), %rdi
callq 0xc5080
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImDrawDataBuilder::FlattenIntoSingleLayer()
void ImDrawDataBuilder::FlattenIntoSingleLayer()
{
    int n = Layers[0].Size;
    int size = n;
    for (int i = 1; i < IM_ARRAYSIZE(Layers); i++)
        size += Layers[i].Size;
    Layers[0].resize(size);
    for (int layer_n = 1; layer_n < IM_ARRAYSIZE(Layers); layer_n++)
    {
        ImVector<ImDrawList*>& layer = Layers[layer_n];
        if (layer.empty())
            continue;
        memcpy(&Layers[0][n], &layer[0], layer.Size * sizeof(ImDrawList*));
        n += layer.Size;
        layer.resize(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0xd340e
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd33e6
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xeb180
movl $0x1, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0xd349f
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xeb1d0
testb $0x1, %al
jne 0xd3449
jmp 0xd344b
jmp 0xd3494
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xeb1f0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xeb1f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rdx
shlq $0x3, %rdx
callq 0xd0a0
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xeb180
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd3421
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ClearDragDrop()
void ImGui::ClearDragDrop()
{
    ImGuiContext& g = *GImGui;
    g.DragDropActive = false;
    g.DragDropPayload.Clear();
    g.DragDropAcceptFlags = ImGuiDragDropFlags_None;
    g.DragDropAcceptIdCurr = g.DragDropAcceptIdPrev = 0;
    g.DragDropAcceptIdCurrRectSurface = FLT_MAX;
    g.DragDropAcceptFrameCount = -1;

    g.DragDropPayloadBufHeap.clear();
    memset(&g.DragDropPayloadBufLocal, 0, sizeof(g.DragDropPayloadBufLocal));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x13ee71(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x2004(%rax)
movq -0x8(%rbp), %rdi
addq $0x2018, %rdi           # imm = 0x2018
callq 0xec120
movq -0x8(%rbp), %rax
movl $0x0, 0x206c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2078(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2074(%rax)
movq -0x8(%rbp), %rax
movss 0x9de90(%rip), %xmm0    # 0x171fb4
movss %xmm0, 0x2070(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x207c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
addq $0x2088, %rdi           # imm = 0x2088
callq 0xec180
movq -0x8(%rbp), %rdi
addq $0x2098, %rdi           # imm = 0x2098
xorl %esi, %esi
movl $0x10, %edx
callq 0xd2f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: AddWindowToSortBuffer(ImVector<ImGuiWindow*>*, ImGuiWindow*)
static void AddWindowToSortBuffer(ImVector<ImGuiWindow*>* out_sorted_windows, ImGuiWindow* window)
{
    out_sorted_windows->push_back(window);
    if (window->Active)
    {
        int count = window->DC.ChildWindows.Size;
        if (count > 1)
            ImQsort(window->DC.ChildWindows.Data, (size_t)count, sizeof(ImGuiWindow*), ChildWindowComparer);
        for (int i = 0; i < count; i++)
        {
            ImGuiWindow* child = window->DC.ChildWindows[i];
            if (child->Active)
                AddWindowToSortBuffer(out_sorted_windows, child);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xeb620
movq -0x10(%rbp), %rax
testb $0x1, 0x8e(%rax)
je 0xd42ca
movq -0x10(%rbp), %rax
movl 0x198(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0xd4271
movq -0x10(%rbp), %rax
movq 0x1a0(%rax), %rdi
movslq -0x14(%rbp), %rsi
movl $0x8, %edx
leaq 0x111f4(%rip), %rcx     # 0xe5460
callq 0xd6c0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd42c8
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
addq $0xc0, %rdi
movl -0x18(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x8e(%rax)
je 0xd42bb
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd4210
jmp 0xd42bd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd4278
jmp 0xd42ca
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: SetupDrawData(ImVector<ImDrawList*>*, ImDrawData*)
static void SetupDrawData(ImVector<ImDrawList*>* draw_lists, ImDrawData* draw_data)
{
    ImGuiIO& io = ImGui::GetIO();
    draw_data->Valid = true;
    draw_data->CmdLists = (draw_lists->Size > 0) ? draw_lists->Data : NULL;
    draw_data->CmdListsCount = draw_lists->Size;
    draw_data->TotalVtxCount = draw_data->TotalIdxCount = 0;
    draw_data->DisplayPos = ImVec2(0.0f, 0.0f);
    draw_data->DisplaySize = io.DisplaySize;
    draw_data->FramebufferScale = io.DisplayFramebufferScale;
    for (int n = 0; n < draw_lists->Size; n++)
    {
        draw_data->TotalVtxCount += draw_lists->Data[n]->VtxBuffer.Size;
        draw_data->TotalIdxCount += draw_lists->Data[n]->IdxBuffer.Size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xcb1a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0xd4817
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xd481f
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xd481f
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x1c(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0xb8(%rcx), %rcx
movq %rcx, 0x2c(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd48e3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd4893
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsKeyDown(int)
bool ImGui::IsKeyDown(int user_key_index)
{
    if (user_key_index < 0)
        return false;
    ImGuiContext& g = *GImGui;
    IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    return g.IO.KeysDown[user_key_index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xd4977
movb $0x0, -0x1(%rbp)
jmp 0xd49d8
movq 0x13e5c2(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jl 0xd499a
cmpl $0x200, -0x8(%rbp)      # imm = 0x200
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xd49a3
jmp 0xd49a5
jmp 0xd49c4
leaq 0x9f0ef(%rip), %rdi     # 0x173a9b
leaq 0x9e556(%rip), %rsi     # 0x172f09
movl $0x1185, %edx           # imm = 0x1185
leaq 0x9f13e(%rip), %rcx     # 0x173afd
callq 0xd180
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movb 0x144(%rax,%rcx), %al
andb $0x1, %al
movb %al, -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.cpp
// Function: ImGui::CalcTypematicRepeatAmount(float, float, float, float)
int ImGui::CalcTypematicRepeatAmount(float t0, float t1, float repeat_delay, float repeat_rate)
{
    if (t1 == 0.0f)
        return 1;
    if (t0 >= t1)
        return 0;
    if (repeat_rate <= 0.0f)
        return (t0 < repeat_delay) && (t1 >= repeat_delay);
    const int count_t0 = (t0 < repeat_delay) ? -1 : (int)((t0 - repeat_delay) / repeat_rate);
    const int count_t1 = (t1 < repeat_delay) ? -1 : (int)((t1 - repeat_delay) / repeat_rate);
    const int count = count_t1 - count_t0;
    return count;
}

// 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), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xd4a23
jp 0xd4a23
movl $0x1, -0x4(%rbp)
jmp 0xd4aec
movss -0x8(%rbp), %xmm0
ucomiss -0xc(%rbp), %xmm0
jb 0xd4a3a
movl $0x0, -0x4(%rbp)
jmp 0xd4aec
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0xd4a73
movss -0x8(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, -0x21(%rbp)
jbe 0xd4a66
movss -0xc(%rbp), %xmm0
ucomiss -0x10(%rbp), %xmm0
setae %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xd4aec
movss -0x8(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xd4a8c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rbp)
jmp 0xd4aa2
movss -0x8(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
divss -0x14(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movss -0xc(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xd4ac1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0xd4ad7
movss -0xc(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
divss -0x14(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetKeyPressedAmount(int, float, float)
int ImGui::GetKeyPressedAmount(int key_index, float repeat_delay, float repeat_rate)
{
    ImGuiContext& g = *GImGui;
    if (key_index < 0)
        return 0;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[key_index];
    return CalcTypematicRepeatAmount(t - g.IO.DeltaTime, t, repeat_delay, repeat_rate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq 0x13e424(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xd4b2f
movl $0x0, -0x4(%rbp)
jmp 0xd4bac
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x1d(%rbp)
jl 0xd4b47
cmpl $0x200, -0x8(%rbp)      # imm = 0x200
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xd4b50
jmp 0xd4b52
jmp 0xd4b71
leaq 0x9efbf(%rip), %rdi     # 0x173b18
leaq 0x9e3a9(%rip), %rsi     # 0x172f09
movl $0x11a0, %edx           # imm = 0x11A0
leaq 0x9f004(%rip), %rcx     # 0x173b70
callq 0xd180
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0x4a0(%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x18(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0xc(%rbp), %xmm2
movss -0x10(%rbp), %xmm3
callq 0xd49f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsKeyPressed(int, bool)
bool ImGui::IsKeyPressed(int user_key_index, bool repeat)
{
    ImGuiContext& g = *GImGui;
    if (user_key_index < 0)
        return false;
    IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[user_key_index];
    if (t == 0.0f)
        return true;
    if (repeat && t > g.IO.KeyRepeatDelay)
        return GetKeyPressedAmount(user_key_index, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate) > 0;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x13e366(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xd4bed
movb $0x0, -0x1(%rbp)
jmp 0xd4ca3
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x1d(%rbp)
jl 0xd4c05
cmpl $0x200, -0x8(%rbp)      # imm = 0x200
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xd4c0e
jmp 0xd4c10
jmp 0xd4c2f
leaq 0x9ee84(%rip), %rdi     # 0x173a9b
leaq 0x9e2eb(%rip), %rsi     # 0x172f09
movl $0x11aa, %edx           # imm = 0x11AA
leaq 0x9ef78(%rip), %rcx     # 0x173ba2
callq 0xd180
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0x4a0(%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xd4c5a
jp 0xd4c5a
movb $0x1, -0x1(%rbp)
jmp 0xd4ca3
testb $0x1, -0x9(%rbp)
je 0xd4c9f
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomiss 0x94(%rax), %xmm0
jbe 0xd4c9f
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rax
movss 0x94(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x98(%rax), %xmm1
callq 0xd4b00
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd4ca3
movb $0x0, -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::IsKeyReleased(int)
bool ImGui::IsKeyReleased(int user_key_index)
{
    ImGuiContext& g = *GImGui;
    if (user_key_index < 0) return false;
    IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    return g.IO.KeysDownDurationPrev[user_key_index] >= 0.0f && !g.IO.KeysDown[user_key_index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0x13e27e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xd4cd2
movb $0x0, -0x1(%rbp)
jmp 0xd4d4e
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jl 0xd4cea
cmpl $0x200, -0x8(%rbp)      # imm = 0x200
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xd4cf3
jmp 0xd4cf5
jmp 0xd4d14
leaq 0x9ed9f(%rip), %rdi     # 0x173a9b
leaq 0x9e206(%rip), %rsi     # 0x172f09
movl $0x11b7, %edx           # imm = 0x11B7
leaq 0x9eeb7(%rip), %rcx     # 0x173bc6
callq 0xd180
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movss 0xca0(%rax,%rcx,4), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x12(%rbp)
jb 0xd4d46
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movb 0x144(%rax,%rcx), %al
xorb $-0x1, %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)