LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableResetSettings(ImGuiTable*)
void ImGui::TableResetSettings(ImGuiTable* table)
{
    table->IsInitializing = table->IsSettingsDirty = true;
    table->IsResetAllRequest = false;
    table->IsSettingsRequestLoad = false;                   // Don't reload from ini
    table->SettingsLoadedFlags = ImGuiTableFlags_None;      // Mark as nothing loaded so our initialized data becomes authoritative
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0x24a(%rdi)
movb $0x0, 0x251(%rdi)
movw $0x100, 0x24e(%rdi)     # imm = 0x100
movl $0x0, 0x60(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnWidthAuto(ImGuiTable*, ImGuiTableColumn*)
float ImGui::TableGetColumnWidthAuto(ImGuiTable* table, ImGuiTableColumn* column)
{
    const float content_width_body = ImMax(column->ContentMaxXFrozen, column->ContentMaxXUnfrozen) - column->WorkMinX;
    const float content_width_headers = column->ContentMaxXHeadersIdeal - column->WorkMinX;
    float width_auto = content_width_body;
    if (!(column->Flags & ImGuiTableColumnFlags_NoHeaderWidth))
        width_auto = ImMax(width_auto, content_width_headers);

    // Non-resizable fixed columns preserve their requested width
    if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && column->InitStretchWeightOrWidth > 0.0f)
        if (!(table->Flags & ImGuiTableFlags_Resizable) || (column->Flags & ImGuiTableColumnFlags_NoResize))
            width_auto = column->InitStretchWeightOrWidth;

    return ImMax(width_auto, table->MinColumnWidth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss 0x40(%rsi), %xmm0
movss 0x44(%rsi), %xmm2
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss 0x34(%rsi), %xmm0
subss %xmm0, %xmm1
movl (%rsi), %eax
btl $0xb, %eax
jb 0x8a3da
movss 0x4c(%rsi), %xmm2
subss %xmm0, %xmm2
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
movaps %xmm0, %xmm3
andnps %xmm2, %xmm3
andps %xmm1, %xmm0
orps %xmm3, %xmm0
movaps %xmm0, %xmm1
testb $0x8, %al
je 0x8a3fa
movss 0x1c(%rsi), %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x8a3fa
testb $0x10, %al
jne 0x8a3f7
movl 0x4(%rdi), %eax
andl $0x1, %eax
jne 0x8a3fa
movaps %xmm0, %xmm1
movss 0xb4(%rdi), %xmm2
movaps %xmm2, %xmm0
cmpless %xmm1, %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableOpenContextMenu(int)
void ImGui::TableOpenContextMenu(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (column_n == -1 && table->CurrentColumn != -1)   // When called within a column automatically use this one (for consistency)
        column_n = table->CurrentColumn;
    if (column_n == table->ColumnsCount)                // To facilitate using with TableGetHoveredColumn()
        column_n = -1;
    IM_ASSERT(column_n >= -1 && column_n < table->ColumnsCount);
    if (table->Flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Hideable))
    {
        table->IsContextPopupOpen = true;
        table->ContextPopupColumn = (ImGuiTableColumnIdx)column_n;
        table->InstanceInteracted = table->InstanceCurrent;
        const ImGuiID context_menu_id = ImHashStr("##ContextMenu", 0, table->ID);
        OpenPopupEx(context_menu_id, ImGuiPopupFlags_None);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x71dc7(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
cmpl $-0x1, %edi
jne 0x8bf1b
movl 0x74(%rax), %edi
movl 0x6c(%rax), %edx
cmpl %edx, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovnel %edi, %ecx
cmpl $-0x1, %ecx
jl 0x8bf68
cmpl %edx, %ecx
jge 0x8bf68
testb $0x7, 0x4(%rax)
je 0x8bf66
movb $0x1, 0x24d(%rax)
movb %cl, 0x23f(%rax)
movzwl 0x78(%rax), %ecx
movw %cx, 0x7a(%rax)
movl (%rax), %edx
leaq 0x45240(%rip), %rdi     # 0xd1195
xorl %esi, %esi
callq 0x428dc
movl %eax, %edi
xorl %esi, %esi
popq %rbp
jmp 0x57dd4
popq %rbp
retq
leaq 0x4604d(%rip), %rdi     # 0xd1fbc
leaq 0x44f44(%rip), %rsi     # 0xd0eba
leaq 0x46070(%rip), %rcx     # 0xd1fed
movl $0xb4f, %edx            # imm = 0xB4F
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableSetupScrollFreeze(int, int)
void ImGui::TableSetupScrollFreeze(int columns, int rows)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Need to call TableSetupColumn() after BeginTable()!");
    IM_ASSERT(table->IsLayoutLocked == false && "Need to call TableSetupColumn() before first row!");
    IM_ASSERT(columns >= 0 && columns < IMGUI_TABLE_MAX_COLUMNS);
    IM_ASSERT(rows >= 0 && rows < 128); // Arbitrary limit

    table->FreezeColumnsRequest = (table->Flags & ImGuiTableFlags_ScrollX) ? (ImGuiTableColumnIdx)columns : 0;
    table->FreezeColumnsCount = (table->InnerWindow->Scroll.x != 0.0f) ? table->FreezeColumnsRequest : 0;
    table->FreezeRowsRequest = (table->Flags & ImGuiTableFlags_ScrollY) ? (ImGuiTableColumnIdx)rows : 0;
    table->FreezeRowsCount = (table->InnerWindow->Scroll.y != 0.0f) ? table->FreezeRowsRequest : 0;
    table->IsUnfrozenRows = (table->FreezeRowsCount == 0); // Make sure this is set before TableUpdateLayout() so ImGuiListClipper can benefit from it.b
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x70c30(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8d136
cmpb $0x0, 0x248(%rax)
jne 0x8d155
cmpl $0x40, %edi
jae 0x8d174
cmpl $0x80, %esi
jae 0x8d193
movl 0x4(%rax), %ecx
xorl %edx, %edx
btl $0x18, %ecx
cmovael %edx, %edi
movb %dil, 0x242(%rax)
movq 0x1d0(%rax), %r8
xorps %xmm0, %xmm0
ucomiss 0x5c(%r8), %xmm0
movl $0x0, %r9d
cmovnel %edi, %r9d
cmovpl %edi, %r9d
movb %r9b, 0x243(%rax)
btl $0x19, %ecx
cmovael %edx, %esi
movb %sil, 0x240(%rax)
ucomiss 0x60(%r8), %xmm0
cmovnel %esi, %edx
cmovpl %esi, %edx
movb %dl, 0x241(%rax)
testb %dl, %dl
sete 0x253(%rax)
popq %rbp
retq
leaq 0x442ed(%rip), %rdi     # 0xd142a
leaq 0x43d76(%rip), %rsi     # 0xd0eba
leaq 0x44521(%rip), %rcx     # 0xd166c
movl $0x58f, %edx            # imm = 0x58F
callq 0xc140
leaq 0x4453d(%rip), %rdi     # 0xd1699
leaq 0x43d57(%rip), %rsi     # 0xd0eba
leaq 0x44502(%rip), %rcx     # 0xd166c
movl $0x590, %edx            # imm = 0x590
callq 0xc140
leaq 0x44574(%rip), %rdi     # 0xd16ef
leaq 0x43d38(%rip), %rsi     # 0xd0eba
leaq 0x444e3(%rip), %rcx     # 0xd166c
movl $0x591, %edx            # imm = 0x591
callq 0xc140
leaq 0x44572(%rip), %rdi     # 0xd170c
leaq 0x43d19(%rip), %rsi     # 0xd0eba
leaq 0x444c4(%rip), %rcx     # 0xd166c
movl $0x592, %edx            # imm = 0x592
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnName(int)
const char* ImGui::TableGetColumnName(int column_n)
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    if (!table)
        return NULL;
    if (column_n < 0)
        column_n = table->CurrentColumn;
    return TableGetColumnName(table, column_n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %esi
leaq 0x70aee(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rdi
testq %rdi, %rdi
je 0x8d1fe
testl %esi, %esi
jns 0x8d1f8
movl 0x74(%rdi), %esi
popq %rbp
jmp 0x8d202
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableGetColumnName(ImGuiTable const*, int)
const char* ImGui::TableGetColumnName(const ImGuiTable* table, int column_n)
{
    if (table->IsLayoutLocked == false && column_n >= table->DeclColumnsCount)
        return ""; // NameOffset is invalid at this point
    const ImGuiTableColumn* column = &table->Columns[column_n];
    if (column->NameOffset == -1)
        return "";
    return &table->ColumnsNames.Buf[column->NameOffset];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x248(%rdi)
leaq 0x29d09(%rip), %rax     # 0xb6f1d
jne 0x8d221
movsbl 0x233(%rdi), %ecx
cmpl %esi, %ecx
jle 0x8d255
testl %esi, %esi
js 0x8d257
movslq %esi, %rcx
imulq $0x68, %rcx, %rcx
addq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x8d257
movswl 0x50(%rcx), %ecx
cmpl $-0x1, %ecx
je 0x8d255
testw %cx, %cx
js 0x8d276
cmpl %ecx, 0x1d8(%rdi)
jle 0x8d276
movl %ecx, %eax
addq 0x1e0(%rdi), %rax
popq %rbp
retq
leaq 0x2f45a(%rip), %rdi     # 0xbc6b8
leaq 0x2e3da(%rip), %rsi     # 0xbb63f
leaq 0x45976(%rip), %rcx     # 0xd2be2
movl $0x20f, %edx            # imm = 0x20F
callq 0xc140
leaq 0x2e3fb(%rip), %rdi     # 0xbb678
leaq 0x2e407(%rip), %rsi     # 0xbb68b
leaq 0x459a7(%rip), %rcx     # 0xd2c32
movl $0x65d, %edx            # imm = 0x65D
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70a34(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8d2c9
testl %edi, %edi
jns 0x8d2b2
movl 0x74(%rax), %edi
cmpl 0x6c(%rax), %edi
jne 0x8d2cc
movsbl 0x234(%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %edi
sete %al
shll $0x17, %eax
retq
xorl %eax, %eax
retq
testl %edi, %edi
js 0x8d2e4
movslq %edi, %rcx
imulq $0x68, %rcx, %rcx
addq 0x10(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x8d2e4
movl (%rcx), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2f3c9(%rip), %rdi     # 0xbc6b8
leaq 0x2e349(%rip), %rsi     # 0xbb63f
leaq 0x2f3d4(%rip), %rcx     # 0xbc6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7094c(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8d39c
movsbl 0x234(%rax), %eax
jmp 0x8d3a1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x707ca(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8d51a
movl 0x70(%rax), %eax
jmp 0x8d51c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70799(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
cmpb $0x0, 0x248(%rbx)
jne 0x8d552
movq %rbx, %rdi
callq 0x89339
cmpb $0x1, 0x249(%rbx)
jne 0x8d563
movq %rbx, %rdi
callq 0x8b7ea
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 0x8d5d9
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_O1/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 0x8d6db
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 0x8d642
cmpb $0x0, 0x241(%rbx)
jle 0x8d642
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 0x8d6d4
movss 0x29956(%rip), %xmm0    # 0xb6fe4
movl $0x2a, %edi
callq 0x445bd
leaq 0x70631(%rip), %rcx     # 0xfdcd0
movq (%rcx), %rcx
movq 0x20a8(%rcx), %rcx
movss 0x7c(%rcx), %xmm0
ucomiss 0x128(%rcx), %xmm0
ja 0x8d6c7
xorl %edx, %edx
cmpl $0x1000000, %eax        # imm = 0x1000000
cmovnel %eax, %edx
movl %edx, 0x98(%rcx)
cmpl $0x0, 0x70(%rbx)
jne 0x8d6d4
movb $0x1, 0x24c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x44123(%rip), %rdi     # 0xd1805
leaq 0x437d1(%rip), %rsi     # 0xd0eba
leaq 0x44129(%rip), %rcx     # 0xd1819
movl $0x642, %edx            # imm = 0x642
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8d7cb
imulq $0x68, %rax, %rax
addq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x8d7cb
movq 0x1d0(%rdi), %rcx
movl $0x48, %edx
testb $0x1, 0x90(%rdi)
jne 0x8d73d
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 0x2eee2(%rip), %rdi     # 0xbc6b8
leaq 0x2de62(%rip), %rsi     # 0xbb63f
leaq 0x2eeed(%rip), %rcx     # 0xbc6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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
movss 0x4(%rsi), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movss 0xc(%rsi), %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
shufps $0x42, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[0,1]
movups (%rsi), %xmm0
movups %xmm0, 0x258(%rdi)
movq 0x2b8(%rdi), %rax
movups %xmm1, 0x88(%rax)
movq 0x2b8(%rdi), %rax
movq 0x60(%rax), %rcx
movslq 0x58(%rax), %rax
shlq $0x4, %rax
movups %xmm1, -0x10(%rcx,%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70487(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8d85d
movl 0x74(%rax), %eax
jmp 0x8d85f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70461(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %r14
testq %r14, %r14
je 0x8d8b7
movl %edi, %ebx
movl 0x74(%r14), %eax
cmpl %edi, %eax
je 0x8d8aa
cmpl $-0x1, %eax
je 0x8d895
movq %r14, %rdi
callq 0x8d6fa
testl %ebx, %ebx
js 0x8d8be
cmpl $0x0, 0x6c(%r14)
je 0x8d8be
movq %r14, %rdi
movl %ebx, %esi
callq 0x8d8dd
movq 0x58(%r14), %rax
btq %rbx, %rax
setb %al
jmp 0x8d8b9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x44027(%rip), %rdi     # 0xd18ec
leaq 0x435ee(%rip), %rsi     # 0xd0eba
leaq 0x4403e(%rip), %rcx     # 0xd1911
movl $0x701, %edx            # imm = 0x701
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70254(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x8dadd
cmpb $0x1, 0x249(%rbx)
jne 0x8dab5
movl 0x74(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl 0x6c(%rbx), %ecx
jge 0x8dab5
cmpl $-0x1, %eax
je 0x8daac
movq %rbx, %rdi
callq 0x8d6fa
movl 0x74(%rbx), %r14d
incl %r14d
jmp 0x8dac2
xorl %r14d, %r14d
xorps %xmm0, %xmm0
xorl %edi, %edi
callq 0x8d51e
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8d8dd
movq 0x58(%rbx), %rax
movl 0x74(%rbx), %ecx
btq %rcx, %rax
setb %al
jmp 0x8dadf
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8dbff
cmpb $-0x1, 0x23d(%rdi)
je 0x8dbff
movslq 0x6c(%rdi), %rax
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testq %rax, %rax
jle 0x8db52
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorps %xmm3, %xmm3
movq %rax, %rsi
cmpq %rdx, %rcx
jae 0x8dba2
cmpb $0x1, 0x5a(%rcx)
jne 0x8db49
testb $0x4, (%rcx)
je 0x8db49
movss 0x18(%rcx), %xmm4
ucomiss %xmm3, %xmm4
jbe 0x8dbe0
addss %xmm4, %xmm0
addss 0x10(%rcx), %xmm1
addq $0x68, %rcx
decq %rsi
jne 0x8db22
ucomiss %xmm2, %xmm0
jbe 0x8dc1e
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jbe 0x8dc1e
testl %eax, %eax
jle 0x8dba0
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x8dba2
cmpb $0x1, 0x5a(%rcx)
jne 0x8db97
testb $0x4, (%rcx)
je 0x8db97
movss 0x10(%rcx), %xmm3
divss %xmm1, %xmm3
mulss %xmm0, %xmm3
movss %xmm3, 0x18(%rcx)
ucomiss %xmm2, %xmm3
jbe 0x8dbc1
addq $0x68, %rcx
decq %rax
jne 0x8db6f
popq %rbp
retq
leaq 0x2eb0f(%rip), %rdi     # 0xbc6b8
leaq 0x2da8f(%rip), %rsi     # 0xbb63f
leaq 0x2eb1a(%rip), %rcx     # 0xbc6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
leaq 0x43ea2(%rip), %rdi     # 0xd1a6a
leaq 0x432eb(%rip), %rsi     # 0xd0eba
leaq 0x43e58(%rip), %rcx     # 0xd1a2e
movl $0x82b, %edx            # imm = 0x82B
callq 0xc140
leaq 0x43e83(%rip), %rdi     # 0xd1a6a
leaq 0x432cc(%rip), %rsi     # 0xd0eba
leaq 0x43e39(%rip), %rcx     # 0xd1a2e
movl $0x81e, %edx            # imm = 0x81E
callq 0xc140
leaq 0x43dda(%rip), %rdi     # 0xd19e0
leaq 0x432ad(%rip), %rsi     # 0xd0eba
leaq 0x43e1a(%rip), %rcx     # 0xd1a2e
movl $0x814, %edx            # imm = 0x814
callq 0xc140
leaq 0x43e62(%rip), %rdi     # 0xd1a87
leaq 0x4328e(%rip), %rsi     # 0xd0eba
leaq 0x43dfb(%rip), %rcx     # 0xd1a2e
movl $0x822, %edx            # imm = 0x822
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8dc6e
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x8dc70
cmpb $0x0, 0x5a(%rcx)
jne 0x8dc5f
testb $0x4, (%rcx)
je 0x8dc65
movw $0x102, 0x62(%rcx)      # imm = 0x102
addq $0x68, %rcx
decq %rax
jne 0x8dc4e
popq %rbp
retq
leaq 0x2ea41(%rip), %rdi     # 0xbc6b8
leaq 0x2d9c1(%rip), %rsi     # 0xbb63f
leaq 0x2ea4c(%rip), %rcx     # 0xbc6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70036(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x1ae0(%rax), %rcx
movq 0x20a8(%rax), %rdi
movups 0x258(%rcx), %xmm0
movups %xmm0, 0x18c(%rdi)
movsd 0x14c(%rdi), %xmm0
movups 0x14c(%rdi), %xmm1
movhps 0x154(%rdi), %xmm0      # xmm0 = xmm0[0,1],mem[0,1]
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 0x7c2ae
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6ffb2(%rip), %rax     # 0xfdcd0
movq (%rax), %rcx
movq 0x20a8(%rcx), %rdi
movslq 0x74(%rdi), %rax
testq %rax, %rax
js 0x8dda0
imulq $0x68, %rax, %rax
addq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x8dda0
movq 0x1ae0(%rcx), %rcx
movsd 0x18c(%rdi), %xmm0
movups 0x18c(%rdi), %xmm1
movhps 0x194(%rdi), %xmm0      # xmm0 = xmm0[0,1],mem[0,1]
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 0x7c2ae
pushq %rbp
movq %rsp, %rbp
leaq 0x2e90d(%rip), %rdi     # 0xbc6b8
leaq 0x2d88d(%rip), %rsi     # 0xbb63f
leaq 0x2e918(%rip), %rcx     # 0xbc6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6ff00(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
movq 0x20a8(%rax), %rbx
testq %rbx, %rbx
je 0x8de1c
testb $0x8, 0x4(%rbx)
jne 0x8dde9
xorl %ebx, %ebx
jmp 0x8de12
cmpb $0x0, 0x248(%rbx)
jne 0x8ddfa
movq %rbx, %rdi
callq 0x89339
cmpb $0x1, 0x24b(%rbx)
jne 0x8de0b
movq %rbx, %rdi
callq 0x8abc0
addq $0x220, %rbx            # imm = 0x220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x43e67(%rip), %rdi     # 0xd1c8a
leaq 0x43090(%rip), %rsi     # 0xd0eba
leaq 0x43e69(%rip), %rcx     # 0xd1c9a
movl $0x9c0, %edx            # imm = 0x9C0
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8de54
movzbl 0x64(%rsi), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl %eax, %edx
andl $0x3, %edx
btl %edx, %ecx
jae 0x8de55
retq
testb $0xc, %al
je 0x8de6e
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 0x449b8(%rip), %rdi     # 0xd2831
leaq 0x4303a(%rip), %rsi     # 0xd0eba
leaq 0x449cf(%rip), %rcx     # 0xd2856
movl $0x9d1, %edx            # imm = 0x9D1
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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), %edx
testb $0xc, %dl
je 0x8df34
cmpb $-0x1, 0x56(%rdi)
je 0x8deee
movl %edx, %r9d
shrl $0x2, %r9d
andl $0x3, %r9d
andl $0x3, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %eax, %r9d
je 0x8df15
movzbl 0x65(%rdi), %esi
movl %esi, %r10d
shrl %cl, %r10d
andl $0x3, %r10d
cmpl %edx, %r10d
je 0x8defc
cmpl $0x2, %eax
leal 0x1(%rax), %r10d
setae %r8b
addl $0x2, %ecx
movl %r10d, %eax
cmpl $0x3, %r10d
jne 0x8debd
jmp 0x8df0b
testb $0xc, %dl
je 0x8df15
movzbl 0x65(%rdi), %esi
andl $0x3, %esi
jmp 0x8df11
incl %eax
xorl %edx, %edx
divl %r9d
leal (%rdx,%rdx), %ecx
shrl %cl, %esi
andl $0x3, %esi
testb $0x1, %r8b
jne 0x8df53
movl %esi, %eax
popq %rbp
retq
leaq 0x44915(%rip), %rdi     # 0xd2831
leaq 0x42f97(%rip), %rsi     # 0xd0eba
leaq 0x4492c(%rip), %rcx     # 0xd2856
movl $0x9d1, %edx            # imm = 0x9D1
callq 0xc140
leaq 0x43d8f(%rip), %rdi     # 0xd1cca
leaq 0x42f78(%rip), %rsi     # 0xd0eba
leaq 0x43da6(%rip), %rcx     # 0xd1cef
movl $0x9e4, %edx            # imm = 0x9E4
callq 0xc140
leaq 0x2c192(%rip), %rdi     # 0xba0ec
leaq 0x42f59(%rip), %rsi     # 0xd0eba
leaq 0x43d87(%rip), %rcx     # 0xd1cef
movl $0x9ea, %edx            # imm = 0x9EA
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x573d2
movaps %xmm0, -0x30(%rbp)
leaq 0x6f8dd(%rip), %r14     # 0xfdcd0
movq (%r14), %rax
movq 0x20a8(%rax), %rax
testq %rax, %rax
je 0x8e408
movl 0x6c(%rax), %r15d
jmp 0x8e40b
xorl %r15d, %r15d
testl %r15d, %r15d
jle 0x8e474
xorl %ebx, %ebx
movl %ebx, %edi
callq 0x8d295
btl $0x14, %eax
jae 0x8e46d
movq (%r14), %rax
movq 0x20a8(%rax), %rdi
testq %rdi, %rdi
je 0x8e43a
movl %ebx, %esi
callq 0x8d202
movq %rax, %rdi
jmp 0x8e43c
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movss 0x28b88(%rip), %xmm0    # 0xb6fd0
callq 0x4548d
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 0x8e412
callq 0x44587
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_O1/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 0x6eefd(%rip), %rcx     # 0xfdcd0
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 0x918ac
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testl %r15d, %r15d
jle 0x8ee32
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 0x8ee09
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_O1/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 0x6ee78(%rip), %rax     # 0xfdcd0
movq (%rax), %r14
movq 0x3120(%r14), %rcx
leaq 0x4(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
je 0x8ee8c
movl %edi, %ebx
addq $0x3118, %r14           # imm = 0x3118
cmpl %ebx, (%rax)
je 0x8ee8c
movq %r14, %rdi
movq %rax, %rsi
callq 0x5f6be
testq %rax, %rax
jne 0x8ee78
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8eed9
cmpl $0x4, %ecx
jl 0x8eedd
leaq 0x6ee22(%rip), %rax     # 0xfdcd0
movq (%rax), %rax
cmpl %ecx, 0x3118(%rax)
jle 0x8eedd
movq 0x3120(%rax), %rax
movl (%rax,%rcx), %edx
cmpl (%rdi), %edx
jne 0x8eefc
addq %rcx, %rax
movsbl 0xd(%rax), %ecx
cmpl %ecx, 0x6c(%rdi)
jle 0x8eedb
movl $0x0, (%rax)
xorl %eax, %eax
popq %rbp
retq
leaq 0x2d6aa(%rip), %rdi     # 0xbc58e
leaq 0x2c754(%rip), %rsi     # 0xbb63f
leaq 0x43e71(%rip), %rcx     # 0xd2d63
movl $0x25b, %edx            # imm = 0x25B
callq 0xc140
leaq 0x4318b(%rip), %rdi     # 0xd208e
leaq 0x41fb0(%rip), %rsi     # 0xd0eba
leaq 0x43197(%rip), %rcx     # 0xd20a8
movl $0xbf8, %edx            # imm = 0xBF8
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36a7d(%rip), %r14     # 0xc59b0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x428dc
movl %eax, %r15d
movl 0x30f8(%rbx), %r13d
movl 0x30fc(%rbx), %eax
cmpl %eax, %r13d
jne 0x8efc9
incl %r13d
testl %eax, %eax
je 0x8ef68
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x8ef6d
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x8efc9
movslq %r13d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rdi
callq 0x424fb
movq %rax, %r12
movq 0x3100(%rbx), %rsi
testq %rsi, %rsi
je 0x8efbb
movslq 0x30f8(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rdx
movq %r12, %rdi
callq 0xc080
movq 0x3100(%rbx), %rdi
callq 0x425d4
movq %r12, 0x3100(%rbx)
movl %r13d, 0x30fc(%rbx)
movq 0x3100(%rbx), %rax
movslq 0x30f8(%rbx), %rcx
leaq (%rcx,%rcx,8), %rcx
movq %r14, (%rax,%rcx,8)
movl %r15d, 0x8(%rax,%rcx,8)
movl $0x0, 0xc(%rax,%rcx,8)
leaq 0x56(%rip), %rdx        # 0x8f049
movq %rdx, 0x10(%rax,%rcx,8)
xorl %edx, %edx
movq %rdx, 0x18(%rax,%rcx,8)
leaq 0xd7(%rip), %rsi        # 0x8f0dd
movq %rsi, 0x20(%rax,%rcx,8)
leaq 0x17b(%rip), %rsi       # 0x8f18d
movq %rsi, 0x28(%rax,%rcx,8)
leaq 0x3c8(%rip), %rsi       # 0x8f3e6
movq %rsi, 0x30(%rax,%rcx,8)
leaq 0x42d(%rip), %rsi       # 0x8f457
movq %rsi, 0x38(%rax,%rcx,8)
movq %rdx, 0x40(%rax,%rcx,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_O1/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 0x8f097
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 0x8f0be
movq 0x20b8(%rbx), %rsi
movl $0xffffffff, 0x64(%rsi,%rax) # imm = 0xFFFFFFFF
addq $0x258, %rax            # imm = 0x258
cmpq %rax, %rdx
jne 0x8f078
movq 0x3120(%rbx), %rdi
testq %rdi, %rdi
je 0x8f0b9
xorl %r14d, %r14d
movq %r14, 0x3118(%rbx)
callq 0x425d4
movq %r14, 0x3120(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2c5b3(%rip), %rdi     # 0xbb678
leaq 0x2c5bf(%rip), %rsi     # 0xbb68b
leaq 0x2d95a(%rip), %rcx     # 0xbca2d
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x437a8(%rip), %rsi     # 0xd28a3
xorl %eax, %eax
callq 0xc0c0
cmpl $0x2, %eax
jl 0x8f183
movl -0xc(%rbp), %edi
callq 0x8ee4a
testq %rax, %rax
je 0x8f12a
movq %rax, %rbx
movb 0xd(%rax), %al
movsbl %al, %edx
movl -0x10(%rbp), %ecx
cmpl %edx, %ecx
jle 0x8f13a
movl $0x0, (%rbx)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x8edc0
movq %rax, %rbx
jmp 0x8f183
movl -0xc(%rbp), %esi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
testb %al, %al
jle 0x8f177
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 0x8f14e
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_O1/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 0x8f436
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 0x8f438
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 0x8f40f
popq %rbp
retq
leaq 0x2c239(%rip), %rdi     # 0xbb678
leaq 0x2c245(%rip), %rsi     # 0xbb68b
leaq 0x2d5e0(%rip), %rcx     # 0xbca2d
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e648(%rip), %rax     # 0xfdcd0
movq (%rax), %r13
leaq 0x20b0(%r13), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9171a
movl %eax, %ebx
movl (%r14), %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x9171a
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x91b0a
testl %ebx, %ebx
js 0x8f6e6
cmpl %ebx, 0x20e8(%r13)
jle 0x8f6e6
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 0x2bf8b(%rip), %rdi     # 0xbb678
leaq 0x2bf97(%rip), %rsi     # 0xbb68b
leaq 0x416f9(%rip), %rcx     # 0xd0df4
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140