LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: GetDraggedColumnOffset(ImGuiOldColumns*, int)
static float GetDraggedColumnOffset(ImGuiOldColumns* columns, int column_index)
{
    // Active (dragged) column always follow mouse. The reason we need this is that dragging a column to the right edge of an auto-resizing
    // window creates a feedback loop because we store normalized positions. So while dragging we enforce absolute positioning.
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(column_index > 0); // We are not supposed to drag column 0.
    IM_ASSERT(g.ActiveId == columns->ID + ImGuiID(column_index));

    float x = g.IO.MousePos.x - g.ActiveIdClickOffset.x + COLUMNS_HIT_RECT_HALF_WIDTH - window->Pos.x;
    x = ImMax(x, ImGui::GetColumnOffset(column_index - 1) + g.Style.ColumnsMinSpacing);
    if ((columns->Flags & ImGuiOldColumnFlags_NoPreserveWidths))
        x = ImMin(x, ImGui::GetColumnOffset(column_index + 1) - g.Style.ColumnsMinSpacing);

    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xdc69a(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1368c4
jmp 0x1368e3
leaq 0x5740b(%rip), %rdi     # 0x18dcd6
leaq 0x556d0(%rip), %rsi     # 0x18bfa2
movl $0xdda, %edx            # imm = 0xDDA
leaq 0x57409(%rip), %rcx     # 0x18dce7
callq 0xd180
movq -0x18(%rbp), %rax
movl 0x1b30(%rax), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1368fc
jmp 0x13691b
leaq 0x57419(%rip), %rdi     # 0x18dd1c
leaq 0x55698(%rip), %rsi     # 0x18bfa2
movl $0xddb, %edx            # imm = 0xDDB
leaq 0x573d1(%rip), %rcx     # 0x18dce7
callq 0xd180
movq -0x18(%rbp), %rax
movss 0x128(%rax), %xmm0
movq -0x18(%rbp), %rax
subss 0x1b58(%rax), %xmm0
movss 0x3bdf9(%rip), %xmm1    # 0x172734
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x135370
movaps %xmm0, %xmm1
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x15cc(%rax), %xmm1
callq 0x12a620
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1369c2
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x135370
movaps %xmm0, %xmm1
movss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
subss 0x15cc(%rax), %xmm1
callq 0x12a6b0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::Columns(int, char const*, bool)
void ImGui::Columns(int columns_count, const char* id, bool border)
{
    ImGuiWindow* window = GetCurrentWindow();
    IM_ASSERT(columns_count >= 1);

    ImGuiOldColumnFlags flags = (border ? 0 : ImGuiOldColumnFlags_NoBorder);
    //flags |= ImGuiOldColumnFlags_NoPreserveWidths; // NB: Legacy behavior
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns != NULL && columns->Count == columns_count && columns->Flags == flags)
        return;

    if (columns != NULL)
        EndColumns();

    if (columns_count != 1)
        BeginColumns(id, columns_count, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0xeb270
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x4(%rbp)
jl 0x1369f7
jmp 0x136a16
leaq 0x56f8e(%rip), %rdi     # 0x18d98c
leaq 0x5559d(%rip), %rsi     # 0x18bfa2
movl $0xf42, %edx            # imm = 0xF42
leaq 0x5704d(%rip), %rcx     # 0x18da5e
callq 0xd180
movb -0x11(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x136a59
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x136a59
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x136a59
jmp 0x136a7a
cmpq $0x0, -0x30(%rbp)
je 0x136a65
callq 0x1363e0
cmpl $0x1, -0x4(%rbp)
je 0x136a7a
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x135b80
addq $0x30, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_internal.h
// Function: ImGuiTableColumn::ImGuiTableColumn()
ImGuiTableColumn()
    {
        memset(this, 0, sizeof(*this));
        StretchWeight = WidthRequest = -1.0f;
        NameOffset = -1;
        DisplayOrder = IndexWithinEnabledSet = -1;
        PrevEnabledColumn = NextEnabledColumn = -1;
        SortOrder = -1;
        SortDirection = ImGuiSortDirection_None;
        DrawChannelCurrent = DrawChannelFrozen = DrawChannelUnfrozen = (ImU8)-1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x20, %rdi
callq 0xe8c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0xd2f0
movq -0x10(%rbp), %rax
movss 0x3af37(%rip), %xmm0    # 0x171f80
movss %xmm0, 0x10(%rax)
movss 0x3af2a(%rip), %xmm0    # 0x171f80
movss %xmm0, 0x18(%rax)
movw $0xffff, 0x50(%rax)     # imm = 0xFFFF
movb $-0x1, 0x53(%rax)
movb $-0x1, 0x52(%rax)
movb $-0x1, 0x55(%rax)
movb $-0x1, 0x54(%rax)
movb $-0x1, 0x56(%rax)
movb 0x64(%rax), %cl
andb $-0x4, %cl
orb $0x0, %cl
movb %cl, 0x64(%rax)
movb $-0x1, 0x59(%rax)
movb $-0x1, 0x58(%rax)
movb $-0x1, 0x57(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_internal.h
// Function: ImGuiTableColumnSettings::ImGuiTableColumnSettings()
ImGuiTableColumnSettings()
    {
        WidthOrWeight = 0.0f;
        UserID = 0;
        Index = -1;
        DisplayOrder = SortOrder = -1;
        SortDirection = ImGuiSortDirection_None;
        IsEnabled = 1;
        IsStretch = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x0, 0x4(%rax)
movb $-0x1, 0x8(%rax)
movb $-0x1, 0xa(%rax)
movb $-0x1, 0x9(%rax)
movb 0xb(%rax), %cl
andb $-0x4, %cl
orb $0x0, %cl
movb %cl, 0xb(%rax)
movb 0xb(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0xb(%rax)
movb 0xb(%rax), %cl
andb $-0x9, %cl
orb $0x0, %cl
movb %cl, 0xb(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_internal.h
// Function: ImBitArraySetBitRange(unsigned int*, int, int)
inline void     ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)
{
    n2--;
    while (n <= n2)
    {
        int a_mod = (n & 31);
        int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
        ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
        arr[n >> 5] |= mask;
        n = (n + 32) & ~31;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x1386a7
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
orl $0x1f, %ecx
cmpl %ecx, %eax
jle 0x138643
movl $0x1f, %eax
movl %eax, -0x20(%rbp)
jmp 0x13864c
movl -0x10(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x20, %eax
andl $-0x20, %eax
movl %eax, -0xc(%rbp)
jmp 0x138617
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TextV(char const*, __va_list_tag*)
void ImGui::TextV(const char* fmt, va_list args)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiContext& g = *GImGui;
    const char* text_end = g.TempBuffer + ImFormatStringV(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), fmt, args);
    TextEx(g.TempBuffer, text_end, ImGuiTextFlags_NoWidthForLargeClippedText);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xeb270
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x139228
jmp 0x13928a
leaq 0xd9d11(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x3378, %rax           # imm = 0x3378
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x3378, %rdi           # imm = 0x3378
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0xc01, %esi            # imm = 0xC01
callq 0xc4e20
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x3378, %rdi           # imm = 0x3378
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x138a30
addq $0x30, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TextColoredV(ImVec4 const&, char const*, __va_list_tag*)
void ImGui::TextColoredV(const ImVec4& col, const char* fmt, va_list args)
{
    PushStyleColor(ImGuiCol_Text, col);
    if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
        TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
    else
        TextV(fmt, args);
    PopStyleColor();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xc78f0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x1393ce
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
jne 0x1393ce
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x1393ce
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0x1393a0
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x1393b7
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x138a30
jmp 0x1393db
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x139200
movl $0x1, %edi
callq 0xc7990
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TextDisabledV(char const*, __va_list_tag*)
void ImGui::TextDisabledV(const char* fmt, va_list args)
{
    ImGuiContext& g = *GImGui;
    PushStyleColor(ImGuiCol_Text, g.Style.Colors[ImGuiCol_TextDisabled]);
    if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
        TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
    else
        TextV(fmt, args);
    PopStyleColor();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xd9a99(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0x1560, %rsi           # imm = 0x1560
addq $0xc4, %rsi
addq $0x10, %rsi
xorl %edi, %edi
callq 0xc78f0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x13954a
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
jne 0x13954a
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x13954a
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0x13951c
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x139533
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x138a30
jmp 0x139557
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x139200
movl $0x1, %edi
callq 0xc7990
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::TextWrappedV(char const*, __va_list_tag*)
void ImGui::TextWrappedV(const char* fmt, va_list args)
{
    ImGuiContext& g = *GImGui;
    bool need_backup = (g.CurrentWindow->DC.TextWrapPos < 0.0f);  // Keep existing wrap position if one is already set
    if (need_backup)
        PushTextWrapPos(0.0f);
    if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
        TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
    else
        TextV(fmt, args);
    if (need_backup)
        PopTextWrapPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xd9919(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1ae0(%rax), %rax
xorps %xmm0, %xmm0
ucomiss 0x1d4(%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x139659
xorps %xmm0, %xmm0
callq 0xda2c0
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x1396d8
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
jne 0x1396d8
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x1396d8
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x28, %eax
ja 0x1396aa
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x1396c1
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x138a30
jmp 0x1396e5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x139200
testb $0x1, -0x19(%rbp)
je 0x1396f0
callq 0xda310
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::SmallButton(char const*)
bool ImGui::SmallButton(const char* label)
{
    ImGuiContext& g = *GImGui;
    float backup_padding_y = g.Style.FramePadding.y;
    g.Style.FramePadding.y = 0.0f;
    bool pressed = ButtonEx(label, ImVec2(0, 0), ImGuiButtonFlags_AlignTextBaseLine);
    g.Style.FramePadding.y = backup_padding_y;
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd85cd(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x159c(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x159c(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x13a640
andb $0x1, %al
movb %al, -0x15(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x159c(%rax)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::InvisibleButton(char const*, ImVec2 const&, int)
bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg, ImGuiButtonFlags flags)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return false;

    // Cannot use zero-size for InvisibleButton(). Unlike Button() there is not way to fallback using the label size.
    IM_ASSERT(size_arg.x != 0.0f && size_arg.y != 0.0f);

    const ImGuiID id = window->GetID(str_id);
    ImVec2 size = CalcItemSize(size_arg, 0.0f, 0.0f);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(size);
    if (!ItemAdd(bb, id))
        return false;

    bool hovered, held;
    bool pressed = ButtonBehavior(bb, id, &hovered, &held, flags);

    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
callq 0xeb270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13aa22
movb $0x0, -0x1(%rbp)
jmp 0x13ab31
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x5c(%rbp)
jne 0x13aa3b
jp 0x13aa3b
jmp 0x13aa55
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x5c(%rbp)
movb -0x5c(%rbp), %al
testb $0x1, %al
jne 0x13aa5e
jmp 0x13aa60
jmp 0x13aa7f
leaq 0x53a69(%rip), %rdi     # 0x18e4d0
leaq 0x53972(%rip), %rsi     # 0x18e3e0
movl $0x2da, %edx            # imm = 0x2DA
leaq 0x53a7f(%rip), %rcx     # 0x18e4f9
callq 0xd180
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0xdcef0
movlpd %xmm0, -0x34(%rbp)
movq -0x28(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x68(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x139090
movq -0x68(%rbp), %rsi
movlpd %xmm0, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xe8660
leaq -0x34(%rbp), %rdi
movss 0x37493(%rip), %xmm0    # 0x171f80
callq 0xd6030
movl -0x2c(%rbp), %esi
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xd6250
testb $0x1, %al
jne 0x13ab0c
movb $0x0, -0x1(%rbp)
jmp 0x13ab31
movl -0x2c(%rbp), %esi
movl -0x1c(%rbp), %r8d
leaq -0x50(%rbp), %rdi
leaq -0x59(%rbp), %rdx
leaq -0x5a(%rbp), %rcx
callq 0x139df0
andb $0x1, %al
movb %al, -0x5b(%rbp)
movb -0x5b(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::GetWindowScrollbarRect(ImGuiWindow*, ImGuiAxis)
ImRect ImGui::GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis)
{
    const ImRect outer_rect = window->Rect();
    const ImRect inner_rect = window->InnerRect;
    const float border_size = window->WindowBorderSize;
    const float scrollbar_size = window->ScrollbarSizes[axis ^ 1]; // (ScrollbarSizes.x = width of Y scrollbar; ScrollbarSizes.y = height of X scrollbar)
    IM_ASSERT(scrollbar_size > 0.0f);
    if (axis == ImGuiAxis_X)
        return ImRect(inner_rect.Min.x, ImMax(outer_rect.Min.y, outer_rect.Max.y - border_size - scrollbar_size), inner_rect.Max.x, outer_rect.Max.y);
    else
        return ImRect(ImMax(outer_rect.Min.x, outer_rect.Max.x - border_size - scrollbar_size), inner_rect.Min.y, outer_rect.Max.x, inner_rect.Max.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xeb880
movlpd %xmm0, -0x2c(%rbp)
movlpd %xmm1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x218(%rax), %rcx
movq %rcx, -0x3c(%rbp)
movq 0x220(%rax), %rax
movq %rax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movss 0x4c(%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x84, %rdi
movl -0x1c(%rbp), %eax
xorl $0x1, %eax
movslq %eax, %rsi
callq 0x15bb20
movss (%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x44(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x13b59b
jmp 0x13b5ba
leaq 0x52fb5(%rip), %rdi     # 0x18e557
leaq 0x52e37(%rip), %rsi     # 0x18e3e0
movl $0x351, %edx            # imm = 0x351
leaq 0x52fb8(%rip), %rcx     # 0x18e56d
callq 0xd180
cmpl $0x0, -0x1c(%rbp)
jne 0x13b600
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
subss -0x40(%rbp), %xmm1
subss -0x44(%rbp), %xmm1
callq 0x139050
movaps %xmm0, %xmm1
movss -0x48(%rbp), %xmm0
movss -0x34(%rbp), %xmm2
movss -0x20(%rbp), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
jmp 0x13b631
movss -0x2c(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
subss -0x40(%rbp), %xmm1
subss -0x44(%rbp), %xmm1
callq 0x139050
movss -0x38(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
movss -0x30(%rbp), %xmm3
leaq -0x10(%rbp), %rdi
callq 0xec090
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::ImageButton(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, int, ImVec4 const&, ImVec4 const&)
bool ImGui::ImageButton(ImTextureID user_texture_id, const ImVec2& size, const ImVec2& uv0, const ImVec2& uv1, int frame_padding, const ImVec4& bg_col, const ImVec4& tint_col)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return false;

    // Default to using texture ID as ID. User can still push string/integer prefixes.
    PushID((void*)(intptr_t)user_texture_id);
    const ImGuiID id = window->GetID("#image");
    PopID();

    const ImVec2 padding = (frame_padding >= 0) ? ImVec2((float)frame_padding, (float)frame_padding) : g.Style.FramePadding;
    return ImageButtonEx(id, user_texture_id, size, uv0, uv1, padding, bg_col, tint_col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
leaq 0xd6845(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13c727
movb $0x0, -0x1(%rbp)
jmp 0x13c7a8
movq -0x10(%rbp), %rdi
callq 0xdb500
movq -0x48(%rbp), %rdi
leaq 0x51f03(%rip), %rsi     # 0x18e63e
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x4c(%rbp)
callq 0xdb640
cmpl $0x0, -0x2c(%rbp)
jl 0x13c767
cvtsi2ssl -0x2c(%rbp), %xmm0
cvtsi2ssl -0x2c(%rbp), %xmm1
leaq -0x54(%rbp), %rdi
callq 0xbf4c0
jmp 0x13c776
movq -0x40(%rbp), %rax
movq 0x1598(%rax), %rax
movq %rax, -0x54(%rbp)
movl -0x4c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r10
movq 0x10(%rbp), %rax
leaq -0x54(%rbp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x13c3b0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::RadioButton(char const*, int*, int)
bool ImGui::RadioButton(const char* label, int* v, int v_button)
{
    const bool pressed = RadioButton(label, *v == v_button);
    if (pressed)
        *v = v_button;
    return pressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x13cdf0
andb $0x1, %al
movb %al, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
je 0x13d3a2
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Bullet()
void ImGui::Bullet()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiContext& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    const float line_height = ImMax(ImMin(window->DC.CurrLineSize.y, g.FontSize + g.Style.FramePadding.y * 2), g.FontSize);
    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(g.FontSize, line_height));
    ItemSize(bb);
    if (!ItemAdd(bb, 0))
    {
        SameLine(0, style.FramePadding.x * 2);
        return;
    }

    // Render and stay on same line
    ImU32 text_col = GetColorU32(ImGuiCol_Text);
    RenderBullet(window->DrawList, bb.Min + ImVec2(style.FramePadding.x + g.FontSize * 0.5f, line_height * 0.5f), text_col);
    SameLine(0, style.FramePadding.x * 2.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
callq 0xeb270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13d6e3
jmp 0x13d86b
leaq 0xd5856(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1560, %rax           # imm = 0x1560
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movss 0x104(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm2
movss 0x159c(%rax), %xmm1
addss %xmm1, %xmm1
addss %xmm2, %xmm1
callq 0x13c690
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm1
callq 0x139050
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
leaq -0x3c(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xbf4c0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x139090
movq -0x58(%rbp), %rsi
movlpd %xmm0, -0x34(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0xe8660
leaq -0x2c(%rbp), %rdi
movss 0x347e3(%rip), %xmm0    # 0x171f80
callq 0xdc300
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd6250
testb $0x1, %al
jne 0x13d7d3
movq -0x18(%rbp), %rax
movss 0x3480b(%rip), %xmm1    # 0x171fcc
mulss 0x38(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0xdc1c0
jmp 0x13d86b
xorl %edi, %edi
movss 0x3345f(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movss 0x38(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm0
movss 0x347c7(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm1
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xbf4c0
movq -0x70(%rbp), %rsi
leaq -0x2c(%rbp), %rdi
callq 0x139090
movq -0x68(%rbp), %rdi
movlpd %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %esi
movsd -0x48(%rbp), %xmm0
callq 0x11cd90
movq -0x18(%rbp), %rax
movss 0x3476e(%rip), %xmm1    # 0x171fcc
mulss 0x38(%rax), %xmm1
xorps %xmm0, %xmm0
callq 0xdc1c0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Spacing()
void ImGui::Spacing()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;
    ItemSize(ImVec2(0, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xeb270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13d8a0
jmp 0x13d8c0
leaq -0x10(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x10(%rbp), %rdi
movss 0x346c5(%rip), %xmm0    # 0x171f80
callq 0xd6030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Dummy(ImVec2 const&)
void ImGui::Dummy(const ImVec2& size)
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    const ImRect bb(window->DC.CursorPos, window->DC.CursorPos + size);
    ItemSize(size);
    ItemAdd(bb, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0xeb270
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13d8f4
jmp 0x13d942
movq -0x10(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x30(%rbp)
movq -0x8(%rbp), %rsi
callq 0x139090
movq -0x30(%rbp), %rsi
movlpd %xmm0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xe8660
movq -0x8(%rbp), %rdi
movss 0x34652(%rip), %xmm0    # 0x171f80
callq 0xd6030
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd6250
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::NewLine()
void ImGui::NewLine()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiContext& g = *GImGui;
    const ImGuiLayoutType backup_layout_type = window->DC.LayoutType;
    window->DC.LayoutType = ImGuiLayoutType_Vertical;
    if (window->DC.CurrLineSize.y > 0.0f)     // In the event that we are on a line with items that is smaller that FontSize high, we will preserve its height.
        ItemSize(ImVec2(0, 0));
    else
        ItemSize(ImVec2(0.0f, g.FontSize));
    window->DC.LayoutType = backup_layout_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xeb270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13d973
jmp 0x13da08
leaq 0xd55c6(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1bc(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x1bc(%rax)
movq -0x8(%rbp), %rax
movss 0x104(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x13d9d2
leaq -0x1c(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq -0x1c(%rbp), %rdi
movss 0x345b5(%rip), %xmm0    # 0x171f80
callq 0xd6030
jmp 0x13d9fb
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm1
leaq -0x24(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xbf4c0
leaq -0x24(%rbp), %rdi
movss 0x3458a(%rip), %xmm0    # 0x171f80
callq 0xd6030
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1bc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::AlignTextToFramePadding()
void ImGui::AlignTextToFramePadding()
{
    ImGuiWindow* window = GetCurrentWindow();
    if (window->SkipItems)
        return;

    ImGuiContext& g = *GImGui;
    window->DC.CurrLineSize.y = ImMax(window->DC.CurrLineSize.y, g.FontSize + g.Style.FramePadding.y * 2);
    window->DC.CurrLineTextBaseOffset = ImMax(window->DC.CurrLineTextBaseOffset, g.Style.FramePadding.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xeb270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13da30
jmp 0x13daa4
leaq 0xd5509(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x104(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm2
movq -0x10(%rbp), %rax
movss 0x159c(%rax), %xmm1
addss %xmm1, %xmm1
addss %xmm2, %xmm1
callq 0x139050
movq -0x8(%rbp), %rax
movss %xmm0, 0x104(%rax)
movq -0x8(%rbp), %rax
movss 0x110(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x159c(%rax), %xmm1
callq 0x139050
movq -0x8(%rbp), %rax
movss %xmm0, 0x110(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Separator()
void ImGui::Separator()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    if (window->SkipItems)
        return;

    // Those flags should eventually be overridable by the user
    ImGuiSeparatorFlags flags = (window->DC.LayoutType == ImGuiLayoutType_Horizontal) ? ImGuiSeparatorFlags_Vertical : ImGuiSeparatorFlags_Horizontal;
    flags |= ImGuiSeparatorFlags_SpanAllColumns;
    SeparatorEx(flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xd5071(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x93(%rax)
je 0x13def4
jmp 0x13df22
movq -0x10(%rbp), %rax
movl 0x1bc(%rax), %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x13dab0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ShrinkWidthItemComparer(void const*, void const*)
static int IMGUI_CDECL ShrinkWidthItemComparer(const void* lhs, const void* rhs)
{
    const ImGuiShrinkWidthItem* a = (const ImGuiShrinkWidthItem*)lhs;
    const ImGuiShrinkWidthItem* b = (const ImGuiShrinkWidthItem*)rhs;
    if (int d = (int)(b->Width - a->Width))
        return d;
    return (b->Index - a->Index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
subss 0x4(%rax), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x13e683
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13e692
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: CalcMaxPopupHeightFromItemCount(int)
static float CalcMaxPopupHeightFromItemCount(int items_count)
{
    ImGuiContext& g = *GImGui;
    if (items_count <= 0)
        return FLT_MAX;
    return (g.FontSize + g.Style.ItemSpacing.y) * items_count - g.Style.ItemSpacing.y + (g.Style.WindowPadding.y * 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0xd3ef2(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jg 0x13f06a
movss 0x32f51(%rip), %xmm0    # 0x171fb4
movss %xmm0, -0x4(%rbp)
jmp 0x13f0c1
movq -0x10(%rbp), %rax
movss 0x1980(%rax), %xmm1
movq -0x10(%rbp), %rax
addss 0x15ac(%rax), %xmm1
cvtsi2ssl -0x8(%rbp), %xmm2
movq -0x10(%rbp), %rax
movss 0x15ac(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x10(%rbp), %rax
movss 0x1568(%rax), %xmm0
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: Items_ArrayGetter(void*, int, char const**)
static bool Items_ArrayGetter(void* data, int idx, const char** out_text)
{
    const char* const* items = (const char* const*)data;
    if (out_text)
        *out_text = items[idx];
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13fb41
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::Combo(char const*, int*, char const*, int)
bool ImGui::Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items)
{
    int items_count = 0;
    const char* p = items_separated_by_zeros;       // FIXME-OPT: Avoid computing this, or at least only when combo is open
    while (*p)
    {
        p += strlen(p) + 1;
        items_count++;
    }
    bool value_changed = Combo(label, current_item, Items_SingleStringGetter, (void*)items_separated_by_zeros, items_count, height_in_items);
    return value_changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x13fb9f
movq -0x28(%rbp), %rdi
callq 0xd410
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13fb76
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %r8d
movl -0x1c(%rbp), %r9d
leaq 0x16(%rip), %rdx        # 0x13fbd0
callq 0x13f0e0
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: Items_SingleStringGetter(void*, int, char const**)
static bool Items_SingleStringGetter(void* data, int idx, const char** out_text)
{
    // FIXME-OPT: we could pre-compute the indices to fasten this. But only 1 active combo means the waste is limited.
    const char* items_separated_by_zeros = (const char*)data;
    int items_count = 0;
    const char* p = items_separated_by_zeros;
    while (*p)
    {
        if (idx == items_count)
            break;
        p += strlen(p) + 1;
        items_count++;
    }
    if (!*p)
        return false;
    if (out_text)
        *out_text = p;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x13fc2d
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x13fc0d
jmp 0x13fc2d
movq -0x38(%rbp), %rdi
callq 0xd410
addq $0x1, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13fbfa
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x13fc3c
movb $0x0, -0x1(%rbp)
jmp 0x13fc52
cmpq $0x0, -0x20(%rbp)
je 0x13fc4e
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::DataTypeCompare(int, void const*, void const*)
int ImGui::DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2)
{
    switch (data_type)
    {
    case ImGuiDataType_S8:     return DataTypeCompareT<ImS8  >((const ImS8*  )arg_1, (const ImS8*  )arg_2);
    case ImGuiDataType_U8:     return DataTypeCompareT<ImU8  >((const ImU8*  )arg_1, (const ImU8*  )arg_2);
    case ImGuiDataType_S16:    return DataTypeCompareT<ImS16 >((const ImS16* )arg_1, (const ImS16* )arg_2);
    case ImGuiDataType_U16:    return DataTypeCompareT<ImU16 >((const ImU16* )arg_1, (const ImU16* )arg_2);
    case ImGuiDataType_S32:    return DataTypeCompareT<ImS32 >((const ImS32* )arg_1, (const ImS32* )arg_2);
    case ImGuiDataType_U32:    return DataTypeCompareT<ImU32 >((const ImU32* )arg_1, (const ImU32* )arg_2);
    case ImGuiDataType_S64:    return DataTypeCompareT<ImS64 >((const ImS64* )arg_1, (const ImS64* )arg_2);
    case ImGuiDataType_U64:    return DataTypeCompareT<ImU64 >((const ImU64* )arg_1, (const ImU64* )arg_2);
    case ImGuiDataType_Float:  return DataTypeCompareT<float >((const float* )arg_1, (const float* )arg_2);
    case ImGuiDataType_Double: return DataTypeCompareT<double>((const double*)arg_1, (const double*)arg_2);
    case ImGuiDataType_COUNT:  break;
    }
    IM_ASSERT(0);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0xa, %rax
ja 0x14108a
movq -0x20(%rbp), %rax
leaq 0x4d2dd(%rip), %rcx     # 0x18e29c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1410c0
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141110
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141160
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1411b0
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141200
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141250
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1412a0
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1412f0
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141340
movl %eax, -0x4(%rbp)
jmp 0x1410a9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x141390
movl %eax, -0x4(%rbp)
jmp 0x1410a9
jmp 0x14108a
leaq 0x34079(%rip), %rdi     # 0x17510a
leaq 0x4d348(%rip), %rsi     # 0x18e3e0
movl $0x7d7, %edx            # imm = 0x7D7
leaq 0x4d99c(%rip), %rcx     # 0x18ea40
callq 0xd180
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: PatchFormatStringFloatToInt(char const*)
static const char* PatchFormatStringFloatToInt(const char* fmt)
{
    if (fmt[0] == '%' && fmt[1] == '.' && fmt[2] == '0' && fmt[3] == 'f' && fmt[4] == 0) // Fast legacy path for "%.0f" which is expected to be the most common case.
        return "%d";
    const char* fmt_start = ImParseFormatFindStart(fmt);    // Find % (if any, and ignore %%)
    const char* fmt_end = ImParseFormatFindEnd(fmt_start);  // Find end of format specifier, which itself is an exercise of confidence/recklessness (because snprintf is dependent on libc or user).
    if (fmt_end > fmt_start && fmt_end[-1] == 'f')
    {
#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
        if (fmt_start == fmt && fmt_end[0] == 0)
            return "%d";
        ImGuiContext& g = *GImGui;
        ImFormatString(g.TempBuffer, IM_ARRAYSIZE(g.TempBuffer), "%.*s%%d%s", (int)(fmt_start - fmt), fmt, fmt_end); // Honor leading and trailing decorations, but lose alignment/precision.
        return g.TempBuffer;
#else
        IM_ASSERT(0 && "DragInt(): Invalid format string!"); // Old versions used a default parameter of "%.0f", please replace with e.g. "%d"
#endif
    }
    return fmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x142adc
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0x142adc
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x30, %eax
jne 0x142adc
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x66, %eax
jne 0x142adc
movq -0x10(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0x142adc
leaq 0x36ef4(%rip), %rax     # 0x1799c7
movq %rax, -0x8(%rbp)
jmp 0x142b8d
movq -0x10(%rbp), %rdi
callq 0x145440
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1454b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x142b85
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x66, %eax
jne 0x142b85
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x142b34
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x142b34
leaq 0x36e99(%rip), %rax     # 0x1799c7
movq %rax, -0x8(%rbp)
jmp 0x142b8d
leaq 0xd0405(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x3378, %rdi           # imm = 0x3378
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0xc01, %esi            # imm = 0xC01
leaq 0x4da48(%rip), %rdx     # 0x1905b6
movb $0x0, %al
callq 0xc4d30
movq -0x28(%rbp), %rax
addq $0x3378, %rax           # imm = 0x3378
movq %rax, -0x8(%rbp)
jmp 0x142b8d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::DragScalar(char const*, int, void*, float, void const*, void const*, char const*, float)
bool ImGui::DragScalar(const char* label, ImGuiDataType data_type, void* p_data, float v_speed, const void* p_min, const void* p_max, const char* format, float power)
{
    ImGuiSliderFlags drag_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        IM_ASSERT(p_min != NULL && p_max != NULL);  // When using a power curve the drag needs to have known bounds
        drag_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return DragScalar(label, data_type, p_data, v_speed, p_min, p_max, format, drag_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movss %xmm1, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movss -0x3c(%rbp), %xmm0
movss 0x2d41f(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
jne 0x143829
jp 0x143829
jmp 0x1438bd
movss -0x3c(%rbp), %xmm0
xorl %eax, %eax
movss 0x2d404(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
movb %al, -0x41(%rbp)
jne 0x143849
jp 0x143849
movb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x143849
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x143852
jmp 0x143854
jmp 0x143873
leaq 0x4b4e3(%rip), %rdi     # 0x18ed3e
leaq 0x4ab7e(%rip), %rsi     # 0x18e3e0
movl $0x9b7, %edx            # imm = 0x9B7
leaq 0x4b54a(%rip), %rcx     # 0x18edb8
callq 0xd180
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x42(%rbp)
je 0x14388a
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x143893
jmp 0x143895
jmp 0x1438b4
leaq 0x4b590(%rip), %rdi     # 0x18ee2c
leaq 0x4ab3d(%rip), %rsi     # 0x18e3e0
movl $0x9b8, %edx            # imm = 0x9B8
leaq 0x4b509(%rip), %rcx     # 0x18edb8
callq 0xd180
movl -0x40(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movss -0x1c(%rbp), %xmm0
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movl -0x40(%rbp), %eax
movl %eax, (%rsp)
callq 0x1422c0
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_widgets.cpp
// Function: ImGui::DragScalarN(char const*, int, void*, int, float, void const*, void const*, char const*, float)
bool ImGui::DragScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, float v_speed, const void* p_min, const void* p_max, const char* format, float power)
{
    ImGuiSliderFlags drag_flags = ImGuiSliderFlags_None;
    if (power != 1.0f)
    {
        IM_ASSERT(power == 1.0f && "Call function with ImGuiSliderFlags_Logarithmic flags instead of using the old 'float power' function!");
        IM_ASSERT(p_min != NULL && p_max != NULL);  // When using a power curve the drag needs to have known bounds
        drag_flags |= ImGuiSliderFlags_Logarithmic;   // Fallback for non-asserting paths
    }
    return DragScalarN(label, data_type, p_data, components, v_speed, p_min, p_max, format, drag_flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movss %xmm1, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
movss 0x2d30c(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
jne 0x14393c
jp 0x14393c
jmp 0x1439d0
movss -0x34(%rbp), %xmm0
xorl %eax, %eax
movss 0x2d2f1(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
movb %al, -0x39(%rbp)
jne 0x14395c
jp 0x14395c
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x14395c
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x143965
jmp 0x143967
jmp 0x143986
leaq 0x4b3d0(%rip), %rdi     # 0x18ed3e
leaq 0x4aa6b(%rip), %rsi     # 0x18e3e0
movl $0x9c3, %edx            # imm = 0x9C3
leaq 0x4b4ce(%rip), %rcx     # 0x18ee4f
callq 0xd180
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x3a(%rbp)
je 0x14399d
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x1439a6
jmp 0x1439a8
jmp 0x1439c7
leaq 0x4b47d(%rip), %rdi     # 0x18ee2c
leaq 0x4aa2a(%rip), %rsi     # 0x18e3e0
movl $0x9c4, %edx            # imm = 0x9C4
leaq 0x4b48d(%rip), %rcx     # 0x18ee4f
callq 0xd180
movl -0x38(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movss -0x20(%rbp), %xmm0
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %r10
movl -0x38(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x142d60
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)