// File: /workspace/github_cpp_makefile_star2_O2/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 0x71152(%rip), %rax     # 0xe3ce0
movq (%rax), %r13
movq 0x20a8(%r13), %rbx
testq %rbx, %rbx
je 0x732de
cmpb $0x0, 0x248(%rbx)
jne 0x72bb2
movq %rbx, %rdi
callq 0x712c6
movq 0x1d0(%rbx), %r14
cmpq 0x1ae0(%r13), %r14
jne 0x732fd
movl 0x4(%rbx), %r12d
movq 0x1c8(%rbx), %r15
cmpq %r14, %r15
je 0x72be3
cmpq 0x388(%r14), %r15
jne 0x73379
cmpb $0x1, 0x249(%rbx)
jne 0x72bf4
movq %rbx, %rdi
callq 0x733b7
testb $0x20, %r12b
je 0x72c24
cmpb $-0x1, 0x234(%rbx)
je 0x72c24
callq 0x4065d
testb %al, %al
jne 0x72c24
pushq $0x1
popq %rdi
callq 0x40253
testb %al, %al
je 0x72c24
movsbl 0x234(%rbx), %edi
callq 0x739bb
movq 0x19c(%rbx), %rax
movq %rax, 0x108(%r14)
movq 0x1a4(%rbx), %rax
movq %rax, 0x100(%r14)
movq 0x1ac(%rbx), %rax
movq %rax, 0xf0(%r14)
movss 0x80(%rbx), %xmm2
ucomiss 0xdc(%r14), %xmm2
jne 0x7331c
jp 0x7331c
cmpq %r14, %r15
je 0x72c7a
movss %xmm2, 0xf4(%r14)
jmp 0x72caa
btl $0x11, %r12d
jb 0x72caa
movss 0xf8(%rbx), %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0x108(%rbx)
movss %xmm1, 0xf8(%rbx)
movaps %xmm2, -0x70(%rbp)
movss 0x118(%rbx), %xmm0
movss 0xf8(%rbx), %xmm1
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
andps %xmm2, %xmm0
andnps %xmm1, %xmm2
orps %xmm0, %xmm2
movss %xmm2, 0x118(%rbx)
subss 0xf0(%rbx), %xmm1
movss %xmm1, 0xcc(%rbx)
movl 0x4(%rbx), %eax
btl $0x18, %eax
jae 0x72d98
movq 0x1d0(%rbx), %rcx
movss 0xf0(%rcx), %xmm2
movsbl 0x23e(%rbx), %esi
cmpl $-0x1, %esi
je 0x72d67
movaps %xmm2, -0x50(%rbp)
btl $0xa, %eax
xorps %xmm0, %xmm0
jae 0x72d24
movss 0x292d4(%rip), %xmm0    # 0x9bff8
movss %xmm0, -0x40(%rbp)
leaq 0x10(%rbx), %rdi
callq 0x4c4c6
movss 0x38(%rax), %xmm0
addss 0xbc(%rbx), %xmm0
addss 0xb8(%rbx), %xmm0
subss -0x40(%rbp), %xmm0
movaps %xmm0, %xmm1
movaps -0x50(%rbp), %xmm3
cmpless %xmm3, %xmm1
movaps %xmm1, %xmm2
andnps %xmm0, %xmm2
andps %xmm3, %xmm1
orps %xmm2, %xmm1
movaps %xmm1, %xmm2
cmpb $-0x1, 0x237(%rbx)
je 0x72d89
movss 0xe4(%rbx), %xmm0
movaps %xmm0, %xmm1
cmpless %xmm2, %xmm1
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm1, %xmm2
movq 0x1d0(%rbx), %rax
movss %xmm2, 0xf0(%rax)
btl $0x14, %r12d
jb 0x72dab
movq 0x2b8(%r14), %rdi
callq 0x622f0
movq 0x2b8(%r14), %rdi
addq $0x58, %rdi
callq 0x4b29e
movups (%rax), %xmm0
movups %xmm0, 0x258(%r14)
testw $0x780, %r12w           # imm = 0x780
je 0x72dd6
movq %rbx, %rdi
callq 0x73a42
movq %r13, -0x50(%rbp)
leaq 0x1e8(%rbx), %r12
movq 0x2b8(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x656c2
testb $0x10, 0x6(%rbx)
jne 0x72e00
movq %rbx, %rdi
callq 0x73e4c
leaq 0xec(%rbx), %rax
movq %rax, -0x58(%rbp)
movq 0x2b8(%r14), %rsi
movq %r12, %rdi
callq 0x65408
movss 0xc4(%rbx), %xmm0
movsbl 0x231(%rbx), %eax
leal -0x1(%rax), %ecx
cvtsi2ss %ecx, %xmm1
addss 0xc8(%rbx), %xmm0
mulss %xmm0, %xmm1
movss 0xb8(%rbx), %xmm0
movss 0xbc(%rbx), %xmm2
addss %xmm0, %xmm0
addss %xmm1, %xmm0
addss %xmm2, %xmm2
cvtsi2ss %eax, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xdc(%rbx)
leaq 0x10(%rbx), %r12
xorl %r13d, %r13d
movslq 0x6c(%rbx), %rax
cmpq %rax, %r13
jge 0x72ec2
movq 0x48(%rbx), %rax
btq %r13, %rax
jae 0x72ebd
movq %r12, %rdi
movl %r13d, %esi
callq 0x4c4c6
movl (%rax), %ecx
andl $0x18, %ecx
cmpl $0x8, %ecx
jne 0x72ea2
movss 0x10(%rax), %xmm0
jmp 0x72ead
movq %rbx, %rdi
movq %rax, %rsi
callq 0x722b1
addss 0xdc(%rbx), %xmm0
movss %xmm0, 0xdc(%rbx)
incq %r13
jmp 0x72e73
cmpq %r14, %r15
je 0x72edf
movl $0x1000000, %eax        # imm = 0x1000000
andl 0x4(%rbx), %eax
jne 0x72edf
andl $0x0, 0x5c(%r14)
movq -0x50(%rbp), %r13
jmp 0x72f8e
movsbl 0x238(%rbx), %esi
cmpl $-0x1, %esi
movq -0x50(%rbp), %r13
je 0x72f8e
cmpb $-0x1, 0x237(%rbx)
jne 0x72f8e
cmpb $0x1, 0x8c(%r14)
jne 0x72f8e
movzwl 0x7a(%rbx), %eax
cmpw 0x78(%rbx), %ax
jne 0x72f8e
movss 0xbc(%rbx), %xmm0
addss %xmm0, %xmm0
addss 0xb4(%rbx), %xmm0
movss %xmm0, -0x40(%rbp)
movq %r12, %rdi
callq 0x4c4c6
movss 0xc(%rax), %xmm0
movss 0x11c(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x72f63
subss 0x10(%r14), %xmm0
subss -0x40(%rbp), %xmm0
movss 0x2909a(%rip), %xmm1    # 0x9bff8
movq %r14, %rdi
jmp 0x72f89
movss -0x40(%rbp), %xmm2
ucomiss 0x124(%rbx), %xmm0
jbe 0x72f8e
subss 0x10(%r14), %xmm0
addss %xmm0, %xmm2
movss 0x29075(%rip), %xmm1    # 0x9bff8
movq %r14, %rdi
movaps %xmm2, %xmm0
callq 0x442a4
movsbl 0x237(%rbx), %esi
cmpl $-0x1, %esi
je 0x72ff2
movzwl 0x78(%rbx), %eax
cmpw 0x7a(%rbx), %ax
jne 0x72ff2
movq %r12, %rdi
callq 0x4c4c6
movss 0x128(%r13), %xmm0
subss 0x1b58(%r13), %xmm0
addss 0x298ca(%rip), %xmm0    # 0x9c890
subss 0x8(%rax), %xmm0
subss 0xc4(%rbx), %xmm0
movss 0xbc(%rbx), %xmm1
addss %xmm1, %xmm1
subss %xmm1, %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xe0(%rbx)
leaq 0xc8(%r14), %rdi
callq 0x4a148
movswl 0x78(%rbx), %ecx
addl (%rbx), %ecx
cmpl %ecx, (%rax)
jne 0x7333b
movl 0x1d8(%r15), %eax
cmpl 0x1c4(%rbx), %eax
jl 0x7335a
callq 0x42fea
movss 0xf0(%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
movss 0xf4(%r15), %xmm0
movaps %xmm0, -0x50(%rbp)
movups 0x16c(%rbx), %xmm0
movups %xmm0, 0x238(%r14)
movups 0x17c(%rbx), %xmm0
movups %xmm0, 0x248(%r14)
movb 0x256(%rbx), %al
movb %al, 0x93(%r14)
movq 0xec(%rbx), %rax
movq %rax, 0xd8(%r15)
movss 0x1c0(%rbx), %xmm0
movss %xmm0, 0x1d0(%r15)
movl 0x1c4(%rbx), %eax
movl %eax, 0x1d8(%r15)
movl 0x1bc(%rbx), %eax
movl %eax, 0x11c(%r15)
cmpq %r14, %r15
je 0x730ae
callq 0x40b4b
jmp 0x730f2
movss 0xf4(%rbx), %xmm0
movss 0xf8(%rbx), %xmm1
subss 0xec(%rbx), %xmm0
subss 0xf0(%rbx), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq -0x78(%rbp), %rdi
movlps %xmm0, (%rdi)
movss 0x28f10(%rip), %xmm0    # 0x9bff0
callq 0x40d3b
movq -0x58(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40ea5
movl 0x4(%rbx), %eax
btl $0x10, %eax
jb 0x73115
movss 0x1b4(%rbx), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x73131
movss 0xf4(%rbx), %xmm0
jmp 0x7318a
btl $0x18, %eax
jb 0x73398
movss 0xec(%rbx), %xmm0
addss 0xdc(%rbx), %xmm0
jmp 0x7318a
btl $0x18, %eax
jae 0x73140
movss 0x84(%r14), %xmm0
movss 0xec(%rbx), %xmm2
addss 0xdc(%rbx), %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(%rbx), %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(%rbx), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x731c2
movss 0xf8(%rbx), %xmm0
jmp 0x7320f
btl $0x19, %eax
jae 0x731d1
movss 0x88(%r14), %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(%rbx), %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(%rbx)
jne 0x7323e
movq %rbx, %rdi
callq 0x7450c
movb $0x0, 0x24a(%rbx)
cmpq %r15, 0x1ae0(%r13)
jne 0x732bf
cmpq %rbx, 0x20a8(%r13)
jne 0x732bf
leaq 0x20d8(%r13), %rbx
movq %rbx, %rdi
callq 0x788de
cmpl $0x0, 0x20d8(%r13)
je 0x7329e
leaq 0x20b0(%r13), %r14
movq %rbx, %rdi
callq 0x7890c
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x4c6b6
movq %rax, 0x20a8(%r13)
movq %r14, %rdi
movq %rax, %rsi
callq 0x7871a
jmp 0x732a9
andq $0x0, 0x20a8(%r13)
pushq $-0x1
popq %rax
movl %eax, 0x1b8(%r15)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43375(%rip), %rdi     # 0xb663b
leaq 0x42e39(%rip), %rsi     # 0xb6106
leaq 0x431b9(%rip), %rcx     # 0xb648d
movl $0x53f, %edx            # imm = 0x53F
callq 0xc140
leaq 0x43160(%rip), %rdi     # 0xb6445
leaq 0x42e1a(%rip), %rsi     # 0xb6106
leaq 0x4319a(%rip), %rcx     # 0xb648d
movl $0x489, %edx            # imm = 0x489
callq 0xc140
leaq 0x431a0(%rip), %rdi     # 0xb64a4
leaq 0x42dfb(%rip), %rsi     # 0xb6106
leaq 0x4317b(%rip), %rcx     # 0xb648d
movl $0x497, %edx            # imm = 0x497
callq 0xc140
leaq 0x431ec(%rip), %rdi     # 0xb650f
leaq 0x42ddc(%rip), %rsi     # 0xb6106
leaq 0x4315c(%rip), %rcx     # 0xb648d
movl $0x4a7, %edx            # imm = 0x4A7
callq 0xc140
leaq 0x431fd(%rip), %rdi     # 0xb653f
leaq 0x42dbd(%rip), %rsi     # 0xb6106
leaq 0x4313d(%rip), %rcx     # 0xb648d
movl $0x500, %edx            # imm = 0x500
callq 0xc140
leaq 0x43242(%rip), %rdi     # 0xb65a3
leaq 0x42d9e(%rip), %rsi     # 0xb6106
leaq 0x4311e(%rip), %rcx     # 0xb648d
movl $0x501, %edx            # imm = 0x501
callq 0xc140
leaq 0x43144(%rip), %rdi     # 0xb64c4
leaq 0x42d7f(%rip), %rsi     # 0xb6106
leaq 0x430ff(%rip), %rcx     # 0xb648d
movl $0x498, %edx            # imm = 0x498
callq 0xc140
leaq 0x4326e(%rip), %rdi     # 0xb660d
leaq 0x42d60(%rip), %rsi     # 0xb6106
leaq 0x430e0(%rip), %rcx     # 0xb648d
movl $0x520, %edx            # imm = 0x520
callq 0xc140