// File: Ciaxur[P]yagb-emu/include/imgui/imgui_tables.cpp
// Function: ImGui::TableEndRow(ImGuiTable*)
void ImGui::TableEndRow(ImGuiTable* table)
{
    ImGuiContext& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    IM_ASSERT(window == table->InnerWindow);
    IM_ASSERT(table->IsInsideRow);

    if (table->CurrentColumn != -1)
        TableEndCell(table);

    // Position cursor at the bottom of our row so it can be used for e.g. clipping calculation. However it is
    // likely that the next call to TableBeginCell() will reposition the cursor to take account of vertical padding.
    window->DC.CursorPos.y = table->RowPosY2;

    // Row background fill
    const float bg_y1 = table->RowPosY1;
    const float bg_y2 = table->RowPosY2;
    const bool unfreeze_rows_actual = (table->CurrentRow + 1 == table->FreezeRowsCount);
    const bool unfreeze_rows_request = (table->CurrentRow + 1 == table->FreezeRowsRequest);
    if (table->CurrentRow == 0)
        table->LastFirstRowHeight = bg_y2 - bg_y1;

    const bool is_visible = (bg_y2 >= table->InnerClipRect.Min.y && bg_y1 <= table->InnerClipRect.Max.y);
    if (is_visible)
    {
        // Decide of background color for the row
        ImU32 bg_col0 = 0;
        ImU32 bg_col1 = 0;
        if (table->RowBgColor[0] != IM_COL32_DISABLE)
            bg_col0 = table->RowBgColor[0];
        else if (table->Flags & ImGuiTableFlags_RowBg)
            bg_col0 = GetColorU32((table->RowBgColorCounter & 1) ? ImGuiCol_TableRowBgAlt : ImGuiCol_TableRowBg);
        if (table->RowBgColor[1] != IM_COL32_DISABLE)
            bg_col1 = table->RowBgColor[1];

        // Decide of top border color
        ImU32 border_col = 0;
        const float border_size = TABLE_BORDER_SIZE;
        if (table->CurrentRow > 0 || table->InnerWindow == table->OuterWindow)
            if (table->Flags & ImGuiTableFlags_BordersInnerH)
                border_col = (table->LastRowFlags & ImGuiTableRowFlags_Headers) ? table->BorderColorStrong : table->BorderColorLight;

        const bool draw_cell_bg_color = table->RowCellDataCurrent >= 0;
        const bool draw_strong_bottom_border = unfreeze_rows_actual;
        if ((bg_col0 | bg_col1 | border_col) != 0 || draw_strong_bottom_border || draw_cell_bg_color)
        {
            // In theory we could call SetWindowClipRectBeforeSetChannel() but since we know TableEndRow() is
            // always followed by a change of clipping rectangle we perform the smallest overwrite possible here.
            if ((table->Flags & ImGuiTableFlags_NoClip) == 0)
                window->DrawList->_CmdHeader.ClipRect = table->Bg0ClipRectForDrawCmd.ToVec4();
            table->DrawSplitter.SetCurrentChannel(window->DrawList, TABLE_DRAW_CHANNEL_BG0);
        }

        // Draw row background
        // We soft/cpu clip this so all backgrounds and borders can share the same clipping rectangle
        if (bg_col0 || bg_col1)
        {
            ImRect row_rect(table->WorkRect.Min.x, bg_y1, table->WorkRect.Max.x, bg_y2);
            row_rect.ClipWith(table->BgClipRect);
            if (bg_col0 != 0 && row_rect.Min.y < row_rect.Max.y)
                window->DrawList->AddRectFilled(row_rect.Min, row_rect.Max, bg_col0);
            if (bg_col1 != 0 && row_rect.Min.y < row_rect.Max.y)
                window->DrawList->AddRectFilled(row_rect.Min, row_rect.Max, bg_col1);
        }

        // Draw cell background color
        if (draw_cell_bg_color)
        {
            ImGuiTableCellData* cell_data_end = &table->RowCellData[table->RowCellDataCurrent];
            for (ImGuiTableCellData* cell_data = &table->RowCellData[0]; cell_data <= cell_data_end; cell_data++)
            {
                const ImGuiTableColumn* column = &table->Columns[cell_data->Column];
                ImRect cell_bg_rect = TableGetCellBgRect(table, cell_data->Column);
                cell_bg_rect.ClipWith(table->BgClipRect);
                cell_bg_rect.Min.x = ImMax(cell_bg_rect.Min.x, column->ClipRect.Min.x);     // So that first column after frozen one gets clipped
                cell_bg_rect.Max.x = ImMin(cell_bg_rect.Max.x, column->MaxX);
                window->DrawList->AddRectFilled(cell_bg_rect.Min, cell_bg_rect.Max, cell_data->BgColor);
            }
        }

        // Draw top border
        if (border_col && bg_y1 >= table->BgClipRect.Min.y && bg_y1 < table->BgClipRect.Max.y)
            window->DrawList->AddLine(ImVec2(table->BorderX1, bg_y1), ImVec2(table->BorderX2, bg_y1), border_col, border_size);

        // Draw bottom border at the row unfreezing mark (always strong)
        if (draw_strong_bottom_border && bg_y2 >= table->BgClipRect.Min.y && bg_y2 < table->BgClipRect.Max.y)
            window->DrawList->AddLine(ImVec2(table->BorderX1, bg_y2), ImVec2(table->BorderX2, bg_y2), table->BorderColorStrong, border_size);
    }

    // End frozen rows (when we are past the last frozen row line, teleport cursor and alter clipping rectangle)
    // We need to do that in TableEndRow() instead of TableBeginRow() so the list clipper can mark end of row and
    // get the new cursor position.
    if (unfreeze_rows_request)
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            column->NavLayerCurrent = (ImS8)((column_n < table->FreezeColumnsCount) ? ImGuiNavLayer_Menu : ImGuiNavLayer_Main);
        }
    if (unfreeze_rows_actual)
    {
        IM_ASSERT(table->IsUnfrozenRows == false);
        table->IsUnfrozenRows = true;

        // BgClipRect starts as table->InnerClipRect, reduce it now and make BgClipRectForDrawCmd == BgClipRect
        float y0 = ImMax(table->RowPosY2 + 1, window->InnerClipRect.Min.y);
        table->BgClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y = ImMin(y0, window->InnerClipRect.Max.y);
        table->BgClipRect.Max.y = table->Bg2ClipRectForDrawCmd.Max.y = window->InnerClipRect.Max.y;
        table->Bg2DrawChannelCurrent = table->Bg2DrawChannelUnfrozen;
        IM_ASSERT(table->Bg2ClipRectForDrawCmd.Min.y <= table->Bg2ClipRectForDrawCmd.Max.y);

        float row_height = table->RowPosY2 - table->RowPosY1;
        table->RowPosY2 = window->DC.CursorPos.y = table->WorkRect.Min.y + table->RowPosY2 - table->OuterRect.Min.y;
        table->RowPosY1 = table->RowPosY2 - row_height;
        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
        {
            ImGuiTableColumn* column = &table->Columns[column_n];
            column->DrawChannelCurrent = column->DrawChannelUnfrozen;
            column->ClipRect.Min.y = table->Bg2ClipRectForDrawCmd.Min.y;
        }

        // Update cliprect ahead of TableBeginCell() so clipper can access to new ClipRect->Min.y
        SetWindowClipRectBeforeSetChannel(window, table->Columns[0].ClipRect);
        table->DrawSplitter.SetCurrentChannel(window->DrawList, table->Columns[0].DrawChannelCurrent);
    }

    if (!(table->RowFlags & ImGuiTableRowFlags_Headers))
        table->RowBgColorCounter++;
    table->IsInsideRow = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
leaq 0xe455a(%rip), %rax     # 0x212f40
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1ae0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1d0(%rcx), %rax
jne 0x12ea0f
jmp 0x12ea2e
leaq 0x5e120(%rip), %rdi     # 0x18cb36
leaq 0x5d585(%rip), %rsi     # 0x18bfa2
movl $0x664, %edx            # imm = 0x664
leaq 0x5e12a(%rip), %rcx     # 0x18cb53
callq 0xd180
movq -0x8(%rbp), %rax
testb $0x1, 0x249(%rax)
je 0x12ea3d
jmp 0x12ea5c
leaq 0x5e0b7(%rip), %rdi     # 0x18cafb
leaq 0x5d557(%rip), %rsi     # 0x18bfa2
movl $0x665, %edx            # imm = 0x665
leaq 0x5e0fc(%rip), %rcx     # 0x18cb53
callq 0xd180
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x12ea6f
movq -0x8(%rbp), %rdi
callq 0x131810
movq -0x8(%rbp), %rax
movss 0x80(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xdc(%rax)
movq -0x8(%rbp), %rax
movss 0x7c(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movss 0x80(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x70(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movsbl 0x241(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movl 0x70(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movsbl 0x240(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x70(%rax)
jne 0x12eb04
movss -0x20(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xd0(%rax)
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
ucomiss 0x120(%rcx), %xmm0
movb %al, -0xc9(%rbp)
jb 0x12eb3b
movss -0x1c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x128(%rax), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
andb $0x1, %al
movb %al, -0x23(%rbp)
testb $0x1, -0x23(%rbp)
je 0x12f021
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1000000, 0x98(%rax)  # imm = 0x1000000
je 0x12eb7d
movq -0x8(%rbp), %rax
movl 0x98(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x12ebbb
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x12ebb9
movq -0x8(%rbp), %rax
movl 0x94(%rax), %ecx
andl $0x1, %ecx
movl $0x2d, %edi
movl $0x2e, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
movss 0x4208b(%rip), %xmm0    # 0x170c3c
callq 0xc76e0
movl %eax, -0x28(%rbp)
jmp 0x12ebbb
movq -0x8(%rbp), %rax
cmpl $0x1000000, 0x9c(%rax)  # imm = 0x1000000
je 0x12ebd8
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movss 0x42055(%rip), %xmm0    # 0x170c3c
movss %xmm0, -0x34(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x70(%rax)
jg 0x12ec0e
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1c8(%rcx), %rax
jne 0x12ec61
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x12ec5f
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
sarl $0x10, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12ec46
movq -0x8(%rbp), %rax
movl 0xa0(%rax), %eax
movl %eax, -0xd0(%rbp)
jmp 0x12ec56
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %eax
movl %eax, -0xd0(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x12ec61
movq -0x8(%rbp), %rax
movsbl 0x244(%rax), %eax
cmpl $0x0, %eax
setge %al
andb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x36(%rbp)
movl -0x28(%rbp), %eax
orl -0x2c(%rbp), %eax
orl -0x30(%rbp), %eax
cmpl $0x0, %eax
jne 0x12ec99
testb $0x1, -0x36(%rbp)
jne 0x12ec99
testb $0x1, -0x35(%rbp)
je 0x12ed02
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
jne 0x12ece5
movq -0x8(%rbp), %rdi
addq $0x13c, %rdi            # imm = 0x13C
callq 0x137560
movlpd %xmm0, -0x48(%rbp)
movlpd %xmm1, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rsi
xorl %edx, %edx
callq 0x115220
cmpl $0x0, -0x28(%rbp)
jne 0x12ed12
cmpl $0x0, -0x2c(%rbp)
je 0x12edcd
movq -0x8(%rbp), %rax
movss 0x10c(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x114(%rax), %xmm2
movss -0x20(%rbp), %xmm3
leaq -0x58(%rbp), %rdi
callq 0xec090
movq -0x8(%rbp), %rsi
addq $0x12c, %rsi            # imm = 0x12C
leaq -0x58(%rbp), %rdi
callq 0xe8970
cmpl $0x0, -0x28(%rbp)
je 0x12ed8e
movss -0x54(%rbp), %xmm1
movss -0x4c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12ed8e
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x58(%rbp), %rdx
addq $0x8, %rdx
movl -0x28(%rbp), %ecx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
cmpl $0x0, -0x2c(%rbp)
je 0x12edcb
movss -0x54(%rbp), %xmm1
movss -0x4c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12edcb
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x58(%rbp), %rdx
addq $0x8, %rdx
movl -0x2c(%rbp), %ecx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
jmp 0x12edcd
testb $0x1, -0x35(%rbp)
je 0x12eeca
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rax
movsbl 0x244(%rax), %esi
callq 0x1374e0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1374e0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x60(%rbp), %rax
ja 0x12eec8
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x68(%rbp), %rax
movsbl 0x4(%rax), %esi
callq 0xeea20
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movq -0x68(%rbp), %rax
movsbl 0x4(%rax), %esi
callq 0x131200
movlpd %xmm0, -0x80(%rbp)
movlpd %xmm1, -0x78(%rbp)
movq -0x8(%rbp), %rsi
addq $0x12c, %rsi            # imm = 0x12C
leaq -0x80(%rbp), %rdi
callq 0xe8970
movss -0x80(%rbp), %xmm0
movq -0x70(%rbp), %rax
movss 0x20(%rax), %xmm1
callq 0x12a620
movss %xmm0, -0x80(%rbp)
movss -0x78(%rbp), %xmm0
movq -0x70(%rbp), %rax
movss 0xc(%rax), %xmm1
callq 0x12a6b0
movss %xmm0, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x80(%rbp), %rdx
addq $0x8, %rdx
movq -0x68(%rbp), %rax
movl (%rax), %ecx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x12ee06
jmp 0x12eeca
cmpl $0x0, -0x30(%rbp)
je 0x12ef71
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x130(%rax), %xmm0
jb 0x12ef71
movss -0x1c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x138(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12ef71
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x8(%rbp), %rax
movss 0xa8(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
leaq -0x88(%rbp), %rdi
callq 0xbf4c0
movq -0x8(%rbp), %rax
movss 0xac(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
leaq -0x90(%rbp), %rdi
callq 0xbf4c0
movq -0xd8(%rbp), %rdi
movl -0x30(%rbp), %ecx
leaq -0x88(%rbp), %rsi
leaq -0x90(%rbp), %rdx
movss 0x41cd0(%rip), %xmm0    # 0x170c3c
callq 0x112e20
testb $0x1, -0x36(%rbp)
je 0x12f01f
movss -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x130(%rax), %xmm0
jb 0x12f01f
movss -0x20(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x138(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x12f01f
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0x8(%rbp), %rax
movss 0xa8(%rax), %xmm0
movss -0x20(%rbp), %xmm1
leaq -0x98(%rbp), %rdi
callq 0xbf4c0
movq -0x8(%rbp), %rax
movss 0xac(%rax), %xmm0
movss -0x20(%rbp), %xmm1
leaq -0xa0(%rbp), %rdi
callq 0xbf4c0
movq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xa0(%rax), %ecx
leaq -0x98(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
movss 0x41c22(%rip), %xmm0    # 0x170c3c
callq 0x112e20
jmp 0x12f021
testb $0x1, -0x22(%rbp)
je 0x12f096
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x12f094
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xa4(%rbp), %esi
callq 0xeea20
movq %rax, -0xb0(%rbp)
movl -0xa4(%rbp), %edx
movq -0x8(%rbp), %rax
movsbl 0x243(%rax), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movb %al, %cl
movq -0xb0(%rbp), %rax
movb %cl, 0x61(%rax)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x12f031
jmp 0x12f096
testb $0x1, -0x21(%rbp)
je 0x12f310
movq -0x8(%rbp), %rax
movb 0x253(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x12f0b6
jmp 0x12f0d5
leaq 0x5dabc(%rip), %rdi     # 0x18cb79
leaq 0x5cede(%rip), %rsi     # 0x18bfa2
movl $0x6c4, %edx            # imm = 0x6C4
leaq 0x5da83(%rip), %rcx     # 0x18cb53
callq 0xd180
movq -0x8(%rbp), %rax
movb $0x1, 0x253(%rax)
movq -0x8(%rbp), %rax
movss 0x41b50(%rip), %xmm0    # 0x170c3c
addss 0x80(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x22c(%rax), %xmm1
callq 0x12a620
movss %xmm0, -0xb4(%rbp)
movss -0xb4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss 0x234(%rax), %xmm1
callq 0x12a6b0
movq -0x8(%rbp), %rax
movss %xmm0, 0x150(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x130(%rax)
movq -0x18(%rbp), %rax
movss 0x234(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x158(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x138(%rax)
movq -0x8(%rbp), %rax
movb 0x247(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x246(%rax)
movq -0x8(%rbp), %rax
movss 0x150(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x158(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x12f195
jmp 0x12f1b4
leaq 0x5d9fc(%rip), %rdi     # 0x18cb98
leaq 0x5cdff(%rip), %rsi     # 0x18bfa2
movl $0x6cc, %edx            # imm = 0x6CC
leaq 0x5d9a4(%rip), %rcx     # 0x18cb53
callq 0xd180
movq -0x8(%rbp), %rax
movss 0x80(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x7c(%rax), %xmm0
movss %xmm0, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movss 0x110(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x80(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xf0(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xdc(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x80(%rax)
movq -0x8(%rbp), %rax
movss 0x80(%rax), %xmm0
subss -0xb8(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x7c(%rax)
movl $0x0, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x12f29a
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xbc(%rbp), %esi
callq 0xeea20
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movb 0x59(%rax), %cl
movq -0xc8(%rbp), %rax
movb %cl, 0x57(%rax)
movq -0x8(%rbp), %rax
movss 0x150(%rax), %xmm0
movq -0xc8(%rbp), %rax
movss %xmm0, 0x24(%rax)
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0x12f234
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0xeea20
movq -0xf8(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x131940
movq -0x8(%rbp), %rax
addq $0x1e8, %rax            # imm = 0x1E8
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rax
movq 0x2b8(%rax), %rax
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0xeea20
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movzbl 0x57(%rax), %edx
callq 0x115220
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
shll $0x10, %eax
sarl $0x10, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x12f33b
movq -0x8(%rbp), %rax
movl 0x94(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x94(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x249(%rax)
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop