// File: /workspace/github_cpp_makefile_star2_O1/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 $0xe8, %rsp
movq %rcx, %r15
movq %rsi, -0x40(%rbp)
movq %rdi, %r12
cmpl $0x0, 0x4(%rdi)
jg 0x3f1d3
movl $0x1, 0x4(%r12)
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x20(%rsi)
movq %r12, %rdi
movq %rdx, -0x58(%rbp)
movq %r15, %rcx
callq 0x3f05a
callq 0x44587
movss 0x4c(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm1, %xmm1
cmpb $0x1, 0x8(%r12)
jne 0x3f226
callq 0x57425
addss -0x48(%rbp), %xmm0
xorps %xmm1, %xmm1
addss %xmm0, %xmm1
cmpb $0x1, 0x9(%r12)
jne 0x3f265
movaps %xmm1, -0xf0(%rbp)
callq 0x57425
movss -0x48(%rbp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0x48(%rbp)
callq 0x573e7
movaps -0xf0(%rbp), %xmm1
mulss 0x77d94(%rip), %xmm0    # 0xb6ff0
addss -0x48(%rbp), %xmm0
addss %xmm0, %xmm1
xorps 0x77d54(%rip), %xmm1    # 0xb6fc0
leaq -0xd4(%rbp), %rbx
movl $0x0, (%rbx)
movss %xmm1, 0x4(%rbx)
leaq 0x78099(%rip), %rdi     # 0xb731e
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %edx, %edx
movl $0xc0004, %ecx          # imm = 0xC0004
callq 0x53078
callq 0x557cb
movq %rax, %r13
movq %r14, (%rbx)
movl $0xa, %edi
movq %rbx, %rsi
callq 0x44ba2
movq %r14, (%rbx)
leaq -0xd4(%rbp), %rsi
movl $0xd, %edi
callq 0x44ba2
movslq 0x4(%r12), %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
decq %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
leaq -0xd4(%rbp), %r14
movq %r14, %rdi
callq 0x44130
movss -0x8c(%rbp), %xmm0
movq %r14, %rdi
movl %ebx, %esi
callq 0x44172
leaq -0xd4(%rbp), %rdi
callq 0x44316
cmpb $0x0, 0x1(%r12)
jne 0x3f31a
movq -0x58(%rbp), %rax
cmpq %rax, 0x48(%r12)
jb 0x3f323
movq $-0x1, 0x48(%r12)
movq %r13, -0xa8(%rbp)
movq %r15, -0x98(%rbp)
movq -0x58(%rbp), %rax
cmpq %rax, 0x40(%r12)
jb 0x3f345
movq $-0x1, 0x40(%r12)
movslq -0xd4(%rbp), %r13
movslq 0x4(%r12), %rax
movq %rax, -0x48(%rbp)
movslq -0xd0(%rbp), %r15
cmpb $0x1, 0x9(%r12)
jne 0x3f38a
movl 0xb4(%r12), %eax
cmpq $0xa, %rax
jae 0x3fddc
leaq 0x78363(%rip), %rcx     # 0xb76e0
movq (%rcx,%rax,8), %rax
movq %rax, -0xf0(%rbp)
jmp 0x3f395
movq $0x0, -0xf0(%rbp)
movq 0x48(%r12), %rbx
cmpq $-0x1, %rbx
je 0x3f46f
movl $0x3, %edi
callq 0x5243e
movl %eax, %edi
movl $0x1, %esi
callq 0x5256e
testb %al, %al
je 0x3f3d1
movq 0x48(%r12), %rax
movslq 0x4(%r12), %rcx
subq %rcx, %rax
jae 0x3f464
movl $0x4, %edi
callq 0x5243e
movl %eax, %edi
movl $0x1, %esi
callq 0x5256e
testb %al, %al
je 0x3f406
movq 0x48(%r12), %rax
movslq 0x4(%r12), %rcx
movq -0x58(%rbp), %rdx
subq %rcx, %rdx
cmpq %rdx, %rax
jae 0x3f406
addq %rcx, %rax
jmp 0x3f464
movl $0x1, %edi
callq 0x5243e
movl %eax, %edi
movl $0x1, %esi
callq 0x5256e
testb %al, %al
je 0x3f42f
movq 0x48(%r12), %rax
testq %rax, %rax
je 0x3f42f
decq %rax
jmp 0x3f464
movl $0x2, %edi
callq 0x5243e
movl %eax, %edi
movl $0x1, %esi
callq 0x5256e
testb %al, %al
je 0x3f46f
movq 0x48(%r12), %rax
movq -0x58(%rbp), %rcx
decq %rcx
cmpq %rcx, %rax
movq $-0x1, %rcx
jae 0x3f476
incq %rax
movb $0x1, 0x50(%r12)
movq %rax, %rcx
jmp 0x3f476
movq $-0x1, %rcx
movq %rcx, -0x50(%rbp)
cmpq $-0x1, %rcx
je 0x3f4ef
movslq 0x4(%r12), %rcx
movq -0x50(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r14
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
cmpq %rax, %r14
je 0x3f4ef
subl %eax, %r14d
jns 0x3f4b9
imulq -0x48(%rbp), %r13
leaq (,%rcx,2), %rax
addq %r13, %rax
cmpq %rax, -0x50(%rbp)
jb 0x3f4d1
testl %r14d, %r14d
jle 0x3f4ef
imulq -0x48(%rbp), %r15
addl %ecx, %ecx
movslq %ecx, %rax
subq %rax, %r15
cmpq %r15, -0x50(%rbp)
jbe 0x3f4ef
callq 0x57a25
cvtsi2ss %r14d, %xmm1
mulss -0x8c(%rbp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x57aba
callq 0x553ff
cmpb $0x1, 0xb(%r12)
movq -0x58(%rbp), %r15
movq -0xa8(%rbp), %rbx
movq -0x50(%rbp), %r13
jne 0x3f568
movss -0x74(%rbp), %xmm1
addss %xmm0, %xmm1
subss -0x88(%rbp), %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm1, -0x30(%rbp)
movss %xmm0, -0x2c(%rbp)
addss 0x77ac2(%rip), %xmm0    # 0xb6ff4
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
movss 0x77aa0(%rip), %xmm0    # 0xb6fe4
movl $0x5, %edi
callq 0x445bd
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movss 0x77a86(%rip), %xmm0    # 0xb6fe4
movq %rbx, %rdi
movl %eax, %ecx
callq 0x79abc
movss 0x77a74(%rip), %xmm0    # 0xb6fe4
xorl %edi, %edi
callq 0x445bd
movl %eax, %ebx
cmpb $0x1, 0xc(%r12)
movl %eax, -0x60(%rbp)
jne 0x3f599
movss 0x77a58(%rip), %xmm0    # 0xb6fe4
movl $0x1, %edi
callq 0x445bd
movl %eax, -0x60(%rbp)
movl %ebx, -0xb4(%rbp)
leaq 0x77d84(%rip), %rax     # 0xb732a
leaq 0x77d85(%rip), %rcx     # 0xb7332
cmpb $0x0, 0xd(%r12)
cmovneq %rax, %rcx
movq %rcx, -0xf8(%rbp)
leaq 0x77ea8(%rip), %rax     # 0xb746d
leaq 0x77eb4(%rip), %rcx     # 0xb7480
cmovneq %rax, %rcx
movq %rcx, -0x110(%rbp)
leaq 0x95077(%rip), %rax     # 0xd4655
leaq 0x77fbf(%rip), %rcx     # 0xb75a4
cmovneq %rax, %rcx
movq %rcx, -0xe0(%rbp)
leaq 0x77d43(%rip), %rax     # 0xb733a
leaq 0x77d42(%rip), %rcx     # 0xb7340
cmovneq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movl -0xd4(%rbp), %ecx
xorl %ebx, %ebx
cmpl -0xd0(%rbp), %ecx
jge 0x3fcde
movl %ecx, %eax
leaq 0x71(%r12), %rcx
movq %rcx, -0x108(%rbp)
leaq 0x51(%r12), %rcx
movq %rcx, -0xb0(%rbp)
movl $0x0, -0x48(%rbp)
movl %eax, %ebx
movslq 0x4(%r12), %r13
movslq %ebx, %rax
movq %rax, -0x100(%rbp)
imulq %rax, %r13
movl -0x90(%rbp), %esi
movq -0x98(%rbp), %rax
leaq (%rax,%r13), %rdx
movq -0xf8(%rbp), %rdi
xorl %eax, %eax
callq 0x92024
cmpl $0x0, 0x4(%r12)
movl %ebx, -0x5c(%rbp)
jle 0x3fab5
cmpq %r15, %r13
jae 0x3fab5
xorl %ebx, %ebx
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
mulss -0x84(%rbp), %xmm0
addss -0x7c(%rbp), %xmm0
movl 0x10(%r12), %ecx
testl %ecx, %ecx
jle 0x3f6bf
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss -0x80(%rbp), %xmm1
addss %xmm1, %xmm0
movss 0x77909(%rip), %xmm1    # 0xb6fd0
callq 0x569e1
cmpq 0xa0(%r12), %r13
setae %r14b
movq 0x30(%r12), %rax
cmpq 0xa8(%r12), %r13
setb %r15b
testq %rax, %rax
je 0x3f6f9
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x3f6fb
xorl %eax, %eax
andb %r15b, %r14b
movq 0x40(%r12), %rdx
cmpq %rdx, %r13
setae %cl
addq -0xf0(%rbp), %rdx
cmpq %rdx, %r13
setb %dl
orb %al, %r14b
movq -0x58(%rbp), %r15
jne 0x3f727
andb %dl, %cl
je 0x3f7fa
callq 0x56ab2
movlps %xmm0, -0x30(%rbp)
movss -0x88(%rbp), %xmm0
movss %xmm0, -0xb8(%rbp)
leaq 0x1(%r13), %rsi
cmpq %r15, %rsi
jae 0x3f770
movq 0xa8(%r12), %rax
cmpq $-0x1, %rax
je 0x3f75c
cmpq %rax, %rsi
jb 0x3f77a
movq 0x30(%r12), %rax
testq %rax, %rax
je 0x3f770
movq -0x40(%rbp), %rdi
callq *%rax
testb %al, %al
jne 0x3f77a
leal 0x1(%rbx), %eax
cmpl 0x4(%r12), %eax
jne 0x3f7b0
movss -0x84(%rbp), %xmm0
movl 0x10(%r12), %ecx
testl %ecx, %ecx
setle %al
testl %ebx, %ebx
sete %dl
orb %al, %dl
jne 0x3f7ab
leal 0x1(%rbx), %eax
cmpl 0x4(%r12), %eax
jge 0x3f7ab
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x3faa8
movaps %xmm0, %xmm1
jmp 0x3f7bc
movss -0xb8(%rbp), %xmm1
addss %xmm1, %xmm1
addss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm0
addss -0x8c(%rbp), %xmm0
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
movl 0x18(%r12), %ecx
xorps %xmm0, %xmm0
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0xf, %r8d
callq 0x79d4a
cmpq 0x48(%r12), %r13
jne 0x3f868
movq %r13, %rdi
callq 0x55e4b
cmpb $0x1, 0x50(%r12)
jne 0x3f967
xorl %edi, %edi
callq 0x55a16
movl $0x1, %edi
callq 0x529ac
movl -0x90(%rbp), %edx
movq -0x98(%rbp), %rax
leaq (%rax,%r13), %rcx
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %rsi
xorl %eax, %eax
callq 0xc880
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x3f947
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x3f94f
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x3f87d
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x3f885
movq -0x40(%rbp), %rax
movb (%rax,%r13), %al
movzbl %al, %esi
cmpb $0x1, 0xa(%r12)
jne 0x3f8d8
leaq 0x77ab6(%rip), %rdi     # 0xb734d
cmpb $0x1f, %al
jg 0x3f905
testl %esi, %esi
je 0x3f8c8
movq -0xa0(%rbp), %rdi
cmpl $0xff, %esi
jne 0x3f905
cmpb $0x0, 0xc(%r12)
leaq 0x77a97(%rip), %rax     # 0xb7352
jne 0x3f8f9
movq -0xa0(%rbp), %rdi
testl %esi, %esi
jne 0x3f905
leaq 0x7b92f(%rip), %rdi     # 0xbb1fe
xorl %eax, %eax
callq 0x92024
jmp 0x3f90c
movq -0xa0(%rbp), %rdi
testl %esi, %esi
jne 0x3f905
cmpb $0x1, 0xc(%r12)
leaq 0x77a66(%rip), %rax     # 0xb7356
movq -0xa0(%rbp), %rdi
jne 0x3f905
movq %rax, %rdi
xorl %eax, %eax
callq 0x921f2
jmp 0x3f90c
xorl %eax, %eax
callq 0x92024
cmpb $0x0, 0x1(%r12)
jne 0x3fa91
xorl %edi, %edi
callq 0x46d03
testb %al, %al
je 0x3fa91
xorl %edi, %edi
xorl %esi, %esi
callq 0x52641
testb %al, %al
je 0x3fa91
movb $0x1, 0x50(%r12)
movq %r13, -0x50(%rbp)
jmp 0x3fa91
movq -0x40(%rbp), %rax
movb (%rax,%r13), %al
movzbl %al, %edx
movq -0xb0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
xorl %eax, %eax
callq 0xc880
movss -0x88(%rbp), %xmm0
addss %xmm0, %xmm0
callq 0x56dd7
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x3f994
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x3f99c
movq -0x40(%rbp), %rax
movb (%rax,%r13), %al
movzbl %al, %edx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq -0xe0(%rbp), %rsi
xorl %eax, %eax
callq 0xc880
movl $0x20, %edx
leaq 0x77986(%rip), %rdi     # 0xb7346
movq -0xb0(%rbp), %rsi
movl $0x3132, %ecx           # imm = 0x3132
leaq 0x471(%rip), %r8        # 0x3fe44
movq %r14, %r9
callq 0x9cdd6
movl %eax, %r14d
testb %al, %al
je 0x3f9e9
movb $0x1, %al
movl %eax, -0x48(%rbp)
jmp 0x3fa0b
cmpb $0x0, 0x50(%r12)
jne 0x3fa0b
callq 0x529d2
testb %al, %al
jne 0x3fa0b
movq $-0x1, 0x48(%r12)
movq $-0x1, -0x50(%rbp)
movb $0x0, 0x50(%r12)
callq 0x571b8
cmpl $0x2, -0x2c(%rbp)
setge %al
movl -0x48(%rbp), %edx
movzbl %dl, %edx
movl $0x1, %ecx
cmovgel %ecx, %edx
orb %al, %r14b
cmpq $-0x1, -0x50(%rbp)
movl $0x0, %ecx
cmovnel %ecx, %edx
movl %edx, -0x48(%rbp)
sete %al
andb %r14b, %al
movl %ecx, -0x38(%rbp)
cmpb $0x1, %al
jne 0x3fa8c
movq -0xb0(%rbp), %rdi
leaq 0x7babc(%rip), %rsi     # 0xbb515
leaq -0x38(%rbp), %rdx
xorl %eax, %eax
callq 0xc0c0
cmpl $0x1, %eax
jne 0x3fa8c
movq 0x28(%r12), %rax
movb -0x38(%rbp), %cl
testq %rax, %rax
je 0x3fa84
movzbl %cl, %edx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq *%rax
jmp 0x3fa8c
movq -0x40(%rbp), %rax
movb %cl, (%rax,%r13)
callq 0x56188
incl %ebx
cmpl 0x4(%r12), %ebx
jge 0x3fab5
incq %r13
cmpq %r15, %r13
jb 0x3f68c
jmp 0x3fab5
movaps %xmm0, %xmm1
addss -0x80(%rbp), %xmm1
jmp 0x3f7bc
cmpb $0x0, 0xb(%r12)
je 0x3fcbd
movss -0x74(%rbp), %xmm0
movss 0x77502(%rip), %xmm1    # 0xb6fd0
callq 0x569e1
callq 0x56ab2
movq -0xa8(%rbp), %r13
movlps %xmm0, -0x30(%rbp)
movslq 0x4(%r12), %rbx
movl -0x5c(%rbp), %edi
callq 0x55f53
movss -0x8c(%rbp), %xmm0
movss -0x70(%rbp), %xmm1
subss -0x74(%rbp), %xmm1
movss %xmm1, -0x38(%rbp)
movss %xmm0, -0x34(%rbp)
leaq 0x77847(%rip), %rdi     # 0xb735a
leaq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x93187
imulq -0x100(%rbp), %rbx
testb %al, %al
je 0x3fb76
callq 0x47c7c
movss 0x120(%rax), %xmm0
subss -0x30(%rbp), %xmm0
divss -0x88(%rbp), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x774a0(%rip), %xmm0    # 0xb6ff8
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
addq %rbx, %rdx
movq %rdx, 0x40(%r12)
movq %rdx, 0x48(%r12)
movb $0x1, 0x50(%r12)
callq 0x56188
cmpl $0x0, 0x4(%r12)
jle 0x3fcbd
cmpq %r15, %rbx
jae 0x3fcbd
movl $0x1, %r14d
cmpq 0x48(%r12), %rbx
jne 0x3fc43
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
addss -0x88(%rbp), %xmm0
addss -0x8c(%rbp), %xmm1
movss %xmm0, -0x38(%rbp)
movss %xmm1, -0x34(%rbp)
movl $0x7, %edi
movss 0x77412(%rip), %xmm0    # 0xb6fe4
callq 0x445bd
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0x79d4a
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
addss -0x88(%rbp), %xmm0
addss -0x8c(%rbp), %xmm1
movss %xmm0, -0x38(%rbp)
movss %xmm1, -0x34(%rbp)
movl $0x2f, %edi
movss 0x773c1(%rip), %xmm0    # 0xb6fe4
callq 0x445bd
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0x79d4a
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x3fc58
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq *%rax
jmp 0x3fc5f
movq -0x40(%rbp), %rax
movb (%rax,%rbx), %al
movzbl %al, %eax
cmpb $0x20, %al
movl %eax, %ecx
movl $0x2e, %edx
cmovll %edx, %ecx
movb %cl, -0x38(%rbp)
movsbl %cl, %ecx
movl -0xb4(%rbp), %edx
cmpl %eax, %ecx
je 0x3fc81
movl -0x60(%rbp), %edx
movq %r13, %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rcx
leaq -0x37(%rbp), %r8
callq 0x7b6d0
movss -0x88(%rbp), %xmm0
addss -0x30(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
cmpl 0x4(%r12), %r14d
jge 0x3fcbd
incq %rbx
incl %r14d
cmpq %r15, %rbx
jb 0x3fb96
movl -0x5c(%rbp), %ebx
incl %ebx
cmpl -0xd0(%rbp), %ebx
jl 0x3f640
movl -0x48(%rbp), %ebx
movq -0x98(%rbp), %r14
movq -0x50(%rbp), %r13
jmp 0x3fce5
movq -0x98(%rbp), %r14
leaq -0xd4(%rbp), %rdi
callq 0x44316
testb %al, %al
jne 0x3fdbd
leaq -0xd4(%rbp), %rdi
callq 0x441e6
movl $0x2, %edi
callq 0x44d5f
callq 0x53104
testb $0x1, %bl
je 0x3fd38
movq 0x48(%r12), %rax
cmpq %r15, %rax
jae 0x3fd38
incq %rax
movq %rax, 0x40(%r12)
movq %rax, 0x48(%r12)
movb $0x1, 0x50(%r12)
jmp 0x3fd48
cmpq $-0x1, %r13
je 0x3fd48
movq %r13, 0x40(%r12)
movq %r13, 0x48(%r12)
movb 0x9(%r12), %bl
cmpb $0x1, 0x8(%r12)
jne 0x3fd73
callq 0x9552a
leaq -0x90(%rbp), %rsi
movq %r12, %rdi
movq -0x40(%rbp), %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x3fe9e
testb %bl, %bl
je 0x3fd95
callq 0x9552a
leaq -0x90(%rbp), %rsi
movq %r12, %rdi
movq -0x40(%rbp), %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x40168
movss -0x6c(%rbp), %xmm0
callq 0x56c54
leaq -0xd4(%rbp), %rdi
callq 0x44148
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7759c(%rip), %rdi     # 0xb7360
leaq 0x775ad(%rip), %rsi     # 0xb7378
leaq 0x775ea(%rip), %rcx     # 0xb73bc
movl $0x1a8, %edx            # imm = 0x1A8
callq 0xc140
leaq 0x77611(%rip), %rdi     # 0xb73f4
leaq 0x7758e(%rip), %rsi     # 0xb7378
leaq 0x77635(%rip), %rcx     # 0xb7426
movl $0x22c, %edx            # imm = 0x22C
callq 0xc140
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
jmp 0x3fe2d
movq %rax, %rbx
leaq -0xd4(%rbp), %rdi
callq 0x44148
movq %rbx, %rdi
callq 0xc560