// File: Ciaxur[P]yagb-emu/include/imgui/imgui.cpp
// Function: ImGui::ShowMetricsWindow(bool*)
void ImGui::ShowMetricsWindow(bool* p_open)
{
    if (!Begin("Dear ImGui Metrics/Debugger", p_open))
    {
        End();
        return;
    }

    ImGuiContext& g = *GImGui;
    ImGuiIO& io = g.IO;
    ImGuiMetricsConfig* cfg = &g.DebugMetricsConfig;

    // Basic info
    Text("Dear ImGui %s", ImGui::GetVersion());
    Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
    Text("%d vertices, %d indices (%d triangles)", io.MetricsRenderVertices, io.MetricsRenderIndices, io.MetricsRenderIndices / 3);
    Text("%d active windows (%d visible)", io.MetricsActiveWindows, io.MetricsRenderWindows);
    Text("%d active allocations", io.MetricsActiveAllocations);
    //SameLine(); if (SmallButton("GC")) { g.GcCompactAll = true; }

    Separator();

    // Debugging enums
    enum { WRT_OuterRect, WRT_OuterRectClipped, WRT_InnerRect, WRT_InnerClipRect, WRT_WorkRect, WRT_Content, WRT_ContentIdeal, WRT_ContentRegionRect, WRT_Count }; // Windows Rect Type
    const char* wrt_rects_names[WRT_Count] = { "OuterRect", "OuterRectClipped", "InnerRect", "InnerClipRect", "WorkRect", "Content", "ContentIdeal", "ContentRegionRect" };
    enum { TRT_OuterRect, TRT_InnerRect, TRT_WorkRect, TRT_HostClipRect, TRT_InnerClipRect, TRT_BackgroundClipRect, TRT_ColumnsRect, TRT_ColumnsWorkRect, TRT_ColumnsClipRect, TRT_ColumnsContentHeadersUsed, TRT_ColumnsContentHeadersIdeal, TRT_ColumnsContentFrozen, TRT_ColumnsContentUnfrozen, TRT_Count }; // Tables Rect Type
    const char* trt_rects_names[TRT_Count] = { "OuterRect", "InnerRect", "WorkRect", "HostClipRect", "InnerClipRect", "BackgroundClipRect", "ColumnsRect", "ColumnsWorkRect", "ColumnsClipRect", "ColumnsContentHeadersUsed", "ColumnsContentHeadersIdeal", "ColumnsContentFrozen", "ColumnsContentUnfrozen" };
    if (cfg->ShowWindowsRectsType < 0)
        cfg->ShowWindowsRectsType = WRT_WorkRect;
    if (cfg->ShowTablesRectsType < 0)
        cfg->ShowTablesRectsType = TRT_WorkRect;

    struct Funcs
    {
        static ImRect GetTableRect(ImGuiTable* table, int rect_type, int n)
        {
            if (rect_type == TRT_OuterRect)                     { return table->OuterRect; }
            else if (rect_type == TRT_InnerRect)                { return table->InnerRect; }
            else if (rect_type == TRT_WorkRect)                 { return table->WorkRect; }
            else if (rect_type == TRT_HostClipRect)             { return table->HostClipRect; }
            else if (rect_type == TRT_InnerClipRect)            { return table->InnerClipRect; }
            else if (rect_type == TRT_BackgroundClipRect)       { return table->BgClipRect; }
            else if (rect_type == TRT_ColumnsRect)              { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->MinX, table->InnerClipRect.Min.y, c->MaxX, table->InnerClipRect.Min.y + table->LastOuterHeight); }
            else if (rect_type == TRT_ColumnsWorkRect)          { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->WorkRect.Min.y, c->WorkMaxX, table->WorkRect.Max.y); }
            else if (rect_type == TRT_ColumnsClipRect)          { ImGuiTableColumn* c = &table->Columns[n]; return c->ClipRect; }
            else if (rect_type == TRT_ColumnsContentHeadersUsed){ ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y, c->ContentMaxXHeadersUsed, table->InnerClipRect.Min.y + table->LastFirstRowHeight); } // Note: y1/y2 not always accurate
            else if (rect_type == TRT_ColumnsContentHeadersIdeal){ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y, c->ContentMaxXHeadersIdeal, table->InnerClipRect.Min.y + table->LastFirstRowHeight); }
            else if (rect_type == TRT_ColumnsContentFrozen)     { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y, c->ContentMaxXFrozen, table->InnerClipRect.Min.y + table->LastFirstRowHeight); }
            else if (rect_type == TRT_ColumnsContentUnfrozen)   { ImGuiTableColumn* c = &table->Columns[n]; return ImRect(c->WorkMinX, table->InnerClipRect.Min.y + table->LastFirstRowHeight, c->ContentMaxXUnfrozen, table->InnerClipRect.Max.y); }
            IM_ASSERT(0);
            return ImRect();
        }

        static ImRect GetWindowRect(ImGuiWindow* window, int rect_type)
        {
            if (rect_type == WRT_OuterRect)                 { return window->Rect(); }
            else if (rect_type == WRT_OuterRectClipped)     { return window->OuterRectClipped; }
            else if (rect_type == WRT_InnerRect)            { return window->InnerRect; }
            else if (rect_type == WRT_InnerClipRect)        { return window->InnerClipRect; }
            else if (rect_type == WRT_WorkRect)             { return window->WorkRect; }
            else if (rect_type == WRT_Content)       { ImVec2 min = window->InnerRect.Min - window->Scroll + window->WindowPadding; return ImRect(min, min + window->ContentSize); }
            else if (rect_type == WRT_ContentIdeal)         { ImVec2 min = window->InnerRect.Min - window->Scroll + window->WindowPadding; return ImRect(min, min + window->ContentSizeIdeal); }
            else if (rect_type == WRT_ContentRegionRect)    { return window->ContentRegionRect; }
            IM_ASSERT(0);
            return ImRect();
        }
    };

    // Tools
    if (TreeNode("Tools"))
    {
        // The Item Picker tool is super useful to visually select an item and break into the call-stack of where it was submitted.
        if (Button("Item Picker.."))
            DebugStartItemPicker();
        SameLine();
        MetricsHelpMarker("Will call the IM_DEBUG_BREAK() macro to break in debugger.\nWarning: If you don't have a debugger attached, this will probably crash.");

        Checkbox("Show windows begin order", &cfg->ShowWindowsBeginOrder);
        Checkbox("Show windows rectangles", &cfg->ShowWindowsRects);
        SameLine();
        SetNextItemWidth(GetFontSize() * 12);
        cfg->ShowWindowsRects |= Combo("##show_windows_rect_type", &cfg->ShowWindowsRectsType, wrt_rects_names, WRT_Count, WRT_Count);
        if (cfg->ShowWindowsRects && g.NavWindow != NULL)
        {
            BulletText("'%s':", g.NavWindow->Name);
            Indent();
            for (int rect_n = 0; rect_n < WRT_Count; rect_n++)
            {
                ImRect r = Funcs::GetWindowRect(g.NavWindow, rect_n);
                Text("(%6.1f,%6.1f) (%6.1f,%6.1f) Size (%6.1f,%6.1f) %s", r.Min.x, r.Min.y, r.Max.x, r.Max.y, r.GetWidth(), r.GetHeight(), wrt_rects_names[rect_n]);
            }
            Unindent();
        }
        Checkbox("Show ImDrawCmd mesh when hovering", &cfg->ShowDrawCmdMesh);
        Checkbox("Show ImDrawCmd bounding boxes when hovering", &cfg->ShowDrawCmdBoundingBoxes);

        Checkbox("Show tables rectangles", &cfg->ShowTablesRects);
        SameLine();
        SetNextItemWidth(GetFontSize() * 12);
        cfg->ShowTablesRects |= Combo("##show_table_rects_type", &cfg->ShowTablesRectsType, trt_rects_names, TRT_Count, TRT_Count);
        if (cfg->ShowTablesRects && g.NavWindow != NULL)
        {
            for (int table_n = 0; table_n < g.Tables.GetSize(); table_n++)
            {
                ImGuiTable* table = g.Tables.GetByIndex(table_n);
                if (table->LastFrameActive < g.FrameCount - 1 || (table->OuterWindow != g.NavWindow && table->InnerWindow != g.NavWindow))
                    continue;

                BulletText("Table 0x%08X (%d columns, in '%s')", table->ID, table->ColumnsCount, table->OuterWindow->Name);
                if (IsItemHovered())
                    GetForegroundDrawList()->AddRect(table->OuterRect.Min - ImVec2(1, 1), table->OuterRect.Max + ImVec2(1, 1), IM_COL32(255, 255, 0, 255), 0.0f, ~0, 2.0f);
                Indent();
                char buf[128];
                for (int rect_n = 0; rect_n < TRT_Count; rect_n++)
                {
                    if (rect_n >= TRT_ColumnsRect)
                    {
                        if (rect_n != TRT_ColumnsRect && rect_n != TRT_ColumnsClipRect)
                            continue;
                        for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                        {
                            ImRect r = Funcs::GetTableRect(table, rect_n, column_n);
                            ImFormatString(buf, IM_ARRAYSIZE(buf), "(%6.1f,%6.1f) (%6.1f,%6.1f) Size (%6.1f,%6.1f) Col %d %s", r.Min.x, r.Min.y, r.Max.x, r.Max.y, r.GetWidth(), r.GetHeight(), column_n, trt_rects_names[rect_n]);
                            Selectable(buf);
                            if (IsItemHovered())
                                GetForegroundDrawList()->AddRect(r.Min - ImVec2(1, 1), r.Max + ImVec2(1, 1), IM_COL32(255, 255, 0, 255), 0.0f, ~0, 2.0f);
                        }
                    }
                    else
                    {
                        ImRect r = Funcs::GetTableRect(table, rect_n, -1);
                        ImFormatString(buf, IM_ARRAYSIZE(buf), "(%6.1f,%6.1f) (%6.1f,%6.1f) Size (%6.1f,%6.1f) %s", r.Min.x, r.Min.y, r.Max.x, r.Max.y, r.GetWidth(), r.GetHeight(), trt_rects_names[rect_n]);
                        Selectable(buf);
                        if (IsItemHovered())
                            GetForegroundDrawList()->AddRect(r.Min - ImVec2(1, 1), r.Max + ImVec2(1, 1), IM_COL32(255, 255, 0, 255), 0.0f, ~0, 2.0f);
                    }
                }
                Unindent();
            }
        }

        TreePop();
    }

    // Contents
    DebugNodeWindowsList(&g.Windows, "Windows");
    //DebugNodeWindowList(&g.WindowsFocusOrder, "WindowsFocusOrder");
    if (TreeNode("DrawLists", "Active DrawLists (%d)", g.DrawDataBuilder.Layers[0].Size))
    {
        for (int i = 0; i < g.DrawDataBuilder.Layers[0].Size; i++)
            DebugNodeDrawList(NULL, g.DrawDataBuilder.Layers[0][i], "DrawList");
        TreePop();
    }

    // Details for Popups
    if (TreeNode("Popups", "Popups (%d)", g.OpenPopupStack.Size))
    {
        for (int i = 0; i < g.OpenPopupStack.Size; i++)
        {
            ImGuiWindow* window = g.OpenPopupStack[i].Window;
            BulletText("PopupID: %08x, Window: '%s'%s%s", g.OpenPopupStack[i].PopupId, window ? window->Name : "NULL", window && (window->Flags & ImGuiWindowFlags_ChildWindow) ? " ChildWindow" : "", window && (window->Flags & ImGuiWindowFlags_ChildMenu) ? " ChildMenu" : "");
        }
        TreePop();
    }

    // Details for TabBars
    if (TreeNode("TabBars", "Tab Bars (%d)", g.TabBars.GetSize()))
    {
        for (int n = 0; n < g.TabBars.GetSize(); n++)
            DebugNodeTabBar(g.TabBars.GetByIndex(n), "TabBar");
        TreePop();
    }

    // Details for Tables
#ifdef IMGUI_HAS_TABLE
    if (TreeNode("Tables", "Tables (%d)", g.Tables.GetSize()))
    {
        for (int n = 0; n < g.Tables.GetSize(); n++)
            DebugNodeTable(g.Tables.GetByIndex(n));
        TreePop();
    }
#endif // #ifdef IMGUI_HAS_TABLE

    // Details for Docking
#ifdef IMGUI_HAS_DOCK
    if (TreeNode("Docking"))
    {
        TreePop();
    }
#endif // #ifdef IMGUI_HAS_DOCK

    // Settings
    if (TreeNode("Settings"))
    {
        if (SmallButton("Clear"))
            ClearIniSettings();
        SameLine();
        if (SmallButton("Save to memory"))
            SaveIniSettingsToMemory();
        SameLine();
        if (SmallButton("Save to disk"))
            SaveIniSettingsToDisk(g.IO.IniFilename);
        SameLine();
        if (g.IO.IniFilename)
            Text("\"%s\"", g.IO.IniFilename);
        else
            TextUnformatted("<NULL>");
        Text("SettingsDirtyTimer %.2f", g.SettingsDirtyTimer);
        if (TreeNode("SettingsHandlers", "Settings handlers: (%d)", g.SettingsHandlers.Size))
        {
            for (int n = 0; n < g.SettingsHandlers.Size; n++)
                BulletText("%s", g.SettingsHandlers[n].TypeName);
            TreePop();
        }
        if (TreeNode("SettingsWindows", "Settings packed data: Windows: %d bytes", g.SettingsWindows.size()))
        {
            for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
                DebugNodeWindowSettings(settings);
            TreePop();
        }

#ifdef IMGUI_HAS_TABLE
        if (TreeNode("SettingsTables", "Settings packed data: Tables: %d bytes", g.SettingsTables.size()))
        {
            for (ImGuiTableSettings* settings = g.SettingsTables.begin(); settings != NULL; settings = g.SettingsTables.next_chunk(settings))
                DebugNodeTableSettings(settings);
            TreePop();
        }
#endif // #ifdef IMGUI_HAS_TABLE

#ifdef IMGUI_HAS_DOCK
#endif // #ifdef IMGUI_HAS_DOCK

        if (TreeNode("SettingsIniData", "Settings unpacked data (.ini): %d bytes", g.SettingsIniData.size()))
        {
            InputTextMultiline("##Ini", (char*)(void*)g.SettingsIniData.c_str(), g.SettingsIniData.Buf.Size, ImVec2(-FLT_MIN, GetTextLineHeight() * 20), ImGuiInputTextFlags_ReadOnly);
            TreePop();
        }
        TreePop();
    }

    // Misc Details
    if (TreeNode("Internal state"))
    {
        const char* input_source_names[] = { "None", "Mouse", "Nav", "NavKeyboard", "NavGamepad" }; IM_ASSERT(IM_ARRAYSIZE(input_source_names) == ImGuiInputSource_COUNT);

        Text("WINDOWING");
        Indent();
        Text("HoveredWindow: '%s'", g.HoveredWindow ? g.HoveredWindow->Name : "NULL");
        Text("HoveredRootWindow: '%s'", g.HoveredRootWindow ? g.HoveredRootWindow->Name : "NULL");
        Text("HoveredWindowUnderMovingWindow: '%s'", g.HoveredWindowUnderMovingWindow ? g.HoveredWindowUnderMovingWindow->Name : "NULL");
        Text("MovingWindow: '%s'", g.MovingWindow ? g.MovingWindow->Name : "NULL");
        Unindent();

        Text("ITEMS");
        Indent();
        Text("ActiveId: 0x%08X/0x%08X (%.2f sec), AllowOverlap: %d, Source: %s", g.ActiveId, g.ActiveIdPreviousFrame, g.ActiveIdTimer, g.ActiveIdAllowOverlap, input_source_names[g.ActiveIdSource]);
        Text("ActiveIdWindow: '%s'", g.ActiveIdWindow ? g.ActiveIdWindow->Name : "NULL");
        Text("HoveredId: 0x%08X/0x%08X (%.2f sec), AllowOverlap: %d", g.HoveredId, g.HoveredIdPreviousFrame, g.HoveredIdTimer, g.HoveredIdAllowOverlap); // Data is "in-flight" so depending on when the Metrics window is called we may see current frame information or not
        Text("DragDrop: %d, SourceId = 0x%08X, Payload \"%s\" (%d bytes)", g.DragDropActive, g.DragDropPayload.SourceId, g.DragDropPayload.DataType, g.DragDropPayload.DataSize);
        Unindent();

        Text("NAV,FOCUS");
        Indent();
        Text("NavWindow: '%s'", g.NavWindow ? g.NavWindow->Name : "NULL");
        Text("NavId: 0x%08X, NavLayer: %d", g.NavId, g.NavLayer);
        Text("NavInputSource: %s", input_source_names[g.NavInputSource]);
        Text("NavActive: %d, NavVisible: %d", g.IO.NavActive, g.IO.NavVisible);
        Text("NavActivateId: 0x%08X, NavInputId: 0x%08X", g.NavActivateId, g.NavInputId);
        Text("NavDisableHighlight: %d, NavDisableMouseHover: %d", g.NavDisableHighlight, g.NavDisableMouseHover);
        Text("NavFocusScopeId = 0x%08X", g.NavFocusScopeId);
        Text("NavWindowingTarget: '%s'", g.NavWindowingTarget ? g.NavWindowingTarget->Name : "NULL");
        Unindent();

        TreePop();
    }

    // Overlay: Display windows Rectangles and Begin Order
    if (cfg->ShowWindowsRects || cfg->ShowWindowsBeginOrder)
    {
        for (int n = 0; n < g.Windows.Size; n++)
        {
            ImGuiWindow* window = g.Windows[n];
            if (!window->WasActive)
                continue;
            ImDrawList* draw_list = GetForegroundDrawList(window);
            if (cfg->ShowWindowsRects)
            {
                ImRect r = Funcs::GetWindowRect(window, cfg->ShowWindowsRectsType);
                draw_list->AddRect(r.Min, r.Max, IM_COL32(255, 0, 128, 255));
            }
            if (cfg->ShowWindowsBeginOrder && !(window->Flags & ImGuiWindowFlags_ChildWindow))
            {
                char buf[32];
                ImFormatString(buf, IM_ARRAYSIZE(buf), "%d", window->BeginOrderWithinContext);
                float font_size = GetFontSize();
                draw_list->AddRectFilled(window->Pos, window->Pos + ImVec2(font_size, font_size), IM_COL32(200, 100, 100, 255));
                draw_list->AddText(window->Pos, IM_COL32(255, 255, 255, 255), buf);
            }
        }
    }

#ifdef IMGUI_HAS_TABLE
    // Overlay: Display Tables Rectangles
    if (cfg->ShowTablesRects)
    {
        for (int table_n = 0; table_n < g.Tables.GetSize(); table_n++)
        {
            ImGuiTable* table = g.Tables.GetByIndex(table_n);
            if (table->LastFrameActive < g.FrameCount - 1)
                continue;
            ImDrawList* draw_list = GetForegroundDrawList(table->OuterWindow);
            if (cfg->ShowTablesRectsType >= TRT_ColumnsRect)
            {
                for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
                {
                    ImRect r = Funcs::GetTableRect(table, cfg->ShowTablesRectsType, column_n);
                    ImU32 col = (table->HoveredColumnBody == column_n) ? IM_COL32(255, 255, 128, 255) : IM_COL32(255, 0, 128, 255);
                    float thickness = (table->HoveredColumnBody == column_n) ? 3.0f : 1.0f;
                    draw_list->AddRect(r.Min, r.Max, col, 0.0f, ~0, thickness);
                }
            }
            else
            {
                ImRect r = Funcs::GetTableRect(table, cfg->ShowTablesRectsType, -1);
                draw_list->AddRect(r.Min, r.Max, IM_COL32(255, 0, 128, 255));
            }
        }
    }
#endif // #ifdef IMGUI_HAS_TABLE

#ifdef IMGUI_HAS_DOCK
    // Overlay: Display Docking info
    if (show_docking_nodes && g.IO.KeyCtrl)
    {
    }
#endif // #ifdef IMGUI_HAS_DOCK

    End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x940d8(%rip), %rdi     # 0x175922
xorl %edx, %edx
callq 0xd0170
testb $0x1, %al
jne 0xe185f
callq 0xd3b60
jmp 0xe323b
movq 0x1316da(%rip), %rax    # 0x212f40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x3174, %rax           # imm = 0x3174
movq %rax, -0x20(%rbp)
callq 0xcaaf0
movq %rax, %rsi
leaq 0x940ab(%rip), %rdi     # 0x17593e
movb $0x0, %al
callq 0x139160
movq -0x18(%rbp), %rax
movss 0x906de(%rip), %xmm0    # 0x171f84
divss 0x398(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss 0x398(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x908cd(%rip), %rdi     # 0x172196
movb $0x2, %al
callq 0x139160
movq -0x18(%rbp), %rax
movl 0x39c(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x3a0(%rax), %eax
movl %eax, -0x328(%rbp)
movq -0x18(%rbp), %rax
movl 0x3a0(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x328(%rbp), %edx
movl %eax, %ecx
leaq 0x94041(%rip), %rdi     # 0x17594c
movb $0x0, %al
callq 0x139160
movq -0x18(%rbp), %rax
movl 0x3a8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x3a4(%rax), %edx
leaq 0x94046(%rip), %rdi     # 0x175973
movb $0x0, %al
callq 0x139160
movq -0x18(%rbp), %rax
movl 0x3ac(%rax), %esi
leaq 0x9404d(%rip), %rdi     # 0x175992
movb $0x0, %al
callq 0x139160
callq 0x13dec0
leaq -0x60(%rbp), %rdi
leaq 0x12baa4(%rip), %rsi    # 0x20d400
movl $0x40, %edx
callq 0xd0a0
leaq -0xd0(%rbp), %rdi
leaq 0x12bacc(%rip), %rsi    # 0x20d440
movl $0x68, %edx
callq 0xd0a0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0xe1993
movq -0x20(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jge 0xe19a8
movq -0x20(%rbp), %rax
movl $0x2, 0xc(%rax)
leaq 0x94100(%rip), %rdi     # 0x175aaf
callq 0x1510b0
testb $0x1, %al
jne 0xe19bd
jmp 0xe2352
leaq -0xd8(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
leaq 0x940df(%rip), %rdi     # 0x175ab5
leaq -0xd8(%rbp), %rsi
callq 0x13a930
testb $0x1, %al
jne 0xe19e8
jmp 0xe19ed
callq 0xec680
xorps %xmm0, %xmm0
movss 0x90588(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq 0x940bf(%rip), %rdi     # 0x175ac3
callq 0xe3250
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
leaq 0x94130(%rip), %rdi     # 0x175b48
callq 0x13c7c0
movq -0x20(%rbp), %rsi
leaq 0x94139(%rip), %rdi     # 0x175b61
callq 0x13c7c0
xorps %xmm0, %xmm0
movss 0x90548(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
callq 0xdae90
movss 0x90d8a(%rip), %xmm1    # 0x1727d4
mulss %xmm1, %xmm0
callq 0xc6860
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdx
leaq 0x94113(%rip), %rdi     # 0x175b79
movl $0x8, %r8d
movl %r8d, %ecx
callq 0x13fac0
andb $0x1, %al
movzbl %al, %edx
movq -0x20(%rbp), %rax
movb (%rax), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0xe1beb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
je 0xe1beb
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rax
movq (%rax), %rsi
leaq 0x940cc(%rip), %rdi     # 0x175b92
movb $0x0, %al
callq 0x139ab0
xorps %xmm0, %xmm0
callq 0xdc9d0
movl $0x0, -0xdc(%rbp)
cmpl $0x8, -0xdc(%rbp)
jge 0xe1be3
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rdi
movl -0xdc(%rbp), %esi
callq 0xe32b0
movlpd %xmm0, -0xec(%rbp)
movlpd %xmm1, -0xe4(%rbp)
movss -0xec(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x330(%rbp)
movss -0xe8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x350(%rbp)
movss -0xe4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x348(%rbp)
movss -0xe0(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x340(%rbp)
leaq -0xec(%rbp), %rdi
callq 0xeb840
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x338(%rbp)
leaq -0xec(%rbp), %rdi
callq 0xeb860
movsd -0x350(%rbp), %xmm1
movsd -0x348(%rbp), %xmm2
movsd -0x340(%rbp), %xmm3
movsd -0x338(%rbp), %xmm4
movaps %xmm0, %xmm5
movsd -0x330(%rbp), %xmm0
cvtss2sd %xmm5, %xmm5
movslq -0xdc(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rsi
leaq 0x93fd0(%rip), %rdi     # 0x175b98
movb $0x6, %al
callq 0x139160
movl -0xdc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xdc(%rbp)
jmp 0xe1adf
xorps %xmm0, %xmm0
callq 0xdca70
movq -0x20(%rbp), %rsi
addq $0x3, %rsi
leaq 0x93fd0(%rip), %rdi     # 0x175bca
callq 0x13c7c0
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
leaq 0x93fde(%rip), %rdi     # 0x175bec
callq 0x13c7c0
movq -0x20(%rbp), %rsi
addq $0x2, %rsi
leaq 0x93ff6(%rip), %rdi     # 0x175c18
callq 0x13c7c0
xorps %xmm0, %xmm0
movss 0x9034e(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
callq 0xdae90
movss 0x90b90(%rip), %xmm1    # 0x1727d4
mulss %xmm1, %xmm0
callq 0xc6860
movq -0x20(%rbp), %rsi
addq $0xc, %rsi
leaq -0xd0(%rbp), %rdx
leaq 0x93fcc(%rip), %rdi     # 0x175c2f
movl $0xd, %r8d
movl %r8d, %ecx
callq 0x13fac0
andb $0x1, %al
movzbl %al, %edx
movq -0x20(%rbp), %rax
movb 0x2(%rax), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, 0x2(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0x2(%rax)
je 0xe234d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
je 0xe234d
movl $0x0, -0xf0(%rbp)
movl -0xf0(%rbp), %eax
movl %eax, -0x354(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
callq 0xec6a0
movl %eax, %ecx
movl -0x354(%rbp), %eax
cmpl %ecx, %eax
jge 0xe234b
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movl -0xf0(%rbp), %esi
callq 0xea9d0
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x1a68(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0xe1d55
movq -0xf8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1c90(%rcx), %rax
je 0xe1d5a
movq -0xf8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1c90(%rcx), %rax
je 0xe1d5a
jmp 0xe2337
movq -0xf8(%rbp), %rax
movl (%rax), %esi
movq -0xf8(%rbp), %rax
movl 0x6c(%rax), %edx
movq -0xf8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq (%rax), %rcx
leaq 0x93ec2(%rip), %rdi     # 0x175c47
movb $0x0, %al
callq 0x139ab0
xorl %edi, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xe1d9c
jmp 0xe1e7a
callq 0xca6c0
movq %rax, -0x360(%rbp)
movq -0xf8(%rbp), %rax
addq $0xec, %rax
movq %rax, -0x388(%rbp)
leaq -0x108(%rbp), %rdi
movq %rdi, -0x380(%rbp)
movss 0x8ee6a(%rip), %xmm1    # 0x170c3c
movss %xmm1, -0x374(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x388(%rbp), %rdi
movq -0x380(%rbp), %rsi
callq 0xc3c00
movss -0x374(%rbp), %xmm1
movlpd %xmm0, -0x100(%rbp)
movq -0xf8(%rbp), %rax
addq $0xf4, %rax
movq %rax, -0x370(%rbp)
leaq -0x118(%rbp), %rdi
movq %rdi, -0x368(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x370(%rbp), %rdi
movq -0x368(%rbp), %rsi
callq 0xc41b0
movq -0x360(%rbp), %rdi
movlpd %xmm0, -0x110(%rbp)
leaq -0x100(%rbp), %rsi
leaq -0x110(%rbp), %rdx
movl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
xorps %xmm0, %xmm0
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movss 0x90157(%rip), %xmm1    # 0x171fcc
callq 0x112ef0
xorps %xmm0, %xmm0
callq 0xdc9d0
movl $0x0, -0x1a4(%rbp)
cmpl $0xd, -0x1a4(%rbp)
jge 0xe232f
cmpl $0x6, -0x1a4(%rbp)
jl 0xe210b
cmpl $0x6, -0x1a4(%rbp)
je 0xe1ebd
cmpl $0x8, -0x1a4(%rbp)
je 0xe1ebd
jmp 0xe231b
movl $0x0, -0x1a8(%rbp)
movl -0x1a8(%rbp), %eax
movq -0xf8(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0xe2106
movq -0xf8(%rbp), %rdi
movl -0x1a4(%rbp), %esi
movl -0x1a8(%rbp), %edx
callq 0xe34a0
movlpd %xmm0, -0x1b8(%rbp)
movlpd %xmm1, -0x1b0(%rbp)
leaq -0x1a0(%rbp), %rax
movq %rax, -0x3c0(%rbp)
movss -0x1b8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x398(%rbp)
movss -0x1b4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x3b8(%rbp)
movss -0x1b0(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x3b0(%rbp)
movss -0x1ac(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x3a8(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xeb840
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x3a0(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xeb860
movq -0x3c0(%rbp), %rdi
movsd -0x3b8(%rbp), %xmm1
movsd -0x3b0(%rbp), %xmm2
movsd -0x3a8(%rbp), %xmm3
movsd -0x3a0(%rbp), %xmm4
movaps %xmm0, %xmm5
movsd -0x398(%rbp), %xmm0
cvtss2sd %xmm5, %xmm5
movl -0x1a8(%rbp), %ecx
movslq -0x1a4(%rbp), %rax
movq -0xd0(%rbp,%rax,8), %r8
movl $0x80, %esi
leaq 0x93c8c(%rip), %rdx     # 0x175c6a
movb $0x6, %al
callq 0xc4d30
leaq -0x1a0(%rbp), %rax
movq %rax, -0x390(%rbp)
leaq -0x1c0(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x390(%rbp), %rdi
xorl %edx, %edx
leaq -0x1c0(%rbp), %rcx
movl %edx, %esi
callq 0x13f2b0
xorl %edi, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xe202c
jmp 0xe20f0
callq 0xca6c0
movq %rax, -0x3c8(%rbp)
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
movss 0x8ebee(%rip), %xmm1    # 0x170c3c
movss %xmm1, -0x3dc(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x3e8(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0xc3c00
movss -0x3dc(%rbp), %xmm1
movlpd %xmm0, -0x1c8(%rbp)
leaq -0x1b0(%rbp), %rax
movq %rax, -0x3d8(%rbp)
leaq -0x1e0(%rbp), %rdi
movq %rdi, -0x3d0(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x3d8(%rbp), %rdi
movq -0x3d0(%rbp), %rsi
callq 0xc41b0
movq -0x3c8(%rbp), %rdi
movlpd %xmm0, -0x1d8(%rbp)
leaq -0x1c8(%rbp), %rsi
leaq -0x1d8(%rbp), %rdx
movl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
xorps %xmm0, %xmm0
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movss 0x8fee1(%rip), %xmm1    # 0x171fcc
callq 0x112ef0
jmp 0xe20f2
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0xe1ec7
jmp 0xe2319
movq -0xf8(%rbp), %rdi
movl -0x1a4(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xe34a0
movlpd %xmm0, -0x1f0(%rbp)
movlpd %xmm1, -0x1e8(%rbp)
leaq -0x1a0(%rbp), %rax
movq %rax, -0x420(%rbp)
movss -0x1f0(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x3f8(%rbp)
movss -0x1ec(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x418(%rbp)
movss -0x1e8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x410(%rbp)
movss -0x1e4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x408(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xeb840
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x400(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xeb860
movq -0x420(%rbp), %rdi
movsd -0x418(%rbp), %xmm1
movsd -0x410(%rbp), %xmm2
movsd -0x408(%rbp), %xmm3
movsd -0x400(%rbp), %xmm4
movaps %xmm0, %xmm5
movsd -0x3f8(%rbp), %xmm0
cvtss2sd %xmm5, %xmm5
movslq -0x1a4(%rbp), %rax
movq -0xd0(%rbp,%rax,8), %rcx
movl $0x80, %esi
leaq 0x93993(%rip), %rdx     # 0x175b98
movb $0x6, %al
callq 0xc4d30
leaq -0x1a0(%rbp), %rax
movq %rax, -0x3f0(%rbp)
leaq -0x1f8(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x3f0(%rbp), %rdi
xorl %edx, %edx
leaq -0x1f8(%rbp), %rcx
movl %edx, %esi
callq 0x13f2b0
xorl %edi, %edi
callq 0xca1c0
testb $0x1, %al
jne 0xe2253
jmp 0xe2317
callq 0xca6c0
movq %rax, -0x428(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x448(%rbp)
movss 0x8e9c7(%rip), %xmm1    # 0x170c3c
movss %xmm1, -0x43c(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x448(%rbp), %rsi
leaq -0x1f0(%rbp), %rdi
callq 0xc3c00
movss -0x43c(%rbp), %xmm1
movlpd %xmm0, -0x200(%rbp)
leaq -0x1e8(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x430(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x438(%rbp), %rdi
movq -0x430(%rbp), %rsi
callq 0xc41b0
movq -0x428(%rbp), %rdi
movlpd %xmm0, -0x210(%rbp)
leaq -0x200(%rbp), %rsi
leaq -0x210(%rbp), %rdx
movl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
xorps %xmm0, %xmm0
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movss 0x8fcba(%rip), %xmm1    # 0x171fcc
callq 0x112ef0
jmp 0xe2319
jmp 0xe231b
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0xe1e8c
xorps %xmm0, %xmm0
callq 0xdca70
movl -0xf0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf0(%rbp)
jmp 0xe1cbb
jmp 0xe234d
callq 0x1523d0
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
leaq 0x9427f(%rip), %rsi     # 0x1765e3
callq 0xe3830
movq -0x10(%rbp), %rax
movl 0x1e48(%rax), %edx
leaq 0x93929(%rip), %rdi     # 0x175ca3
leaq 0x9392c(%rip), %rsi     # 0x175cad
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe238e
jmp 0xe23e9
movl $0x0, -0x21c(%rbp)
movl -0x21c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1e48(%rcx), %eax
jge 0xe23e4
movq -0x10(%rbp), %rdi
addq $0x1e48, %rdi           # imm = 0x1E48
movl -0x21c(%rbp), %esi
callq 0xeb1f0
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x938f5(%rip), %rdx     # 0x175cc3
callq 0xe38d0
movl -0x21c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x21c(%rbp)
jmp 0xe2398
callq 0x1523d0
movq -0x10(%rbp), %rax
movl 0x1c70(%rax), %edx
leaq 0x938d2(%rip), %rdi     # 0x175ccc
leaq 0x938d2(%rip), %rsi     # 0x175cd3
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe2411
jmp 0xe257f
movl $0x0, -0x220(%rbp)
movl -0x220(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c70(%rcx), %eax
jge 0xe257a
movq -0x10(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movl -0x220(%rbp), %esi
callq 0xeb4c0
movq 0x8(%rax), %rax
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1c70, %rdi           # imm = 0x1C70
movl -0x220(%rbp), %esi
callq 0xeb4c0
movl (%rax), %eax
movl %eax, -0x44c(%rbp)
cmpq $0x0, -0x228(%rbp)
je 0xe248d
movq -0x228(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x458(%rbp)
jmp 0xe249d
leaq 0x93efa(%rip), %rax     # 0x17638e
movq %rax, -0x458(%rbp)
jmp 0xe249d
movq -0x458(%rbp), %rax
movq %rax, -0x468(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x228(%rbp)
movb %al, -0x459(%rbp)
je 0xe24d8
movq -0x228(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
setne %al
movb %al, -0x459(%rbp)
movb -0x459(%rbp), %dl
leaq 0x8fa24(%rip), %rax     # 0x171f09
leaq 0x93813(%rip), %rcx     # 0x175cff
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x478(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x228(%rbp)
movb %al, -0x469(%rbp)
je 0xe2527
movq -0x228(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10000000, %eax       # imm = 0x10000000
cmpl $0x0, %eax
setne %al
movb %al, -0x469(%rbp)
movq -0x478(%rbp), %rcx
movq -0x468(%rbp), %rdx
movl -0x44c(%rbp), %esi
movb -0x469(%rbp), %dil
leaq 0x8f9c0(%rip), %r8      # 0x171f09
leaq 0x937bc(%rip), %rax     # 0x175d0c
testb $0x1, %dil
cmovneq %rax, %r8
leaq 0x93780(%rip), %rdi     # 0x175cdf
movb $0x0, %al
callq 0x139ab0
movl -0x220(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0xe241b
callq 0x1523d0
movq -0x10(%rbp), %rdi
addq $0x2110, %rdi           # imm = 0x2110
callq 0xec6b0
movl %eax, %edx
leaq 0x9377f(%rip), %rdi     # 0x175d17
leaq 0x93780(%rip), %rsi     # 0x175d1f
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe25ac
jmp 0xe2619
movl $0x0, -0x22c(%rbp)
movl -0x22c(%rbp), %eax
movl %eax, -0x47c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2110, %rdi           # imm = 0x2110
callq 0xec6b0
movl %eax, %ecx
movl -0x47c(%rbp), %eax
cmpl %ecx, %eax
jge 0xe2614
movq -0x10(%rbp), %rdi
addq $0x2110, %rdi           # imm = 0x2110
movl -0x22c(%rbp), %esi
callq 0xec6c0
movq %rax, %rdi
leaq 0xa0eeb(%rip), %rsi     # 0x1834e9
callq 0xe4240
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0xe25b6
callq 0x1523d0
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
callq 0xec6a0
movl %eax, %edx
leaq 0x937b1(%rip), %rdi     # 0x175de3
leaq 0x936f4(%rip), %rsi     # 0x175d2d
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe2646
jmp 0xe26ac
movl $0x0, -0x230(%rbp)
movl -0x230(%rbp), %eax
movl %eax, -0x480(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
callq 0xec6a0
movl %eax, %ecx
movl -0x480(%rbp), %eax
cmpl %ecx, %eax
jge 0xe26a7
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movl -0x230(%rbp), %esi
callq 0xea9d0
movq %rax, %rdi
callq 0x1344f0
movl -0x230(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x230(%rbp)
jmp 0xe2650
callq 0x1523d0
leaq 0x9eaf7(%rip), %rdi     # 0x1811aa
callq 0x1510b0
testb $0x1, %al
jne 0xe26c1
jmp 0xe29ce
leaq 0x93671(%rip), %rdi     # 0x175d39
callq 0x13a960
testb $0x1, %al
jne 0xe26d3
jmp 0xe26d8
callq 0xe1220
xorps %xmm0, %xmm0
movss 0x8f89d(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq 0x93650(%rip), %rdi     # 0x175d3f
callq 0x13a960
testb $0x1, %al
jne 0xe26fa
jmp 0xe2703
xorl %eax, %eax
movl %eax, %edi
callq 0xe1750
xorps %xmm0, %xmm0
movss 0x8f872(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
leaq 0x93634(%rip), %rdi     # 0x175d4e
callq 0x13a960
testb $0x1, %al
jne 0xe2725
jmp 0xe2732
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xd3330
xorps %xmm0, %xmm0
movss 0x8f843(%rip), %xmm1    # 0x171f80
callq 0xdc1c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xe2765
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0xa1116(%rip), %rdi     # 0x183872
movb $0x0, %al
callq 0x139160
jmp 0xe2775
leaq 0x935ef(%rip), %rdi     # 0x175d5b
xorl %eax, %eax
movl %eax, %esi
callq 0x139130
movq -0x10(%rbp), %rax
movss 0x30e4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x935d6(%rip), %rdi     # 0x175d62
movb $0x1, %al
callq 0x139160
movq -0x10(%rbp), %rax
movl 0x30f8(%rax), %edx
leaq 0x935d6(%rip), %rdi     # 0x175d7a
leaq 0x935e0(%rip), %rsi     # 0x175d8b
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe27b8
jmp 0xe2811
movl $0x0, -0x234(%rbp)
movl -0x234(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x30f8(%rcx), %eax
jge 0xe280c
movq -0x10(%rbp), %rdi
addq $0x30f8, %rdi           # imm = 0x30F8
movl -0x234(%rbp), %esi
callq 0xec5a0
movq (%rax), %rsi
leaq 0x933d3(%rip), %rdi     # 0x175bc7
movb $0x0, %al
callq 0x139ab0
movl -0x234(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x234(%rbp)
jmp 0xe27c2
callq 0x1523d0
movq -0x10(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
callq 0xec6f0
movl %eax, %edx
leaq 0x93579(%rip), %rdi     # 0x175da3
leaq 0x93582(%rip), %rsi     # 0x175db3
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe283e
jmp 0xe2890
movq -0x10(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
callq 0xec430
movq %rax, -0x240(%rbp)
cmpq $0x0, -0x240(%rbp)
je 0xe288b
movq -0x240(%rbp), %rdi
callq 0xe4670
movq -0x10(%rbp), %rdi
addq $0x3108, %rdi           # imm = 0x3108
movq -0x240(%rbp), %rsi
callq 0xec470
movq %rax, -0x240(%rbp)
jmp 0xe2855
callq 0x1523d0
movq -0x10(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
callq 0xec700
movl %eax, %edx
leaq 0x93532(%rip), %rdi     # 0x175ddb
leaq 0x9353a(%rip), %rsi     # 0x175dea
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe28bd
jmp 0xe290f
movq -0x10(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
callq 0xec710
movq %rax, -0x248(%rbp)
cmpq $0x0, -0x248(%rbp)
je 0xe290a
movq -0x248(%rbp), %rdi
callq 0x1350b0
movq -0x10(%rbp), %rdi
addq $0x3118, %rdi           # imm = 0x3118
movq -0x248(%rbp), %rsi
callq 0xec750
movq %rax, -0x248(%rbp)
jmp 0xe28d4
callq 0x1523d0
movq -0x10(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
callq 0xec2b0
movl %eax, %edx
leaq 0x934e9(%rip), %rdi     # 0x175e11
leaq 0x934f2(%rip), %rsi     # 0x175e21
movb $0x0, %al
callq 0x150dd0
testb $0x1, %al
jne 0xe293f
jmp 0xe29c9
movq -0x10(%rbp), %rdi
addq $0x30e8, %rdi           # imm = 0x30E8
callq 0xec270
movq %rax, -0x490(%rbp)
movq -0x10(%rbp), %rax
movslq 0x30e8(%rax), %rax
movq %rax, -0x488(%rbp)
callq 0xdd000
movaps %xmm0, %xmm1
movss 0x8fe64(%rip), %xmm0    # 0x1727dc
mulss %xmm0, %xmm1
leaq -0x250(%rbp), %rdi
movss 0x8fe4d(%rip), %xmm0    # 0x1727d8
callq 0xbf4c0
movq -0x490(%rbp), %rsi
movq -0x488(%rbp), %rdx
leaq 0x934a4(%rip), %rdi     # 0x175e49
leaq -0x250(%rbp), %rcx
movl $0x4000, %r8d           # imm = 0x4000
xorl %eax, %eax
movl %eax, %r9d
movq $0x0, (%rsp)
callq 0x14a300
callq 0x1523d0
callq 0x1523d0
leaq 0x9347a(%rip), %rdi     # 0x175e4f
callq 0x1510b0
testb $0x1, %al
jne 0xe29e3
jmp 0xe2e09
leaq -0x280(%rbp), %rdi
leaq 0x12aabf(%rip), %rsi    # 0x20d4b0
movl $0x28, %edx
callq 0xd0a0
leaq 0x93477(%rip), %rdi     # 0x175e79
movb $0x0, %al
callq 0x139160
xorps %xmm0, %xmm0
callq 0xdc9d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1ae8(%rax)
je 0xe2a36
movq -0x10(%rbp), %rax
movq 0x1ae8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x498(%rbp)
jmp 0xe2a46
leaq 0x93951(%rip), %rax     # 0x17638e
movq %rax, -0x498(%rbp)
jmp 0xe2a46
movq -0x498(%rbp), %rsi
leaq 0x9342f(%rip), %rdi     # 0x175e83
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1af0(%rax)
je 0xe2a80
movq -0x10(%rbp), %rax
movq 0x1af0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x4a0(%rbp)
jmp 0xe2a90
leaq 0x93907(%rip), %rax     # 0x17638e
movq %rax, -0x4a0(%rbp)
jmp 0xe2a90
movq -0x4a0(%rbp), %rsi
leaq 0x933f9(%rip), %rdi     # 0x175e97
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1af8(%rax)
je 0xe2aca
movq -0x10(%rbp), %rax
movq 0x1af8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x4a8(%rbp)
jmp 0xe2ada
leaq 0x938bd(%rip), %rax     # 0x17638e
movq %rax, -0x4a8(%rbp)
jmp 0xe2ada
movq -0x4a8(%rbp), %rsi
leaq 0x933c7(%rip), %rdi     # 0x175eaf
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b00(%rax)
je 0xe2b14
movq -0x10(%rbp), %rax
movq 0x1b00(%rax), %rax
movq (%rax), %rax
movq %rax, -0x4b0(%rbp)
jmp 0xe2b24
leaq 0x93873(%rip), %rax     # 0x17638e
movq %rax, -0x4b0(%rbp)
jmp 0xe2b24
movq -0x4b0(%rbp), %rsi
leaq 0x9338f(%rip), %rdi     # 0x175ec1
movb $0x0, %al
callq 0x139160
xorps %xmm0, %xmm0
callq 0xdca70
leaq 0x9338c(%rip), %rdi     # 0x175ed4
movb $0x0, %al
callq 0x139160
xorps %xmm0, %xmm0
callq 0xdc9d0
movq -0x10(%rbp), %rax
movl 0x1b30(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x1b70(%rax), %edx
movq -0x10(%rbp), %rax
movss 0x1b38(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movb 0x1b3d(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl 0x1b68(%rax), %eax
movq -0x280(%rbp,%rax,8), %r8
leaq 0x93337(%rip), %rdi     # 0x175eda
movb $0x1, %al
callq 0x139160
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b60(%rax)
je 0xe2bcf
movq -0x10(%rbp), %rax
movq 0x1b60(%rax), %rax
movq (%rax), %rax
movq %rax, -0x4b8(%rbp)
jmp 0xe2bdf
leaq 0x937b8(%rip), %rax     # 0x17638e
movq %rax, -0x4b8(%rbp)
jmp 0xe2bdf
movq -0x4b8(%rbp), %rsi
leaq 0x9332e(%rip), %rdi     # 0x175f1b
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movl 0x1b1c(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x1b20(%rax), %edx
movq -0x10(%rbp), %rax
movss 0x1b28(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movb 0x1b24(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x93302(%rip), %rdi     # 0x175f30
movb $0x1, %al
callq 0x139160
movq -0x10(%rbp), %rax
movb 0x2004(%rax), %al
andb $0x1, %al
movzbl %al, %esi
movq -0x10(%rbp), %rax
movl 0x2024(%rax), %edx
movq -0x10(%rbp), %rcx
addq $0x2018, %rcx           # imm = 0x2018
addq $0x18, %rcx
movq -0x10(%rbp), %rax
movl 0x2020(%rax), %r8d
leaq 0x932f7(%rip), %rdi     # 0x175f66
movb $0x0, %al
callq 0x139160
xorps %xmm0, %xmm0
callq 0xdca70
leaq 0x9331a(%rip), %rdi     # 0x175f9f
movb $0x0, %al
callq 0x139160
xorps %xmm0, %xmm0
callq 0xdc9d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1c90(%rax)
je 0xe2cb9
movq -0x10(%rbp), %rax
movq 0x1c90(%rax), %rax
movq (%rax), %rax
movq %rax, -0x4c0(%rbp)
jmp 0xe2cc9
leaq 0x936ce(%rip), %rax     # 0x17638e
movq %rax, -0x4c0(%rbp)
jmp 0xe2cc9
movq -0x4c0(%rbp), %rsi
leaq 0x932d2(%rip), %rdi     # 0x175fa9
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movl 0x1c98(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x1cdc(%rax), %edx
leaq 0x932c0(%rip), %rdi     # 0x175fb9
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movl 0x1cc4(%rax), %eax
movq -0x280(%rbp,%rax,8), %rsi
leaq 0x932bc(%rip), %rdi     # 0x175fd5
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movb 0x39d(%rax), %al
andb $0x1, %al
movzbl %al, %esi
movq -0x10(%rbp), %rax
movb 0x39e(%rax), %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x932a3(%rip), %rdi     # 0x175fe8
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movl 0x1ca0(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x1cac(%rax), %edx
leaq 0x9329f(%rip), %rdi     # 0x176006
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movb 0x1ce6(%rax), %al
andb $0x1, %al
movzbl %al, %esi
movq -0x10(%rbp), %rax
movb 0x1ce7(%rax), %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x9329d(%rip), %rdi     # 0x176030
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
movl 0x1c9c(%rax), %esi
leaq 0x932b7(%rip), %rdi     # 0x176062
movb $0x0, %al
callq 0x139160
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1dc0(%rax)
je 0xe2dd7
movq -0x10(%rbp), %rax
movq 0x1dc0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x4c8(%rbp)
jmp 0xe2de7
leaq 0x935b0(%rip), %rax     # 0x17638e
movq %rax, -0x4c8(%rbp)
jmp 0xe2de7
movq -0x4c8(%rbp), %rsi
leaq 0x93286(%rip), %rdi     # 0x17607b
movb $0x0, %al
callq 0x139160
xorps %xmm0, %xmm0
callq 0xdca70
callq 0x1523d0
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
jne 0xe2e20
movq -0x20(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0xe3004
movl $0x0, -0x284(%rbp)
movl -0x284(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1a88(%rcx), %eax
jge 0xe3002
movq -0x10(%rbp), %rdi
addq $0x1a88, %rdi           # imm = 0x1A88
movl -0x284(%rbp), %esi
callq 0xea8d0
movq (%rax), %rax
movq %rax, -0x290(%rbp)
movq -0x290(%rbp), %rax
testb $0x1, 0x8f(%rax)
jne 0xe2e75
jmp 0xe2fee
movq -0x290(%rbp), %rdi
callq 0xec880
movq %rax, -0x298(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0xe2ee8
movq -0x290(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xe32b0
movlpd %xmm0, -0x2a8(%rbp)
movlpd %xmm1, -0x2a0(%rbp)
movq -0x298(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
leaq -0x2a8(%rbp), %rdx
addq $0x8, %rdx
movl $0xff8000ff, %ecx       # imm = 0xFF8000FF
xorps %xmm0, %xmm0
movl $0xf, %r8d
movss 0x8dd59(%rip), %xmm1    # 0x170c3c
callq 0x112ef0
movq -0x20(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0xe2fec
movq -0x290(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
jne 0xe2fec
movq -0x290(%rbp), %rax
movswl 0x9e(%rax), %ecx
leaq 0x96aa4(%rip), %rdx     # 0x1799c7
xorl %eax, %eax
leaq -0x2d0(%rbp), %rdi
movl $0x20, %esi
callq 0xc4d30
callq 0xdae90
movss %xmm0, -0x2d4(%rbp)
movq -0x298(%rbp), %rax
movq %rax, -0x4d8(%rbp)
movq -0x290(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x4d0(%rbp)
movss -0x2d4(%rbp), %xmm1
leaq -0x2e4(%rbp), %rdi
movq %rdi, -0x4e0(%rbp)
movaps %xmm1, %xmm0
callq 0xbf4c0
movq -0x4e0(%rbp), %rsi
movq -0x4d0(%rbp), %rdi
callq 0xc41b0
movq -0x4d8(%rbp), %rdi
movq -0x4d0(%rbp), %rsi
movlpd %xmm0, -0x2dc(%rbp)
leaq -0x2dc(%rbp), %rdx
movl $0xff6464c8, %ecx       # imm = 0xFF6464C8
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movq -0x298(%rbp), %rdi
movq -0x290(%rbp), %rsi
addq $0x10, %rsi
leaq -0x2d0(%rbp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r8d
callq 0x114680
jmp 0xe2fee
movl -0x284(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x284(%rbp)
jmp 0xe2e2a
jmp 0xe3004
movq -0x20(%rbp), %rax
testb $0x1, 0x2(%rax)
je 0xe3236
movl $0x0, -0x2e8(%rbp)
movl -0x2e8(%rbp), %eax
movl %eax, -0x4e4(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
callq 0xec6a0
movl %eax, %ecx
movl -0x4e4(%rbp), %eax
cmpl %ecx, %eax
jge 0xe3234
movq -0x10(%rbp), %rdi
addq $0x20b0, %rdi           # imm = 0x20B0
movl -0x2e8(%rbp), %esi
callq 0xea9d0
movq %rax, -0x2f0(%rbp)
movq -0x2f0(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x1a68(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xe3085
jmp 0xe3220
movq -0x2f0(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0xec880
movq %rax, -0x2f8(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, 0xc(%rax)
jl 0xe31c2
movl $0x0, -0x2fc(%rbp)
movl -0x2fc(%rbp), %eax
movq -0x2f0(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0xe31c0
movq -0x2f0(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movl -0x2fc(%rbp), %edx
callq 0xe34a0
movlpd %xmm0, -0x30c(%rbp)
movlpd %xmm1, -0x304(%rbp)
movq -0x2f0(%rbp), %rax
movsbl 0x234(%rax), %edx
movl -0x2fc(%rbp), %esi
movl $0xff8000ff, %eax       # imm = 0xFF8000FF
movl $0xff80ffff, %ecx       # imm = 0xFF80FFFF
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x310(%rbp)
movq -0x2f0(%rbp), %rax
movsbl 0x234(%rax), %eax
movl -0x2fc(%rbp), %ecx
movss 0x8ee85(%rip), %xmm0    # 0x171fc0
movss 0x8daf9(%rip), %xmm1    # 0x170c3c
movss %xmm1, -0x4ec(%rbp)
cmpl %ecx, %eax
movss %xmm0, -0x4e8(%rbp)
je 0xe3167
movss -0x4ec(%rbp), %xmm0
movss %xmm0, -0x4e8(%rbp)
movss -0x4e8(%rbp), %xmm0
movss %xmm0, -0x314(%rbp)
movq -0x2f8(%rbp), %rdi
leaq -0x30c(%rbp), %rsi
leaq -0x30c(%rbp), %rdx
addq $0x8, %rdx
movl -0x310(%rbp), %ecx
movss -0x314(%rbp), %xmm1
xorps %xmm0, %xmm0
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x112ef0
movl -0x2fc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2fc(%rbp)
jmp 0xe30b7
jmp 0xe321e
movq -0x2f0(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xe34a0
movlpd %xmm0, -0x324(%rbp)
movlpd %xmm1, -0x31c(%rbp)
movq -0x2f8(%rbp), %rdi
leaq -0x324(%rbp), %rsi
leaq -0x324(%rbp), %rdx
addq $0x8, %rdx
movl $0xff8000ff, %ecx       # imm = 0xFF8000FF
xorps %xmm0, %xmm0
movl $0xf, %r8d
movss 0x8da23(%rip), %xmm1    # 0x170c3c
callq 0x112ef0
jmp 0xe3220
movl -0x2e8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2e8(%rbp)
jmp 0xe301c
jmp 0xe3236
callq 0xd3b60
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
nopw %cs:(%rax,%rax)