// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddPolyline(ImVec2 const*, int, unsigned int, bool, float, bool)
void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, bool closed, float thickness, bool anti_aliased)
{
    if (points_count < 2)
        return;

    const ImVec2 uv = GImGui->FontTexUvWhitePixel;
    anti_aliased &= GImGui->Style.AntiAliasedLines;
    //if (ImGui::GetIO().KeyCtrl) anti_aliased = false; // Debug

    int count = points_count;
    if (!closed)
        count = points_count-1;

    const bool thick_line = thickness > 1.0f;
    if (anti_aliased)
    {
        // Anti-aliased stroke
        const float AA_SIZE = 1.0f;
        const ImU32 col_trans = col & 0x00ffffff;

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

        // Temporary buffer
        ImVec2* temp_normals = (ImVec2*)alloca(points_count * (thick_line ? 5 : 3) * sizeof(ImVec2));
        ImVec2* temp_points = temp_normals + points_count;

        for (int i1 = 0; i1 < count; i1++)
        {
            const int i2 = (i1+1) == points_count ? 0 : i1+1;
            ImVec2 diff = points[i2] - points[i1];
            diff *= ImInvLength(diff, 1.0f);
            temp_normals[i1].x = diff.y;
            temp_normals[i1].y = -diff.x;
        }
        if (!closed)
            temp_normals[points_count-1] = temp_normals[points_count-2];

        if (!thick_line)
        {
            if (!closed)
            {
                temp_points[0] = points[0] + temp_normals[0] * AA_SIZE;
                temp_points[1] = points[0] - temp_normals[0] * AA_SIZE;
                temp_points[(points_count-1)*2+0] = points[points_count-1] + temp_normals[points_count-1] * AA_SIZE;
                temp_points[(points_count-1)*2+1] = points[points_count-1] - temp_normals[points_count-1] * AA_SIZE;
            }

            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
            unsigned int idx1 = _VtxCurrentIdx;
            for (int i1 = 0; i1 < count; i1++)
            {
                const int i2 = (i1+1) == points_count ? 0 : i1+1;
                unsigned int idx2 = (i1+1) == points_count ? _VtxCurrentIdx : idx1+3;

                // Average normals
                ImVec2 dm = (temp_normals[i1] + temp_normals[i2]) * 0.5f;
                float dmr2 = dm.x*dm.x + dm.y*dm.y;
                if (dmr2 > 0.000001f)
                {
                    float scale = 1.0f / dmr2;
                    if (scale > 100.0f) scale = 100.0f;
                    dm *= scale;
                }
                dm *= AA_SIZE;
                temp_points[i2*2+0] = points[i2] + dm;
                temp_points[i2*2+1] = points[i2] - dm;

                // Add indexes
                _IdxWritePtr[0] = (ImDrawIdx)(idx2+0); _IdxWritePtr[1] = (ImDrawIdx)(idx1+0); _IdxWritePtr[2] = (ImDrawIdx)(idx1+2);
                _IdxWritePtr[3] = (ImDrawIdx)(idx1+2); _IdxWritePtr[4] = (ImDrawIdx)(idx2+2); _IdxWritePtr[5] = (ImDrawIdx)(idx2+0);
                _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;

                idx1 = idx2;
            }

            // Add vertexes
            for (int i = 0; i < points_count; i++)
            {
                _VtxWritePtr[0].pos = points[i];          _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
                _VtxWritePtr[1].pos = temp_points[i*2+0]; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col_trans;
                _VtxWritePtr[2].pos = temp_points[i*2+1]; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col_trans;
                _VtxWritePtr += 3;
            }
        }
        else
        {
            const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f;
            if (!closed)
            {
                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_count-1)*4+0] = points[points_count-1] + temp_normals[points_count-1] * (half_inner_thickness + AA_SIZE);
                temp_points[(points_count-1)*4+1] = points[points_count-1] + temp_normals[points_count-1] * (half_inner_thickness);
                temp_points[(points_count-1)*4+2] = points[points_count-1] - temp_normals[points_count-1] * (half_inner_thickness);
                temp_points[(points_count-1)*4+3] = points[points_count-1] - temp_normals[points_count-1] * (half_inner_thickness + AA_SIZE);
            }

            // FIXME-OPT: Merge the different loops, possibly remove the temporary buffer.
            unsigned int idx1 = _VtxCurrentIdx;
            for (int i1 = 0; i1 < count; i1++)
            {
                const int i2 = (i1+1) == points_count ? 0 : i1+1;
                unsigned int idx2 = (i1+1) == points_count ? _VtxCurrentIdx : idx1+4;

                // Average normals
                ImVec2 dm = (temp_normals[i1] + temp_normals[i2]) * 0.5f;
                float dmr2 = dm.x*dm.x + dm.y*dm.y;
                if (dmr2 > 0.000001f)
                {
                    float scale = 1.0f / dmr2;
                    if (scale > 100.0f) scale = 100.0f;
                    dm *= scale;
                }
                ImVec2 dm_out = dm * (half_inner_thickness + AA_SIZE);
                ImVec2 dm_in = dm * half_inner_thickness;
                temp_points[i2*4+0] = points[i2] + dm_out;
                temp_points[i2*4+1] = points[i2] + dm_in;
                temp_points[i2*4+2] = points[i2] - dm_in;
                temp_points[i2*4+3] = points[i2] - dm_out;

                // 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 vertexes
            for (int i = 0; i < points_count; i++)
            {
                _VtxWritePtr[0].pos = temp_points[i*4+0]; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col_trans;
                _VtxWritePtr[1].pos = temp_points[i*4+1]; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
                _VtxWritePtr[2].pos = temp_points[i*4+2]; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
                _VtxWritePtr[3].pos = temp_points[i*4+3]; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col_trans;
                _VtxWritePtr += 4;
            }
        }
        _VtxCurrentIdx += (ImDrawIdx)vtx_count;
    }
    else
    {
        // Non Anti-aliased Stroke
        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];
            ImVec2 diff = p2 - p1;
            diff *= ImInvLength(diff, 1.0f);

            const float dx = diff.x * (thickness * 0.5f);
            const float dy = diff.y * (thickness * 0.5f);
            _VtxWritePtr[0].pos.x = p1.x + dy; _VtxWritePtr[0].pos.y = p1.y - dx; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
            _VtxWritePtr[1].pos.x = p2.x + dy; _VtxWritePtr[1].pos.y = p2.y - dx; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
            _VtxWritePtr[2].pos.x = p2.x - dy; _VtxWritePtr[2].pos.y = p2.y + dx; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
            _VtxWritePtr[3].pos.x = p1.x - dy; _VtxWritePtr[3].pos.y = p1.y + dx; _VtxWritePtr[3].uv = 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:
cmpl $0x2, %edx
jl 0x28da6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28023(%rip), %rax     # 0x50480
movq (%rax), %rax
movq 0x1720(%rax), %r13
cmpb $0x0, 0x1458(%rax)
sete %al
xorb $0x1, %r9b
leal -0x1(%r12), %ecx
testb %r8b, %r8b
movl %ecx, %edi
cmovnel %edx, %edi
orb %al, %r9b
movss %xmm0, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
jne 0x28590
movl %r8d, -0x44(%rbp)
movq %rcx, -0x50(%rbp)
leal (,%r12,4), %eax
xorl %ecx, %ecx
ucomiss 0xdee3(%rip), %xmm0     # 0x36390
seta %cl
movq %rcx, -0x38(%rbp)
pushq $0x12
popq %rcx
pushq $0xc
popq %rsi
cmoval %ecx, %esi
leal (%r12,%r12,2), %edx
cmoval %eax, %edx
imull %edi, %esi
movq %rbx, %rdi
movl %edx, -0x48(%rbp)
callq 0x2820c
movq -0x38(%rbp), %rax
leal 0x3(,%rax,2), %eax
imull %r12d, %eax
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
movq %rsp, %rdx
subq %rax, %rdx
movq %rdx, %rsp
movl %r12d, %eax
movl -0x40(%rbp), %esi
negq %rsi
pushq $0x1
popq %rcx
xorl %edi, %edi
movss 0xde84(%rip), %xmm0     # 0x36390
movaps 0xde1d(%rip), %xmm1     # 0x36330
leaq (%rsi,%rcx), %r8
cmpq $0x1, %r8
je 0x28734
cmpq %rcx, %rax
movl %ecx, %r8d
cmoveq %rdi, %r8
movss (%r15,%r8,8), %xmm2
movss 0x4(%r15,%r8,8), %xmm3
subss -0x8(%r15,%rcx,8), %xmm2
subss -0x4(%r15,%rcx,8), %xmm3
movaps %xmm3, %xmm4
mulss %xmm3, %xmm4
movaps %xmm2, %xmm5
mulss %xmm2, %xmm5
addss %xmm4, %xmm5
sqrtss %xmm5, %xmm4
movaps %xmm0, %xmm6
divss %xmm4, %xmm6
xorps %xmm4, %xmm4
cmpltss %xmm5, %xmm4
andps %xmm4, %xmm6
andnps %xmm0, %xmm4
orps %xmm6, %xmm4
mulss %xmm4, %xmm3
movss %xmm3, -0x8(%rdx,%rcx,8)
xorps %xmm1, %xmm2
mulss %xmm4, %xmm2
movss %xmm2, -0x4(%rdx,%rcx,8)
incq %rcx
jmp 0x28513
imull $0x6, %edi, %esi
leal (,%rdi,4), %edx
movq %rbx, %rdi
callq 0x2820c
movss -0x30(%rbp), %xmm8
mulss 0xde1f(%rip), %xmm8     # 0x363d0
movl %r12d, %eax
movl -0x40(%rbp), %ecx
negq %rcx
pushq $0x1
popq %rdx
xorl %esi, %esi
movss 0xddc9(%rip), %xmm0     # 0x36390
leaq (%rcx,%rdx), %rdi
cmpq $0x1, %rdi
je 0x28d98
cmpq %rdx, %rax
movl %edx, %edi
cmoveq %rsi, %rdi
movss (%r15,%rdi,8), %xmm1
movss 0x4(%r15,%rdi,8), %xmm5
movss -0x8(%r15,%rdx,8), %xmm4
movss -0x4(%r15,%rdx,8), %xmm3
subss %xmm4, %xmm1
subss %xmm3, %xmm5
movaps %xmm5, %xmm2
mulss %xmm5, %xmm2
movaps %xmm1, %xmm6
mulss %xmm1, %xmm6
addss %xmm2, %xmm6
sqrtss %xmm6, %xmm2
movaps %xmm0, %xmm7
divss %xmm2, %xmm7
xorps %xmm2, %xmm2
cmpltss %xmm6, %xmm2
andps %xmm2, %xmm7
andnps %xmm0, %xmm2
orps %xmm7, %xmm2
mulss %xmm2, %xmm1
mulss %xmm5, %xmm2
mulss %xmm8, %xmm1
mulss %xmm8, %xmm2
addss %xmm2, %xmm4
movq 0x40(%rbx), %r8
movss %xmm4, (%r8)
subss %xmm1, %xmm3
movss %xmm3, 0x4(%r8)
movq %r13, 0x8(%r8)
movq 0x40(%rbx), %r8
movl %r14d, 0x10(%r8)
movss (%r15,%rdi,8), %xmm3
addss %xmm2, %xmm3
movss %xmm3, 0x14(%r8)
movss 0x4(%r15,%rdi,8), %xmm3
subss %xmm1, %xmm3
movss %xmm3, 0x18(%r8)
movq %r13, 0x1c(%r8)
movq 0x40(%rbx), %r8
movl %r14d, 0x24(%r8)
movss (%r15,%rdi,8), %xmm3
subss %xmm2, %xmm3
movss %xmm3, 0x28(%r8)
movss 0x4(%r15,%rdi,8), %xmm3
addss %xmm1, %xmm3
movss %xmm3, 0x2c(%r8)
movq %r13, 0x30(%r8)
movq 0x40(%rbx), %rdi
movl %r14d, 0x38(%rdi)
movss -0x8(%r15,%rdx,8), %xmm3
subss %xmm2, %xmm3
movss %xmm3, 0x3c(%rdi)
addss -0x4(%r15,%rdx,8), %xmm1
movss %xmm1, 0x40(%rdi)
movq %r13, 0x44(%rdi)
movq 0x40(%rbx), %rdi
movl %r14d, 0x4c(%rdi)
addq $0x50, %rdi
movq %rdi, 0x40(%rbx)
movl 0x38(%rbx), %edi
movq 0x48(%rbx), %r8
movw %di, (%r8)
leal 0x1(%rdi), %r9d
movw %r9w, 0x2(%r8)
leal 0x2(%rdi), %r9d
movw %r9w, 0x4(%r8)
movw %di, 0x6(%r8)
movw %r9w, 0x8(%r8)
leal 0x3(%rdi), %r9d
movw %r9w, 0xa(%r8)
addq $0xc, %r8
movq %r8, 0x48(%rbx)
addl $0x4, %edi
movl %edi, 0x38(%rbx)
incq %rdx
jmp 0x285c7
movl %r14d, %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
leaq (%rdx,%rax,8), %rdi
cmpb $0x0, -0x44(%rbp)
movl %ecx, -0x38(%rbp)
je 0x28782
movss -0x30(%rbp), %xmm13
ucomiss 0xdc38(%rip), %xmm13    # 0x36390
jbe 0x28bdb
addss 0xdc35(%rip), %xmm13    # 0x3639c
mulss 0xdc60(%rip), %xmm13    # 0x363d0
movss 0xdc18(%rip), %xmm1     # 0x36390
addss %xmm13, %xmm1
jmp 0x288f0
movss -0x30(%rbp), %xmm13
ucomiss 0xdc00(%rip), %xmm13    # 0x36390
movq -0x10(%rdi), %r8
movq %r8, -0x8(%rdi)
jbe 0x28b5e
addss 0xdbf5(%rip), %xmm13    # 0x3639c
mulss 0xdc20(%rip), %xmm13    # 0x363d0
movss 0xdbd8(%rip), %xmm1     # 0x36390
addss %xmm13, %xmm1
movss (%rdx), %xmm2
movss 0x4(%rdx), %xmm3
movaps %xmm13, %xmm4
mulss %xmm2, %xmm4
mulss %xmm1, %xmm2
movaps %xmm1, %xmm5
mulss %xmm3, %xmm5
movss (%r15), %xmm6
movss 0x4(%r15), %xmm7
movaps %xmm2, %xmm8
addss %xmm6, %xmm8
movaps %xmm5, %xmm9
addss %xmm7, %xmm9
unpcklps %xmm9, %xmm8            # xmm8 = xmm8[0],xmm9[0],xmm8[1],xmm9[1]
mulss %xmm13, %xmm3
movaps %xmm6, %xmm9
subss %xmm4, %xmm9
addss %xmm6, %xmm4
movaps %xmm7, %xmm10
subss %xmm3, %xmm10
addss %xmm7, %xmm3
unpcklps %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
movlhps %xmm4, %xmm8            # xmm8 = xmm8[0],xmm4[0]
movups %xmm8, (%rdi)
unpcklps %xmm10, %xmm9           # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1]
subss %xmm2, %xmm6
subss %xmm5, %xmm7
unpcklps %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1]
movlhps %xmm6, %xmm9            # xmm9 = xmm9[0],xmm6[0]
movups %xmm9, 0x10(%rdi)
movq -0x50(%rbp), %rcx
movl %ecx, %r8d
movss (%rdx,%r8,8), %xmm4
mulss %xmm1, %xmm4
movss 0x4(%rdx,%r8,8), %xmm5
mulss %xmm1, %xmm5
movss (%r15,%r8,8), %xmm2
movss 0x4(%r15,%r8,8), %xmm3
addss %xmm2, %xmm4
addss %xmm3, %xmm5
unpcklps %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
shll $0x2, %ecx
movlps %xmm4, (%rdi,%rcx,8)
movss (%rdx,%r8,8), %xmm4
mulss %xmm13, %xmm4
movss 0x4(%rdx,%r8,8), %xmm5
mulss %xmm13, %xmm5
addss %xmm2, %xmm4
addss %xmm3, %xmm5
unpcklps %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
movlps %xmm4, 0x8(%rdi,%rcx,8)
movss (%rdx,%r8,8), %xmm4
mulss %xmm13, %xmm4
movss 0x4(%rdx,%r8,8), %xmm5
mulss %xmm13, %xmm5
movaps %xmm2, %xmm6
subss %xmm4, %xmm6
movaps %xmm3, %xmm4
subss %xmm5, %xmm4
unpcklps %xmm4, %xmm6            # xmm6 = xmm6[0],xmm4[0],xmm6[1],xmm4[1]
movlps %xmm6, 0x10(%rdi,%rcx,8)
movss (%rdx,%r8,8), %xmm4
mulss %xmm1, %xmm4
movss 0x4(%rdx,%r8,8), %xmm5
mulss %xmm1, %xmm5
subss %xmm4, %xmm2
subss %xmm5, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movlps %xmm2, 0x18(%rdi,%rcx,8)
movl 0x38(%rbx), %r11d
movq 0x48(%rbx), %r8
pushq $0x1
popq %r10
movss 0xdacc(%rip), %xmm2     # 0x363d0
movss 0x130c4(%rip), %xmm3    # 0x3b9d0
movss 0xdb5c(%rip), %xmm4     # 0x36470
movq %rax, -0x30(%rbp)
movq %rsi, -0x40(%rbp)
leaq (%rsi,%r10), %rcx
cmpq $0x1, %rcx
je 0x28ac6
cmpq %r10, %rax
movl %r10d, %r9d
movl $0x0, %eax
cmovel %eax, %r9d
leal 0x4(%r11), %r12d
cmovel 0x38(%rbx), %r12d
movss -0x8(%rdx,%r10,8), %xmm5
addss (%rdx,%r9,8), %xmm5
movss -0x4(%rdx,%r10,8), %xmm6
addss 0x4(%rdx,%r9,8), %xmm6
mulss %xmm2, %xmm5
mulss %xmm2, %xmm6
movaps %xmm6, %xmm8
mulss %xmm6, %xmm8
movaps %xmm5, %xmm7
mulss %xmm5, %xmm7
addss %xmm8, %xmm7
ucomiss %xmm3, %xmm7
jbe 0x28998
movaps %xmm0, %xmm8
divss %xmm7, %xmm8
movaps %xmm4, %xmm7
minss %xmm8, %xmm7
mulss %xmm7, %xmm5
mulss %xmm7, %xmm6
unpcklps %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1]
movaps %xmm1, %xmm6
mulss %xmm5, %xmm6
movaps %xmm13, %xmm8
mulss %xmm5, %xmm8
shufps $0x55, %xmm5, %xmm5     # xmm5 = xmm5[1,1,1,1]
movaps %xmm1, %xmm7
mulss %xmm5, %xmm7
mulss %xmm13, %xmm5
movss (%r15,%r9,8), %xmm9
movss 0x4(%r15,%r9,8), %xmm10
movaps %xmm9, %xmm11
addss %xmm6, %xmm11
movaps %xmm10, %xmm12
addss %xmm7, %xmm12
unpcklps %xmm12, %xmm11          # xmm11 = xmm11[0],xmm12[0],xmm11[1],xmm12[1]
leal (,%r9,4), %ecx
movlps %xmm11, (%rdi,%rcx,8)
movaps %xmm9, %xmm11
addss %xmm8, %xmm11
movaps %xmm10, %xmm12
addss %xmm5, %xmm12
unpcklps %xmm12, %xmm11          # xmm11 = xmm11[0],xmm12[0],xmm11[1],xmm12[1]
movlps %xmm11, 0x8(%rdi,%rcx,8)
movaps %xmm9, %xmm11
subss %xmm8, %xmm11
movaps %xmm10, %xmm8
subss %xmm5, %xmm8
unpcklps %xmm8, %xmm11           # xmm11 = xmm11[0],xmm8[0],xmm11[1],xmm8[1]
movlps %xmm11, 0x10(%rdi,%rcx,8)
subss %xmm6, %xmm9
subss %xmm7, %xmm10
unpcklps %xmm10, %xmm9           # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1]
movlps %xmm9, 0x18(%rdi,%rcx,8)
leal 0x1(%r12), %ecx
movw %cx, (%r8)
leal 0x1(%r11), %r9d
movw %r9w, 0x2(%r8)
leal 0x2(%r11), %esi
movw %si, 0x4(%r8)
movw %si, 0x6(%r8)
leal 0x2(%r12), %eax
movw %ax, 0x8(%r8)
movw %cx, 0xa(%r8)
movw %cx, 0xc(%r8)
movw %r9w, 0xe(%r8)
movw %r11w, 0x10(%r8)
movw %r11w, 0x12(%r8)
movw %r12w, 0x14(%r8)
movw %cx, 0x16(%r8)
movw %ax, 0x18(%r8)
movw %si, 0x1a(%r8)
addl $0x3, %r11d
movw %r11w, 0x1c(%r8)
movw %r11w, 0x1e(%r8)
leal 0x3(%r12), %ecx
movw %cx, 0x20(%r8)
movw %ax, 0x22(%r8)
addq $0x24, %r8
movq %r8, 0x48(%rbx)
incq %r10
movl %r12d, %r11d
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rsi
jmp 0x2891c
leaq (%rdx,%rax,8), %rdx
addq $0x18, %rdx
shlq $0x5, %rax
xorl %esi, %esi
movl -0x38(%rbp), %r8d
cmpq %rsi, %rax
je 0x28d91
movq %rax, %rdi
movq 0x40(%rbx), %rax
movq -0x18(%rdx,%rsi), %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rax
movq %r13, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r8d, 0x10(%rax)
movq -0x10(%rdx,%rsi), %rcx
movq %rcx, 0x14(%rax)
movq 0x40(%rbx), %rax
movq %r13, 0x1c(%rax)
movq 0x40(%rbx), %rax
movl %r14d, 0x24(%rax)
movq -0x8(%rdx,%rsi), %rcx
movq %rcx, 0x28(%rax)
movq 0x40(%rbx), %rax
movq %r13, 0x30(%rax)
movq 0x40(%rbx), %rax
movl %r14d, 0x38(%rax)
movq (%rdx,%rsi), %rcx
movq %rcx, 0x3c(%rax)
movq 0x40(%rbx), %rax
movq %r13, 0x44(%rax)
movq 0x40(%rbx), %rax
movl %r8d, 0x4c(%rax)
addq $0x50, %rax
movq %rax, 0x40(%rbx)
movq %rdi, %rax
addq $0x20, %rsi
jmp 0x28ad8
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm2
movss (%r15), %xmm3
movss 0x4(%r15), %xmm4
movaps %xmm1, %xmm5
addss %xmm3, %xmm5
movaps %xmm2, %xmm6
addss %xmm4, %xmm6
unpcklps %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1]
subss %xmm1, %xmm3
subss %xmm2, %xmm4
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
movlhps %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
movups %xmm5, (%rdi)
movq -0x50(%rbp), %rcx
movl %ecx, %r8d
movss (%r15,%r8,8), %xmm1
movss 0x4(%r15,%r8,8), %xmm2
movss (%rdx,%r8,8), %xmm3
addss %xmm1, %xmm3
movss 0x4(%rdx,%r8,8), %xmm4
addss %xmm2, %xmm4
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
addl %ecx, %ecx
movlps %xmm3, (%rdi,%rcx,8)
subss (%rdx,%r8,8), %xmm1
subss 0x4(%rdx,%r8,8), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movlps %xmm1, 0x8(%rdi,%rcx,8)
movl 0x38(%rbx), %r11d
movq 0x48(%rbx), %r8
pushq $0x1
popq %r10
movss 0xd7e1(%rip), %xmm1     # 0x363d0
movss 0x12dd9(%rip), %xmm2    # 0x3b9d0
movss 0xd871(%rip), %xmm3     # 0x36470
leaq (%rsi,%r10), %r9
cmpq $0x1, %r9
je 0x28d1c
cmpq %r10, %rax
movl %r10d, %r9d
movl $0x0, %ecx
cmovel %ecx, %r9d
leal 0x3(%r11), %r12d
cmovel 0x38(%rbx), %r12d
movss -0x8(%rdx,%r10,8), %xmm4
addss (%rdx,%r9,8), %xmm4
movss -0x4(%rdx,%r10,8), %xmm5
addss 0x4(%rdx,%r9,8), %xmm5
mulss %xmm1, %xmm4
mulss %xmm1, %xmm5
movaps %xmm5, %xmm7
mulss %xmm5, %xmm7
movaps %xmm4, %xmm6
mulss %xmm4, %xmm6
addss %xmm7, %xmm6
ucomiss %xmm2, %xmm6
jbe 0x28c75
movaps %xmm0, %xmm7
divss %xmm6, %xmm7
movaps %xmm3, %xmm6
minss %xmm7, %xmm6
mulss %xmm6, %xmm4
mulss %xmm6, %xmm5
unpcklps %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
movaps %xmm4, %xmm5
shufps $0x55, %xmm4, %xmm5     # xmm5 = xmm5[1,1],xmm4[1,1]
movss (%r15,%r9,8), %xmm6
movss 0x4(%r15,%r9,8), %xmm7
movaps %xmm6, %xmm8
addss %xmm4, %xmm8
movaps %xmm5, %xmm9
addss %xmm7, %xmm9
unpcklps %xmm9, %xmm8            # xmm8 = xmm8[0],xmm9[0],xmm8[1],xmm9[1]
addl %r9d, %r9d
movlps %xmm8, (%rdi,%r9,8)
subss %xmm4, %xmm6
subss %xmm5, %xmm7
unpcklps %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1]
movlps %xmm6, 0x8(%rdi,%r9,8)
movw %r12w, (%r8)
movw %r11w, 0x2(%r8)
leal 0x2(%r11), %r9d
movw %r9w, 0x4(%r8)
movw %r9w, 0x6(%r8)
leal 0x2(%r12), %r9d
movw %r9w, 0x8(%r8)
movw %r12w, 0xa(%r8)
leal 0x1(%r12), %r9d
movw %r9w, 0xc(%r8)
movl %r11d, %ecx
incl %ecx
movw %cx, 0xe(%r8)
movw %r11w, 0x10(%r8)
movw %r11w, 0x12(%r8)
movw %r12w, 0x14(%r8)
movw %r9w, 0x16(%r8)
addq $0x18, %r8
movq %r8, 0x48(%rbx)
incq %r10
movl %r12d, %r11d
jmp 0x28bff
leaq (%rdx,%rax,8), %rdx
addq $0x8, %rdx
leaq (,%rax,8), %rax
xorl %esi, %esi
movl -0x38(%rbp), %r8d
cmpq %rsi, %rax
je 0x28d91
movq 0x40(%rbx), %rcx
movq (%r15,%rsi), %rdi
movq %rdi, (%rcx)
movq 0x40(%rbx), %rcx
movq %r13, 0x8(%rcx)
movq 0x40(%rbx), %rcx
movl %r14d, 0x10(%rcx)
movq -0x8(%rdx,%rsi,2), %rdi
movq %rdi, 0x14(%rcx)
movq 0x40(%rbx), %rcx
movq %r13, 0x1c(%rcx)
movq 0x40(%rbx), %rcx
movl %r8d, 0x24(%rcx)
movq (%rdx,%rsi,2), %rdi
movq %rdi, 0x28(%rcx)
movq 0x40(%rbx), %rcx
movq %r13, 0x30(%rcx)
movq 0x40(%rbx), %rcx
movl %r8d, 0x38(%rcx)
addq $0x3c, %rcx
movq %rcx, 0x40(%rbx)
addq $0x8, %rsi
jmp 0x28d32
movzwl -0x48(%rbp), %eax
addl %eax, 0x38(%rbx)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop