LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, float)
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 1)
    {
        ImGuiContext& g = *GImGui;
        float* pvar = (float*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() float variant but variable is not a float!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0xc7ae0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xc7ab4
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xc7ab4
movq 0x14b4ea(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1560, %rsi           # imm = 0x1560
callq 0xe87d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1c20, %rax           # imm = 0x1C20
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %esi
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
leaq -0x2c(%rbp), %rdi
callq 0xe8860
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xe87f0
movss -0x8(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
leaq 0xab841(%rip), %rdi     # 0x1732fc
leaq 0xab447(%rip), %rsi     # 0x172f09
movl $0x9c4, %edx            # imm = 0x9C4
leaq 0xab876(%rip), %rcx     # 0x173344
callq 0xd180
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, ImVec2 const&)
void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
    const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
    if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
    {
        ImGuiContext& g = *GImGui;
        ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
        g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
        *pvar = val;
        return;
    }
    IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0xc7ae0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xc7bec
movq -0x18(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0xc7bec
movq 0x14b3bb(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1560, %rsi           # imm = 0x1560
callq 0xe87d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1c20, %rax           # imm = 0x1C20
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %esi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
leaq -0x34(%rbp), %rdi
callq 0xe8890
movq -0x48(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xe87f0
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
leaq 0xab780(%rip), %rdi     # 0x173373
leaq 0xab30f(%rip), %rsi     # 0x172f09
movl $0x9d2, %edx            # imm = 0x9D2
leaq 0xab7b7(%rip), %rcx     # 0x1733bd
callq 0xd180
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::PopStyleVar(int)
void ImGui::PopStyleVar(int count)
{
    ImGuiContext& g = *GImGui;
    while (count > 0)
    {
        // We avoid a generic memcpy(data, &backup.Backup.., GDataTypeSize[info->Type] * info->Count), the overhead in Debug is not worth it.
        ImGuiStyleMod& backup = g.StyleVarStack.back();
        const ImGuiStyleVarInfo* info = GetStyleVarInfo(backup.VarIdx);
        void* data = info->GetVarPtr(&g.Style);
        if (info->Type == ImGuiDataType_Float && info->Count == 1)      { ((float*)data)[0] = backup.BackupFloat[0]; }
        else if (info->Type == ImGuiDataType_Float && info->Count == 2) { ((float*)data)[0] = backup.BackupFloat[0]; ((float*)data)[1] = backup.BackupFloat[1]; }
        g.StyleVarStack.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x14b31e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xc7ce7
movq -0x10(%rbp), %rdi
addq $0x1c20, %rdi           # imm = 0x1C20
callq 0xe88c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0xc7ae0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1560, %rsi           # imm = 0x1560
callq 0xe87d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xc7c91
movq -0x20(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xc7c91
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
jmp 0xc7cc9
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xc7cc7
movq -0x20(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0xc7cc7
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movss %xmm0, 0x4(%rax)
jmp 0xc7cc9
movq -0x10(%rbp), %rdi
addq $0x1c20, %rdi           # imm = 0x1C20
callq 0xe8920
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc7c26
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::FindRenderedTextEnd(char const*, char const*)
const char* ImGui::FindRenderedTextEnd(const char* text, const char* text_end)
{
    const char* text_display_end = text;
    if (!text_end)
        text_end = (const char*)-1;

    while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
        text_display_end++;
    return text_display_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc80b6
movq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc80b8
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0xc8100
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xc8100
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x23, %ecx
movb %al, -0x1a(%rbp)
jne 0xc80fa
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x23, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xc8109
jmp 0xc8117
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc80b8
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderText(ImVec2, char const*, char const*, bool)
void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    // Hide anything after a '##' string
    const char* text_display_end;
    if (hide_text_after_hash)
    {
        text_display_end = FindRenderedTextEnd(text, text_end);
    }
    else
    {
        if (!text_end)
            text_end = text + strlen(text); // FIXME-OPT
        text_display_end = text_end;
    }

    if (text != text_display_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_display_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movlpd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq 0x14adfd(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
je 0xc816f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc8090
movq %rax, -0x38(%rbp)
jmp 0xc819d
cmpq $0x0, -0x18(%rbp)
jne 0xc8195
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd410
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0xc8236
movq -0x30(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq 0x1978(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movss 0x1980(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
xorl %edi, %edi
movss 0xa8a58(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movss -0x44(%rbp), %xmm0
movl %eax, %ecx
movq -0x10(%rbp), %r8
movq -0x38(%rbp), %r9
leaq -0x8(%rbp), %rdx
xorps %xmm1, %xmm1
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x1139a0
movq -0x28(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xc8234
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0xc8240
jmp 0xc8236
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderTextWrapped(ImVec2, char const*, char const*, float)
void ImGui::RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    if (!text_end)
        text_end = text + strlen(text); // FIXME-OPT

    if (text != text_end)
    {
        window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_end, wrap_width);
        if (g.LogEnabled)
            LogRenderedText(&pos, text, text_end);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm1, -0x1c(%rbp)
movq 0x14aacf(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc84aa
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd410
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc8545
movq -0x30(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq 0x1978(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movss 0x1980(%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
xorl %edi, %edi
movss 0xa874b(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movss -0x3c(%rbp), %xmm0
movl %eax, %ecx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movss -0x1c(%rbp), %xmm1
leaq -0x8(%rbp), %rdx
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x1139a0
movq -0x28(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xc8543
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0xc8240
jmp 0xc8545
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcTextSize(char const*, char const*, bool, float)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
    ImGuiContext& g = *GImGui;

    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindRenderedTextEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;

    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    if (text == text_display_end)
        return ImVec2(0.0f, font_size);
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);

    // Round
    text_size.x = IM_FLOOR(text_size.x + 0.95f);

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movss %xmm0, -0x20(%rbp)
movq 0x14a73d(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0xc8820
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc8090
movq %rax, -0x30(%rbp)
jmp 0xc8828
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x1978(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movss 0x1980(%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xc8865
movss -0x3c(%rbp), %xmm1
leaq -0x8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xbf4c0
jmp 0xc88ab
movq -0x38(%rbp), %rdi
movss -0x3c(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movss 0xa972d(%rip), %xmm1    # 0x171fb4
callq 0x11c520
movlpd %xmm0, -0x8(%rbp)
movss 0xa9ed3(%rip), %xmm0    # 0x17276c
addss -0x8(%rbp), %xmm0
cvttss2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderTextClipped(ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*)
void ImGui::RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
    // Hide anything after a '##' string
    const char* text_display_end = FindRenderedTextEnd(text, text_end);
    const int text_len = (int)(text_display_end - text);
    if (text_len == 0)
        return;

    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    RenderTextClippedEx(window->DrawList, pos_min, pos_max, text, text_display_end, text_size_if_known, align, clip_rect);
    if (g.LogEnabled)
        LogRenderedText(&pos_min, text, text_display_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc8090
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0xc894b
jmp 0xc89b8
movq 0x14a5ee(%rip), %rax    # 0x212f40
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x2b8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r10
movq 0x10(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xc8550
movq -0x48(%rbp), %rax
testb $0x1, 0x3138(%rax)
je 0xc89b8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xc8240
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderFrame(ImVec2, ImVec2, unsigned int, bool, float)
void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
    const float border_size = g.Style.FrameBorderSize;
    if (border && border_size > 0.0f)
    {
        window->DrawList->AddRect(p_min + ImVec2(1, 1), p_max + ImVec2(1, 1), GetColorU32(ImGuiCol_BorderShadow), rounding, ImDrawCornerFlags_All, border_size);
        window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, ImDrawCornerFlags_All, border_size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movlpd %xmm0, -0x8(%rbp)
movlpd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movss %xmm2, -0x1c(%rbp)
movq 0x149ff4(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x2b8(%rax), %rdi
movl -0x14(%rbp), %ecx
movss -0x1c(%rbp), %xmm0
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0xf, %r8d
callq 0x113090
movq -0x28(%rbp), %rax
movss 0x15a4(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
testb $0x1, -0x15(%rbp)
je 0xc908f
movss -0x34(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc908f
movq -0x30(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x44(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movss 0xa7c6c(%rip), %xmm1    # 0x170c3c
movss %xmm1, -0x74(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x80(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xc41b0
movss -0x74(%rbp), %xmm1
movlpd %xmm0, -0x3c(%rbp)
leaq -0x54(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x70(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xc41b0
movlpd %xmm0, -0x4c(%rbp)
movl $0x6, %edi
movss 0xa7c19(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movq -0x68(%rbp), %rdi
movl %eax, %ecx
movss -0x1c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
leaq -0x3c(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
movl $0xf, %r8d
callq 0x112ef0
movq -0x30(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x60(%rbp)
movl $0x5, %edi
movss 0xa7bd5(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movq -0x60(%rbp), %rdi
movl %eax, %ecx
movss -0x1c(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0xf, %r8d
callq 0x112ef0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::RenderFrameBorder(ImVec2, ImVec2, float)
void ImGui::RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const float border_size = g.Style.FrameBorderSize;
    if (border_size > 0.0f)
    {
        window->DrawList->AddRect(p_min + ImVec2(1, 1), p_max + ImVec2(1, 1), GetColorU32(ImGuiCol_BorderShadow), rounding, ImDrawCornerFlags_All, border_size);
        window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, ImDrawCornerFlags_All, border_size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movlpd %xmm0, -0x8(%rbp)
movlpd %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq 0x149e7f(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movss 0x15a4(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc91d4
movq -0x28(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x3c(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movss 0xa7b27(%rip), %xmm1    # 0x170c3c
movss %xmm1, -0x6c(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x78(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xc41b0
movss -0x6c(%rbp), %xmm1
movlpd %xmm0, -0x34(%rbp)
leaq -0x4c(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x68(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xc41b0
movlpd %xmm0, -0x44(%rbp)
movl $0x6, %edi
movss 0xa7ad4(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movq -0x60(%rbp), %rdi
movl %eax, %ecx
movss -0x14(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
leaq -0x34(%rbp), %rsi
leaq -0x44(%rbp), %rdx
movl $0xf, %r8d
callq 0x112ef0
movq -0x28(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x5, %edi
movss 0xa7a90(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movq -0x58(%rbp), %rdi
movl %eax, %ecx
movss -0x14(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0xf, %r8d
callq 0x112ef0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetID(char const*, char const*)
ImGuiID ImGuiWindow::GetID(const char* str, const char* str_end)
{
    ImGuiID seed = IDStack.back();
    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)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9130
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc9959
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xc9961
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xc9961
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xc4f20
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0xc9a90
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::~ImGuiWindow()
ImGuiWindow::~ImGuiWindow()
{
    IM_ASSERT(DrawList == &DrawListInst);
    IM_DELETE(Name);
    for (int i = 0; i != ColumnsStorage.Size; i++)
        ColumnsStorage[i].~ImGuiOldColumns();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x2b8(%rcx), %rax
addq $0x2c0, %rcx            # imm = 0x2C0
cmpq %rcx, %rax
jne 0xc99b9
jmp 0xc99d8
leaq 0xa9d10(%rip), %rdi     # 0x1736d0
leaq 0xa9542(%rip), %rsi     # 0x172f09
movl $0xb39, %edx            # imm = 0xB39
leaq 0xa9d17(%rip), %rcx     # 0x1736ea
callq 0xd180
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xe9050
jmp 0xc99e6
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x2a0(%rcx), %eax
je 0xc9a29
movq -0x18(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
movl -0xc(%rbp), %esi
callq 0xe9080
movq %rax, -0x20(%rbp)
jmp 0xc9a15
movq -0x20(%rbp), %rdi
callq 0xe9100
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc99ed
movq -0x18(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0xe8ed0
movq -0x18(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
callq 0xe8f60
movq -0x18(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
callq 0xe8fa0
movq -0x18(%rbp), %rdi
addq $0xd8, %rdi
callq 0xe8fc0
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9010
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xb4190
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::KeepAliveID(unsigned int)
void ImGui::KeepAliveID(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    if (g.ActiveId == id)
        g.ActiveIdIsAlive = id;
    if (g.ActiveIdPreviousFrame == id)
        g.ActiveIdPreviousFrameIsAlive = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x1494a2(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1b30(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xc9abe
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1b34(%rax)
movq -0x10(%rbp), %rax
movl 0x1b70(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xc9ad8
movq -0x10(%rbp), %rax
movb $0x1, 0x1b74(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetID(void const*)
ImGuiID ImGuiWindow::GetID(const void* ptr)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashData(&ptr, sizeof(void*), seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO(id, ImGuiDataType_Pointer, ptr);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9130
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0xc4ea0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0xc9a90
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetID(int)
ImGuiID ImGuiWindow::GetID(int n)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashData(&n, sizeof(n), seed);
    ImGui::KeepAliveID(id);
#ifdef IMGUI_ENABLE_TEST_ENGINE
    ImGuiContext& g = *GImGui;
    IMGUI_TEST_ENGINE_ID_INFO(id, ImGuiDataType_S32, (intptr_t)n);
#endif
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9130
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
callq 0xc4ea0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xc9a90
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetIDNoKeepAlive(char const*, char const*)
ImGuiID ImGuiWindow::GetIDNoKeepAlive(const char* str, const char* str_end)
{
    ImGuiID seed = IDStack.back();
    ImGuiID id = ImHashStr(str, str_end ? (str_end - str) : 0, seed);
#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)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9130
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc9bc9
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xc9bd1
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xc9bd1
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xc4f20
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGuiWindow::GetIDFromRectangle(ImRect const&)
ImGuiID ImGuiWindow::GetIDFromRectangle(const ImRect& r_abs)
{
    ImGuiID seed = IDStack.back();
    const int r_rel[4] = { (int)(r_abs.Min.x - Pos.x), (int)(r_abs.Min.y - Pos.y), (int)(r_abs.Max.x - Pos.x), (int)(r_abs.Max.y - Pos.y) };
    ImGuiID id = ImHashData(&r_rel, sizeof(r_rel), seed);
    ImGui::KeepAliveID(id);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0xc8, %rdi
callq 0xe9130
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
subss 0x10(%rax), %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
subss 0x14(%rax), %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x2c(%rbp)
movq -0x10(%rbp), %rcx
movss 0x8(%rcx), %xmm0
subss 0x10(%rax), %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movss 0xc(%rcx), %xmm0
subss 0x14(%rax), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0xc4ea0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0xc9a90
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GcCompactTransientMiscBuffers()
void ImGui::GcCompactTransientMiscBuffers()
{
    ImGuiContext& g = *GImGui;
    g.ItemFlagsStack.clear();
    g.GroupStack.clear();
    TableGcCompactSettings();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1491f1(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1c50, %rdi           # imm = 0x1C50
callq 0xe9190
movq -0x8(%rbp), %rdi
addq $0x1c60, %rdi           # imm = 0x1C60
callq 0xe91e0
callq 0x134350
addq $0x10, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GcCompactTransientWindowBuffers(ImGuiWindow*)
void ImGui::GcCompactTransientWindowBuffers(ImGuiWindow* window)
{
    window->MemoryCompacted = true;
    window->MemoryDrawListIdxCapacity = window->DrawList->IdxBuffer.Capacity;
    window->MemoryDrawListVtxCapacity = window->DrawList->VtxBuffer.Capacity;
    window->IDStack.clear();
    window->DrawList->_ClearFreeMemory();
    window->DC.ChildWindows.clear();
    window->DC.ItemWidthStack.clear();
    window->DC.TextWrapPosStack.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3e0(%rax)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3d8(%rax)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3dc(%rax)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0xe9230
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rdi
callq 0x10ee60
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
addq $0xc0, %rdi
callq 0xe9280
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0xe92d0
movq -0x8(%rbp), %rdi
addq $0xd8, %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0xe92d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::GcAwakeTransientWindowBuffers(ImGuiWindow*)
void ImGui::GcAwakeTransientWindowBuffers(ImGuiWindow* window)
{
    // We stored capacity of the ImDrawList buffer to reduce growth-caused allocation/copy when awakening.
    // The other buffers tends to amortize much faster.
    window->MemoryCompacted = false;
    window->DrawList->IdxBuffer.reserve(window->MemoryDrawListIdxCapacity);
    window->DrawList->VtxBuffer.reserve(window->MemoryDrawListVtxCapacity);
    window->MemoryDrawListIdxCapacity = window->MemoryDrawListVtxCapacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x3e0(%rax)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movl 0x3d8(%rax), %esi
callq 0xe9320
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rax
movl 0x3dc(%rax), %esi
callq 0xe93a0
movq -0x8(%rbp), %rax
movl $0x0, 0x3dc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3d8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetActiveID(unsigned int, ImGuiWindow*)
void ImGui::SetActiveID(ImGuiID id, ImGuiWindow* window)
{
    ImGuiContext& g = *GImGui;
    g.ActiveIdIsJustActivated = (g.ActiveId != id);
    if (g.ActiveIdIsJustActivated)
    {
        g.ActiveIdTimer = 0.0f;
        g.ActiveIdHasBeenPressedBefore = false;
        g.ActiveIdHasBeenEditedBefore = false;
        if (id != 0)
        {
            g.LastActiveId = id;
            g.LastActiveIdTimer = 0.0f;
        }
    }
    g.ActiveId = id;
    g.ActiveIdAllowOverlap = false;
    g.ActiveIdNoClearOnFocusLoss = false;
    g.ActiveIdWindow = window;
    g.ActiveIdHasBeenEditedThisFrame = false;
    if (id)
    {
        g.ActiveIdIsAlive = id;
        g.ActiveIdSource = (g.NavActivateId == id || g.NavInputId == id || g.NavJustTabbedId == id || g.NavJustMovedToId == id) ? ImGuiInputSource_Nav : ImGuiInputSource_Mouse;
    }

    // Clear declaration of inputs claimed by the widget
    // (Please note that this is WIP and not all keys/inputs are thoroughly declared by all widgets yet)
    g.ActiveIdUsingMouseWheel = false;
    g.ActiveIdUsingNavDirMask = 0x00;
    g.ActiveIdUsingNavInputMask = 0x00;
    g.ActiveIdUsingKeyInputMask = 0x00;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x14906e(%rip), %rax    # 0x212f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1b30(%rax), %eax
cmpl -0x4(%rbp), %eax
setne %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1b3c(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x1b3c(%rax)
je 0xc9f49
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1b38(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1b3f(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1b40(%rax)
cmpl $0x0, -0x4(%rbp)
je 0xc9f47
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1b80(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1b84(%rax)
jmp 0xc9f49
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1b30(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1b3d(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1b3e(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x1b60(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1b41(%rax)
cmpl $0x0, -0x4(%rbp)
je 0xca005
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1b34(%rax)
movq -0x18(%rbp), %rax
movl 0x1ca0(%rax), %ecx
movb $0x1, %al
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
je 0xc9fe8
movq -0x18(%rbp), %rax
movl 0x1cac(%rax), %ecx
movb $0x1, %al
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
je 0xc9fe8
movq -0x18(%rbp), %rax
movl 0x1cb0(%rax), %ecx
movb $0x1, %al
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
je 0xc9fe8
movq -0x18(%rbp), %rax
movl 0x1cb4(%rax), %eax
cmpl -0x4(%rbp), %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
movl $0x1, %ecx
movl $0x2, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1b68(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1b42(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1b44(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1b48(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x1b50(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::SetHoveredID(unsigned int)
void ImGui::SetHoveredID(ImGuiID id)
{
    ImGuiContext& g = *GImGui;
    g.HoveredId = id;
    g.HoveredIdAllowOverlap = false;
    g.HoveredIdUsingMouseWheel = false;
    if (id != 0 && g.HoveredIdPreviousFrame != id)
        g.HoveredIdTimer = g.HoveredIdNotActiveTimer = 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x148ed2(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1b1c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1b24(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1b25(%rax)
cmpl $0x0, -0x4(%rbp)
je 0xca0c8
movq -0x10(%rbp), %rax
movl 0x1b20(%rax), %eax
cmpl -0x4(%rbp), %eax
je 0xca0c8
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1b2c(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1b28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::MarkItemEdited(unsigned int)
void ImGui::MarkItemEdited(ImGuiID id)
{
    // This marking is solely to be able to provide info for IsItemDeactivatedAfterEdit().
    // ActiveId might have been released by the time we call this (as in the typical press/release button behavior) but still need need to fill the data.
    ImGuiContext& g = *GImGui;
    IM_ASSERT(g.ActiveId == id || g.ActiveId == 0 || g.DragDropActive);
    IM_UNUSED(id); // Avoid unused variable warnings when asserts are compiled out.
    //IM_ASSERT(g.CurrentWindow->DC.LastItemId == id);
    g.ActiveIdHasBeenEditedThisFrame = true;
    g.ActiveIdHasBeenEditedBefore = true;
    g.CurrentWindow->DC.LastItemStatusFlags |= ImGuiItemStatusFlags_Edited;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x148e1e(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1b30(%rax), %ecx
movb $0x1, %al
cmpl -0x4(%rbp), %ecx
movb %al, -0x11(%rbp)
je 0xca159
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x1b30(%rcx)
movb %al, -0x11(%rbp)
je 0xca159
movq -0x10(%rbp), %rax
movb 0x2004(%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xca162
jmp 0xca164
jmp 0xca183
leaq 0xa959b(%rip), %rdi     # 0x173706
leaq 0xa8d97(%rip), %rsi     # 0x172f09
movl $0xbfe, %edx            # imm = 0xBFE
leaq 0xa95c0(%rip), %rcx     # 0x17373e
callq 0xd180
movq -0x10(%rbp), %rax
movb $0x1, 0x1b41(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x1b40(%rax)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movl 0x128(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x128(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsItemFocused()
bool ImGui::IsItemFocused()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;

    if (g.NavId != window->DC.LastItemId || g.NavId == 0)
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x148be5(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c98(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x124(%rcx), %eax
jne 0xca391
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c98(%rax)
jne 0xca397
movb $0x0, -0x1(%rbp)
jmp 0xca39b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: IsWindowContentHoverable(ImGuiWindow*, int)
static inline bool IsWindowContentHoverable(ImGuiWindow* window, ImGuiHoveredFlags flags)
{
    // An active popup disable hovering on other windows (apart from its own children)
    // FIXME-OPT: This could be cached/stored within the window.
    ImGuiContext& g = *GImGui;
    if (g.NavWindow)
        if (ImGuiWindow* focused_root_window = g.NavWindow->RootWindow)
            if (focused_root_window->WasActive && focused_root_window != window->RootWindow)
            {
                // For the purpose of those flags we differentiate "standard popup" from "modal popup"
                // NB: The order of those two tests is important because Modal windows are also Popups.
                if (focused_root_window->Flags & ImGuiWindowFlags_Modal)
                    return false;
                if ((focused_root_window->Flags & ImGuiWindowFlags_Popup) && !(flags & ImGuiHoveredFlags_AllowWhenBlockedByPopup))
                    return false;
            }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x148b7e(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
je 0xca44e
movq -0x20(%rbp), %rax
movq 0x1c90(%rax), %rax
movq 0x390(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xca44c
movq -0x28(%rbp), %rax
testb $0x1, 0x8f(%rax)
je 0xca44a
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x390(%rcx), %rax
je 0xca44a
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
je 0xca426
movb $0x0, -0x1(%rbp)
jmp 0xca452
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
je 0xca448
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xca448
movb $0x0, -0x1(%rbp)
jmp 0xca452
jmp 0xca44a
jmp 0xca44c
jmp 0xca44e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsMouseHoveringRect(ImVec2 const&, ImVec2 const&, bool)
bool ImGui::IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip)
{
    ImGuiContext& g = *GImGui;

    // Clip
    ImRect rect_clipped(r_min, r_max);
    if (clip)
        rect_clipped.ClipWith(g.CurrentWindow->ClipRect);

    // Expand for touch input
    const ImRect rect_for_touch(rect_clipped.Min - g.Style.TouchExtraPadding, rect_clipped.Max + g.Style.TouchExtraPadding);
    if (!rect_for_touch.Contains(g.IO.MousePos))
        return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq 0x148932(%rip), %rax    # 0x212f40
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe8660
testb $0x1, -0x19(%rbp)
je 0xca644
movq -0x28(%rbp), %rax
movq 0x1ae0(%rax), %rsi
addq $0x258, %rsi            # imm = 0x258
leaq -0x38(%rbp), %rdi
callq 0xe8970
movq -0x28(%rbp), %rsi
addq $0x15c0, %rsi           # imm = 0x15C0
leaq -0x38(%rbp), %rdi
callq 0xc3c00
movlpd %xmm0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x15c0, %rsi           # imm = 0x15C0
callq 0xc41b0
movlpd %xmm0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0xe8660
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
addq $0x120, %rsi            # imm = 0x120
leaq -0x48(%rbp), %rdi
callq 0xea710
testb $0x1, %al
jne 0xca6a9
movb $0x0, -0x1(%rbp)
jmp 0xca6ad
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::IsClippedEx(ImRect const&, unsigned int, bool)
bool ImGui::IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (!bb.Overlaps(window->ClipRect))
        if (id == 0 || (id != g.ActiveId && id != g.NavId))
            if (clip_even_when_logged || !g.LogEnabled)
                return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq 0x148843(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x258, %rsi            # imm = 0x258
callq 0xe9420
testb $0x1, %al
jne 0xca769
cmpl $0x0, -0x14(%rbp)
je 0xca74c
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x1b30(%rcx), %eax
je 0xca767
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x1c98(%rcx), %eax
je 0xca767
testb $0x1, -0x15(%rbp)
jne 0xca75f
movq -0x20(%rbp), %rax
testb $0x1, 0x3138(%rax)
jne 0xca765
movb $0x1, -0x1(%rbp)
jmp 0xca76d
jmp 0xca767
jmp 0xca769
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CalcWrapWidthForPos(ImVec2 const&, float)
float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
    if (wrap_pos_x < 0.0f)
        return 0.0f;

    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (wrap_pos_x == 0.0f)
    {
        // We could decide to setup a default wrapping max point for auto-resizing windows,
        // or have auto-wrap (with unspecified wrapping pos) behave as a ContentSize extending function?
        //if (window->Hidden && (window->Flags & ImGuiWindowFlags_AlwaysAutoResize))
        //    wrap_pos_x = ImMax(window->WorkRect.Min.x + g.FontSize * 10.0f, window->WorkRect.Max.x);
        //else
        wrap_pos_x = window->WorkRect.Max.x;
    }
    else if (wrap_pos_x > 0.0f)
    {
        wrap_pos_x += window->Pos.x - window->Scroll.x; // wrap_pos_x is provided is window local space
    }

    return ImMax(wrap_pos_x - pos.x, 1.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0xca9a7
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xcaa2d
movq 0x148592(%rip), %rax    # 0x212f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xca9e3
jp 0xca9e3
movq -0x28(%rbp), %rax
movss 0x240(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0xcaa0e
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xcaa0c
movq -0x28(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
subss 0x5c(%rax), %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0xcaa0e
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
subss (%rax), %xmm0
movss 0xa6219(%rip), %xmm1    # 0x170c3c
callq 0xc88c0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CreateContext(ImFontAtlas*)
ImGuiContext* ImGui::CreateContext(ImFontAtlas* shared_font_atlas)
{
    ImGuiContext* ctx = IM_NEW(ImGuiContext)(shared_font_atlas);
    if (GImGui == NULL)
        SetCurrentContext(ctx);
    Initialize(ctx);
    return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3f80, %edi           # imm = 0x3F80
movq %rdi, -0x40(%rbp)
callq 0xc4820
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq %rsi, %rax
movq %rax, -0x38(%rbp)
callq 0xe9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
callq 0xe9530
jmp 0xcabb2
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x14837e(%rip)    # 0x212f40
jne 0xcabea
movq -0x10(%rbp), %rdi
callq 0xcab10
jmp 0xcabea
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xea550
jmp 0xcabfd
movq -0x10(%rbp), %rdi
callq 0xcac10
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd620
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::Initialize(ImGuiContext*)
void ImGui::Initialize(ImGuiContext* context)
{
    ImGuiContext& g = *context;
    IM_ASSERT(!g.Initialized && !g.SettingsLoaded);

    // Add .ini handle for ImGuiWindow type
    {
        ImGuiSettingsHandler ini_handler;
        ini_handler.TypeName = "Window";
        ini_handler.TypeHash = ImHashStr("Window");
        ini_handler.ClearAllFn = WindowSettingsHandler_ClearAll;
        ini_handler.ReadOpenFn = WindowSettingsHandler_ReadOpen;
        ini_handler.ReadLineFn = WindowSettingsHandler_ReadLine;
        ini_handler.ApplyAllFn = WindowSettingsHandler_ApplyAll;
        ini_handler.WriteAllFn = WindowSettingsHandler_WriteAll;
        g.SettingsHandlers.push_back(ini_handler);
    }

#ifdef IMGUI_HAS_TABLE
    // Add .ini handle for ImGuiTable type
    TableSettingsInstallHandler(context);
#endif // #ifdef IMGUI_HAS_TABLE

#ifdef IMGUI_HAS_DOCK
#endif // #ifdef IMGUI_HAS_DOCK

    g.Initialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, (%rcx)
movb %al, -0x59(%rbp)
jne 0xcac41
movq -0x10(%rbp), %rax
movb 0x30e1(%rax), %al
xorb $-0x1, %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xcac4a
jmp 0xcac4c
jmp 0xcac6b
leaq 0xa8cea(%rip), %rdi     # 0x17393d
leaq 0xa82af(%rip), %rsi     # 0x172f09
movl $0xf9e, %edx            # imm = 0xF9E
leaq 0xa8cfb(%rip), %rcx     # 0x173961
callq 0xd180
leaq -0x58(%rbp), %rdi
callq 0xeaba0
leaq 0xacac4(%rip), %rax     # 0x17773f
movq %rax, -0x58(%rbp)
leaq 0xacab9(%rip), %rdi     # 0x17773f
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xc4f20
movl %eax, -0x50(%rbp)
leaq 0x81a5(%rip), %rax      # 0xd2e40
movq %rax, -0x48(%rbp)
leaq 0x820a(%rip), %rax      # 0xd2eb0
movq %rax, -0x38(%rbp)
leaq 0x826f(%rip), %rax      # 0xd2f20
movq %rax, -0x30(%rbp)
leaq 0x8344(%rip), %rax      # 0xd3000
movq %rax, -0x28(%rbp)
leaq 0x83c9(%rip), %rax      # 0xd3090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
leaq -0x58(%rbp), %rsi
callq 0xeabd0
movq -0x8(%rbp), %rdi
callq 0x133950
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::DestroyContext(ImGuiContext*)
void ImGui::DestroyContext(ImGuiContext* ctx)
{
    if (ctx == NULL)
        ctx = GImGui;
    Shutdown(ctx);
    if (GImGui == ctx)
        SetCurrentContext(NULL);
    IM_DELETE(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xcad1e
movq 0x148226(%rip), %rax    # 0x212f40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcad50
movq 0x148212(%rip), %rax    # 0x212f40
cmpq -0x8(%rbp), %rax
jne 0xcad3d
xorl %eax, %eax
movl %eax, %edi
callq 0xcab10
movq -0x8(%rbp), %rdi
callq 0xea560
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::CallContextHooks(ImGuiContext*, ImGuiContextHookType)
void ImGui::CallContextHooks(ImGuiContext* ctx, ImGuiContextHookType hook_type)
{
    ImGuiContext& g = *ctx;
    for (int n = 0; n < g.Hooks.Size; n++)
        if (g.Hooks[n].Type == hook_type)
            g.Hooks[n].Callback(&g, &g.Hooks[n]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x3128(%rcx), %eax
jge 0xcb197
movq -0x18(%rbp), %rdi
addq $0x3128, %rdi           # imm = 0x3128
movl -0x1c(%rbp), %esi
callq 0xea610
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xcb18a
movq -0x18(%rbp), %rdi
addq $0x3128, %rdi           # imm = 0x3128
movl -0x1c(%rbp), %esi
callq 0xea610
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3128, %rdi           # imm = 0x3128
movl -0x1c(%rbp), %esi
callq 0xea610
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rax
callq *%rax
jmp 0xcb18c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcb11e
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)