// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::BeginTableEx(char const*, unsigned int, int, int, ImVec2 const&, float)
bool    ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, const ImVec2& outer_size, float inner_width)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* outer_window = GetCurrentWindow();
    if (outer_window->SkipItems) // Consistent with other tables + beneficial side effect that assert on miscalling EndTable() will be more visible.
        return false;

    // Sanity checks
    IM_ASSERT(columns_count > 0 && columns_count <= IMGUI_TABLE_MAX_COLUMNS && "Only 1..64 columns allowed!");
    if (flags & ImGuiTableFlags_ScrollX)
        IM_ASSERT(inner_width >= 0.0f);

    // If an outer size is specified ahead we will be able to early out when not visible. Exact clipping rules may evolve.
    const bool use_child_window = (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) != 0;
    const ImVec2 avail_size = GetContentRegionAvail();
    ImVec2 actual_outer_size = CalcItemSize(outer_size, ImMax(avail_size.x, 1.0f), use_child_window ? ImMax(avail_size.y, 1.0f) : 0.0f);
    ImRect outer_rect(outer_window->DC.CursorPos, outer_window->DC.CursorPos + actual_outer_size);
    if (use_child_window && IsClippedEx(outer_rect, 0, false))
    {
        ItemSize(outer_rect);
        return false;
    }

    // Acquire storage for the table
    ImGuiTable* table = g.Tables.GetOrAddByKey(id);
    const int instance_no = (table->LastFrameActive != g.FrameCount) ? 0 : table->InstanceCurrent + 1;
    const ImGuiID instance_id = id + instance_no;
    const ImGuiTableFlags table_last_flags = table->Flags;
    if (instance_no > 0)
        IM_ASSERT(table->ColumnsCount == columns_count && "BeginTable(): Cannot change columns count mid-frame while preserving same ID");

    // Fix flags
    table->IsDefaultSizingPolicy = (flags & ImGuiTableFlags_SizingMask_) == 0;
    flags = TableFixFlags(flags, outer_window);

    // Initialize
    table->ID = id;
    table->Flags = flags;
    table->InstanceCurrent = (ImS16)instance_no;
    table->LastFrameActive = g.FrameCount;
    table->OuterWindow = table->InnerWindow = outer_window;
    table->ColumnsCount = columns_count;
    table->IsLayoutLocked = false;
    table->InnerWidth = inner_width;
    table->UserOuterSize = outer_size;

    // When not using a child window, WorkRect.Max will grow as we append contents.
    if (use_child_window)
    {
        // Ensure no vertical scrollbar appears if we only want horizontal one, to make flag consistent
        // (we have no other way to disable vertical scrollbar of a window while keeping the horizontal one showing)
        ImVec2 override_content_size(FLT_MAX, FLT_MAX);
        if ((flags & ImGuiTableFlags_ScrollX) && !(flags & ImGuiTableFlags_ScrollY))
            override_content_size.y = FLT_MIN;

        // Ensure specified width (when not specified, Stretched columns will act as if the width == OuterWidth and
        // never lead to any scrolling). We don't handle inner_width < 0.0f, we could potentially use it to right-align
        // based on the right side of the child window work rect, which would require knowing ahead if we are going to
        // have decoration taking horizontal spaces (typically a vertical scrollbar).
        if ((flags & ImGuiTableFlags_ScrollX) && inner_width > 0.0f)
            override_content_size.x = inner_width;

        if (override_content_size.x != FLT_MAX || override_content_size.y != FLT_MAX)
            SetNextWindowContentSize(ImVec2(override_content_size.x != FLT_MAX ? override_content_size.x : 0.0f, override_content_size.y != FLT_MAX ? override_content_size.y : 0.0f));

        // Reset scroll if we are reactivating it
        if ((table_last_flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) == 0)
            SetNextWindowScroll(ImVec2(0.0f, 0.0f));

        // Create scrolling region (without border and zero window padding)
        ImGuiWindowFlags child_flags = (flags & ImGuiTableFlags_ScrollX) ? ImGuiWindowFlags_HorizontalScrollbar : ImGuiWindowFlags_None;
        BeginChildEx(name, instance_id, outer_rect.GetSize(), false, child_flags);
        table->InnerWindow = g.CurrentWindow;
        table->WorkRect = table->InnerWindow->WorkRect;
        table->OuterRect = table->InnerWindow->Rect();
        table->InnerRect = table->InnerWindow->InnerRect;
        IM_ASSERT(table->InnerWindow->WindowPadding.x == 0.0f && table->InnerWindow->WindowPadding.y == 0.0f && table->InnerWindow->WindowBorderSize == 0.0f);
    }
    else
    {
        // For non-scrolling tables, WorkRect == OuterRect == InnerRect.
        // But at this point we do NOT have a correct value for .Max.y (unless a height has been explicitly passed in). It will only be updated in EndTable().
        table->WorkRect = table->OuterRect = table->InnerRect = outer_rect;
    }

    // Push a standardized ID for both child-using and not-child-using tables
    PushOverrideID(instance_id);

    // Backup a copy of host window members we will modify
    ImGuiWindow* inner_window = table->InnerWindow;
    table->HostIndentX = inner_window->DC.Indent.x;
    table->HostClipRect = inner_window->ClipRect;
    table->HostSkipItems = inner_window->SkipItems;
    table->HostBackupWorkRect = inner_window->WorkRect;
    table->HostBackupParentWorkRect = inner_window->ParentWorkRect;
    table->HostBackupColumnsOffset = outer_window->DC.ColumnsOffset;
    table->HostBackupPrevLineSize = inner_window->DC.PrevLineSize;
    table->HostBackupCurrLineSize = inner_window->DC.CurrLineSize;
    table->HostBackupCursorMaxPos = inner_window->DC.CursorMaxPos;
    table->HostBackupItemWidth = outer_window->DC.ItemWidth;
    table->HostBackupItemWidthStackSize = outer_window->DC.ItemWidthStack.Size;
    inner_window->DC.PrevLineSize = inner_window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);

    // Padding and Spacing
    // - None               ........Content..... Pad .....Content........
    // - PadOuter           | Pad ..Content..... Pad .....Content.. Pad |
    // - PadInner           ........Content.. Pad | Pad ..Content........
    // - PadOuter+PadInner  | Pad ..Content.. Pad | Pad ..Content.. Pad |
    const bool pad_outer_x = (flags & ImGuiTableFlags_NoPadOuterX) ? false : (flags & ImGuiTableFlags_PadOuterX) ? true : (flags & ImGuiTableFlags_BordersOuterV) != 0;
    const bool pad_inner_x = (flags & ImGuiTableFlags_NoPadInnerX) ? false : true;
    const float inner_spacing_for_border = (flags & ImGuiTableFlags_BordersInnerV) ? TABLE_BORDER_SIZE : 0.0f;
    const float inner_spacing_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) == 0) ? g.Style.CellPadding.x : 0.0f;
    const float inner_padding_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) != 0) ? g.Style.CellPadding.x : 0.0f;
    table->CellSpacingX1 = inner_spacing_explicit + inner_spacing_for_border;
    table->CellSpacingX2 = inner_spacing_explicit;
    table->CellPaddingX = inner_padding_explicit;
    table->CellPaddingY = g.Style.CellPadding.y;

    const float outer_padding_for_border = (flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
    const float outer_padding_explicit = pad_outer_x ? g.Style.CellPadding.x : 0.0f;
    table->OuterPaddingX = (outer_padding_for_border + outer_padding_explicit) - table->CellPaddingX;

    table->CurrentColumn = -1;
    table->CurrentRow = -1;
    table->RowBgColorCounter = 0;
    table->LastRowFlags = ImGuiTableRowFlags_None;
    table->InnerClipRect = (inner_window == outer_window) ? table->WorkRect : inner_window->ClipRect;
    table->InnerClipRect.ClipWith(table->WorkRect);     // We need this to honor inner_width
    table->InnerClipRect.ClipWithFull(table->HostClipRect);
    table->InnerClipRect.Max.y = (flags & ImGuiTableFlags_NoHostExtendY) ? ImMin(table->InnerClipRect.Max.y, inner_window->WorkRect.Max.y) : inner_window->ClipRect.Max.y;

    table->RowPosY1 = table->RowPosY2 = table->WorkRect.Min.y; // This is needed somehow
    table->RowTextBaseline = 0.0f; // This will be cleared again by TableBeginRow()
    table->FreezeRowsRequest = table->FreezeRowsCount = 0; // This will be setup by TableSetupScrollFreeze(), if any
    table->FreezeColumnsRequest = table->FreezeColumnsCount = 0;
    table->IsUnfrozenRows = true;
    table->DeclColumnsCount = 0;

    // Using opaque colors facilitate overlapping elements of the grid
    table->BorderColorStrong = GetColorU32(ImGuiCol_TableBorderStrong);
    table->BorderColorLight = GetColorU32(ImGuiCol_TableBorderLight);

    // Make table current
    const int table_idx = g.Tables.GetIndex(table);
    g.CurrentTableStack.push_back(ImGuiPtrOrIndex(table_idx));
    g.CurrentTable = table;
    outer_window->DC.CurrentTableIdx = table_idx;
    if (inner_window != outer_window) // So EndChild() within the inner window can restore the table properly.
        inner_window->DC.CurrentTableIdx = table_idx;

    if ((table_last_flags & ImGuiTableFlags_Reorderable) && (flags & ImGuiTableFlags_Reorderable) == 0)
        table->IsResetDisplayOrderRequest = true;

    // Mark as used
    if (table_idx >= g.TablesLastTimeActive.Size)
        g.TablesLastTimeActive.resize(table_idx + 1, -1.0f);
    g.TablesLastTimeActive[table_idx] = (float)g.Time;
    table->MemoryCompacted = false;

    // Setup memory buffer (clear data if columns count changed)
    const int stored_size = table->Columns.size();
    if (stored_size != 0 && stored_size != columns_count)
    {
        IM_FREE(table->RawData);
        table->RawData = NULL;
    }
    if (table->RawData == NULL)
    {
        TableBeginInitMemory(table, columns_count);
        table->IsInitializing = table->IsSettingsRequestLoad = true;
    }
    if (table->IsResetAllRequest)
        TableResetSettings(table);
    if (table->IsInitializing)
    {
        // Initialize
        table->SettingsOffset = -1;
        table->IsSortSpecsDirty = true;
        table->InstanceInteracted = -1;
        table->ContextPopupColumn = -1;
        table->ReorderColumn = table->ResizedColumn = table->LastResizedColumn = -1;
        table->AutoFitSingleColumn = -1;
        table->HoveredColumnBody = table->HoveredColumnBorder = -1;
        for (int n = 0; n < columns_count; n++)
        {
            ImGuiTableColumn* column = &table->Columns[n];
            float width_auto = column->WidthAuto;
            *column = ImGuiTableColumn();
            column->WidthAuto = width_auto;
            column->IsPreserveWidthAuto = true; // Preserve WidthAuto when reinitializing a live table: not technically necessary but remove a visible flicker
            column->DisplayOrder = table->DisplayOrderToIndex[n] = (ImGuiTableColumnIdx)n;
            column->IsEnabled = column->IsEnabledNextFrame = true;
        }
    }

    // Load settings
    if (table->IsSettingsRequestLoad)
        TableLoadSettings(table);

    // Handle DPI/font resize
    // This is designed to facilitate DPI changes with the assumption that e.g. style.CellPadding has been scaled as well.
    // It will also react to changing fonts with mixed results. It doesn't need to be perfect but merely provide a decent transition.
    // FIXME-DPI: Provide consistent standards for reference size. Perhaps using g.CurrentDpiScale would be more self explanatory.
    // This is will lead us to non-rounded WidthRequest in columns, which should work but is a poorly tested path.
    const float new_ref_scale_unit = g.FontSize; // g.Font->GetCharAdvance('A') ?
    if (table->RefScale != 0.0f && table->RefScale != new_ref_scale_unit)
    {
        const float scale_factor = new_ref_scale_unit / table->RefScale;
        //IMGUI_DEBUG_LOG("[table] %08X RefScaleUnit %.3f -> %.3f, scaling width by %.3f\n", table->ID, table->RefScaleUnit, new_ref_scale_unit, scale_factor);
        for (int n = 0; n < columns_count; n++)
            table->Columns[n].WidthRequest = table->Columns[n].WidthRequest * scale_factor;
    }
    table->RefScale = new_ref_scale_unit;

    // Disable output until user calls TableNextRow() or TableNextColumn() leading to the TableUpdateLayout() call..
    // This is not strictly necessary but will reduce cases were "out of table" output will be misleading to the user.
    // Because we cannot safely assert in EndTable() when no rows have been created, this seems like our best option.
    inner_window->SkipItems = true;

    // Clear names
    // At this point the ->NameOffset field of each column will be invalid until TableUpdateLayout() or the first call to TableSetupColumn()
    if (table->ColumnsNames.Buf.Size > 0)
        table->ColumnsNames.Buf.resize(0);

    // Apply queued resizing/reordering/hiding requests
    TableBeginApplyRequests(table);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq 0x73a9d(%rip), %rax     # 0xe3ce0
movq (%rax), %r14
movq 0x1ae0(%r14), %r15
movb $0x1, 0x90(%r15)
cmpb $0x0, 0x93(%r15)
jne 0x70318
movl %edx, %ebx
leal -0x1(%rbx), %eax
cmpl $0x3f, %eax
ja 0x70b2b
movl %ecx, %r12d
movl %esi, %r13d
movq %r8, -0x30(%rbp)
movq %rdi, -0x78(%rbp)
btl $0x18, %ecx
jae 0x70291
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x70b4a
movss %xmm0, -0x64(%rbp)
callq 0x409d2
movaps %xmm0, %xmm2
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movaps %xmm2, %xmm1
maxss 0x2bd47(%rip), %xmm1    # 0x9bff8
testl $0x3000000, %r12d       # imm = 0x3000000
je 0x7031f
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
maxss 0x2bd32(%rip), %xmm2    # 0x9bff8
callq 0x43dc5
movss 0xd8(%r15), %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0xdc(%r15), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq 0xd8(%r15), %rax
leaq -0x60(%rbp), %rdi
movq %rax, (%rdi)
movlps %xmm1, 0x8(%rdi)
xorl %esi, %esi
xorl %edx, %edx
callq 0x37840
testb %al, %al
je 0x70353
leaq -0x60(%rbp), %rdi
movss 0x2bcdd(%rip), %xmm0    # 0x9bff0
callq 0x4388d
xorl %eax, %eax
jmp 0x70b19
xorps %xmm2, %xmm2
callq 0x43dc5
movss 0xd8(%r15), %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0xdc(%r15), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq 0xd8(%r15), %rax
movq %rax, -0x60(%rbp)
movlps %xmm1, -0x58(%rbp)
movq %rbx, -0x48(%rbp)
leaq 0x20b0(%r14), %rdi
movq %rdi, -0x70(%rbp)
movl %r13d, %esi
callq 0x78664
movq %rax, %rbx
movl 0x68(%rax), %eax
movq %r14, -0x38(%rbp)
cmpl 0x1a68(%r14), %eax
jne 0x703c0
movswl 0x78(%rbx), %eax
leal 0x1(%rax), %r14d
leal (%rax,%r13), %ecx
incl %ecx
movl %ecx, -0x50(%rbp)
movl 0x4(%rbx), %ecx
movl %ecx, -0x40(%rbp)
testl %eax, %eax
js 0x703cd
movq -0x48(%rbp), %rax
cmpl %eax, 0x6c(%rbx)
je 0x703cd
leaq 0x45dee(%rip), %rdi     # 0xb6196
leaq 0x45d57(%rip), %rsi     # 0xb6106
leaq 0x45d6f(%rip), %rcx     # 0xb6125
movl $0x148, %edx            # imm = 0x148
callq 0xc140
movl 0x4(%rbx), %eax
movl %eax, -0x40(%rbp)
xorl %r14d, %r14d
movl %r13d, -0x50(%rbp)
testw $0xe000, %r12w          # imm = 0xE000
sete 0x254(%rbx)
movl %r12d, %edi
movq %r15, %rsi
callq 0x786a1
movl %r13d, (%rbx)
movl %eax, %r13d
movl %eax, 0x4(%rbx)
movw %r14w, 0x78(%rbx)
movq -0x38(%rbp), %r14
movl 0x1a68(%r14), %eax
movl %eax, 0x68(%rbx)
movq %r15, 0x1d0(%rbx)
movq %r15, 0x1c8(%rbx)
movq -0x48(%rbp), %rax
movl %eax, 0x6c(%rbx)
movb $0x0, 0x248(%rbx)
movss -0x64(%rbp), %xmm4
movss %xmm4, 0xd4(%rbx)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x1b4(%rbx)
testl $0x3000000, %r12d       # imm = 0x3000000
je 0x70599
movl $0x1000000, %ecx        # imm = 0x1000000
movl %r13d, %r12d
andl %ecx, %r12d
movl %r13d, %eax
andl $0x3000000, %eax        # imm = 0x3000000
movss 0x2c410(%rip), %xmm2    # 0x9c870
movaps %xmm4, %xmm3
testl %r12d, %r12d
jne 0x7046b
movaps %xmm2, %xmm3
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
cmpltss %xmm4, %xmm1
andps %xmm1, %xmm3
andnps %xmm2, %xmm1
orps %xmm3, %xmm1
cmpl %ecx, %eax
je 0x7048e
ucomiss 0x2c3e6(%rip), %xmm1    # 0x9c870
jne 0x7048e
jnp 0x704c1
movaps %xmm1, %xmm2
cmpneqss 0x2c3d6(%rip), %xmm2    # 0x9c870
andps %xmm1, %xmm2
cmpl $0x1000000, %eax        # imm = 0x1000000
jne 0x704ac
movss 0x45c08(%rip), %xmm0    # 0xb60b4
leaq -0xc0(%rbp), %rdi
movss %xmm2, (%rdi)
movss %xmm0, 0x4(%rdi)
callq 0x42a26
testl $0x3000000, -0x40(%rbp) # imm = 0x3000000
jne 0x704da
leaq -0xc0(%rbp), %rdi
andq $0x0, (%rdi)
callq 0x42a5b
movss -0x58(%rbp), %xmm0
movss -0x54(%rbp), %xmm1
subss -0x60(%rbp), %xmm0
subss -0x5c(%rbp), %xmm1
shrl $0xd, %r12d
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0xc0(%rbp), %rdx
movlps %xmm0, (%rdx)
movq -0x78(%rbp), %rdi
movl -0x50(%rbp), %esi
xorl %ecx, %ecx
movl %r12d, %r8d
callq 0x407dc
movq 0x1ae0(%r14), %rdi
movq %rdi, 0x1d0(%rbx)
movups 0x238(%rdi), %xmm0
movups %xmm0, 0x10c(%rbx)
callq 0x4b560
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xec(%rbx)
movq 0x1d0(%rbx), %rax
movups 0x218(%rax), %xmm0
movups %xmm0, 0xfc(%rbx)
movss 0x40(%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x7057a
jp 0x7057a
movss 0x44(%rax), %xmm1
ucomiss %xmm0, %xmm1
jne 0x7057a
jp 0x7057a
movss 0x4c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x7057a
jnp 0x705ba
leaq 0x45c8c(%rip), %rdi     # 0xb620d
leaq 0x45b7e(%rip), %rsi     # 0xb6106
leaq 0x45b96(%rip), %rcx     # 0xb6125
movl $0x177, %edx            # imm = 0x177
callq 0xc140
movups -0x60(%rbp), %xmm0
movups %xmm0, 0xfc(%rbx)
movups -0x60(%rbp), %xmm0
movups %xmm0, 0xec(%rbx)
movups -0x60(%rbp), %xmm0
movups %xmm0, 0x10c(%rbx)
movl -0x50(%rbp), %edi
callq 0x42f94
movq 0x1d0(%rbx), %rdi
movss 0x118(%rdi), %xmm0
movss %xmm0, 0xb0(%rbx)
movups 0x258(%rdi), %xmm0
movups %xmm0, 0x15c(%rbx)
movb 0x93(%rdi), %al
movb %al, 0x256(%rbx)
movups 0x238(%rdi), %xmm0
movups %xmm0, 0x16c(%rbx)
movups 0x248(%rdi), %xmm0
movups %xmm0, 0x17c(%rbx)
movl 0x11c(%r15), %eax
movl %eax, 0x1bc(%rbx)
movq 0x108(%rdi), %rax
movq %rax, 0x19c(%rbx)
movq 0x100(%rdi), %rax
movq %rax, 0x1a4(%rbx)
movq 0xf0(%rdi), %rax
movq %rax, 0x1ac(%rbx)
movss 0x1d0(%r15), %xmm0
movss %xmm0, 0x1c0(%rbx)
movl 0x1d8(%r15), %eax
movl %eax, 0x1c4(%rbx)
btl $0x16, %r13d
setae %al
testl $0x200400, %r13d        # imm = 0x200400
setne %cl
btl $0x9, %r13d
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
jae 0x7068b
movss 0x2b96d(%rip), %xmm1    # 0x9bff8
movl %r13d, %edx
andl $0x800200, %edx         # imm = 0x800200
xorps %xmm2, %xmm2
movups %xmm2, 0x100(%rdi)
cmpl $0x200, %edx            # imm = 0x200
je 0x706b5
testl %edx, %edx
jne 0x706be
movss 0x15b8(%r14), %xmm2
jmp 0x706c1
movss 0x15b8(%r14), %xmm0
xorps %xmm2, %xmm2
andb %cl, %al
addss %xmm2, %xmm1
movss %xmm1, 0xc4(%rbx)
movss %xmm2, 0xc8(%rbx)
movss %xmm0, 0xbc(%rbx)
movss 0x15bc(%r14), %xmm1
movss %xmm1, 0xc0(%rbx)
btl $0xa, %r13d
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
jae 0x70705
movss 0x2b8f3(%rip), %xmm1    # 0x9bff8
movl %r13d, -0x30(%rbp)
leaq 0x258(%rdi), %rcx
leaq 0x15c(%rbx), %r12
testb %al, %al
je 0x70724
movss 0x15b8(%r14), %xmm2
addss %xmm2, %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0xb8(%rbx)
orq $-0x1, 0x70(%rbx)
andl $0x0, 0x94(%rbx)
movzwl 0x90(%rbx), %eax
leaq 0x10c(%rbx), %rsi
cmpq %r15, %rdi
cmoveq %rsi, %rcx
movl %eax, 0x90(%rbx)
movq %rdi, %r14
leaq 0x11c(%rbx), %r13
movups (%rcx), %xmm0
movups %xmm0, 0x11c(%rbx)
movq %r13, %rdi
callq 0x49efc
movq %r13, %rdi
movq %r12, %rsi
callq 0x4b582
btl $0x11, -0x30(%rbp)
jb 0x70794
movss 0x264(%r14), %xmm0
jmp 0x707a5
movss 0x128(%rbx), %xmm0
minss 0x244(%r14), %xmm0
movq %rbx, %r13
movss %xmm0, 0x128(%rbx)
movss 0x110(%rbx), %xmm0
movss %xmm0, 0x80(%rbx)
movss %xmm0, 0x7c(%rbx)
andl $0x0, 0x88(%rbx)
andl $0x0, 0x240(%rbx)
movb $0x1, 0x253(%rbx)
movb $0x0, 0x233(%rbx)
pushq $0x2b
popq %rdi
movss 0x2b80c(%rip), %xmm0    # 0x9bff8
callq 0x35d33
movl %eax, 0xa0(%rbx)
pushq $0x2c
popq %rdi
movss 0x2b7f6(%rip), %xmm0    # 0x9bff8
callq 0x35d33
movl %eax, 0xa4(%rbx)
movq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x7871a
movl %eax, %r12d
movq -0x38(%rbp), %rbx
leaq 0x20d8(%rbx), %rdi
leaq -0xc0(%rbp), %rsi
andq $0x0, (%rsi)
movl %eax, 0x8(%rsi)
callq 0x7876a
movq %r13, 0x20a8(%rbx)
movl %r12d, 0x1b8(%r15)
cmpq %r15, %r14
je 0x70854
movl %r12d, 0x1b8(%r14)
movq %r14, -0x50(%rbp)
testb $0x2, -0x40(%rbp)
je 0x7086c
andl $0x2, -0x30(%rbp)
jne 0x7086c
movb $0x1, 0x252(%r13)
movq -0x38(%rbp), %r14
leaq 0x20e8(%r14), %r15
cmpl 0x20e8(%r14), %r12d
movq -0x48(%rbp), %rbx
jl 0x7089e
movl %r12d, %esi
incl %esi
leaq -0xc0(%rbp), %rdx
movl $0xbf800000, (%rdx)     # imm = 0xBF800000
movq %r15, %rdi
callq 0x6fcea
cvtsd2ss 0x1a60(%r14), %xmm0
movss %xmm0, -0x30(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x4ad98
movss -0x30(%rbp), %xmm0
movss %xmm0, (%rax)
movb $0x0, 0x255(%r13)
movq 0x8(%r13), %rdi
movq 0x18(%r13), %rax
subq 0x10(%r13), %rax
pushq $0x68
popq %rcx
cqto
idivq %rcx
testl %eax, %eax
sete %cl
cmpl %ebx, %eax
sete %al
orb %cl, %al
je 0x708f1
testq %rdi, %rdi
jne 0x70915
jmp 0x708fb
callq 0x344ad
andq $0x0, 0x8(%r13)
movq %r13, %rdi
movl %ebx, %esi
callq 0x70b69
movb $0x1, %al
movb %al, 0x24e(%r13)
movb %al, 0x24a(%r13)
leaq 0x10(%r13), %r15
cmpb $0x1, 0x251(%r13)
movq %r13, -0x40(%rbp)
jne 0x70948
movb $0x1, 0x24a(%r13)
movb $0x0, 0x251(%r13)
movw $0x100, 0x24e(%r13)     # imm = 0x100
andl $0x0, 0x60(%r13)
jmp 0x70956
testb $0x1, 0x24a(%r13)
je 0x70a4e
movq -0x40(%rbp), %rcx
orl $-0x1, 0x64(%rcx)
movb $0x1, 0x24b(%rcx)
orw $-0x1, 0x7a(%rcx)
movb $-0x1, %al
movb %al, 0x23f(%rcx)
movb %al, 0x23a(%rcx)
leaq 0x20(%rcx), %rdx
movq %rdx, -0x30(%rbp)
movb %al, 0x238(%rcx)
orl $-0x1, 0x234(%rcx)
xorl %r13d, %r13d
leaq -0x8c(%rbp), %r14
movl $0xbf800000, %r12d      # imm = 0xBF800000
cmpl %r13d, %ebx
je 0x70a4e
movq %r15, %rdi
movl %r13d, %esi
callq 0x4c4c6
xorps %xmm0, %xmm0
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
andl $0x0, -0x90(%rbp)
movaps %xmm0, -0xc0(%rbp)
orl $-0x1, 0x3(%r14)
orl $-0x1, (%r14)
movq %rax, %rbx
movups %xmm0, (%rax)
movl %r12d, 0x10(%rax)
movl %r12d, 0x18(%rax)
movaps -0xc0(%rbp), %xmm0
movaps -0xb0(%rbp), %xmm1
movaps -0xa0(%rbp), %xmm2
movups %xmm0, 0x1c(%rax)
movups %xmm1, 0x2c(%rax)
movups %xmm2, 0x3c(%rax)
movups -0x95(%rbp), %xmm0
movups %xmm0, 0x47(%rax)
orw $-0x1, 0x57(%rax)
movb $-0x1, 0x59(%rax)
andq $0x0, 0x5a(%rax)
andl $0x0, 0x62(%rax)
movb $0x1, 0x60(%rax)
movq -0x30(%rbp), %rdi
movl %r13d, %esi
callq 0x787be
movb %r13b, (%rax)
movb %r13b, 0x52(%rbx)
movw $0x101, 0x5a(%rbx)      # imm = 0x101
movq -0x48(%rbp), %rbx
incl %r13d
jmp 0x7099d
movq -0x40(%rbp), %r14
cmpb $0x1, 0x24e(%r14)
jne 0x70a64
movq %r14, %rdi
callq 0x70c47
movq -0x38(%rbp), %rax
movss 0x1980(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
movss 0xe8(%r14), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movq -0x50(%rbp), %r13
jne 0x70a8c
jnp 0x70ade
ucomiss -0x38(%rbp), %xmm0
jne 0x70a94
jnp 0x70ade
movss -0x38(%rbp), %xmm1
divss %xmm0, %xmm1
movss %xmm1, -0x30(%rbp)
xorl %r12d, %r12d
cmpl %r12d, %ebx
je 0x70ade
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c4c6
movss 0x10(%rax), %xmm0
mulss -0x30(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x4c4c6
movss -0x48(%rbp), %xmm0
movss %xmm0, 0x10(%rax)
incl %r12d
jmp 0x70aa5
movss -0x38(%rbp), %xmm0
movss %xmm0, 0xe8(%r14)
movb $0x1, 0x93(%r13)
cmpl $0x0, 0x1d8(%r14)
jle 0x70b0f
movq %r14, %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
xorl %esi, %esi
callq 0x49cb6
movq %r14, %rdi
callq 0x70e03
movb $0x1, %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4558a(%rip), %rdi     # 0xb60bc
leaq 0x455cd(%rip), %rsi     # 0xb6106
leaq 0x455e5(%rip), %rcx     # 0xb6125
movl $0x133, %edx            # imm = 0x133
callq 0xc140
leaq 0x45631(%rip), %rdi     # 0xb6182
leaq 0x455ae(%rip), %rsi     # 0xb6106
leaq 0x455c6(%rip), %rcx     # 0xb6125
movl $0x135, %edx            # imm = 0x135
callq 0xc140