// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::EndTable()
void    ImGui::EndTable()
{
    ImGuiContext& g = *GImGui;
    ImGuiTable* table = g.CurrentTable;
    IM_ASSERT(table != NULL && "Only call EndTable() if BeginTable() returns true!");

    // This assert would be very useful to catch a common error... unfortunately it would probably trigger in some
    // cases, and for consistency user may sometimes output empty tables (and still benefit from e.g. outer border)
    //IM_ASSERT(table->IsLayoutLocked && "Table unused: never called TableNextRow(), is that the intent?");

    // If the user never got to call TableNextRow() or TableNextColumn(), we call layout ourselves to ensure all our
    // code paths are consistent (instead of just hoping that TableBegin/TableEnd will work), get borders drawn, etc.
    if (!table->IsLayoutLocked)
        TableUpdateLayout(table);

    const ImGuiTableFlags flags = table->Flags;
    ImGuiWindow* inner_window = table->InnerWindow;
    ImGuiWindow* outer_window = table->OuterWindow;
    IM_ASSERT(inner_window == g.CurrentWindow);
    IM_ASSERT(outer_window == inner_window || outer_window == inner_window->ParentWindow);

    if (table->IsInsideRow)
        TableEndRow(table);

    // Context menu in columns body
    if (flags & ImGuiTableFlags_ContextMenuInBody)
        if (table->HoveredColumnBody != -1 && !IsAnyItemHovered() && IsMouseReleased(ImGuiMouseButton_Right))
            TableOpenContextMenu((int)table->HoveredColumnBody);

    // Finalize table height
    inner_window->DC.PrevLineSize = table->HostBackupPrevLineSize;
    inner_window->DC.CurrLineSize = table->HostBackupCurrLineSize;
    inner_window->DC.CursorMaxPos = table->HostBackupCursorMaxPos;
    const float inner_content_max_y = table->RowPosY2;
    IM_ASSERT(table->RowPosY2 == inner_window->DC.CursorPos.y);
    if (inner_window != outer_window)
        inner_window->DC.CursorMaxPos.y = inner_content_max_y;
    else if (!(flags & ImGuiTableFlags_NoHostExtendY))
        table->OuterRect.Max.y = table->InnerRect.Max.y = ImMax(table->OuterRect.Max.y, inner_content_max_y); // Patch OuterRect/InnerRect height
    table->WorkRect.Max.y = ImMax(table->WorkRect.Max.y, table->OuterRect.Max.y);
    table->LastOuterHeight = table->OuterRect.GetHeight();

    // Setup inner scrolling range
    // FIXME: This ideally should be done earlier, in BeginTable() SetNextWindowContentSize call, just like writing to inner_window->DC.CursorMaxPos.y,
    // but since the later is likely to be impossible to do we'd rather update both axises together.
    if (table->Flags & ImGuiTableFlags_ScrollX)
    {
        const float outer_padding_for_border = (table->Flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
        float max_pos_x = table->InnerWindow->DC.CursorMaxPos.x;
        if (table->RightMostEnabledColumn != -1)
            max_pos_x = ImMax(max_pos_x, table->Columns[table->RightMostEnabledColumn].WorkMaxX + table->CellPaddingX + table->OuterPaddingX - outer_padding_for_border);
        if (table->ResizedColumn != -1)
            max_pos_x = ImMax(max_pos_x, table->ResizeLockMinContentsX2);
        table->InnerWindow->DC.CursorMaxPos.x = max_pos_x;
    }

    // Pop clipping rect
    if (!(flags & ImGuiTableFlags_NoClip))
        inner_window->DrawList->PopClipRect();
    inner_window->ClipRect = inner_window->DrawList->_ClipRectStack.back();

    // Draw borders
    if ((flags & ImGuiTableFlags_Borders) != 0)
        TableDrawBorders(table);

#if 0
    // Strip out dummy channel draw calls
    // We have no way to prevent user submitting direct ImDrawList calls into a hidden column (but ImGui:: calls will be clipped out)
    // Pros: remove draw calls which will have no effect. since they'll have zero-size cliprect they may be early out anyway.
    // Cons: making it harder for users watching metrics/debugger to spot the wasted vertices.
    if (table->DummyDrawChannel != (ImGuiTableColumnIdx)-1)
    {
        ImDrawChannel* dummy_channel = &table->DrawSplitter._Channels[table->DummyDrawChannel];
        dummy_channel->_CmdBuffer.resize(0);
        dummy_channel->_IdxBuffer.resize(0);
    }
#endif

    // Flatten channels and merge draw calls
    table->DrawSplitter.SetCurrentChannel(inner_window->DrawList, 0);
    if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
        TableMergeDrawChannels(table);
    table->DrawSplitter.Merge(inner_window->DrawList);

    // Update ColumnsAutoFitWidth to get us ahead for host using our size to auto-resize without waiting for next BeginTable()
    const float width_spacings = (table->OuterPaddingX * 2.0f) + (table->CellSpacingX1 + table->CellSpacingX2) * (table->ColumnsEnabledCount - 1);
    table->ColumnsAutoFitWidth = width_spacings + (table->CellPaddingX * 2.0f) * table->ColumnsEnabledCount;
    for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        if (table->EnabledMaskByIndex & ((ImU64)1 << column_n))
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            if ((column->Flags & ImGuiTableColumnFlags_WidthFixed) && !(column->Flags & ImGuiTableColumnFlags_NoResize))
                table->ColumnsAutoFitWidth += column->WidthRequest;
            else
                table->ColumnsAutoFitWidth += TableGetColumnWidthAuto(table, column);
        }

    // Update scroll
    if ((table->Flags & ImGuiTableFlags_ScrollX) == 0 && inner_window != outer_window)
    {
        inner_window->Scroll.x = 0.0f;
    }
    else if (table->LastResizedColumn != -1 && table->ResizedColumn == -1 && inner_window->ScrollbarX && table->InstanceInteracted == table->InstanceCurrent)
    {
        // When releasing a column being resized, scroll to keep the resulting column in sight
        const float neighbor_width_to_keep_visible = table->MinColumnWidth + table->CellPaddingX * 2.0f;
        ImGuiTableColumn* column = &table->Columns[table->LastResizedColumn];
        if (column->MaxX < table->InnerClipRect.Min.x)
            SetScrollFromPosX(inner_window, column->MaxX - inner_window->Pos.x - neighbor_width_to_keep_visible, 1.0f);
        else if (column->MaxX > table->InnerClipRect.Max.x)
            SetScrollFromPosX(inner_window, column->MaxX - inner_window->Pos.x + neighbor_width_to_keep_visible, 1.0f);
    }

    // Apply resizing/dragging at the end of the frame
    if (table->ResizedColumn != -1 && table->InstanceCurrent == table->InstanceInteracted)
    {
        ImGuiTableColumn* column = &table->Columns[table->ResizedColumn];
        const float new_x2 = (g.IO.MousePos.x - g.ActiveIdClickOffset.x + TABLE_RESIZE_SEPARATOR_HALF_THICKNESS);
        const float new_width = ImFloor(new_x2 - column->MinX - table->CellSpacingX1 - table->CellPaddingX * 2.0f);
        table->ResizedColumnNextWidth = new_width;
    }

    // Pop from id stack
    IM_ASSERT_USER_ERROR(inner_window->IDStack.back() == table->ID + table->InstanceCurrent, "Mismatching PushID/PopID!");
    IM_ASSERT_USER_ERROR(outer_window->DC.ItemWidthStack.Size >= table->HostBackupItemWidthStackSize, "Too many PopItemWidth!");
    PopID();

    // Restore window data that we modified
    const ImVec2 backup_outer_max_pos = outer_window->DC.CursorMaxPos;
    inner_window->WorkRect = table->HostBackupWorkRect;
    inner_window->ParentWorkRect = table->HostBackupParentWorkRect;
    inner_window->SkipItems = table->HostSkipItems;
    outer_window->DC.CursorPos = table->OuterRect.Min;
    outer_window->DC.ItemWidth = table->HostBackupItemWidth;
    outer_window->DC.ItemWidthStack.Size = table->HostBackupItemWidthStackSize;
    outer_window->DC.ColumnsOffset = table->HostBackupColumnsOffset;

    // Layout in outer window
    // (FIXME: To allow auto-fit and allow desirable effect of SameLine() we dissociate 'used' vs 'ideal' size by overriding
    // CursorPosPrevLine and CursorMaxPos manually. That should be a more general layout feature, see same problem e.g. #3414)
    if (inner_window != outer_window)
    {
        EndChild();
    }
    else
    {
        ItemSize(table->OuterRect.GetSize());
        ItemAdd(table->OuterRect, 0);
    }

    // Override declared contents width/height to enable auto-resize while not needlessly adding a scrollbar
    if (table->Flags & ImGuiTableFlags_NoHostExtendX)
    {
        // FIXME-TABLE: Could we remove this section?
        // ColumnsAutoFitWidth may be one frame ahead here since for Fixed+NoResize is calculated from latest contents
        IM_ASSERT((table->Flags & ImGuiTableFlags_ScrollX) == 0);
        outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth);
    }
    else if (table->UserOuterSize.x <= 0.0f)
    {
        const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollX) ? inner_window->ScrollbarSizes.x : 0.0f;
        outer_window->DC.IdealMaxPos.x = ImMax(outer_window->DC.IdealMaxPos.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth + decoration_size - table->UserOuterSize.x);
        outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, ImMin(table->OuterRect.Max.x, table->OuterRect.Min.x + table->ColumnsAutoFitWidth));
    }
    else
    {
        outer_window->DC.CursorMaxPos.x = ImMax(backup_outer_max_pos.x, table->OuterRect.Max.x);
    }
    if (table->UserOuterSize.y <= 0.0f)
    {
        const float decoration_size = (table->Flags & ImGuiTableFlags_ScrollY) ? inner_window->ScrollbarSizes.y : 0.0f;
        outer_window->DC.IdealMaxPos.y = ImMax(outer_window->DC.IdealMaxPos.y, inner_content_max_y + decoration_size - table->UserOuterSize.y);
        outer_window->DC.CursorMaxPos.y = ImMax(backup_outer_max_pos.y, ImMin(table->OuterRect.Max.y, inner_content_max_y));
    }
    else
    {
        // OuterRect.Max.y may already have been pushed downward from the initial value (unless ImGuiTableFlags_NoHostExtendY is set)
        outer_window->DC.CursorMaxPos.y = ImMax(backup_outer_max_pos.y, table->OuterRect.Max.y);
    }

    // Save settings
    if (table->IsSettingsDirty)
        TableSaveSettings(table);
    table->IsInitializing = false;

    // Clear or restore current table, if any
    IM_ASSERT(g.CurrentWindow == outer_window && g.CurrentTable == table);
    g.CurrentTableStack.pop_back();
    g.CurrentTable = g.CurrentTableStack.Size ? g.Tables.GetByIndex(g.CurrentTableStack.back().Index) : NULL;
    outer_window->DC.CurrentTableIdx = g.CurrentTable ? g.Tables.GetIndex(g.CurrentTable) : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x72ad4(%rip), %rax     # 0xfbcd0
movq (%rax), %rbx
movq 0x20a8(%rbx), %r14
testq %r14, %r14
je 0x89a3f
cmpb $0x0, 0x248(%r14)
jne 0x89221
movq %r14, %rdi
callq 0x87673
movq 0x1d0(%r14), %r13
cmpq 0x1ae0(%rbx), %r13
jne 0x89a5e
movl 0x4(%r14), %r12d
movq 0x1c8(%r14), %r15
cmpq %r13, %r15
je 0x89252
cmpq 0x388(%r13), %r15
jne 0x89b2f
cmpb $0x1, 0x249(%r14)
jne 0x89264
movq %r14, %rdi
callq 0x89b8c
testb $0x20, %r12b
je 0x89298
cmpb $-0x1, 0x234(%r14)
je 0x89298
callq 0x51b4b
testb %al, %al
jne 0x89298
movl $0x1, %edi
callq 0x516d9
testb %al, %al
je 0x89298
movsbl 0x234(%r14), %edi
callq 0x8a23f
movq 0x19c(%r14), %rax
movq %rax, 0x108(%r13)
movq 0x1a4(%r14), %rax
movq %rax, 0x100(%r13)
movq 0x1ac(%r14), %rax
movq %rax, 0xf0(%r13)
movss 0x80(%r14), %xmm2
ucomiss 0xdc(%r13), %xmm2
jne 0x89a7d
jp 0x89a7d
cmpq %r13, %r15
je 0x892ef
movss %xmm2, 0xf4(%r13)
jmp 0x89322
btl $0x11, %r12d
jb 0x89322
movss 0xf8(%r14), %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0x108(%r14)
movss %xmm1, 0xf8(%r14)
movaps %xmm2, -0x70(%rbp)
movss 0x118(%r14), %xmm0
movss 0xf8(%r14), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0x118(%r14)
subss 0xf0(%r14), %xmm1
movss %xmm1, 0xcc(%r14)
movl 0x4(%r14), %ecx
btl $0x18, %ecx
jae 0x89418
movq 0x1d0(%r14), %rax
movss 0xf0(%rax), %xmm0
movsbq 0x23e(%r14), %rdx
cmpq $-0x1, %rdx
je 0x893ec
testb %dl, %dl
js 0x89a01
imulq $0x68, %rdx, %rdx
addq 0x10(%r14), %rdx
cmpq 0x18(%r14), %rdx
jae 0x89a01
btl $0xa, %ecx
xorps %xmm1, %xmm1
jae 0x893ba
movss 0x2bc2a(%rip), %xmm1    # 0xb4fe4
movss 0x38(%rdx), %xmm2
addss 0xbc(%r14), %xmm2
addss 0xb8(%r14), %xmm2
subss %xmm1, %xmm2
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
movaps %xmm1, %xmm3
andnps %xmm2, %xmm3
andps %xmm0, %xmm1
orps %xmm3, %xmm1
movaps %xmm1, %xmm0
cmpb $-0x1, 0x237(%r14)
je 0x89410
movss 0xe4(%r14), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm2, %xmm0
movss %xmm0, 0xf0(%rax)
btl $0x14, %r12d
jb 0x8942b
movq 0x2b8(%r13), %rdi
callq 0x75d0e
movq 0x2b8(%r13), %rsi
movslq 0x58(%rsi), %rax
testq %rax, %rax
jle 0x89a9c
movq %r15, -0x60(%rbp)
movq 0x60(%rsi), %rcx
shlq $0x4, %rax
movups -0x10(%rcx,%rax), %xmm0
movups %xmm0, 0x258(%r13)
testl $0x780, %r12d           # imm = 0x780
je 0x89470
movq %r14, %rdi
callq 0x8a2c8
movq 0x2b8(%r13), %rsi
movq %rbx, -0x30(%rbp)
leaq 0x1e8(%r14), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x7a998
testb $0x10, 0x6(%r14)
jne 0x89494
movq %r14, %rdi
callq 0x8a753
movq %r13, -0x58(%rbp)
movq 0x2b8(%r13), %rsi
movq %r12, %rdi
callq 0x7a55a
movss 0xc4(%r14), %xmm0
movsbl 0x231(%r14), %eax
leal -0x1(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
addss 0xc8(%r14), %xmm0
mulss %xmm0, %xmm1
movss 0xb8(%r14), %xmm0
movss 0xbc(%r14), %xmm2
addss %xmm0, %xmm0
addss %xmm1, %xmm0
addss %xmm2, %xmm2
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xdc(%r14)
movslq 0x6c(%r14), %r12
testq %r12, %r12
jle 0x8957e
movq 0x48(%r14), %rbx
movl $0x10, %r13d
xorl %r15d, %r15d
movss %xmm2, -0x40(%rbp)
btq %r15, %rbx
jae 0x89572
movq 0x10(%r14), %rax
leaq (%rax,%r13), %rsi
addq $-0x10, %rsi
cmpq 0x18(%r14), %rsi
jae 0x89a01
movl (%rsi), %ecx
andl $0x18, %ecx
cmpl $0x8, %ecx
jne 0x8954e
movss (%rax,%r13), %xmm0
jmp 0x89565
movq %r14, %rdi
movss %xmm1, -0x50(%rbp)
callq 0x8873f
movss -0x50(%rbp), %xmm1
movss -0x40(%rbp), %xmm2
addss %xmm0, %xmm1
movss %xmm1, 0xdc(%r14)
incq %r15
addq $0x68, %r13
cmpq %r15, %r12
jne 0x89520
movq -0x60(%rbp), %r15
movq -0x58(%rbp), %r13
cmpq %r13, %r15
je 0x895a7
movl $0x1000000, %eax        # imm = 0x1000000
andl 0x4(%r14), %eax
jne 0x895a7
movl $0x0, 0x5c(%r13)
movq -0x30(%rbp), %rbx
jmp 0x89659
movsbq 0x238(%r14), %rax
cmpq $-0x1, %rax
movq -0x30(%rbp), %rbx
je 0x89659
cmpb $-0x1, 0x237(%r14)
jne 0x89659
cmpb $0x1, 0x8c(%r13)
jne 0x89659
movzwl 0x7a(%r14), %ecx
cmpw 0x78(%r14), %cx
jne 0x89659
testb %al, %al
js 0x89a01
imulq $0x68, %rax, %rax
addq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x89a01
addss 0xb4(%r14), %xmm2
movss 0xc(%rax), %xmm0
movss 0x11c(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x89632
subss 0x10(%r13), %xmm0
subss %xmm2, %xmm0
movss 0x2b9b7(%rip), %xmm1    # 0xb4fe4
movq %r13, %rdi
jmp 0x89654
ucomiss 0x124(%r14), %xmm0
jbe 0x89659
subss 0x10(%r13), %xmm0
addss %xmm0, %xmm2
movss 0x2b996(%rip), %xmm1    # 0xb4fe4
movq %r13, %rdi
movaps %xmm2, %xmm0
callq 0x567c6
movsbq 0x237(%r14), %rax
cmpq $-0x1, %rax
je 0x896d4
movzwl 0x78(%r14), %ecx
cmpw 0x7a(%r14), %cx
jne 0x896d4
testb %al, %al
js 0x89a01
imulq $0x68, %rax, %rax
addq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x89a01
movss 0x128(%rbx), %xmm0
subss 0x1b58(%rbx), %xmm0
addss 0x2c1bf(%rip), %xmm0    # 0xb5864
subss 0x8(%rax), %xmm0
subss 0xc4(%r14), %xmm0
movss 0xbc(%r14), %xmm1
addss %xmm1, %xmm1
subss %xmm1, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xe0(%r14)
movslq 0xc8(%r13), %rax
testq %rax, %rax
jle 0x89ab3
movq 0xd0(%r13), %rcx
movswl 0x78(%r14), %edx
addl (%r14), %edx
cmpl %edx, -0x4(%rcx,%rax,4)
jne 0x89ad2
movl 0x1d8(%r15), %eax
cmpl 0x1c4(%r14), %eax
jl 0x89af1
callq 0x55082
movss 0xf0(%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
movss 0xf4(%r15), %xmm0
movaps %xmm0, -0x50(%rbp)
movups 0x16c(%r14), %xmm0
movups %xmm0, 0x238(%r13)
movups 0x17c(%r14), %xmm0
movups %xmm0, 0x248(%r13)
movb 0x256(%r14), %al
movb %al, 0x93(%r13)
movq 0xec(%r14), %rax
movq %rax, 0xd8(%r15)
movss 0x1c0(%r14), %xmm0
movss %xmm0, 0x1d0(%r15)
movl 0x1c4(%r14), %eax
movl %eax, 0x1d8(%r15)
movl 0x1bc(%r14), %eax
movl %eax, 0x11c(%r15)
cmpq %r13, %r15
je 0x897a6
callq 0x52109
jmp 0x897f4
movss 0xf4(%r14), %xmm0
movss 0xf8(%r14), %xmm1
subss 0xec(%r14), %xmm0
subss 0xf0(%r14), %xmm1
leaq 0xec(%r14), %r12
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x78(%rbp), %rdi
movlps %xmm0, (%rdi)
movss 0x2b7ed(%rip), %xmm0    # 0xb4fd0
callq 0x52315
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x524a8
movl 0x4(%r14), %eax
btl $0x10, %eax
jb 0x8981a
movss 0x1b4(%r14), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x89838
movss 0xf4(%r14), %xmm0
jmp 0x89894
btl $0x18, %eax
jb 0x89b6d
movss 0xec(%r14), %xmm0
addss 0xdc(%r14), %xmm0
jmp 0x89894
btl $0x18, %eax
jae 0x89847
movss 0x84(%r13), %xmm0
movss 0xec(%r14), %xmm2
addss 0xdc(%r14), %xmm2
movss 0xf8(%r15), %xmm3
addss %xmm2, %xmm0
subss %xmm1, %xmm0
movaps %xmm0, %xmm1
cmpless %xmm3, %xmm1
movaps %xmm1, %xmm4
andnps %xmm0, %xmm4
andps %xmm3, %xmm1
orps %xmm4, %xmm1
movss %xmm1, 0xf8(%r15)
movss 0xf4(%r14), %xmm0
minss %xmm2, %xmm0
movaps %xmm0, %xmm1
movaps -0x40(%rbp), %xmm2
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm2, %xmm1
movss %xmm1, 0xf0(%r15)
movss 0x1b8(%r14), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x898ce
movss 0xf8(%r14), %xmm0
jmp 0x8991c
btl $0x19, %eax
jae 0x898dd
movss 0x88(%r13), %xmm0
movss 0xfc(%r15), %xmm2
movaps -0x70(%rbp), %xmm4
addss %xmm4, %xmm0
subss %xmm1, %xmm0
movaps %xmm0, %xmm1
cmpless %xmm2, %xmm1
movaps %xmm1, %xmm3
andnps %xmm0, %xmm3
andps %xmm2, %xmm1
orps %xmm3, %xmm1
movss %xmm1, 0xfc(%r15)
movss 0xf8(%r14), %xmm0
minss %xmm4, %xmm0
movaps %xmm0, %xmm1
movaps -0x50(%rbp), %xmm2
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm2, %xmm1
movss %xmm1, 0xf4(%r15)
cmpb $0x1, 0x24f(%r14)
jne 0x8994c
movq %r14, %rdi
callq 0x8af65
movb $0x0, 0x24a(%r14)
cmpq %r15, 0x1ae0(%rbx)
jne 0x89a20
cmpq %r14, 0x20a8(%rbx)
jne 0x89a20
movl 0x20d8(%rbx), %eax
testl %eax, %eax
jle 0x89b10
decl %eax
movl %eax, 0x20d8(%rbx)
je 0x899db
movq 0x20e0(%rbx), %rcx
movl %eax, %eax
shlq $0x4, %rax
movslq -0x8(%rcx,%rax), %rax
testq %rax, %rax
js 0x89b4e
cmpl %eax, 0x20b0(%rbx)
jle 0x89b4e
movq 0x20b8(%rbx), %rcx
imulq $0x258, %rax, %rsi      # imm = 0x258
addq %rcx, %rsi
movq %rsi, 0x20a8(%rbx)
testq %rcx, %rcx
je 0x899e6
addq $0x20b0, %rbx           # imm = 0x20B0
movq %rbx, %rdi
callq 0x8fa00
jmp 0x899eb
movq $0x0, 0x20a8(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x1b8(%r15)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30cb0(%rip), %rdi     # 0xba6b8
leaq 0x2fc30(%rip), %rsi     # 0xb963f
leaq 0x30cbb(%rip), %rcx     # 0xba6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
leaq 0x45998(%rip), %rdi     # 0xcf3bf
leaq 0x4545c(%rip), %rsi     # 0xcee8a
leaq 0x457dc(%rip), %rcx     # 0xcf211
movl $0x53f, %edx            # imm = 0x53F
callq 0xc140
leaq 0x45783(%rip), %rdi     # 0xcf1c9
leaq 0x4543d(%rip), %rsi     # 0xcee8a
leaq 0x457bd(%rip), %rcx     # 0xcf211
movl $0x489, %edx            # imm = 0x489
callq 0xc140
leaq 0x457c3(%rip), %rdi     # 0xcf228
leaq 0x4541e(%rip), %rsi     # 0xcee8a
leaq 0x4579e(%rip), %rcx     # 0xcf211
movl $0x497, %edx            # imm = 0x497
callq 0xc140
leaq 0x4580f(%rip), %rdi     # 0xcf293
leaq 0x453ff(%rip), %rsi     # 0xcee8a
leaq 0x4577f(%rip), %rcx     # 0xcf211
movl $0x4a7, %edx            # imm = 0x4A7
callq 0xc140
leaq 0x43f07(%rip), %rdi     # 0xcd9aa
leaq 0x2fbe1(%rip), %rsi     # 0xb968b
leaq 0x31070(%rip), %rcx     # 0xbab21
jmp 0x89ac8
leaq 0x43ef0(%rip), %rdi     # 0xcd9aa
leaq 0x2fbca(%rip), %rsi     # 0xb968b
leaq 0x30f30(%rip), %rcx     # 0xba9f8
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x457ea(%rip), %rdi     # 0xcf2c3
leaq 0x453aa(%rip), %rsi     # 0xcee8a
leaq 0x4572a(%rip), %rcx     # 0xcf211
movl $0x500, %edx            # imm = 0x500
callq 0xc140
leaq 0x4582f(%rip), %rdi     # 0xcf327
leaq 0x4538b(%rip), %rsi     # 0xcee8a
leaq 0x4570b(%rip), %rcx     # 0xcf211
movl $0x501, %edx            # imm = 0x501
callq 0xc140
leaq 0x43e93(%rip), %rdi     # 0xcd9aa
leaq 0x2fb6d(%rip), %rsi     # 0xb968b
leaq 0x46f4e(%rip), %rcx     # 0xd0a73
movl $0x672, %edx            # imm = 0x672
callq 0xc140
leaq 0x45712(%rip), %rdi     # 0xcf248
leaq 0x4534d(%rip), %rsi     # 0xcee8a
leaq 0x456cd(%rip), %rcx     # 0xcf211
movl $0x498, %edx            # imm = 0x498
callq 0xc140
leaq 0x2fb23(%rip), %rdi     # 0xb9678
leaq 0x2fb2f(%rip), %rsi     # 0xb968b
leaq 0x30eca(%rip), %rcx     # 0xbaa2d
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
leaq 0x4581d(%rip), %rdi     # 0xcf391
leaq 0x4530f(%rip), %rsi     # 0xcee8a
leaq 0x4568f(%rip), %rcx     # 0xcf211
movl $0x520, %edx            # imm = 0x520
callq 0xc140