// File: /workspace/github_c_makefile_star2_O3/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 $0xd8, %rsp
testq %rdi, %rdi
je 0x291ce
movaps %xmm0, 0x60(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x90(%rsp)
cmpl $0x2, %edx
jae 0x2920b
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5de1b(%rip), %rbx     # 0x86ff0
movq (%rbx), %rdi
leaq 0x47bbd(%rip), %rsi     # 0x70d9c
leaq 0x47bd4(%rip), %rdx     # 0x70dba
movl $0x26bc, %ecx           # imm = 0x26BC
xorl %eax, %eax
callq 0x12d80
movq (%rbx), %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movl %ecx, %eax
shrl $0x18, %eax
movzbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movq 0x38(%rsp), %rbx
movss 0x70(%rbx), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %edx, %esi
leal -0x1(%rdx), %r13d
testl %r8d, %r8d
movq %rsi, 0x80(%rsp)
movq %rsi, %rdi
cmoveq %r13, %rdi
movl $0xff, %esi
andl %esi, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movd %ecx, %xmm0
shrl $0x10, %ecx
pxor %xmm2, %xmm2
punpcklbw %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3],xmm0[4],xmm2[4],xmm0[5],xmm2[5],xmm0[6],xmm2[6],xmm0[7],xmm2[7]
punpcklwd %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3]
cvtdq2ps %xmm0, %xmm1
movaps 0x44349(%rip), %xmm0    # 0x6d5c0
mulps %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp)
andl %esi, %ecx
shll $0x8, %eax
orl %ecx, %eax
movd %eax, %xmm1
punpcklbw %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3],xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
cvtdq2ps %xmm1, %xmm1
mulps %xmm0, %xmm1
movaps %xmm1, 0x50(%rsp)
movl 0xcc(%rbx), %eax
movq %rax, 0x28(%rsp)
cmpl $0x1, %r9d
movq %rdi, 0x78(%rsp)
jne 0x294ba
movaps 0x60(%rsp), %xmm0
ucomiss 0x445e1(%rip), %xmm0    # 0x6d8a4
leal (,%rdx,4), %eax
movl $0x12, %ecx
movl $0xc, %r12d
cmovaq %rcx, %r12
leal (%rdx,%rdx,2), %esi
cmoval %eax, %esi
imulq %rdi, %r12
movq %rbx, %rdi
movq %rdx, (%rsp)
movl %r8d, %r14d
callq 0x29cac
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29d2b
testq %r15, %r15
je 0x291bc
movq %rax, %r12
testq %rax, %rax
je 0x291bc
xorl %ebp, %ebp
movaps 0x60(%rsp), %xmm0
ucomiss 0x44581(%rip), %xmm0    # 0x6d8a4
seta %bpl
movq 0x38(%rsp), %rbx
movq 0xb8(%rbx), %rdi
movq 0x40(%rdi), %rax
movq %rax, 0x30(%rsp)
xorl %esi, %esi
callq 0x13e70
shll $0x4, %ebp
addq $0x18, %rbp
imulq 0x80(%rsp), %rbp
movq 0xb8(%rbx), %rdi
movl $0x4, %ecx
xorl %esi, %esi
movq %rbp, %rdx
movq %r13, %rbp
callq 0x256b9
movq (%rsp), %r9
testq %rax, %rax
je 0x291bc
movl %r14d, %r10d
movaps 0x50(%rsp), %xmm10
unpcklps 0x44226(%rip), %xmm10   # xmm10 = xmm10[0],mem[0],xmm10[1],mem[1]
subq 0x30(%rsp), %r15
movq 0x80(%rsp), %r13
leaq (%rax,%r13,8), %rcx
movq 0x38(%rsp), %rbx
movq 0xb8(%rbx), %rdx
addq 0x40(%rdx), %r15
movq 0x78(%rsp), %r11
negq %r11
movl $0x1, %edx
xorl %esi, %esi
movss 0x444e2(%rip), %xmm0    # 0x6d8a4
xorps %xmm1, %xmm1
movss 0x44503(%rip), %xmm2    # 0x6d8d0
movss 0x444ff(%rip), %xmm3    # 0x6d8d4
movaps 0x44194(%rip), %xmm4    # 0x6d570
movq 0x90(%rsp), %r14
cmpq %rdx, %r13
movq %rdx, %rdi
cmoveq %rsi, %rdi
movss (%r14,%rdi,8), %xmm6
movss 0x4(%r14,%rdi,8), %xmm5
subss -0x8(%r14,%rdx,8), %xmm6
subss -0x4(%r14,%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 0x29429
jnp 0x29458
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(%rax,%rdx,8)
leaq (%r11,%rdx), %rdi
incq %rdi
incq %rdx
cmpq $0x1, %rdi
jne 0x293e4
testl %r10d, %r10d
movaps %xmm10, 0x40(%rsp)
je 0x2976e
movaps 0x60(%rsp), %xmm8
ucomiss 0x44407(%rip), %xmm8    # 0x6d8a4
jbe 0x29ad0
addss 0x44408(%rip), %xmm8    # 0x6d8b4
mulss 0x443eb(%rip), %xmm8    # 0x6d8a0
jmp 0x2983f
leaq (%rdi,%rdi), %rax
leaq (%rax,%rax,2), %r15
leaq (,%rdi,4), %rsi
movq %rbx, %rdi
callq 0x29cac
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29d2b
movq %rax, %r15
testq %r12, %r12
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x291bc
movaps 0x60(%rsp), %xmm0
mulss 0x44399(%rip), %xmm0    # 0x6d8a0
movaps %xmm0, 0x60(%rsp)
negq 0x78(%rsp)
movl $0x1, %ebp
xorl %r13d, %r13d
movq 0x28(%rsp), %rbx
movq 0x38(%rsp), %r14
cmpq %rbp, 0x80(%rsp)
movl $0x0, %eax
cmovneq %rbp, %rax
movq 0x90(%rsp), %rcx
movss (%rcx,%r13,2), %xmm7
movss 0x4(%rcx,%r13,2), %xmm8
movss (%rcx,%rax,8), %xmm4
movss 0x4(%rcx,%rax,8), %xmm5
movaps %xmm4, 0xb0(%rsp)
movaps %xmm4, %xmm2
subss %xmm7, %xmm2
movaps %xmm5, 0xa0(%rsp)
movaps %xmm5, %xmm3
subss %xmm8, %xmm3
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
movaps %xmm2, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
ucomiss 0x44354(%rip), %xmm0    # 0x6d8e0
movss 0x44310(%rip), %xmm6    # 0x6d8a4
jne 0x29598
jnp 0x295c8
movd %xmm0, %eax
shrl %eax
movl $0x5f375a84, %ecx       # imm = 0x5F375A84
subl %eax, %ecx
movd %ecx, %xmm1
mulss 0x4431f(%rip), %xmm0    # 0x6d8d0
mulss %xmm1, %xmm0
mulss %xmm1, %xmm0
addss 0x44313(%rip), %xmm0    # 0x6d8d4
mulss %xmm1, %xmm0
movaps %xmm0, %xmm6
leaq (%rbx,%r13), %rax
movq %rax, 0x98(%rsp)
movsd 0x90(%r14), %xmm1
movaps %xmm1, 0x40(%rsp)
mulss %xmm6, %xmm2
mulss %xmm6, %xmm3
movaps 0x60(%rsp), %xmm0
mulss %xmm0, %xmm2
movaps %xmm2, (%rsp)
mulss %xmm0, %xmm3
movss %xmm3, 0x30(%rsp)
movaps %xmm7, %xmm0
addss %xmm3, %xmm0
movaps %xmm8, %xmm6
subss %xmm2, %xmm6
unpcklps %xmm6, %xmm0            # xmm0 = xmm0[0],xmm6[0],xmm0[1],xmm6[1]
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
movq %r12, %rdi
movaps %xmm7, 0xc0(%rsp)
movaps 0x10(%rsp), %xmm2
movss %xmm8, 0x8c(%rsp)
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movaps 0xb0(%rsp), %xmm0
addss 0x30(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
subss (%rsp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
movq %rax, %rdi
movaps 0x40(%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movaps 0xb0(%rsp), %xmm0
subss 0x30(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
addss (%rsp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
movq %rax, %rdi
movaps 0x40(%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movaps 0xc0(%rsp), %xmm0
subss 0x30(%rsp), %xmm0
movaps (%rsp), %xmm1
addss 0x8c(%rsp), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
movq %rax, %rdi
movaps 0x40(%rsp), %xmm1
movdqa 0x10(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movq %rax, %r12
movq 0x98(%rsp), %rcx
movw %cx, (%r15)
leal (%rbx,%r13), %eax
incl %eax
movw %ax, 0x2(%r15)
leal 0x2(%rbx,%r13), %eax
movw %ax, 0x4(%r15)
movw %cx, 0x6(%r15)
movw %ax, 0x8(%r15)
leal (%rbx,%r13), %eax
addl $0x3, %eax
movw %ax, 0xa(%r15)
addq $0xc, %r15
addq $0x4, %r13
movq 0x78(%rsp), %rax
addq %rbp, %rax
incq %rax
incq %rbp
cmpq $0x1, %rax
jne 0x29523
jmp 0x291bc
addl $-0x2, %r9d
movaps 0x60(%rsp), %xmm8
ucomiss 0x44124(%rip), %xmm8    # 0x6d8a4
movq (%rax,%r9,8), %rdx
movq %rdx, (%rax,%rbp,8)
jbe 0x29a91
addss 0x4411d(%rip), %xmm8    # 0x6d8b4
mulss 0x44100(%rip), %xmm8    # 0x6d8a0
movss 0x440fc(%rip), %xmm0    # 0x6d8a4
addss %xmm8, %xmm0
movsd (%rax), %xmm2
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movaps %xmm0, %xmm3
mulps %xmm2, %xmm3
movsd (%r14), %xmm1
addps %xmm3, %xmm1
movlps %xmm1, (%rcx)
movaps %xmm8, %xmm1
shufps $0x0, %xmm8, %xmm1      # xmm1 = xmm1[0,0],xmm8[0,0]
mulps %xmm1, %xmm2
movsd (%r14), %xmm4
addps %xmm2, %xmm4
movlps %xmm4, 0x8(%rcx)
movsd (%r14), %xmm4
subps %xmm2, %xmm4
movlps %xmm4, 0x10(%rcx)
movsd (%r14), %xmm2
subps %xmm3, %xmm2
movlps %xmm2, 0x18(%rcx)
leal (,%rbp,4), %edx
movsd (%rax,%rbp,8), %xmm2
mulps %xmm2, %xmm0
movsd (%r14,%rbp,8), %xmm3
addps %xmm0, %xmm3
movlps %xmm3, (%rcx,%rdx,8)
mulps %xmm2, %xmm1
movsd (%r14,%rbp,8), %xmm2
addps %xmm1, %xmm2
movlps %xmm2, 0x8(%rcx,%rdx,8)
movsd (%r14,%rbp,8), %xmm2
subps %xmm1, %xmm2
movlps %xmm2, 0x10(%rcx,%rdx,8)
movsd (%r14,%rbp,8), %xmm1
subps %xmm0, %xmm1
movlps %xmm1, 0x18(%rcx,%rdx,8)
movss 0x4405d(%rip), %xmm0    # 0x6d8a4
addss %xmm8, %xmm0
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
shufps $0x0, %xmm8, %xmm8      # xmm8 = xmm8[0,0,0,0]
movl $0x1, %edx
movaps 0x43d6f(%rip), %xmm1    # 0x6d5d0
movss 0x4406f(%rip), %xmm2    # 0x6d8d8
movss 0x44033(%rip), %xmm3    # 0x6d8a4
movss 0x44063(%rip), %xmm4    # 0x6d8dc
movq 0x28(%rsp), %r8
movq %r11, %rsi
leaq 0x4(%r8), %rdi
cmpq %rdx, %r13
movq %rdx, %r9
movl $0x0, %r10d
cmoveq %r10, %r9
cmoveq 0x28(%rsp), %rdi
movsd -0x8(%rax,%rdx,8), %xmm6
movsd (%rax,%r9,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 0x298dc
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 %r9, %r10
shlq $0x5, %r10
movaps %xmm0, %xmm6
mulps %xmm5, %xmm6
movsd (%r14,%r9,8), %xmm7
addps %xmm6, %xmm7
movlps %xmm7, (%rcx,%r10)
mulps %xmm8, %xmm5
movsd (%r14,%r9,8), %xmm7
addps %xmm5, %xmm7
movlps %xmm7, 0x8(%rcx,%r10)
movsd (%r14,%r9,8), %xmm7
subps %xmm5, %xmm7
movlps %xmm7, 0x10(%rcx,%r10)
movsd (%r14,%r9,8), %xmm5
subps %xmm6, %xmm5
movlps %xmm5, 0x18(%rcx,%r10)
leal 0x1(%rdi), %r9d
movw %r9w, (%r12)
leal 0x1(%r8), %r10d
movw %r10w, 0x2(%r12)
leal 0x2(%r8), %r11d
movw %r11w, 0x4(%r12)
movw %r11w, 0x6(%r12)
leal 0x2(%rdi), %ebp
movw %bp, 0x8(%r12)
movw %r9w, 0xa(%r12)
movw %r9w, 0xc(%r12)
movw %r10w, 0xe(%r12)
movw %r8w, 0x10(%r12)
movw %r8w, 0x12(%r12)
movw %di, 0x14(%r12)
movw %r9w, 0x16(%r12)
movw %bp, 0x18(%r12)
movw %r11w, 0x1a(%r12)
addl $0x3, %r8d
movw %r8w, 0x1c(%r12)
movw %r8w, 0x1e(%r12)
leal 0x3(%rdi), %r8d
movw %r8w, 0x20(%r12)
movw %bp, 0x22(%r12)
addq $0x24, %r12
leaq (%rsi,%rdx), %r9
incq %r9
incq %rdx
movq %rdi, %r8
cmpq $0x1, %r9
jne 0x29881
leaq (%rax,%r13,8), %r14
addq $0x18, %r14
movsd 0x90(%rbx), %xmm1
movaps %xmm1, (%rsp)
movsd -0x18(%r14), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %r15, %rdi
movaps 0x10(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x29d6f
movsd -0x10(%r14), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %rax, %rdi
movaps (%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movsd -0x8(%r14), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %rax, %rdi
movaps (%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movsd (%r14), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %rax, %rdi
movaps (%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x29d6f
movq %rax, %r15
addq $0x20, %r14
decq %r13
jne 0x299cd
jmp 0x29c8d
movsd (%rax), %xmm0
movsd (%r14), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, (%rcx)
movsd (%r14), %xmm1
subps %xmm0, %xmm1
movlps %xmm1, 0x8(%rcx)
leal (%rbp,%rbp), %edx
movsd (%rax,%rbp,8), %xmm0
movsd (%r14,%rbp,8), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, (%rcx,%rdx,8)
movsd (%r14,%rbp,8), %xmm1
subps %xmm0, %xmm1
movlps %xmm1, 0x8(%rcx,%rdx,8)
movl $0x1, %edx
xorl %esi, %esi
movaps 0x43af2(%rip), %xmm0    # 0x6d5d0
movss 0x43df2(%rip), %xmm1    # 0x6d8d8
movss 0x43db6(%rip), %xmm2    # 0x6d8a4
movss 0x43de6(%rip), %xmm3    # 0x6d8dc
movq 0x28(%rsp), %r8
leaq 0x3(%r8), %rdi
cmpq %rdx, %r13
movq %rdx, %r9
cmoveq %rsi, %r9
cmoveq 0x28(%rsp), %rdi
movsd -0x8(%rax,%rdx,8), %xmm5
movsd (%rax,%r9,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 0x29b50
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 %r9, %r10
shlq $0x4, %r10
movsd (%r14,%r9,8), %xmm5
addps %xmm4, %xmm5
movlps %xmm5, (%rcx,%r10)
movsd (%r14,%r9,8), %xmm5
subps %xmm4, %xmm5
movlps %xmm5, 0x8(%rcx,%r10)
movw %di, (%r12)
movw %r8w, 0x2(%r12)
leal 0x2(%r8), %r9d
movw %r9w, 0x4(%r12)
movw %r9w, 0x6(%r12)
leal 0x2(%rdi), %r9d
movw %r9w, 0x8(%r12)
movw %di, 0xa(%r12)
leal 0x1(%rdi), %r9d
movw %r9w, 0xc(%r12)
leal 0x1(%r8), %r10d
movw %r10w, 0xe(%r12)
movw %r8w, 0x10(%r12)
movw %r8w, 0x12(%r12)
movw %di, 0x14(%r12)
movw %r9w, 0x16(%r12)
addq $0x18, %r12
leaq (%r11,%rdx), %r9
incq %r9
incq %rdx
movq %rdi, %r8
cmpq $0x1, %r9
jne 0x29afb
movq %r14, %rbp
leaq (%rax,%r13,8), %r14
addq $0x8, %r14
xorl %r12d, %r12d
movsd 0x90(%rbx), %xmm1
movaps %xmm1, (%rsp)
movsd (%rbp,%r12,8), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %r15, %rdi
movaps 0x10(%rsp), %xmm2
movaps 0x50(%rsp), %xmm3
callq 0x29d6f
movsd -0x8(%r14), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %rax, %rdi
movaps (%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x29d6f
movsd (%r14), %xmm0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %rax, %rdi
movaps (%rsp), %xmm1
movaps 0x10(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
callq 0x29d6f
movq %rax, %r15
incq %r12
addq $0x10, %r14
cmpq %r12, %r13
jne 0x29bf4
movq 0xb8(%rbx), %rdi
xorl %esi, %esi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x127a0