// File: /workspace/github_c_makefile_star2_O2/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 $0x188, %rsp            # imm = 0x188
movl %edi, %ecx
movaps %xmm2, %xmm13
ucomiss %xmm0, %xmm2
jbe 0x54911
leaq 0x74(%rsp), %r12
leaq 0x7c(%rsp), %rbp
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
cvtps2pd %xmm3, %xmm1
addpd 0x1ac1d(%rip), %xmm1    # 0x6f520
cvtpd2ps %xmm1, %xmm1
movaps %xmm13, %xmm9
movaps %xmm0, %xmm10
jmp 0x54940
ucomiss %xmm13, %xmm0
jne 0x5492b
jp 0x5492b
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
leaq 0x78(%rsp), %rbp
leaq 0x70(%rsp), %r12
movaps %xmm0, %xmm9
movaps %xmm13, %xmm10
orl $0x8, %ecx
movapd %xmm1, %xmm11
shufps $0x55, %xmm1, %xmm11    # xmm11 = xmm11[1,1],xmm1[1,1]
movaps %xmm11, %xmm12
subss %xmm1, %xmm12
movaps %xmm1, %xmm3
subss %xmm11, %xmm3
movaps %xmm9, %xmm2
subss %xmm10, %xmm2
movaps %xmm3, 0x150(%rsp)
divss %xmm2, %xmm3
movl 0x5b327a(%rip), %r14d   # 0x607bf4
movaps %xmm10, %xmm4
subss %xmm9, %xmm4
xorps 0x19b46(%rip), %xmm4    # 0x6e4d0
movaps %xmm4, 0x130(%rsp)
movaps %xmm10, %xmm4
shufps $0x0, %xmm10, %xmm4     # xmm4 = xmm4[0,0],xmm10[0,0]
movaps %xmm4, 0x160(%rsp)
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
movaps %xmm3, 0x170(%rsp)
xorl %eax, %eax
leaq 0x5b3228(%rip), %r13    # 0x607be0
xorps %xmm14, %xmm14
movaps 0x19afc(%rip), %xmm15   # 0x6e4c0
movl %ecx, 0x10(%rsp)
movss %xmm13, 0x6c(%rsp)
movss %xmm0, 0x1c(%rsp)
movaps %xmm1, 0x140(%rsp)
movss %xmm9, 0x18(%rsp)
movaps %xmm10, 0xa0(%rsp)
movaps %xmm11, 0x90(%rsp)
movaps %xmm12, 0x80(%rsp)
movss %xmm2, 0x14(%rsp)
testl %r14d, %r14d
je 0x55227
movl %r14d, %r15d
movslq %r14d, %rdx
imulq $0x28, %rdx, %rbx
movslq 0x14(%rbx,%r13), %r14
imulq $0x28, %r14, %rdx
movss (%rdx,%r13), %xmm7
ucomiss %xmm7, %xmm10
jae 0x54a05
movss (%rbx,%r13), %xmm3
ucomiss %xmm9, %xmm3
jae 0x54a05
addq %r13, %rbx
cmpl $0x0, 0x20(%rbx)
jle 0x54a05
movaps %xmm7, %xmm4
subss %xmm3, %xmm4
movaps %xmm4, 0x100(%rsp)
movss 0x4(%rbx), %xmm4
movss %xmm4, 0x78(%rsp)
movss 0x8(%rbx), %xmm5
movss %xmm4, 0xec(%rsp)
subss %xmm4, %xmm5
movss %xmm5, 0xe8(%rsp)
movss %xmm5, 0x70(%rsp)
movss 0xc(%rbx), %xmm4
movss %xmm4, 0x7c(%rsp)
movss 0x10(%rbx), %xmm5
movss %xmm4, 0xe4(%rsp)
subss %xmm4, %xmm5
movss %xmm5, 0xe0(%rsp)
movss %xmm5, 0x74(%rsp)
xorl %esi, %esi
ucomiss %xmm3, %xmm10
movaps %xmm10, %xmm8
movss %xmm3, 0xc(%rsp)
subss %xmm3, %xmm8
jbe 0x54b28
ucomiss %xmm10, %xmm7
jbe 0x54b28
movaps %xmm11, %xmm4
subss (%rbp), %xmm4
mulss 0x100(%rsp), %xmm4
movss (%r12), %xmm3
mulss %xmm8, %xmm3
subss %xmm4, %xmm3
xorl %edi, %edi
ucomiss %xmm3, %xmm14
setbe %dil
xorl %r8d, %r8d
ucomiss %xmm14, %xmm3
setbe %r8b
ucomiss %xmm0, %xmm13
cmoval %r8d, %edi
testb %dil, %dil
jne 0x54b28
movss %xmm10, 0xd0(%rsp)
movss %xmm11, 0xf0(%rsp)
orl $-0x1, 0xc0(%rsp)
pushq $0x1
popq %rsi
addq %r13, %rdx
xorps 0x1999d(%rip), %xmm8    # 0x6e4d0
movaps 0x100(%rsp), %xmm6
shufps $0x0, %xmm6, %xmm6      # xmm6 = xmm6[0,0,0,0]
unpcklps 0x130(%rsp), %xmm8      # xmm8 = xmm8[0],mem[0],xmm8[1],mem[1]
xorl %r8d, %r8d
movslq %esi, %rdi
cmpq $0x2, %r8
je 0x54bf8
movaps %xmm11, %xmm4
subss 0x78(%rsp,%r8,4), %xmm4
unpcklps %xmm12, %xmm4           # xmm4 = xmm4[0],xmm12[0],xmm4[1],xmm12[1]
mulps %xmm6, %xmm4
movss 0x70(%rsp,%r8,4), %xmm3
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
mulps %xmm8, %xmm3
addps %xmm4, %xmm3
movaps %xmm3, %xmm4
andps %xmm15, %xmm4
pshufd $0x55, %xmm4, %xmm5     # xmm5 = xmm4[1,1,1,1]
ucomiss %xmm4, %xmm5
jae 0x54b92
incq %r8
jmp 0x54b4b
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4     # xmm4 = xmm4[1,1],xmm3[1,1]
ucomiss %xmm14, %xmm4
jne 0x54ba1
jnp 0x54b8d
movaps %xmm4, %xmm5
mulss %xmm3, %xmm5
ucomiss %xmm14, %xmm5
jb 0x54b8d
divss %xmm4, %xmm3
movaps %xmm2, %xmm4
mulss %xmm3, %xmm4
addss %xmm10, %xmm4
ucomiss 0xc(%rsp), %xmm4
jbe 0x54b8d
ucomiss %xmm4, %xmm7
jbe 0x54b8d
movss %xmm4, 0xd0(%rsp,%rdi,4)
mulss 0x150(%rsp), %xmm3
addss %xmm11, %xmm3
movss %xmm3, 0xf0(%rsp,%rdi,4)
movl %r8d, 0xc0(%rsp,%rdi,4)
incl %edi
movl %edi, %esi
jmp 0x54b8d
cmpl $0x2, %esi
jl 0x54c82
leal -0x1(%rsi), %r8d
movss 0xd0(%rsp,%r8,4), %xmm4
leal -0x2(%rsi), %r9d
movss 0xd0(%rsp,%r9,4), %xmm3
ucomiss %xmm4, %xmm3
jbe 0x54c82
movss %xmm3, 0xd0(%rsp,%r8,4)
movss %xmm4, 0xd0(%rsp,%r9,4)
movss 0xf0(%rsp,%r8,4), %xmm4
movss 0xf0(%rsp,%r9,4), %xmm3
movss %xmm3, 0xf0(%rsp,%r8,4)
movss %xmm4, 0xf0(%rsp,%r9,4)
movl 0xc0(%rsp,%r8,4), %r10d
movl 0xc0(%rsp,%r9,4), %r11d
movl %r11d, 0xc0(%rsp,%r8,4)
movl %r10d, 0xc0(%rsp,%r9,4)
movl 0x10(%rsp), %ecx
movss 0xc(%rsp), %xmm8
ucomiss %xmm8, %xmm9
movq %r12, 0x128(%rsp)
movq %rbp, 0x120(%rsp)
jbe 0x54d09
ucomiss %xmm9, %xmm7
jbe 0x54d09
movaps %xmm9, %xmm3
subss %xmm8, %xmm3
movaps %xmm1, %xmm4
subss (%rbp), %xmm4
mulss 0x100(%rsp), %xmm4
mulss (%r12), %xmm3
subss %xmm4, %xmm3
xorl %r8d, %r8d
ucomiss %xmm3, %xmm14
setbe %r8b
xorl %r9d, %r9d
ucomiss %xmm14, %xmm3
setbe %r9b
ucomiss %xmm0, %xmm13
cmoval %r9d, %r8d
testb %r8b, %r8b
jne 0x54d09
movss %xmm9, 0xd0(%rsp,%rdi,4)
movss %xmm1, 0xf0(%rsp,%rdi,4)
orl $-0x1, 0xc0(%rsp,%rdi,4)
incl %esi
orl $-0x1, 0x1c(%rdx)
orl $-0x1, 0x1c(%rbx)
movslq %esi, %r12
xorl %ebp, %ebp
cmpq %r12, %rbp
jg 0x55203
jge 0x54e00
movslq 0x5daea0(%rip), %r8     # 0x62fbcc
imulq $0x28, %r8, %rax
movslq 0x14(%rax,%r13), %rdx
imulq $0x28, %rdx, %rsi
movl $0xfff, 0x18(%rsi,%r13) # imm = 0xFFF
movl %edx, 0x5dae84(%rip)    # 0x62fbcc
movslq %r15d, %rdx
imulq $0x28, %rdx, %rsi
movups (%rsi,%r13), %xmm3
movups 0x10(%rsi,%r13), %xmm4
movups %xmm4, 0x10(%rax,%r13)
movq 0x20(%rsi,%r13), %rdi
movq %rdi, 0x20(%rax,%r13)
movups %xmm3, (%rax,%r13)
movl %edx, 0x18(%rax,%r13)
movslq 0x14(%rsi,%r13), %rdi
movl %edi, 0x14(%rax,%r13)
imulq $0x28, %rdi, %rdi
movl %r8d, 0x18(%rdi,%r13)
movl %r8d, 0x14(%rsi,%r13)
movss 0xd0(%rsp,%rbp,4), %xmm4
movaps %xmm4, %xmm5
subss %xmm8, %xmm5
divss 0x100(%rsp), %xmm5
movaps %xmm5, %xmm3
mulss 0xe8(%rsp), %xmm3
addss 0xec(%rsp), %xmm3
movss %xmm3, 0x8(%rsi,%r13)
mulss 0xe0(%rsp), %xmm5
addss 0xe4(%rsp), %xmm5
movss %xmm5, 0x10(%rsi,%r13)
movss %xmm4, (%rax,%r13)
movss %xmm3, 0x4(%rax,%r13)
movss %xmm5, 0xc(%rax,%r13)
movl 0xc0(%rsp,%rbp,4), %esi
movl %esi, 0x1c(%rax,%r13)
movl %r8d, %r15d
jmp 0x54e0f
movslq %r15d, %rdx
imulq $0x28, %rdx, %rsi
movl 0x14(%rsi,%r13), %r8d
movl %eax, %r15d
testl %r8d, %r8d
je 0x551f8
imulq $0x28, %rdx, %rbx
addq %r13, %rbx
movss (%rbx), %xmm6
ucomiss %xmm6, %xmm10
ja 0x551f8
movslq %r8d, %rax
imulq $0x28, %rax, %rsi
movss (%rsi,%r13), %xmm7
ucomiss %xmm9, %xmm7
ja 0x551f8
movaps %xmm6, %xmm5
unpcklps %xmm7, %xmm5            # xmm5 = xmm5[0],xmm7[0],xmm5[1],xmm7[1]
movaps %xmm5, %xmm13
subps 0x160(%rsp), %xmm13
mulps 0x170(%rsp), %xmm13
addps %xmm11, %xmm13
movl 0x1c(%rbx), %edx
testl %edx, %edx
je 0x54e86
cvtss2sd %xmm13, %xmm3
cvtss2sd 0x4(%rbx), %xmm4
addsd 0x19663(%rip), %xmm4    # 0x6e4e0
ucomisd %xmm3, %xmm4
pushq $0x4
popq %rax
jb 0x54e89
pushq $0x3
popq %rax
cmpl $0x1, %edx
je 0x54ea6
cvtss2sd 0xc(%rbx), %xmm3
cvtss2sd %xmm13, %xmm4
addsd 0x1a800(%rip), %xmm3    # 0x6f6a0
ucomisd %xmm3, %xmm4
jb 0x54ea8
incl %eax
addq %r13, %rsi
movl 0x1c(%rsi), %edx
movaps %xmm13, %xmm1
shufps $0x55, %xmm13, %xmm1    # xmm1 = xmm1[1,1],xmm13[1,1]
testl %edx, %edx
je 0x54ed2
cvtss2sd 0x8(%rbx), %xmm3
cvtss2sd %xmm1, %xmm4
addsd 0x19614(%rip), %xmm3    # 0x6e4e0
ucomisd %xmm4, %xmm3
jb 0x54ed5
addl $-0x3, %eax
cmpl $0x1, %edx
movaps %xmm1, 0x110(%rsp)
je 0x54ef9
cvtss2sd 0x10(%rbx), %xmm3
cvtss2sd %xmm1, %xmm4
addsd 0x1a7ad(%rip), %xmm3    # 0x6f6a0
ucomisd %xmm3, %xmm4
jb 0x54efc
addl $0x3, %eax
movss 0x6c(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x54f79
cmpl $0x7, %eax
ja 0x551f8
movl %eax, %eax
leaq 0x1a7d7(%rip), %rdx     # 0x6f6f0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
cvtps2pd %xmm5, %xmm0
movaps %xmm13, 0xb0(%rsp)
cvtps2pd %xmm13, %xmm1
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x20(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x30(%rsp)
cvtps2pd 0xc(%rbx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
movaps 0xb0(%rsp), %xmm0
movlps %xmm0, 0xc(%rbx)
jmp 0x550a2
decl %eax
cmpl $0x7, %eax
ja 0x551f8
leaq 0x1a745(%rip), %rdx     # 0x6f6d0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
cvtps2pd %xmm5, %xmm2
jmpq *%rax
cvtps2pd 0x4(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm2, 0x20(%rsp)
shufps $0x4e, %xmm2, %xmm2     # xmm2 = xmm2[2,3,0,1]
movaps %xmm2, 0x30(%rsp)
movaps %xmm13, 0xb0(%rsp)
cvtps2pd %xmm13, %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
movaps 0xb0(%rsp), %xmm0
movlps %xmm0, 0x4(%rbx)
jmp 0x55151
cvtss2sd %xmm6, %xmm0
movsd %xmm0, 0x20(%rsp)
cvtss2sd %xmm7, %xmm0
movss 0xc(%rbx), %xmm1
movsd %xmm0, 0x28(%rsp)
movss %xmm1, %xmm13           # xmm13 = xmm1[0],xmm13[1,2,3]
cvtps2pd %xmm13, %xmm1
movaps %xmm1, 0x40(%rsp)
movsd %xmm0, 0x30(%rsp)
cvtss2sd 0x10(%rbx), %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
movaps 0x110(%rsp), %xmm0
movss %xmm0, 0x10(%rbx)
jmp 0x550a2
cvtps2pd %xmm5, %xmm0
movaps %xmm0, 0x20(%rsp)
movss 0x10(%rbx), %xmm1
movaps %xmm13, 0xb0(%rsp)
movlhps %xmm13, %xmm1           # xmm1 = xmm1[0],xmm13[0]
shufps $0xe2, %xmm13, %xmm1    # xmm1 = xmm1[2,0],xmm13[2,3]
cvtps2pd %xmm1, %xmm1
movaps %xmm1, 0x40(%rsp)
movlps %xmm0, 0x30(%rsp)
cvtss2sd 0xc(%rbx), %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
movaps 0xb0(%rsp), %xmm0
movss %xmm0, 0xc(%rbx)
movl 0x5dab38(%rip), %eax    # 0x62fbe0
movl %eax, 0x24(%rbx)
jmp 0x551b7
movaps %xmm2, 0x20(%rsp)
cvtps2pd 0x4(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movlps %xmm2, 0x30(%rsp)
movaps %xmm13, 0xb0(%rsp)
cvtss2sd %xmm13, %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
movaps 0xb0(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
jmp 0x55151
cvtss2sd %xmm6, %xmm0
movsd %xmm0, 0x20(%rsp)
cvtss2sd %xmm7, %xmm0
movsd %xmm0, 0x28(%rsp)
cvtps2pd 0x4(%rbx), %xmm1
movaps %xmm1, 0x40(%rsp)
movsd %xmm0, 0x30(%rsp)
cvtss2sd 0x110(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x3
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
movaps 0x110(%rsp), %xmm0
movss %xmm0, 0x8(%rbx)
movl 0x5daa89(%rip), %eax    # 0x62fbe0
movl %eax, 0x20(%rbx)
jmp 0x551b7
cvtps2pd 0x4(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm2, 0x20(%rsp)
shufps $0x4e, %xmm2, %xmm2     # xmm2 = xmm2[2,3,0,1]
movaps %xmm2, 0x30(%rsp)
jmp 0x5518f
cvtps2pd %xmm5, %xmm0
cvtps2pd 0x4(%rbx), %xmm1
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x20(%rsp)
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x30(%rsp)
cvtps2pd 0xc(%rbx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movaps %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x47666
movl 0x10(%rsp), %ecx
orq $-0x1, 0x20(%rbx)
movss 0x1c(%rsp), %xmm0
movss 0x18(%rsp), %xmm9
movaps 0xa0(%rsp), %xmm10
movaps 0x90(%rsp), %xmm11
movaps 0x80(%rsp), %xmm12
movss 0x14(%rsp), %xmm2
xorps %xmm14, %xmm14
movaps 0x192cf(%rip), %xmm15   # 0x6e4c0
movss 0xc(%rsp), %xmm8
incq %rbp
movl %r15d, %eax
jmp 0x54d16
movq 0x128(%rsp), %r12
movq 0x120(%rsp), %rbp
movaps 0x140(%rsp), %xmm1
movss 0x6c(%rsp), %xmm13
jmp 0x54a05
incl 0x5da9b3(%rip)          # 0x62fbe0
movl 0x5b29c1(%rip), %eax    # 0x607bf4
movslq %eax, %rcx
imulq $0x28, %rcx, %rcx
addq %r13, %rcx
testl %eax, %eax
je 0x54919
movss 0x4(%rcx), %xmm0
ucomiss 0xc(%rcx), %xmm0
jb 0x55260
movss 0x8(%rcx), %xmm0
ucomiss 0x10(%rcx), %xmm0
jb 0x55260
orq $-0x1, 0x20(%rcx)
movl 0x14(%rcx), %edx
movslq %edx, %rsi
movl 0x20(%rcx), %edi
imulq $0x28, %rsi, %r8
leaq (%r8,%r13), %rsi
cmpl 0x20(%r8,%r13), %edi
jne 0x552d3
movl 0x24(%rcx), %edi
cmpl 0x24(%rsi), %edi
jne 0x552d3
movss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rcx)
movss 0x10(%rsi), %xmm0
movss %xmm0, 0x10(%rcx)
movslq 0x18(%rsi), %rdi
movslq 0x14(%rsi), %r8
imulq $0x28, %r8, %r9
movl %edi, 0x18(%r9,%r13)
imulq $0x28, %rdi, %rdi
movl %r8d, 0x14(%rdi,%r13)
movslq 0x5da917(%rip), %rdi    # 0x62fbcc
movl %edi, 0x14(%rsi)
movl $0xfff, 0x18(%rsi)      # imm = 0xFFF
imulq $0x28, %rdi, %rsi
movl %edx, 0x18(%rsi,%r13)
movl %edx, 0x5da8fe(%rip)    # 0x62fbcc
jmp 0x5523d
movl %edx, %eax
jmp 0x55233