// File: Ciaxur[P]yagb-emu/include/imgui/imgui_draw.cpp
// Function: ImDrawList::AddPolyline(ImVec2 const*, int, unsigned int, bool, float)
void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, bool closed, float thickness)
{
    if (points_count < 2)
        return;

    const ImVec2 opaque_uv = _Data->TexUvWhitePixel;
    const int count = closed ? points_count : points_count - 1; // The number of line segments we need to draw
    const bool thick_line = (thickness > _FringeScale);

    if (Flags & ImDrawListFlags_AntiAliasedLines)
    {
        // Anti-aliased stroke
        const float AA_SIZE = _FringeScale;
        const ImU32 col_trans = col & ~IM_COL32_A_MASK;

        // Thicknesses <1.0 should behave like thickness 1.0
        thickness = ImMax(thickness, 1.0f);
        const int integer_thickness = (int)thickness;
        const float fractional_thickness = thickness - integer_thickness;

        // Do we want to draw this line using a texture?
        // - For now, only draw integer-width lines using textures to avoid issues with the way scaling occurs, could be improved.
        // - If AA_SIZE is not 1.0f we cannot use the texture path.
        const bool use_texture = (Flags & ImDrawListFlags_AntiAliasedLinesUseTex) && (integer_thickness < IM_DRAWLIST_TEX_LINES_WIDTH_MAX) && (fractional_thickness <= 0.00001f) && (AA_SIZE == 1.0f);

        // We should never hit this, because NewFrame() doesn't set ImDrawListFlags_AntiAliasedLinesUseTex unless ImFontAtlasFlags_NoBakedLines is off
        IM_ASSERT_PARANOID(!use_texture || !(_Data->Font->ContainerAtlas->Flags & ImFontAtlasFlags_NoBakedLines));

        const int idx_count = use_texture ? (count * 6) : (thick_line ? count * 18 : count * 12);
        const int vtx_count = use_texture ? (points_count * 2) : (thick_line ? points_count * 4 : points_count * 3);
        PrimReserve(idx_count, vtx_count);

        // Temporary buffer
        // The first <points_count> items are normals at each line point, then after that there are either 2 or 4 temp points for each line point
        ImVec2* temp_normals = (ImVec2*)alloca(points_count * ((use_texture || !thick_line) ? 3 : 5) * sizeof(ImVec2)); //-V630
        ImVec2* temp_points = temp_normals + points_count;

        // Calculate normals (tangents) for each line segment
        for (int i1 = 0; i1 < count; i1++)
        {
            const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;
            float dx = points[i2].x - points[i1].x;
            float dy = points[i2].y - points[i1].y;
            IM_NORMALIZE2F_OVER_ZERO(dx, dy);
            temp_normals[i1].x = dy;
            temp_normals[i1].y = -dx;
        }
        if (!closed)
            temp_normals[points_count - 1] = temp_normals[points_count - 2];

        // If we are drawing a one-pixel-wide line without a texture, or a textured line of any width, we only need 2 or 3 vertices per point
        if (use_texture || !thick_line)
        {
            // [PATH 1] Texture-based lines (thick or non-thick)
            // [PATH 2] Non texture-based lines (non-thick)

            // The width of the geometry we need to draw - this is essentially <thickness> pixels for the line itself, plus "one pixel" for AA.
            // - In the texture-based path, we don't use AA_SIZE here because the +1 is tied to the generated texture
            //   (see ImFontAtlasBuildRenderLinesTexData() function), and so alternate values won't work without changes to that code.
            // - In the non texture-based paths, we would allow AA_SIZE to potentially be != 1.0f with a patch (e.g. fringe_scale patch to
            //   allow scaling geometry while preserving one-screen-pixel AA fringe).
            const float half_draw_size = use_texture ? ((thickness * 0.5f) + 1) : AA_SIZE;

            // If line is not closed, the first and last points need to be generated differently as there are no normals to blend
            if (!closed)
            {
                temp_points[0] = points[0] + temp_normals[0] * half_draw_size;
                temp_points[1] = points[0] - temp_normals[0] * half_draw_size;
                temp_points[(points_count-1)*2+0] = points[points_count-1] + temp_normals[points_count-1] * half_draw_size;
                temp_points[(points_count-1)*2+1] = points[points_count-1] - temp_normals[points_count-1] * half_draw_size;
            }

            // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges
            // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)
            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
            unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment
            for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment
            {
                const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1; // i2 is the second point of the line segment
                const unsigned int idx2 = ((i1 + 1) == points_count) ? _VtxCurrentIdx : (idx1 + (use_texture ? 2 : 3)); // Vertex index for end of segment

                // Average normals
                float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;
                float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;
                IM_FIXNORMAL2F(dm_x, dm_y);
                dm_x *= half_draw_size; // dm_x, dm_y are offset to the outer edge of the AA area
                dm_y *= half_draw_size;

                // Add temporary vertexes for the outer edges
                ImVec2* out_vtx = &temp_points[i2 * 2];
                out_vtx[0].x = points[i2].x + dm_x;
                out_vtx[0].y = points[i2].y + dm_y;
                out_vtx[1].x = points[i2].x - dm_x;
                out_vtx[1].y = points[i2].y - dm_y;

                if (use_texture)
                {
                    // Add indices for two triangles
                    _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 1); // Right tri
                    _IdxWritePtr[3] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[4] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Left tri
                    _IdxWritePtr += 6;
                }
                else
                {
                    // Add indexes for four triangles
                    _IdxWritePtr[0] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[1] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[2] = (ImDrawIdx)(idx1 + 2); // Right tri 1
                    _IdxWritePtr[3] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[4] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[5] = (ImDrawIdx)(idx2 + 0); // Right tri 2
                    _IdxWritePtr[6] = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[7] = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[8] = (ImDrawIdx)(idx1 + 0); // Left tri 1
                    _IdxWritePtr[9] = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[10] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[11] = (ImDrawIdx)(idx2 + 1); // Left tri 2
                    _IdxWritePtr += 12;
                }

                idx1 = idx2;
            }

            // Add vertexes for each point on the line
            if (use_texture)
            {
                // If we're using textures we only need to emit the left/right edge vertices
                ImVec4 tex_uvs = _Data->TexUvLines[integer_thickness];
                /*if (fractional_thickness != 0.0f) // Currently always zero when use_texture==false!
                {
                    const ImVec4 tex_uvs_1 = _Data->TexUvLines[integer_thickness + 1];
                    tex_uvs.x = tex_uvs.x + (tex_uvs_1.x - tex_uvs.x) * fractional_thickness; // inlined ImLerp()
                    tex_uvs.y = tex_uvs.y + (tex_uvs_1.y - tex_uvs.y) * fractional_thickness;
                    tex_uvs.z = tex_uvs.z + (tex_uvs_1.z - tex_uvs.z) * fractional_thickness;
                    tex_uvs.w = tex_uvs.w + (tex_uvs_1.w - tex_uvs.w) * fractional_thickness;
                }*/
                ImVec2 tex_uv0(tex_uvs.x, tex_uvs.y);
                ImVec2 tex_uv1(tex_uvs.z, tex_uvs.w);
                for (int i = 0; i < points_count; i++)
                {
                    _VtxWritePtr[0].pos = temp_points[i * 2 + 0]; _VtxWritePtr[0].uv = tex_uv0; _VtxWritePtr[0].col = col; // Left-side outer edge
                    _VtxWritePtr[1].pos = temp_points[i * 2 + 1]; _VtxWritePtr[1].uv = tex_uv1; _VtxWritePtr[1].col = col; // Right-side outer edge
                    _VtxWritePtr += 2;
                }
            }
            else
            {
                // If we're not using a texture, we need the center vertex as well
                for (int i = 0; i < points_count; i++)
                {
                    _VtxWritePtr[0].pos = points[i];              _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col;       // Center of line
                    _VtxWritePtr[1].pos = temp_points[i * 2 + 0]; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col_trans; // Left-side outer edge
                    _VtxWritePtr[2].pos = temp_points[i * 2 + 1]; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col_trans; // Right-side outer edge
                    _VtxWritePtr += 3;
                }
            }
        }
        else
        {
            // [PATH 2] Non texture-based lines (thick): we need to draw the solid line core and thus require four vertices per point
            const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f;

            // If line is not closed, the first and last points need to be generated differently as there are no normals to blend
            if (!closed)
            {
                const int points_last = points_count - 1;
                temp_points[0] = points[0] + temp_normals[0] * (half_inner_thickness + AA_SIZE);
                temp_points[1] = points[0] + temp_normals[0] * (half_inner_thickness);
                temp_points[2] = points[0] - temp_normals[0] * (half_inner_thickness);
                temp_points[3] = points[0] - temp_normals[0] * (half_inner_thickness + AA_SIZE);
                temp_points[points_last * 4 + 0] = points[points_last] + temp_normals[points_last] * (half_inner_thickness + AA_SIZE);
                temp_points[points_last * 4 + 1] = points[points_last] + temp_normals[points_last] * (half_inner_thickness);
                temp_points[points_last * 4 + 2] = points[points_last] - temp_normals[points_last] * (half_inner_thickness);
                temp_points[points_last * 4 + 3] = points[points_last] - temp_normals[points_last] * (half_inner_thickness + AA_SIZE);
            }

            // Generate the indices to form a number of triangles for each line segment, and the vertices for the line edges
            // This takes points n and n+1 and writes into n+1, with the first point in a closed line being generated from the final one (as n+1 wraps)
            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
            unsigned int idx1 = _VtxCurrentIdx; // Vertex index for start of line segment
            for (int i1 = 0; i1 < count; i1++) // i1 is the first point of the line segment
            {
                const int i2 = (i1 + 1) == points_count ? 0 : (i1 + 1); // i2 is the second point of the line segment
                const unsigned int idx2 = (i1 + 1) == points_count ? _VtxCurrentIdx : (idx1 + 4); // Vertex index for end of segment

                // Average normals
                float dm_x = (temp_normals[i1].x + temp_normals[i2].x) * 0.5f;
                float dm_y = (temp_normals[i1].y + temp_normals[i2].y) * 0.5f;
                IM_FIXNORMAL2F(dm_x, dm_y);
                float dm_out_x = dm_x * (half_inner_thickness + AA_SIZE);
                float dm_out_y = dm_y * (half_inner_thickness + AA_SIZE);
                float dm_in_x = dm_x * half_inner_thickness;
                float dm_in_y = dm_y * half_inner_thickness;

                // Add temporary vertices
                ImVec2* out_vtx = &temp_points[i2 * 4];
                out_vtx[0].x = points[i2].x + dm_out_x;
                out_vtx[0].y = points[i2].y + dm_out_y;
                out_vtx[1].x = points[i2].x + dm_in_x;
                out_vtx[1].y = points[i2].y + dm_in_y;
                out_vtx[2].x = points[i2].x - dm_in_x;
                out_vtx[2].y = points[i2].y - dm_in_y;
                out_vtx[3].x = points[i2].x - dm_out_x;
                out_vtx[3].y = points[i2].y - dm_out_y;

                // Add indexes
                _IdxWritePtr[0]  = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[1]  = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[2]  = (ImDrawIdx)(idx1 + 2);
                _IdxWritePtr[3]  = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[4]  = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[5]  = (ImDrawIdx)(idx2 + 1);
                _IdxWritePtr[6]  = (ImDrawIdx)(idx2 + 1); _IdxWritePtr[7]  = (ImDrawIdx)(idx1 + 1); _IdxWritePtr[8]  = (ImDrawIdx)(idx1 + 0);
                _IdxWritePtr[9]  = (ImDrawIdx)(idx1 + 0); _IdxWritePtr[10] = (ImDrawIdx)(idx2 + 0); _IdxWritePtr[11] = (ImDrawIdx)(idx2 + 1);
                _IdxWritePtr[12] = (ImDrawIdx)(idx2 + 2); _IdxWritePtr[13] = (ImDrawIdx)(idx1 + 2); _IdxWritePtr[14] = (ImDrawIdx)(idx1 + 3);
                _IdxWritePtr[15] = (ImDrawIdx)(idx1 + 3); _IdxWritePtr[16] = (ImDrawIdx)(idx2 + 3); _IdxWritePtr[17] = (ImDrawIdx)(idx2 + 2);
                _IdxWritePtr += 18;

                idx1 = idx2;
            }

            // Add vertices
            for (int i = 0; i < points_count; i++)
            {
                _VtxWritePtr[0].pos = temp_points[i * 4 + 0]; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col_trans;
                _VtxWritePtr[1].pos = temp_points[i * 4 + 1]; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
                _VtxWritePtr[2].pos = temp_points[i * 4 + 2]; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col;
                _VtxWritePtr[3].pos = temp_points[i * 4 + 3]; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col_trans;
                _VtxWritePtr += 4;
            }
        }
        _VtxCurrentIdx += (ImDrawIdx)vtx_count;
    }
    else
    {
        // [PATH 4] Non texture-based, Non anti-aliased lines
        const int idx_count = count * 6;
        const int vtx_count = count * 4;    // FIXME-OPT: Not sharing edges
        PrimReserve(idx_count, vtx_count);

        for (int i1 = 0; i1 < count; i1++)
        {
            const int i2 = (i1 + 1) == points_count ? 0 : i1 + 1;
            const ImVec2& p1 = points[i1];
            const ImVec2& p2 = points[i2];

            float dx = p2.x - p1.x;
            float dy = p2.y - p1.y;
            IM_NORMALIZE2F_OVER_ZERO(dx, dy);
            dx *= (thickness * 0.5f);
            dy *= (thickness * 0.5f);

            _VtxWritePtr[0].pos.x = p1.x + dy; _VtxWritePtr[0].pos.y = p1.y - dx; _VtxWritePtr[0].uv = opaque_uv; _VtxWritePtr[0].col = col;
            _VtxWritePtr[1].pos.x = p2.x + dy; _VtxWritePtr[1].pos.y = p2.y - dx; _VtxWritePtr[1].uv = opaque_uv; _VtxWritePtr[1].col = col;
            _VtxWritePtr[2].pos.x = p2.x - dy; _VtxWritePtr[2].pos.y = p2.y + dx; _VtxWritePtr[2].uv = opaque_uv; _VtxWritePtr[2].col = col;
            _VtxWritePtr[3].pos.x = p1.x - dy; _VtxWritePtr[3].pos.y = p1.y + dx; _VtxWritePtr[3].uv = opaque_uv; _VtxWritePtr[3].col = col;
            _VtxWritePtr += 4;

            _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx + 1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx + 2);
            _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx + 2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx + 3);
            _IdxWritePtr += 6;
            _VtxCurrentIdx += 4;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x210(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x10fe0c
jmp 0x111665
movq -0x210(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0x10fe2f
movl -0x14(%rbp), %eax
movl %eax, -0x214(%rbp)
jmp 0x10fe3b
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x214(%rbp)
movq -0x210(%rbp), %rax
movl -0x214(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movss -0x20(%rbp), %xmm0
ucomiss 0xc0(%rax), %xmm0
seta %cl
andb $0x1, %cl
movb %cl, -0x2d(%rbp)
movl 0x30(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1112d3
movq -0x210(%rbp), %rax
movss 0xc0(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movl -0x18(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x38(%rbp)
movss -0x20(%rbp), %xmm0
movss 0x60da1(%rip), %xmm1    # 0x170c3c
callq 0x10f610
movq -0x210(%rbp), %rax
movss %xmm0, -0x20(%rbp)
cvttss2si -0x20(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movss -0x20(%rbp), %xmm0
cvtsi2ssl -0x3c(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movl 0x30(%rax), %ecx
andl $0x2, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x215(%rbp)
je 0x10ff1c
xorl %eax, %eax
cmpl $0x3f, -0x3c(%rbp)
movb %al, -0x215(%rbp)
jge 0x10ff1c
xorl %eax, %eax
movss 0x62892(%rip), %xmm0    # 0x172784
ucomiss -0x40(%rbp), %xmm0
movb %al, -0x215(%rbp)
jb 0x10ff1c
movss -0x34(%rbp), %xmm0
movss 0x60d31(%rip), %xmm1    # 0x170c3c
ucomiss %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x215(%rbp)
movb -0x215(%rbp), %al
andb $0x1, %al
movb %al, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
je 0x10ff39
imull $0x6, -0x2c(%rbp), %eax
movl %eax, -0x21c(%rbp)
jmp 0x10ff61
testb $0x1, -0x2d(%rbp)
je 0x10ff4b
imull $0x12, -0x2c(%rbp), %eax
movl %eax, -0x220(%rbp)
jmp 0x10ff55
imull $0xc, -0x2c(%rbp), %eax
movl %eax, -0x220(%rbp)
movl -0x220(%rbp), %eax
movl %eax, -0x21c(%rbp)
movl -0x21c(%rbp), %eax
movl %eax, -0x48(%rbp)
testb $0x1, -0x41(%rbp)
je 0x10ff7d
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x224(%rbp)
jmp 0x10ffa7
testb $0x1, -0x2d(%rbp)
je 0x10ff91
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x228(%rbp)
jmp 0x10ff9b
imull $0x3, -0x14(%rbp), %eax
movl %eax, -0x228(%rbp)
movl -0x228(%rbp), %eax
movl %eax, -0x224(%rbp)
movq -0x210(%rbp), %rdi
movl -0x224(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x48(%rbp), %esi
movl -0x4c(%rbp), %edx
callq 0x10f7f0
movl -0x14(%rbp), %eax
movl %eax, -0x230(%rbp)
movb $0x1, %al
testb $0x1, -0x41(%rbp)
movb %al, -0x229(%rbp)
jne 0x10ffe4
movb -0x2d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x229(%rbp)
movl -0x230(%rbp), %eax
movb -0x229(%rbp), %cl
notb %cl
movzbl %cl, %edx
andl $0x1, %edx
movl %edx, %ecx
leal 0x3(%rcx,%rcx), %ecx
imull %ecx, %eax
cltq
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x110158
movl -0x64(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x110057
xorl %eax, %eax
movl %eax, -0x234(%rbp)
jmp 0x110063
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x234(%rbp)
movl -0x234(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movslq -0x68(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
subss (%rax,%rcx,8), %xmm0
movss %xmm0, -0x6c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x68(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
subss 0x4(%rax,%rcx,8), %xmm0
movss %xmm0, -0x70(%rbp)
movss -0x6c(%rbp), %xmm0
movss -0x6c(%rbp), %xmm2
movss -0x70(%rbp), %xmm1
mulss -0x70(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x74(%rbp)
movss -0x74(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x110116
movss -0x74(%rbp), %xmm0
callq 0xd960
movaps %xmm0, %xmm1
movss 0x60b4d(%rip), %xmm0    # 0x170c3c
divss %xmm1, %xmm0
movss %xmm0, -0x78(%rbp)
movss -0x78(%rbp), %xmm0
mulss -0x6c(%rbp), %xmm0
movss %xmm0, -0x6c(%rbp)
movss -0x78(%rbp), %xmm0
mulss -0x70(%rbp), %xmm0
movss %xmm0, -0x70(%rbp)
jmp 0x110118
movss -0x70(%rbp), %xmm0
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
movss %xmm0, (%rax,%rcx,8)
movss -0x6c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
movss %xmm0, 0x4(%rax,%rcx,8)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x110036
testb $0x1, -0x19(%rbp)
jne 0x110180
movq -0x58(%rbp), %rdx
movl -0x14(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rsi
movq -0x58(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
testb $0x1, -0x41(%rbp)
jne 0x110190
testb $0x1, -0x2d(%rbp)
jne 0x110988
testb $0x1, -0x41(%rbp)
je 0x1101bd
movss -0x20(%rbp), %xmm0
movss 0x61e35(%rip), %xmm1    # 0x171fd8
mulss %xmm1, %xmm0
movss 0x60a8d(%rip), %xmm1    # 0x170c3c
addss %xmm1, %xmm0
movss %xmm0, -0x238(%rbp)
jmp 0x1101ca
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x238(%rbp)
movss -0x238(%rbp), %xmm0
movss %xmm0, -0x7c(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x110346
movq -0x10(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x58(%rbp), %rdi
movss -0x7c(%rbp), %xmm0
callq 0x1116c0
movq -0x258(%rbp), %rdi
movlpd %xmm0, -0x8c(%rbp)
leaq -0x8c(%rbp), %rsi
callq 0x111670
movlpd %xmm0, -0x84(%rbp)
movq -0x60(%rbp), %rax
movq -0x84(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x58(%rbp), %rdi
movss -0x7c(%rbp), %xmm0
callq 0x1116c0
movq -0x250(%rbp), %rdi
movlpd %xmm0, -0x9c(%rbp)
leaq -0x9c(%rbp), %rsi
callq 0x111700
movlpd %xmm0, -0x94(%rbp)
movq -0x60(%rbp), %rax
movq -0x94(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
decl %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x248(%rbp)
movq -0x58(%rbp), %rax
leaq (%rax,%rcx,8), %rdi
movss -0x7c(%rbp), %xmm0
callq 0x1116c0
movq -0x248(%rbp), %rdi
movlpd %xmm0, -0xac(%rbp)
leaq -0xac(%rbp), %rsi
callq 0x111670
movlpd %xmm0, -0xa4(%rbp)
movq -0x60(%rbp), %rax
movl -0x14(%rbp), %edx
movl %edx, %ecx
leal -0x2(%rcx,%rcx), %ecx
movslq %ecx, %rcx
movq -0xa4(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
decl %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x240(%rbp)
movq -0x58(%rbp), %rax
leaq (%rax,%rcx,8), %rdi
movss -0x7c(%rbp), %xmm0
callq 0x1116c0
movq -0x240(%rbp), %rdi
movlpd %xmm0, -0xbc(%rbp)
leaq -0xbc(%rbp), %rsi
callq 0x111700
movlpd %xmm0, -0xb4(%rbp)
movq -0x60(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq -0xb4(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x210(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0xc0(%rbp)
movl $0x0, -0xc4(%rbp)
movl -0xc4(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x110787
movl -0xc4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x110387
xorl %eax, %eax
movl %eax, -0x25c(%rbp)
jmp 0x110396
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x25c(%rbp)
movl -0x25c(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xc4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x1103c2
movq -0x210(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x260(%rbp)
jmp 0x1103e5
movl -0xc0(%rbp), %eax
movb -0x41(%rbp), %sil
movl $0x3, %ecx
movl $0x2, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
addl %ecx, %eax
movl %eax, -0x260(%rbp)
movl -0x260(%rbp), %eax
movl %eax, -0xcc(%rbp)
movq -0x58(%rbp), %rax
movslq -0xc4(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
movq -0x58(%rbp), %rax
movslq -0xc8(%rbp), %rcx
addss (%rax,%rcx,8), %xmm0
movss 0x61bbf(%rip), %xmm1    # 0x171fd8
mulss %xmm1, %xmm0
movss %xmm0, -0xd0(%rbp)
movq -0x58(%rbp), %rax
movslq -0xc4(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm0
movq -0x58(%rbp), %rax
movslq -0xc8(%rbp), %rcx
addss 0x4(%rax,%rcx,8), %xmm0
movss 0x61b89(%rip), %xmm1    # 0x171fd8
mulss %xmm1, %xmm0
movss %xmm0, -0xd4(%rbp)
movss -0xd0(%rbp), %xmm0
movss -0xd0(%rbp), %xmm2
movss -0xd4(%rbp), %xmm1
mulss -0xd4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xd8(%rbp)
movss 0x61b45(%rip), %xmm0    # 0x171fd8
ucomiss -0xd8(%rbp), %xmm0
jbe 0x1104ac
movss 0x61b34(%rip), %xmm0    # 0x171fd8
movss %xmm0, -0xd8(%rbp)
movss 0x60788(%rip), %xmm0    # 0x170c3c
divss -0xd8(%rbp), %xmm0
movss %xmm0, -0xdc(%rbp)
movss -0xdc(%rbp), %xmm0
mulss -0xd0(%rbp), %xmm0
movss %xmm0, -0xd0(%rbp)
movss -0xdc(%rbp), %xmm0
mulss -0xd4(%rbp), %xmm0
movss %xmm0, -0xd4(%rbp)
movss -0x7c(%rbp), %xmm0
mulss -0xd0(%rbp), %xmm0
movss %xmm0, -0xd0(%rbp)
movss -0x7c(%rbp), %xmm0
mulss -0xd4(%rbp), %xmm0
movss %xmm0, -0xd4(%rbp)
movq -0x60(%rbp), %rax
movl -0xc8(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movslq -0xc8(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
addss -0xd0(%rbp), %xmm0
movq -0xe8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movslq -0xc8(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm0
addss -0xd4(%rbp), %xmm0
movq -0xe8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movslq -0xc8(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
subss -0xd0(%rbp), %xmm0
movq -0xe8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0xc8(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm0
subss -0xd4(%rbp), %xmm0
movq -0xe8(%rbp), %rax
movss %xmm0, 0xc(%rax)
testb $0x1, -0x41(%rbp)
je 0x110665
movq -0x210(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, (%rcx)
movl -0xc0(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x2(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x4(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x6(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x8(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xa(%rcx)
movq 0x50(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x50(%rax)
jmp 0x110767
movq -0x210(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, (%rcx)
movl -0xc0(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x2(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x4(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x6(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x8(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xa(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xc(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xe(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x10(%rcx)
movl -0xc0(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x12(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x14(%rcx)
movl -0xcc(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x16(%rcx)
movq 0x50(%rax), %rcx
addq $0x18, %rcx
movq %rcx, 0x50(%rax)
movl -0xcc(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x110360
testb $0x1, -0x41(%rbp)
je 0x1108ad
movq -0x210(%rbp), %rax
movq 0x38(%rax), %rax
movq 0xd0(%rax), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0xf8(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0xf0(%rbp)
movss -0xf8(%rbp), %xmm0
movss -0xf4(%rbp), %xmm1
leaq -0x100(%rbp), %rdi
callq 0xbf4c0
movss -0xf0(%rbp), %xmm0
movss -0xec(%rbp), %xmm1
leaq -0x108(%rbp), %rdi
callq 0xbf4c0
movl $0x0, -0x10c(%rbp)
movl -0x10c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1108a8
movq -0x210(%rbp), %rax
movq -0x60(%rbp), %rdx
movl -0x10c(%rbp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rcx)
movq 0x48(%rax), %rcx
movq -0x100(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x10(%rcx)
movq -0x60(%rbp), %rdx
movl -0x10c(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x14(%rcx)
movq 0x48(%rax), %rcx
movq -0x108(%rbp), %rdx
movq %rdx, 0x1c(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x24(%rcx)
movq 0x48(%rax), %rcx
addq $0x28, %rcx
movq %rcx, 0x48(%rax)
movl -0x10c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10c(%rbp)
jmp 0x110805
jmp 0x110983
movl $0x0, -0x110(%rbp)
movl -0x110(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x110981
movq -0x210(%rbp), %rax
movq -0x10(%rbp), %rdx
movslq -0x110(%rbp), %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x10(%rcx)
movq -0x60(%rbp), %rdx
movl -0x110(%rbp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x14(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x1c(%rcx)
movl -0x38(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x24(%rcx)
movq -0x60(%rbp), %rdx
movl -0x110(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x28(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x30(%rcx)
movl -0x38(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x38(%rcx)
movq 0x48(%rax), %rcx
addq $0x3c, %rcx
movq %rcx, 0x48(%rax)
movl -0x110(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x110(%rbp)
jmp 0x1108b7
jmp 0x110983
jmp 0x1112bb
movss -0x20(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movss 0x6163e(%rip), %xmm1    # 0x171fd8
mulss %xmm1, %xmm0
movss %xmm0, -0x114(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x110cbf
movl -0x14(%rbp), %eax
decl %eax
movl %eax, -0x118(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movq -0x58(%rbp), %rdi
movss -0x114(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
addss %xmm1, %xmm0
callq 0x1116c0
movq -0x2a0(%rbp), %rdi
movlpd %xmm0, -0x128(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x111670
movlpd %xmm0, -0x120(%rbp)
movq -0x60(%rbp), %rax
movq -0x120(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x298(%rbp)
movq -0x58(%rbp), %rdi
movss -0x114(%rbp), %xmm0
callq 0x1116c0
movq -0x298(%rbp), %rdi
movlpd %xmm0, -0x138(%rbp)
leaq -0x138(%rbp), %rsi
callq 0x111670
movlpd %xmm0, -0x130(%rbp)
movq -0x60(%rbp), %rax
movq -0x130(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x58(%rbp), %rdi
movss -0x114(%rbp), %xmm0
callq 0x1116c0
movq -0x290(%rbp), %rdi
movlpd %xmm0, -0x148(%rbp)
leaq -0x148(%rbp), %rsi
callq 0x111700
movlpd %xmm0, -0x140(%rbp)
movq -0x60(%rbp), %rax
movq -0x140(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x288(%rbp)
movq -0x58(%rbp), %rdi
movss -0x114(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
addss %xmm1, %xmm0
callq 0x1116c0
movq -0x288(%rbp), %rdi
movlpd %xmm0, -0x158(%rbp)
leaq -0x158(%rbp), %rsi
callq 0x111700
movlpd %xmm0, -0x150(%rbp)
movq -0x60(%rbp), %rax
movq -0x150(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movslq -0x118(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x280(%rbp)
movq -0x58(%rbp), %rax
leaq (%rax,%rcx,8), %rdi
movss -0x114(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
addss %xmm1, %xmm0
callq 0x1116c0
movq -0x280(%rbp), %rdi
movlpd %xmm0, -0x168(%rbp)
leaq -0x168(%rbp), %rsi
callq 0x111670
movlpd %xmm0, -0x160(%rbp)
movq -0x60(%rbp), %rax
movl -0x118(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movq -0x160(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x118(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x278(%rbp)
movq -0x58(%rbp), %rax
leaq (%rax,%rcx,8), %rdi
movss -0x114(%rbp), %xmm0
callq 0x1116c0
movq -0x278(%rbp), %rdi
movlpd %xmm0, -0x178(%rbp)
leaq -0x178(%rbp), %rsi
callq 0x111670
movlpd %xmm0, -0x170(%rbp)
movq -0x60(%rbp), %rax
movl -0x118(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movq -0x170(%rbp), %rdx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x118(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x270(%rbp)
movq -0x58(%rbp), %rax
leaq (%rax,%rcx,8), %rdi
movss -0x114(%rbp), %xmm0
callq 0x1116c0
movq -0x270(%rbp), %rdi
movlpd %xmm0, -0x188(%rbp)
leaq -0x188(%rbp), %rsi
callq 0x111700
movlpd %xmm0, -0x180(%rbp)
movq -0x60(%rbp), %rax
movl -0x118(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movq -0x180(%rbp), %rdx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x118(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x268(%rbp)
movq -0x58(%rbp), %rax
leaq (%rax,%rcx,8), %rdi
movss -0x114(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
addss %xmm1, %xmm0
callq 0x1116c0
movq -0x268(%rbp), %rdi
movlpd %xmm0, -0x198(%rbp)
leaq -0x198(%rbp), %rsi
callq 0x111700
movlpd %xmm0, -0x190(%rbp)
movq -0x60(%rbp), %rax
movl -0x118(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq -0x190(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x210(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x19c(%rbp)
movl $0x0, -0x1a0(%rbp)
movl -0x1a0(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x1111a6
movl -0x1a0(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x110d00
xorl %eax, %eax
movl %eax, -0x2a4(%rbp)
jmp 0x110d0f
movl -0x1a0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2a4(%rbp)
movl -0x2a4(%rbp), %eax
movl %eax, -0x1a4(%rbp)
movl -0x1a0(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x110d3b
movq -0x210(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x2a8(%rbp)
jmp 0x110d4a
movl -0x19c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x2a8(%rbp)
movl -0x2a8(%rbp), %eax
movl %eax, -0x1a8(%rbp)
movq -0x58(%rbp), %rax
movslq -0x1a0(%rbp), %rcx
movss (%rax,%rcx,8), %xmm0
movq -0x58(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
addss (%rax,%rcx,8), %xmm0
movss 0x6125a(%rip), %xmm1    # 0x171fd8
mulss %xmm1, %xmm0
movss %xmm0, -0x1ac(%rbp)
movq -0x58(%rbp), %rax
movslq -0x1a0(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm0
movq -0x58(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
addss 0x4(%rax,%rcx,8), %xmm0
movss 0x61224(%rip), %xmm1    # 0x171fd8
mulss %xmm1, %xmm0
movss %xmm0, -0x1b0(%rbp)
movss -0x1ac(%rbp), %xmm0
movss -0x1ac(%rbp), %xmm2
movss -0x1b0(%rbp), %xmm1
mulss -0x1b0(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1b4(%rbp)
movss 0x611e0(%rip), %xmm0    # 0x171fd8
ucomiss -0x1b4(%rbp), %xmm0
jbe 0x110e11
movss 0x611cf(%rip), %xmm0    # 0x171fd8
movss %xmm0, -0x1b4(%rbp)
movss 0x5fe23(%rip), %xmm0    # 0x170c3c
divss -0x1b4(%rbp), %xmm0
movss %xmm0, -0x1b8(%rbp)
movss -0x1b8(%rbp), %xmm0
mulss -0x1ac(%rbp), %xmm0
movss %xmm0, -0x1ac(%rbp)
movss -0x1b8(%rbp), %xmm0
mulss -0x1b0(%rbp), %xmm0
movss %xmm0, -0x1b0(%rbp)
movq -0x210(%rbp), %rax
movss -0x1ac(%rbp), %xmm0
movss -0x114(%rbp), %xmm1
addss -0x34(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x1bc(%rbp)
movss -0x1b0(%rbp), %xmm0
movss -0x114(%rbp), %xmm1
addss -0x34(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x1c0(%rbp)
movss -0x1ac(%rbp), %xmm0
mulss -0x114(%rbp), %xmm0
movss %xmm0, -0x1c4(%rbp)
movss -0x1b0(%rbp), %xmm0
mulss -0x114(%rbp), %xmm0
movss %xmm0, -0x1c8(%rbp)
movq -0x60(%rbp), %rcx
movl -0x1a4(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x1d0(%rbp)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss (%rcx,%rdx,8), %xmm0
addss -0x1bc(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, (%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss 0x4(%rcx,%rdx,8), %xmm0
addss -0x1c0(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0x4(%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss (%rcx,%rdx,8), %xmm0
addss -0x1c4(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0x8(%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss 0x4(%rcx,%rdx,8), %xmm0
addss -0x1c8(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0xc(%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss (%rcx,%rdx,8), %xmm0
subss -0x1c4(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0x10(%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss 0x4(%rcx,%rdx,8), %xmm0
subss -0x1c8(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0x14(%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss (%rcx,%rdx,8), %xmm0
subss -0x1bc(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movslq -0x1a4(%rbp), %rdx
movss 0x4(%rcx,%rdx,8), %xmm0
subss -0x1c0(%rbp), %xmm0
movq -0x1d0(%rbp), %rcx
movss %xmm0, 0x1c(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, (%rcx)
movl -0x19c(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x2(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x4(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x6(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x8(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xa(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xc(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xe(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x10(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x12(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x0, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x14(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x16(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x18(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x1a(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x1c(%rcx)
movl -0x19c(%rbp), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x1e(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x20(%rcx)
movl -0x1a8(%rbp), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x22(%rcx)
movq 0x50(%rax), %rcx
addq $0x24, %rcx
movq %rcx, 0x50(%rax)
movl -0x1a8(%rbp), %eax
movl %eax, -0x19c(%rbp)
movl -0x1a0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a0(%rbp)
jmp 0x110cd9
movl $0x0, -0x1d4(%rbp)
movl -0x1d4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1112b9
movq -0x210(%rbp), %rax
movq -0x60(%rbp), %rdx
movl -0x1d4(%rbp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl -0x38(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x10(%rcx)
movq -0x60(%rbp), %rdx
movl -0x1d4(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x14(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x1c(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x24(%rcx)
movq -0x60(%rbp), %rdx
movl -0x1d4(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x28(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x30(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x38(%rcx)
movq -0x60(%rbp), %rdx
movl -0x1d4(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rsi
movq 0x48(%rax), %rcx
movq (%rdx,%rsi,8), %rdx
movq %rdx, 0x3c(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x44(%rcx)
movl -0x38(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x4c(%rcx)
movq 0x48(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x48(%rax)
movl -0x1d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4(%rbp)
jmp 0x1111b0
jmp 0x1112bb
movq -0x210(%rbp), %rax
movl -0x4c(%rbp), %ecx
movzwl %cx, %ecx
addl 0x34(%rax), %ecx
movl %ecx, 0x34(%rax)
jmp 0x111665
movq -0x210(%rbp), %rdi
imull $0x6, -0x2c(%rbp), %eax
movl %eax, -0x1d8(%rbp)
movl -0x2c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1dc(%rbp)
movl -0x1d8(%rbp), %esi
movl -0x1dc(%rbp), %edx
callq 0x10f7f0
movl $0x0, -0x1e0(%rbp)
movl -0x1e0(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x111663
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x111332
xorl %eax, %eax
movl %eax, -0x2ac(%rbp)
jmp 0x111341
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2ac(%rbp)
movl -0x2ac(%rbp), %eax
movl %eax, -0x1e4(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1e0(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1f0(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1e4(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x1f8(%rbp)
movq -0x1f8(%rbp), %rax
movss (%rax), %xmm0
movq -0x1f0(%rbp), %rax
subss (%rax), %xmm0
movss %xmm0, -0x1fc(%rbp)
movq -0x1f8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x1f0(%rbp), %rax
subss 0x4(%rax), %xmm0
movss %xmm0, -0x200(%rbp)
movss -0x1fc(%rbp), %xmm0
movss -0x1fc(%rbp), %xmm2
movss -0x200(%rbp), %xmm1
mulss -0x200(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x204(%rbp)
movss -0x204(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x111451
movss -0x204(%rbp), %xmm0
callq 0xd960
movaps %xmm0, %xmm1
movss 0x5f827(%rip), %xmm0    # 0x170c3c
divss %xmm1, %xmm0
movss %xmm0, -0x208(%rbp)
movss -0x208(%rbp), %xmm0
mulss -0x1fc(%rbp), %xmm0
movss %xmm0, -0x1fc(%rbp)
movss -0x208(%rbp), %xmm0
mulss -0x200(%rbp), %xmm0
movss %xmm0, -0x200(%rbp)
jmp 0x111453
movq -0x210(%rbp), %rax
movss 0x60b76(%rip), %xmm0    # 0x171fd8
mulss -0x20(%rbp), %xmm0
mulss -0x1fc(%rbp), %xmm0
movss %xmm0, -0x1fc(%rbp)
movss 0x60b59(%rip), %xmm0    # 0x171fd8
mulss -0x20(%rbp), %xmm0
mulss -0x200(%rbp), %xmm0
movss %xmm0, -0x200(%rbp)
movq -0x1f0(%rbp), %rcx
movss (%rcx), %xmm0
addss -0x200(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, (%rcx)
movq -0x1f0(%rbp), %rcx
movss 0x4(%rcx), %xmm0
subss -0x1fc(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x4(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x10(%rcx)
movq -0x1f8(%rbp), %rcx
movss (%rcx), %xmm0
addss -0x200(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x14(%rcx)
movq -0x1f8(%rbp), %rcx
movss 0x4(%rcx), %xmm0
subss -0x1fc(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x18(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x1c(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x24(%rcx)
movq -0x1f8(%rbp), %rcx
movss (%rcx), %xmm0
subss -0x200(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x28(%rcx)
movq -0x1f8(%rbp), %rcx
movss 0x4(%rcx), %xmm0
addss -0x1fc(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x2c(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x30(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x38(%rcx)
movq -0x1f0(%rbp), %rcx
movss (%rcx), %xmm0
subss -0x200(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x3c(%rcx)
movq -0x1f0(%rbp), %rcx
movss 0x4(%rcx), %xmm0
addss -0x1fc(%rbp), %xmm0
movq 0x48(%rax), %rcx
movss %xmm0, 0x40(%rcx)
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, 0x44(%rcx)
movl -0x18(%rbp), %edx
movq 0x48(%rax), %rcx
movl %edx, 0x4c(%rcx)
movq 0x48(%rax), %rcx
addq $0x50, %rcx
movq %rcx, 0x48(%rax)
movl 0x34(%rax), %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, (%rcx)
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x2(%rcx)
movl 0x34(%rax), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x4(%rcx)
movl 0x34(%rax), %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x6(%rcx)
movl 0x34(%rax), %ecx
addl $0x2, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0x8(%rcx)
movl 0x34(%rax), %ecx
addl $0x3, %ecx
movw %cx, %dx
movq 0x50(%rax), %rcx
movw %dx, 0xa(%rcx)
movq 0x50(%rax), %rcx
addq $0xc, %rcx
movq %rcx, 0x50(%rax)
movl 0x34(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x34(%rax)
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
jmp 0x11130b
jmp 0x111665
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)