LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::SetWindowClipRectBeforeSetChannel(ImGuiWindow*, ImRect const&)
void ImGui::SetWindowClipRectBeforeSetChannel(ImGuiWindow* window, const ImRect& clip_rect)
{
    ImVec4 clip_rect_vec4 = clip_rect.ToVec4();
    window->ClipRect = clip_rect;
    window->DrawList->_CmdHeader.ClipRect = clip_rect_vec4;
    window->DrawList->_ClipRectStack.Data[window->DrawList->_ClipRectStack.Size - 1] = clip_rect_vec4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x137560
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x258(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2b8(%rcx), %rcx
movl 0x58(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnIndex()
int ImGui::TableGetColumnIndex()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return 0;
    return table->CurrentColumn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe1555(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131a11
movl $0x0, -0x4(%rbp)
jmp 0x131a1b
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSetColumnIndex(int)
bool ImGui::TableSetColumnIndex(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return false;

    if (table->CurrentColumn != column_n)
    {
        if (table->CurrentColumn != -1)
            TableEndCell(table);
        IM_ASSERT(column_n >= 0 && table->ColumnsCount);
        TableBeginCell(table, column_n);
    }

    // Return whether the column is visible. User may choose to skip submitting items based on this return value,
    // however they shouldn't skip submitting for columns that may have the tallest contribution to row height.
    return (table->RequestOutputMaskByIndex & ((ImU64)1 << column_n)) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq 0xe150e(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131a58
movb $0x0, -0x1(%rbp)
jmp 0x131aeb
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x131ac6
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x131a77
movq -0x18(%rbp), %rdi
callq 0x131810
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
jl 0x131a90
movq -0x18(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x131a99
jmp 0x131a9b
jmp 0x131aba
leaq 0x5b13f(%rip), %rdi     # 0x18cbe1
leaq 0x5a4f9(%rip), %rsi     # 0x18bfa2
movl $0x701, %edx            # imm = 0x701
leaq 0x5b151(%rip), %rcx     # 0x18cc06
callq 0xd180
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x131b00
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x8(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableNextColumn()
bool ImGui::TableNextColumn()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return false;

    if (table->IsInsideRow && table->CurrentColumn + 1 < table->ColumnsCount)
    {
        if (table->CurrentColumn != -1)
            TableEndCell(table);
        TableBeginCell(table, table->CurrentColumn + 1);
    }
    else
    {
        TableNextRow();
        TableBeginCell(table, 0);
    }

    // Return whether the column is visible. User may choose to skip submitting items based on this return value,
    // however they shouldn't skip submitting for columns that may have the tallest contribution to row height.
    int column_n = table->CurrentColumn;
    return (table->RequestOutputMaskByIndex & ((ImU64)1 << column_n)) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe11f1(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131d75
movb $0x0, -0x1(%rbp)
jmp 0x131e01
movq -0x18(%rbp), %rax
testb $0x1, 0x249(%rax)
je 0x131dbd
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x131dbd
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x131da8
movq -0x18(%rbp), %rdi
callq 0x131810
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x74(%rax), %esi
addl $0x1, %esi
callq 0x131b00
jmp 0x131dd2
xorl %edi, %edi
xorps %xmm0, %xmm0
callq 0x131530
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x131b00
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSetColumnWidthAutoAll(ImGuiTable*)
void ImGui::TableSetColumnWidthAutoAll(ImGuiTable* table)
{
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (!column->IsEnabled && !(column->Flags & ImGuiTableColumnFlags_WidthStretch)) // Cannot reset weight of hidden stretch column
            continue;
        column->CannotSkipItemsQueue = (1 << 0);
        column->AutoFitQueue = (1 << 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x132088
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0xeea20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x5a(%rax)
jne 0x13206d
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x13206d
jmp 0x13207d
movq -0x18(%rbp), %rax
movb $0x1, 0x63(%rax)
movq -0x18(%rbp), %rax
movb $0x2, 0x62(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x132033
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TablePushBackgroundChannel()
void ImGui::TablePushBackgroundChannel()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiTable* table = g.CurrentTable;

    // Optimization: avoid SetCurrentChannel() + PushClipRect()
    table->HostBackupInnerClipRect = window->ClipRect;
    SetWindowClipRectBeforeSetChannel(window, table->Bg2ClipRectForDrawCmd);
    table->DrawSplitter.SetCurrentChannel(window->DrawList, table->Bg2DrawChannelCurrent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe0ea1(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x258(%rcx), %rdx
movq %rdx, 0x18c(%rax)
movq 0x260(%rcx), %rcx
movq %rcx, 0x194(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x14c, %rsi            # imm = 0x14C
callq 0x131940
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq -0x10(%rbp), %rax
movq 0x2b8(%rax), %rsi
movq -0x18(%rbp), %rax
movzbl 0x246(%rax), %edx
callq 0x115220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TablePopBackgroundChannel()
void ImGui::TablePopBackgroundChannel()
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiTable* table = g.CurrentTable;
    ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];

    // Optimization: avoid PopClipRect() + SetCurrentChannel()
    SetWindowClipRectBeforeSetChannel(window, table->HostBackupInnerClipRect);
    table->DrawSplitter.SetCurrentChannel(window->DrawList, column->DrawChannelCurrent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe0e01(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movl 0x74(%rax), %esi
callq 0xeea20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18c, %rsi            # imm = 0x18C
callq 0x131940
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq -0x10(%rbp), %rax
movq 0x2b8(%rax), %rsi
movq -0x20(%rbp), %rax
movzbl 0x57(%rax), %edx
callq 0x115220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetSortSpecs()
ImGuiTableSortSpecs* ImGui::TableGetSortSpecs()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL);

    if (!(table->Flags & ImGuiTableFlags_Sortable))
        return NULL;

    // Require layout (in case TableHeadersRow() hasn't been called) as it may alter IsSortSpecsDirty in some paths.
    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);

    if (table->IsSortSpecsDirty)
        TableSortSpecsBuild(table);

    return &table->SortSpecs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe0d41(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13221e
jmp 0x13223d
leaq 0x5ad5a(%rip), %rdi     # 0x18cf7f
leaq 0x59d76(%rip), %rsi     # 0x18bfa2
movl $0x9c0, %edx            # imm = 0x9C0
leaq 0x5ad57(%rip), %rcx     # 0x18cf8f
callq 0xd180
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x132256
movq $0x0, -0x8(%rbp)
jmp 0x132290
movq -0x18(%rbp), %rax
testb $0x1, 0x248(%rax)
jne 0x13226c
movq -0x18(%rbp), %rdi
callq 0x12b270
movq -0x18(%rbp), %rax
testb $0x1, 0x24b(%rax)
je 0x132282
movq -0x18(%rbp), %rdi
callq 0x12d970
movq -0x18(%rbp), %rax
addq $0x220, %rax            # imm = 0x220
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableFixColumnSortDirection(ImGuiTable*, ImGuiTableColumn*)
void ImGui::TableFixColumnSortDirection(ImGuiTable* table, ImGuiTableColumn* column)
{
    if (column->SortOrder == -1 || (column->SortDirectionsAvailMask & (1 << column->SortDirection)) != 0)
        return;
    column->SortDirection = (ImU8)TableGetColumnAvailSortDirection(column, 0);
    table->IsSortSpecsDirty = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x56(%rax), %eax
cmpl $-0x1, %eax
je 0x1322e7
movq -0x10(%rbp), %rax
movb 0x64(%rax), %al
shrb $0x4, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movb 0x64(%rcx), %cl
andb $0x3, %cl
movzbl %cl, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1322e9
jmp 0x132313
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x132320
movb %al, %dl
movq -0x10(%rbp), %rax
movb 0x64(%rax), %cl
andb $0x3, %dl
andb $-0x4, %cl
orb %dl, %cl
movb %cl, 0x64(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x24b(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnNextSortDirection(ImGuiTableColumn*)
ImGuiSortDirection ImGui::TableGetColumnNextSortDirection(ImGuiTableColumn* column)
{
    IM_ASSERT(column->SortDirectionsAvailCount > 0);
    if (column->SortOrder == -1)
        return TableGetColumnAvailSortDirection(column, 0);
    for (int n = 0; n < 3; n++)
        if (column->SortDirection == TableGetColumnAvailSortDirection(column, n))
            return TableGetColumnAvailSortDirection(column, (n + 1) % column->SortDirectionsAvailCount);
    IM_ASSERT(0);
    return ImGuiSortDirection_None;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x64(%rax), %al
shrb $0x2, %al
andb $0x3, %al
movzbl %al, %eax
cmpl $0x0, %eax
jle 0x1323a2
jmp 0x1323c1
leaq 0x5ac16(%rip), %rdi     # 0x18cfbf
leaq 0x59bf2(%rip), %rsi     # 0x18bfa2
movl $0x9e4, %edx            # imm = 0x9E4
leaq 0x5ac28(%rip), %rcx     # 0x18cfe4
callq 0xd180
movq -0x10(%rbp), %rax
movsbl 0x56(%rax), %eax
cmpl $-0x1, %eax
jne 0x1323e1
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x132320
movl %eax, -0x4(%rbp)
jmp 0x132467
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x132448
movq -0x10(%rbp), %rax
movb 0x64(%rax), %al
andb $0x3, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x132320
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jne 0x13243b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
movb 0x64(%rcx), %cl
shrb $0x2, %cl
andb $0x3, %cl
movzbl %cl, %ecx
cltd
idivl %ecx
movl %edx, %esi
callq 0x132320
movl %eax, -0x4(%rbp)
jmp 0x132467
jmp 0x13243d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1323e8
leaq 0x42cbb(%rip), %rdi     # 0x17510a
leaq 0x59b4c(%rip), %rsi     # 0x18bfa2
movl $0x9ea, %edx            # imm = 0x9EA
leaq 0x5ab82(%rip), %rcx     # 0x18cfe4
callq 0xd180
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetHeaderRowHeight()
float ImGui::TableGetHeaderRowHeight()
{
    // Caring for a minor edge case:
    // Calculate row height, for the unlikely case that some labels may be taller than others.
    // If we didn't do that, uneven header height would highlight but smaller one before the tallest wouldn't catch input for all height.
    // In your custom header row you may omit this all together and just call TableNextRow() without a height...
    float row_height = GetTextLineHeight();
    int columns_count = TableGetColumnCount();
    for (int column_n = 0; column_n < columns_count; column_n++)
        if (TableGetColumnFlags(column_n) & ImGuiTableColumnFlags_IsEnabled)
            row_height = ImMax(row_height, CalcTextSize(TableGetColumnName(column_n)).y);
    row_height += GetStyle().CellPadding.y * 2.0f;
    return row_height;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xdd000
movss %xmm0, -0x4(%rbp)
callq 0x131010
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x132a8a
movl -0xc(%rbp), %edi
callq 0x131160
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0x132a7d
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x131050
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
movss 0x3f524(%rip), %xmm0    # 0x171f80
callq 0xc87e0
movaps %xmm0, %xmm1
movss -0x18(%rbp), %xmm0
movlpd %xmm1, -0x14(%rbp)
movss -0x10(%rbp), %xmm1
callq 0x12a620
movss %xmm0, -0x4(%rbp)
jmp 0x132a7f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x132a21
callq 0xc7680
movss 0x5c(%rax), %xmm0
movss -0x4(%rbp), %xmm1
addss %xmm0, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSettingsCreate(unsigned int, int)
ImGuiTableSettings* ImGui::TableSettingsCreate(ImGuiID id, int columns_count)
{
    ImGuiContext& g = *GImGui;
    ImGuiTableSettings* settings = g.SettingsTables.alloc_chunk(TableSettingsCalcChunkSize(columns_count));
    TableSettingsInit(settings, id, columns_count, columns_count);
    return settings;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xdf88b(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x3118, %rax           # imm = 0x3118
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
callq 0x133700
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x137780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0x8(%rbp), %ecx
callq 0x133720
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: TableSettingsInit(ImGuiTableSettings*, unsigned int, int, int)
static void TableSettingsInit(ImGuiTableSettings* settings, ImGuiID id, int columns_count, int columns_count_max)
{
    IM_PLACEMENT_NEW(settings) ImGuiTableSettings();
    ImGuiTableColumnSettings* settings_column = settings->GetColumnSettings();
    for (int n = 0; n < columns_count_max; n++, settings_column++)
        IM_PLACEMENT_NEW(settings_column) ImGuiTableColumnSettings();
    settings->ID = id;
    settings->ColumnsCount = (ImGuiTableColumnIdx)columns_count;
    settings->ColumnsCountMax = (ImGuiTableColumnIdx)columns_count_max;
    settings->WantApply = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movl $0x10, %edi
callq 0xe9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x137d70
jmp 0x133758
movq -0x8(%rbp), %rdi
callq 0x137910
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1337e6
movq -0x30(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movl $0xc, %edi
callq 0xe9510
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x137da0
jmp 0x133797
jmp 0x133799
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x30(%rbp)
jmp 0x13376c
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xea550
jmp 0x133815
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xea550
jmp 0x133815
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xe(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd620
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSettingsFindByID(unsigned int)
ImGuiTableSettings* ImGui::TableSettingsFindByID(ImGuiID id)
{
    // FIXME-OPT: Might want to store a lookup map for this?
    ImGuiContext& g = *GImGui;
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
        if (settings->ID == id)
            return settings;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0xdf70e(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
callq 0xec710
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x133885
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x133869
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13388d
jmp 0x13386b
movq -0x18(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
movq -0x20(%rbp), %rsi
callq 0xec750
movq %rax, -0x20(%rbp)
jmp 0x13384d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetBoundSettings(ImGuiTable*)
ImGuiTableSettings* ImGui::TableGetBoundSettings(ImGuiTable* table)
{
    if (table->SettingsOffset != -1)
    {
        ImGuiContext& g = *GImGui;
        ImGuiTableSettings* settings = g.SettingsTables.ptr_from_offset(table->SettingsOffset);
        IM_ASSERT(settings->ID == table->ID);
        if (settings->ColumnsCountMax >= table->ColumnsCount)
            return settings; // OK
        settings->ID = 0; // Invalidate storage, we won't fit because of a count change
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x64(%rax)
je 0x133933
leaq 0xdf683(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
movq -0x10(%rbp), %rax
movl 0x64(%rax), %esi
callq 0x137800
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1338ef
jmp 0x13390e
leaq 0x59aef(%rip), %rdi     # 0x18d3e5
leaq 0x586a5(%rip), %rsi     # 0x18bfa2
movl $0xbf8, %edx            # imm = 0xBF8
leaq 0x59af6(%rip), %rcx     # 0x18d3ff
callq 0xd180
movq -0x20(%rbp), %rax
movsbl 0xd(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jl 0x133929
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13393b
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSettingsInstallHandler(ImGuiContext*)
void ImGui::TableSettingsInstallHandler(ImGuiContext* context)
{
    ImGuiContext& g = *context;
    ImGuiSettingsHandler ini_handler;
    ini_handler.TypeName = "Table";
    ini_handler.TypeHash = ImHashStr("Table");
    ini_handler.ClearAllFn = TableSettingsHandler_ClearAll;
    ini_handler.ReadOpenFn = TableSettingsHandler_ReadOpen;
    ini_handler.ReadLineFn = TableSettingsHandler_ReadLine;
    ini_handler.ApplyAllFn = TableSettingsHandler_ApplyAll;
    ini_handler.WriteAllFn = TableSettingsHandler_WriteAll;
    g.SettingsHandlers.push_back(ini_handler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xeaba0
leaq 0x4d63c(%rip), %rax     # 0x180fb0
movq %rax, -0x58(%rbp)
leaq 0x4d631(%rip), %rdi     # 0x180fb0
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xc4f20
movl %eax, -0x50(%rbp)
leaq 0x4c(%rip), %rax        # 0x1339e0
movq %rax, -0x48(%rbp)
leaq 0xc1(%rip), %rax        # 0x133a60
movq %rax, -0x38(%rbp)
leaq 0x166(%rip), %rax       # 0x133b10
movq %rax, -0x30(%rbp)
leaq 0x46b(%rip), %rax       # 0x133e20
movq %rax, -0x28(%rbp)
leaq 0x4e0(%rip), %rax       # 0x133ea0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
leaq -0x58(%rbp), %rsi
callq 0xeabd0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: TableSettingsHandler_ClearAll(ImGuiContext*, ImGuiSettingsHandler*)
static void TableSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
{
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Tables.GetSize(); i++)
        g.Tables.GetByIndex(i)->SettingsOffset = -1;
    g.SettingsTables.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
callq 0xec6a0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
je 0x133a43
movq -0x18(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movl -0x1c(%rbp), %esi
callq 0xea9d0
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1339ff
movq -0x18(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
callq 0x137df0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: TableSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, char const*)
static void* TableSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name)
{
    ImGuiID id = 0;
    int columns_count = 0;
    if (sscanf(name, "0x%08X,%d", &id, &columns_count) < 2)
        return NULL;

    if (ImGuiTableSettings* settings = ImGui::TableSettingsFindByID(id))
    {
        if (settings->ColumnsCountMax >= columns_count)
        {
            TableSettingsInit(settings, id, columns_count, settings->ColumnsCountMax); // Recycle
            return settings;
        }
        settings->ID = 0; // Invalidate storage, we won't fit because of a count change
    }
    return ImGui::TableSettingsCreate(id, columns_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x5a16d(%rip), %rsi     # 0x18dbfa
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
movb $0x0, %al
callq 0xd0d0
cmpl $0x2, %eax
jge 0x133aab
movq $0x0, -0x8(%rbp)
jmp 0x133b05
movl -0x24(%rbp), %edi
callq 0x133820
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x133af6
movq -0x30(%rbp), %rax
movsbl 0xd(%rax), %eax
cmpl -0x28(%rbp), %eax
jl 0x133aec
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x30(%rbp), %rax
movsbl 0xd(%rax), %ecx
callq 0x133720
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x133b05
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x1336a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: TableSettingsHandler_ApplyAll(ImGuiContext*, ImGuiSettingsHandler*)
static void TableSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
{
    ImGuiContext& g = *ctx;
    for (int i = 0; i != g.Tables.GetSize(); i++)
    {
        ImGuiTable* table = g.Tables.GetByIndex(i);
        table->IsSettingsRequestLoad = true;
        table->SettingsOffset = -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
callq 0xec6a0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
je 0x133e96
movq -0x18(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movl -0x1c(%rbp), %esi
callq 0xea9d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x24e(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x133e3f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableRemove(ImGuiTable*)
void ImGui::TableRemove(ImGuiTable* table)
{
    //IMGUI_DEBUG_LOG("TableRemove() id=0x%08X\n", table->ID);
    ImGuiContext& g = *GImGui;
    int table_idx = g.Tables.GetIndex(table);
    //memset(table->RawData.Data, 0, table->RawData.size_in_bytes());
    //memset(table, 0, sizeof(ImGuiTable));
    g.Tables.Remove(table->ID, table);
    g.TablesLastTimeActive[table_idx] = -1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xded6d(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movq -0x8(%rbp), %rsi
callq 0x136eb0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rdx
callq 0x137930
movq -0x10(%rbp), %rdi
addq $0x20e8, %rdi           # imm = 0x20E8
movl -0x14(%rbp), %esi
callq 0xea950
movss 0x3dd5a(%rip), %xmm0    # 0x171f80
movss %xmm0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGcCompactTransientBuffers(ImGuiTable*)
void ImGui::TableGcCompactTransientBuffers(ImGuiTable* table)
{
    //IMGUI_DEBUG_LOG("TableGcCompactTransientBuffers() id=0x%08X\n", table->ID);
    ImGuiContext& g = *GImGui;
    IM_ASSERT(table->MemoryCompacted == false);
    table->DrawSplitter.ClearFreeMemory();
    table->SortSpecsMulti.clear();
    table->SortSpecs.Specs = NULL;
    table->IsSortSpecsDirty = true;
    table->ColumnsNames.clear();
    table->MemoryCompacted = true;
    for (int n = 0; n < table->ColumnsCount; n++)
        table->Columns[n].NameOffset = -1;
    g.TablesLastTimeActive[g.Tables.GetIndex(table)] = -1.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xdecfd(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x255(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x134260
jmp 0x13427f
leaq 0x59268(%rip), %rdi     # 0x18d4cf
leaq 0x57d34(%rip), %rsi     # 0x18bfa2
movl $0xd0f, %edx            # imm = 0xD0F
leaq 0x59275(%rip), %rcx     # 0x18d4ef
callq 0xd180
movq -0x8(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x10eef0
movq -0x8(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x137970
movq -0x8(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x24b(%rax)
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0xeb160
movq -0x8(%rbp), %rax
movb $0x1, 0x255(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x134308
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %esi
callq 0xeea20
movw $0xffff, 0x50(%rax)     # imm = 0xFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1342db
movq -0x10(%rbp), %rax
addq $0x20e8, %rax           # imm = 0x20E8
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movq -0x8(%rbp), %rsi
callq 0x136eb0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xea950
movss 0x3dc43(%rip), %xmm0    # 0x171f80
movss %xmm0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGcCompactSettings()
void ImGui::TableGcCompactSettings()
{
    ImGuiContext& g = *GImGui;
    int required_memory = 0;
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
        if (settings->ID != 0)
            required_memory += (int)TableSettingsCalcChunkSize(settings->ColumnsCount);
    if (required_memory == g.SettingsTables.Buf.Size)
        return;
    ImChunkStream<ImGuiTableSettings> new_chunk_stream;
    new_chunk_stream.Buf.reserve(required_memory);
    for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
        if (settings->ID != 0)
            memcpy(new_chunk_stream.alloc_chunk(TableSettingsCalcChunkSize(settings->ColumnsCount)), settings, TableSettingsCalcChunkSize(settings->ColumnsCount));
    g.SettingsTables.swap(new_chunk_stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0xdebde(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
callq 0xec710
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1343c3
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1343a7
movq -0x18(%rbp), %rax
movsbl 0xc(%rax), %edi
callq 0x133700
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x1343a9
movq -0x8(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
movq -0x18(%rbp), %rsi
callq 0xec750
movq %rax, -0x18(%rbp)
jmp 0x134384
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3118(%rcx), %eax
jne 0x1343d7
jmp 0x1344d3
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xed740
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xe8470
jmp 0x1343f2
movq -0x8(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
callq 0xec710
movq %rax, -0x50(%rbp)
jmp 0x134408
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1344b4
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13448b
movq -0x40(%rbp), %rax
movsbl 0xc(%rax), %edi
callq 0x133700
movq %rax, -0x58(%rbp)
jmp 0x134437
movq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x137780
movq %rax, -0x60(%rbp)
jmp 0x13444a
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movsbl 0xc(%rax), %edi
callq 0x133700
movq %rax, -0x68(%rbp)
jmp 0x134461
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0xd0a0
jmp 0x13448b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xed820
jmp 0x1344dc
jmp 0x13448d
movq -0x8(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
movq -0x40(%rbp), %rsi
callq 0xec750
movq %rax, -0x78(%rbp)
jmp 0x1344a7
movq -0x78(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x134410
movq -0x8(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
leaq -0x28(%rbp), %rsi
callq 0x1379c0
jmp 0x1344ca
leaq -0x28(%rbp), %rdi
callq 0xed820
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xd620
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: DebugNodeTableGetSizingPolicyDesc(int)
static const char* DebugNodeTableGetSizingPolicyDesc(ImGuiTableFlags sizing_policy)
{
    sizing_policy &= ImGuiTableFlags_SizingMask_;
    if (sizing_policy == ImGuiTableFlags_SizingFixedFit)    { return "FixedFit"; }
    if (sizing_policy == ImGuiTableFlags_SizingFixedSame)   { return "FixedSame"; }
    if (sizing_policy == ImGuiTableFlags_SizingStretchProp) { return "StretchProp"; }
    if (sizing_policy == ImGuiTableFlags_SizingStretchSame) { return "StretchSame"; }
    return "N/A";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xe000, %eax           # imm = 0xE000
movl %eax, -0xc(%rbp)
cmpl $0x2000, -0xc(%rbp)     # imm = 0x2000
jne 0x135058
leaq 0x4c69b(%rip), %rax     # 0x1816ed
movq %rax, -0x8(%rbp)
jmp 0x1350a5
cmpl $0x4000, -0xc(%rbp)     # imm = 0x4000
jne 0x13506e
leaq 0x4c70d(%rip), %rax     # 0x181775
movq %rax, -0x8(%rbp)
jmp 0x1350a5
cmpl $0x6000, -0xc(%rbp)     # imm = 0x6000
jne 0x135084
leaq 0x4c7ba(%rip), %rax     # 0x181838
movq %rax, -0x8(%rbp)
jmp 0x1350a5
cmpl $0x8000, -0xc(%rbp)     # imm = 0x8000
jne 0x13509a
leaq 0x4c812(%rip), %rax     # 0x1818a6
movq %rax, -0x8(%rbp)
jmp 0x1350a5
leaq 0x3d470(%rip), %rax     # 0x172511
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::GetColumnOffset(int)
float ImGui::GetColumnOffset(int column_index)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns == NULL)
        return 0.0f;

    if (column_index < 0)
        column_index = columns->Current;
    IM_ASSERT(column_index < columns->Columns.Size);

    const float t = columns->Columns[column_index].OffsetNorm;
    const float x_offset = ImLerp(columns->OffMinX, columns->OffMaxX, t);
    return x_offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
callq 0xeb540
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1353a7
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x135428
cmpl $0x0, -0x8(%rbp)
jge 0x1353b7
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x1353c5
jmp 0x1353e4
leaq 0x58518(%rip), %rdi     # 0x18d8e4
leaq 0x56bcf(%rip), %rsi     # 0x18bfa2
movl $0xdee, %edx            # imm = 0xDEE
leaq 0x5852a(%rip), %rcx     # 0x18d909
callq 0xd180
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movl -0x8(%rbp), %esi
callq 0xec8a0
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm1
movss -0x1c(%rbp), %xmm2
callq 0x135440
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::GetColumnWidth(int)
float ImGui::GetColumnWidth(int column_index)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns == NULL)
        return GetContentRegionAvail().x;

    if (column_index < 0)
        column_index = columns->Current;
    return GetColumnOffsetFromNorm(columns, columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
leaq 0xddaae(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1354d4
callq 0xd5b40
movlpd %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x13552f
cmpl $0x0, -0x8(%rbp)
jge 0x1354e4
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x8(%rbp), %esi
addl $0x1, %esi
callq 0xec8a0
movss (%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x8(%rbp), %esi
callq 0xec8a0
movss -0x34(%rbp), %xmm0
movq -0x30(%rbp), %rdi
subss (%rax), %xmm0
callq 0x135310
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: GetColumnWidthEx(ImGuiOldColumns*, int, bool)
static float GetColumnWidthEx(ImGuiOldColumns* columns, int column_index, bool before_resize = false)
{
    if (column_index < 0)
        column_index = columns->Current;

    float offset_norm;
    if (before_resize)
        offset_norm = columns->Columns[column_index + 1].OffsetNormBeforeResize - columns->Columns[column_index].OffsetNormBeforeResize;
    else
        offset_norm = columns->Columns[column_index + 1].OffsetNorm - columns->Columns[column_index].OffsetNorm;
    return ImGui::GetColumnOffsetFromNorm(columns, offset_norm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x135746
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
testb $0x1, -0xd(%rbp)
je 0x13578a
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0xec8a0
movss 0x4(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
callq 0xec8a0
movss -0x18(%rbp), %xmm0
subss 0x4(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x1357c4
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0xec8a0
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0xc(%rbp), %esi
callq 0xec8a0
movss -0x1c(%rbp), %xmm0
subss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movss -0x14(%rbp), %xmm0
callq 0x135310
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::SetColumnWidth(int, float)
void ImGui::SetColumnWidth(int column_index, float width)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    IM_ASSERT(columns != NULL);

    if (column_index < 0)
        column_index = columns->Current;
    SetColumnOffset(column_index + 1, GetColumnOffset(column_index) + width);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
callq 0xeb540
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x135811
jmp 0x135830
leaq 0x58113(%rip), %rdi     # 0x18d92b
leaq 0x56783(%rip), %rsi     # 0x18bfa2
movl $0xe29, %edx            # imm = 0xE29
leaq 0x5813a(%rip), %rcx     # 0x18d965
callq 0xd180
cmpl $0x0, -0x4(%rbp)
jge 0x135840
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %edi
callq 0x135370
movl -0x1c(%rbp), %edi
addss -0x8(%rbp), %xmm0
callq 0x135540
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::PushColumnClipRect(int)
void ImGui::PushColumnClipRect(int column_index)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (column_index < 0)
        column_index = columns->Current;

    ImGuiOldColumnData* column = &columns->Columns[column_index];
    PushClipRect(column->ClipRect.Min, column->ClipRect.Max, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0xeb540
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x1358a3
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movl -0x4(%rbp), %esi
callq 0xec8a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
movq -0x20(%rbp), %rsi
addq $0xc, %rsi
addq $0x8, %rsi
xorl %edx, %edx
callq 0xd34b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::PushColumnsBackground()
void ImGui::PushColumnsBackground()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns->Count == 1)
        return;

    // Optimization: avoid SetCurrentChannel() + PushClipRect()
    columns->HostBackupClipRect = window->ClipRect;
    SetWindowClipRectBeforeSetChannel(window, columns->HostInitialClipRect);
    columns->Splitter.SetCurrentChannel(window->DrawList, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xeb540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x13590c
jmp 0x135955
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x258(%rcx), %rdx
movq %rdx, 0x3c(%rax)
movq 0x260(%rcx), %rcx
movq %rcx, 0x44(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2c, %rsi
callq 0x131940
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rsi
xorl %edx, %edx
callq 0x115220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::PopColumnsBackground()
void ImGui::PopColumnsBackground()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImGuiOldColumns* columns = window->DC.CurrentColumns;
    if (columns->Count == 1)
        return;

    // Optimization: avoid PopClipRect() + SetCurrentChannel()
    SetWindowClipRectBeforeSetChannel(window, columns->HostBackupClipRect);
    columns->Splitter.SetCurrentChannel(window->DrawList, columns->Current + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xeb540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x13598c
jmp 0x1359bf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x3c, %rsi
callq 0x131940
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
addl $0x1, %edx
callq 0x115220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::FindOrCreateColumns(ImGuiWindow*, unsigned int)
ImGuiOldColumns* ImGui::FindOrCreateColumns(ImGuiWindow* window, ImGuiID id)
{
    // We have few columns per window so for now we don't need bother much with turning this into a faster lookup.
    for (int n = 0; n < window->ColumnsStorage.Size; n++)
        if (window->ColumnsStorage[n].ID == id)
            return &window->ColumnsStorage[n];

    window->ColumnsStorage.push_back(ImGuiOldColumns());
    ImGuiOldColumns* columns = &window->ColumnsStorage.back();
    columns->ID = id;
    return columns;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x2a0(%rcx), %eax
jge 0x135a3b
movq -0x10(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
movl -0x18(%rbp), %esi
callq 0xe9080
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x135a2e
movq -0x10(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
movl -0x18(%rbp), %esi
callq 0xe9080
movq %rax, -0x8(%rbp)
jmp 0x135ad0
jmp 0x135a30
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1359e9
movq -0x10(%rbp), %rax
addq $0x2a0, %rax            # imm = 0x2A0
movq %rax, -0xc8(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x137a60
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x1379f0
jmp 0x135a74
leaq -0xa0(%rbp), %rdi
callq 0xe9100
movq -0x10(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
callq 0x137af0
movq %rax, -0xb8(%rbp)
movl -0x14(%rbp), %ecx
movq -0xb8(%rbp), %rax
movl %ecx, (%rax)
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x135ad0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xe9100
jmp 0x135add
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0xd620
nopl (%rax)
// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::GetColumnsID(char const*, int)
ImGuiID ImGui::GetColumnsID(const char* str_id, int columns_count)
{
    ImGuiWindow* window = GetCurrentWindow();

    // Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
    // In addition, when an identifier isn't explicitly provided we include the number of columns in the hash to make it uniquer.
    PushID(0x11223347 + (str_id ? 0 : columns_count));
    ImGuiID id = window->GetID(str_id ? str_id : "columns");
    PopID();

    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0xeb270
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x135b16
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x135b1c
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
addl $0x11223347, %edi       # imm = 0x11223347
callq 0xdb550
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x135b43
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x135b50
leaq 0x4c09c(%rip), %rax     # 0x181be6
movq %rax, -0x30(%rbp)
jmp 0x135b50
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xc9910
movl %eax, -0x1c(%rbp)
callq 0xdb640
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)