LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnFlags(int)
ImGuiTableColumnFlags ImGui::TableGetColumnFlags(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return ImGuiTableColumnFlags_None;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    if (column_n == table->ColumnsCount)
        return (table->HoveredColumnBody == column_n) ? ImGuiTableColumnFlags_IsHovered : ImGuiTableColumnFlags_None;
    return table->Columns[column_n].Flags;
}

// Assembly:
leaq 0x706ff(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8b5fe
testl %edi, %edi
jns 0x8b5e7
movl 0x74(%rax), %edi
cmpl 0x6c(%rax), %edi
jne 0x8b601
movsbl 0x234(%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %edi
sete %al
shll $0x17, %eax
retq
xorl %eax, %eax
retq
testl %edi, %edi
js 0x8b619
movslq %edi, %rcx
imulq $0x68, %rcx, %rcx
addq 0x10(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x8b619
movl (%rcx), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2f094(%rip), %rdi     # 0xba6b8
leaq 0x2e014(%rip), %rsi     # 0xb963f
leaq 0x2f09f(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetHoveredColumn()
int ImGui::TableGetHoveredColumn()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return -1;
    return (int)table->HoveredColumnBody;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x70617(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8b6d1
movsbl 0x234(%rax), %eax
jmp 0x8b6d6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetRowIndex()
int ImGui::TableGetRowIndex()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return 0;
    return table->CurrentRow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x70498(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8b84c
movl 0x70(%rax), %eax
jmp 0x8b84e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableNextRow(int, float)
void ImGui::TableNextRow(ImGuiTableRowFlags row_flags, float row_min_height)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;

    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);
    if (table->IsInsideRow)
        TableEndRow(table);

    table->LastRowFlags = table->RowFlags;
    table->RowFlags = row_flags;
    table->RowMinHeight = row_min_height;
    TableBeginRow(table);

    // We honor min_row_height requested by user, but cannot guarantee per-row maximum height,
    // because that would essentially require a unique clipping rectangle per-cell.
    table->RowPosY2 += table->CellPaddingY * 2.0f;
    table->RowPosY2 = ImMax(table->RowPosY2, table->RowPosY1 + row_min_height);

    // Disable output until user calls TableNextColumn()
    table->InnerWindow->SkipItems = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, -0x20(%rbp)
movl %edi, %r14d
leaq 0x70467(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
cmpb $0x0, 0x248(%rbx)
jne 0x8b884
movq %rbx, %rdi
callq 0x87673
cmpb $0x1, 0x249(%rbx)
jne 0x8b895
movq %rbx, %rdi
callq 0x89b8c
movl 0x90(%rbx), %eax
shll $0x10, %eax
movzwl %r14w, %ecx
orl %eax, %ecx
movl %ecx, 0x90(%rbx)
movaps -0x20(%rbp), %xmm0
movss %xmm0, 0x84(%rbx)
movq %rbx, %rdi
callq 0x8b90b
movss 0xc0(%rbx), %xmm0
addss %xmm0, %xmm0
addss 0x80(%rbx), %xmm0
movaps -0x20(%rbp), %xmm2
addss 0x7c(%rbx), %xmm2
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0x80(%rbx)
movq 0x1d0(%rbx), %rax
movb $0x1, 0x93(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableBeginRow(ImGuiTable*)
void ImGui::TableBeginRow(ImGuiTable* table)
{
    ImGuiWindow* window = table->InnerWindow;
    IM_ASSERT(!table->IsInsideRow);

    // New row
    table->CurrentRow++;
    table->CurrentColumn = -1;
    table->RowBgColor[0] = table->RowBgColor[1] = IM_COL32_DISABLE;
    table->RowCellDataCurrent = -1;
    table->IsInsideRow = true;

    // Begin frozen rows
    float next_y1 = table->RowPosY2;
    if (table->CurrentRow == 0 && table->FreezeRowsCount > 0)
        next_y1 = window->DC.CursorPos.y = table->OuterRect.Min.y;

    table->RowPosY1 = table->RowPosY2 = next_y1;
    table->RowTextBaseline = 0.0f;
    table->RowIndentOffsetX = window->DC.Indent.x - table->HostIndentX; // Lock indent
    window->DC.PrevLineTextBaseOffset = 0.0f;
    window->DC.CursorMaxPos.y = next_y1;

    // Making the header BG color non-transparent will allow us to overlay it multiple times when handling smooth dragging.
    if (table->RowFlags & ImGuiTableRowFlags_Headers)
    {
        TableSetBgColor(ImGuiTableBgTarget_RowBg0, GetColorU32(ImGuiCol_TableHeaderBg));
        if (table->CurrentRow == 0)
            table->IsUsingHeaders = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x249(%rdi)
je 0x8ba0d
movq %rdi, %rbx
movq 0x1d0(%rdi), %rax
incl 0x70(%rdi)
movl $0xffffffff, 0x74(%rdi) # imm = 0xFFFFFFFF
movabsq $0x100000001000000, %rcx # imm = 0x100000001000000
movq %rcx, 0x98(%rdi)
movb $-0x1, 0x244(%rdi)
movb $0x1, 0x249(%rdi)
movss 0x80(%rdi), %xmm0
jne 0x8b974
cmpb $0x0, 0x241(%rbx)
jle 0x8b974
movss 0xf0(%rbx), %xmm0
movss %xmm0, 0xdc(%rax)
movss %xmm0, 0x80(%rbx)
movss %xmm0, 0x7c(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x88(%rbx)
movss 0x118(%rax), %xmm1
subss 0xb0(%rbx), %xmm1
movss %xmm1, 0x8c(%rbx)
movl %ecx, 0x114(%rax)
movss %xmm0, 0xf4(%rax)
testb $0x1, 0x90(%rbx)
je 0x8ba06
movss 0x29624(%rip), %xmm0    # 0xb4fe4
movl $0x2a, %edi
callq 0x43bca
leaq 0x702ff(%rip), %rcx     # 0xfbcd0
movq (%rcx), %rcx
movq 0x20a8(%rcx), %rcx
movss 0x7c(%rcx), %xmm0
ucomiss 0x128(%rcx), %xmm0
ja 0x8b9f9
xorl %edx, %edx
cmpl $0x1000000, %eax        # imm = 0x1000000
cmovnel %eax, %edx
movl %edx, 0x98(%rcx)
cmpl $0x0, 0x70(%rbx)
jne 0x8ba06
movb $0x1, 0x24c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x43dc1(%rip), %rdi     # 0xcf7d5
leaq 0x4346f(%rip), %rsi     # 0xcee8a
leaq 0x43dc7(%rip), %rcx     # 0xcf7e9
movl $0x642, %edx            # imm = 0x642
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x74(%rdi), %rax
testq %rax, %rax
js 0x8bafd
imulq $0x68, %rax, %rax
addq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x8bafd
movq 0x1d0(%rdi), %rcx
movl $0x48, %edx
testb $0x1, 0x90(%rdi)
jne 0x8ba6f
movzbl 0x253(%rdi), %edx
leaq 0x40(,%rdx,4), %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(%rdi), %xmm0
movss 0xf4(%rcx), %xmm1
addss 0xc0(%rdi), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
movss %xmm2, 0x80(%rdi)
movss 0x1d0(%rcx), %xmm0
movss %xmm0, 0x3c(%rax)
movss 0x88(%rdi), %xmm0
movss 0x114(%rcx), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0x88(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2ebb0(%rip), %rdi     # 0xba6b8
leaq 0x2db30(%rip), %rsi     # 0xb963f
leaq 0x2ebbb(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7016c(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8bb78
movl 0x74(%rax), %eax
jmp 0x8bb7a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70146(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %r14
testq %r14, %r14
je 0x8bbd2
movl %edi, %ebx
movl 0x74(%r14), %eax
cmpl %edi, %eax
je 0x8bbc5
cmpl $-0x1, %eax
je 0x8bbb0
movq %r14, %rdi
callq 0x8ba2c
testl %ebx, %ebx
js 0x8bbd9
cmpl $0x0, 0x6c(%r14)
je 0x8bbd9
movq %r14, %rdi
movl %ebx, %esi
callq 0x8bbf8
movq 0x58(%r14), %rax
btq %rbx, %rax
setb %al
jmp 0x8bbd4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x43cdc(%rip), %rdi     # 0xcf8bc
leaq 0x432a3(%rip), %rsi     # 0xcee8a
leaq 0x43cf3(%rip), %rcx     # 0xcf8e1
movl $0x701, %edx            # imm = 0x701
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ff3e(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x8bdf3
cmpb $0x1, 0x249(%rbx)
jne 0x8bdcb
movl 0x74(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl 0x6c(%rbx), %ecx
jge 0x8bdcb
cmpl $-0x1, %eax
je 0x8bdfa
movq %rbx, %rdi
callq 0x8ba2c
movl 0x74(%rbx), %r14d
incl %r14d
jmp 0x8bdd8
xorl %r14d, %r14d
xorps %xmm0, %xmm0
xorl %edi, %edi
callq 0x8b850
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8bbf8
movq 0x58(%rbx), %rax
movl 0x74(%rbx), %ecx
btq %rcx, %rax
setb %al
jmp 0x8bdf5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x8bdd8
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableUpdateColumnsWeightFromWidth(ImGuiTable*)
void ImGui::TableUpdateColumnsWeightFromWidth(ImGuiTable* table)
{
    IM_ASSERT(table->LeftMostStretchedColumn != -1 && table->RightMostStretchedColumn != -1);

    // Measure existing quantity
    float visible_weight = 0.0f;
    float visible_width = 0.0f;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch))
            continue;
        IM_ASSERT(column->StretchWeight > 0.0f);
        visible_weight += column->StretchWeight;
        visible_width += column->WidthRequest;
    }
    IM_ASSERT(visible_weight > 0.0f && visible_width > 0.0f);

    // Apply new weights
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
    {
        ImGuiTableColumn* column = &table->Columns[column_n];
        if (!column->IsEnabled || !(column->Flags & ImGuiTableColumnFlags_WidthStretch))
            continue;
        column->StretchWeight = (column->WidthRequest / visible_width) * visible_weight;
        IM_ASSERT(column->StretchWeight > 0.0f);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $-0x1, 0x23c(%rdi)
je 0x8bf1b
cmpb $-0x1, 0x23d(%rdi)
je 0x8bf1b
movslq 0x6c(%rdi), %rax
testq %rax, %rax
jle 0x8bf3a
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorps %xmm2, %xmm2
movq %rax, %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
cmpq %rdx, %rcx
jae 0x8bebe
cmpb $0x1, 0x5a(%rcx)
jne 0x8be65
testb $0x4, (%rcx)
je 0x8be65
movss 0x18(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x8bedd
addss %xmm3, %xmm0
addss 0x10(%rcx), %xmm1
addq $0x68, %rcx
decq %rsi
jne 0x8be3e
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x8bf3a
ucomiss %xmm2, %xmm1
jbe 0x8bf3a
testl %eax, %eax
jle 0x8bebc
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x8bebe
cmpb $0x1, 0x5a(%rcx)
jne 0x8beb3
testb $0x4, (%rcx)
je 0x8beb3
movss 0x10(%rcx), %xmm3
divss %xmm1, %xmm3
mulss %xmm0, %xmm3
movss %xmm3, 0x18(%rcx)
ucomiss %xmm2, %xmm3
jbe 0x8befc
addq $0x68, %rcx
decq %rax
jne 0x8be8b
popq %rbp
retq
leaq 0x2e7f3(%rip), %rdi     # 0xba6b8
leaq 0x2d773(%rip), %rsi     # 0xb963f
leaq 0x2e7fe(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
leaq 0x43b56(%rip), %rdi     # 0xcfa3a
leaq 0x42f9f(%rip), %rsi     # 0xcee8a
leaq 0x43b0c(%rip), %rcx     # 0xcf9fe
movl $0x81e, %edx            # imm = 0x81E
callq 0xc140
leaq 0x43b37(%rip), %rdi     # 0xcfa3a
leaq 0x42f80(%rip), %rsi     # 0xcee8a
leaq 0x43aed(%rip), %rcx     # 0xcf9fe
movl $0x82b, %edx            # imm = 0x82B
callq 0xc140
leaq 0x43a8e(%rip), %rdi     # 0xcf9b0
leaq 0x42f61(%rip), %rsi     # 0xcee8a
leaq 0x43ace(%rip), %rcx     # 0xcf9fe
movl $0x814, %edx            # imm = 0x814
callq 0xc140
leaq 0x43b16(%rip), %rdi     # 0xcfa57
leaq 0x42f42(%rip), %rsi     # 0xcee8a
leaq 0x43aaf(%rip), %rcx     # 0xcf9fe
movl $0x822, %edx            # imm = 0x822
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq 0x6c(%rdi), %rax
testq %rax, %rax
jle 0x8bf8a
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x8bf8c
cmpb $0x0, 0x5a(%rcx)
jne 0x8bf7b
testb $0x4, (%rcx)
je 0x8bf81
movw $0x102, 0x62(%rcx)      # imm = 0x102
addq $0x68, %rcx
decq %rax
jne 0x8bf6a
popq %rbp
retq
leaq 0x2e725(%rip), %rdi     # 0xba6b8
leaq 0x2d6a5(%rip), %rsi     # 0xb963f
leaq 0x2e730(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x6fd1a(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rcx
movq 0x20a8(%rax), %rdi
movups 0x258(%rcx), %xmm0
movups %xmm0, 0x18c(%rdi)
movups 0x14c(%rdi), %xmm0
movups 0x14c(%rdi), %xmm1
movups %xmm1, 0x258(%rcx)
movq 0x2b8(%rcx), %rax
movups %xmm0, 0x88(%rax)
movq 0x2b8(%rcx), %rax
movq 0x60(%rax), %rdx
movslq 0x58(%rax), %rax
shlq $0x4, %rax
movups %xmm0, -0x10(%rdx,%rax)
movq 0x2b8(%rcx), %rsi
movzbl 0x246(%rdi), %edx
addq $0x1e8, %rdi            # imm = 0x1E8
popq %rbp
jmp 0x7a998
// File: /workspace/github_cpp_makefile_star2_O3/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:
leaq 0x6fc9e(%rip), %rax     # 0xfbcd0
movq (%rax), %rcx
movq 0x20a8(%rcx), %rdi
movslq 0x74(%rdi), %rax
testq %rax, %rax
js 0x8c0ac
imulq $0x68, %rax, %rax
addq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x8c0ac
movq 0x1ae0(%rcx), %rcx
movups 0x18c(%rdi), %xmm0
movups 0x18c(%rdi), %xmm1
movups %xmm1, 0x258(%rcx)
movq 0x2b8(%rcx), %rdx
movups %xmm0, 0x88(%rdx)
movq 0x2b8(%rcx), %rdx
movq 0x60(%rdx), %rsi
movslq 0x58(%rdx), %rdx
shlq $0x4, %rdx
movups %xmm0, -0x10(%rsi,%rdx)
addq $0x1e8, %rdi            # imm = 0x1E8
movq 0x2b8(%rcx), %rsi
movzbl 0x57(%rax), %edx
jmp 0x7a998
pushq %rbp
movq %rsp, %rbp
leaq 0x2e601(%rip), %rdi     # 0xba6b8
leaq 0x2d581(%rip), %rsi     # 0xb963f
leaq 0x2e60c(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6fbf4(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x8c128
testb $0x8, 0x4(%rbx)
jne 0x8c0f5
xorl %ebx, %ebx
jmp 0x8c11e
cmpb $0x0, 0x248(%rbx)
jne 0x8c106
movq %rbx, %rdi
callq 0x87673
cmpb $0x1, 0x24b(%rbx)
jne 0x8c117
movq %rbx, %rdi
callq 0x88f79
addq $0x220, %rbx            # imm = 0x220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x43b2b(%rip), %rdi     # 0xcfc5a
leaq 0x42d54(%rip), %rsi     # 0xcee8a
leaq 0x43b2d(%rip), %rcx     # 0xcfc6a
movl $0x9c0, %edx            # imm = 0x9C0
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $-0x1, 0x56(%rsi)
je 0x8c160
movzbl 0x64(%rsi), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl %eax, %edx
andl $0x3, %edx
btl %edx, %ecx
jae 0x8c161
retq
testb $0xc, %al
je 0x8c17a
movb 0x65(%rsi), %cl
andb $0x3, %cl
andb $-0x4, %al
orb %cl, %al
movb %al, 0x64(%rsi)
movb $0x1, 0x24b(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x4467c(%rip), %rdi     # 0xd0801
leaq 0x42cfe(%rip), %rsi     # 0xcee8a
leaq 0x44693(%rip), %rcx     # 0xd0826
movl $0x9d1, %edx            # imm = 0x9D1
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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
movzbl 0x64(%rdi), %eax
testb $0xc, %al
je 0x8c245
cmpb $-0x1, 0x56(%rdi)
je 0x8c21b
movl %eax, %esi
shrl $0x2, %esi
andl $0x3, %esi
andl $0x3, %eax
movl %esi, %r8d
addl %esi, %r8d
movb $0x1, %r9b
xorl %ecx, %ecx
cmpl %ecx, %r8d
je 0x8c226
movzbl 0x65(%rdi), %edx
movl %edx, %r10d
shrl %cl, %r10d
andl $0x3, %r10d
cmpl %eax, %r10d
je 0x8c20b
incb %r9b
addl $0x2, %ecx
cmpl $0x6, %ecx
jne 0x8c1c9
leaq 0x2bef9(%rip), %rdi     # 0xb80ec
leaq 0x42c90(%rip), %rsi     # 0xcee8a
leaq 0x43abe(%rip), %rcx     # 0xcfcbf
movl $0x9ea, %edx            # imm = 0x9EA
callq 0xc140
movzbl %r9b, %eax
divb %sil
movzbl %ah, %ecx
addb %cl, %cl
shrl %cl, %edx
jmp 0x8c21f
movzbl 0x65(%rdi), %edx
andl $0x3, %edx
movl %edx, %eax
popq %rbp
retq
leaq 0x445d4(%rip), %rdi     # 0xd0801
leaq 0x42c56(%rip), %rsi     # 0xcee8a
leaq 0x445eb(%rip), %rcx     # 0xd0826
movl $0x9d1, %edx            # imm = 0x9D1
callq 0xc140
leaq 0x43a4e(%rip), %rdi     # 0xcfc9a
leaq 0x42c37(%rip), %rsi     # 0xcee8a
leaq 0x43a65(%rip), %rcx     # 0xcfcbf
movl $0x9e4, %edx            # imm = 0x9E4
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x562cd
movaps %xmm0, -0x30(%rbp)
leaq 0x6f62e(%rip), %r14     # 0xfbcd0
movq (%r14), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8c71e
movl 0x6c(%rax), %r15d
testl %r15d, %r15d
jle 0x8c71e
xorl %ebx, %ebx
movl %ebx, %edi
callq 0x8b5ca
btl $0x14, %eax
jae 0x8c717
movq (%r14), %rax
movq 0x20a8(%rax), %rdi
testq %rdi, %rdi
je 0x8c6e4
movl %ebx, %esi
callq 0x8b537
movq %rax, %rdi
jmp 0x8c6e6
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movss 0x288de(%rip), %xmm0    # 0xb4fd0
callq 0x44a23
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, %xmm1
movaps -0x30(%rbp), %xmm3
cmpless %xmm3, %xmm1
movaps %xmm1, %xmm2
andnps %xmm0, %xmm2
andps %xmm3, %xmm1
orps %xmm2, %xmm1
movaps %xmm1, -0x30(%rbp)
incl %ebx
cmpl %ebx, %r15d
jne 0x8c6bc
callq 0x43b94
movss 0x5c(%rax), %xmm0
addss %xmm0, %xmm0
addss -0x30(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %esi, %ebx
leaq 0x6ec3f(%rip), %rcx     # 0xfbcd0
movl $0x3118, %eax           # imm = 0x3118
addq (%rcx), %rax
movl %edi, %r14d
movslq %esi, %r15
leaq (%r15,%r15,2), %rcx
leaq 0x10(,%rcx,4), %rsi
movq %rax, %rdi
callq 0x8fb92
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testl %r15d, %r15d
jle 0x8d0f0
movq %rax, %rcx
addq $0x10, %rcx
movl %ebx, %edx
movq $0x0, (%rcx)
movw $0xffff, 0x8(%rcx)      # imm = 0xFFFF
movb $-0x1, 0xa(%rcx)
movb 0xb(%rcx), %sil
andb $-0x10, %sil
orb $0x4, %sil
movb %sil, 0xb(%rcx)
addq $0xc, %rcx
decl %edx
jne 0x8d0c7
movl %r14d, (%rax)
movb %bl, 0xc(%rax)
movb %bl, 0xd(%rax)
movb $0x1, 0xe(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x6ebba(%rip), %rax     # 0xfbcd0
movq (%rax), %r14
movq 0x3120(%r14), %rax
testq %rax, %rax
je 0x8d146
movl %edi, %ebx
addq $0x3118, %r14           # imm = 0x3118
addq $0x4, %rax
cmpl %ebx, (%rax)
je 0x8d148
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e4e0
testq %rax, %rax
jne 0x8d132
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x64(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rcx
je 0x8d195
cmpl $0x4, %ecx
jl 0x8d199
leaq 0x6eb66(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
cmpl %ecx, 0x3118(%rax)
jle 0x8d199
movq 0x3120(%rax), %rax
movl (%rax,%rcx), %edx
cmpl (%rdi), %edx
jne 0x8d1b8
addq %rcx, %rax
movsbl 0xd(%rax), %ecx
cmpl %ecx, 0x6c(%rdi)
jle 0x8d197
movl $0x0, (%rax)
xorl %eax, %eax
popq %rbp
retq
leaq 0x2d3ee(%rip), %rdi     # 0xba58e
leaq 0x2c498(%rip), %rsi     # 0xb963f
leaq 0x43a87(%rip), %rcx     # 0xd0c35
movl $0x25b, %edx            # imm = 0x25B
callq 0xc140
leaq 0x42e9f(%rip), %rdi     # 0xd005e
leaq 0x41cc4(%rip), %rsi     # 0xcee8a
leaq 0x42eab(%rip), %rcx     # 0xd0078
movl $0xbf8, %edx            # imm = 0xBF8
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x36791(%rip), %r14     # 0xc3980
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42033
movl %eax, %r15d
movl 0x30f8(%rbx), %eax
cmpl 0x30fc(%rbx), %eax
jne 0x8d221
leal 0x1(%rax), %r13d
testl %eax, %eax
je 0x8d22a
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x8d22f
movq 0x3100(%rbx), %r12
jmp 0x8d28c
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rdi
callq 0x41c63
movq %rax, %r12
movq 0x3100(%rbx), %rsi
testq %rsi, %rsi
je 0x8d278
movslq 0x30f8(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x3100(%rbx), %rdi
callq 0x41d3c
movq %r12, 0x3100(%rbx)
movl %r13d, 0x30fc(%rbx)
movl 0x30f8(%rbx), %eax
cltq
leaq (%rax,%rax,8), %rax
movq %r14, (%r12,%rax,8)
movl %r15d, 0x8(%r12,%rax,8)
movl $0x0, 0xc(%r12,%rax,8)
leaq 0x56(%rip), %rcx        # 0x8d301
movq %rcx, 0x10(%r12,%rax,8)
xorl %ecx, %ecx
movq %rcx, 0x18(%r12,%rax,8)
leaq 0xd7(%rip), %rdx        # 0x8d395
movq %rdx, 0x20(%r12,%rax,8)
leaq 0x17b(%rip), %rdx       # 0x8d445
movq %rdx, 0x28(%r12,%rax,8)
leaq 0x3c8(%rip), %rdx       # 0x8d69e
movq %rdx, 0x30(%r12,%rax,8)
leaq 0x42d(%rip), %rdx       # 0x8d70f
movq %rdx, 0x38(%r12,%rax,8)
movq %rcx, 0x40(%r12,%rax,8)
incl 0x30f8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movl 0x20b0(%rdi), %edx
testq %rdx, %rdx
je 0x8d34f
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
imulq $0x258, %rcx, %rcx      # imm = 0x258
imulq $0x258, %rdx, %rdx      # imm = 0x258
cmpq %rax, %rcx
je 0x8d376
movq 0x20b8(%rbx), %rsi
movl $0xffffffff, 0x64(%rsi,%rax) # imm = 0xFFFFFFFF
addq $0x258, %rax            # imm = 0x258
cmpq %rax, %rdx
jne 0x8d330
movq 0x3120(%rbx), %rdi
testq %rdi, %rdi
je 0x8d371
xorl %r14d, %r14d
movq %r14, 0x3118(%rbx)
callq 0x41d3c
movq %r14, 0x3120(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2c2fb(%rip), %rdi     # 0xb9678
leaq 0x2c307(%rip), %rsi     # 0xb968b
leaq 0x2d6a2(%rip), %rcx     # 0xbaa2d
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %ebx, %ebx
leaq -0xc(%rbp), %rdx
movl %ebx, (%rdx)
leaq -0x10(%rbp), %rcx
movl %ebx, (%rcx)
leaq 0x434c0(%rip), %rsi     # 0xd0873
xorl %eax, %eax
callq 0xc0c0
cmpl $0x2, %eax
jl 0x8d43b
movl -0xc(%rbp), %edi
callq 0x8d108
testq %rax, %rax
je 0x8d3e2
movq %rax, %rbx
movb 0xd(%rax), %al
movsbl %al, %edx
movl -0x10(%rbp), %ecx
cmpl %edx, %ecx
jle 0x8d3f2
movl $0x0, (%rbx)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x8d07e
movq %rax, %rbx
jmp 0x8d43b
movl -0xc(%rbp), %esi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
testb %al, %al
jle 0x8d42f
movq %rbx, %rdi
addq $0x10, %rdi
movq $0x0, (%rdi)
movw $0xffff, 0x8(%rdi)      # imm = 0xFFFF
movb $-0x1, 0xa(%rdi)
movb 0xb(%rdi), %r8b
andb $-0x10, %r8b
orb $0x4, %r8b
movb %r8b, 0xb(%rdi)
addq $0xc, %rdi
decl %edx
jne 0x8d406
movl %esi, (%rbx)
movb %cl, 0xc(%rbx)
movb %al, 0xd(%rbx)
movb $0x1, 0xe(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x20b0(%rdi), %edx
testq %rdx, %rdx
je 0x8d6ee
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
imulq $0x258, %rcx, %rcx      # imm = 0x258
imulq $0x258, %rdx, %rdx      # imm = 0x258
cmpq %rax, %rcx
je 0x8d6f0
movq 0x20b8(%rdi), %rsi
movb $0x1, 0x24e(%rsi,%rax)
movl $0xffffffff, 0x64(%rsi,%rax) # imm = 0xFFFFFFFF
addq $0x258, %rax            # imm = 0x258
cmpq %rax, %rdx
jne 0x8d6c7
popq %rbp
retq
leaq 0x2bf81(%rip), %rdi     # 0xb9678
leaq 0x2bf8d(%rip), %rsi     # 0xb968b
leaq 0x2d328(%rip), %rcx     # 0xbaa2d
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x6e38e(%rip), %rax     # 0xfbcd0
movq (%rax), %r13
leaq 0x20b0(%r13), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8fa00
movl %eax, %ebx
movl (%r14), %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x8fa00
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x8fdf0
testl %ebx, %ebx
js 0x8d9a0
cmpl %ebx, 0x20e8(%r13)
jle 0x8d9a0
movq 0x20f0(%r13), %rax
movl %ebx, %ecx
movl $0xbf800000, (%rax,%rcx,4) # imm = 0xBF800000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bcd1(%rip), %rdi     # 0xb9678
leaq 0x2bcdd(%rip), %rsi     # 0xb968b
leaq 0x41408(%rip), %rcx     # 0xcedbd
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
cmpb $0x0, 0x255(%rdi)
jne 0x8dac4
movq %rdi, %rbx
leaq 0x6e2f0(%rip), %rax     # 0xfbcd0
movq (%rax), %r14
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x754ba
movq 0x218(%rbx), %rdi
testq %rdi, %rdi
je 0x8da11
xorl %r15d, %r15d
movq %r15, 0x210(%rbx)
callq 0x41d3c
movq %r15, 0x218(%rbx)
movq $0x0, 0x220(%rbx)
movb $0x1, 0x24b(%rbx)
movq 0x1e0(%rbx), %rdi
testq %rdi, %rdi
je 0x8da45
xorl %r15d, %r15d
movq %r15, 0x1d8(%rbx)
callq 0x41d3c
movq %r15, 0x1e0(%rbx)
movb $0x1, 0x255(%rbx)
movslq 0x6c(%rbx), %rax
testq %rax, %rax
jle 0x8da6e
movq 0x10(%rbx), %rcx
cmpq 0x18(%rbx), %rcx
jae 0x8daa5
movw $0xffff, 0x50(%rcx)     # imm = 0xFFFF
addq $0x68, %rcx
decq %rax
jne 0x8da59
leaq 0x20b0(%r14), %rdi
movq %rbx, %rsi
callq 0x8fa00
testl %eax, %eax
js 0x8dae3
cmpl %eax, 0x20e8(%r14)
jle 0x8dae3
movq 0x20f0(%r14), %rcx
movl %eax, %eax
movl $0xbf800000, (%rcx,%rax,4) # imm = 0xBF800000
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cc0c(%rip), %rdi     # 0xba6b8
leaq 0x2bb8c(%rip), %rsi     # 0xb963f
leaq 0x2cc17(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
leaq 0x4267d(%rip), %rdi     # 0xd0148
leaq 0x413b8(%rip), %rsi     # 0xcee8a
leaq 0x4268f(%rip), %rcx     # 0xd0168
movl $0xd0f, %edx            # imm = 0xD0F
callq 0xc140
leaq 0x2bb8e(%rip), %rdi     # 0xb9678
leaq 0x2bb9a(%rip), %rsi     # 0xb968b
leaq 0x412c5(%rip), %rcx     # 0xcedbd
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x6e1b6(%rip), %rax     # 0xfbcd0
movq (%rax), %r12
leaq 0x3118(%r12), %rbx
movq 0x3120(%r12), %rax
testq %rax, %rax
je 0x8dba4
addq $0x4, %rax
xorl %r13d, %r13d
cmpl $0x0, (%rax)
je 0x8db4a
movsbl 0xc(%rax), %ecx
leal (%rcx,%rcx,2), %ecx
leal 0x10(%r13,%rcx,4), %r13d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5e4e0
testq %rax, %rax
jne 0x8db39
cmpl (%rbx), %r13d
je 0x8dc69
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testl %r13d, %r13d
jle 0x8dbb4
movl %r13d, %edi
callq 0x41c63
movq %rax, %r14
movq -0x38(%rbp), %r15
testq %r15, %r15
je 0x8db9a
movslq -0x40(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xc080
movq %r15, %rdi
callq 0x41d3c
movq %r14, -0x38(%rbp)
movl %r13d, -0x3c(%rbp)
jmp 0x8dbb4
cmpl $0x0, (%rbx)
je 0x8dc69
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq 0x3120(%r12), %rax
leaq 0x4(%rax), %r14
testq %rax, %rax
cmoveq %rax, %r14
leaq -0x40(%rbp), %r15
testq %r14, %r14
je 0x8dc1b
cmpl $0x0, (%r14)
je 0x8dc0b
movsbq 0xc(%r14), %rax
leaq (%rax,%rax,2), %rax
leaq 0x10(,%rax,4), %rsi
movq %r15, %rdi
callq 0x8fb92
movsbq 0xc(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x10(,%rcx,4), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xc080
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e4e0
movq %rax, %r14
jmp 0x8dbcb
movl 0x3118(%r12), %eax
movl -0x40(%rbp), %ecx
movl %ecx, 0x3118(%r12)
movl %eax, -0x40(%rbp)
movl 0x311c(%r12), %eax
movl -0x3c(%rbp), %ecx
movl %ecx, 0x311c(%r12)
movl %eax, -0x3c(%rbp)
movq 0x3120(%r12), %rdi
movq -0x38(%rbp), %rax
movq %rax, 0x3120(%r12)
movq %rdi, -0x38(%rbp)
testq %rdi, %rdi
je 0x8dc69
callq 0x41d3c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8dc82
movq %rax, %rdi
callq 0x39dbe
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5e656
movq %rbx, %rdi
callq 0xc560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4210d(%rip), %rsi     # 0xd04bd
movl %edi, %edx
xorl %eax, %eax
callq 0xa086e
testb %al, %al
je 0x8e4bc
movl 0x4(%rbx), %esi
leaq 0x4210f(%rip), %rdi     # 0xd04da
xorl %eax, %eax
callq 0x90944
movsbl 0xc(%rbx), %esi
movsbl 0xd(%rbx), %edx
leaq 0x4210b(%rip), %rdi     # 0xd04ec
xorl %eax, %eax
callq 0x90944
cmpb $0x0, 0xc(%rbx)
jle 0x8e4a9
leaq 0x1b(%rbx), %r12
xorl %r14d, %r14d
leaq 0x4214f(%rip), %r13     # 0xd054f
leaq 0x420ff(%rip), %r15     # 0xd0506
movsbl -0x1(%r12), %ecx
movb (%r12), %al
cmpl $-0x1, %ecx
je 0x8e440
movl %eax, %edx
andb $0x3, %dl
cmpb $0x2, %dl
leaq 0x42f18(%rip), %r8      # 0xd133d
leaq 0x4211f(%rip), %rsi     # 0xd054b
cmoveq %rsi, %r8
cmpb $0x1, %dl
leaq 0x4210d(%rip), %rdx     # 0xd0547
cmoveq %rdx, %r8
jmp 0x8e44c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x42ef1(%rip), %r8      # 0xd133d
movsbl -0x2(%r12), %edx
movl %eax, %esi
shrb $0x2, %sil
andb $0x1, %sil
testb $0x8, %al
movq %r13, %r10
leaq 0x420ee(%rip), %rax     # 0xd0556
cmoveq %rax, %r10
movzbl %sil, %r9d
xorps %xmm0, %xmm0
cvtss2sd -0xb(%r12), %xmm0
movl -0x7(%r12), %r11d
movq %r15, %rdi
movl %r14d, %esi
movb $0x1, %al
pushq %r11
pushq %r10
callq 0x90944
addq $0x10, %rsp
incq %r14
movsbq 0xc(%rbx), %rax
addq $0xc, %r12
cmpq %rax, %r14
jl 0x8e407
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa1609
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x6d77b(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %rax
testq %rax, %rax
je 0x8e5a5
testl %edi, %edi
jns 0x8e572
movl 0xc(%rax), %edi
cmpl 0x60(%rax), %edi
jge 0x8e5aa
testl %edi, %edi
js 0x8e5c9
movq 0x68(%rax), %rcx
movl %edi, %edx
leaq (%rdx,%rdx,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rdx, %rsi
movss 0x14(%rax), %xmm1
movss 0x18(%rax), %xmm0
subss %xmm1, %xmm0
mulss (%rcx,%rsi), %xmm0
addss %xmm1, %xmm0
jmp 0x8e5a8
xorps %xmm0, %xmm0
popq %rbp
retq
leaq 0x41fac(%rip), %rdi     # 0xd055d
leaq 0x408d2(%rip), %rsi     # 0xcee8a
leaq 0x41fc3(%rip), %rcx     # 0xd0582
movl $0xdee, %edx            # imm = 0xDEE
callq 0xc140
leaq 0x2b0a8(%rip), %rdi     # 0xb9678
leaq 0x2b0b4(%rip), %rsi     # 0xb968b
leaq 0x42706(%rip), %rcx     # 0xd0ce4
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x6d6dd(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %rax
testq %rax, %rax
je 0x8e659
testl %edi, %edi
jns 0x8e610
movl 0xc(%rax), %edi
cmpl $-0x1, %edi
jl 0x8e660
leal 0x1(%rdi), %ecx
cmpl %ecx, 0x60(%rax)
jle 0x8e660
testl %edi, %edi
js 0x8e660
movq 0x68(%rax), %rdx
movl %ecx, %ecx
leaq (%rcx,%rcx,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rcx, %rsi
movss (%rdx,%rsi), %xmm1
movl %edi, %ecx
leaq (%rcx,%rcx,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rcx, %rsi
subss (%rdx,%rsi), %xmm1
movss 0x18(%rax), %xmm0
subss 0x14(%rax), %xmm0
mulss %xmm1, %xmm0
jmp 0x8e65e
callq 0x51f24
popq %rbp
retq
leaq 0x2b011(%rip), %rdi     # 0xb9678
leaq 0x2b01d(%rip), %rsi     # 0xb968b
leaq 0x4266f(%rip), %rcx     # 0xd0ce4
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d44e(%rip), %rax     # 0xfbcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1b0(%rax), %rax
testq %rax, %rax
je 0x8e8be
movss %xmm0, -0xc(%rbp)
testl %edi, %edi
jns 0x8e8a4
movl 0xc(%rax), %edi
leal 0x1(%rdi), %ebx
callq 0x8e54a
addss -0xc(%rbp), %xmm0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8e67f
leaq 0x41cdf(%rip), %rdi     # 0xd05a4
leaq 0x405be(%rip), %rsi     # 0xcee8a
leaq 0x41d0b(%rip), %rcx     # 0xd05de
movl $0xe29, %edx            # imm = 0xE29
callq 0xc140