LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableEndCell(ImGuiTable*)
void ImGui::TableEndCell(ImGuiTable* table)
{
    ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
    ImGuiWindow* window = table->InnerWindow;

    // Report maximum position so we can infer content size per column.
    float* p_max_pos_x;
    if (table->RowFlags & ImGuiTableRowFlags_Headers)
        p_max_pos_x = &column->ContentMaxXHeadersUsed;  // Useful in case user submit contents in header row that is not a TableHeader() call
    else
        p_max_pos_x = table->IsUnfrozenRows ? &column->ContentMaxXUnfrozen : &column->ContentMaxXFrozen;
    *p_max_pos_x = ImMax(*p_max_pos_x, window->DC.CursorMaxPos.x);
    table->RowPosY2 = ImMax(table->RowPosY2, window->DC.CursorMaxPos.y + table->CellPaddingY);
    column->ItemWidth = window->DC.ItemWidth;

    // Propagate text baseline for the entire row
    // FIXME-TABLE: Here we propagate text baseline from the last line of the cell.. instead of the first one.
    table->RowTextBaseline = ImMax(table->RowTextBaseline, window->DC.PrevLineTextBaseOffset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
movl 0x74(%rbx), %esi
callq 0x4c4c6
movq 0x1d0(%rbx), %rcx
testb $0x1, 0x90(%rbx)
jne 0x74f40
movzbl 0x253(%rbx), %edx
leaq 0x40(,%rdx,4), %rdx
jmp 0x74f43
pushq $0x48
popq %rdx
movss (%rax,%rdx), %xmm0
movss 0xf0(%rcx), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, (%rax,%rdx)
movss 0x80(%rbx), %xmm0
movss 0xf4(%rcx), %xmm1
addss 0xc0(%rbx), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
movss %xmm2, 0x80(%rbx)
movss 0x1d0(%rcx), %xmm0
movss %xmm0, 0x3c(%rax)
movss 0x88(%rbx), %xmm0
movss 0x114(%rcx), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movups (%rsi), %xmm0
movups (%rsi), %xmm1
movups %xmm1, 0x258(%rdi)
movq 0x2b8(%rdi), %rax
movups %xmm0, 0x88(%rax)
movq 0x2b8(%rdi), %rax
movq 0x60(%rax), %rcx
movslq 0x58(%rax), %rax
shlq $0x4, %rax
movups %xmm0, -0x10(%rcx,%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6ecc5(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x7502f
movl 0x74(%rax), %eax
jmp 0x75031
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6ec9f(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x20a8(%rax), %r14
testq %r14, %r14
je 0x75089
movl %edi, %ebx
movl 0x74(%r14), %eax
cmpl %edi, %eax
je 0x7507c
cmpl $-0x1, %eax
je 0x75067
movq %r14, %rdi
callq 0x74f0a
testl %ebx, %ebx
js 0x75090
cmpl $0x0, 0x6c(%r14)
je 0x75090
movq %r14, %rdi
movl %ebx, %esi
callq 0x750af
movq 0x58(%r14), %rax
btq %rbx, %rax
setb %al
jmp 0x7508b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x41aa1(%rip), %rdi     # 0xb6b38
leaq 0x41068(%rip), %rsi     # 0xb6106
leaq 0x41ab8(%rip), %rcx     # 0xb6b5d
movl $0x701, %edx            # imm = 0x701
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6eac9(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x75278
cmpb $0x1, 0x249(%rbx)
jne 0x75250
movl 0x74(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl 0x6c(%rbx), %ecx
jge 0x75250
cmpl $-0x1, %eax
je 0x7527f
movq %rbx, %rdi
callq 0x74f0a
movl 0x74(%rbx), %r14d
incl %r14d
jmp 0x7525d
xorl %r14d, %r14d
xorps %xmm0, %xmm0
xorl %edi, %edi
callq 0x74d33
movq %rbx, %rdi
movl %r14d, %esi
callq 0x750af
movq 0x58(%rbx), %rax
movl 0x74(%rbx), %ecx
btq %rcx, %rax
setb %al
jmp 0x7527a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x7525d
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
cmpl 0x6c(%rbx), %r15d
jge 0x75435
movq %r14, %rdi
movl %r15d, %esi
callq 0x4c4c6
cmpb $0x0, 0x5a(%rax)
jne 0x7542a
testb $0x4, (%rax)
je 0x75430
movw $0x102, 0x62(%rax)      # imm = 0x102
incl %r15d
jmp 0x7540e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6e892(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rbx
movq 0x20a8(%rax), %r14
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x18c(%r14)
leaq 0x14c(%r14), %rsi
movq %rbx, %rdi
callq 0x74fd7
movq 0x2b8(%rbx), %rsi
movzbl 0x246(%r14), %edx
addq $0x1e8, %r14            # imm = 0x1E8
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x656c2
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6e830(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rbx
movq 0x20a8(%rax), %r14
leaq 0x10(%r14), %rdi
movl 0x74(%r14), %esi
callq 0x4c4c6
movq %rax, %r15
leaq 0x18c(%r14), %rsi
movq %rbx, %rdi
callq 0x74fd7
addq $0x1e8, %r14            # imm = 0x1E8
movq 0x2b8(%rbx), %rsi
movzbl 0x57(%r15), %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x656c2
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x6e7ce(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x7555e
testb $0x8, 0x4(%rbx)
jne 0x7552b
xorl %ebx, %ebx
jmp 0x75554
cmpb $0x0, 0x248(%rbx)
jne 0x7553c
movq %rbx, %rdi
callq 0x712c6
cmpb $0x1, 0x24b(%rbx)
jne 0x7554d
movq %rbx, %rdi
callq 0x729dc
addq $0x220, %rbx            # imm = 0x220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x41971(%rip), %rdi     # 0xb6ed6
leaq 0x40b9a(%rip), %rsi     # 0xb6106
leaq 0x41973(%rip), %rcx     # 0xb6ee6
movl $0x9c0, %edx            # imm = 0x9C0
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0xc, 0x64(%rdi)
je 0x7568c
movq %rdi, %rbx
cmpb $-0x1, 0x56(%rdi)
je 0x75659
xorl %r14d, %r14d
cmpl $0x3, %r14d
je 0x7566d
movzbl 0x64(%rbx), %r15d
andl $0x3, %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x755c4
cmpl %r15d, %eax
je 0x75642
incl %r14d
jmp 0x7561e
movb 0x64(%rbx), %cl
shrb $0x2, %cl
andb $0x3, %cl
incb %r14b
movzbl %r14b, %eax
divb %cl
movzbl %ah, %esi
jmp 0x7565b
xorl %esi, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x755c4
leaq 0x29aa8(%rip), %rdi     # 0x9f11c
leaq 0x40a8b(%rip), %rsi     # 0xb6106
leaq 0x418b9(%rip), %rcx     # 0xb6f3b
movl $0x9ea, %edx            # imm = 0x9EA
callq 0xc140
leaq 0x41883(%rip), %rdi     # 0xb6f16
leaq 0x40a6c(%rip), %rsi     # 0xb6106
leaq 0x4189a(%rip), %rcx     # 0xb6f3b
movl $0x9e4, %edx            # imm = 0x9E4
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x43e97
movaps %xmm0, -0x20(%rbp)
leaq 0x6e29b(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
xorl %ebx, %ebx
movl $0x0, %r14d
testq %rax, %rax
je 0x75a60
movl 0x6c(%rax), %r14d
testl %r14d, %r14d
cmovlel %ebx, %r14d
cmpl %ebx, %r14d
je 0x75ab8
movl %ebx, %edi
callq 0x74b09
btl $0x14, %eax
jae 0x75ab4
movl %ebx, %edi
callq 0x74a8a
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x26561(%rip), %xmm0    # 0x9bff0
callq 0x365e8
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, %xmm1
movaps -0x20(%rbp), %xmm3
cmpless %xmm3, %xmm1
movaps %xmm1, %xmm2
andnps %xmm0, %xmm2
andps %xmm3, %xmm1
orps %xmm2, %xmm1
movaps %xmm1, -0x20(%rbp)
incl %ebx
jmp 0x75a67
callq 0x35cfd
movss 0x5c(%rax), %xmm0
addss %xmm0, %xmm0
addss -0x20(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6d88a(%rip), %rcx     # 0xe3ce0
movl $0x3118, %eax           # imm = 0x3118
addq (%rcx), %rax
movl %edi, %ebx
movslq %esi, %r14
imulq $0xc, %r14, %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x78adc
movq %rax, %r15
movq %rax, %rdi
movl %ebx, %esi
movl %r14d, %edx
movl %r14d, %ecx
callq 0x76494
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, -0x2c(%rbp)
movl %esi, %r12d
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %r13
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
subl $0x1, %r15d
jb 0x764d4
movq %r13, %rdi
callq 0x78db6
addq $0xc, %r13
jmp 0x764c0
movl %r12d, (%r14)
movl -0x2c(%rbp), %eax
movb %al, 0xc(%r14)
movb %bl, 0xd(%r14)
movb $0x1, 0xe(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x6d7da(%rip), %rax     # 0xe3ce0
movq (%rax), %r14
movq 0x3120(%r14), %rcx
addq $0x3118, %r14           # imm = 0x3118
leaq 0x4(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
testq %rax, %rax
je 0x76538
cmpl %ebx, (%rax)
je 0x76538
movq %r14, %rdi
movq %rax, %rsi
callq 0x4bb2a
jmp 0x76522
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl 0x64(%rdi), %esi
cmpl $-0x1, %esi
je 0x76574
movq %rdi, %rbx
leaq 0x6d78b(%rip), %rax     # 0xe3ce0
movl $0x3118, %edi           # imm = 0x3118
addq (%rax), %rdi
callq 0x78b18
movl (%rax), %ecx
cmpl (%rbx), %ecx
jne 0x7657d
movsbl 0xd(%rax), %ecx
cmpl %ecx, 0x6c(%rbx)
jle 0x76576
andl $0x0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x40d56(%rip), %rdi     # 0xb72da
leaq 0x3fb7b(%rip), %rsi     # 0xb6106
leaq 0x40d62(%rip), %rcx     # 0xb72f4
movl $0xbf8, %edx            # imm = 0xBF8
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x58(%rbp), %r14
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
leaq 0x346e4(%rip), %rdi     # 0xaacb0
movq %rdi, (%r14)
xorl %esi, %esi
xorl %edx, %edx
callq 0x3479a
movl %eax, 0x8(%r14)
leaq 0x4b(%rip), %rax        # 0x7662e
movq %rax, 0x10(%r14)
leaq 0x89(%rip), %rax        # 0x76677
movq %rax, 0x20(%r14)
leaq 0xed(%rip), %rax        # 0x766e6
movq %rax, 0x28(%r14)
leaq 0x343(%rip), %rax       # 0x76947
movq %rax, 0x30(%r14)
leaq 0x371(%rip), %rax       # 0x76980
movq %rax, 0x38(%r14)
addq $0x30f8, %rbx           # imm = 0x30F8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4af14
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20b0(%rdi), %r14
xorl %r15d, %r15d
cmpl (%r14), %r15d
je 0x7665e
movq %r14, %rdi
movl %r15d, %esi
callq 0x4c6b6
orl $-0x1, 0x64(%rax)
incl %r15d
jmp 0x76645
addq $0x3118, %rbx           # imm = 0x3118
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4b1ac
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdx, %rdi
leaq -0xc(%rbp), %rdx
andl $0x0, (%rdx)
leaq -0x10(%rbp), %rcx
andl $0x0, (%rcx)
leaq 0x4145a(%rip), %rsi     # 0xb7aef
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xc0c0
cmpl $0x2, %eax
jl 0x766dc
movl -0xc(%rbp), %edi
callq 0x764f6
testq %rax, %rax
je 0x766c1
movq %rax, %rbx
movsbl 0xd(%rax), %ecx
movl -0x10(%rbp), %edx
cmpl %ecx, %edx
jle 0x766d1
andl $0x0, (%rbx)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x76445
movq %rax, %rbx
jmp 0x766dc
movl -0xc(%rbp), %esi
movq %rbx, %rdi
callq 0x76494
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x20b0, %rbx           # imm = 0x20B0
xorl %r14d, %r14d
cmpl (%rbx), %r14d
je 0x7697b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4c6b6
movb $0x1, 0x24e(%rax)
orl $-0x1, 0x64(%rax)
incl %r14d
jmp 0x7695b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x6d13e(%rip), %rax     # 0xe3ce0
movq (%rax), %r14
leaq 0x20b0(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7871a
movl %eax, %r12d
movl (%rbx), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x78b9a
addq $0x20e8, %r14           # imm = 0x20E8
movq %r14, %rdi
movl %r12d, %esi
callq 0x4ad98
movl $0xbf800000, (%rax)     # imm = 0xBF800000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, 0x255(%rdi)
jne 0x76c9e
movq %rdi, %rbx
leaq 0x6d0d6(%rip), %rax     # 0xe3ce0
movq (%rax), %r14
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x61e2c
leaq 0x210(%rbx), %rdi
callq 0x78bbe
andq $0x0, 0x220(%rbx)
movb $0x1, %r15b
movb %r15b, 0x24b(%rbx)
leaq 0x1d8(%rbx), %rdi
callq 0x4b1ac
movb %r15b, 0x255(%rbx)
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
cmpl 0x6c(%rbx), %r12d
jge 0x76c6c
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c4c6
orw $-0x1, 0x50(%rax)
incl %r12d
jmp 0x76c51
leaq 0x20e8(%r14), %r15
addq $0x20b0, %r14           # imm = 0x20B0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7871a
movq %r15, %rdi
movl %eax, %esi
callq 0x4ad98
movl $0xbf800000, (%rax)     # imm = 0xBF800000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4071f(%rip), %rdi     # 0xb73c4
leaq 0x3f45a(%rip), %rsi     # 0xb6106
leaq 0x40731(%rip), %rcx     # 0xb73e4
movl $0xd0f, %edx            # imm = 0xD0F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x6d00d(%rip), %rax     # 0xe3ce0
movq (%rax), %r12
leaq 0x3118(%r12), %rbx
movq 0x3120(%r12), %rax
leaq 0x4(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0x76d19
cmpl $0x0, (%rax)
je 0x76d0c
movsbl 0xc(%rax), %ecx
imull $0xc, %ecx, %ecx
addl %ecx, %r14d
addl $0x10, %r14d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4bb2a
jmp 0x76cf4
cmpl (%rbx), %r14d
je 0x76dde
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movl %r14d, %esi
callq 0x49c66
movq 0x3120(%r12), %rax
leaq 0x4(%rax), %r14
testq %rax, %rax
cmoveq %rax, %r14
leaq -0x30(%rbp), %r15
testq %r14, %r14
je 0x76d93
cmpl $0x0, (%r14)
je 0x76d83
movsbq 0xc(%r14), %rax
imulq $0xc, %rax, %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x78adc
movsbq 0xc(%r14), %rcx
imulq $0xc, %rcx, %rdx
addq $0x10, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xc080
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4bb2a
movq %rax, %r14
jmp 0x76d4b
movl 0x3118(%r12), %eax
leaq -0x30(%rbp), %rdi
movl (%rdi), %ecx
movl %ecx, 0x3118(%r12)
movl %eax, (%rdi)
movl 0x311c(%r12), %eax
movl 0x4(%rdi), %ecx
movl %ecx, 0x311c(%r12)
movl %eax, 0x4(%rdi)
movq 0x3120(%r12), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x3120(%r12)
movq %rax, 0x8(%rdi)
callq 0x4be3a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x76ded
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4be3a
movq %rbx, %rdi
callq 0xc580
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::DebugNodeTableSettings(ImGuiTableSettings*)
void ImGui::DebugNodeTableSettings(ImGuiTableSettings* settings)
{
    if (!TreeNode((void*)(intptr_t)settings->ID, "Settings 0x%08X (%d columns)", settings->ID, settings->ColumnsCount))
        return;
    BulletText("SaveFlags: 0x%08X", settings->SaveFlags);
    BulletText("ColumnsCount: %d (max %d)", settings->ColumnsCount, settings->ColumnsCountMax);
    for (int n = 0; n < settings->ColumnsCount; n++)
    {
        ImGuiTableColumnSettings* column_settings = &settings->GetColumnSettings()[n];
        ImGuiSortDirection sort_dir = (column_settings->SortOrder != -1) ? (ImGuiSortDirection)column_settings->SortDirection : ImGuiSortDirection_None;
        BulletText("Column %d Order %d SortOrder %d %s Vis %d %s %7.3f UserID 0x%08X",
            n, column_settings->DisplayOrder, column_settings->SortOrder,
            (sort_dir == ImGuiSortDirection_Ascending) ? "Asc" : (sort_dir == ImGuiSortDirection_Descending) ? "Des" : "---",
            column_settings->IsEnabled, column_settings->IsStretch ? "Weight" : "Width ", column_settings->WidthOrWeight, column_settings->UserID);
    }
    TreePop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
movsbl 0xc(%rbx), %ecx
leaq 0x402f0(%rip), %rsi     # 0xb7739
movl %edi, %edx
xorl %eax, %eax
callq 0x88935
testb %al, %al
je 0x77545
movl 0x4(%rbx), %esi
leaq 0x402f2(%rip), %rdi     # 0xb7756
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x79bb3
movsbl 0xc(%rbx), %esi
movsbl 0xd(%rbx), %edx
leaq 0x402eb(%rip), %rdi     # 0xb7768
xorl %eax, %eax
callq 0x79bb3
leaq 0x1b(%rbx), %r12
leaq 0x4121e(%rip), %r13     # 0xb86ad
leaq 0x402ec(%rip), %r15     # 0xb7782
movsbq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x77532
movsbl -0x1(%r12), %edx
movb (%r12), %al
pushq $-0x1
popq %rcx
movq %r13, %r8
cmpl $-0x1, %edx
je 0x774df
movl %eax, %ecx
andb $0x3, %cl
cmpb $0x2, %cl
movq %r13, %r8
leaq 0x402fc(%rip), %rsi     # 0xb77c7
cmoveq %rsi, %r8
cmpb $0x1, %cl
leaq 0x402ea(%rip), %rcx     # 0xb77c3
cmoveq %rcx, %r8
movl %edx, %ecx
movsbl -0x2(%r12), %edx
movl %eax, %esi
shrb $0x2, %sil
andb $0x1, %sil
testb $0x8, %al
leaq 0x402d3(%rip), %r10     # 0xb77cb
leaq 0x402d3(%rip), %rax     # 0xb77d2
cmoveq %rax, %r10
movzbl %sil, %r9d
cvtss2sd -0xb(%r12), %xmm0
movl -0x7(%r12), %r11d
movq %r15, %rdi
movl %r14d, %esi
movb $0x1, %al
pushq %r11
pushq %r10
callq 0x79bb3
popq %rax
popq %rcx
incq %r14
addq $0xc, %r12
jmp 0x77496
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x89637
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x6c700(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %rbx
testq %rbx, %rbx
je 0x77625
movl %edi, %esi
testl %edi, %edi
jns 0x775ff
movl 0xc(%rbx), %esi
cmpl 0x60(%rbx), %esi
jge 0x7762f
leaq 0x60(%rbx), %rdi
callq 0x4bb92
movss 0x14(%rbx), %xmm1
movss 0x18(%rbx), %xmm0
subss %xmm1, %xmm0
mulss (%rax), %xmm0
addss %xmm1, %xmm0
jmp 0x77628
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x401a3(%rip), %rdi     # 0xb77d9
leaq 0x3eac9(%rip), %rsi     # 0xb6106
leaq 0x401ba(%rip), %rcx     # 0xb77fe
movl $0xdee, %edx            # imm = 0xDEE
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6c681(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %r15
testq %r15, %r15
je 0x776bc
movl %edi, %ebx
testl %edi, %edi
jns 0x7767f
movl 0xc(%r15), %ebx
leaq 0x60(%r15), %r14
leal 0x1(%rbx), %esi
movq %r14, %rdi
callq 0x4bb92
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq %r14, %rdi
movl %ebx, %esi
callq 0x4bb92
movss -0x1c(%rbp), %xmm1
subss (%rax), %xmm1
movss 0x18(%r15), %xmm0
subss 0x14(%r15), %xmm0
mulss %xmm1, %xmm0
jmp 0x776c1
callq 0x409d2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x6c43e(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %rax
testq %rax, %rax
je 0x778de
movss %xmm0, -0xc(%rbp)
testl %edi, %edi
jns 0x778c4
movl 0xc(%rax), %edi
leal 0x1(%rdi), %ebx
callq 0x775d3
addss -0xc(%rbp), %xmm0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x776cc
leaq 0x3ff3b(%rip), %rdi     # 0xb7820
leaq 0x3e81a(%rip), %rsi     # 0xb6106
leaq 0x3ff67(%rip), %rcx     # 0xb785a
movl $0xe29, %edx            # imm = 0xE29
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edi, %esi
leaq 0x6c3da(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %rdi
testl %esi, %esi
jns 0x7791e
movl 0xc(%rdi), %esi
pushq %rbp
movq %rsp, %rbp
addq $0x60, %rdi
callq 0x4bb92
leaq 0xc(%rax), %rdi
leaq 0x14(%rax), %rsi
xorl %edx, %edx
popq %rbp
jmp 0x3f0d3
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6c397(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rbx
movq 0x1b0(%rbx), %r14
cmpl $0x1, 0x10(%r14)
jne 0x77966
popq %rbx
popq %r14
popq %rbp
retq
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x3c(%r14)
leaq 0x2c(%r14), %rsi
movq %rbx, %rdi
callq 0x74fd7
addq $0x70, %r14
movq 0x2b8(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x656c2
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6c33b(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %r14
movq 0x1b0(%r14), %rbx
cmpl $0x1, 0x10(%rbx)
jne 0x779c1
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3c(%rbx), %rsi
movq %r14, %rdi
callq 0x74fd7
movq 0x2b8(%r14), %rsi
movl 0xc(%rbx), %edx
addq $0x70, %rbx
incl %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x656c2
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x2a0, %r14            # imm = 0x2A0
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x77a21
movq %r14, %rdi
movl %r15d, %esi
callq 0x4a0ea
cmpl %ebx, (%rax)
je 0x77a66
incl %r15d
jmp 0x77a08
leaq -0xa0(%rbp), %r15
movl $0x88, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0xc270
movq %r14, %rdi
movq %r15, %rsi
callq 0x78be6
leaq -0xa0(%rbp), %rdi
callq 0x4a124
movq %r14, %rdi
callq 0x78c42
movl %ebx, (%rax)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %r15d, %esi
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4a0ea
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4a124
movq %rbx, %rdi
callq 0xc580
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6c23d(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rbx
movb $0x1, 0x90(%rbx)
movl $0x11223347, %ecx       # imm = 0x11223347
leal (%rsi,%rcx), %eax
testq %rdi, %rdi
cmovnel %ecx, %eax
leaq 0x33e1d(%rip), %r14     # 0xab8e6
cmovneq %rdi, %r14
movl %eax, %edi
callq 0x42f5a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3700a
movl %eax, %ebx
callq 0x42fea
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x6b777(%rip), %rax     # 0xe3ce0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movb $0x1, 0x90(%rax)
testl %edi, %edi
jle 0x785cd
movq %rsi, %r14
movl %edi, %ebx
xorb $0x1, %dl
movzbl %dl, %r15d
movq 0x1b0(%rax), %rax
testq %rax, %rax
je 0x785a6
cmpl %ebx, 0x10(%rax)
jne 0x785a1
cmpl %r15d, 0x4(%rax)
je 0x785ab
callq 0x780e5
cmpl $0x1, %ebx
jne 0x785b6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x77aef
leaq 0x3f2ad(%rip), %rdi     # 0xb7881
leaq 0x3db2b(%rip), %rsi     # 0xb6106
leaq 0x3f371(%rip), %rcx     # 0xb7953
movl $0xf42, %edx            # imm = 0xF42
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: TableFixFlags(int, ImGuiWindow*)
inline ImGuiTableFlags TableFixFlags(ImGuiTableFlags flags, ImGuiWindow* outer_window)
{
    // Adjust flags: set default sizing policy
    if ((flags & ImGuiTableFlags_SizingMask_) == 0)
        flags |= ((flags & ImGuiTableFlags_ScrollX) || (outer_window->Flags & ImGuiWindowFlags_AlwaysAutoResize)) ? ImGuiTableFlags_SizingFixedFit : ImGuiTableFlags_SizingStretchSame;

    // Adjust flags: enable NoKeepColumnsVisible when using ImGuiTableFlags_SizingFixedSame
    if ((flags & ImGuiTableFlags_SizingMask_) == ImGuiTableFlags_SizingFixedSame)
        flags |= ImGuiTableFlags_NoKeepColumnsVisible;

    // Adjust flags: enforce borders when resizable
    if (flags & ImGuiTableFlags_Resizable)
        flags |= ImGuiTableFlags_BordersInnerV;

    // Adjust flags: disable NoHostExtendX/NoHostExtendY if we have any scrolling going on
    if (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY))
        flags &= ~(ImGuiTableFlags_NoHostExtendX | ImGuiTableFlags_NoHostExtendY);

    // Adjust flags: NoBordersInBodyUntilResize takes priority over NoBordersInBody
    if (flags & ImGuiTableFlags_NoBordersInBodyUntilResize)
        flags &= ~ImGuiTableFlags_NoBordersInBody;

    // Adjust flags: disable saved settings if there's nothing to save
    if ((flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Hideable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Sortable)) == 0)
        flags |= ImGuiTableFlags_NoSavedSettings;

    // Inherit _NoSavedSettings from top-level window (child windows always have _NoSavedSettings set)
#ifdef IMGUI_HAS_DOCK
    ImGuiWindow* window_for_settings = outer_window->RootWindowDockStop;
#else
    ImGuiWindow* window_for_settings = outer_window->RootWindow;
#endif
    if (window_for_settings->Flags & ImGuiWindowFlags_NoSavedSettings)
        flags |= ImGuiTableFlags_NoSavedSettings;

    return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
andl $0xe000, %eax           # imm = 0xE000
jne 0x786c7
movl $0x2000, %eax           # imm = 0x2000
btl $0x18, %edi
jb 0x786c5
testb $0x40, 0xc(%rsi)
movl $0x8000, %ecx           # imm = 0x8000
cmovel %ecx, %eax
orl %eax, %edi
movl %edi, %ecx
orl $0x40000, %ecx          # imm = 0x40000
cmpl $0x4000, %eax           # imm = 0x4000
cmovnel %edi, %ecx
movl %ecx, %eax
andl $0x1, %eax
shll $0x9, %eax
orl %ecx, %eax
movl %eax, %edx
andl $0xfffcffff, %edx       # imm = 0xFFFCFFFF
testl $0x3000000, %ecx        # imm = 0x3000000
cmovel %eax, %edx
movl %edx, %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
btl $0xc, %edx
cmovael %edx, %eax
movl %eax, %ecx
orl $0x10, %ecx
testb $0xf, %al
cmovel %ecx, %eax
movq 0x390(%rsi), %rdx
testb $0x1, 0xd(%rdx)
cmovnel %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
orw $-0x1, 0x8(%rdi)
movb $-0x1, 0xa(%rdi)
movb 0xb(%rdi), %al
andb $-0x10, %al
orb $0x4, %al
movb %al, 0xb(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leal -0x1(%rdx), %eax
movl %eax, %r8d
andl $0x1f, %r8d
incl %r8d
movl $0x20, %r9d
movabsq $-0x1, %r10
cmpl %edx, %esi
jge 0x79011
movl %esi, %ecx
orl $0x1f, %ecx
cmpl %ecx, %eax
movl %r8d, %ecx
cmovgl %r9d, %ecx
movq %r10, %r11
shlq %cl, %r11
notl %r11d
movl %esi, %ecx
shrl %cl, %r11d
shll %cl, %r11d
movl %esi, %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
orl %r11d, (%rdi,%rcx,4)
andl $-0x20, %esi
addl $0x20, %esi
jmp 0x78fda
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x6a6ab(%rip), %rax     # 0xe3ce0
movq (%rax), %r14
movq 0x1ae0(%r14), %rax
movb $0x1, 0x90(%rax)
cmpb $0x0, 0x93(%rax)
je 0x79654
popq %rbx
popq %r14
popq %rbp
retq
movq %rsi, %rcx
movq %rdi, %rdx
leaq 0x3378(%r14), %rbx
movl $0xc01, %esi            # imm = 0xC01
movq %rbx, %rdi
callq 0x34731
cltq
leaq (%r14,%rax), %rsi
addq $0x3378, %rsi           # imm = 0x3378
pushq $0x1
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7911c
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
xorl %edi, %edi
callq 0x35e60
cmpb $0x25, (%r14)
jne 0x7972c
cmpb $0x73, 0x1(%r14)
jne 0x7972c
cmpb $0x0, 0x2(%r14)
je 0x79743
movq %r14, %rdi
movq %rbx, %rsi
callq 0x79627
pushq $0x1
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x35eb4
movl (%rbx), %ecx
cmpq $0x28, %rcx
ja 0x79759
movq %rcx, %rax
addq 0x10(%rbx), %rax
addl $0x8, %ecx
movl %ecx, (%rbx)
jmp 0x79765
movq 0x8(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x7911c
jmp 0x79737