LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowPos(ImVec2 const&, int, ImVec2 const&)
void ImGui::SetNextWindowPos(const ImVec2& pos, ImGuiCond cond, const ImVec2& pivot)
{
    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_HasPos;
    g.NextWindowData.PosVal = pos;
    g.NextWindowData.PosPivotVal = pivot;
    g.NextWindowData.PosCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x1383e6(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x21(%rbp)
je 0xdab74
movl -0xc(%rbp), %edi
callq 0xda7c0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xdab7d
jmp 0xdab7f
jmp 0xdab9e
leaq 0x99877(%rip), %rdi     # 0x1743fd
leaq 0x9837c(%rip), %rsi     # 0x172f09
movl $0x1a16, %edx           # imm = 0x1A16
leaq 0x9997c(%rip), %rcx     # 0x174515
callq 0xd180
movq -0x20(%rbp), %rax
movl 0x1b88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x1b88(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x1b98(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x1ba0(%rax)
cmpl $0x0, -0xc(%rbp)
je 0xdabe3
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xdabed
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xdabed
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1b8c(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowSizeConstraints(ImVec2 const&, ImVec2 const&, void (*)(ImGuiSizeCallbackData*), void*)
void ImGui::SetNextWindowSizeConstraints(const ImVec2& size_min, const ImVec2& size_max, ImGuiSizeCallback custom_callback, void* custom_callback_user_data)
{
    ImGuiContext& g = *GImGui;
    g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasSizeConstraint;
    g.NextWindowData.SizeConstraintRect = ImRect(size_min, size_max);
    g.NextWindowData.SizeCallback = custom_callback;
    g.NextWindowData.SizeCallbackUserData = custom_callback_user_data;
}

// 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 0x138321(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x1b88(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x1b88(%rax)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe8660
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x1bc4(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x1bcc(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x1bd8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x1be0(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetNextWindowCollapsed(bool, int)
void ImGui::SetNextWindowCollapsed(bool collapsed, 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_HasCollapsed;
    g.NextWindowData.CollapsedVal = collapsed;
    g.NextWindowData.CollapsedCond = cond ? cond : ImGuiCond_Always;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq 0x138206(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movb $0x1, %al
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0xdad54
movl -0x8(%rbp), %edi
callq 0xda7c0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xdad5d
jmp 0xdad5f
jmp 0xdad7e
leaq 0x99697(%rip), %rdi     # 0x1743fd
leaq 0x9819c(%rip), %rsi     # 0x172f09
movl $0x1a42, %edx           # imm = 0x1A42
leaq 0x9981d(%rip), %rcx     # 0x174596
callq 0xd180
movq -0x10(%rbp), %rax
movl 0x1b88(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x1b88(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1bc0(%rax)
cmpl $0x0, -0x8(%rbp)
je 0xdadaf
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xdadb9
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xdadb9
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1b94(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetWindowFontScale(float)
void ImGui::SetWindowFontScale(float scale)
{
    IM_ASSERT(scale > 0.0f);
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->FontWindowScale = scale;
    g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xdaeec
jmp 0xdaf0b
leaq 0x996d7(%rip), %rdi     # 0x1745ca
leaq 0x9800f(%rip), %rsi     # 0x172f09
movl $0x1a6c, %edx           # imm = 0x1A6C
leaq 0x996d1(%rip), %rcx     # 0x1745d7
callq 0xd180
movq 0x13802e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
callq 0xeb270
movq %rax, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x2b0(%rax)
movq -0x18(%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
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushFocusScope(unsigned int)
void ImGui::PushFocusScope(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    g.FocusScopeStack.push_back(window->DC.NavFocusScopeIdCurrent);
    window->DC.NavFocusScopeIdCurrent = id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x137f9e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c40, %rdi           # imm = 0x1C40
movq -0x18(%rbp), %rsi
addq $0xd8, %rsi
addq $0x80, %rsi
callq 0xe8e70
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x158(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopFocusScope()
void ImGui::PopFocusScope()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(g.FocusScopeStack.Size > 0); // Too many PopFocusScope() ?
    window->DC.NavFocusScopeIdCurrent = g.FocusScopeStack.back();
    g.FocusScopeStack.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x137f41(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c40(%rax)
jle 0xdb021
jmp 0xdb040
leaq 0x995d5(%rip), %rdi     # 0x1745fd
leaq 0x97eda(%rip), %rsi     # 0x172f09
movl $0x1a85, %edx           # imm = 0x1A85
leaq 0x995dd(%rip), %rcx     # 0x174618
callq 0xd180
movq -0x8(%rbp), %rdi
addq $0x1c40, %rdi           # imm = 0x1C40
callq 0xe9130
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x158(%rax)
movq -0x8(%rbp), %rdi
addq $0x1c40, %rdi           # imm = 0x1C40
callq 0xebf40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetKeyboardFocusHere(int)
void ImGui::SetKeyboardFocusHere(int offset)
{
    IM_ASSERT(offset >= -1);    // -1 is allowed but not below
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    g.FocusRequestNextWindow = window;
    g.FocusRequestNextCounterRegular = window->DC.FocusCounterRegular + 1 + offset;
    g.FocusRequestNextCounterTabStop = INT_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jl 0xdb093
jmp 0xdb0b2
leaq 0x9959a(%rip), %rdi     # 0x174634
leaq 0x97e68(%rip), %rsi     # 0x172f09
movl $0x1a8c, %edx           # imm = 0x1A8C
leaq 0x99594(%rip), %rcx     # 0x174641
callq 0xd180
movq 0x137e87(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1df0(%rax)
movq -0x18(%rbp), %rax
movl 0x1c4(%rax), %ecx
addl $0x1, %ecx
addl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1e00(%rax)
movq -0x10(%rbp), %rax
movl $0x7fffffff, 0x1e04(%rax) # imm = 0x7FFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetItemDefaultFocus()
void ImGui::SetItemDefaultFocus()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (!window->Appearing)
        return;
    if (g.NavWindow == window->RootWindowForNav && (g.NavInitRequest || g.NavInitResultId != 0) && g.NavLayer == g.NavWindow->DC.NavLayerCurrent)
    {
        g.NavInitRequest = false;
        g.NavInitResultId = g.NavWindow->DC.LastItemId;
        g.NavInitResultRectRel = ImRect(g.NavWindow->DC.LastItemRect.Min - g.NavWindow->Pos, g.NavWindow->DC.LastItemRect.Max - g.NavWindow->Pos);
        NavUpdateAnyRequestFlag();
        if (!IsItemVisible())
            SetScrollHereY();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x137e21(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x94(%rax)
jne 0xdb144
jmp 0xdb24f
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3a0(%rcx), %rax
jne 0xdb24f
movq -0x8(%rbp), %rax
testb $0x1, 0x1ce9(%rax)
jne 0xdb17e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1cec(%rax)
je 0xdb24f
movq -0x8(%rbp), %rax
movl 0x1cdc(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x1c90(%rcx), %rcx
cmpl 0x14c(%rcx), %eax
jne 0xdb24f
movq -0x8(%rbp), %rax
movb $0x0, 0x1ce9(%rax)
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rcx
movl 0x124(%rcx), %ecx
movl %ecx, 0x1cec(%rax)
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rsi
movq %rsi, %rdi
addq $0x12c, %rdi            # imm = 0x12C
addq $0x10, %rsi
callq 0xc3c00
movlpd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rsi
movq %rsi, %rdi
addq $0x134, %rdi            # imm = 0x134
addq $0x10, %rsi
callq 0xc3c00
movlpd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xe8660
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x1cf0(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x1cf8(%rax)
callq 0xdb260
callq 0xd56f0
testb $0x1, %al
jne 0xdb24d
movss 0x96d90(%rip), %xmm0    # 0x171fd8
callq 0xdb300
jmp 0xdb24f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavUpdateAnyRequestFlag()
static inline void ImGui::NavUpdateAnyRequestFlag()
{
    ImGuiContext& g = *GImGui;
    g.NavAnyRequest = g.NavMoveRequest || g.NavInitRequest || (IMGUI_DEBUG_NAV_SCORING && g.NavWindow != NULL);
    if (g.NavAnyRequest)
        IM_ASSERT(g.NavWindow != NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x137cd1(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x1d00(%rcx)
movb %al, -0x9(%rbp)
jne 0xdb29e
movq -0x8(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x1ce9(%rcx)
movb %al, -0x9(%rbp)
jne 0xdb29e
xorl %eax, %eax
movb %al, -0x9(%rbp)
jmp 0xdb29e
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1ce8(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x1ce8(%rax)
je 0xdb2ec
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
je 0xdb2cb
jmp 0xdb2ea
leaq 0x9c2f1(%rip), %rdi     # 0x1775c3
leaq 0x97c30(%rip), %rsi     # 0x172f09
movl $0x2200, %edx           # imm = 0x2200
leaq 0x9c2f4(%rip), %rcx     # 0x1775d9
callq 0xd180
jmp 0xdb2ec
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollHereY(float)
void ImGui::SetScrollHereY(float center_y_ratio)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float spacing_y = g.Style.ItemSpacing.y;
    float target_pos_y = ImLerp(window->DC.CursorPosPrevLine.y - spacing_y, window->DC.CursorPosPrevLine.y + window->DC.PrevLineSize.y + spacing_y, center_y_ratio);
    SetScrollFromPosY(window, target_pos_y - window->Pos.y, center_y_ratio); // Convert from absolute to local pos

    // Tweak: snap on edges when aiming at an item very close to the edge
    window->ScrollTargetEdgeSnapDist.y = ImMax(0.0f, window->WindowPadding.y - spacing_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq 0x137c2c(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x15ac(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0xe4(%rax), %xmm0
subss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss 0xe4(%rax), %xmm1
movq -0x18(%rbp), %rax
addss 0x10c(%rax), %xmm1
addss -0x1c(%rbp), %xmm1
movss -0x4(%rbp), %xmm2
callq 0xddb10
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x14(%rax), %xmm0
movss -0x4(%rbp), %xmm1
callq 0xdd740
movq -0x18(%rbp), %rax
movss 0x44(%rax), %xmm1
subss -0x1c(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0xc88c0
movq -0x18(%rbp), %rax
movss %xmm0, 0x80(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(char const*)
void ImGui::PushID(const char* str_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(str_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x137aed(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9b80
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0xe8e70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(char const*, char const*)
void ImGui::PushID(const char* str_id_begin, const char* str_id_end)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(str_id_begin, str_id_end);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x137a89(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xc9b80
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x24(%rbp), %rsi
callq 0xe8e70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(void const*)
void ImGui::PushID(const void* ptr_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(ptr_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x137a2d(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xc9bf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0xe8e70
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushID(int)
void ImGui::PushID(int int_id)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiID id = window->GetIDNoKeepAlive(int_id);
    window->IDStack.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x1379de(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xc9c40
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0xe8e70
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetIDWithSeed(char const*, char const*, unsigned int)
ImGuiID ImGui::GetIDWithSeed(const char* str, const char* str_end, ImGuiID seed)
{
    ImGuiID id = ImHashStr(str, str_end ? (str_end - str) : 0, seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO2(id, ImGuiDataType_String, str, str_end);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdb613
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xdb61b
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xdb61b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xc4f20
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0xc9a90
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SameLine(float, float)
void ImGui::SameLine(float offset_from_start_x, float spacing_w)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiContext& g = *GImGui;
    if (offset_from_start_x != 0.0f)
    {
        if (spacing_w < 0.0f) spacing_w = 0.0f;
        window->DC.CursorPos.x = window->Pos.x - window->Scroll.x + offset_from_start_x + spacing_w + window->DC.GroupOffset.x + window->DC.ColumnsOffset.x;
        window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
    }
    else
    {
        if (spacing_w < 0.0f) spacing_w = g.Style.ItemSpacing.x;
        window->DC.CursorPos.x = window->DC.CursorPosPrevLine.x + spacing_w;
        window->DC.CursorPos.y = window->DC.CursorPosPrevLine.y;
    }
    window->DC.CurrLineSize = window->DC.PrevLineSize;
    window->DC.CurrLineTextBaseOffset = window->DC.PrevLineTextBaseOffset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
callq 0xeb270
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0xdc1ed
jmp 0xdc2f1
movq 0x136d4c(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xdc209
jp 0xdc209
jmp 0xdc274
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0xdc21a
xorps %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x5c(%rax), %xmm0
addss -0x4(%rbp), %xmm0
addss -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss 0x120(%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x11c(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xd8(%rax)
movq -0x10(%rbp), %rax
movss 0xe4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xdc(%rax)
jmp 0xdc2c3
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0xdc28e
movq -0x18(%rbp), %rax
movss 0x15a8(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movss 0xe0(%rax), %xmm0
addss -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xd8(%rax)
movq -0x10(%rbp), %rax
movss 0xe4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xdc(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x108(%rcx), %rcx
movq %rcx, 0x100(%rax)
movq -0x10(%rbp), %rax
movss 0x114(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x110(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::Indent(float)
void ImGui::Indent(float indent_w)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindow();
    window->DC.Indent.x += (indent_w != 0.0f) ? indent_w : g.Style.IndentSpacing;
    window->DC.CursorPos.x = window->Pos.x + window->DC.Indent.x + window->DC.ColumnsOffset.x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq 0x13655c(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
callq 0xeb270
movq %rax, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xdca02
jp 0xdca02
jmp 0xdca0e
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0xdca1f
movq -0x10(%rbp), %rax
movss 0x15c8(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x118(%rax), %xmm0
movss %xmm0, 0x118(%rax)
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x118(%rax), %xmm0
movq -0x18(%rbp), %rax
addss 0x11c(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xd8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushItemWidth(float)
void ImGui::PushItemWidth(float item_width)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->DC.ItemWidth = (item_width == 0.0f ? window->ItemWidthDefault : item_width);
    window->DC.ItemWidthStack.push_back(window->DC.ItemWidth);
    g.NextItemData.Flags &= ~ImGuiNextItemDataFlags_HasWidth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq 0x13641c(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xdcb59
jp 0xdcb59
movq -0x18(%rbp), %rax
movss 0x288(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0xdcb63
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x1d0(%rax)
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rsi
addq $0xd8, %rsi
addq $0xf8, %rsi
callq 0xebde0
movq -0x10(%rbp), %rax
movl 0x1bf8(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x1bf8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushMultiItemsWidths(int, float)
void ImGui::PushMultiItemsWidths(int components, float w_full)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiStyle& style = g.Style;
    const float w_item_one  = ImMax(1.0f, IM_FLOOR((w_full - (style.ItemInnerSpacing.x) * (components - 1)) / (float)components));
    const float w_item_last = ImMax(1.0f, IM_FLOOR(w_full - (w_item_one + style.ItemInnerSpacing.x) * (components - 1)));
    window->DC.ItemWidthStack.push_back(w_item_last);
    for (int i = 0; i < components - 1; i++)
        window->DC.ItemWidthStack.push_back(w_item_one);
    window->DC.ItemWidth = window->DC.ItemWidthStack.back();
    g.NextItemData.Flags &= ~ImGuiNextItemDataFlags_HasWidth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq 0x136369(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
movq %rax, -0x20(%rbp)
movss -0x8(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x50(%rax), %xmm0
movl -0x4(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvtsi2ssl -0x4(%rbp), %xmm1
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm1
movss 0x93ffe(%rip), %xmm0    # 0x170c3c
callq 0xc88c0
movss %xmm0, -0x24(%rbp)
movss -0x8(%rbp), %xmm1
movss -0x24(%rbp), %xmm0
movq -0x20(%rbp), %rax
addss 0x50(%rax), %xmm0
movl -0x4(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm1
movss 0x93fb2(%rip), %xmm0    # 0x170c3c
callq 0xc88c0
movss %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x28(%rbp), %rsi
callq 0xebde0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xdcce9
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x24(%rbp), %rsi
callq 0xebde0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xdccb6
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0xebeb0
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x1d0(%rax)
movq -0x10(%rbp), %rax
movl 0x1bf8(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x1bf8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcItemWidth()
float ImGui::CalcItemWidth()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float w;
    if (g.NextItemData.Flags & ImGuiNextItemDataFlags_HasWidth)
        w = g.NextItemData.Width;
    else
        w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        float region_max_x = GetContentRegionMaxAbs().x;
        w = ImMax(1.0f, region_max_x - window->DC.CursorPos.x + w);
    }
    w = IM_FLOOR(w);
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x136171(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1bf8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xdce07
movq -0x8(%rbp), %rax
movss 0x1bfc(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0xdce18
movq -0x10(%rbp), %rax
movss 0x1d0(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0xdce5d
callq 0xdce80
movlpd %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
subss 0xd8(%rax), %xmm1
addss -0x14(%rbp), %xmm1
movss 0x93de9(%rip), %xmm0    # 0x170c3c
callq 0xc88c0
movss %xmm0, -0x14(%rbp)
cvttss2si -0x14(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetContentRegionMaxAbs()
ImVec2 ImGui::GetContentRegionMaxAbs()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x;
    return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1360b5(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1b0(%rax)
jne 0xdcec9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20a8(%rax)
je 0xdceda
movq -0x18(%rbp), %rax
movss 0x240(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcItemSize(ImVec2, float, float)
ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_w, float default_h)
{
    ImGuiWindow* window = GImGui->CurrentWindow;

    ImVec2 region_max;
    if (size.x < 0.0f || size.y < 0.0f)
        region_max = GetContentRegionMaxAbs();

    if (size.x == 0.0f)
        size.x = default_w;
    else if (size.x < 0.0f)
        size.x = ImMax(4.0f, region_max.x - window->DC.CursorPos.x + size.x);

    if (size.y == 0.0f)
        size.y = default_h;
    else if (size.y < 0.0f)
        size.y = ImMax(4.0f, region_max.y - window->DC.CursorPos.y + size.y);

    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movlpd %xmm0, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movq 0x136032(%rip), %rax    # 0x212f40
movq 0x1ae0(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe7de0
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
ja 0xdcf34
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0xdcf46
callq 0xdce80
movlpd %xmm0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xdcf61
jp 0xdcf61
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
jmp 0xdcf94
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0xdcf92
movss -0x28(%rbp), %xmm1
movq -0x20(%rbp), %rax
subss 0xd8(%rax), %xmm1
addss -0x10(%rbp), %xmm1
movss 0x957ac(%rip), %xmm0    # 0x172734
callq 0xc88c0
movss %xmm0, -0x10(%rbp)
jmp 0xdcf94
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xdcfaf
jp 0xdcfaf
movss -0x18(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0xdcfe2
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0xdcfe0
movss -0x24(%rbp), %xmm1
movq -0x20(%rbp), %rax
subss 0xdc(%rax), %xmm1
addss -0xc(%rbp), %xmm1
movss 0x9575e(%rip), %xmm0    # 0x172734
callq 0xc88c0
movss %xmm0, -0xc(%rbp)
jmp 0xdcfe2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GetContentRegionMax()
ImVec2 ImGui::GetContentRegionMax()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImVec2 mx = window->ContentRegionRect.Max - window->Pos;
    if (window->DC.CurrentColumns || g.CurrentTable)
        mx.x = window->WorkRect.Max.x - window->Pos.x;
    return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x135e61(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x270, %rdi            # imm = 0x270
addq $0x10, %rsi
callq 0xc3c00
movlpd %xmm0, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1b0(%rax)
jne 0xdd12a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20a8(%rax)
je 0xdd144
movq -0x18(%rbp), %rax
movss 0x240(%rax), %xmm0
movq -0x18(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollFromPosX(ImGuiWindow*, float, float)
void ImGui::SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio)
{
    IM_ASSERT(center_x_ratio >= 0.0f && center_x_ratio <= 1.0f);
    window->ScrollTarget.x = IM_FLOOR(local_x + window->Scroll.x); // Convert local position to scroll offset
    window->ScrollTargetCenterRatio.x = center_x_ratio;
    window->ScrollTargetEdgeSnapDist.x = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rbp)
jb 0xdd6ca
movss 0x9357c(%rip), %xmm0    # 0x170c3c
ucomiss -0x10(%rbp), %xmm0
setae %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xdd6d3
jmp 0xdd6d5
jmp 0xdd6f4
leaq 0x977fe(%rip), %rdi     # 0x174eda
leaq 0x95826(%rip), %rsi     # 0x172f09
movl $0x1e45, %edx           # imm = 0x1E45
leaq 0x9781c(%rip), %rcx     # 0x174f0b
callq 0xd180
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x5c(%rax), %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x6c(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x74(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x7c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollFromPosY(ImGuiWindow*, float, float)
void ImGui::SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio)
{
    IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
    local_y -= window->TitleBarHeight() + window->MenuBarHeight(); // FIXME: Would be nice to have a more standardized access to our scrollable/client rect
    window->ScrollTarget.y = IM_FLOOR(local_y + window->Scroll.y); // Convert local position to scroll offset
    window->ScrollTargetCenterRatio.y = center_y_ratio;
    window->ScrollTargetEdgeSnapDist.y = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rbp)
jb 0xdd77a
movss 0x934cc(%rip), %xmm0    # 0x170c3c
ucomiss -0x10(%rbp), %xmm0
setae %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xdd783
jmp 0xdd785
jmp 0xdd7a4
leaq 0x977ba(%rip), %rdi     # 0x174f46
leaq 0x95776(%rip), %rsi     # 0x172f09
movl $0x1e4d, %edx           # imm = 0x1E4D
leaq 0x977d8(%rip), %rcx     # 0x174f77
callq 0xd180
movq -0x8(%rbp), %rdi
callq 0xeb6f0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xeb760
movss -0x18(%rbp), %xmm1
addss %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
addss 0x60(%rax), %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x70(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x80(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetScrollHereX(float)
void ImGui::SetScrollHereX(float center_x_ratio)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    float spacing_x = g.Style.ItemSpacing.x;
    float target_pos_x = ImLerp(window->DC.LastItemRect.Min.x - spacing_x, window->DC.LastItemRect.Max.x + spacing_x, center_x_ratio);
    SetScrollFromPosX(window, target_pos_x - window->Pos.x, center_x_ratio); // Convert from absolute to local pos

    // Tweak: snap on edges when aiming at an item very close to the edge
    window->ScrollTargetEdgeSnapDist.x = ImMax(0.0f, window->WindowPadding.x - spacing_x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movq 0x1354cc(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x15a8(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0x12c(%rax), %xmm0
subss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss 0x134(%rax), %xmm1
addss -0x1c(%rbp), %xmm1
movss -0x4(%rbp), %xmm2
callq 0xddb10
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x10(%rax), %xmm0
movss -0x4(%rbp), %xmm1
callq 0xdd690
movq -0x18(%rbp), %rax
movss 0x40(%rax), %xmm1
subss -0x1c(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0xc88c0
movq -0x18(%rbp), %rax
movss %xmm0, 0x7c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsPopupOpen(char const*, int)
bool ImGui::IsPopupOpen(const char* str_id, ImGuiPopupFlags popup_flags)
{
    ImGuiContext& g = *GImGui;
    ImGuiID id = (popup_flags & ImGuiPopupFlags_AnyPopupId) ? 0 : g.CurrentWindow->GetID(str_id);
    if ((popup_flags & ImGuiPopupFlags_AnyPopupLevel) && id != 0)
        IM_ASSERT(0 && "Cannot use IsPopupOpen() with a string id and ImGuiPopupFlags_AnyPopupLevel."); // But non-string version is legal and used internally
    return IsPopupOpen(id, popup_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x1351ca(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xddd8e
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xddda9
movq -0x18(%rbp), %rax
movq 0x1ae0(%rax), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xddde1
cmpl $0x0, -0x1c(%rbp)
je 0xddde1
leaq 0x97284(%rip), %rdi     # 0x17504d
leaq 0x95139(%rip), %rsi     # 0x172f09
movl $0x1ee1, %edx           # imm = 0x1EE1
leaq 0x972c5(%rip), %rcx     # 0x1750a1
callq 0xd180
movl -0x1c(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xcbb60
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::NavCalcPreferredRefPos()
static ImVec2 ImGui::NavCalcPreferredRefPos()
{
    ImGuiContext& g = *GImGui;
    if (g.NavDisableHighlight || !g.NavDisableMouseHover || !g.NavWindow)
    {
        // Mouse (we need a fallback in case the mouse becomes invalid after being used)
        if (IsMousePosValid(&g.IO.MousePos))
            return g.IO.MousePos;
        return g.LastValidMousePos;
    }
    else
    {
        // When navigation is active and mouse is disabled, decide on an arbitrary position around the bottom left of the currently navigated item.
        const ImRect& rect_rel = g.NavWindow->NavRectRel[g.NavLayer];
        ImVec2 pos = g.NavWindow->Pos + ImVec2(rect_rel.Min.x + ImMin(g.Style.FramePadding.x * 4, rect_rel.GetWidth()), rect_rel.Max.y - ImMin(g.Style.FramePadding.y, rect_rel.GetHeight()));
        ImRect visible_rect = GetViewportRect();
        return ImFloor(ImClamp(pos, visible_rect.Min, visible_rect.Max));   // ImFloor() is important because non-integer mouse position application in backend might be lossy and result in undesirable non-zero delta.
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x134f31(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x1ce6(%rax)
jne 0xde03b
movq -0x10(%rbp), %rax
testb $0x1, 0x1ce7(%rax)
je 0xde03b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
jne 0xde07d
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0xcb710
testb $0x1, %al
jne 0xde055
jmp 0xde069
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde197
movq -0x10(%rbp), %rax
movq 0x2158(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde197
movq -0x10(%rbp), %rcx
movq 0x1c90(%rcx), %rax
movl 0x1cdc(%rcx), %ecx
shlq $0x4, %rcx
leaq 0x3b8(%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rcx
addq $0x10, %rcx
movq %rcx, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movss (%rdi), %xmm0
movss %xmm0, -0x68(%rbp)
movss 0x1598(%rax), %xmm0
movss 0x94666(%rip), %xmm1    # 0x172734
mulss %xmm1, %xmm0
movss %xmm0, -0x6c(%rbp)
callq 0xeb840
movaps %xmm0, %xmm1
movss -0x6c(%rbp), %xmm0
callq 0xc4620
movaps %xmm0, %xmm1
movss -0x68(%rbp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x5c(%rbp)
movq -0x18(%rbp), %rdi
movss 0xc(%rdi), %xmm0
movss %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movss 0x159c(%rax), %xmm0
movss %xmm0, -0x64(%rbp)
callq 0xeb860
movaps %xmm0, %xmm1
movss -0x64(%rbp), %xmm0
callq 0xc4620
movss -0x60(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x5c(%rbp), %xmm0
subss %xmm2, %xmm1
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xbf4c0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xc41b0
movlpd %xmm0, -0x20(%rbp)
callq 0xd7920
movlpd %xmm0, -0x38(%rbp)
movlpd %xmm1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdf120
movlpd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc2f10
movlpd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ClosePopupToLevel(int, bool)
void ImGui::ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup)
{
    ImGuiContext& g = *GImGui;
    IMGUI_DEBUG_LOG_POPUP("ClosePopupToLevel(%d), restore_focus_to_window_under_popup=%d\n", remaining, restore_focus_to_window_under_popup);
    IM_ASSERT(remaining >= 0 && remaining < g.OpenPopupStack.Size);

    // Trim open popup stack
    ImGuiWindow* focus_window = g.OpenPopupStack[remaining].SourceWindow;
    ImGuiWindow* popup_window = g.OpenPopupStack[remaining].Window;
    g.OpenPopupStack.resize(remaining);

    if (restore_focus_to_window_under_popup)
    {
        if (focus_window && !focus_window->WasActive && popup_window)
        {
            // Fallback
            FocusTopMostWindowUnderOne(popup_window, NULL);
        }
        else
        {
            if (g.NavLayer == ImGuiNavLayer_Main && focus_window)
                focus_window = NavRestoreLastChildNavWindow(focus_window);
            FocusWindow(focus_window);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movq 0x134d76(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x21(%rbp)
jl 0xde1ec
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c70(%rcx), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xde1f5
jmp 0xde1f7
jmp 0xde216
leaq 0x96f45(%rip), %rdi     # 0x175143
leaq 0x94d04(%rip), %rsi     # 0x172f09
movl $0x1f5a, %edx           # imm = 0x1F5A
leaq 0x96f66(%rip), %rcx     # 0x175177
callq 0xd180
movq -0x10(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movl -0x4(%rbp), %esi
callq 0xeb4c0
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movl -0x4(%rbp), %esi
callq 0xeb4c0
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movl -0x4(%rbp), %esi
callq 0xeaa50
testb $0x1, -0x5(%rbp)
je 0xde2bb
cmpq $0x0, -0x18(%rbp)
je 0xde28f
movq -0x18(%rbp), %rax
testb $0x1, 0x8f(%rax)
jne 0xde28f
cmpq $0x0, -0x20(%rbp)
je 0xde28f
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcfed0
jmp 0xde2b9
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1cdc(%rax)
jne 0xde2b0
cmpq $0x0, -0x18(%rbp)
je 0xde2b0
movq -0x18(%rbp), %rdi
callq 0xd9fa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcb380
jmp 0xde2bb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopupEx(unsigned int, int)
bool ImGui::BeginPopupEx(ImGuiID id, ImGuiWindowFlags flags)
{
    ImGuiContext& g = *GImGui;
    if (!IsPopupOpen(id, ImGuiPopupFlags_None))
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }

    char name[20];
    if (flags & ImGuiWindowFlags_ChildMenu)
        ImFormatString(name, IM_ARRAYSIZE(name), "##Menu_%02d", g.BeginPopupStack.Size); // Recycle windows based on depth
    else
        ImFormatString(name, IM_ARRAYSIZE(name), "##Popup_%08x", id); // Not recycling, so we can close/open during the same frame

    flags |= ImGuiWindowFlags_Popup;
    bool is_open = Begin(name, NULL, flags);
    if (!is_open) // NB: Begin can return false when the popup is completely clipped (e.g. zero size display)
        EndPopup();

    return is_open;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x134b1b(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
xorl %esi, %esi
callq 0xcbb60
testb $0x1, %al
jne 0xde44d
movq -0x18(%rbp), %rdi
addq $0x1b88, %rdi           # imm = 0x1B88
callq 0xebb30
movb $0x0, -0x1(%rbp)
jmp 0xde4ca
movl -0xc(%rbp), %eax
andl $0x10000000, %eax       # imm = 0x10000000
cmpl $0x0, %eax
je 0xde47d
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1c80(%rax), %ecx
movl $0x14, %esi
leaq 0x96d2c(%rip), %rdx     # 0x1751a0
movb $0x0, %al
callq 0xc4d30
jmp 0xde497
leaq -0x30(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x14, %esi
leaq 0x96d1c(%rip), %rdx     # 0x1751ac
movb $0x0, %al
callq 0xc4d30
movl -0xc(%rbp), %eax
orl $0x4000000, %eax        # imm = 0x4000000
movl %eax, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0xd0170
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0xde4c2
callq 0xde4e0
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::EndPopup()
void ImGui::EndPopup()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup);  // Mismatched BeginPopup()/EndPopup() calls
    IM_ASSERT(g.BeginPopupStack.Size > 0);

    // Make all menus and popups wrap around for now, may need to expose that policy.
    if (g.NavWindow == window)
        NavMoveRequestTryWrapping(window, ImGuiNavMoveFlags_LoopY);

    // Child-popups don't need to be laid out
    IM_ASSERT(g.WithinEndChild == false);
    if (window->Flags & ImGuiWindowFlags_ChildWindow)
        g.WithinEndChild = true;
    End();
    g.WithinEndChild = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x134a51(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
je 0xde515
jmp 0xde534
leaq 0x96c9d(%rip), %rdi     # 0x1751b9
leaq 0x949e6(%rip), %rsi     # 0x172f09
movl $0x1fd7, %edx           # imm = 0x1FD7
leaq 0x96cb1(%rip), %rcx     # 0x1751e0
callq 0xd180
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c80(%rax)
jle 0xde543
jmp 0xde562
leaq 0x96cad(%rip), %rdi     # 0x1751f7
leaq 0x949b8(%rip), %rsi     # 0x172f09
movl $0x1fd8, %edx           # imm = 0x1FD8
leaq 0x96c83(%rip), %rcx     # 0x1751e0
callq 0xd180
movq -0x8(%rbp), %rax
movq 0x1c90(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xde581
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xde7b0
movq -0x8(%rbp), %rax
movb 0x1a76(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xde597
jmp 0xde5b6
leaq 0x958cf(%rip), %rdi     # 0x173e6d
leaq 0x94964(%rip), %rsi     # 0x172f09
movl $0x1fdf, %edx           # imm = 0x1FDF
leaq 0x96c2f(%rip), %rcx     # 0x1751e0
callq 0xd180
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0xde5d2
movq -0x8(%rbp), %rax
movb $0x1, 0x1a76(%rax)
callq 0xd3b60
movq -0x8(%rbp), %rax
movb $0x0, 0x1a76(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::BeginPopup(char const*, int)
bool ImGui::BeginPopup(const char* str_id, ImGuiWindowFlags flags)
{
    ImGuiContext& g = *GImGui;
    if (g.OpenPopupStack.Size <= g.BeginPopupStack.Size) // Early out for performance
    {
        g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
        return false;
    }
    flags |= ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings;
    return BeginPopupEx(g.CurrentWindow->GetID(str_id), flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x13493a(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c70(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x1c80(%rcx), %eax
jg 0xde636
movq -0x20(%rbp), %rdi
addq $0x1b88, %rdi           # imm = 0x1B88
callq 0xebb30
movb $0x0, -0x1(%rbp)
jmp 0xde668
movl -0x14(%rbp), %eax
orl $0x141, %eax            # imm = 0x141
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x1ae0(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, %edi
movl -0x14(%rbp), %esi
callq 0xde410
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)