// File: Ciaxur[P]yagb-emu/include/imgui/imgui_demo.cpp
// Function: ShowExampleAppCustomRendering(bool*)
static void ShowExampleAppCustomRendering(bool* p_open)
{
    if (!ImGui::Begin("Example: Custom rendering", p_open))
    {
        ImGui::End();
        return;
    }

    // Tip: If you do a lot of custom rendering, you probably want to use your own geometrical types and benefit of
    // overloaded operators, etc. Define IM_VEC2_CLASS_EXTRA in imconfig.h to create implicit conversions between your
    // types and ImVec2/ImVec4. Dear ImGui defines overloaded operators but they are internal to imgui.cpp and not
    // exposed outside (to avoid messing with your types) In this example we are not using the maths operators!

    if (ImGui::BeginTabBar("##TabBar"))
    {
        if (ImGui::BeginTabItem("Primitives"))
        {
            ImGui::PushItemWidth(-ImGui::GetFontSize() * 15);
            ImDrawList* draw_list = ImGui::GetWindowDrawList();

            // Draw gradients
            // (note that those are currently exacerbating our sRGB/Linear issues)
            // Calling ImGui::GetColorU32() multiplies the given colors by the current Style Alpha, but you may pass the IM_COL32() directly as well..
            ImGui::Text("Gradients");
            ImVec2 gradient_size = ImVec2(ImGui::CalcItemWidth(), ImGui::GetFrameHeight());
            {
                ImVec2 p0 = ImGui::GetCursorScreenPos();
                ImVec2 p1 = ImVec2(p0.x + gradient_size.x, p0.y + gradient_size.y);
                ImU32 col_a = ImGui::GetColorU32(IM_COL32(0, 0, 0, 255));
                ImU32 col_b = ImGui::GetColorU32(IM_COL32(255, 255, 255, 255));
                draw_list->AddRectFilledMultiColor(p0, p1, col_a, col_b, col_b, col_a);
                ImGui::InvisibleButton("##gradient1", gradient_size);
            }
            {
                ImVec2 p0 = ImGui::GetCursorScreenPos();
                ImVec2 p1 = ImVec2(p0.x + gradient_size.x, p0.y + gradient_size.y);
                ImU32 col_a = ImGui::GetColorU32(IM_COL32(0, 255, 0, 255));
                ImU32 col_b = ImGui::GetColorU32(IM_COL32(255, 0, 0, 255));
                draw_list->AddRectFilledMultiColor(p0, p1, col_a, col_b, col_b, col_a);
                ImGui::InvisibleButton("##gradient2", gradient_size);
            }

            // Draw a bunch of primitives
            ImGui::Text("All primitives");
            static float sz = 36.0f;
            static float thickness = 3.0f;
            static int ngon_sides = 6;
            static bool circle_segments_override = false;
            static int circle_segments_override_v = 12;
            static bool curve_segments_override = false;
            static int curve_segments_override_v = 8;
            static ImVec4 colf = ImVec4(1.0f, 1.0f, 0.4f, 1.0f);
            ImGui::DragFloat("Size", &sz, 0.2f, 2.0f, 72.0f, "%.0f");
            ImGui::DragFloat("Thickness", &thickness, 0.05f, 1.0f, 8.0f, "%.02f");
            ImGui::SliderInt("N-gon sides", &ngon_sides, 3, 12);
            ImGui::Checkbox("##circlesegmentoverride", &circle_segments_override);
            ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
            circle_segments_override |= ImGui::SliderInt("Circle segments override", &circle_segments_override_v, 3, 40);
            ImGui::Checkbox("##curvessegmentoverride", &curve_segments_override);
            ImGui::SameLine(0.0f, ImGui::GetStyle().ItemInnerSpacing.x);
            curve_segments_override |= ImGui::SliderInt("Curves segments override", &curve_segments_override_v, 3, 40);
            ImGui::ColorEdit4("Color", &colf.x);

            const ImVec2 p = ImGui::GetCursorScreenPos();
            const ImU32 col = ImColor(colf);
            const float spacing = 10.0f;
            const ImDrawCornerFlags corners_none = 0;
            const ImDrawCornerFlags corners_all = ImDrawCornerFlags_All;
            const ImDrawCornerFlags corners_tl_br = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotRight;
            const int circle_segments = circle_segments_override ? circle_segments_override_v : 0;
            const int curve_segments = curve_segments_override ? curve_segments_override_v : 0;
            float x = p.x + 4.0f;
            float y = p.y + 4.0f;
            for (int n = 0; n < 2; n++)
            {
                // First line uses a thickness of 1.0f, second line uses the configurable thickness
                float th = (n == 0) ? 1.0f : thickness;
                draw_list->AddNgon(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col, ngon_sides, th);                 x += sz + spacing;  // N-gon
                draw_list->AddCircle(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col, circle_segments, th);          x += sz + spacing;  // Circle
                draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col, 0.0f,  corners_none, th);             x += sz + spacing;  // Square
                draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col, 10.0f, corners_all, th);              x += sz + spacing;  // Square with all rounded corners
                draw_list->AddRect(ImVec2(x, y), ImVec2(x + sz, y + sz), col, 10.0f, corners_tl_br, th);            x += sz + spacing;  // Square with two rounded corners
                draw_list->AddTriangle(ImVec2(x+sz*0.5f,y), ImVec2(x+sz, y+sz-0.5f), ImVec2(x, y+sz-0.5f), col, th);x += sz + spacing;  // Triangle
                //draw_list->AddTriangle(ImVec2(x+sz*0.2f,y), ImVec2(x, y+sz-0.5f), ImVec2(x+sz*0.4f, y+sz-0.5f), col, th);x+= sz*0.4f + spacing; // Thin triangle
                draw_list->AddLine(ImVec2(x, y), ImVec2(x + sz, y), col, th);                                       x += sz + spacing;  // Horizontal line (note: drawing a filled rectangle will be faster!)
                draw_list->AddLine(ImVec2(x, y), ImVec2(x, y + sz), col, th);                                       x += spacing;       // Vertical line (note: drawing a filled rectangle will be faster!)
                draw_list->AddLine(ImVec2(x, y), ImVec2(x + sz, y + sz), col, th);                                  x += sz + spacing;  // Diagonal line

                // Quadratic Bezier Curve (3 control points)
                ImVec2 cp3[3] = { ImVec2(x, y + sz * 0.6f), ImVec2(x + sz * 0.5f, y - sz * 0.4f), ImVec2(x + sz, y + sz) };
                draw_list->AddBezierQuadratic(cp3[0], cp3[1], cp3[2], col, th, curve_segments); x += sz + spacing;

                // Cubic Bezier Curve (4 control points)
                ImVec2 cp4[4] = { ImVec2(x, y), ImVec2(x + sz * 1.3f, y + sz * 0.3f), ImVec2(x + sz - sz * 1.3f, y + sz - sz * 0.3f), ImVec2(x + sz, y + sz) };
                draw_list->AddBezierCubic(cp4[0], cp4[1], cp4[2], cp4[3], col, th, curve_segments);

                x = p.x + 4;
                y += sz + spacing;
            }
            draw_list->AddNgonFilled(ImVec2(x + sz * 0.5f, y + sz * 0.5f), sz*0.5f, col, ngon_sides);               x += sz + spacing;  // N-gon
            draw_list->AddCircleFilled(ImVec2(x + sz*0.5f, y + sz*0.5f), sz*0.5f, col, circle_segments);            x += sz + spacing;  // Circle
            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + sz), col);                                    x += sz + spacing;  // Square
            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + sz), col, 10.0f);                             x += sz + spacing;  // Square with all rounded corners
            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + sz), col, 10.0f, corners_tl_br);              x += sz + spacing;  // Square with two rounded corners
            draw_list->AddTriangleFilled(ImVec2(x+sz*0.5f,y), ImVec2(x+sz, y+sz-0.5f), ImVec2(x, y+sz-0.5f), col);  x += sz + spacing;  // Triangle
            //draw_list->AddTriangleFilled(ImVec2(x+sz*0.2f,y), ImVec2(x, y+sz-0.5f), ImVec2(x+sz*0.4f, y+sz-0.5f), col); x += sz*0.4f + spacing; // Thin triangle
            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + sz, y + thickness), col);                             x += sz + spacing;  // Horizontal line (faster than AddLine, but only handle integer thickness)
            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + thickness, y + sz), col);                             x += spacing * 2.0f;// Vertical line (faster than AddLine, but only handle integer thickness)
            draw_list->AddRectFilled(ImVec2(x, y), ImVec2(x + 1, y + 1), col);                                      x += sz;            // Pixel (faster than AddLine)
            draw_list->AddRectFilledMultiColor(ImVec2(x, y), ImVec2(x + sz, y + sz), IM_COL32(0, 0, 0, 255), IM_COL32(255, 0, 0, 255), IM_COL32(255, 255, 0, 255), IM_COL32(0, 255, 0, 255));

            ImGui::Dummy(ImVec2((sz + spacing) * 10.2f, (sz + spacing) * 3.0f));
            ImGui::PopItemWidth();
            ImGui::EndTabItem();
        }

        if (ImGui::BeginTabItem("Canvas"))
        {
            static ImVector<ImVec2> points;
            static ImVec2 scrolling(0.0f, 0.0f);
            static bool opt_enable_grid = true;
            static bool opt_enable_context_menu = true;
            static bool adding_line = false;

            ImGui::Checkbox("Enable grid", &opt_enable_grid);
            ImGui::Checkbox("Enable context menu", &opt_enable_context_menu);
            ImGui::Text("Mouse Left: drag to add lines,\nMouse Right: drag to scroll, click for context menu.");

            // Typically you would use a BeginChild()/EndChild() pair to benefit from a clipping region + own scrolling.
            // Here we demonstrate that this can be replaced by simple offsetting + custom drawing + PushClipRect/PopClipRect() calls.
            // To use a child window instead we could use, e.g:
            //      ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));      // Disable padding
            //      ImGui::PushStyleColor(ImGuiCol_ChildBg, IM_COL32(50, 50, 50, 255));  // Set a background color
            //      ImGui::BeginChild("canvas", ImVec2(0.0f, 0.0f), true, ImGuiWindowFlags_NoMove);
            //      ImGui::PopStyleColor();
            //      ImGui::PopStyleVar();
            //      [...]
            //      ImGui::EndChild();

            // Using InvisibleButton() as a convenience 1) it will advance the layout cursor and 2) allows us to use IsItemHovered()/IsItemActive()
            ImVec2 canvas_p0 = ImGui::GetCursorScreenPos();      // ImDrawList API uses screen coordinates!
            ImVec2 canvas_sz = ImGui::GetContentRegionAvail();   // Resize canvas to what's available
            if (canvas_sz.x < 50.0f) canvas_sz.x = 50.0f;
            if (canvas_sz.y < 50.0f) canvas_sz.y = 50.0f;
            ImVec2 canvas_p1 = ImVec2(canvas_p0.x + canvas_sz.x, canvas_p0.y + canvas_sz.y);

            // Draw border and background color
            ImGuiIO& io = ImGui::GetIO();
            ImDrawList* draw_list = ImGui::GetWindowDrawList();
            draw_list->AddRectFilled(canvas_p0, canvas_p1, IM_COL32(50, 50, 50, 255));
            draw_list->AddRect(canvas_p0, canvas_p1, IM_COL32(255, 255, 255, 255));

            // This will catch our interactions
            ImGui::InvisibleButton("canvas", canvas_sz, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
            const bool is_hovered = ImGui::IsItemHovered(); // Hovered
            const bool is_active = ImGui::IsItemActive();   // Held
            const ImVec2 origin(canvas_p0.x + scrolling.x, canvas_p0.y + scrolling.y); // Lock scrolled origin
            const ImVec2 mouse_pos_in_canvas(io.MousePos.x - origin.x, io.MousePos.y - origin.y);

            // Add first and second point
            if (is_hovered && !adding_line && ImGui::IsMouseClicked(ImGuiMouseButton_Left))
            {
                points.push_back(mouse_pos_in_canvas);
                points.push_back(mouse_pos_in_canvas);
                adding_line = true;
            }
            if (adding_line)
            {
                points.back() = mouse_pos_in_canvas;
                if (!ImGui::IsMouseDown(ImGuiMouseButton_Left))
                    adding_line = false;
            }

            // Pan (we use a zero mouse threshold when there's no context menu)
            // You may decide to make that threshold dynamic based on whether the mouse is hovering something etc.
            const float mouse_threshold_for_pan = opt_enable_context_menu ? -1.0f : 0.0f;
            if (is_active && ImGui::IsMouseDragging(ImGuiMouseButton_Right, mouse_threshold_for_pan))
            {
                scrolling.x += io.MouseDelta.x;
                scrolling.y += io.MouseDelta.y;
            }

            // Context menu (under default mouse threshold)
            ImVec2 drag_delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
            if (opt_enable_context_menu && ImGui::IsMouseReleased(ImGuiMouseButton_Right) && drag_delta.x == 0.0f && drag_delta.y == 0.0f)
                ImGui::OpenPopupOnItemClick("context");
            if (ImGui::BeginPopup("context"))
            {
                if (adding_line)
                    points.resize(points.size() - 2);
                adding_line = false;
                if (ImGui::MenuItem("Remove one", NULL, false, points.Size > 0)) { points.resize(points.size() - 2); }
                if (ImGui::MenuItem("Remove all", NULL, false, points.Size > 0)) { points.clear(); }
                ImGui::EndPopup();
            }

            // Draw grid + all lines in the canvas
            draw_list->PushClipRect(canvas_p0, canvas_p1, true);
            if (opt_enable_grid)
            {
                const float GRID_STEP = 64.0f;
                for (float x = fmodf(scrolling.x, GRID_STEP); x < canvas_sz.x; x += GRID_STEP)
                    draw_list->AddLine(ImVec2(canvas_p0.x + x, canvas_p0.y), ImVec2(canvas_p0.x + x, canvas_p1.y), IM_COL32(200, 200, 200, 40));
                for (float y = fmodf(scrolling.y, GRID_STEP); y < canvas_sz.y; y += GRID_STEP)
                    draw_list->AddLine(ImVec2(canvas_p0.x, canvas_p0.y + y), ImVec2(canvas_p1.x, canvas_p0.y + y), IM_COL32(200, 200, 200, 40));
            }
            for (int n = 0; n < points.Size; n += 2)
                draw_list->AddLine(ImVec2(origin.x + points[n].x, origin.y + points[n].y), ImVec2(origin.x + points[n + 1].x, origin.y + points[n + 1].y), IM_COL32(255, 255, 0, 255), 2.0f);
            draw_list->PopClipRect();

            ImGui::EndTabItem();
        }

        if (ImGui::BeginTabItem("BG/FG draw lists"))
        {
            static bool draw_bg = true;
            static bool draw_fg = true;
            ImGui::Checkbox("Draw in Background draw list", &draw_bg);
            ImGui::SameLine(); HelpMarker("The Background draw list will be rendered below every Dear ImGui windows.");
            ImGui::Checkbox("Draw in Foreground draw list", &draw_fg);
            ImGui::SameLine(); HelpMarker("The Foreground draw list will be rendered over every Dear ImGui windows.");
            ImVec2 window_pos = ImGui::GetWindowPos();
            ImVec2 window_size = ImGui::GetWindowSize();
            ImVec2 window_center = ImVec2(window_pos.x + window_size.x * 0.5f, window_pos.y + window_size.y * 0.5f);
            if (draw_bg)
                ImGui::GetBackgroundDrawList()->AddCircle(window_center, window_size.x * 0.6f, IM_COL32(255, 0, 0, 200), 0, 10 + 4);
            if (draw_fg)
                ImGui::GetForegroundDrawList()->AddCircle(window_center, window_size.y * 0.6f, IM_COL32(0, 255, 0, 200), 0, 10);
            ImGui::EndTabItem();
        }

        ImGui::EndTabBar();
    }

    ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp            # imm = 0x3D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x90e43(%rip), %rdi     # 0x1834cd
xorl %edx, %edx
callq 0xd0170
testb $0x1, %al
jne 0xf269f
callq 0xd3b60
jmp 0xf4483
leaq 0x90e41(%rip), %rdi     # 0x1834e7
xorl %esi, %esi
callq 0x1558c0
testb $0x1, %al
jne 0xf26b6
jmp 0xf447e
leaq 0x90e33(%rip), %rdi     # 0x1834f0
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1573a0
testb $0x1, %al
jne 0xf26d1
jmp 0xf3aa6
callq 0xdae90
movss 0x85eb6(%rip), %xmm1    # 0x178594
mulss %xmm1, %xmm0
callq 0xdcb10
callq 0xdae40
movq %rax, -0x10(%rbp)
leaq 0x90e04(%rip), %rdi     # 0x1834fb
xorl %eax, %eax
movl %eax, -0x2b4(%rbp)
callq 0x139160
callq 0xdcdc0
movss %xmm0, -0x2cc(%rbp)
callq 0xdd050
movaps %xmm0, %xmm1
movss -0x2cc(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
callq 0xbf4c0
callq 0xdc6c0
movlpd %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
movss -0x18(%rbp), %xmm3
movss -0x14(%rbp), %xmm2
addss %xmm3, %xmm0
addss %xmm2, %xmm1
leaq -0x28(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0xbf4c0
movl $0xff000000, %edi       # imm = 0xFF000000
callq 0xc77e0
movl %eax, -0x2c(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xc77e0
movq -0x2c8(%rbp), %rdx
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq %rsp, %rax
movl %ecx, (%rax)
leaq -0x20(%rbp), %rsi
movl %r9d, %r8d
callq 0x113130
movq -0x2c0(%rbp), %rsi
movl -0x2b4(%rbp), %edx
leaq 0x90d4d(%rip), %rdi     # 0x183505
callq 0x13a9f0
callq 0xdc6c0
movlpd %xmm0, -0x38(%rbp)
movss -0x38(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
addss -0x14(%rbp), %xmm1
leaq -0x40(%rbp), %rdi
callq 0xbf4c0
movl $0xff00ff00, %edi       # imm = 0xFF00FF00
callq 0xc77e0
movl %eax, -0x44(%rbp)
movl $0xff0000ff, %edi       # imm = 0xFF0000FF
callq 0xc77e0
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %ecx
movl -0x48(%rbp), %r8d
movl -0x48(%rbp), %r9d
movl -0x44(%rbp), %eax
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movl %eax, (%rsp)
callq 0x113130
leaq 0x90cea(%rip), %rdi     # 0x183511
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x13a9f0
leaq 0x90ce4(%rip), %rdi     # 0x18351d
movb $0x0, %al
callq 0x139160
cmpb $0x0, 0x121c21(%rip)    # 0x214468
jne 0xf288a
leaq 0x121c18(%rip), %rdi    # 0x214468
callq 0xd380
cmpl $0x0, %eax
je 0xf288a
leaq 0x121bf3(%rip), %rdi    # 0x214454
movss 0x7ff7b(%rip), %xmm2    # 0x1727e4
movss 0x7e3cb(%rip), %xmm3    # 0x170c3c
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
callq 0xbf4f0
jmp 0xf287e
leaq 0x121be3(%rip), %rdi    # 0x214468
callq 0xd580
leaq 0x8b2e6(%rip), %rdi     # 0x17db77
leaq 0x1203d0(%rip), %rsi    # 0x212c68
leaq 0x8bda4(%rip), %rdx     # 0x17e643
movss 0x7f729(%rip), %xmm0    # 0x171fd0
movss 0x7f71d(%rip), %xmm1    # 0x171fcc
movss 0x85ce1(%rip), %xmm2    # 0x178598
xorl %ecx, %ecx
movl %ecx, -0x2d0(%rbp)
callq 0x142f00
movl -0x2d0(%rbp), %ecx
leaq 0x90c5b(%rip), %rdi     # 0x18352c
leaq 0x120394(%rip), %rsi    # 0x212c6c
leaq 0x90c57(%rip), %rdx     # 0x183536
movss 0x7ff09(%rip), %xmm0    # 0x1727f0
movss 0x7e34d(%rip), %xmm1    # 0x170c3c
movss 0x7fe4d(%rip), %xmm2    # 0x172744
callq 0x142f00
movl -0x2d0(%rbp), %r9d
leaq 0x90c32(%rip), %rdi     # 0x18353c
leaq 0x12035f(%rip), %rsi    # 0x212c70
leaq 0x870af(%rip), %r8      # 0x1799c7
movq %r8, -0x2d8(%rbp)
movl $0x3, %edx
movl %edx, -0x2e0(%rbp)
movl $0xc, %ecx
callq 0x144b30
leaq 0x90c0d(%rip), %rdi     # 0x183548
leaq 0x121b0e(%rip), %rsi    # 0x214450
callq 0x13c7c0
callq 0xc7680
movss 0x50(%rax), %xmm1
xorps %xmm0, %xmm0
movss %xmm0, -0x2e4(%rbp)
callq 0xdc1c0
movl -0x2e0(%rbp), %edx
movq -0x2d8(%rbp), %r8
movl -0x2d0(%rbp), %r9d
leaq 0x90be4(%rip), %rdi     # 0x183560
leaq 0x1202f1(%rip), %rsi    # 0x212c74
movl $0x28, %ecx
movl %ecx, -0x2dc(%rbp)
callq 0x144b30
movb %al, %cl
movb 0x121ab5(%rip), %al     # 0x214450
orb %cl, %al
andb $0x1, %al
movb %al, 0x121aab(%rip)     # 0x214450
leaq 0x90bcd(%rip), %rdi     # 0x183579
leaq 0x121a9e(%rip), %rsi    # 0x214451
callq 0x13c7c0
callq 0xc7680
movss -0x2e4(%rbp), %xmm0
movss 0x50(%rax), %xmm1
callq 0xdc1c0
movl -0x2e0(%rbp), %edx
movl -0x2dc(%rbp), %ecx
movq -0x2d8(%rbp), %r8
movl -0x2d0(%rbp), %r9d
leaq 0x90ba1(%rip), %rdi     # 0x183591
leaq 0x120281(%rip), %rsi    # 0x212c78
callq 0x144b30
movl -0x2d0(%rbp), %edx
movb %al, %cl
movb 0x121a47(%rip), %al     # 0x214451
orb %cl, %al
andb $0x1, %al
movb %al, 0x121a3d(%rip)     # 0x214451
leaq 0x89992(%rip), %rdi     # 0x17c3ad
leaq 0x121a32(%rip), %rsi    # 0x214454
callq 0x14bea0
callq 0xdc6c0
movlpd %xmm0, -0x5c(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x121a18(%rip), %rsi    # 0x214454
callq 0x10b770
leaq -0x70(%rbp), %rdi
callq 0x10b7b0
movl %eax, -0x60(%rbp)
movss 0x7f587(%rip), %xmm0    # 0x171fdc
movss %xmm0, -0x74(%rbp)
movl $0x0, -0x78(%rbp)
movl $0xf, -0x7c(%rbp)
movl $0x9, -0x80(%rbp)
testb $0x1, 0x1219da(%rip)    # 0x214450
je 0xf2a86
movl 0x1201f6(%rip), %eax    # 0x212c74
movl %eax, -0x2e8(%rbp)
jmp 0xf2a90
xorl %eax, %eax
movl %eax, -0x2e8(%rbp)
jmp 0xf2a90
movl -0x2e8(%rbp), %eax
movl %eax, -0x84(%rbp)
testb $0x1, 0x1219ae(%rip)    # 0x214451
je 0xf2ab3
movl 0x1201cd(%rip), %eax    # 0x212c78
movl %eax, -0x2ec(%rbp)
jmp 0xf2abd
xorl %eax, %eax
movl %eax, -0x2ec(%rbp)
jmp 0xf2abd
movl -0x2ec(%rbp), %eax
movl %eax, -0x88(%rbp)
movss 0x7fc63(%rip), %xmm0    # 0x172734
addss -0x5c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movss 0x7fc4e(%rip), %xmm0    # 0x172734
addss -0x58(%rbp), %xmm0
movss %xmm0, -0x90(%rbp)
movl $0x0, -0x94(%rbp)
cmpl $0x2, -0x94(%rbp)
jge 0xf3405
cmpl $0x0, -0x94(%rbp)
jne 0xf2b25
movss 0x7e121(%rip), %xmm0    # 0x170c3c
movss %xmm0, -0x2f0(%rbp)
jmp 0xf2b35
movss 0x12013f(%rip), %xmm0   # 0x212c6c
movss %xmm0, -0x2f0(%rbp)
movss -0x2f0(%rbp), %xmm0
movss %xmm0, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x338(%rbp)
movss -0x8c(%rbp), %xmm1
movss 0x120108(%rip), %xmm0   # 0x212c68
movss 0x7f470(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
movss 0x1200e8(%rip), %xmm1   # 0x212c68
movss 0x7f450(%rip), %xmm3    # 0x171fd8
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0xa0(%rbp), %rdi
callq 0xbf4c0
movq -0x338(%rbp), %rdi
movss 0x7f42d(%rip), %xmm0    # 0x171fd8
mulss 0x1200b5(%rip), %xmm0   # 0x212c68
movl -0x60(%rbp), %edx
movl 0x1200b4(%rip), %ecx    # 0x212c70
movss -0x98(%rbp), %xmm1
leaq -0xa0(%rbp), %rsi
callq 0x113750
movss 0x7f404(%rip), %xmm0    # 0x171fdc
addss 0x120088(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x330(%rbp)
movss -0x8c(%rbp), %xmm1
movss 0x12005d(%rip), %xmm0   # 0x212c68
movss 0x7f3c5(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
movss 0x12003d(%rip), %xmm1   # 0x212c68
movss 0x7f3a5(%rip), %xmm3    # 0x171fd8
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0xa8(%rbp), %rdi
callq 0xbf4c0
movq -0x330(%rbp), %rdi
movss 0x7f382(%rip), %xmm0    # 0x171fd8
mulss 0x12000a(%rip), %xmm0   # 0x212c68
movl -0x60(%rbp), %edx
movl -0x84(%rbp), %ecx
movss -0x98(%rbp), %xmm1
leaq -0xa8(%rbp), %rsi
callq 0x113490
movss 0x7f359(%rip), %xmm0    # 0x171fdc
addss 0x11ffdd(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x328(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0xb0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11ff96(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11ff86(%rip), %xmm1   # 0x212c68
leaq -0xb8(%rbp), %rdi
callq 0xbf4c0
movq -0x328(%rbp), %rdi
movl -0x60(%rbp), %ecx
movss -0x98(%rbp), %xmm1
leaq -0xb0(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
xorps %xmm0, %xmm0
xorl %r8d, %r8d
callq 0x112ef0
movss 0x7f2bb(%rip), %xmm0    # 0x171fdc
addss 0x11ff3f(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x320(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0xc0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11fef8(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11fee8(%rip), %xmm1   # 0x212c68
leaq -0xc8(%rbp), %rdi
callq 0xbf4c0
movq -0x320(%rbp), %rdi
movl -0x60(%rbp), %ecx
movss -0x98(%rbp), %xmm1
leaq -0xc0(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
movss 0x7f228(%rip), %xmm0    # 0x171fdc
movl $0xf, %r8d
callq 0x112ef0
movss 0x7f215(%rip), %xmm0    # 0x171fdc
addss 0x11fe99(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x318(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0xd0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11fe52(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11fe42(%rip), %xmm1   # 0x212c68
leaq -0xd8(%rbp), %rdi
callq 0xbf4c0
movq -0x318(%rbp), %rdi
movl -0x60(%rbp), %ecx
movss -0x98(%rbp), %xmm1
leaq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
movss 0x7f182(%rip), %xmm0    # 0x171fdc
movl $0x9, %r8d
callq 0x112ef0
movss 0x7f16f(%rip), %xmm0    # 0x171fdc
addss 0x11fdf3(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x310(%rbp)
movss -0x8c(%rbp), %xmm1
movss 0x11fdc8(%rip), %xmm0   # 0x212c68
movss 0x7f130(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm1
leaq -0xe0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11fd94(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11fd84(%rip), %xmm1   # 0x212c68
movss 0x7f0ec(%rip), %xmm2    # 0x171fd8
subss %xmm2, %xmm1
leaq -0xe8(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
addss 0x11fd54(%rip), %xmm1   # 0x212c68
movss 0x7f0bc(%rip), %xmm2    # 0x171fd8
subss %xmm2, %xmm1
leaq -0xf0(%rbp), %rdi
callq 0xbf4c0
movq -0x310(%rbp), %rdi
movl -0x60(%rbp), %r8d
movss -0x98(%rbp), %xmm0
leaq -0xe0(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
leaq -0xf0(%rbp), %rcx
callq 0x1133a0
movss 0x7f07b(%rip), %xmm0    # 0x171fdc
addss 0x11fcff(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x308(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0xf8(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11fcb8(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
leaq -0x100(%rbp), %rdi
callq 0xbf4c0
movq -0x308(%rbp), %rdi
movl -0x60(%rbp), %ecx
movss -0x98(%rbp), %xmm0
leaq -0xf8(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x112e20
movss 0x7efeb(%rip), %xmm0    # 0x171fdc
addss 0x11fc6f(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x300(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x108(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
addss 0x11fc20(%rip), %xmm1   # 0x212c68
leaq -0x110(%rbp), %rdi
callq 0xbf4c0
movq -0x300(%rbp), %rdi
movl -0x60(%rbp), %ecx
movss -0x98(%rbp), %xmm0
leaq -0x108(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0x112e20
movss 0x7ef5b(%rip), %xmm0    # 0x171fdc
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x118(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11fba0(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11fb90(%rip), %xmm1   # 0x212c68
leaq -0x120(%rbp), %rdi
callq 0xbf4c0
movq -0x2f8(%rbp), %rdi
movl -0x60(%rbp), %ecx
movss -0x98(%rbp), %xmm0
leaq -0x118(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x112e20
movss 0x7eecb(%rip), %xmm0    # 0x171fdc
addss 0x11fb4f(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm2
movss 0x11fb27(%rip), %xmm1   # 0x212c68
movss 0x7ee5f(%rip), %xmm3    # 0x171fa8
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x140(%rbp), %rdi
callq 0xbf4c0
leaq -0x140(%rbp), %rdi
addq $0x8, %rdi
movss -0x8c(%rbp), %xmm1
movss 0x11faf0(%rip), %xmm0   # 0x212c68
movss 0x7ee58(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
movss 0x11fad0(%rip), %xmm1   # 0x212c68
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
movss 0x7f637(%rip), %xmm3    # 0x1727e4
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
callq 0xbf4c0
leaq -0x140(%rbp), %rdi
addq $0x10, %rdi
movss -0x8c(%rbp), %xmm0
addss 0x11fa93(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11fa83(%rip), %xmm1   # 0x212c68
callq 0xbf4c0
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
leaq -0x140(%rbp), %rdx
addq $0x8, %rdx
leaq -0x140(%rbp), %rcx
addq $0x10, %rcx
movl -0x60(%rbp), %r8d
movss -0x98(%rbp), %xmm0
movl -0x88(%rbp), %r9d
callq 0x113920
movss 0x7edb1(%rip), %xmm0    # 0x171fdc
addss 0x11fa35(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x160(%rbp), %rdi
callq 0xbf4c0
leaq -0x160(%rbp), %rdi
addq $0x8, %rdi
movss -0x8c(%rbp), %xmm1
movss 0x11f9ee(%rip), %xmm0   # 0x212c68
movss 0x85326(%rip), %xmm2    # 0x1785a8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
movss 0x11f9ce(%rip), %xmm1   # 0x212c68
movss 0x7f4aa(%rip), %xmm3    # 0x17274c
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
callq 0xbf4c0
leaq -0x160(%rbp), %rdi
addq $0x10, %rdi
movss -0x8c(%rbp), %xmm1
addss 0x11f99e(%rip), %xmm1   # 0x212c68
movss 0x11f996(%rip), %xmm0   # 0x212c68
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0x852c1(%rip), %xmm2    # 0x1785a8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
addss 0x11f969(%rip), %xmm2   # 0x212c68
movss 0x11f961(%rip), %xmm1   # 0x212c68
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
movss 0x7f430(%rip), %xmm3    # 0x17274c
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
callq 0xbf4c0
leaq -0x160(%rbp), %rdi
addq $0x18, %rdi
movss -0x8c(%rbp), %xmm0
addss 0x11f924(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f914(%rip), %xmm1   # 0x212c68
callq 0xbf4c0
movq -0x10(%rbp), %rdi
leaq -0x160(%rbp), %rsi
leaq -0x160(%rbp), %rdx
addq $0x8, %rdx
leaq -0x160(%rbp), %rcx
addq $0x10, %rcx
leaq -0x160(%rbp), %r8
addq $0x18, %r8
movl -0x60(%rbp), %r9d
movss -0x98(%rbp), %xmm0
movl -0x88(%rbp), %eax
movl %eax, (%rsp)
callq 0x1138a0
movss 0x7f38d(%rip), %xmm0    # 0x172734
addss -0x5c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movss 0x7ec20(%rip), %xmm0    # 0x171fdc
addss 0x11f8a4(%rip), %xmm0   # 0x212c68
addss -0x90(%rbp), %xmm0
movss %xmm0, -0x90(%rbp)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0xf2afd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq 0x12106d(%rip), %rdi    # 0x214468
callq 0xd460
jmp 0xf448c
movq -0x10(%rbp), %rax
movq %rax, -0x388(%rbp)
movss -0x8c(%rbp), %xmm1
movss 0x11f848(%rip), %xmm0   # 0x212c68
movss 0x7ebb0(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
movss 0x11f828(%rip), %xmm1   # 0x212c68
movss 0x7eb90(%rip), %xmm3    # 0x171fd8
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x168(%rbp), %rdi
callq 0xbf4c0
movq -0x388(%rbp), %rdi
movss 0x7eb6d(%rip), %xmm0    # 0x171fd8
mulss 0x11f7f5(%rip), %xmm0   # 0x212c68
movl -0x60(%rbp), %edx
movl 0x11f7f4(%rip), %ecx    # 0x212c70
leaq -0x168(%rbp), %rsi
callq 0x113800
movss 0x7eb4c(%rip), %xmm0    # 0x171fdc
addss 0x11f7d0(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x380(%rbp)
movss -0x8c(%rbp), %xmm1
movss 0x11f7a5(%rip), %xmm0   # 0x212c68
movss 0x7eb0d(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm2
movss 0x11f785(%rip), %xmm1   # 0x212c68
movss 0x7eaed(%rip), %xmm3    # 0x171fd8
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x170(%rbp), %rdi
callq 0xbf4c0
movq -0x380(%rbp), %rdi
movss 0x7eaca(%rip), %xmm0    # 0x171fd8
mulss 0x11f752(%rip), %xmm0   # 0x212c68
movl -0x60(%rbp), %edx
movl -0x84(%rbp), %ecx
leaq -0x170(%rbp), %rsi
callq 0x113600
movss 0x7eaa9(%rip), %xmm0    # 0x171fdc
addss 0x11f72d(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x378(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x178(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f6e6(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f6d6(%rip), %xmm1   # 0x212c68
leaq -0x180(%rbp), %rdi
callq 0xbf4c0
movq -0x378(%rbp), %rdi
movl -0x60(%rbp), %ecx
leaq -0x178(%rbp), %rsi
leaq -0x180(%rbp), %rdx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movss 0x7ea10(%rip), %xmm0    # 0x171fdc
addss 0x11f694(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x370(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x188(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f64d(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f63d(%rip), %xmm1   # 0x212c68
leaq -0x190(%rbp), %rdi
callq 0xbf4c0
movq -0x370(%rbp), %rdi
movl -0x60(%rbp), %ecx
leaq -0x188(%rbp), %rsi
leaq -0x190(%rbp), %rdx
movss 0x7e985(%rip), %xmm0    # 0x171fdc
movl $0xf, %r8d
callq 0x113090
movss 0x7e972(%rip), %xmm0    # 0x171fdc
addss 0x11f5f6(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x368(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x198(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f5af(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f59f(%rip), %xmm1   # 0x212c68
leaq -0x1a0(%rbp), %rdi
callq 0xbf4c0
movq -0x368(%rbp), %rdi
movl -0x60(%rbp), %ecx
leaq -0x198(%rbp), %rsi
leaq -0x1a0(%rbp), %rdx
movss 0x7e8e7(%rip), %xmm0    # 0x171fdc
movl $0x9, %r8d
callq 0x113090
movss 0x7e8d4(%rip), %xmm0    # 0x171fdc
addss 0x11f558(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x360(%rbp)
movss -0x8c(%rbp), %xmm1
movss 0x11f52d(%rip), %xmm0   # 0x212c68
movss 0x7e895(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x1a8(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f4f9(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f4e9(%rip), %xmm1   # 0x212c68
movss 0x7e851(%rip), %xmm2    # 0x171fd8
subss %xmm2, %xmm1
leaq -0x1b0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
addss 0x11f4b9(%rip), %xmm1   # 0x212c68
movss 0x7e821(%rip), %xmm2    # 0x171fd8
subss %xmm2, %xmm1
leaq -0x1b8(%rbp), %rdi
callq 0xbf4c0
movq -0x360(%rbp), %rdi
movl -0x60(%rbp), %r8d
leaq -0x1a8(%rbp), %rsi
leaq -0x1b0(%rbp), %rdx
leaq -0x1b8(%rbp), %rcx
callq 0x113420
movss 0x7e7e8(%rip), %xmm0    # 0x171fdc
addss 0x11f46c(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x358(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x1c0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f425(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f419(%rip), %xmm1   # 0x212c6c
leaq -0x1c8(%rbp), %rdi
callq 0xbf4c0
movq -0x358(%rbp), %rdi
movl -0x60(%rbp), %ecx
leaq -0x1c0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movss 0x7e74f(%rip), %xmm0    # 0x171fdc
addss 0x11f3d3(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x350(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x1d0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f390(%rip), %xmm0   # 0x212c6c
movss -0x90(%rbp), %xmm1
addss 0x11f37c(%rip), %xmm1   # 0x212c68
leaq -0x1d8(%rbp), %rdi
callq 0xbf4c0
movq -0x350(%rbp), %rdi
movl -0x60(%rbp), %ecx
leaq -0x1d0(%rbp), %rsi
leaq -0x1d8(%rbp), %rdx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movss 0x7eeb6(%rip), %xmm0    # 0x1727dc
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x348(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x1e0(%rbp), %rdi
callq 0xbf4c0
movss 0x7d2d7(%rip), %xmm0    # 0x170c3c
addss -0x8c(%rbp), %xmm0
movss 0x7d2c7(%rip), %xmm1    # 0x170c3c
addss -0x90(%rbp), %xmm1
leaq -0x1e8(%rbp), %rdi
callq 0xbf4c0
movq -0x348(%rbp), %rdi
movl -0x60(%rbp), %ecx
leaq -0x1e0(%rbp), %rsi
leaq -0x1e8(%rbp), %rdx
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movss 0x11f2b1(%rip), %xmm0   # 0x212c68
addss -0x8c(%rbp), %xmm0
movss %xmm0, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x340(%rbp)
movss -0x8c(%rbp), %xmm0
movss -0x90(%rbp), %xmm1
leaq -0x1f0(%rbp), %rdi
callq 0xbf4c0
movss -0x8c(%rbp), %xmm0
addss 0x11f26a(%rip), %xmm0   # 0x212c68
movss -0x90(%rbp), %xmm1
addss 0x11f25a(%rip), %xmm1   # 0x212c68
leaq -0x1f8(%rbp), %rdi
callq 0xbf4c0
movq -0x340(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
leaq -0x1f8(%rbp), %rdx
movl $0xff000000, %ecx       # imm = 0xFF000000
movl $0xff0000ff, %r8d       # imm = 0xFF0000FF
movl $0xff00ffff, %r9d       # imm = 0xFF00FFFF
movl $0xff00ff00, (%rsp)     # imm = 0xFF00FF00
callq 0x113130
movss 0x7e588(%rip), %xmm0    # 0x171fdc
addss 0x11f20c(%rip), %xmm0   # 0x212c68
movss 0x84b38(%rip), %xmm1    # 0x17859c
mulss %xmm1, %xmm0
movss 0x7e56c(%rip), %xmm1    # 0x171fdc
addss 0x11f1f0(%rip), %xmm1   # 0x212c68
movss 0x7e540(%rip), %xmm2    # 0x171fc0
mulss %xmm2, %xmm1
leaq -0x200(%rbp), %rdi
callq 0xbf4c0
leaq -0x200(%rbp), %rdi
callq 0x13d8d0
callq 0xdcd30
callq 0x158140
leaq 0x8fafd(%rip), %rdi     # 0x1835aa
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1573a0
testb $0x1, %al
jne 0xf3ac1
jmp 0xf4308
cmpb $0x0, 0x1209b8(%rip)    # 0x214480
jne 0xf3b0f
leaq 0x1209af(%rip), %rdi    # 0x214480
callq 0xd380
cmpl $0x0, %eax
je 0xf3b0f
leaq 0x12098e(%rip), %rdi    # 0x214470
callq 0xecea0
jmp 0xf3ae9
leaq -0x6bc0(%rip), %rdi     # 0xecf30
leaq 0x120979(%rip), %rsi    # 0x214470
leaq 0x11aaba(%rip), %rdx    # 0x20e5b8
callq 0xd820
leaq 0x120976(%rip), %rdi    # 0x214480
callq 0xd580
cmpb $0x0, 0x12097a(%rip)    # 0x214490
jne 0xf3b49
leaq 0x120971(%rip), %rdi    # 0x214490
callq 0xd380
cmpl $0x0, %eax
je 0xf3b49
leaq 0x120958(%rip), %rdi    # 0x214488
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xbf4c0
jmp 0xf3b3d
leaq 0x12094c(%rip), %rdi    # 0x214490
callq 0xd580
leaq 0x8fa61(%rip), %rdi     # 0x1835b1
leaq 0x11f125(%rip), %rsi    # 0x212c7c
callq 0x13c7c0
leaq 0x8fa5a(%rip), %rdi     # 0x1835bd
leaq 0x11f113(%rip), %rsi    # 0x212c7d
callq 0x13c7c0
leaq 0x8fa5b(%rip), %rdi     # 0x1835d1
xorl %eax, %eax
callq 0x139160
callq 0xdc6c0
movlpd %xmm0, -0x208(%rbp)
callq 0xd5b40
movlpd %xmm0, -0x210(%rbp)
movss 0x84a01(%rip), %xmm0    # 0x1785a0
ucomiss -0x210(%rbp), %xmm0
jbe 0xf3bf4
movss 0x849f0(%rip), %xmm0    # 0x1785a0
movss %xmm0, -0x210(%rbp)
jmp 0xf3bf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq 0x1208b3(%rip), %rdi    # 0x214480
callq 0xd460
jmp 0xf448c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq 0x1208a6(%rip), %rdi    # 0x214490
callq 0xd460
jmp 0xf448c
movss 0x849a4(%rip), %xmm0    # 0x1785a0
ucomiss -0x20c(%rbp), %xmm0
jbe 0xf3c15
movss 0x84993(%rip), %xmm0    # 0x1785a0
movss %xmm0, -0x20c(%rbp)
movss -0x208(%rbp), %xmm0
addss -0x210(%rbp), %xmm0
movss -0x204(%rbp), %xmm1
addss -0x20c(%rbp), %xmm1
leaq -0x218(%rbp), %rdi
callq 0xbf4c0
callq 0xcb1a0
movq %rax, -0x220(%rbp)
callq 0xdae40
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rdi
leaq -0x208(%rbp), %rsi
leaq -0x218(%rbp), %rdx
movl $0xff323232, %ecx       # imm = 0xFF323232
xorps %xmm0, %xmm0
movl $0xf, %r8d
callq 0x113090
movq -0x228(%rbp), %rdi
leaq -0x208(%rbp), %rsi
leaq -0x218(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movl $0xf, %r8d
movss 0x7cf90(%rip), %xmm1    # 0x170c3c
callq 0x112ef0
leaq 0x8f96d(%rip), %rdi     # 0x183625
leaq -0x210(%rbp), %rsi
movl $0x3, %edx
callq 0x13a9f0
xorl %edi, %edi
callq 0xca1c0
andb $0x1, %al
movb %al, -0x229(%rbp)
callq 0xd53c0
andb $0x1, %al
movb %al, -0x22a(%rbp)
movss -0x208(%rbp), %xmm0
addss 0x120793(%rip), %xmm0   # 0x214488
movss -0x204(%rbp), %xmm1
addss 0x120787(%rip), %xmm1   # 0x21448c
leaq -0x234(%rbp), %rdi
callq 0xbf4c0
movq -0x220(%rbp), %rax
movss 0x120(%rax), %xmm0
subss -0x234(%rbp), %xmm0
movq -0x220(%rbp), %rax
movss 0x124(%rax), %xmm1
subss -0x230(%rbp), %xmm1
leaq -0x23c(%rbp), %rdi
callq 0xbf4c0
testb $0x1, -0x229(%rbp)
je 0xf3d99
testb $0x1, 0x12073d(%rip)    # 0x214498
jne 0xf3d99
xorl %esi, %esi
movl %esi, %edi
callq 0xd4d60
testb $0x1, %al
jne 0xf3d6c
jmp 0xf3d99
leaq 0x1206fd(%rip), %rdi    # 0x214470
leaq -0x23c(%rbp), %rsi
callq 0xee5d0
leaq 0x1206ea(%rip), %rdi    # 0x214470
leaq -0x23c(%rbp), %rsi
callq 0xee5d0
movb $0x1, 0x1206ff(%rip)    # 0x214498
testb $0x1, 0x1206f8(%rip)    # 0x214498
je 0xf3dcc
leaq 0x1206c7(%rip), %rdi    # 0x214470
callq 0x10b7d0
movq -0x23c(%rbp), %rcx
movq %rcx, (%rax)
xorl %edi, %edi
callq 0xd4050
testb $0x1, %al
jne 0xf3dca
movb $0x0, 0x1206ce(%rip)    # 0x214498
jmp 0xf3dcc
movb 0x11eeab(%rip), %al     # 0x212c7d
movss 0x7e1a6(%rip), %xmm0    # 0x171f80
xorps %xmm1, %xmm1
movss %xmm1, -0x390(%rbp)
testb $0x1, %al
movss %xmm0, -0x38c(%rbp)
jne 0xf3e01
movss -0x390(%rbp), %xmm0
movss %xmm0, -0x38c(%rbp)
movss -0x38c(%rbp), %xmm0
movss %xmm0, -0x240(%rbp)
testb $0x1, -0x22a(%rbp)
je 0xf3e70
movss -0x240(%rbp), %xmm0
movl $0x1, %edi
callq 0xd4fe0
testb $0x1, %al
jne 0xf3e32
jmp 0xf3e70
movq -0x220(%rbp), %rax
movss 0x3b0(%rax), %xmm0
addss 0x12063f(%rip), %xmm0   # 0x214488
movss %xmm0, 0x120637(%rip)   # 0x214488
movq -0x220(%rbp), %rax
movss 0x3b4(%rax), %xmm0
addss 0x120624(%rip), %xmm0   # 0x21448c
movss %xmm0, 0x12061c(%rip)   # 0x21448c
movl $0x1, %edi
movss 0x7e103(%rip), %xmm0    # 0x171f80
callq 0xd5160
movlpd %xmm0, -0x248(%rbp)
testb $0x1, 0x11edec(%rip)    # 0x212c7d
je 0xf3ed8
movl $0x1, %edi
callq 0xd4e60
testb $0x1, %al
jne 0xf3ea3
jmp 0xf3ed8
movss -0x248(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xf3ed8
jp 0xf3ed8
movss -0x244(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xf3ed8
jp 0xf3ed8
leaq 0x813d9(%rip), %rdi     # 0x1752a7
movl $0x1, %esi
callq 0xde7f0
leaq 0x813c8(%rip), %rdi     # 0x1752a7
xorl %esi, %esi
callq 0xde5f0
testb $0x1, %al
jne 0xf3eef
jmp 0xf3f9e
testb $0x1, 0x1205a2(%rip)    # 0x214498
je 0xf3f15
leaq 0x120571(%rip), %rdi    # 0x214470
callq 0x10b880
movl %eax, %esi
subl $0x2, %esi
leaq 0x120560(%rip), %rdi    # 0x214470
callq 0x10b830
movb $0x0, 0x12057c(%rip)    # 0x214498
cmpl $0x0, 0x12054d(%rip)    # 0x214470
setg %al
xorl %ecx, %ecx
xorl %ecx, %ecx
movzbl %al, %ecx
andl $0x1, %ecx
leaq 0x8f6f5(%rip), %rdi     # 0x18362c
xorl %edx, %edx
movl %edx, %esi
callq 0x155360
testb $0x1, %al
jne 0xf3f46
jmp 0xf3f63
leaq 0x120523(%rip), %rdi    # 0x214470
callq 0x10b880
movl %eax, %esi
subl $0x2, %esi
leaq 0x120512(%rip), %rdi    # 0x214470
callq 0x10b830
cmpl $0x0, 0x120506(%rip)    # 0x214470
setg %al
xorl %ecx, %ecx
xorl %ecx, %ecx
movzbl %al, %ecx
andl $0x1, %ecx
leaq 0x8f6b9(%rip), %rdi     # 0x183637
xorl %edx, %edx
movl %edx, %esi
callq 0x155360
testb $0x1, %al
jne 0xf3f8d
jmp 0xf3f99
leaq 0x1204dc(%rip), %rdi    # 0x214470
callq 0x10b890
callq 0xde4e0
movq -0x228(%rbp), %rdi
movq -0x208(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x258(%rbp)
movsd -0x250(%rbp), %xmm0
movsd -0x258(%rbp), %xmm1
movl $0x1, %esi
callq 0x10f4f0
testb $0x1, 0x11ec9a(%rip)    # 0x212c7c
je 0xf419a
movss 0x845b4(%rip), %xmm0    # 0x1785a4
movss %xmm0, -0x25c(%rbp)
movss 0x120488(%rip), %xmm0   # 0x214488
movss 0x8459c(%rip), %xmm1    # 0x1785a4
callq 0xdb30
movss %xmm0, -0x260(%rbp)
movss -0x260(%rbp), %xmm1
movss -0x210(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xf40c8
movq -0x228(%rbp), %rax
movq %rax, -0x398(%rbp)
movss -0x208(%rbp), %xmm0
addss -0x260(%rbp), %xmm0
movss -0x204(%rbp), %xmm1
leaq -0x268(%rbp), %rdi
callq 0xbf4c0
movss -0x208(%rbp), %xmm0
addss -0x260(%rbp), %xmm0
movss -0x214(%rbp), %xmm1
leaq -0x270(%rbp), %rdi
callq 0xbf4c0
movq -0x398(%rbp), %rdi
leaq -0x268(%rbp), %rsi
leaq -0x270(%rbp), %rdx
movl $0x28c8c8c8, %ecx       # imm = 0x28C8C8C8
movss 0x7cb96(%rip), %xmm0    # 0x170c3c
callq 0x112e20
movss 0x844f1(%rip), %xmm0    # 0x1785a4
addss -0x260(%rbp), %xmm0
movss %xmm0, -0x260(%rbp)
jmp 0xf4015
movss 0x1203bc(%rip), %xmm0   # 0x21448c
movss 0x844cc(%rip), %xmm1    # 0x1785a4
callq 0xdb30
movss %xmm0, -0x274(%rbp)
movss -0x274(%rbp), %xmm1
movss -0x20c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xf4198
movq -0x228(%rbp), %rax
movq %rax, -0x3a0(%rbp)
movss -0x208(%rbp), %xmm0
movss -0x204(%rbp), %xmm1
addss -0x274(%rbp), %xmm1
leaq -0x27c(%rbp), %rdi
callq 0xbf4c0
movss -0x218(%rbp), %xmm0
movss -0x204(%rbp), %xmm1
addss -0x274(%rbp), %xmm1
leaq -0x284(%rbp), %rdi
callq 0xbf4c0
movq -0x3a0(%rbp), %rdi
leaq -0x27c(%rbp), %rsi
leaq -0x284(%rbp), %rdx
movl $0x28c8c8c8, %ecx       # imm = 0x28C8C8C8
movss 0x7cac6(%rip), %xmm0    # 0x170c3c
callq 0x112e20
movss 0x84421(%rip), %xmm0    # 0x1785a4
addss -0x274(%rbp), %xmm0
movss %xmm0, -0x274(%rbp)
jmp 0xf40e5
jmp 0xf419a
movl $0x0, -0x288(%rbp)
movl -0x288(%rbp), %eax
cmpl 0x1202c0(%rip), %eax    # 0x214470
jge 0xf42f7
movq -0x228(%rbp), %rax
movq %rax, -0x3a8(%rbp)
movss -0x234(%rbp), %xmm0
movss %xmm0, -0x3c0(%rbp)
movl -0x288(%rbp), %esi
leaq 0x12028f(%rip), %rdi    # 0x214470
callq 0x10b8e0
movss -0x3c0(%rbp), %xmm0
addss (%rax), %xmm0
movss %xmm0, -0x3b8(%rbp)
movss -0x230(%rbp), %xmm0
movss %xmm0, -0x3bc(%rbp)
movl -0x288(%rbp), %esi
leaq 0x120259(%rip), %rdi    # 0x214470
callq 0x10b8e0
movss -0x3bc(%rbp), %xmm1
movss -0x3b8(%rbp), %xmm0
addss 0x4(%rax), %xmm1
leaq -0x290(%rbp), %rdi
callq 0xbf4c0
movss -0x234(%rbp), %xmm0
movss %xmm0, -0x3b4(%rbp)
movl -0x288(%rbp), %esi
addl $0x1, %esi
leaq 0x120213(%rip), %rdi    # 0x214470
callq 0x10b8e0
movss -0x3b4(%rbp), %xmm0
addss (%rax), %xmm0
movss %xmm0, -0x3ac(%rbp)
movss -0x230(%rbp), %xmm0
movss %xmm0, -0x3b0(%rbp)
movl -0x288(%rbp), %esi
addl $0x1, %esi
leaq 0x1201da(%rip), %rdi    # 0x214470
callq 0x10b8e0
movss -0x3b0(%rbp), %xmm1
movss -0x3ac(%rbp), %xmm0
addss 0x4(%rax), %xmm1
leaq -0x298(%rbp), %rdi
callq 0xbf4c0
movq -0x3a8(%rbp), %rdi
leaq -0x290(%rbp), %rsi
leaq -0x298(%rbp), %rdx
movl $0xff00ffff, %ecx       # imm = 0xFF00FFFF
movss 0x7dcee(%rip), %xmm0    # 0x171fcc
callq 0x112e20
movl -0x288(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x288(%rbp)
jmp 0xf41a4
movq -0x228(%rbp), %rdi
callq 0x10f6c0
callq 0x158140
leaq 0x8f333(%rip), %rdi     # 0x183642
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1573a0
testb $0x1, %al
jne 0xf4323
jmp 0xf4479
leaq 0x8f329(%rip), %rdi     # 0x183653
leaq 0x11e94d(%rip), %rsi    # 0x212c7e
callq 0x13c7c0
xorps %xmm0, %xmm0
movss %xmm0, -0x3c8(%rbp)
movss 0x7dc37(%rip), %xmm1    # 0x171f80
movss %xmm1, -0x3c4(%rbp)
callq 0xdc1c0
leaq 0x8f313(%rip), %rdi     # 0x183670
callq 0xf6290
leaq 0x8f351(%rip), %rdi     # 0x1836ba
leaq 0x11e90f(%rip), %rsi    # 0x212c7f
callq 0x13c7c0
movss -0x3c8(%rbp), %xmm0
movss -0x3c4(%rbp), %xmm1
callq 0xdc1c0
leaq 0x8f346(%rip), %rdi     # 0x1836d7
callq 0xf6290
callq 0xda780
movlpd %xmm0, -0x2a0(%rbp)
callq 0xda8a0
movlpd %xmm0, -0x2a8(%rbp)
movss -0x2a0(%rbp), %xmm1
movss -0x2a8(%rbp), %xmm0
movss 0x7dc10(%rip), %xmm2    # 0x171fd8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss -0x29c(%rbp), %xmm2
movss -0x2a4(%rbp), %xmm1
movss 0x7dbf0(%rip), %xmm3    # 0x171fd8
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
leaq -0x2b0(%rbp), %rdi
callq 0xbf4c0
testb $0x1, 0x11e87b(%rip)    # 0x212c7e
je 0xf4438
callq 0xcb280
movq %rax, %rdi
movss 0x7db93(%rip), %xmm0    # 0x171fa8
mulss -0x2a8(%rbp), %xmm0
leaq -0x2b0(%rbp), %rsi
movl $0xc80000ff, %edx       # imm = 0xC80000FF
xorl %ecx, %ecx
movss 0x7e309(%rip), %xmm1    # 0x17273c
callq 0x113490
testb $0x1, 0x11e840(%rip)    # 0x212c7f
je 0xf4474
callq 0xca6c0
movq %rax, %rdi
movss 0x7db57(%rip), %xmm0    # 0x171fa8
mulss -0x2a4(%rbp), %xmm0
leaq -0x2b0(%rbp), %rsi
movl $0xc800ff00, %edx       # imm = 0xC800FF00
xorl %ecx, %ecx
movss 0x7db6d(%rip), %xmm1    # 0x171fdc
callq 0x113490
callq 0x158140
callq 0x155dd0
callq 0xd3b60
addq $0x3d0, %rsp            # imm = 0x3D0
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xd620
nopw %cs:(%rax,%rax)