// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: domost
static void domost (float x0, float y0, float x1, float y1, int polymethod)
{
	double dpx[4], dpy[4];
	float d, f, n, t, slop, dx, dx0, dx1, nx, nx0, ny0, nx1, ny1;
	float spx[4], spy[4], cy[2], cv[2];
	int i, j, k, z, ni, vcnt = 0, scnt, newi, dir, spt[4];

#ifdef DEBUGGINGAIDS
	polymostcallcounts.domost++;
#endif
	polymethod |= METH_LAYERS;

	if (x0 < x1)
	{
		dir = 1; //clip dmost (floor)
		y0 -= .01; y1 -= .01;
	}
	else
	{
		if (x0 == x1) return;
		f = x0; x0 = x1; x1 = f;
		f = y0; y0 = y1; y1 = f;
		dir = 0; //clip umost (ceiling)
		//y0 += .01; y1 += .01; //necessary?
	}

	slop = (y1-y0)/(x1-x0);
	for(i=vsp[0].n;i;i=newi)
	{
		newi = vsp[i].n; nx0 = vsp[i].x; nx1 = vsp[newi].x;
		if ((x0 >= nx1) || (nx0 >= x1) || (vsp[i].ctag <= 0)) continue;
		dx = nx1-nx0;
		cy[0] = vsp[i].cy[0]; cv[0] = vsp[i].cy[1]-cy[0];
		cy[1] = vsp[i].fy[0]; cv[1] = vsp[i].fy[1]-cy[1];

		scnt = 0;

			//Test if left edge requires split (x0,y0) (nx0,cy(0)),<dx,cv(0)>
		if ((x0 > nx0) && (x0 < nx1))
		{
			t = (x0-nx0)*cv[dir] - (y0-cy[dir])*dx;
			if (((!dir) && (t < 0)) || ((dir) && (t > 0)))
				{ spx[scnt] = x0; spy[scnt] = y0; spt[scnt] = -1; scnt++; }
		}

			//Test for intersection on umost (j == 0) and dmost (j == 1)
		for(j=0;j<2;j++)
		{
			d = (y0-y1)*dx - (x0-x1)*cv[j];
			n = (y0-cy[j])*dx - (x0-nx0)*cv[j];
			if ((fabs(n) <= fabs(d)) && (d*n >= 0) && (d != 0))
			{
				t = n/d; nx = (x1-x0)*t + x0;
				if ((nx > nx0) && (nx < nx1))
				{
					spx[scnt] = nx; spy[scnt] = (y1-y0)*t + y0;
					spt[scnt] = j; scnt++;
				}
			}
		}

			//Nice hack to avoid full sort later :)
		if ((scnt >= 2) && (spx[scnt-1] < spx[scnt-2]))
		{
			f = spx[scnt-1]; spx[scnt-1] = spx[scnt-2]; spx[scnt-2] = f;
			f = spy[scnt-1]; spy[scnt-1] = spy[scnt-2]; spy[scnt-2] = f;
			j = spt[scnt-1]; spt[scnt-1] = spt[scnt-2]; spt[scnt-2] = j;
		}

			//Test if right edge requires split
		if ((x1 > nx0) && (x1 < nx1))
		{
			t = (x1-nx0)*cv[dir] - (y1-cy[dir])*dx;
			if (((!dir) && (t < 0)) || ((dir) && (t > 0)))
				{ spx[scnt] = x1; spy[scnt] = y1; spt[scnt] = -1; scnt++; }
		}

		vsp[i].tag = vsp[newi].tag = -1;
		for(z=0;z<=scnt;z++,i=vcnt)
		{
			if (z < scnt)
			{
				vcnt = vsinsaft(i);
				t = (spx[z]-nx0)/dx;
				vsp[i].cy[1] = t*cv[0] + cy[0];
				vsp[i].fy[1] = t*cv[1] + cy[1];
				vsp[vcnt].x = spx[z];
				vsp[vcnt].cy[0] = vsp[i].cy[1];
				vsp[vcnt].fy[0] = vsp[i].fy[1];
				vsp[vcnt].tag = spt[z];
			}

			ni = vsp[i].n; if (!ni) continue; //this 'if' fixes many bugs!
			dx0 = vsp[i].x; if (x0 > dx0) continue;
			dx1 = vsp[ni].x; if (x1 < dx1) continue;
			ny0 = (dx0-x0)*slop + y0;
			ny1 = (dx1-x0)*slop + y0;

				//      dx0           dx1
				//       ~             ~
				//----------------------------
				//     t0+=0         t1+=0
				//   vsp[i].cy[0]  vsp[i].cy[1]
				//============================
				//     t0+=1         t1+=3
				//============================
				//   vsp[i].fy[0]    vsp[i].fy[1]
				//     t0+=2         t1+=6
				//
				//     ny0 ?         ny1 ?

			k = 1+3;
			if ((vsp[i].tag == 0) || (ny0 <= vsp[i].cy[0]+.01)) k--;
			if ((vsp[i].tag == 1) || (ny0 >= vsp[i].fy[0]-.01)) k++;
			if ((vsp[ni].tag == 0) || (ny1 <= vsp[i].cy[1]+.01)) k -= 3;
			if ((vsp[ni].tag == 1) || (ny1 >= vsp[i].fy[1]-.01)) k += 3;

			if (!dir)
			{
				switch(k)
				{
					case 1: case 2:
						dpx[0] = dx0; dpy[0] = vsp[i].cy[0];
						dpx[1] = dx1; dpy[1] = vsp[i].cy[1];
						dpx[2] = dx0; dpy[2] = ny0; drawpoly(dpx,dpy,3,polymethod);
						vsp[i].cy[0] = ny0; vsp[i].ctag = gtag; break;
					case 3: case 6:
						dpx[0] = dx0; dpy[0] = vsp[i].cy[0];
						dpx[1] = dx1; dpy[1] = vsp[i].cy[1];
						dpx[2] = dx1; dpy[2] = ny1; drawpoly(dpx,dpy,3,polymethod);
						vsp[i].cy[1] = ny1; vsp[i].ctag = gtag; break;
					case 4: case 5: case 7:
						dpx[0] = dx0; dpy[0] = vsp[i].cy[0];
						dpx[1] = dx1; dpy[1] = vsp[i].cy[1];
						dpx[2] = dx1; dpy[2] = ny1;
						dpx[3] = dx0; dpy[3] = ny0; drawpoly(dpx,dpy,4,polymethod);
						vsp[i].cy[0] = ny0; vsp[i].cy[1] = ny1; vsp[i].ctag = gtag; break;
					case 8:
						dpx[0] = dx0; dpy[0] = vsp[i].cy[0];
						dpx[1] = dx1; dpy[1] = vsp[i].cy[1];
						dpx[2] = dx1; dpy[2] = vsp[i].fy[1];
						dpx[3] = dx0; dpy[3] = vsp[i].fy[0]; drawpoly(dpx,dpy,4,polymethod);
						vsp[i].ctag = vsp[i].ftag = -1; break;
					default: break;
				}
			}
			else
			{
				switch(k)
				{
					case 7: case 6:
						dpx[0] = dx0; dpy[0] = ny0;
						dpx[1] = dx1; dpy[1] = vsp[i].fy[1];
						dpx[2] = dx0; dpy[2] = vsp[i].fy[0]; drawpoly(dpx,dpy,3,polymethod);
						vsp[i].fy[0] = ny0; vsp[i].ftag = gtag; break;
					case 5: case 2:
						dpx[0] = dx0; dpy[0] = vsp[i].fy[0];
						dpx[1] = dx1; dpy[1] = ny1;
						dpx[2] = dx1; dpy[2] = vsp[i].fy[1]; drawpoly(dpx,dpy,3,polymethod);
						vsp[i].fy[1] = ny1; vsp[i].ftag = gtag; break;
					case 4: case 3: case 1:
						dpx[0] = dx0; dpy[0] = ny0;
						dpx[1] = dx1; dpy[1] = ny1;
						dpx[2] = dx1; dpy[2] = vsp[i].fy[1];
						dpx[3] = dx0; dpy[3] = vsp[i].fy[0]; drawpoly(dpx,dpy,4,polymethod);
						vsp[i].fy[0] = ny0; vsp[i].fy[1] = ny1; vsp[i].ftag = gtag; break;
					case 0:
						dpx[0] = dx0; dpy[0] = vsp[i].cy[0];
						dpx[1] = dx1; dpy[1] = vsp[i].cy[1];
						dpx[2] = dx1; dpy[2] = vsp[i].fy[1];
						dpx[3] = dx0; dpy[3] = vsp[i].fy[0]; drawpoly(dpx,dpy,4,polymethod);
						vsp[i].ctag = vsp[i].ftag = -1; break;
					default: break;
				}
			}
		}
	}

	gtag++;

		//Combine neighboring vertical strips with matching collinear top&bottom edges
		//This prevents x-splits from propagating through the entire scan
	i = vsp[0].n;
	while (i)
	{
		ni = vsp[i].n;
		if ((vsp[i].cy[0] >= vsp[i].fy[0]) && (vsp[i].cy[1] >= vsp[i].fy[1])) { vsp[i].ctag = vsp[i].ftag = -1; }
		if ((vsp[i].ctag == vsp[ni].ctag) && (vsp[i].ftag == vsp[ni].ftag))
			{ vsp[i].cy[1] = vsp[ni].cy[1]; vsp[i].fy[1] = vsp[ni].fy[1]; vsdel(ni); }
		else i = ni;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movl %edi, 0x8(%rsp)
ucomiss %xmm0, %xmm2
jbe 0x5edef
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
cvtps2pd %xmm3, %xmm1
addpd 0x1ba17(%rip), %xmm1    # 0x7a7e0
cvtpd2ps %xmm1, %xmm1
leaq 0x4(%rsp), %rax
movq %rax, 0x100(%rsp)
movq %rsp, %rax
movq %rax, 0xf8(%rsp)
movaps %xmm2, %xmm9
movaps %xmm0, %xmm10
jmp 0x5ee25
ucomiss %xmm2, %xmm0
jne 0x5edfa
jnp 0x5f826
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
leaq 0x8c(%rsp), %rax
movq %rax, 0x100(%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0xf8(%rsp)
movaps %xmm0, %xmm9
movaps %xmm2, %xmm10
movl 0x5afdc9(%rip), %eax    # 0x60ebf4
testl %eax, %eax
je 0x5f820
orl $0x8, 0x8(%rsp)
movapd %xmm1, %xmm5
movapd %xmm1, %xmm12
shufps $0x55, %xmm1, %xmm12    # xmm12 = xmm12[1,1],xmm1[1,1]
subss %xmm12, %xmm1
movaps %xmm9, %xmm13
subss %xmm10, %xmm13
movaps %xmm1, %xmm3
divss %xmm13, %xmm3
movaps %xmm12, %xmm14
movaps %xmm10, %xmm4
subss %xmm9, %xmm4
xorps 0x15280(%rip), %xmm4    # 0x740f0
movaps %xmm4, 0x140(%rsp)
subss %xmm5, %xmm14
movaps %xmm10, %xmm4
shufps $0x0, %xmm10, %xmm4     # xmm4 = xmm4[0,0],xmm10[0,0]
movaps %xmm4, 0x150(%rsp)
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
movaps %xmm3, 0x160(%rsp)
xorl %r15d, %r15d
leaq 0x5afd3c(%rip), %r12    # 0x60ebe0
xorps %xmm15, %xmm15
leaq 0x4(%rsp), %r10
movq %rsp, %r11
movss %xmm2, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movaps %xmm1, 0xc0(%rsp)
movss %xmm9, 0x10(%rsp)
movaps %xmm10, 0xb0(%rsp)
movss %xmm5, 0x10c(%rsp)
movaps %xmm12, 0xa0(%rsp)
movss %xmm13, 0xc(%rsp)
movaps %xmm14, 0x90(%rsp)
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rcx
movslq 0x14(%r12,%rcx,8), %rdx
movq %rdx, 0x138(%rsp)
leaq (%rdx,%rdx,4), %rdx
movss (%r12,%rdx,8), %xmm7
ucomiss %xmm7, %xmm10
jae 0x5f755
movss (%r12,%rcx,8), %xmm3
movss %xmm3, 0x1c(%rsp)
ucomiss %xmm9, %xmm3
jae 0x5f755
leaq (%r12,%rcx,8), %rcx
cmpl $0x0, 0x20(%rcx)
jle 0x5f755
movaps %xmm7, %xmm4
movss 0x1c(%rsp), %xmm3
subss %xmm3, %xmm4
movaps %xmm4, 0x50(%rsp)
movss 0x4(%rcx), %xmm4
movss %xmm4, 0x8c(%rsp)
movss 0x8(%rcx), %xmm5
movss %xmm4, 0x11c(%rsp)
subss %xmm4, %xmm5
movss %xmm5, 0x118(%rsp)
movss %xmm5, 0x88(%rsp)
movss 0xc(%rcx), %xmm4
movss %xmm4, 0x4(%rsp)
movss 0x10(%rcx), %xmm5
movss %xmm4, 0x114(%rsp)
subss %xmm4, %xmm5
xorl %esi, %esi
ucomiss %xmm3, %xmm10
movss %xmm5, 0x110(%rsp)
movss %xmm5, (%rsp)
movaps %xmm10, %xmm8
subss %xmm3, %xmm8
movl $0x0, %ebx
jbe 0x5f04b
ucomiss %xmm10, %xmm7
movl $0x0, %ebx
jbe 0x5f04b
movaps %xmm12, %xmm4
movq 0x100(%rsp), %rdi
subss (%rdi), %xmm4
mulss 0x50(%rsp), %xmm4
movq 0xf8(%rsp), %rdi
movss (%rdi), %xmm3
mulss %xmm8, %xmm3
subss %xmm4, %xmm3
xorl %edi, %edi
ucomiss %xmm3, %xmm15
setbe %dil
xorl %r8d, %r8d
ucomiss %xmm15, %xmm3
setbe %r8b
ucomiss %xmm0, %xmm2
cmoval %r8d, %edi
movl $0x0, %ebx
testb %dil, %dil
jne 0x5f04b
movss %xmm10, 0xe0(%rsp)
movss %xmm12, 0x120(%rsp)
movl $0xffffffff, 0xd0(%rsp) # imm = 0xFFFFFFFF
movl $0x1, %ebx
leaq (%r12,%rdx,8), %rdx
xorps 0x15099(%rip), %xmm8    # 0x740f0
movaps 0x50(%rsp), %xmm6
shufps $0x0, %xmm6, %xmm6      # xmm6 = xmm6[0,0,0,0]
unpcklps 0x140(%rsp), %xmm8      # xmm8 = xmm8[0],mem[0],xmm8[1],mem[1]
movb $0x1, %dil
leaq 0x88(%rsp), %r8
leaq 0x8c(%rsp), %r9
movaps %xmm12, %xmm4
subss (%r9), %xmm4
unpcklps %xmm14, %xmm4           # xmm4 = xmm4[0],xmm14[0],xmm4[1],xmm14[1]
mulps %xmm6, %xmm4
movss (%r8), %xmm3
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
mulps %xmm8, %xmm3
addps %xmm4, %xmm3
movaps %xmm3, %xmm4
andps 0x1a6aa(%rip), %xmm4    # 0x79750
pshufd $0x55, %xmm4, %xmm5     # xmm5 = xmm4[1,1,1,1]
ucomiss %xmm4, %xmm5
jae 0x5f0c8
movl $0x1, %esi
movq %r11, %r8
movq %r10, %r9
testb $0x1, %dil
movl $0x0, %edi
jne 0x5f07c
jmp 0x5f12a
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
ucomiss %xmm15, %xmm4
jne 0x5f0d7
jnp 0x5f0b0
movaps %xmm4, %xmm5
mulss %xmm3, %xmm5
ucomiss %xmm15, %xmm5
jb 0x5f0b0
divss %xmm4, %xmm3
movaps %xmm13, %xmm4
mulss %xmm3, %xmm4
addss %xmm10, %xmm4
ucomiss 0x1c(%rsp), %xmm4
jbe 0x5f0b0
ucomiss %xmm4, %xmm7
jbe 0x5f0b0
movslq %ebx, %rbx
movss %xmm4, 0xe0(%rsp,%rbx,4)
mulss %xmm1, %xmm3
addss %xmm12, %xmm3
movss %xmm3, 0x120(%rsp,%rbx,4)
movl %esi, 0xd0(%rsp,%rbx,4)
incl %ebx
jmp 0x5f0b0
cmpl $0x2, %ebx
jl 0x5f1a2
leal -0x1(%rbx), %esi
movss 0xe0(%rsp,%rsi,4), %xmm4
leal -0x2(%rbx), %edi
movss 0xe0(%rsp,%rdi,4), %xmm3
ucomiss %xmm4, %xmm3
jbe 0x5f1a2
movss %xmm3, 0xe0(%rsp,%rsi,4)
movss %xmm4, 0xe0(%rsp,%rdi,4)
movss 0x120(%rsp,%rsi,4), %xmm4
movss 0x120(%rsp,%rdi,4), %xmm3
movss %xmm3, 0x120(%rsp,%rsi,4)
movss %xmm4, 0x120(%rsp,%rdi,4)
movl 0xd0(%rsp,%rsi,4), %r8d
movl 0xd0(%rsp,%rdi,4), %r9d
movl %r9d, 0xd0(%rsp,%rsi,4)
movl %r8d, 0xd0(%rsp,%rdi,4)
ucomiss 0x1c(%rsp), %xmm9
movaps 0x50(%rsp), %xmm8
jbe 0x5f22f
ucomiss %xmm9, %xmm7
jbe 0x5f22f
movaps %xmm9, %xmm3
subss 0x1c(%rsp), %xmm3
movss 0x10c(%rsp), %xmm5
movaps %xmm5, %xmm4
movq 0x100(%rsp), %rsi
subss (%rsi), %xmm4
mulss %xmm8, %xmm4
movq 0xf8(%rsp), %rsi
mulss (%rsi), %xmm3
subss %xmm4, %xmm3
xorl %esi, %esi
ucomiss %xmm3, %xmm15
setbe %sil
xorl %edi, %edi
ucomiss %xmm15, %xmm3
setbe %dil
ucomiss %xmm0, %xmm2
cmoval %edi, %esi
testb %sil, %sil
jne 0x5f22f
movslq %ebx, %rsi
movss %xmm9, 0xe0(%rsp,%rsi,4)
movss %xmm5, 0x120(%rsp,%rsi,4)
movl $0xffffffff, 0xd0(%rsp,%rsi,4) # imm = 0xFFFFFFFF
incl %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %esi, 0x1c(%rdx)
movl %esi, 0x1c(%rcx)
testl %ebx, %ebx
js 0x5f755
movl %ebx, %r14d
incl %ebx
xorl %r13d, %r13d
cmpq %r14, %r13
jae 0x5f32c
movslq 0x5d7972(%rip), %rcx    # 0x636bcc
leaq (%rcx,%rcx,4), %rdx
movslq 0x14(%r12,%rdx,8), %rsi
leaq (%rsi,%rsi,4), %rdi
movl $0xfff, 0x18(%r12,%rdi,8) # imm = 0xFFF
movl %esi, 0x5d7956(%rip)    # 0x636bcc
cltq
leaq (%rax,%rax,4), %rsi
movups (%r12,%rsi,8), %xmm3
movups 0x10(%r12,%rsi,8), %xmm4
movups %xmm4, 0x10(%r12,%rdx,8)
movq 0x20(%r12,%rsi,8), %rdi
movq %rdi, 0x20(%r12,%rdx,8)
movups %xmm3, (%r12,%rdx,8)
movl %eax, 0x18(%r12,%rdx,8)
movslq 0x14(%r12,%rsi,8), %rdi
movl %edi, 0x14(%r12,%rdx,8)
leaq (%rdi,%rdi,4), %rdi
movl %ecx, 0x18(%r12,%rdi,8)
movl %ecx, 0x14(%r12,%rsi,8)
movss 0xe0(%rsp,%r13,4), %xmm4
movaps %xmm4, %xmm5
subss 0x1c(%rsp), %xmm5
divss %xmm8, %xmm5
movaps %xmm5, %xmm3
mulss 0x118(%rsp), %xmm3
addss 0x11c(%rsp), %xmm3
movss %xmm3, 0x8(%r12,%rsi,8)
mulss 0x110(%rsp), %xmm5
addss 0x114(%rsp), %xmm5
movss %xmm5, 0x10(%r12,%rsi,8)
movss %xmm4, (%r12,%rdx,8)
movss %xmm3, 0x4(%r12,%rdx,8)
movss %xmm5, 0xc(%r12,%rdx,8)
movl 0xd0(%rsp,%r13,4), %esi
movl %esi, 0x1c(%r12,%rdx,8)
movl %ecx, %r15d
jmp 0x5f337
cltq
leaq (%rax,%rax,4), %rcx
movl 0x14(%r12,%rcx,8), %ecx
testl %ecx, %ecx
je 0x5f746
leaq (%rax,%rax,4), %rax
leaq (%r12,%rax,8), %rbp
movss (%rbp), %xmm6
ucomiss %xmm6, %xmm10
ja 0x5f746
movslq %ecx, %rax
leaq (%rax,%rax,4), %rcx
movss (%r12,%rcx,8), %xmm7
ucomiss %xmm9, %xmm7
ja 0x5f746
movaps %xmm6, %xmm5
unpcklps %xmm7, %xmm5            # xmm5 = xmm5[0],xmm7[0],xmm5[1],xmm7[1]
movaps %xmm5, %xmm11
subps 0x150(%rsp), %xmm11
mulps 0x160(%rsp), %xmm11
addps %xmm12, %xmm11
movl 0x1c(%rbp), %edx
testl %edx, %edx
je 0x5f3b7
xorps %xmm3, %xmm3
cvtss2sd %xmm11, %xmm3
xorps %xmm4, %xmm4
cvtss2sd 0x4(%rbp), %xmm4
addsd 0x1a3b4(%rip), %xmm4    # 0x79760
movl $0x4, %eax
ucomisd %xmm3, %xmm4
jb 0x5f3bc
movl $0x3, %eax
cmpl $0x1, %edx
je 0x5f3df
xorps %xmm3, %xmm3
cvtss2sd 0xc(%rbp), %xmm3
xorps %xmm4, %xmm4
cvtss2sd %xmm11, %xmm4
addsd 0x1b587(%rip), %xmm3    # 0x7a960
ucomisd %xmm3, %xmm4
jb 0x5f3e1
incl %eax
leaq (%r12,%rcx,8), %rcx
movl 0x1c(%rcx), %ecx
movaps %xmm11, %xmm4
shufps $0x55, %xmm11, %xmm4    # xmm4 = xmm4[1,1],xmm11[1,1]
testl %ecx, %ecx
je 0x5f419
xorps %xmm3, %xmm3
cvtss2sd 0x8(%rbp), %xmm3
xorps %xmm15, %xmm15
cvtss2sd %xmm4, %xmm15
addsd 0x1a352(%rip), %xmm3    # 0x79760
ucomisd %xmm15, %xmm3
xorps %xmm15, %xmm15
jb 0x5f41c
addl $-0x3, %eax
cmpl $0x1, %ecx
je 0x5f445
xorps %xmm3, %xmm3
cvtss2sd 0x10(%rbp), %xmm3
xorps %xmm15, %xmm15
cvtss2sd %xmm4, %xmm15
addsd 0x1b526(%rip), %xmm3    # 0x7a960
ucomisd %xmm3, %xmm15
xorps %xmm15, %xmm15
jb 0x5f448
addl $0x3, %eax
ucomiss %xmm0, %xmm2
jbe 0x5f4bb
cmpl $0x7, %eax
ja 0x5f746
movl %eax, %eax
leaq 0x1b551(%rip), %rcx     # 0x7a9b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtps2pd %xmm5, %xmm0
movaps %xmm11, 0x40(%rsp)
cvtps2pd %xmm11, %xmm1
movaps %xmm1, 0x60(%rsp)
movaps %xmm0, 0x20(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x30(%rsp)
cvtps2pd 0xc(%rbp), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x4, %edx
movl 0x8(%rsp), %ecx
callq 0x5114d
movaps 0x40(%rsp), %xmm0
movlps %xmm0, 0xc(%rbp)
jmp 0x5f638
decl %eax
cmpl $0x7, %eax
ja 0x5f746
leaq 0x1b4c3(%rip), %rcx     # 0x7a990
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtps2pd %xmm5, %xmm0
cvtps2pd 0x4(%rbp), %xmm1
movaps %xmm1, 0x60(%rsp)
movaps %xmm0, 0x20(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x30(%rsp)
movaps %xmm11, 0x40(%rsp)
cvtps2pd %xmm11, %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x4, %edx
movl 0x8(%rsp), %ecx
callq 0x5114d
movaps 0x40(%rsp), %xmm0
movlps %xmm0, 0x4(%rbp)
jmp 0x5f6ee
cvtss2sd %xmm6, %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm7, %xmm0
movss 0xc(%rbp), %xmm1
movsd %xmm0, 0x28(%rsp)
movss %xmm1, %xmm11           # xmm11 = xmm1[0],xmm11[1,2,3]
cvtps2pd %xmm11, %xmm1
movaps %xmm1, 0x60(%rsp)
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rbp), %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x3, %edx
movl 0x8(%rsp), %ecx
movaps %xmm4, 0x40(%rsp)
callq 0x5114d
movaps 0x40(%rsp), %xmm0
movss %xmm0, 0x10(%rbp)
jmp 0x5f638
cvtps2pd %xmm5, %xmm0
cvtps2pd 0x4(%rbp), %xmm1
movaps %xmm1, 0x60(%rsp)
movaps %xmm0, 0x20(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x30(%rsp)
cvtps2pd 0xc(%rbp), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x4, %edx
movl 0x8(%rsp), %ecx
callq 0x5114d
movq $-0x1, 0x20(%rbp)
jmp 0x5f6f7
cvtps2pd %xmm5, %xmm0
movaps %xmm0, 0x20(%rsp)
movss 0x10(%rbp), %xmm1
movaps %xmm11, 0x40(%rsp)
movlhps %xmm11, %xmm1           # xmm1 = xmm1[0],xmm11[0]
shufps $0xe2, %xmm11, %xmm1    # xmm1 = xmm1[2,0],xmm11[2,3]
cvtps2pd %xmm1, %xmm1
movaps %xmm1, 0x60(%rsp)
movlps %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rbp), %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x3, %edx
movl 0x8(%rsp), %ecx
callq 0x5114d
movaps 0x40(%rsp), %xmm0
movss %xmm0, 0xc(%rbp)
movl 0x5d75a2(%rip), %eax    # 0x636be0
movl %eax, 0x24(%rbp)
jmp 0x5f6f7
cvtps2pd %xmm5, %xmm0
movaps %xmm0, 0x20(%rsp)
cvtps2pd 0x4(%rbp), %xmm1
movaps %xmm1, 0x60(%rsp)
movlps %xmm0, 0x30(%rsp)
movaps %xmm11, 0x40(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm11, %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x3, %edx
movl 0x8(%rsp), %ecx
callq 0x5114d
movaps 0x40(%rsp), %xmm0
movss %xmm0, 0x4(%rbp)
jmp 0x5f6ee
cvtss2sd %xmm6, %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm7, %xmm0
movsd %xmm0, 0x28(%rsp)
cvtps2pd 0x4(%rbp), %xmm1
movaps %xmm1, 0x60(%rsp)
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm4, %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x3, %edx
movl 0x8(%rsp), %ecx
movaps %xmm4, 0x40(%rsp)
callq 0x5114d
movaps 0x40(%rsp), %xmm0
movss %xmm0, 0x8(%rbp)
movl 0x5d74ec(%rip), %eax    # 0x636be0
movl %eax, 0x20(%rbp)
movss 0x18(%rsp), %xmm2
movss 0x14(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movss 0x10(%rsp), %xmm9
movaps 0xb0(%rsp), %xmm10
movaps 0xa0(%rsp), %xmm12
movss 0xc(%rsp), %xmm13
movaps 0x90(%rsp), %xmm14
xorps %xmm15, %xmm15
leaq 0x4(%rsp), %r10
movq %rsp, %r11
movaps 0x50(%rsp), %xmm8
incq %r13
movl %r15d, %eax
cmpq %r13, %rbx
jne 0x5f24a
movq 0x138(%rsp), %rcx
movl %ecx, %eax
testl %ecx, %ecx
jne 0x5eef6
movl 0x5af487(%rip), %eax    # 0x60ebf4
incl 0x5d746d(%rip)          # 0x636be0
testl %eax, %eax
je 0x5f826
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%r12,%rcx,8), %rdx
movss 0x4(%rdx), %xmm0
ucomiss 0xc(%rdx), %xmm0
jb 0x5f7a4
movss 0x8(%rdx), %xmm0
ucomiss 0x10(%rdx), %xmm0
jb 0x5f7a4
movq $-0x1, 0x20(%rdx)
movl 0x14(%r12,%rcx,8), %ecx
movslq %ecx, %rsi
movl 0x20(%rdx), %edi
leaq (%rsi,%rsi,4), %rsi
cmpl 0x20(%r12,%rsi,8), %edi
jne 0x5f819
leaq (%r12,%rsi,8), %rsi
movl 0x24(%rdx), %edi
cmpl 0x24(%rsi), %edi
jne 0x5f819
movss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rdx)
movss 0x10(%rsi), %xmm0
movss %xmm0, 0x10(%rdx)
movslq 0x18(%rsi), %rdx
movslq 0x14(%rsi), %rdi
leaq (%rdi,%rdi,4), %r8
movl %edx, 0x18(%r12,%r8,8)
leaq (%rdx,%rdx,4), %rdx
movl %edi, 0x14(%r12,%rdx,8)
movslq 0x5d73d1(%rip), %rdx    # 0x636bcc
movl %edx, 0x14(%rsi)
movl $0xfff, 0x18(%rsi)      # imm = 0xFFF
leaq (%rdx,%rdx,4), %rdx
movl %ecx, 0x18(%r12,%rdx,8)
movl %ecx, 0x5d73b8(%rip)    # 0x636bcc
jmp 0x5f773
movl %ecx, %eax
jmp 0x5f773
incl 0x5d73ba(%rip)          # 0x636be0
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq