// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_stroke_poly_line
NK_API void
nk_draw_list_stroke_poly_line(struct nk_draw_list *list, const struct nk_vec2 *points,
    const unsigned int points_count, struct nk_color color, enum nk_draw_list_stroke closed,
    float thickness, enum nk_anti_aliasing aliasing)
{
    nk_size count;
    int thick_line;
    struct nk_colorf col;
    struct nk_colorf col_trans;
    NK_ASSERT(list);
    if (!list || points_count < 2) return;

    color.a = (nk_byte)((float)color.a * list->config.global_alpha);
    count = points_count;
    if (!closed) count = points_count-1;
    thick_line = thickness > 1.0f;

#ifdef NK_INCLUDE_COMMAND_USERDATA
    nk_draw_list_push_userdata(list, list->userdata);
#endif

    color.a = (nk_byte)((float)color.a * list->config.global_alpha);
    nk_color_fv(&col.r, color);
    col_trans = col;
    col_trans.a = 0;

    if (aliasing == NK_ANTI_ALIASING_ON) {
        /* ANTI-ALIASED STROKE */
        const float AA_SIZE = 1.0f;
        NK_STORAGE const nk_size pnt_align = NK_ALIGNOF(struct nk_vec2);
        NK_STORAGE const nk_size pnt_size = sizeof(struct nk_vec2);

        /* allocate vertices and elements  */
        nk_size i1 = 0;
        nk_size vertex_offset;
        nk_size index = list->vertex_count;

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

        void *vtx = nk_draw_list_alloc_vertices(list, vtx_count);
        nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count);

        nk_size size;
        struct nk_vec2 *normals, *temp;
        if (!vtx || !ids) return;

        /* temporary allocate normals + points */
        vertex_offset = (nk_size)((nk_byte*)vtx - (nk_byte*)list->vertices->memory.ptr);
        nk_buffer_mark(list->vertices, NK_BUFFER_FRONT);
        size = pnt_size * ((thick_line) ? 5 : 3) * points_count;
        normals = (struct nk_vec2*) nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT, size, pnt_align);
        if (!normals) return;
        temp = normals + points_count;

        /* make sure vertex pointer is still correct */
        vtx = (void*)((nk_byte*)list->vertices->memory.ptr + vertex_offset);

        /* calculate normals */
        for (i1 = 0; i1 < count; ++i1) {
            const nk_size i2 = ((i1 + 1) == points_count) ? 0 : (i1 + 1);
            struct nk_vec2 diff = nk_vec2_sub(points[i2], points[i1]);
            float len;

            /* vec2 inverted length  */
            len = nk_vec2_len_sqr(diff);
            if (len != 0.0f)
                len = NK_INV_SQRT(len);
            else len = 1.0f;

            diff = nk_vec2_muls(diff, len);
            normals[i1].x = diff.y;
            normals[i1].y = -diff.x;
        }

        if (!closed)
            normals[points_count-1] = normals[points_count-2];

        if (!thick_line) {
            nk_size idx1, i;
            if (!closed) {
                struct nk_vec2 d;
                temp[0] = nk_vec2_add(points[0], nk_vec2_muls(normals[0], AA_SIZE));
                temp[1] = nk_vec2_sub(points[0], nk_vec2_muls(normals[0], AA_SIZE));
                d = nk_vec2_muls(normals[points_count-1], AA_SIZE);
                temp[(points_count-1) * 2 + 0] = nk_vec2_add(points[points_count-1], d);
                temp[(points_count-1) * 2 + 1] = nk_vec2_sub(points[points_count-1], d);
            }

            /* fill elements */
            idx1 = index;
            for (i1 = 0; i1 < count; i1++) {
                struct nk_vec2 dm;
                float dmr2;
                nk_size i2 = ((i1 + 1) == points_count) ? 0 : (i1 + 1);
                nk_size idx2 = ((i1+1) == points_count) ? index: (idx1 + 3);

                /* average normals */
                dm = nk_vec2_muls(nk_vec2_add(normals[i1], normals[i2]), 0.5f);
                dmr2 = dm.x * dm.x + dm.y* dm.y;
                if (dmr2 > 0.000001f) {
                    float scale = 1.0f/dmr2;
                    scale = NK_MIN(100.0f, scale);
                    dm = nk_vec2_muls(dm, scale);
                }

                dm = nk_vec2_muls(dm, AA_SIZE);
                temp[i2*2+0] = nk_vec2_add(points[i2], dm);
                temp[i2*2+1] = nk_vec2_sub(points[i2], dm);

                ids[0] = (nk_draw_index)(idx2 + 0); ids[1] = (nk_draw_index)(idx1+0);
                ids[2] = (nk_draw_index)(idx1 + 2); ids[3] = (nk_draw_index)(idx1+2);
                ids[4] = (nk_draw_index)(idx2 + 2); ids[5] = (nk_draw_index)(idx2+0);
                ids[6] = (nk_draw_index)(idx2 + 1); ids[7] = (nk_draw_index)(idx1+1);
                ids[8] = (nk_draw_index)(idx1 + 0); ids[9] = (nk_draw_index)(idx1+0);
                ids[10]= (nk_draw_index)(idx2 + 0); ids[11]= (nk_draw_index)(idx2+1);
                ids += 12;
                idx1 = idx2;
            }

            /* fill vertices */
            for (i = 0; i < points_count; ++i) {
                const struct nk_vec2 uv = list->config.tex_null.uv;
                vtx = nk_draw_vertex(vtx, &list->config, points[i], uv, col);
                vtx = nk_draw_vertex(vtx, &list->config, temp[i*2+0], uv, col_trans);
                vtx = nk_draw_vertex(vtx, &list->config, temp[i*2+1], uv, col_trans);
            }
        } else {
            nk_size idx1, i;
            const float half_inner_thickness = (thickness - AA_SIZE) * 0.5f;
            if (!closed) {
                struct nk_vec2 d1 = nk_vec2_muls(normals[0], half_inner_thickness + AA_SIZE);
                struct nk_vec2 d2 = nk_vec2_muls(normals[0], half_inner_thickness);

                temp[0] = nk_vec2_add(points[0], d1);
                temp[1] = nk_vec2_add(points[0], d2);
                temp[2] = nk_vec2_sub(points[0], d2);
                temp[3] = nk_vec2_sub(points[0], d1);

                d1 = nk_vec2_muls(normals[points_count-1], half_inner_thickness + AA_SIZE);
                d2 = nk_vec2_muls(normals[points_count-1], half_inner_thickness);

                temp[(points_count-1)*4+0] = nk_vec2_add(points[points_count-1], d1);
                temp[(points_count-1)*4+1] = nk_vec2_add(points[points_count-1], d2);
                temp[(points_count-1)*4+2] = nk_vec2_sub(points[points_count-1], d2);
                temp[(points_count-1)*4+3] = nk_vec2_sub(points[points_count-1], d1);
            }

            /* add all elements */
            idx1 = index;
            for (i1 = 0; i1 < count; ++i1) {
                struct nk_vec2 dm_out, dm_in;
                const nk_size i2 = ((i1+1) == points_count) ? 0: (i1 + 1);
                nk_size idx2 = ((i1+1) == points_count) ? index: (idx1 + 4);

                /* average normals */
                struct nk_vec2 dm = nk_vec2_muls(nk_vec2_add(normals[i1], normals[i2]), 0.5f);
                float dmr2 = dm.x * dm.x + dm.y* dm.y;
                if (dmr2 > 0.000001f) {
                    float scale = 1.0f/dmr2;
                    scale = NK_MIN(100.0f, scale);
                    dm = nk_vec2_muls(dm, scale);
                }

                dm_out = nk_vec2_muls(dm, ((half_inner_thickness) + AA_SIZE));
                dm_in = nk_vec2_muls(dm, half_inner_thickness);
                temp[i2*4+0] = nk_vec2_add(points[i2], dm_out);
                temp[i2*4+1] = nk_vec2_add(points[i2], dm_in);
                temp[i2*4+2] = nk_vec2_sub(points[i2], dm_in);
                temp[i2*4+3] = nk_vec2_sub(points[i2], dm_out);

                /* add indexes */
                ids[0] = (nk_draw_index)(idx2 + 1); ids[1] = (nk_draw_index)(idx1+1);
                ids[2] = (nk_draw_index)(idx1 + 2); ids[3] = (nk_draw_index)(idx1+2);
                ids[4] = (nk_draw_index)(idx2 + 2); ids[5] = (nk_draw_index)(idx2+1);
                ids[6] = (nk_draw_index)(idx2 + 1); ids[7] = (nk_draw_index)(idx1+1);
                ids[8] = (nk_draw_index)(idx1 + 0); ids[9] = (nk_draw_index)(idx1+0);
                ids[10]= (nk_draw_index)(idx2 + 0); ids[11] = (nk_draw_index)(idx2+1);
                ids[12]= (nk_draw_index)(idx2 + 2); ids[13] = (nk_draw_index)(idx1+2);
                ids[14]= (nk_draw_index)(idx1 + 3); ids[15] = (nk_draw_index)(idx1+3);
                ids[16]= (nk_draw_index)(idx2 + 3); ids[17] = (nk_draw_index)(idx2+2);
                ids += 18;
                idx1 = idx2;
            }

            /* add vertices */
            for (i = 0; i < points_count; ++i) {
                const struct nk_vec2 uv = list->config.tex_null.uv;
                vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+0], uv, col_trans);
                vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+1], uv, col);
                vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+2], uv, col);
                vtx = nk_draw_vertex(vtx, &list->config, temp[i*4+3], uv, col_trans);
            }
        }
        /* free temporary normals + points */
        nk_buffer_reset(list->vertices, NK_BUFFER_FRONT);
    } else {
        /* NON ANTI-ALIASED STROKE */
        nk_size i1 = 0;
        nk_size idx = list->vertex_count;
        const nk_size idx_count = count * 6;
        const nk_size vtx_count = count * 4;
        void *vtx = nk_draw_list_alloc_vertices(list, vtx_count);
        nk_draw_index *ids = nk_draw_list_alloc_elements(list, idx_count);
        if (!vtx || !ids) return;

        for (i1 = 0; i1 < count; ++i1) {
            float dx, dy;
            const struct nk_vec2 uv = list->config.tex_null.uv;
            const nk_size i2 = ((i1+1) == points_count) ? 0 : i1 + 1;
            const struct nk_vec2 p1 = points[i1];
            const struct nk_vec2 p2 = points[i2];
            struct nk_vec2 diff = nk_vec2_sub(p2, p1);
            float len;

            /* vec2 inverted length  */
            len = nk_vec2_len_sqr(diff);
            if (len != 0.0f)
                len = NK_INV_SQRT(len);
            else len = 1.0f;
            diff = nk_vec2_muls(diff, len);

            /* add vertices */
            dx = diff.x * (thickness * 0.5f);
            dy = diff.y * (thickness * 0.5f);

            vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p1.x + dy, p1.y - dx), uv, col);
            vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p2.x + dy, p2.y - dx), uv, col);
            vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p2.x - dy, p2.y + dx), uv, col);
            vtx = nk_draw_vertex(vtx, &list->config, nk_vec2(p1.x - dy, p1.y + dx), uv, col);

            ids[0] = (nk_draw_index)(idx+0); ids[1] = (nk_draw_index)(idx+1);
            ids[2] = (nk_draw_index)(idx+2); ids[3] = (nk_draw_index)(idx+0);
            ids[4] = (nk_draw_index)(idx+2); ids[5] = (nk_draw_index)(idx+3);

            ids += 6;
            idx += 4;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
testq %rdi, %rdi
je 0x2793a
movl %edx, %ebp
movq %rdi, 0x38(%rsp)
cmpl $0x2, %edx
jae 0x27977
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5d6af(%rip), %rbx     # 0x84ff0
movq (%rbx), %rdi
leaq 0x423c1(%rip), %rsi     # 0x69d0c
leaq 0x423d8(%rip), %rdx     # 0x69d2a
movl $0x26bc, %ecx           # imm = 0x26BC
xorl %eax, %eax
callq 0x12ea0
movq (%rbx), %rdi
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13960
movl %r9d, %r13d
movq %rsi, %r15
movaps %xmm0, 0x80(%rsp)
movl %ecx, %eax
shrl $0x18, %eax
movzbl %al, %eax
cvtsi2ss %eax, %xmm0
movq 0x38(%rsp), %r14
movss 0x70(%r14), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %ebp, %r12d
leal -0x1(%rbp), %esi
movl %r8d, 0xc(%rsp)
testl %r8d, %r8d
movq %r12, 0x10(%rsp)
movq %rsi, 0xa0(%rsp)
cmoveq %rsi, %r12
movzbl %al, %eax
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
leaq 0x70(%r14), %rdx
movq %rdx, 0x70(%rsp)
shll $0x18, %eax
andl $0xffffff, %ecx         # imm = 0xFFFFFF
orl %eax, %ecx
leaq 0xd8(%rsp), %rbx
movq %rbx, %rdi
movl %ecx, %esi
callq 0x12830
movsd (%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x50(%rsp)
movl 0xcc(%r14), %eax
movq %rax, 0x30(%rsp)
cmpl $0x1, %r13d
jne 0x27bea
movaps 0x80(%rsp), %xmm0
ucomiss 0x3ee04(%rip), %xmm0    # 0x66834
leal (,%rbp,4), %eax
pushq $0x12
popq %rcx
pushq $0xc
popq %rbx
cmovaq %rcx, %rbx
leal (%rbp,%rbp,2), %esi
cmoval %eax, %esi
movq %r12, 0x68(%rsp)
imulq %r12, %rbx
movq %r14, %rdi
callq 0x283af
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2842e
movaps 0x80(%rsp), %xmm0
testq %r12, %r12
je 0x27928
movq %rax, %r13
testq %rax, %rax
je 0x27928
xorl %ebx, %ebx
ucomiss 0x3eda7(%rip), %xmm0    # 0x66834
seta %bl
movq %r12, %r14
movq 0x38(%rsp), %r12
movq 0xb8(%r12), %rdi
movq 0x40(%rdi), %rax
movq %rax, 0x90(%rsp)
xorl %esi, %esi
callq 0x140b0
shll $0x4, %ebx
addq $0x18, %rbx
imulq 0x10(%rsp), %rbx
movq 0xb8(%r12), %rdi
pushq $0x4
popq %rcx
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2403e
movl 0xc(%rsp), %r9d
movaps 0x80(%rsp), %xmm9
testq %rax, %rax
je 0x27928
movq %rax, %rcx
xorps %xmm0, %xmm0
movaps 0x50(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, 0x40(%rsp)
subq 0x90(%rsp), %r14
movq %r14, %r10
movq 0x38(%rsp), %r12
movq 0xb8(%r12), %rax
movq 0x40(%rax), %rax
movq 0x68(%rsp), %r14
negq %r14
pushq $0x1
popq %rdx
xorl %esi, %esi
movss 0x3ed04(%rip), %xmm0    # 0x66834
xorps %xmm1, %xmm1
movss 0x3ed25(%rip), %xmm2    # 0x66860
movss 0x3ed21(%rip), %xmm3    # 0x66864
movaps 0x3ea26(%rip), %xmm4    # 0x66570
leaq (%r14,%rdx), %rdi
cmpq $0x1, %rdi
je 0x27e81
cmpq %rdx, 0x10(%rsp)
movq %rdx, %rdi
cmoveq %rsi, %rdi
movss (%r15,%rdi,8), %xmm6
movss 0x4(%r15,%rdi,8), %xmm5
subss -0x8(%r15,%rdx,8), %xmm6
subss -0x4(%r15,%rdx,8), %xmm5
movaps %xmm5, %xmm8
mulss %xmm5, %xmm8
movaps %xmm6, %xmm7
mulss %xmm6, %xmm7
addss %xmm8, %xmm7
ucomiss %xmm1, %xmm7
movaps %xmm0, %xmm8
jne 0x27b9f
jnp 0x27bce
movd %xmm7, %edi
shrl %edi
movl $0x5f375a84, %r8d       # imm = 0x5F375A84
subl %edi, %r8d
movd %r8d, %xmm8
mulss %xmm2, %xmm7
mulss %xmm8, %xmm7
mulss %xmm8, %xmm7
addss %xmm3, %xmm7
mulss %xmm8, %xmm7
movaps %xmm7, %xmm8
xorps %xmm4, %xmm6
unpcklps %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1]
unpcklps %xmm8, %xmm8            # xmm8 = xmm8[0,0,1,1]
mulps %xmm5, %xmm8
movlps %xmm8, -0x8(%rcx,%rdx,8)
incq %rdx
jmp 0x27b4a
imulq $0x6, %r12, %rbx
shlq $0x2, %r12
movq %r14, %rdi
movq %r12, 0x68(%rsp)
movq %r12, %rsi
callq 0x283af
movq %rax, %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2842e
movq %rax, %r13
testq %rbp, %rbp
setne %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
movaps 0x80(%rsp), %xmm4
jne 0x27928
mulss 0x3ebf6(%rip), %xmm4    # 0x66830
movq 0x10(%rsp), %rax
leaq -0x4(,%rax,4), %rax
movq %rax, 0xb0(%rsp)
pushq $0x1
popq %rbx
xorl %r12d, %r12d
movq %r15, 0xb8(%rsp)
movaps %xmm4, 0x80(%rsp)
cmpq %r12, 0x68(%rsp)
je 0x27928
cmpq %r12, 0xb0(%rsp)
movq %rbx, %rax
movl $0x0, %ecx
cmoveq %rcx, %rax
movss (%r15,%r12,2), %xmm8
movss 0x4(%r15,%r12,2), %xmm9
movss (%r15,%rax,8), %xmm5
movss 0x4(%r15,%rax,8), %xmm6
movaps %xmm5, 0xa0(%rsp)
movaps %xmm5, %xmm2
subss %xmm8, %xmm2
movaps %xmm6, 0x90(%rsp)
movaps %xmm6, %xmm3
subss %xmm9, %xmm3
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
movaps %xmm2, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
ucomiss 0x3eb99(%rip), %xmm0    # 0x66870
movss 0x3eb55(%rip), %xmm7    # 0x66834
jne 0x27ce3
jnp 0x27d13
movd %xmm0, %eax
shrl %eax
movl $0x5f375a84, %ecx       # imm = 0x5F375A84
subl %eax, %ecx
movd %ecx, %xmm1
mulss 0x3eb64(%rip), %xmm0    # 0x66860
mulss %xmm1, %xmm0
mulss %xmm1, %xmm0
addss 0x3eb58(%rip), %xmm0    # 0x66864
mulss %xmm1, %xmm0
movaps %xmm0, %xmm7
movq 0x30(%rsp), %r15
leaq (%r15,%r12), %r14
movq 0x38(%rsp), %rax
movsd 0x90(%rax), %xmm1
movaps %xmm1, 0x10(%rsp)
mulss %xmm7, %xmm2
mulss %xmm7, %xmm3
mulss %xmm4, %xmm2
movaps %xmm2, 0x40(%rsp)
mulss %xmm4, %xmm3
movss %xmm3, 0xc(%rsp)
movaps %xmm8, %xmm0
addss %xmm3, %xmm0
movaps %xmm9, %xmm7
subss %xmm2, %xmm7
unpcklps %xmm7, %xmm0            # xmm0 = xmm0[0],xmm7[0],xmm0[1],xmm7[1]
movq %rbp, %rdi
movq 0x70(%rsp), %rbp
movq %rbp, %rsi
movaps %xmm8, 0xc0(%rsp)
movaps 0x20(%rsp), %xmm2
movss %xmm9, 0x7c(%rsp)
movaps 0x50(%rsp), %xmm3
callq 0x28470
movaps 0xa0(%rsp), %xmm0
addss 0xc(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
subss 0x40(%rsp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq %rax, %rdi
movq %rbp, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x28470
movaps 0xa0(%rsp), %xmm0
subss 0xc(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
addss 0x40(%rsp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq %rax, %rdi
movq %rbp, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x28470
movaps 0xc0(%rsp), %xmm0
subss 0xc(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
addss 0x7c(%rsp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq %rax, %rdi
movq %rbp, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x28470
movaps 0x80(%rsp), %xmm4
movq %rax, %rbp
movw %r14w, (%r13)
leal (%r15,%r12), %eax
incl %eax
movw %ax, 0x2(%r13)
leal 0x2(%r15,%r12), %eax
movw %ax, 0x4(%r13)
movw %r14w, 0x6(%r13)
movw %ax, 0x8(%r13)
leal (%r15,%r12), %eax
addl $0x3, %eax
movw %ax, 0xa(%r13)
addq $0xc, %r13
addq $0x4, %r12
incq %rbx
movq 0xb8(%rsp), %r15
jmp 0x27c65
addq %r10, %rax
movq 0x10(%rsp), %rdx
leaq (%rcx,%rdx,8), %rdx
testl %r9d, %r9d
je 0x27ec4
ucomiss 0x3e99a(%rip), %xmm9    # 0x66834
jbe 0x281f3
addss 0x3e99b(%rip), %xmm9    # 0x66844
mulss 0x3e97e(%rip), %xmm9    # 0x66830
movss 0x3e97a(%rip), %xmm0    # 0x66834
addss %xmm9, %xmm0
jmp 0x27f99
addl $-0x2, %ebp
ucomiss 0x3e965(%rip), %xmm9    # 0x66834
movq (%rcx,%rbp,8), %rsi
movq 0xa0(%rsp), %rdi
movq %rsi, (%rcx,%rdi,8)
jbe 0x281b5
addss 0x3e956(%rip), %xmm9    # 0x66844
mulss 0x3e939(%rip), %xmm9    # 0x66830
movss 0x3e935(%rip), %xmm0    # 0x66834
addss %xmm9, %xmm0
movsd (%rcx), %xmm3
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1      # xmm1 = xmm1[0,0],xmm0[0,0]
movaps %xmm1, %xmm4
mulps %xmm3, %xmm4
movsd (%r15), %xmm2
addps %xmm4, %xmm2
movlps %xmm2, (%rdx)
movaps %xmm9, %xmm2
shufps $0x0, %xmm9, %xmm2      # xmm2 = xmm2[0,0],xmm9[0,0]
mulps %xmm2, %xmm3
movsd (%r15), %xmm5
addps %xmm3, %xmm5
movlps %xmm5, 0x8(%rdx)
movsd (%r15), %xmm5
subps %xmm3, %xmm5
movlps %xmm5, 0x10(%rdx)
movsd (%r15), %xmm3
subps %xmm4, %xmm3
movlps %xmm3, 0x18(%rdx)
leal (,%rdi,4), %esi
movsd (%rcx,%rdi,8), %xmm3
mulps %xmm3, %xmm1
movsd (%r15,%rdi,8), %xmm4
addps %xmm1, %xmm4
movlps %xmm4, (%rdx,%rsi,8)
mulps %xmm3, %xmm2
movsd (%r15,%rdi,8), %xmm3
addps %xmm2, %xmm3
movlps %xmm3, 0x8(%rdx,%rsi,8)
movsd (%r15,%rdi,8), %xmm3
subps %xmm2, %xmm3
movlps %xmm3, 0x10(%rdx,%rsi,8)
movsd (%r15,%rdi,8), %xmm2
subps %xmm1, %xmm2
movlps %xmm2, 0x18(%rdx,%rsi,8)
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
shufps $0x0, %xmm9, %xmm9      # xmm9 = xmm9[0,0,0,0]
pushq $0x1
popq %rsi
xorl %edi, %edi
movaps 0x3e612(%rip), %xmm1    # 0x665c0
movss 0x3e8b2(%rip), %xmm2    # 0x66868
movss 0x3e876(%rip), %xmm3    # 0x66834
movss 0x3e8a6(%rip), %xmm4    # 0x6686c
movq 0x30(%rsp), %r8
leaq (%r14,%rsi), %r9
cmpq $0x1, %r9
je 0x280fd
leaq 0x4(%r8), %r9
cmpq %rsi, 0x10(%rsp)
movq %rsi, %r10
cmoveq %rdi, %r10
cmoveq 0x30(%rsp), %r9
movsd -0x8(%rcx,%rsi,8), %xmm6
movsd (%rcx,%r10,8), %xmm5
addps %xmm6, %xmm5
mulps %xmm1, %xmm5
movaps %xmm5, %xmm7
mulps %xmm5, %xmm7
shufps $0x55, %xmm7, %xmm7     # xmm7 = xmm7[1,1,1,1]
movaps %xmm5, %xmm6
mulss %xmm5, %xmm6
addss %xmm7, %xmm6
ucomiss %xmm2, %xmm6
jbe 0x28030
movaps %xmm3, %xmm7
divss %xmm6, %xmm7
movaps %xmm4, %xmm6
minss %xmm7, %xmm6
shufps $0x0, %xmm6, %xmm6      # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm5
movq %r10, %r11
shlq $0x5, %r11
movaps %xmm0, %xmm6
mulps %xmm5, %xmm6
movsd (%r15,%r10,8), %xmm7
addps %xmm6, %xmm7
movlps %xmm7, (%rdx,%r11)
mulps %xmm9, %xmm5
movsd (%r15,%r10,8), %xmm7
addps %xmm5, %xmm7
movlps %xmm7, 0x8(%rdx,%r11)
movsd (%r15,%r10,8), %xmm7
subps %xmm5, %xmm7
movlps %xmm7, 0x10(%rdx,%r11)
movsd (%r15,%r10,8), %xmm5
subps %xmm6, %xmm5
movlps %xmm5, 0x18(%rdx,%r11)
leal 0x1(%r9), %r10d
movw %r10w, (%r13)
leal 0x1(%r8), %r11d
movw %r11w, 0x2(%r13)
leal 0x2(%r8), %ebx
movw %bx, 0x4(%r13)
movw %bx, 0x6(%r13)
leal 0x2(%r9), %ebp
movw %bp, 0x8(%r13)
movw %r10w, 0xa(%r13)
movw %r10w, 0xc(%r13)
movw %r11w, 0xe(%r13)
movw %r8w, 0x10(%r13)
movw %r8w, 0x12(%r13)
movw %r9w, 0x14(%r13)
movw %r10w, 0x16(%r13)
movw %bp, 0x18(%r13)
movw %bx, 0x1a(%r13)
addl $0x3, %r8d
movw %r8w, 0x1c(%r13)
movw %r8w, 0x1e(%r13)
leal 0x3(%r9), %r8d
movw %r8w, 0x20(%r13)
movw %bp, 0x22(%r13)
addq $0x24, %r13
incq %rsi
movq %r9, %r8
jmp 0x27fcb
movq 0x10(%rsp), %r13
leaq (%rcx,%r13,8), %rbx
addq $0x18, %rbx
shlq $0x5, %r13
xorl %r14d, %r14d
movq 0x70(%rsp), %r15
cmpq %r14, %r13
je 0x2838f
movsd 0x90(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movsd -0x18(%rbx,%r14), %xmm0
movq %rax, %rdi
movq %r15, %rsi
movaps 0x20(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x28470
movsd -0x10(%rbx,%r14), %xmm0
movq %rax, %rdi
movq %r15, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x28470
movsd -0x8(%rbx,%r14), %xmm0
movq %rax, %rdi
movq %r15, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x28470
movsd (%rbx,%r14), %xmm0
movq %rax, %rdi
movq %r15, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x28470
addq $0x20, %r14
jmp 0x28116
movsd (%rcx), %xmm0
movsd (%r15), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, (%rdx)
movsd (%r15), %xmm1
subps %xmm0, %xmm1
movlps %xmm1, 0x8(%rdx)
leal (%rdi,%rdi), %esi
movsd (%rcx,%rdi,8), %xmm0
movsd (%r15,%rdi,8), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, (%rdx,%rsi,8)
movsd (%r15,%rdi,8), %xmm1
subps %xmm0, %xmm1
movlps %xmm1, 0x8(%rdx,%rsi,8)
pushq $0x1
popq %rsi
xorl %edi, %edi
movaps 0x3e3c1(%rip), %xmm0    # 0x665c0
movss 0x3e661(%rip), %xmm1    # 0x66868
movss 0x3e625(%rip), %xmm2    # 0x66834
movss 0x3e655(%rip), %xmm3    # 0x6686c
movq 0x30(%rsp), %r8
leaq (%r14,%rsi), %r9
cmpq $0x1, %r9
je 0x28300
leaq 0x3(%r8), %r9
cmpq %rsi, 0x10(%rsp)
movq %rsi, %r10
cmoveq %rdi, %r10
cmoveq 0x30(%rsp), %r9
movsd -0x8(%rcx,%rsi,8), %xmm5
movsd (%rcx,%r10,8), %xmm4
addps %xmm5, %xmm4
mulps %xmm0, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6     # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
ucomiss %xmm1, %xmm5
jbe 0x28281
movaps %xmm2, %xmm6
divss %xmm5, %xmm6
movaps %xmm3, %xmm5
minss %xmm6, %xmm5
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
mulps %xmm5, %xmm4
movq %r10, %r11
shlq $0x4, %r11
movsd (%r15,%r10,8), %xmm5
addps %xmm4, %xmm5
movlps %xmm5, (%rdx,%r11)
movsd (%r15,%r10,8), %xmm5
subps %xmm4, %xmm5
movlps %xmm5, 0x8(%rdx,%r11)
movw %r9w, (%r13)
movw %r8w, 0x2(%r13)
leal 0x2(%r8), %r10d
movw %r10w, 0x4(%r13)
movw %r10w, 0x6(%r13)
leal 0x2(%r9), %r10d
movw %r10w, 0x8(%r13)
movw %r9w, 0xa(%r13)
leal 0x1(%r9), %r10d
movw %r10w, 0xc(%r13)
leal 0x1(%r8), %r11d
movw %r11w, 0xe(%r13)
movw %r8w, 0x10(%r13)
movw %r8w, 0x12(%r13)
movw %r9w, 0x14(%r13)
movw %r10w, 0x16(%r13)
addq $0x18, %r13
incq %rsi
movq %r9, %r8
jmp 0x2821c
movq 0x10(%rsp), %rbp
leaq (%rcx,%rbp,8), %rbx
addq $0x8, %rbx
shlq $0x3, %rbp
xorl %r14d, %r14d
movq 0x70(%rsp), %r13
cmpq %r14, %rbp
je 0x2838f
movsd 0x90(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movsd (%r15,%r14), %xmm0
movq %rax, %rdi
movq %r13, %rsi
movaps 0x20(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x28470
movsd -0x8(%rbx,%r14,2), %xmm0
movq %rax, %rdi
movq %r13, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x28470
movsd (%rbx,%r14,2), %xmm0
movq %rax, %rdi
movq %r13, %rsi
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x28470
addq $0x8, %r14
jmp 0x28319
movq 0xb8(%r12), %rdi
xorl %esi, %esi
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12850