// File: /workspace/github_c_makefile_star2_O2/jonof[P]jftekwar/jfbuild/src/engine.c
// Function: drawmasks
void drawmasks(void)
{
	int i, j, k, l, gap, xs, ys, xp, yp, yoff, yspan;

	for(i=spritesortcnt-1;i>=0;i--) tspriteptr[i] = &tsprite[i];
	for(i=spritesortcnt-1;i>=0;i--)
	{
		xs = tspriteptr[i]->x-globalposx; ys = tspriteptr[i]->y-globalposy;
		yp = dmulscale6(xs,cosviewingrangeglobalang,ys,sinviewingrangeglobalang);
		if (yp > (4<<8))
		{
			xp = dmulscale6(ys,cosglobalang,-xs,singlobalang);
			if (mulscale24(abs(xp+yp),xdimen) >= yp) goto killsprite;
			spritesx[i] = scale(xp+yp,xdimen<<7,yp);
		}
		else if ((tspriteptr[i]->cstat&48) == 0)
		{
killsprite:
			spritesortcnt--;  //Delete face sprite if on wrong side!
			if (i != spritesortcnt)
			{
				tspriteptr[i] = tspriteptr[spritesortcnt];
				spritesx[i] = spritesx[spritesortcnt];
				spritesy[i] = spritesy[spritesortcnt];
			}
			continue;
		}
		spritesy[i] = yp;
	}

	gap = 1; while (gap < spritesortcnt) gap = (gap<<1)+1;
	for(gap>>=1;gap>0;gap>>=1)      //Sort sprite list
		for(i=0;i<spritesortcnt-gap;i++)
			for(l=i;l>=0;l-=gap)
			{
				if (spritesy[l] <= spritesy[l+gap]) break;
				swaplong(&tspriteptr[l],&tspriteptr[l+gap]);
				swaplong(&spritesx[l],&spritesx[l+gap]);
				swaplong(&spritesy[l],&spritesy[l+gap]);
			}

	if (spritesortcnt > 0)
		spritesy[spritesortcnt] = (spritesy[spritesortcnt-1]^1);

	ys = spritesy[0]; i = 0;
	for(j=1;j<=spritesortcnt;j++)
	{
		if (spritesy[j] == ys) continue;
		ys = spritesy[j];
		if (j > i+1)
		{
			for(k=i;k<j;k++)
			{
				spritesz[k] = tspriteptr[k]->z;
				if ((tspriteptr[k]->cstat&48) != 32)
				{
					yoff = (int)((signed char)((picanm[tspriteptr[k]->picnum]>>16)&255))+((int)tspriteptr[k]->yoffset);
					spritesz[k] -= ((yoff*tspriteptr[k]->yrepeat)<<2);
					yspan = (tilesizy[tspriteptr[k]->picnum]*tspriteptr[k]->yrepeat<<2);
					if (!(tspriteptr[k]->cstat&128)) spritesz[k] -= (yspan>>1);
					if (klabs(spritesz[k]-globalposz) < (yspan>>1)) spritesz[k] = globalposz;
				}
			}
			for(k=i+1;k<j;k++)
				for(l=i;l<k;l++)
					if (klabs(spritesz[k]-globalposz) < klabs(spritesz[l]-globalposz))
					{
						swaplong(&tspriteptr[k],&tspriteptr[l]);
						swaplong(&spritesx[k],&spritesx[l]);
						swaplong(&spritesy[k],&spritesy[l]);
						swaplong(&spritesz[k],&spritesz[l]);
					}
			for(k=i+1;k<j;k++)
				for(l=i;l<k;l++)
					if (tspriteptr[k]->statnum < tspriteptr[l]->statnum)
					{
						swaplong(&tspriteptr[k],&tspriteptr[l]);
						swaplong(&spritesx[k],&spritesx[l]);
						swaplong(&spritesy[k],&spritesy[l]);
					}
		}
		i = j;
	}

	/*for(i=spritesortcnt-1;i>=0;i--)
	{
		xs = tspriteptr[i].x-globalposx;
		ys = tspriteptr[i].y-globalposy;
		zs = tspriteptr[i].z-globalposz;

		xp = ys*cosglobalang-xs*singlobalang;
		yp = (zs<<1);
		zp = xs*cosglobalang+ys*singlobalang;

		xs = scale(xp,halfxdimen<<12,zp)+((halfxdimen+windowx1)<<12);
		ys = scale(yp,xdimenscale<<12,zp)+((globalhoriz+windowy1)<<12);

		drawline256(xs-65536,ys-65536,xs+65536,ys+65536,31);
		drawline256(xs+65536,ys-65536,xs-65536,ys+65536,31);
	}*/

#if USE_POLYMOST
		//Hack to make it draw all opaque quads first. This should reduce the chances of
		//bad sorting causing transparent quads knocking out opaque quads behind it.
		//
		//Need to store alpha flag with all textures before this works right!
	if (rendmode > 0)
	{
		for(i=spritesortcnt-1;i>=0;i--)
			if ((!(tspriteptr[i]->cstat&2))
#if USE_OPENGL
			    && (!polymost_texmayhavealpha(tspriteptr[i]->picnum,tspriteptr[i]->pal))
#endif
			   )
				{ drawsprite(i); tspriteptr[i] = 0; } //draw only if it is fully opaque
		for(i=j=0;i<spritesortcnt;i++)
		{
			if (!tspriteptr[i]) continue;
			tspriteptr[j] = tspriteptr[i];
			spritesx[j] = spritesx[i];
			spritesy[j] = spritesy[i]; j++;
		}
		spritesortcnt = j;


		for(i=maskwallcnt-1;i>=0;i--)
		{
			k = thewall[maskwall[i]];
			if ((!(wall[k].cstat&128))
#if USE_OPENGL
			    && (!polymost_texmayhavealpha(wall[k].overpicnum,wall[k].pal))
#endif
			   )
				{ drawmaskwall(i); maskwall[i] = -1; } //draw only if it is fully opaque
		}
		for(i=j=0;i<maskwallcnt;i++)
		{
			if (maskwall[i] < 0) continue;
			maskwall[j++] = maskwall[i];
		}
		maskwallcnt = j;
	}
#endif

	while ((spritesortcnt > 0) && (maskwallcnt > 0))  //While BOTH > 0
	{
		j = maskwall[maskwallcnt-1];
		if (spritewallfront(tspriteptr[spritesortcnt-1],(int)thewall[j]) == 0)
			drawsprite(--spritesortcnt);
		else
		{
				//Check to see if any sprites behind the masked wall...
			k = -1;
			gap = 0;
			for(i=spritesortcnt-2;i>=0;i--)
			{
#if USE_POLYMOST
				if (rendmode > 0)
					l = dxb1[j] <= (double)spritesx[i]/256.0 && (double)spritesx[i]/256.0 <= dxb2[j];
				else
#endif
					l = xb1[j] <= (spritesx[i]>>8) && (spritesx[i]>>8) <= xb2[j];
				if (l && spritewallfront(tspriteptr[i],(int)thewall[j]) == 0)
				{
					drawsprite(i);
					tspriteptr[i]->owner = -1;
					k = i;
					gap++;
				}
			}
			if (k >= 0)       //remove holes in sprite list
			{
				for(i=k;i<spritesortcnt;i++)
					if (tspriteptr[i]->owner >= 0)
					{
						if (i > k)
						{
							tspriteptr[k] = tspriteptr[i];
							spritesx[k] = spritesx[i];
							spritesy[k] = spritesy[i];
						}
						k++;
					}
				spritesortcnt -= gap;
			}

				//finally safe to draw the masked wall
			drawmaskwall(--maskwallcnt);
		}
	}
	while (spritesortcnt > 0) drawsprite(--spritesortcnt);
	while (maskwallcnt > 0) drawmaskwall(--maskwallcnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x3aa3f2(%rip), %r12d   # 0x3d07a4
movl %r12d, %esi
imulq $0x2c, %rsi, %rax
leaq 0x3b4410(%rip), %rcx    # 0x3da7d0
addq %rcx, %rax
addq $-0x2c, %rax
leaq 0x3ca402(%rip), %r15    # 0x3f07d0
movq %rsi, %rcx
testl %ecx, %ecx
jle 0x263e3
movq %rax, -0x8(%r15,%rcx,8)
decq %rcx
addq $-0x2c, %rax
jmp 0x263d1
movslq 0x20d666(%rip), %rdi    # 0x233a50
movslq 0x20d663(%rip), %r8     # 0x233a54
movslq 0x242684(%rip), %r9     # 0x268a7c
movslq 0x242675(%rip), %r11    # 0x268a74
movslq 0x24266a(%rip), %rax    # 0x268a70
movq %rax, (%rsp)
movslq 0x242667(%rip), %r14    # 0x268a78
movslq 0x77418(%rip), %rbp     # 0x9d830
movl %ebp, %eax
shll $0x7, %eax
cltq
movq %rax, 0x8(%rsp)
leaq 0x3d03a5(%rip), %r13    # 0x3f67d0
movl %r12d, %eax
movq %rax, 0x10(%rsp)
testl %esi, %esi
jle 0x26506
movq -0x8(%r15,%rsi,8), %rdx
movslq (%rdx), %rcx
subq %rdi, %rcx
movslq 0x4(%rdx), %rax
subq %r8, %rax
movq %r9, %rbx
imulq %rcx, %rbx
movq %r11, %r10
imulq %rax, %r10
addq %rbx, %r10
shrq $0x6, %r10
cmpl $0x401, %r10d           # imm = 0x401
jl 0x264bb
negl %ecx
imulq (%rsp), %rax
movslq %ecx, %rcx
imulq %r14, %rcx
addq %rax, %rcx
shrq $0x6, %rcx
addl %r10d, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
imulq %rbp, %rax
shrq $0x18, %rax
cmpl %r10d, %eax
jge 0x264c1
movslq %ecx, %rax
imulq 0x8(%rsp), %rax
movl %r10d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cqto
idivq %rcx
leaq 0x3ce31b(%rip), %rcx    # 0x3f47d0
movl %eax, -0x4(%rcx,%rsi,4)
jmp 0x264f9
testb $0x30, 0xc(%rdx)
jne 0x264f9
movq %r12, %rax
decl %eax
movl %eax, 0x3aa2d8(%rip)    # 0x3d07a4
cmpq 0x10(%rsp), %rsi
jne 0x264d8
movq %rax, %r12
jmp 0x264fe
movq %rax, %r12
cltq
movq (%r15,%rax,8), %rcx
movq %rcx, -0x8(%r15,%rsi,8)
leaq 0x3ce2e3(%rip), %rdx    # 0x3f47d0
movl (%rdx,%rax,4), %ecx
movl %ecx, -0x4(%rdx,%rsi,4)
movl (%r13,%rax,4), %r10d
movl %r10d, -0x4(%r13,%rsi,4)
decq %rsi
jmp 0x2642b
pushq $0x1
popq %rax
leaq 0x3ce2c0(%rip), %r14    # 0x3f47d0
cmpl %r12d, %eax
jge 0x2651e
leal 0x1(,%rax,2), %eax
jmp 0x26510
sarl %eax
testl %eax, %eax
jle 0x26585
movl %r12d, %edx
subl %eax, %edx
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
cmpl %edx, %ecx
je 0x26581
movl %ecx, %esi
testl %esi, %esi
js 0x2657d
movl %esi, %edi
movl (%r13,%rdi,4), %r8d
leal (%rax,%rsi), %r9d
movl (%r13,%r9,4), %r10d
cmpl %r10d, %r8d
jle 0x2657d
movl (%r15,%r9,8), %r11d
movl (%r15,%rdi,8), %ebx
movl %ebx, (%r15,%r9,8)
movl %r11d, (%r15,%rdi,8)
movl (%r14,%r9,4), %r11d
movl (%r14,%rdi,4), %ebx
movl %ebx, (%r14,%r9,4)
movl %r11d, (%r14,%rdi,4)
movl %r8d, (%r13,%r9,4)
movl %r10d, (%r13,%rdi,4)
subl %eax, %esi
jmp 0x26536
incl %ecx
jmp 0x26530
shrl %eax
jmp 0x26520
testl %r12d, %r12d
jle 0x265a1
leal -0x1(%r12), %eax
movl (%r13,%rax,4), %eax
xorl $0x1, %eax
movq 0x10(%rsp), %rcx
movl %eax, (%r13,%rcx,4)
movl 0x3d0229(%rip), %edi    # 0x3f67d0
movl 0x23e4b3(%rip), %eax    # 0x264a60
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
incl %r12d
pushq $0x1
popq %r11
movq %r12, 0x20(%rsp)
cmpq %r12, %r11
je 0x26837
movl (%r13,%r11,4), %esi
cmpl %edi, %esi
jne 0x265db
movl %edi, %esi
jmp 0x2682d
leal 0x1(%rcx), %edx
movslq %edx, %r10
cmpq %r10, %r11
jle 0x266ee
movl %esi, 0x1c(%rsp)
movslq %ecx, %rcx
leaq (,%rcx,8), %r14
movq %rcx, (%rsp)
leaq (,%rcx,4), %rbp
xorl %edi, %edi
movq %r11, 0x8(%rsp)
movq (%rsp), %rcx
leaq (%rcx,%rdi), %rdx
cmpq %r11, %rdx
jge 0x266f6
leaq (%r14,%rdi,8), %rdx
movq (%r15,%rdx), %rbx
movl 0x8(%rbx), %ecx
leaq (,%rdi,4), %rdx
addq %rbp, %rdx
leaq 0x3d21a6(%rip), %rsi    # 0x3f87e0
movl %ecx, (%rsi,%rdx)
movzwl 0xc(%rbx), %edx
andl $0x30, %edx
cmpw $0x20, %dx
je 0x266e1
leaq (,%rdi,4), %r11
movswq 0xe(%rbx), %rdx
leaq 0x20d3fe(%rip), %rsi    # 0x233a60
movsbl 0x2(%rsi,%rdx,4), %edx
movsbl 0x17(%rbx), %r9d
addl %edx, %r9d
movzbl 0x15(%rbx), %edx
imull %r9d, %edx
shll $0x2, %edx
subl %edx, %ecx
addq %rbp, %r11
leaq 0x3d215a(%rip), %rdx    # 0x3f87e0
movl %ecx, (%rdx,%r11)
movswq 0xe(%rbx), %rdx
leaq 0x3d414a(%rip), %rsi    # 0x3fa7e0
movswl (%rsi,%rdx,2), %edx
movzbl 0x15(%rbx), %r9d
imull %edx, %r9d
movb 0xc(%rbx), %bl
addl %r9d, %r9d
testb $-0x80, %bl
movl $0x0, %edx
cmovel %r9d, %edx
subl %edx, %ecx
movl %ecx, %r8d
subl %eax, %r8d
movl %r8d, %edx
negl %edx
cmovsl %r8d, %edx
testb $-0x80, %bl
je 0x266d0
cmpl %r9d, %edx
jge 0x266e1
cmpl %r9d, %edx
cmovll %eax, %ecx
leaq 0x3d2103(%rip), %rdx    # 0x3f87e0
movl %ecx, (%rdx,%r11)
incq %rdi
movq 0x8(%rsp), %r11
jmp 0x2660c
movl %r11d, %ecx
jmp 0x2682d
movq %r10, %rdi
cmpq %r11, %rdi
jge 0x26815
xorl %r8d, %r8d
movq (%rsp), %r11
cmpq %rdi, %r11
jge 0x2679c
leaq 0x3d20c7(%rip), %r9     # 0x3f87e0
movl (%r9,%rdi,4), %ebx
movl %ebx, %ecx
subl %eax, %ecx
movl %ecx, %esi
negl %esi
cmovsl %ecx, %esi
leaq (%r8,%rbp), %rdx
movl (%r9,%rdx), %r12d
movl %r12d, %r9d
subl %eax, %r9d
movl %r9d, %ecx
negl %ecx
cmovsl %r9d, %ecx
cmpl %ecx, %esi
jae 0x26790
leaq (%r14,%r8,2), %rcx
movl (%r15,%rcx), %esi
movl (%r15,%rdi,8), %r9d
movl %r9d, (%r15,%rcx)
movl %esi, (%r15,%rdi,8)
leaq 0x3ce072(%rip), %r9     # 0x3f47d0
movl (%r9,%rdx), %ecx
movl (%r9,%rdi,4), %esi
movl %esi, (%r9,%rdx)
movl %ecx, (%r9,%rdi,4)
movl (%r13,%rdx), %ecx
movl (%r13,%rdi,4), %esi
movl %esi, (%r13,%rdx)
movl %ecx, (%r13,%rdi,4)
leaq 0x3d2057(%rip), %rcx    # 0x3f87e0
movl %ebx, (%rcx,%rdx)
movl %r12d, (%rcx,%rdi,4)
incq %r11
addq $0x4, %r8
jmp 0x26709
incq %rdi
movq 0x8(%rsp), %r11
jmp 0x266f9
xorl %edi, %edi
movq (%rsp), %r8
cmpq %r10, %r8
jge 0x26812
movq (%r15,%r10,8), %rdx
movzwl 0x1a(%rdx), %ecx
leaq (%r14,%rdi,2), %rsi
movq (%r15,%rsi), %r9
cmpw 0x1a(%r9), %cx
jge 0x26809
leaq (%rdi,%rdi), %rcx
addq %r14, %rcx
movl %edx, (%r15,%rcx)
movl %r9d, (%r15,%r10,8)
leaq (%rdi,%rbp), %rcx
leaq 0x3cdfeb(%rip), %r9     # 0x3f47d0
movl (%r9,%rcx), %edx
movl (%r9,%r10,4), %esi
movl %esi, (%r9,%rcx)
movl %edx, (%r9,%r10,4)
movl (%r13,%rcx), %edx
movl (%r13,%r10,4), %esi
movl %esi, (%r13,%rcx)
movl %edx, (%r13,%r10,4)
incq %r8
addq $0x4, %rdi
jmp 0x267af
incq %r10
cmpq %r11, %r10
jl 0x267a9
movl %r11d, %ecx
leaq 0x3cdfac(%rip), %r14    # 0x3f47d0
movq 0x20(%rsp), %r12
movl 0x1c(%rsp), %esi
incq %r11
movl %esi, %edi
jmp 0x265c2
leaq 0x5cd112(%rip), %rax    # 0x5f3950
cmpl $0x0, (%rax)
jle 0x2698d
movq 0x10(%rsp), %r12
testl %r12d, %r12d
jle 0x26881
decq %r12
movl %r12d, %ebx
movq (%r15,%rbx,8), %rax
testb $0x2, 0xc(%rax)
jne 0x2684c
movswl 0xe(%rax), %edi
movzbl 0x11(%rax), %esi
callq 0x465ac
testl %eax, %eax
jne 0x2684c
movl %r12d, %edi
callq 0x26b78
andq $0x0, (%r15,%rbx,8)
jmp 0x2684c
movl 0x3a9f1d(%rip), %eax    # 0x3d07a4
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
shlq $0x2, %rax
movq %r15, %rdx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x268c8
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x268be
movslq %esi, %rsi
movq %rdi, (%r15,%rsi,8)
movl (%rcx,%r14), %edi
movl %edi, (%r14,%rsi,4)
movl (%rcx,%r13), %edi
movl %edi, (%r13,%rsi,4)
incl %esi
addq $0x4, %rcx
addq $0x8, %rdx
jmp 0x26897
movl %esi, 0x3a9ed6(%rip)    # 0x3d07a4
movswq 0x3a9ec8(%rip), %rsi    # 0x3d079e
movl %esi, %ebp
decl %esi
leaq 0x3d86ff(%rip), %r8     # 0x3fefe0
leaq 0x18b168(%rip), %rdx    # 0x1b1a50
testl %ebp, %ebp
jle 0x26951
decq %rbp
movl %ebp, %ebx
movswq (%r8,%rbx,2), %rax
leaq 0x20b153(%rip), %rcx    # 0x231a50
movswq (%rcx,%rax,2), %rax
shlq $0x5, %rax
testb $-0x80, 0xe(%rax,%rdx)
jne 0x2694d
addq %rdx, %rax
movswl 0x12(%rax), %edi
movq %rsi, (%rsp)
movzbl 0x15(%rax), %esi
movq %rdx, %r12
movq %r8, %r14
callq 0x465ac
movq (%rsp), %rsi
movq %r14, %r8
movq %r12, %rdx
testl %eax, %eax
jne 0x2694d
movswl %si, %edi
callq 0x2a791
movq (%rsp), %rsi
movq %r14, %r8
movq %r12, %rdx
orw $-0x1, (%r14,%rbx,2)
decl %esi
jmp 0x268e8
movzwl 0x3a9e46(%rip), %ecx    # 0x3d079e
xorl %eax, %eax
testw %cx, %cx
cmovlel %eax, %ecx
movzwl %cx, %ecx
addl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
je 0x26986
movzwl (%rax,%r8), %esi
testw %si, %si
js 0x26980
movslq %edx, %rdi
incl %edx
movw %si, (%r8,%rdi,2)
addq $0x2, %rax
jmp 0x26967
movw %dx, 0x3a9e11(%rip)     # 0x3d079e
movl 0x3a9e11(%rip), %ebx    # 0x3d07a4
testl %ebx, %ebx
jle 0x26b46
movzwl 0x3a9dfc(%rip), %eax    # 0x3d079e
testw %ax, %ax
jle 0x26b46
movzwl %ax, %eax
decl %eax
leaq 0x3d8629(%rip), %rcx    # 0x3fefe0
movswq (%rcx,%rax,2), %rcx
leal -0x1(%rbx), %ebp
movq (%r15,%rbp,8), %rdi
leaq 0x20b086(%rip), %rax    # 0x231a50
movq %rcx, %r12
movswl (%rax,%rcx,2), %esi
callq 0x2ad31
testl %eax, %eax
je 0x26b1f
addl $-0x2, %ebx
movl $0x0, (%rsp)
pushq $-0x1
popq %rbp
movq %r12, %rdx
leaq 0x5ccf5b(%rip), %rsi    # 0x5f3950
testl %ebx, %ebx
js 0x26a97
cmpl $0x0, (%rsi)
movl %ebx, %r14d
leaq 0x3cddc6(%rip), %rax    # 0x3f47d0
movl (%rax,%r14,4), %eax
jle 0x26a3e
cvtsi2sd %eax, %xmm0
mulsd 0x45584(%rip), %xmm0    # 0x6bfa0
leaq 0x5d11bd(%rip), %rax    # 0x5f7be0
ucomisd (%rax,%rdx,8), %xmm0
jb 0x26a90
leaq 0x5d91af(%rip), %rax    # 0x5ffbe0
movsd (%rax,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x26a59
jmp 0x26a90
sarl $0x8, %eax
leaq 0x23e028(%rip), %rcx    # 0x264a70
cmpl %eax, (%rcx,%rdx,4)
jg 0x26a90
leaq 0x24202c(%rip), %rcx    # 0x268a80
cmpl (%rcx,%rdx,4), %eax
jg 0x26a90
movq (%r15,%r14,8), %rdi
leaq 0x20afec(%rip), %rax    # 0x231a50
movswl (%rax,%rdx,2), %esi
callq 0x2ad31
testl %eax, %eax
jne 0x26a86
movl %ebx, %edi
callq 0x26b78
movq (%r15,%r14,8), %rax
orw $-0x1, 0x1e(%rax)
incl (%rsp)
movl %ebx, %ebp
movq %r12, %rdx
leaq 0x5ccec0(%rip), %rsi    # 0x5f3950
decl %ebx
jmp 0x269f5
testl %ebp, %ebp
js 0x26b02
movl 0x3a9d03(%rip), %eax    # 0x3d07a4
movl %ebp, %ecx
leaq (,%rcx,4), %rdx
shlq $0x3, %rcx
xorl %esi, %esi
movl %ebp, %edi
cmpl %ebp, %eax
jle 0x26af9
leaq (%rcx,%rsi,2), %r8
movq (%r15,%r8), %r8
cmpw $0x0, 0x1e(%r8)
js 0x26af1
cmpl %ebp, %edi
jge 0x26aef
movslq %edi, %r9
movq %r8, (%r15,%r9,8)
leaq (%rdx,%rsi), %r8
leaq 0x3cdcf3(%rip), %r11    # 0x3f47d0
movl (%r11,%r8), %r10d
movl %r10d, (%r11,%r9,4)
movl (%r13,%r8), %r8d
movl %r8d, (%r13,%r9,4)
incl %edi
addq $0x4, %rsi
incl %ebp
jmp 0x26ab3
subl (%rsp), %eax
movl %eax, 0x3a9ca2(%rip)    # 0x3d07a4
movzwl 0x3a9c95(%rip), %eax    # 0x3d079e
decl %eax
movw %ax, 0x3a9c8c(%rip)     # 0x3d079e
movswl %ax, %edi
callq 0x2a791
jmp 0x2698d
movl %ebp, 0x3a9c7f(%rip)    # 0x3d07a4
movl %ebp, %edi
callq 0x26b78
jmp 0x2698d
decl %ebx
movl %ebx, 0x3a9c6b(%rip)    # 0x3d07a4
movl %ebx, %edi
callq 0x26b78
movl 0x3a9c5e(%rip), %ebx    # 0x3d07a4
testl %ebx, %ebx
jg 0x26b31
jmp 0x26b5d
decl %eax
movw %ax, 0x3a9c49(%rip)     # 0x3d079e
movswl %ax, %edi
callq 0x2a791
movzwl 0x3a9c3a(%rip), %eax    # 0x3d079e
testw %ax, %ax
jg 0x26b4c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq