// File: /workspace/github_cpp_makefile_star2_O2/Ciaxur[P]yagb-emu/src/../include/imgui_club/imgui_memory_editor/imgui_memory_editor.h
// Function: MemoryEditor::DrawContents(void*, unsigned long, unsigned long)
void DrawContents(void* mem_data_void, size_t mem_size, size_t base_display_addr = 0x0000)
    {
        if (Cols < 1)
            Cols = 1;

        ImU8* mem_data = (ImU8*)mem_data_void;
        Sizes s;
        CalcSizes(s, mem_size, base_display_addr);
        ImGuiStyle& style = ImGui::GetStyle();

        // We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent click from moving the window.
        // This is used as a facility since our main click detection code doesn't assign an ActiveId so the click would normally be caught as a window-move.
        const float height_separator = style.ItemSpacing.y;
        float footer_height = 0;
        if (OptShowOptions)
            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1;
        if (OptShowDataPreview)
            footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1 + ImGui::GetTextLineHeightWithSpacing() * 3;
        ImGui::BeginChild("##scrolling", ImVec2(0, -footer_height), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
        ImDrawList* draw_list = ImGui::GetWindowDrawList();

        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));

        // We are not really using the clipper API correctly here, because we rely on visible_start_addr/visible_end_addr for our scrolling function.
        const int line_total_count = (int)((mem_size + Cols - 1) / Cols);
        ImGuiListClipper clipper;
        clipper.Begin(line_total_count, s.LineHeight);
        clipper.Step();
        const size_t visible_start_addr = clipper.DisplayStart * Cols;
        const size_t visible_end_addr = clipper.DisplayEnd * Cols;

        bool data_next = false;

        if (ReadOnly || DataEditingAddr >= mem_size)
            DataEditingAddr = (size_t)-1;
        if (DataPreviewAddr >= mem_size)
            DataPreviewAddr = (size_t)-1;

        size_t preview_data_type_size = OptShowDataPreview ? DataTypeGetSize(PreviewDataType) : 0;

        size_t data_editing_addr_backup = DataEditingAddr;
        size_t data_editing_addr_next = (size_t)-1;
        if (DataEditingAddr != (size_t)-1)
        {
            // Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
            if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && DataEditingAddr >= (size_t)Cols)          { data_editing_addr_next = DataEditingAddr - Cols; DataEditingTakeFocus = true; }
            else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && DataEditingAddr < mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; DataEditingTakeFocus = true; }
            else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && DataEditingAddr > 0)               { data_editing_addr_next = DataEditingAddr - 1; DataEditingTakeFocus = true; }
            else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && DataEditingAddr < mem_size - 1)   { data_editing_addr_next = DataEditingAddr + 1; DataEditingTakeFocus = true; }
        }
        if (data_editing_addr_next != (size_t)-1 && (data_editing_addr_next / Cols) != (data_editing_addr_backup / Cols))
        {
            // Track cursor movements
            const int scroll_offset = ((int)(data_editing_addr_next / Cols) - (int)(data_editing_addr_backup / Cols));
            const bool scroll_desired = (scroll_offset < 0 && data_editing_addr_next < visible_start_addr + Cols * 2) || (scroll_offset > 0 && data_editing_addr_next > visible_end_addr - Cols * 2);
            if (scroll_desired)
                ImGui::SetScrollY(ImGui::GetScrollY() + scroll_offset * s.LineHeight);
        }

        // Draw vertical separator
        ImVec2 window_pos = ImGui::GetWindowPos();
        if (OptShowAscii)
            draw_list->AddLine(ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));

        const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text);
        const ImU32 color_disabled = OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text;

        const char* format_address = OptUpperCaseHex ? "%0*" _PRISizeT "X: " : "%0*" _PRISizeT "x: ";
        const char* format_data = OptUpperCaseHex ? "%0*" _PRISizeT "X" : "%0*" _PRISizeT "x";
        const char* format_byte = OptUpperCaseHex ? "%02X" : "%02x";
        const char* format_byte_space = OptUpperCaseHex ? "%02X " : "%02x ";

        for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible lines
        {
            size_t addr = (size_t)(line_i * Cols);
            ImGui::Text(format_address, s.AddrDigitsCount, base_display_addr + addr);

            // Draw Hexadecimal
            for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
            {
                float byte_pos_x = s.PosHexStart + s.HexCellWidth * n;
                if (OptMidColsCount > 0)
                    byte_pos_x += (float)(n / OptMidColsCount) * s.SpacingBetweenMidCols;
                ImGui::SameLine(byte_pos_x);

                // Draw highlight
                bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
                bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr));
                bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr < DataPreviewAddr + preview_data_type_size);
                if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
                {
                    ImVec2 pos = ImGui::GetCursorScreenPos();
                    float highlight_width = s.GlyphWidth * 2;
                    bool is_next_byte_highlighted =  (addr + 1 < mem_size) && ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) || (HighlightFn && HighlightFn(mem_data, addr + 1)));
                    if (is_next_byte_highlighted || (n + 1 == Cols))
                    {
                        highlight_width = s.HexCellWidth;
                        if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols && ((n + 1) % OptMidColsCount) == 0)
                            highlight_width += s.SpacingBetweenMidCols;
                    }
                    draw_list->AddRectFilled(pos, ImVec2(pos.x + highlight_width, pos.y + s.LineHeight), HighlightColor);
                }

                if (DataEditingAddr == addr)
                {
                    // Display text input on current byte
                    bool data_write = false;
                    ImGui::PushID((void*)addr);
                    if (DataEditingTakeFocus)
                    {
                        ImGui::SetKeyboardFocusHere();
                        ImGui::CaptureKeyboardFromApp(true);
                        sprintf(AddrInputBuf, format_data, s.AddrDigitsCount, base_display_addr + addr);
                        sprintf(DataInputBuf, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
                    }
                    ImGui::PushItemWidth(s.GlyphWidth * 2);
                    struct UserData
                    {
                        // FIXME: We should have a way to retrieve the text edit cursor position more easily in the API, this is rather tedious. This is such a ugly mess we may be better off not using InputText() at all here.
                        static int Callback(ImGuiInputTextCallbackData* data)
                        {
                            UserData* user_data = (UserData*)data->UserData;
                            if (!data->HasSelection())
                                user_data->CursorPos = data->CursorPos;
                            if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen)
                            {
                                // When not editing a byte, always rewrite its content (this is a bit tricky, since InputText technically "owns" the master copy of the buffer we edit it in there)
                                data->DeleteChars(0, data->BufTextLen);
                                data->InsertChars(0, user_data->CurrentBufOverwrite);
                                data->SelectionStart = 0;
                                data->SelectionEnd = 2;
                                data->CursorPos = 0;
                            }
                            return 0;
                        }
                        char   CurrentBufOverwrite[3];  // Input
                        int    CursorPos;               // Output
                    };
                    UserData user_data;
                    user_data.CursorPos = -1;
                    sprintf(user_data.CurrentBufOverwrite, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
                    ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_AlwaysInsertMode | ImGuiInputTextFlags_CallbackAlways;
                    if (ImGui::InputText("##data", DataInputBuf, 32, flags, UserData::Callback, &user_data))
                        data_write = data_next = true;
                    else if (!DataEditingTakeFocus && !ImGui::IsItemActive())
                        DataEditingAddr = data_editing_addr_next = (size_t)-1;
                    DataEditingTakeFocus = false;
                    ImGui::PopItemWidth();
                    if (user_data.CursorPos >= 2)
                        data_write = data_next = true;
                    if (data_editing_addr_next != (size_t)-1)
                        data_write = data_next = false;
                    unsigned int data_input_value = 0;
                    if (data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1)
                    {
                        if (WriteFn)
                            WriteFn(mem_data, addr, (ImU8)data_input_value);
                        else
                            mem_data[addr] = (ImU8)data_input_value;
                    }
                    ImGui::PopID();
                }
                else
                {
                    // NB: The trailing space is not visible but ensure there's no gap that the mouse cannot click on.
                    ImU8 b = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];

                    if (OptShowHexII)
                    {
                        if ((b >= 32 && b < 128))
                            ImGui::Text(".%c ", b);
                        else if (b == 0xFF && OptGreyOutZeroes)
                            ImGui::TextDisabled("## ");
                        else if (b == 0x00)
                            ImGui::Text("   ");
                        else
                            ImGui::Text(format_byte_space, b);
                    }
                    else
                    {
                        if (b == 0 && OptGreyOutZeroes)
                            ImGui::TextDisabled("00 ");
                        else
                            ImGui::Text(format_byte_space, b);
                    }
                    if (!ReadOnly && ImGui::IsItemHovered() && ImGui::IsMouseClicked(0))
                    {
                        DataEditingTakeFocus = true;
                        data_editing_addr_next = addr;
                    }
                }
            }

            if (OptShowAscii)
            {
                // Draw ASCII values
                ImGui::SameLine(s.PosAsciiStart);
                ImVec2 pos = ImGui::GetCursorScreenPos();
                addr = line_i * Cols;
                ImGui::PushID(line_i);
                if (ImGui::InvisibleButton("ascii", ImVec2(s.PosAsciiEnd - s.PosAsciiStart, s.LineHeight)))
                {
                    DataEditingAddr = DataPreviewAddr = addr + (size_t)((ImGui::GetIO().MousePos.x - pos.x) / s.GlyphWidth);
                    DataEditingTakeFocus = true;
                }
                ImGui::PopID();
                for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
                {
                    if (addr == DataEditingAddr)
                    {
                        draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg));
                        draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
                    }
                    unsigned char c = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
                    char display_c = (c < 32 || c >= 128) ? '.' : c;
                    draw_list->AddText(pos, (display_c == c) ? color_text : color_disabled, &display_c, &display_c + 1);
                    pos.x += s.GlyphWidth;
                }
            }
        }
        IM_ASSERT(clipper.Step() == false);
        clipper.End();
        ImGui::PopStyleVar(2);
        ImGui::EndChild();

        if (data_next && DataEditingAddr < mem_size)
        {
            DataEditingAddr = DataPreviewAddr = DataEditingAddr + 1;
            DataEditingTakeFocus = true;
        }
        else if (data_editing_addr_next != (size_t)-1)
        {
            DataEditingAddr = DataPreviewAddr = data_editing_addr_next;
        }

        const bool lock_show_data_preview = OptShowDataPreview;
        if (OptShowOptions)
        {
            ImGui::Separator();
            DrawOptionsLine(s, mem_data, mem_size, base_display_addr);
        }

        if (lock_show_data_preview)
        {
            ImGui::Separator();
            DrawPreviewLine(s, mem_data, mem_size, base_display_addr);
        }

        // Notify the main window of our ideal child content size (FIXME: we are missing an API to get the contents size from the child)
        ImGui::SetCursorPosX(s.WindowWidth);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
cmpl $0x0, 0x4(%rdi)
jg 0x319ad
movl $0x1, 0x4(%r14)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
andq $0x0, 0x20(%rsi)
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x31838
callq 0x35cfd
movss 0x4c(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm1, %xmm1
cmpb $0x1, 0x8(%r14)
jne 0x319fb
callq 0x43eea
addss -0x48(%rbp), %xmm0
xorps %xmm1, %xmm1
addss %xmm0, %xmm1
cmpb $0x1, 0x9(%r14)
jne 0x31a33
movaps %xmm1, -0x60(%rbp)
callq 0x43eea
movss -0x48(%rbp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0x48(%rbp)
callq 0x43eac
movaps -0x60(%rbp), %xmm1
mulss 0x6a5da(%rip), %xmm0    # 0x9c004
addss -0x48(%rbp), %xmm0
addss %xmm0, %xmm1
xorps 0x6a5a6(%rip), %xmm1    # 0x9bfe0
leaq -0xec(%rbp), %rbx
andl $0x0, (%rbx)
movss %xmm1, 0x4(%rbx)
leaq 0x6a8e2(%rip), %rdi     # 0x9c332
movq %rbx, %rsi
xorl %edx, %edx
movl $0xc0004, %ecx          # imm = 0xC0004
callq 0x40abf
callq 0x42af8
movq %rax, -0x70(%rbp)
andq $0x0, (%rbx)
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x35fca
andq $0x0, (%rbx)
pushq $0xd
popq %rdi
leaq -0xec(%rbp), %rsi
callq 0x35fca
movq %r14, -0x60(%rbp)
movslq 0x4(%r14), %rcx
leaq (%r12,%rcx), %rax
decq %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
leaq -0xec(%rbp), %r14
movq %r14, %rdi
callq 0x358c6
movss -0xac(%rbp), %xmm0
movq %r14, %rdi
movl %ebx, %esi
callq 0x35904
leaq -0xec(%rbp), %rdi
callq 0x35aa6
movq -0x60(%rbp), %r14
movq 0x48(%r14), %rbx
cmpq %r12, %rbx
setae %al
orb 0x1(%r14), %al
cmpb $0x1, %al
jne 0x31aec
orq $-0x1, 0x48(%r14)
pushq $-0x1
popq %rbx
cmpq %r12, 0x40(%r14)
jb 0x31af7
orq $-0x1, 0x40(%r14)
movslq -0xec(%rbp), %rcx
movslq 0x4(%r14), %rax
movq %rax, -0x78(%rbp)
movslq -0xe8(%rbp), %rax
cmpb $0x1, 0x9(%r14)
movq %rax, -0x48(%rbp)
movq %rcx, -0x68(%rbp)
jne 0x31b38
movl 0xb4(%r14), %esi
movq %r14, %rdi
callq 0x32590
movq %rax, -0x100(%rbp)
movq 0x48(%r14), %rbx
jmp 0x31b43
movq $0x0, -0x100(%rbp)
pushq $-0x1
popq %r13
cmpq $-0x1, %rbx
je 0x31c62
pushq $0x3
popq %rdi
callq 0x3ffc8
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x400fa
testb %al, %al
je 0x31b7c
movq -0x60(%rbp), %rax
movq 0x48(%rax), %r14
movslq 0x4(%rax), %rax
subq %rax, %r14
jae 0x31c09
pushq $0x4
popq %rdi
callq 0x3ffc8
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x400fa
testb %al, %al
je 0x31bae
movq -0x60(%rbp), %rax
movq 0x48(%rax), %r14
movslq 0x4(%rax), %rax
movq %r12, %rcx
subq %rax, %rcx
cmpq %rcx, %r14
jae 0x31bae
addq %rax, %r14
jmp 0x31c09
pushq $0x1
popq %rdi
callq 0x3ffc8
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x400fa
testb %al, %al
je 0x31bde
movq -0x60(%rbp), %rax
movq 0x48(%rax), %r14
testq %r14, %r14
je 0x31bde
decq %r14
movq -0x60(%rbp), %rax
movb $0x1, 0x50(%rax)
jmp 0x31c17
pushq $0x2
popq %rdi
callq 0x3ffc8
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x400fa
testb %al, %al
je 0x31c62
leaq -0x1(%r12), %rax
movq -0x60(%rbp), %rcx
movq 0x48(%rcx), %r14
cmpq %rax, %r14
jae 0x31c62
incq %r14
movq -0x60(%rbp), %rax
movb $0x1, 0x50(%rax)
cmpq $-0x1, %r14
je 0x31c62
movq -0x60(%rbp), %rax
movslq 0x4(%rax), %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r13
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
cmpq %rax, %r13
je 0x31c5f
movq -0x48(%rbp), %rdx
movq -0x78(%rbp), %rsi
imulq %rsi, %rdx
subl %eax, %r13d
js 0x324f0
je 0x31c5f
addl %ecx, %ecx
movslq %ecx, %rax
subq %rax, %rdx
cmpq %rdx, %r14
ja 0x32502
movq %r14, %r13
callq 0x427a9
movq -0x60(%rbp), %r14
cmpb $0x1, 0xb(%r14)
jne 0x31cd1
movss -0x94(%rbp), %xmm1
addss %xmm0, %xmm1
subss -0xa8(%rbp), %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
addss 0x6a36c(%rip), %xmm0    # 0x9c008
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
pushq $0x5
popq %rdi
movss 0x6a347(%rip), %xmm0    # 0x9bff8
callq 0x35d33
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movss 0x6a332(%rip), %xmm0    # 0x9bff8
movq -0x70(%rbp), %rdi
movl %eax, %ecx
callq 0x63ec2
movss 0x6a31f(%rip), %xmm0    # 0x9bff8
xorl %edi, %edi
callq 0x35d33
cmpb $0x1, 0xc(%r14)
movl %eax, -0xcc(%rbp)
movl %eax, -0x7c(%rbp)
jne 0x31d03
pushq $0x1
popq %rdi
movss 0x6a2fd(%rip), %xmm0    # 0x9bff8
callq 0x35d33
movl %eax, -0x7c(%rbp)
leaq 0x6a634(%rip), %rax     # 0x9c33e
cmpb $0x0, 0xd(%r14)
leaq 0x6a630(%rip), %rcx     # 0x9c346
cmovneq %rax, %rcx
movq %rcx, -0x108(%rbp)
leaq 0x6a759(%rip), %rax     # 0x9c481
leaq 0x6a765(%rip), %rcx     # 0x9c494
cmovneq %rax, %rcx
movq %rcx, -0x120(%rbp)
leaq 0x87b31(%rip), %rax     # 0xb9872
leaq 0x6a870(%rip), %rcx     # 0x9c5b8
cmovneq %rax, %rcx
movq %rcx, -0xf8(%rbp)
leaq 0x6a5f4(%rip), %rax     # 0x9c34e
leaq 0x6a5f3(%rip), %rcx     # 0x9c354
cmovneq %rax, %rcx
movq %rcx, -0xb8(%rbp)
movl -0xec(%rbp), %ebx
leaq 0x71(%r14), %rax
movq %rax, -0x118(%rbp)
leaq 0x51(%r14), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0x68(%rbp)
movq %r12, -0x128(%rbp)
cmpl -0xe8(%rbp), %ebx
jge 0x3241e
movq %r13, -0xc0(%rbp)
movslq 0x4(%r14), %r13
movslq %ebx, %rax
movq %rax, -0x110(%rbp)
imulq %rax, %r13
movl -0xb0(%rbp), %esi
leaq (%r15,%r13), %rdx
movq -0x108(%rbp), %rdi
xorl %eax, %eax
callq 0x795ac
xorl %eax, %eax
movl %ebx, -0x78(%rbp)
movq %rax, -0x48(%rbp)
cmpl 0x4(%r14), %eax
jge 0x32209
cmpq %r12, %r13
jae 0x32209
movq -0x48(%rbp), %rax
cvtsi2ss %eax, %xmm0
mulss -0xa4(%rbp), %xmm0
addss -0x9c(%rbp), %xmm0
movl 0x10(%r14), %ecx
testl %ecx, %ecx
jle 0x31e23
xorl %edx, %edx
divl %ecx
cvtsi2ss %eax, %xmm1
mulss -0xa0(%rbp), %xmm1
addss %xmm1, %xmm0
movss 0x6a1c5(%rip), %xmm1    # 0x9bff0
callq 0x437ec
cmpq 0xa0(%r14), %r13
setae %bl
movq 0x30(%r14), %rax
cmpq 0xa8(%r14), %r13
setb %r14b
testq %rax, %rax
je 0x31e59
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x31e5b
xorl %eax, %eax
andb %r14b, %bl
movq -0x60(%rbp), %r14
movq 0x40(%r14), %rdx
cmpq %rdx, %r13
setae %cl
addq -0x100(%rbp), %rdx
cmpq %rdx, %r13
setb %dl
orb %al, %bl
movl -0x78(%rbp), %ebx
jne 0x31e88
andb %dl, %cl
je 0x31f57
callq 0x438bd
movlps %xmm0, -0x30(%rbp)
movss -0xa8(%rbp), %xmm0
movss %xmm0, -0xd0(%rbp)
leaq 0x1(%r13), %rsi
cmpq %r12, %rsi
jae 0x31ecf
movq 0xa8(%r14), %rax
cmpq $-0x1, %rax
je 0x31ebc
cmpq %rax, %rsi
jb 0x31edb
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x31ecf
movq -0x40(%rbp), %rdi
callq *%rax
testb %al, %al
jne 0x31edb
movq -0x48(%rbp), %rax
incl %eax
cmpl 0x4(%r14), %eax
jne 0x31f13
movss -0xa4(%rbp), %xmm0
movl 0x10(%r14), %ecx
testl %ecx, %ecx
setle %al
movq -0x48(%rbp), %rsi
testl %esi, %esi
sete %dl
orb %al, %dl
jne 0x31f0e
leal 0x1(%rsi), %eax
cmpl 0x4(%r14), %eax
jge 0x31f0e
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x321f9
movaps %xmm0, %xmm1
jmp 0x31f1f
movss -0xd0(%rbp), %xmm1
addss %xmm1, %xmm1
addss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm0
addss -0xac(%rbp), %xmm0
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
movl 0x18(%r14), %ecx
xorps %xmm0, %xmm0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
pushq $0xf
popq %r8
callq 0x64020
cmpq 0x48(%r14), %r13
jne 0x31fb9
movq %r13, %rdi
callq 0x42f1f
cmpb $0x1, 0x50(%r14)
jne 0x320a7
xorl %edi, %edi
callq 0x42c68
pushq $0x1
popq %rdi
callq 0x40503
movl -0xb0(%rbp), %edx
leaq (%r15,%r13), %rcx
movq -0x118(%rbp), %rdi
movq -0x120(%rbp), %rsi
xorl %eax, %eax
callq 0xc8d0
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x32087
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x3208f
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x31fcd
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x31fd5
movq -0x40(%rbp), %rax
movb (%rax,%r13), %al
movzbl %al, %esi
cmpb $0x1, 0xa(%r14)
jne 0x32018
leaq 0x6a37b(%rip), %rdi     # 0x9c361
cmpb $0x1f, %al
jg 0x32044
testl %esi, %esi
je 0x321e6
movq -0xb8(%rbp), %rdi
cmpl $0xff, %esi
jne 0x32044
cmpb $0x0, 0xc(%r14)
leaq 0x6a359(%rip), %rax     # 0x9c366
movq -0xb8(%rbp), %rdi
jne 0x32038
jmp 0x32044
movq -0xb8(%rbp), %rdi
testl %esi, %esi
jne 0x32044
cmpb $0x1, 0xc(%r14)
leaq 0x6a33b(%rip), %rax     # 0x9c36a
movq -0xb8(%rbp), %rdi
jne 0x32044
movq %rax, %rdi
xorl %eax, %eax
callq 0x79774
jmp 0x3204b
xorl %eax, %eax
callq 0x795ac
cmpb $0x0, 0x1(%r14)
jne 0x321d8
xorl %edi, %edi
callq 0x374fd
testb %al, %al
je 0x321d8
xorl %edi, %edi
xorl %esi, %esi
callq 0x401cd
testb %al, %al
je 0x321d8
movb $0x1, 0x50(%r14)
movq %r13, -0xc0(%rbp)
jmp 0x321d8
movq -0x40(%rbp), %rax
movb (%rax,%r13), %al
movzbl %al, %edx
movq -0xc8(%rbp), %rdi
movq -0xf8(%rbp), %rsi
xorl %eax, %eax
callq 0xc8d0
movss -0xa8(%rbp), %xmm0
addss %xmm0, %xmm0
callq 0x43b8c
orl $-0x1, -0x2c(%rbp)
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x320d0
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x320d8
movq -0x40(%rbp), %rax
movb (%rax,%r13), %al
movzbl %al, %edx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq -0xf8(%rbp), %rsi
xorl %eax, %eax
callq 0xc8d0
leaq 0x6a263(%rip), %rdi     # 0x9c35a
movq -0xc8(%rbp), %rsi
pushq $0x20
popq %rdx
movl $0x3132, %ecx           # imm = 0x3132
leaq 0x4b9(%rip), %r8        # 0x325c6
movq %rbx, %r9
callq 0x83c1c
movl %eax, %ebx
testb %al, %al
je 0x32122
movb $0x1, %al
movl %eax, -0x68(%rbp)
jmp 0x32141
cmpb $0x0, 0x50(%r14)
jne 0x32141
callq 0x40529
testb %al, %al
jne 0x32141
orq $-0x1, 0x48(%r14)
pushq $-0x1
popq %rax
movq %rax, -0xc0(%rbp)
movb $0x0, 0x50(%r14)
callq 0x43cbe
movq %r15, %r12
cmpl $0x2, -0x2c(%rbp)
setge %r15b
orb %r15b, %bl
cmpq $-0x1, -0xc0(%rbp)
sete %r14b
andb %r14b, %bl
andl $0x0, -0x38(%rbp)
cmpb $0x1, %bl
movl -0x78(%rbp), %ebx
jne 0x321b8
movq -0xc8(%rbp), %rdi
leaq 0x6e3c3(%rip), %rsi     # 0xa0545
leaq -0x38(%rbp), %rdx
xorl %eax, %eax
callq 0xc0c0
cmpl $0x1, %eax
jne 0x321b8
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rax
movb -0x38(%rbp), %cl
testq %rax, %rax
je 0x321b0
movzbl %cl, %edx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x321b8
movq -0x40(%rbp), %rax
movb %cl, (%rax,%r13)
callq 0x42fea
orb -0x68(%rbp), %r15b
andb %r15b, %r14b
movl %r14d, %eax
movl %eax, -0x68(%rbp)
movq %r12, %r15
movq -0x128(%rbp), %r12
movq -0x60(%rbp), %r14
movq -0x48(%rbp), %rax
incl %eax
incq %r13
jmp 0x31dd8
leaq 0x6e041(%rip), %rdi     # 0xa022e
xorl %eax, %eax
callq 0x795ac
jmp 0x3204b
movaps %xmm0, %xmm1
addss -0xa0(%rbp), %xmm1
jmp 0x31f1f
cmpb $0x0, 0xb(%r14)
je 0x32410
movss -0x94(%rbp), %xmm0
movss 0x69dcc(%rip), %xmm1    # 0x9bff0
callq 0x437ec
callq 0x438bd
movl -0xcc(%rbp), %r13d
movlps %xmm0, -0x30(%rbp)
movq -0x60(%rbp), %rax
movslq 0x4(%rax), %r14
movl %ebx, %edi
callq 0x42f5a
movss -0xac(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
subss -0x94(%rbp), %xmm1
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
leaq 0x6a0fd(%rip), %rdi     # 0x9c36e
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x7a6a4
imulq -0x110(%rbp), %r14
testb %al, %al
je 0x322d4
callq 0x37e82
movss 0x120(%rax), %xmm0
subss -0x30(%rbp), %xmm0
divss -0xa8(%rbp), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x69d56(%rip), %xmm0    # 0x9c00c
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
addq %r14, %rdx
movq -0x60(%rbp), %rax
movq %rdx, 0x40(%rax)
movq %rdx, 0x48(%rax)
movb $0x1, 0x50(%rax)
callq 0x42fea
xorl %ebx, %ebx
movq -0x60(%rbp), %rax
cmpl 0x4(%rax), %ebx
jge 0x32409
cmpq %r12, %r14
jae 0x32409
movq -0x60(%rbp), %rax
cmpq 0x48(%rax), %r14
jne 0x3239f
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
addss -0xa8(%rbp), %xmm0
addss -0xac(%rbp), %xmm1
movss %xmm0, -0x38(%rbp)
movss %xmm1, -0x34(%rbp)
pushq $0x7
popq %rdi
movss 0x69cca(%rip), %xmm0    # 0x9bff8
callq 0x35d33
xorps %xmm0, %xmm0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %eax, %ecx
pushq $0xf
popq %r8
callq 0x64020
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
addss -0xa8(%rbp), %xmm0
addss -0xac(%rbp), %xmm1
movss %xmm0, -0x38(%rbp)
movss %xmm1, -0x34(%rbp)
pushq $0x2f
popq %rdi
movss 0x69c7c(%rip), %xmm0    # 0x9bff8
callq 0x35d33
xorps %xmm0, %xmm0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %eax, %ecx
pushq $0xf
popq %r8
callq 0x64020
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x323b3
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq *%rax
jmp 0x323bb
movq -0x40(%rbp), %rax
movb (%rax,%r14), %al
movzbl %al, %eax
cmpb $0x20, %al
movl %eax, %ecx
pushq $0x2e
popq %rdx
cmovll %edx, %ecx
movb %cl, -0x38(%rbp)
movsbl %cl, %ecx
movl %r13d, %edx
cmpl %eax, %ecx
je 0x323d8
movl -0x7c(%rbp), %edx
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rcx
leaq -0x37(%rbp), %r8
callq 0x64eb6
movss -0xa8(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
incl %ebx
incq %r14
jmp 0x322db
movq -0x60(%rbp), %r14
movl -0x78(%rbp), %ebx
incl %ebx
movq -0xc0(%rbp), %r13
jmp 0x31d96
leaq -0xec(%rbp), %rdi
callq 0x35aa6
testb %al, %al
jne 0x32528
leaq -0xec(%rbp), %rdi
callq 0x35976
pushq $0x2
popq %rdi
callq 0x3605c
callq 0x40b4b
testb $0x1, -0x68(%rbp)
je 0x3246c
movq 0x48(%r14), %rax
cmpq %r12, %rax
jae 0x3246c
incq %rax
movq %rax, 0x40(%r14)
movq %rax, 0x48(%r14)
movb $0x1, 0x50(%r14)
jmp 0x3247a
cmpq $-0x1, %r13
je 0x3247a
movq %r13, 0x40(%r14)
movq %r13, 0x48(%r14)
movb 0x9(%r14), %bl
cmpb $0x1, 0x8(%r14)
jne 0x324a3
callq 0x7cad7
leaq -0xb0(%rbp), %rsi
movq %r14, %rdi
movq -0x40(%rbp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x3261a
testb %bl, %bl
je 0x324c5
callq 0x7cad7
leaq -0xb0(%rbp), %rsi
movq %r14, %rdi
movq -0x40(%rbp), %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x328ca
movss -0x8c(%rbp), %xmm0
callq 0x43a09
leaq -0xec(%rbp), %rdi
callq 0x358da
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
imulq -0x68(%rbp), %rsi
leaq (%rsi,%rcx,2), %rax
cmpq %rax, %r14
jae 0x31c5f
callq 0x443a1
cvtsi2ss %r13d, %xmm1
mulss -0xac(%rbp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x44436
movq %r14, %r13
jmp 0x31c62
leaq 0x69e45(%rip), %rdi     # 0x9c374
leaq 0x69e56(%rip), %rsi     # 0x9c38c
leaq 0x69e93(%rip), %rcx     # 0x9c3d0
movl $0x1a8, %edx            # imm = 0x1A8
callq 0xc140
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
jmp 0x32579
movq %rax, %rbx
leaq -0xec(%rbp), %rdi
callq 0x358da
movq %rbx, %rdi
callq 0xc580