// File: /workspace/github_cpp_makefile_star2_O1/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 0x72e8f(%rip), %rax     # 0xfdcd0
movq (%rax), %rbx
movq 0x20a8(%rbx), %r14
testq %r14, %r14
je 0x8b680
cmpb $0x0, 0x248(%r14)
jne 0x8ae66
movq %r14, %rdi
callq 0x89339
movq 0x1d0(%r14), %r13
cmpq 0x1ae0(%rbx), %r13
jne 0x8b69f
movl 0x4(%r14), %r12d
movq 0x1c8(%r14), %r15
cmpq %r13, %r15
je 0x8ae97
cmpq 0x388(%r13), %r15
jne 0x8b76e
cmpb $0x1, 0x249(%r14)
jne 0x8aea9
movq %r14, %rdi
callq 0x8b7ea
testb $0x20, %r12b
je 0x8aedd
cmpb $-0x1, 0x234(%r14)
je 0x8aedd
callq 0x52b47
testb %al, %al
jne 0x8aedd
movl $0x1, %edi
callq 0x526c7
testb %al, %al
je 0x8aedd
movsbl 0x234(%r14), %edi
callq 0x8befe
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 0x8b6be
jp 0x8b6be
cmpq %r13, %r15
je 0x8af34
movss %xmm2, 0xf4(%r13)
jmp 0x8af67
btl $0x11, %r12d
jb 0x8af67
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 0x8b05d
movq 0x1d0(%r14), %rax
movss 0xf0(%rax), %xmm0
movsbq 0x23e(%r14), %rdx
cmpq $-0x1, %rdx
je 0x8b031
testb %dl, %dl
js 0x8b642
imulq $0x68, %rdx, %rdx
addq 0x10(%r14), %rdx
cmpq 0x18(%r14), %rdx
jae 0x8b642
btl $0xa, %ecx
xorps %xmm1, %xmm1
jae 0x8afff
movss 0x2bfe5(%rip), %xmm1    # 0xb6fe4
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 0x8b055
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 0x8b070
movq 0x2b8(%r13), %rdi
callq 0x772e8
movq 0x2b8(%r13), %rcx
movslq 0x58(%rcx), %rax
testq %rax, %rax
jle 0x8b6dd
movq %r15, -0x60(%rbp)
movq 0x60(%rcx), %rcx
shlq $0x4, %rax
movups -0x10(%rcx,%rax), %xmm0
movups %xmm0, 0x258(%r13)
testl $0x780, %r12d           # imm = 0x780
je 0x8b0ae
movq %r14, %rdi
callq 0x8bf87
movq %rbx, -0x40(%rbp)
leaq 0x1e8(%r14), %r12
movq 0x2b8(%r13), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x7c2ae
testb $0x10, 0x6(%r14)
jne 0x8b0d9
movq %r14, %rdi
callq 0x8c415
movq %r13, -0x58(%rbp)
movq 0x2b8(%r13), %rsi
movq %r12, %rdi
callq 0x7be68
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 0x8b1be
movq 0x48(%r14), %rbx
movl $0x10, %r13d
xorl %r15d, %r15d
movss %xmm2, -0x50(%rbp)
btq %r15, %rbx
jae 0x8b1b2
movq 0x10(%r14), %rax
leaq (%rax,%r13), %rsi
addq $-0x10, %rsi
cmpq 0x18(%r14), %rsi
jae 0x8b642
movl (%rsi), %ecx
andl $0x18, %ecx
cmpl $0x8, %ecx
jne 0x8b193
movss (%rax,%r13), %xmm0
jmp 0x8b1a0
movq %r14, %rdi
callq 0x8a38a
movss -0x50(%rbp), %xmm2
addss 0xdc(%r14), %xmm0
movss %xmm0, 0xdc(%r14)
incq %r15
addq $0x68, %r13
cmpq %r15, %r12
jne 0x8b165
movq -0x60(%rbp), %r15
movq -0x58(%rbp), %r13
cmpq %r13, %r15
je 0x8b1e7
movl $0x1000000, %eax        # imm = 0x1000000
andl 0x4(%r14), %eax
jne 0x8b1e7
movl $0x0, 0x5c(%r13)
movq -0x40(%rbp), %rbx
jmp 0x8b299
movsbq 0x238(%r14), %rax
cmpq $-0x1, %rax
movq -0x40(%rbp), %rbx
je 0x8b299
cmpb $-0x1, 0x237(%r14)
jne 0x8b299
cmpb $0x1, 0x8c(%r13)
jne 0x8b299
movzwl 0x7a(%r14), %ecx
cmpw 0x78(%r14), %cx
jne 0x8b299
testb %al, %al
js 0x8b642
imulq $0x68, %rax, %rax
addq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x8b642
addss 0xb4(%r14), %xmm2
movss 0xc(%rax), %xmm0
movss 0x11c(%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x8b272
subss 0x10(%r13), %xmm0
subss %xmm2, %xmm0
movss 0x2bd77(%rip), %xmm1    # 0xb6fe4
movq %r13, %rdi
jmp 0x8b294
ucomiss 0x124(%r14), %xmm0
jbe 0x8b299
subss 0x10(%r13), %xmm0
addss %xmm0, %xmm2
movss 0x2bd56(%rip), %xmm1    # 0xb6fe4
movq %r13, %rdi
movaps %xmm2, %xmm0
callq 0x578db
movsbq 0x237(%r14), %rax
cmpq $-0x1, %rax
je 0x8b314
movzwl 0x78(%r14), %ecx
cmpw 0x7a(%r14), %cx
jne 0x8b314
testb %al, %al
js 0x8b642
imulq $0x68, %rax, %rax
addq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x8b642
movss 0x128(%rbx), %xmm0
subss 0x1b58(%rbx), %xmm0
addss 0x2c57f(%rip), %xmm0    # 0xb7864
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 0x8b6f7
movq 0xd0(%r13), %rcx
movswl 0x78(%r14), %edx
addl (%r14), %edx
cmpl %edx, -0x4(%rcx,%rax,4)
jne 0x8b711
movl 0x1d8(%r15), %eax
cmpl 0x1c4(%r14), %eax
jl 0x8b730
callq 0x56188
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 0x8b3e6
callq 0x53104
jmp 0x8b434
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 0x2bbad(%rip), %xmm0    # 0xb6fd0
callq 0x532de
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5346f
movl 0x4(%r14), %eax
btl $0x10, %eax
jb 0x8b45a
movss 0x1b4(%r14), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x8b478
movss 0xf4(%r14), %xmm0
jmp 0x8b4d4
btl $0x18, %eax
jb 0x8b7cb
movss 0xec(%r14), %xmm0
addss 0xdc(%r14), %xmm0
jmp 0x8b4d4
btl $0x18, %eax
jae 0x8b487
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 0x8b50e
movss 0xf8(%r14), %xmm0
jmp 0x8b55c
btl $0x19, %eax
jae 0x8b51d
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 0x8b58c
movq %r14, %rdi
callq 0x8cc1b
movb $0x0, 0x24a(%r14)
cmpq %r15, 0x1ae0(%rbx)
jne 0x8b661
cmpq %r14, 0x20a8(%rbx)
jne 0x8b661
movl 0x20d8(%rbx), %eax
testl %eax, %eax
jle 0x8b74f
movl %eax, %ecx
decl %ecx
movl %ecx, 0x20d8(%rbx)
je 0x8b608
cmpl $0x1, %eax
je 0x8b78d
movq 0x20e0(%rbx), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
movslq -0x8(%rax,%rcx), %rax
testq %rax, %rax
js 0x8b7ac
cmpl %eax, 0x20b0(%rbx)
jle 0x8b7ac
imulq $0x258, %rax, %rsi      # imm = 0x258
addq 0x20b8(%rbx), %rsi
jmp 0x8b60a
xorl %esi, %esi
movq %rsi, 0x20a8(%rbx)
testq %rsi, %rsi
je 0x8b627
addq $0x20b0, %rbx           # imm = 0x20B0
movq %rbx, %rdi
callq 0x9171a
jmp 0x8b62c
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 0x3106f(%rip), %rdi     # 0xbc6b8
leaq 0x2ffef(%rip), %rsi     # 0xbb63f
leaq 0x3107a(%rip), %rcx     # 0xbc6d1
movl $0x20e, %edx            # imm = 0x20E
callq 0xc140
leaq 0x45d87(%rip), %rdi     # 0xd13ef
leaq 0x4584b(%rip), %rsi     # 0xd0eba
leaq 0x45bcb(%rip), %rcx     # 0xd1241
movl $0x53f, %edx            # imm = 0x53F
callq 0xc140
leaq 0x45b72(%rip), %rdi     # 0xd11f9
leaq 0x4582c(%rip), %rsi     # 0xd0eba
leaq 0x45bac(%rip), %rcx     # 0xd1241
movl $0x489, %edx            # imm = 0x489
callq 0xc140
leaq 0x45bb2(%rip), %rdi     # 0xd1258
leaq 0x4580d(%rip), %rsi     # 0xd0eba
leaq 0x45b8d(%rip), %rcx     # 0xd1241
movl $0x497, %edx            # imm = 0x497
callq 0xc140
leaq 0x45bfe(%rip), %rdi     # 0xd12c3
leaq 0x457ee(%rip), %rsi     # 0xd0eba
leaq 0x45b6e(%rip), %rcx     # 0xd1241
movl $0x4a7, %edx            # imm = 0x4A7
callq 0xc140
leaq 0x442f6(%rip), %rdi     # 0xcf9da
leaq 0x2ffa0(%rip), %rsi     # 0xbb68b
leaq 0x3142f(%rip), %rcx     # 0xbcb21
jmp 0x8b7a2
leaq 0x442dc(%rip), %rdi     # 0xcf9da
leaq 0x2ff86(%rip), %rsi     # 0xbb68b
leaq 0x312ec(%rip), %rcx     # 0xbc9f8
jmp 0x8b7a2
leaq 0x45bdb(%rip), %rdi     # 0xd12f3
leaq 0x4579b(%rip), %rsi     # 0xd0eba
leaq 0x45b1b(%rip), %rcx     # 0xd1241
movl $0x500, %edx            # imm = 0x500
callq 0xc140
leaq 0x45c20(%rip), %rdi     # 0xd1357
leaq 0x4577c(%rip), %rsi     # 0xd0eba
leaq 0x45afc(%rip), %rcx     # 0xd1241
movl $0x501, %edx            # imm = 0x501
callq 0xc140
leaq 0x44284(%rip), %rdi     # 0xcf9da
leaq 0x2ff2e(%rip), %rsi     # 0xbb68b
leaq 0x47402(%rip), %rcx     # 0xd2b66
movl $0x672, %edx            # imm = 0x672
callq 0xc140
leaq 0x45b03(%rip), %rdi     # 0xd1278
leaq 0x4573e(%rip), %rsi     # 0xd0eba
leaq 0x45abe(%rip), %rcx     # 0xd1241
movl $0x498, %edx            # imm = 0x498
callq 0xc140
leaq 0x44246(%rip), %rdi     # 0xcf9da
leaq 0x2fef0(%rip), %rsi     # 0xbb68b
leaq 0x47405(%rip), %rcx     # 0xd2ba7
movl $0x666, %edx            # imm = 0x666
callq 0xc140
leaq 0x2fec5(%rip), %rdi     # 0xbb678
leaq 0x2fed1(%rip), %rsi     # 0xbb68b
leaq 0x3126c(%rip), %rcx     # 0xbca2d
movl $0x65c, %edx            # imm = 0x65C
callq 0xc140
leaq 0x45bef(%rip), %rdi     # 0xd13c1
leaq 0x456e1(%rip), %rsi     # 0xd0eba
leaq 0x45a61(%rip), %rcx     # 0xd1241
movl $0x520, %edx            # imm = 0x520
callq 0xc140