LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: osdcmd_mapversion
static int osdcmd_mapversion(const osdfuncparm_t *parm)
{
	int newversion;

	if (parm->numparms < 1) {
		buildprintf("mapversion is %d\n", mapversion);
		return OSDCMD_OK;
	}
	newversion = atoi(parm->parms[0]);
	if (newversion < 5 || newversion > 8) {
		return OSDCMD_SHOWHELP;
	}

	buildprintf("mapversion is now %d (was %d)\n", newversion, mapversion);
	mapversion = newversion;

	return OSDCMD_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, (%rdi)
jle 0xb800
movq 0x10(%rdi), %rax
movq (%rax), %rdi
callq 0x6310
movl %eax, %r14d
leal -0x9(%r14), %eax
movl $0x1, %ebx
cmpl $-0x4, %eax
jb 0xb819
leaq 0x98fb3(%rip), %r15     # 0xa4798
movl (%r15), %edx
leaq 0x69825(%rip), %rdi     # 0x75014
xorl %ebx, %ebx
movl %r14d, %esi
xorl %eax, %eax
callq 0x25221
movl %r14d, (%r15)
jmp 0xb819
leaq 0x98f91(%rip), %rax     # 0xa4798
movl (%rax), %esi
leaq 0x697f2(%rip), %rdi     # 0x75002
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x25221
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: osdcmd_showspriteextents
static int osdcmd_showspriteextents(const osdfuncparm_t *parm)
{
	int newval;

	if (parm->numparms != 1) {
		buildprintf("showspriteextents is %d\n", showspriteextents);
		return OSDCMD_OK;
	}
	newval = atoi(parm->parms[0]);
	if (newval < 0 || newval > 2) {
		return OSDCMD_SHOWHELP;
	}

	buildprintf("showspriteextents is now %d (was %d)\n", newval, showspriteextents);
	showspriteextents = newval;
	return OSDCMD_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x1, (%rdi)
jne 0xb863
movq 0x10(%rdi), %rax
movq (%rax), %rdi
callq 0x6310
movl $0x1, %ebx
cmpl $0x2, %eax
ja 0xb87a
movl %eax, %ebp
movswl 0x1220e0(%rip), %edx    # 0x12d928
leaq 0x697fd(%rip), %rdi     # 0x7504c
xorl %ebx, %ebx
movl %eax, %esi
xorl %eax, %eax
callq 0x25221
movw %bp, 0x1220c7(%rip)     # 0x12d928
jmp 0xb87a
movswl 0x1220be(%rip), %esi    # 0x12d928
leaq 0x697c2(%rip), %rdi     # 0x75033
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x25221
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: updatenumsprites
void updatenumsprites(void)
{
	int i;

	numsprites = 0;
	for(i=0;i<MAXSPRITES;i++)
		if (sprite[i].statnum < MAXSTATUS)
			numsprites++;
}

// Assembly:
movl $0x0, 0x166ca4(%rip)    # 0x17a1cc
xorl %eax, %eax
movl $0x1a, %ecx
leaq 0x26977a(%rip), %rdx    # 0x27ccb0
cmpw $0x3ff, (%rdx,%rcx)     # imm = 0x3FF
jg 0x13546
incl %eax
movl %eax, 0x166c86(%rip)    # 0x17a1cc
addq $0x2c, %rcx
cmpq $0xb001a, %rcx          # imm = 0xB001A
jne 0x13536
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: printmessage256
void printmessage256(char *name)
{
	char snotbuf[40];
	int i;

	i = 0;
	while ((name[i] != 0) && (i < 38))
	{
		snotbuf[i] = name[i];
		i++;
	}
	while (i < 38)
	{
		snotbuf[i] = 32;
		i++;
	}
	snotbuf[38] = 0;

	printext256(0L,0L,whitecol,blackcol,snotbuf,0);
}

// Assembly:
subq $0x28, %rsp
movb (%rdi), %dl
testb %dl, %dl
je 0x13584
xorl %ecx, %ecx
movb %dl, (%rsp,%rcx)
leaq 0x1(%rcx), %rax
cmpq $0x24, %rcx
ja 0x13578
movb 0x1(%rdi,%rcx), %dl
movq %rax, %rcx
testb %dl, %dl
jne 0x13560
leaq -0x1(%rax), %rcx
cmpq $0x24, %rcx
jbe 0x13586
jmp 0x1359d
xorl %eax, %eax
movl %eax, %ecx
leaq (%rsp,%rcx), %rdi
movl $0x26, %edx
subl %eax, %edx
movl $0x20, %esi
callq 0x62f0
movq %rsp, %r8
movb $0x0, 0x26(%r8)
movswl 0x11a79c(%rip), %edx    # 0x12dd48
movswl 0x11a799(%rip), %ecx    # 0x12dd4c
xorl %edi, %edi
xorl %esi, %esi
xorl %r9d, %r9d
callq 0x3d8b3
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: fixspritesectors
void fixspritesectors(void)
{
	int i, j, dax, day, daz;

	for(i=numsectors-1;i>=0;i--)
		if ((sector[i].wallnum <= 0) || (sector[i].wallptr >= numwalls))
			deletesector((short)i);

	for(i=0;i<MAXSPRITES;i++)
		if (sprite[i].statnum < MAXSTATUS)
		{
			dax = sprite[i].x;
			day = sprite[i].y;
			if (inside(dax,day,sprite[i].sectnum) != 1)
			{
				daz = ((tilesizy[sprite[i].picnum]*sprite[i].yrepeat)<<2);

				for(j=0;j<numsectors;j++)
					if (inside(dax,day,(short)j) == 1)
						if (sprite[i].z >= getceilzofslope(j,dax,day))
							if (sprite[i].z-daz <= getflorzofslope(j,dax,day))
							{
								changespritesect((short)i,(short)j);
								break;
							}
			}
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3bc96c(%rip), %rax    # 0x3cff60
movswq (%rax), %rbx
testq %rbx, %rbx
jle 0x13647
leaq (%rbx,%rbx,4), %rax
incq %rbx
leaq 0x230455(%rip), %rcx    # 0x243a60
leaq (%rcx,%rax,8), %r14
addq $-0x26, %r14
leaq 0x40364e(%rip), %r15    # 0x416c68
cmpw $0x0, (%r14)
jle 0x1362c
movzwl -0x2(%r14), %eax
cmpw (%r15), %ax
jl 0x1363a
leal 0xfffe(%rbx), %eax
movswl %ax, %edi
callq 0x1c2c7
decq %rbx
addq $-0x28, %r14
cmpq $0x1, %rbx
ja 0x1361a
xorl %r15d, %r15d
imulq $0x2c, %r15, %r13
leaq 0x26965b(%rip), %rax    # 0x27ccb0
cmpw $0x3ff, 0x1a(%rax,%r13) # imm = 0x3FF
jg 0x13720
addq 0x7f95e(%rip), %r13     # 0x92fc8
movl (%r13), %ebx
movl 0x4(%r13), %ebp
movswl 0x18(%r13), %edx
movl %ebx, %edi
movl %ebp, %esi
callq 0x367f7
cmpl $0x1, %eax
je 0x13720
leaq 0x3bc8d0(%rip), %rax    # 0x3cff60
cmpw $0x0, (%rax)
jle 0x13720
movswq 0xe(%r13), %rax
leaq 0x3ee13a(%rip), %rcx    # 0x4017e0
movswl (%rcx,%rax,2), %eax
movzbl 0x15(%r13), %ecx
imull %eax, %ecx
shll $0x2, %ecx
movl %ecx, 0x4(%rsp)
xorl %r14d, %r14d
movswl %r14w, %edx
movl %ebx, %edi
movl %ebp, %esi
callq 0x367f7
cmpl $0x1, %eax
jne 0x136ff
movl 0x8(%r13), %r12d
movswl %r14w, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x3abce
cmpl %eax, %r12d
jl 0x136ff
movl 0x8(%r13), %r12d
subl 0x4(%rsp), %r12d
movswl %r14w, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x3aaf4
cmpl %eax, %r12d
jle 0x13713
incl %r14d
leaq 0x3bc857(%rip), %rax    # 0x3cff60
movswl (%rax), %eax
cmpl %eax, %r14d
jl 0x136bc
jmp 0x13720
movswl %r14w, %esi
movswl %r15w, %edi
callq 0x36a71
incq %r15
cmpq $0x4000, %r15           # imm = 0x4000
jne 0x1364a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: clearfilenames
void clearfilenames(void)
{
	klistfree(finddirs);
	klistfree(findfiles);
	finddirs = findfiles = NULL;
	numfiles = numdirs = 0;
}

// Assembly:
pushq %rax
movq 0x166e89(%rip), %rdi    # 0x17a5d0
callq 0x20b90
movq 0x166e85(%rip), %rdi    # 0x17a5d8
callq 0x20b90
xorl %eax, %eax
movq %rax, 0x166e77(%rip)    # 0x17a5d8
movq %rax, 0x166e68(%rip)    # 0x17a5d0
movl %eax, 0x166e72(%rip)    # 0x17a5e0
movl %eax, 0x166e70(%rip)    # 0x17a5e4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: showmouse
void showmouse(void)
{
	drawline256((searchx+1)<<12, (searchy  )<<12, (searchx+5)<<12, (searchy  )<<12, whitecol);
	drawline256((searchx  )<<12, (searchy+1)<<12, (searchx  )<<12, (searchy+5)<<12, whitecol);
	drawline256((searchx-1)<<12, (searchy  )<<12, (searchx-5)<<12, (searchy  )<<12, whitecol);
	drawline256((searchx  )<<12, (searchy-1)<<12, (searchx  )<<12, (searchy-5)<<12, whitecol);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x914bc(%rip), %r14     # 0xa4c40
movl (%r14), %edx
shll $0xc, %edx
movl $0x1000, %ebx           # imm = 0x1000
leal (%rdx,%rbx), %edi
leaq 0x4056cf(%rip), %r15    # 0x418e68
movl (%r15), %ecx
shll $0xc, %ecx
movl $0x5000, %ebp           # imm = 0x5000
addl %ebp, %edx
movzbl 0x11a59a(%rip), %r8d    # 0x12dd48
movl %ecx, %esi
callq 0x3d51a
movl (%r14), %edi
shll $0xc, %edi
movl (%r15), %ecx
shll $0xc, %ecx
addl %ecx, %ebx
addl %ebp, %ecx
movzbl 0x11a57b(%rip), %r8d    # 0x12dd48
movl %ebx, %esi
movl %edi, %edx
callq 0x3d51a
movl (%r14), %edx
shll $0xc, %edx
movl $0xfffff000, %ebx       # imm = 0xFFFFF000
leal (%rdx,%rbx), %edi
movl (%r15), %ecx
shll $0xc, %ecx
movl $0xffffb000, %ebp       # imm = 0xFFFFB000
addl %ebp, %edx
movzbl 0x11a54f(%rip), %r8d    # 0x12dd48
movl %ecx, %esi
callq 0x3d51a
movl (%r14), %edi
shll $0xc, %edi
movl (%r15), %ecx
shll $0xc, %ecx
addl %ecx, %ebx
addl %ebp, %ecx
movzbl 0x11a530(%rip), %r8d    # 0x12dd48
movl %ebx, %esi
movl %edi, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d51a
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: setoverheadviewport16
void setoverheadviewport16(void)
{
	bakydim16 = ydim16;
	bakytop16 = ytop16;
	ydim16 = yres - STATUS2DSIZ;
	ytop16 = 0;
}

// Assembly:
movl 0x11a537(%rip), %eax    # 0x12dd68
movl %eax, 0x907d9(%rip)     # 0xa4010
movl 0x11a52f(%rip), %eax    # 0x12dd6c
movl %eax, 0x907d1(%rip)     # 0xa4014
leaq 0x907ea(%rip), %rax     # 0xa4034
movl $0xffffff70, %ecx       # imm = 0xFFFFFF70
addl (%rax), %ecx
movl %ecx, 0x11a511(%rip)    # 0x12dd68
movl $0x0, 0x11a50b(%rip)    # 0x12dd6c
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: setstatusbarviewport16
void setstatusbarviewport16(void)
{
	bakydim16 = ydim16;
	bakytop16 = ytop16;
	ydim16 = STATUS2DSIZ;
	ytop16 = yres - STATUS2DSIZ;
}

// Assembly:
movl 0x11a500(%rip), %eax    # 0x12dd68
movl %eax, 0x907a2(%rip)     # 0xa4010
movl 0x11a4f8(%rip), %eax    # 0x12dd6c
movl %eax, 0x9079a(%rip)     # 0xa4014
movl $0x90, 0x11a4e4(%rip)   # 0x12dd68
leaq 0x907a9(%rip), %rax     # 0xa4034
movl $0xffffff70, %ecx       # imm = 0xFFFFFF70
addl (%rax), %ecx
movl %ecx, 0x11a4d4(%rip)    # 0x12dd6c
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: restoreviewport16
void restoreviewport16(void)
{
	if (bakytop16 < 0) {
		debugprintf("restoreviewport16: no viewport saved\n");
		return;
	}
	ydim16 = bakydim16;
	ytop16 = bakytop16;
	bakytop16 = bakydim16 = -1;
}

// Assembly:
movl 0x90775(%rip), %eax     # 0xa4014
testl %eax, %eax
js 0x138c7
movl 0x90767(%rip), %ecx     # 0xa4010
movl %ecx, 0x11a4b9(%rip)    # 0x12dd68
movl %eax, 0x11a4b7(%rip)    # 0x12dd6c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x90750(%rip)     # 0xa4010
movl %eax, 0x9074e(%rip)     # 0xa4014
retq
leaq 0x60cb2(%rip), %rdi     # 0x74580
xorl %eax, %eax
jmp 0x6e05b
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: fixrepeats
void fixrepeats(short i)
{
	int dax, day, dist;

	dax = wall[wall[i].point2].x-wall[i].x;
	day = wall[wall[i].point2].y-wall[i].y;
	dist = ksqrt(dax*dax+day*day);
	dax = wall[i].xrepeat; day = wall[i].yrepeat;
	wall[i].xrepeat = (unsigned char)min(max(mulscale10(dist,day),1),255);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq %edi, %rbx
shlq $0x5, %rbx
leaq 0x1a0e30(%rip), %r14    # 0x1b8a50
movswq 0x8(%r14,%rbx), %rax
shlq $0x5, %rax
movl (%r14,%rax), %ecx
movl 0x4(%r14,%rax), %edi
subl (%r14,%rbx), %ecx
subl 0x4(%r14,%rbx), %edi
imull %ecx, %ecx
imull %edi, %edi
addl %ecx, %edi
callq 0x3699d
movzbl 0x17(%r14,%rbx), %ecx
cltq
imulq %rcx, %rax
shrq $0xa, %rax
movl $0xff, %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
cmpl $0x2, %eax
movl $0x1, %eax
cmovgel %ecx, %eax
movb %al, 0x16(%r14,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: changechar
unsigned char changechar(unsigned char dachar, int dadir, unsigned char smooshyalign, unsigned char boundcheck)
{
	if (dadir < 0)
	{
		if ((dachar > 0) || (boundcheck == 0))
		{
			dachar--;
			if (smooshyalign > 0)
				dachar = (dachar&0xf8);
		}
	}
	else if (dadir > 0)
	{
		if ((dachar < 255) || (boundcheck == 0))
		{
			dachar++;
			if (smooshyalign > 0)
			{
				if (dachar >= 256-8) dachar = 255;
				else dachar = ((dachar+7)&0xf8);
			}
		}
	}
	return(dachar);
}

// Assembly:
testl %esi, %esi
js 0x183f2
je 0x183ef
cmpb $-0x1, %dil
sete %sil
testb %cl, %cl
setne %cl
movb $-0x1, %al
testb %cl, %sil
jne 0x183f1
leal 0x1(%rdi), %ecx
testb %dl, %dl
je 0x18419
cmpb $-0x9, %cl
ja 0x183f1
andb $-0x8, %dil
addb $0x8, %dil
movl %edi, %eax
retq
testb %dil, %dil
sete %al
testb %cl, %cl
setne %cl
testb %cl, %al
jne 0x18416
decb %dil
movzbl %dil, %ecx
andb $-0x8, %dil
testb %dl, %dl
movzbl %dil, %eax
cmovel %ecx, %eax
retq
xorl %eax, %eax
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: getnumber256
short getnumber256(char *namestart, short num, int maxnumber, char sign)
{
	char buffer[80], ch;
	int n, danum, oldnum;

	danum = (int)num;
	oldnum = danum;
	bflushchars();
	while (keystatus[0x1] == 0)
	{
		if (handleevents()) {
			if (quitevent) quitevent = 0;
		}

		drawrooms(posx,posy,posz,ang,horiz,cursectnum);
		ExtAnalyzeSprites();
		drawmasks();

		ch = bgetchar();

		snprintf(buffer, sizeof(buffer), "%s%d_ ",namestart,danum);
		printmessage256(buffer);
		showframe();

		if (ch >= '0' && ch <= '9') {
			if (sign && danum<0)
				n = (danum*10)-(ch-'0');
			else
				n = (danum*10)+(ch-'0');
			if (n < maxnumber) danum = n;
		} else if (ch == 8 || ch == 127) {	// backspace
			danum /= 10;
		} else if (ch == 13) {
			oldnum = danum;
			asksave = 1;
			break;
		} else if (ch == '-' && sign) {	// negate
			danum = -danum;
		}
	}
	clearkeys();

	lockclock = totalclock;  //Reset timing

	return((short)oldnum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, %r15
callq 0x1f0c4
leaq 0x165c80(%rip), %rax    # 0x17e290
cmpb $0x0, 0x1(%rax)
jne 0x18741
movl %r14d, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
movswl %bx, %r12d
leaq 0x10(%rsp), %rbx
movq %rax, %r14
callq 0x6f32a
testl %eax, %eax
je 0x1864e
leaq 0x165a61(%rip), %rax    # 0x17e0a0
cmpb $0x0, (%rax)
je 0x1864e
leaq 0x165a55(%rip), %rax    # 0x17e0a0
movb $0x0, (%rax)
movl 0x1156fc(%rip), %edi    # 0x12dd50
movl 0x1156fa(%rip), %esi    # 0x12dd54
movl 0x1156f8(%rip), %edx    # 0x12dd58
movswl 0x1156f5(%rip), %ecx    # 0x12dd5c
movl 0x8b962(%rip), %r8d     # 0xa3fd0
movswl 0x1156e8(%rip), %r9d    # 0x12dd5e
callq 0x25e5d
callq 0xacdc
callq 0x29bd8
callq 0x1f08a
movl %eax, %r13d
movl $0x50, %esi
movq %rbx, %rdi
leaq 0x5c46e(%rip), %rdx     # 0x74b0a
movq %r15, %rcx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x64f0
movq %rbx, %rdi
callq 0x13554
callq 0x6efcd
leal -0x30(%r13), %ecx
movzbl %r13b, %eax
cmpb $0x9, %cl
ja 0x186ee
leal (%r12,%r12), %ecx
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx), %edx
addl $-0x30, %edx
subl %eax, %ecx
addl $0x30, %ecx
testl %r12d, %r12d
cmovnsl %edx, %ecx
testb %bpl, %bpl
cmovel %edx, %ecx
cmpl 0xc(%rsp), %ecx
cmovgel %r12d, %ecx
movl %ecx, %r12d
jmp 0x1872f
cmpb $0x8, %r13b
je 0x18717
cmpl $0x7f, %eax
je 0x18717
cmpl $0xd, %eax
je 0x18774
movl %r12d, %eax
negl %eax
cmpb $0x2d, %r13b
cmovnel %r12d, %eax
testb %bpl, %bpl
cmovel %r12d, %eax
movl %eax, %r12d
jmp 0x1872f
movslq %r12d, %rax
imulq $0x66666667, %rax, %r12 # imm = 0x66666667
movq %r12, %rax
shrq $0x3f, %rax
sarq $0x22, %r12
addl %eax, %r12d
movq %r14, %rax
cmpb $0x0, 0x1(%r14)
je 0x1862c
movl 0x8(%rsp), %ebx
leaq 0x165b48(%rip), %rdi    # 0x17e290
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x62f0
leaq 0x393d8d(%rip), %rax    # 0x3ac4e8
movl (%rax), %eax
movl %eax, 0x1155fd(%rip)    # 0x12dd60
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movw $0x1, 0x1151a9(%rip)    # 0x12d926
movl %r12d, %ebx
jmp 0x18741
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: qsetmodeany
void qsetmodeany(int daxdim, int daydim)
{
	if (daxdim < 640) daxdim = 640;
	if (daydim < 480) daydim = 480;

	if (qsetmode != ((daxdim<<16)|(daydim&0xffff))) {
		if (setvideomode(daxdim, daydim, 8, fullscreen) < 0)
			return;
		setbrightness(0,NULL,4);

		xdim = xres;
		ydim = yres;
		pixelaspect = 65536;

		setvgapalette();

		setoverheadviewport16();
		bakydim16 = -1; bakytop16 = -1;
		halfxdim16 = xres >> 1;
		midydim16 = scale(200,yres,480);

		clearbuf((void *)(frameplace + (ydim16*bytesperline)), (bytesperline*STATUS2DSIZ) >> 2, 0x08080808l);
		clearbuf((void *)frameplace, (ydim16*bytesperline) >> 2, 0L);
	}

	qsetmode = ((daxdim<<16)|(daydim&0xffff));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movl %edi, %ecx
cmpl $0x281, %edi            # imm = 0x281
movl $0x280, %edi            # imm = 0x280
cmovgel %ecx, %edi
cmpl $0x1e1, %esi            # imm = 0x1E1
movl $0x1e0, %esi            # imm = 0x1E0
cmovgel %eax, %esi
leaq 0x19fd63(%rip), %rbx    # 0x1b8a28
movl %edi, %eax
shll $0x10, %eax
movzwl %si, %ebp
orl %eax, %ebp
cmpl %ebp, (%rbx)
je 0x18de0
leaq 0x1653ca(%rip), %rax    # 0x17e0a8
movl (%rax), %ecx
movl $0x8, %edx
callq 0x6e817
testl %eax, %eax
js 0x18de2
xorl %edi, %edi
xorl %esi, %esi
movl $0x4, %edx
callq 0x348a4
leaq 0x8b329(%rip), %r14     # 0xa4030
movl (%r14), %eax
leaq 0x3ef2db(%rip), %rcx    # 0x407fec
movl %eax, (%rcx)
leaq 0x8b31a(%rip), %r15     # 0xa4034
movl (%r15), %eax
leaq 0x3ef2cc(%rip), %rcx    # 0x407ff0
movl %eax, (%rcx)
leaq 0x3fdf4b(%rip), %rax    # 0x416c78
movl $0x10000, (%rax)        # imm = 0x10000
callq 0x3c32f
movslq (%r15), %rax
leaq -0x90(%rax), %rsi
movl %esi, 0x115020(%rip)    # 0x12dd68
movl $0x0, 0x11501a(%rip)    # 0x12dd6c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, 0x8b2b3(%rip)     # 0xa4010
movl %ecx, 0x8b2b1(%rip)     # 0xa4014
movl (%r14), %ecx
sarl %ecx
movl %ecx, 0x161456(%rip)    # 0x17a1c4
imulq $0xc8, %rax, %rcx
movabsq $-0x7777777777777777, %rdx # imm = 0x8888888888888889
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x8, %rdx
addl %eax, %edx
leaq 0x1654e8(%rip), %r14    # 0x17e284
movslq (%r14), %rax
movq %rax, %rdi
imulq %rsi, %rdi
leaq 0x165303(%rip), %r15    # 0x17e0b0
addq (%r15), %rdi
movl %edx, 0x161412(%rip)    # 0x17a1c8
shll $0x4, %eax
leal (%rax,%rax,8), %esi
sarl $0x2, %esi
movl $0x8080808, %edx        # imm = 0x8080808
callq 0x4d2d8
movq (%r15), %rdi
movl (%r14), %esi
imull 0x114f92(%rip), %esi    # 0x12dd68
sarl $0x2, %esi
xorl %edx, %edx
callq 0x4d2d8
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: printext16
void printext16(int xpos, int ypos, short col, short backcol, const char *name, char fontsize)
{
	int stx, i, x, y;
	const unsigned char *letptr;
	unsigned char *ptr;
	const struct textfontspec *f;

	f = &textfonts[min((unsigned)fontsize, 2)];
	stx = xpos;

	for(i=0;name[i];i++)
	{
		letptr = &f->font[((int)(unsigned char)name[i])*f->cellh + f->cellyoff];
		ptr = (unsigned char *)(bytesperline*(ytop16+ypos+f->charysiz-1)+stx+frameplace);
		for(y=f->charysiz-1;y>=0;y--)
		{
			for(x=f->charxsiz-1;x>=0;x--)
			{
				if (letptr[y]&pow2char[7-x-f->cellxoff])
					ptr[x] = (unsigned char)col;
				else if (backcol >= 0)
					ptr[x] = (unsigned char)backcol;
			}
			ptr -= bytesperline;
		}
		stx += f->charxsiz;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, -0x38(%rsp)
movl %edi, -0x34(%rsp)
movq %r8, -0x10(%rsp)
movb (%r8), %sil
testb %sil, %sil
je 0x192bd
movzbl %r9b, %eax
cmpb $0x2, %al
movl $0x2, %edi
cmovbl %eax, %edi
movzbl %dil, %edi
shll $0x5, %edi
leaq 0x798a4(%rip), %r8      # 0x92a40
leaq (%r8,%rdi), %rax
movq (%r8,%rdi), %r9
movq %r9, -0x18(%rsp)
movslq 0x10(%r8,%rdi), %r9
movq %r9, -0x20(%rsp)
movslq 0x18(%r8,%rdi), %r9
movq %r9, -0x28(%rsp)
movl 0xc(%r8,%rdi), %r9d
movq %r9, -0x30(%rsp)
decl -0x38(%rsp)
movslq 0x8(%r8,%rdi), %r14
movq %r14, %r8
incq %r8
xorl %edi, %edi
leaq 0x8b5c1(%rip), %r13     # 0xa47a0
movq %rdi, -0x8(%rsp)
cmpl $0x0, -0x30(%rsp)
jle 0x1929d
movzbl %sil, %r9d
imulq -0x20(%rsp), %r9
addq -0x28(%rsp), %r9
addq -0x18(%rsp), %r9
movl 0x114b63(%rip), %esi    # 0x12dd6c
addl -0x38(%rsp), %esi
movq -0x30(%rsp), %r10
addl %r10d, %esi
leaq 0x165068(%rip), %rdi    # 0x17e284
movl (%rdi), %r11d
imull %r11d, %esi
addl -0x34(%rsp), %esi
movslq %esi, %rsi
leaq 0x164e7f(%rip), %rdi    # 0x17e0b0
addq (%rdi), %rsi
leaq -0x1(%r10), %rbx
testl %r14d, %r14d
jle 0x1928e
movl 0x14(%rax), %ebp
addl %r14d, %ebp
movl $0x8, %r11d
subl %ebp, %r11d
movq %r8, %r15
testw %cx, %cx
sets %dil
movslq %r11d, %rbp
movb (%r13,%rbp), %bpl
andb (%r9,%rbx), %bpl
sete %r12b
testb %dil, %r12b
jne 0x19278
testb %bpl, %bpl
movl %ecx, %edi
cmovnel %edx, %edi
movb %dil, -0x2(%rsi,%r15)
decq %r15
incl %r11d
cmpq $0x1, %r15
jg 0x1924f
leaq 0x164ff9(%rip), %rdi    # 0x17e284
movl (%rdi), %r11d
movslq %r11d, %rdi
subq %rdi, %rsi
cmpq $0x1, %r10
movq %rbx, %r10
jg 0x19234
addl %r14d, -0x34(%rsp)
movq -0x10(%rsp), %rsi
movq -0x8(%rsp), %rdi
movb 0x1(%rsi,%rdi), %sil
incq %rdi
testb %sil, %sil
jne 0x191df
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: printmessage16
void printmessage16(char *name)
{
	char snotbuf[60];
	int i;

	i = 0;
	while ((name[i] != 0) && (i < 54))
	{
		snotbuf[i] = name[i];
		i++;
	}
	while (i < 54)
	{
		snotbuf[i] = 32;
		i++;
	}
	snotbuf[54] = 0;

	setstatusbarviewport16();
	printext16(200L, 8L, 0, 6, snotbuf, 0);
	restoreviewport16();
}

// Assembly:
subq $0x48, %rsp
movb (%rdi), %dl
testb %dl, %dl
je 0x192f8
xorl %ecx, %ecx
movb %dl, (%rsp,%rcx)
leaq 0x1(%rcx), %rax
cmpq $0x34, %rcx
ja 0x192ec
movb 0x1(%rdi,%rcx), %dl
movq %rax, %rcx
testb %dl, %dl
jne 0x192d4
leaq -0x1(%rax), %rcx
cmpq $0x34, %rcx
jbe 0x192fa
jmp 0x19311
xorl %eax, %eax
movl %eax, %ecx
leaq (%rsp,%rcx), %rdi
movl $0x36, %edx
subl %eax, %edx
movl $0x20, %esi
callq 0x62f0
movq %rsp, %r8
movb $0x0, 0x36(%r8)
movl 0x114a49(%rip), %eax    # 0x12dd68
movl %eax, 0x8aceb(%rip)     # 0xa4010
movl 0x114a41(%rip), %eax    # 0x12dd6c
movl %eax, 0x8ace3(%rip)     # 0xa4014
movl $0x90, 0x114a2d(%rip)   # 0x12dd68
leaq 0x8acf2(%rip), %rax     # 0xa4034
movl $0xffffff70, %ecx       # imm = 0xFFFFFF70
addl (%rax), %ecx
movl %ecx, 0x114a1d(%rip)    # 0x12dd6c
movl $0xc8, %edi
movl $0x8, %esi
xorl %edx, %edx
movl $0x6, %ecx
xorl %r9d, %r9d
callq 0x1915d
movl 0x8aca6(%rip), %eax     # 0xa4014
testl %eax, %eax
js 0x1939a
movl 0x8ac98(%rip), %ecx     # 0xa4010
movl %ecx, 0x1149ea(%rip)    # 0x12dd68
movl %eax, 0x1149e8(%rip)    # 0x12dd6c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8ac81(%rip)     # 0xa4010
movl %eax, 0x8ac7f(%rip)     # 0xa4014
addq $0x48, %rsp
retq
leaq 0x5b1df(%rip), %rdi     # 0x74580
xorl %eax, %eax
addq $0x48, %rsp
jmp 0x6e05b
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: getpoint
void getpoint(int searchxe, int searchye, int *x, int *y)
{
	if (posx <= -editorgridextent) posx = -editorgridextent;
	if (posx >= editorgridextent) posx = editorgridextent;
	if (posy <= -editorgridextent) posy = -editorgridextent;
	if (posy >= editorgridextent) posy = editorgridextent;

	*x = posx + divscale14(searchxe-halfxdim16,zoom);
	*y = posy + divscale14(searchye-midydim16,zoom);

	if (*x <= -editorgridextent) *x = -editorgridextent;
	if (*x >= editorgridextent) *x = editorgridextent;
	if (*y <= -editorgridextent) *y = -editorgridextent;
	if (*y >= editorgridextent) *y = editorgridextent;
}

// Assembly:
pushq %rbx
movq %rdx, %r8
movl 0x114999(%rip), %r10d   # 0x12dd50
leaq 0x8b3de(%rip), %r9      # 0xa479c
movl (%r9), %eax
movl %eax, %edx
negl %edx
cmpl %edx, %r10d
setg %r11b
cmovlel %edx, %r10d
cmpl %eax, %r10d
setl %bl
cmovgel %eax, %r10d
testb %bl, %r11b
jne 0x193e6
movl %r10d, 0x11496a(%rip)   # 0x12dd50
movl 0x114967(%rip), %r11d   # 0x12dd54
cmpl %edx, %r11d
cmovgl %r11d, %edx
setg %r11b
cmpl %eax, %edx
setl %bl
testb %bl, %r11b
jne 0x1940d
cmpl %eax, %edx
cmovll %edx, %eax
movl %eax, 0x114947(%rip)    # 0x12dd54
movslq 0x160db0(%rip), %rdx    # 0x17a1c4
movslq %edi, %rax
subq %rdx, %rax
movslq 0x8abe3(%rip), %rdi     # 0xa4004
shlq $0xe, %rax
cqto
idivq %rdi
addl %eax, %r10d
movl %r10d, (%r8)
movslq 0x160d91(%rip), %rdx    # 0x17a1c8
movslq %esi, %rax
subq %rdx, %rax
movslq 0x8abc0(%rip), %rsi     # 0xa4004
shlq $0xe, %rax
cqto
idivq %rsi
addl 0x114901(%rip), %eax    # 0x12dd54
movl %eax, (%rcx)
movl (%r8), %edx
movl (%r9), %eax
movl %eax, %esi
negl %esi
cmpl %esi, %edx
jg 0x1946b
movl %esi, (%r8)
movl (%r9), %eax
movl %esi, %edx
cmpl %eax, %edx
jl 0x19475
movl %eax, (%r8)
movl (%r9), %eax
movl (%rcx), %edx
movl %eax, %esi
negl %esi
cmpl %esi, %edx
jg 0x19486
movl %esi, (%rcx)
movl (%r9), %eax
movl %esi, %edx
cmpl %eax, %edx
jl 0x1948c
movl %eax, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: getlinehighlight
int getlinehighlight(int xplc, int yplc)
{
	int i, dst, dist, closest, x1, y1, x2, y2, nx, ny;

	if (numwalls == 0)
		return(-1);
	dist = 0x7fffffff;
	closest = numwalls-1;
	for(i=0;i<numwalls;i++)
	{
		getclosestpointonwall(xplc,yplc,i,&nx,&ny);
		dst = klabs(xplc-nx)+klabs(yplc-ny);
		if (dst <= dist)
			dist = dst, closest = i;
	}

	if (wall[closest].nextwall >= 0)
	{    //if red line, allow highlighting of both sides
		x1 = wall[closest].x;
		y1 = wall[closest].y;
		x2 = wall[wall[closest].point2].x;
		y2 = wall[wall[closest].point2].y;
		if (dmulscale32(xplc-x1,y2-y1,-(x2-x1),yplc-y1) >= 0)
			closest = wall[closest].nextwall;
	}

	return(closest);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3fd7c8(%rip), %rax    # 0x416c68
movswl (%rax), %r12d
testl %r12d, %r12d
je 0x1955f
movl %esi, %ebp
movl %edi, %r14d
leal -0x1(%r12), %ebx
testw %r12w, %r12w
jle 0x1950a
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movl %r14d, %edi
movl %ebp, %esi
movl %r15d, %edx
leaq 0x4(%rsp), %rcx
movq %rsp, %r8
callq 0x1ac67
movl %r14d, %eax
subl 0x4(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %ebp, %eax
subl (%rsp), %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
addl %ecx, %edx
cmpl %r13d, %edx
cmovlel %r15d, %ebx
cmovll %edx, %r13d
incl %r15d
cmpl %r15d, %r12d
jne 0x194c6
movslq %ebx, %rdx
shlq $0x5, %rdx
leaq 0x19f538(%rip), %rcx    # 0x1b8a50
movswl 0xa(%rcx,%rdx), %eax
testl %eax, %eax
js 0x19564
addq %rcx, %rdx
movslq (%rdx), %rsi
movslq 0x4(%rdx), %rdi
movswq 0x8(%rdx), %rdx
shlq $0x5, %rdx
movslq (%rcx,%rdx), %r8
movslq 0x4(%rcx,%rdx), %rcx
movslq %r14d, %rdx
subq %rsi, %rdx
subq %rdi, %rcx
imulq %rdx, %rcx
subq %r8, %rsi
movslq %ebp, %rdx
subq %rdi, %rdx
imulq %rsi, %rdx
addq %rcx, %rdx
cmovnsl %eax, %ebx
jmp 0x19564
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: adjustmark
int adjustmark(int *xplc, int *yplc, short danumwalls)
{
	int i, dst, dist, dax, day, pointlockdist;

	if (danumwalls < 0)
		danumwalls = numwalls;

	pointlockdist = 0;
	if ((grid > 0) && (gridlock > 0))
		pointlockdist = (128>>grid);

	dist = pointlockdist;
	dax = *xplc;
	day = *yplc;
	for(i=0;i<danumwalls;i++)
	{
		dst = klabs((*xplc)-wall[i].x) + klabs((*yplc)-wall[i].y);
		if (dst < dist)
		{
			dist = dst;
			dax = wall[i].x;
			day = wall[i].y;
		}
	}
	if (dist == pointlockdist)
		if ((gridlock > 0) && (grid > 0))
		{
			dax = ((dax+(1024>>grid))&(0xffffffff<<(11-grid)));
			day = ((day+(1024>>grid))&(0xffffffff<<(11-grid)));
		}

	*xplc = dax;
	*yplc = day;
	return(0);
}

// Assembly:
testw %dx, %dx
jns 0x19584
leaq 0x3fd6e7(%rip), %rax    # 0x416c68
movzwl (%rax), %edx
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movswl 0x8aa67(%rip), %ecx     # 0xa3ffc
movzwl 0x8aa61(%rip), %r9d     # 0xa3ffe
movl $0x80, %eax
shrl %cl, %eax
xorl %r8d, %r8d
movw %r9w, -0x12(%rsp)
testw %r9w, %r9w
cmovlel %r8d, %eax
testl %ecx, %ecx
cmovlel %r8d, %eax
movq %rdi, -0x10(%rsp)
movl (%rdi), %r9d
movq %rsi, -0x8(%rsp)
movl (%rsi), %edi
testw %dx, %dx
jle 0x1962d
movzwl %dx, %r14d
shll $0x5, %r14d
xorl %r15d, %r15d
leaq 0x19f46f(%rip), %r12    # 0x1b8a50
movl %edi, %edx
movl %r9d, %r8d
movl %eax, %ebx
movl (%r12,%r15), %ebp
movl 0x4(%r12,%r15), %r13d
movl %r9d, %r10d
subl %ebp, %r10d
movl %r10d, %esi
negl %esi
cmovsl %r10d, %esi
movl %edi, %r11d
subl %r13d, %r11d
movl %r11d, %r10d
negl %r10d
cmovsl %r11d, %r10d
addl %esi, %r10d
cmpl %ebx, %r10d
cmovll %r10d, %ebx
cmovll %ebp, %r8d
cmovll %r13d, %edx
addq $0x20, %r15
cmpq %r15, %r14
jne 0x195e8
jmp 0x19634
movl %eax, %ebx
movl %r9d, %r8d
movl %edi, %edx
cmpw $0x0, -0x12(%rsp)
setg %sil
testw %cx, %cx
setg %dil
cmpl %eax, %ebx
sete %al
andb %sil, %dil
andb %al, %dil
cmpb $0x1, %dil
jne 0x19674
movl $0x400, %esi            # imm = 0x400
shrl %cl, %esi
movb $0xb, %al
subb %cl, %al
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %edi
addl %esi, %r8d
andl %edi, %r8d
addl %esi, %edx
andl %edi, %edx
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movl %r8d, (%rcx)
movl %edx, (%rax)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: getclosestpointonwall
void getclosestpointonwall(int x, int y, int dawall, int *nx, int *ny)
{
	walltype *wal;
	int i, j, dx, dy;

    if (dawall < 0) { *nx = *ny = 0; return; }
	wal = &wall[dawall];
	dx = wall[wal->point2].x-wal->x;
	dy = wall[wal->point2].y-wal->y;
	i = dx*(x-wal->x) + dy*(y-wal->y);
	if (i <= 0) { *nx = wal->x; *ny = wal->y; return; }
	j = dx*dx+dy*dy;
	if (i >= j) { *nx = wal->x+dx; *ny = wal->y+dy; return; }
	i = divscale30(i,j);
	*nx = wal->x + mulscale30(dx,i);
	*ny = wal->y + mulscale30(dy,i);
}

// Assembly:
testl %edx, %edx
js 0x1acfa
pushq %r14
pushq %rbx
movl %edx, %edx
shlq $0x5, %rdx
leaq 0x19ddd1(%rip), %r14    # 0x1b8a50
leaq (%r14,%rdx), %r9
movswq 0x8(%r14,%rdx), %r10
shlq $0x5, %r10
movl (%r14,%r10), %eax
movl (%r14,%rdx), %r11d
movl %eax, %ebx
subl %r11d, %ebx
movslq 0x4(%r14,%r10), %r10
movslq 0x4(%r14,%rdx), %rdx
subq %rdx, %r10
subl %r11d, %edi
imull %ebx, %edi
subl %edx, %esi
imull %r10d, %esi
addl %edi, %esi
jle 0x1ad02
movl %ebx, %edi
imull %ebx, %edi
movl %r10d, %edx
imull %r10d, %edx
addl %edi, %edx
cmpl %edx, %esi
jge 0x1ad0b
movl %esi, %eax
shlq $0x1e, %rax
movl %edx, %esi
xorl %edx, %edx
divq %rsi
movslq %ebx, %rdx
cltq
imulq %rax, %rdx
shrq $0x1e, %rdx
addl %edx, %r11d
movl %r11d, (%rcx)
imulq %rax, %r10
shrq $0x1e, %r10
addl 0x4(%r9), %r10d
movl %r10d, (%r8)
jmp 0x1ad17
xorl %eax, %eax
movl %eax, (%r8)
movl %eax, (%rcx)
retq
movl %r11d, (%rcx)
movl 0x4(%r9), %eax
jmp 0x1ad14
movl %eax, (%rcx)
movl 0x4(%r9), %eax
addl %r10d, %eax
movl %eax, (%r8)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: getpointhighlight
int getpointhighlight(int xplc, int yplc)
{
	int i, dst, dist, closest;

	if (numwalls == 0)
		return(-1);

	dist = 0;
	if (grid > 0)
		dist = 1024;

	closest = -1;
	for(i=0;i<numwalls;i++)
	{
		dst = klabs(xplc-wall[i].x) + klabs(yplc-wall[i].y);
		if (dst <= dist)
			dist = dst, closest = i;
	}
	for(i=0;i<MAXSPRITES;i++)
		if (sprite[i].statnum < MAXSTATUS)
		{
			dst = klabs(xplc-sprite[i].x) + klabs(yplc-sprite[i].y);
			if (dst <= dist)
				dist = dst, closest = i+16384;
		}
	return(closest);
}

// Assembly:
pushq %rbx
leaq 0x3fbf45(%rip), %rax    # 0x416c68
movzwl (%rax), %edx
testq %rdx, %rdx
je 0x1ad8d
xorl %ecx, %ecx
cmpw $0x0, 0x892c7(%rip)     # 0xa3ffc
setg %cl
shll $0xa, %ecx
testw %dx, %dx
jle 0x1ad94
leaq 0x19dd09(%rip), %r8     # 0x1b8a50
addq $0x4, %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
movl %edi, %r10d
subl -0x4(%r8), %r10d
movl %r10d, %r11d
negl %r11d
cmovsl %r10d, %r11d
movl %esi, %r10d
subl (%r8), %r10d
movl %r10d, %ebx
negl %ebx
cmovsl %r10d, %ebx
addl %r11d, %ebx
cmpl %ecx, %ebx
cmovll %ebx, %ecx
cmovlel %r9d, %eax
incq %r9
addq $0x20, %r8
cmpq %r9, %rdx
jne 0x1ad53
jmp 0x1ad99
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1adf4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x261f10(%rip), %rdx    # 0x27ccb0
xorl %r8d, %r8d
cmpw $0x3ff, 0x1a(%rdx)      # imm = 0x3FF
jg 0x1ade4
movl %edi, %r9d
subl (%rdx), %r9d
movl %r9d, %r10d
negl %r10d
cmovsl %r9d, %r10d
movl %esi, %r9d
subl 0x4(%rdx), %r9d
movl %r9d, %r11d
negl %r11d
cmovsl %r9d, %r11d
addl %r10d, %r11d
movl %r8d, %r9d
orl $0x4000, %r9d           # imm = 0x4000
cmpl %ecx, %r11d
cmovll %r11d, %ecx
cmovlel %r9d, %eax
incq %r8
addq $0x2c, %rdx
cmpq $0x4000, %r8            # imm = 0x4000
jne 0x1ada3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: clearmidstatbar16
void clearmidstatbar16(void)
{
	setstatusbarviewport16();
	clearbuf((unsigned char *)(frameplace + (bytesperline*(ytop16+25L))),(bytesperline*(ydim16-1-(25<<1))) >> 2, 0x08080808l);
	drawline16(0,0,0,ydim16-1,7);
	drawline16(xdim-1,0,xdim-1,ydim16-1,7);
	restoreviewport16();
}

// Assembly:
pushq %rax
movl 0x112f6b(%rip), %eax    # 0x12dd68
movl %eax, 0x8920d(%rip)     # 0xa4010
movl 0x112f63(%rip), %eax    # 0x12dd6c
movl %eax, 0x89205(%rip)     # 0xa4014
movl $0x90, 0x112f4f(%rip)   # 0x12dd68
leaq 0x89214(%rip), %rax     # 0xa4034
movslq (%rax), %rdi
leal -0x90(%rdi), %eax
movl %eax, 0x112f3d(%rip)    # 0x12dd6c
leaq 0x16327a(%rip), %rax    # 0x17e0b0
leaq 0x163447(%rip), %rcx    # 0x17e284
movslq (%rcx), %rcx
addq $-0x77, %rdi
imulq %rcx, %rdi
addq (%rax), %rdi
imull $0x5d, %ecx, %esi
sarl $0x2, %esi
movl $0x8080808, %edx        # imm = 0x8080808
callq 0x4d2d8
movl 0x112f07(%rip), %ecx    # 0x12dd68
decl %ecx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movl $0x7, %r8d
callq 0x18ded
leaq 0x3ed171(%rip), %rax    # 0x407fec
movl (%rax), %edi
decl %edi
movl 0x112ee3(%rip), %ecx    # 0x12dd68
decl %ecx
xorl %esi, %esi
movl %edi, %edx
movl $0x7, %r8d
callq 0x18ded
movl 0x89178(%rip), %eax     # 0xa4014
testl %eax, %eax
js 0x1aec5
movl 0x8916a(%rip), %ecx     # 0xa4010
movl %ecx, 0x112ebc(%rip)    # 0x12dd68
movl %eax, 0x112eba(%rip)    # 0x12dd6c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x89153(%rip)     # 0xa4010
movl %eax, 0x89151(%rip)     # 0xa4014
popq %rax
retq
leaq 0x596b4(%rip), %rdi     # 0x74580
xorl %eax, %eax
popq %rcx
jmp 0x6e05b
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: getnumber16
short getnumber16(char *namestart, short num, int maxnumber, char sign)
{
	char buffer[80], ch;
	int n, danum, oldnum;

	danum = (int)num;
	oldnum = danum;
	bflushchars();
	while (keystatus[0x1] == 0)
	{
		if (handleevents()) {
			if (quitevent) quitevent = 0;
		}

		ch = bgetchar();

		snprintf(buffer, sizeof(buffer), "%s%d_ ",namestart,danum);
		printmessage16(buffer);
		showframe();

		if (ch >= '0' && ch <= '9') {
			if (sign && danum<0)
				n = (danum*10)-(ch-'0');
			else
				n = (danum*10)+(ch-'0');
			if (n < maxnumber) danum = n;
		} else if (ch == 8 || ch == 127) {	// backspace
			danum /= 10;
		} else if (ch == 13) {
			oldnum = danum;
			asksave = 1;
			break;
		} else if (ch == '-' && sign) {	// negate
			danum = -danum;
		}
	}
	clearkeys();
	return((short)oldnum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, %r15
callq 0x1f0c4
leaq 0x162e3a(%rip), %rax    # 0x17e290
cmpb $0x0, 0x1(%rax)
jne 0x1b550
movl %r14d, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
movswl %bx, %r12d
leaq 0x10(%rsp), %rbx
movq %rax, %r14
callq 0x6f32a
testl %eax, %eax
je 0x1b494
leaq 0x162c1b(%rip), %rax    # 0x17e0a0
cmpb $0x0, (%rax)
je 0x1b494
leaq 0x162c0f(%rip), %rax    # 0x17e0a0
movb $0x0, (%rax)
callq 0x1f08a
movl %eax, %r13d
movl $0x50, %esi
movq %rbx, %rdi
leaq 0x5965f(%rip), %rdx     # 0x74b0a
movq %r15, %rcx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x64f0
movq %rbx, %rdi
callq 0x192c8
callq 0x6efcd
leal -0x30(%r13), %ecx
movzbl %r13b, %eax
cmpb $0x9, %cl
ja 0x1b4fd
leal (%r12,%r12), %ecx
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx), %edx
addl $-0x30, %edx
subl %eax, %ecx
addl $0x30, %ecx
testl %r12d, %r12d
cmovnsl %edx, %ecx
testb %bpl, %bpl
cmovel %edx, %ecx
cmpl 0xc(%rsp), %ecx
cmovgel %r12d, %ecx
movl %ecx, %r12d
jmp 0x1b53e
cmpb $0x8, %r13b
je 0x1b526
cmpl $0x7f, %eax
je 0x1b526
cmpl $0xd, %eax
je 0x1b574
movl %r12d, %eax
negl %eax
cmpb $0x2d, %r13b
cmovnel %r12d, %eax
testb %bpl, %bpl
cmovel %r12d, %eax
movl %eax, %r12d
jmp 0x1b53e
movslq %r12d, %rax
imulq $0x66666667, %rax, %r12 # imm = 0x66666667
movq %r12, %rax
shrq $0x3f, %rax
sarq $0x22, %r12
addl %eax, %r12d
movq %r14, %rax
cmpb $0x0, 0x1(%r14)
je 0x1b472
movl 0x8(%rsp), %ebx
leaq 0x162d39(%rip), %rdi    # 0x17e290
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x62f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movw $0x1, 0x1123a9(%rip)    # 0x12d926
movl %r12d, %ebx
jmp 0x1b550
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: checksectorpointer
int checksectorpointer(short i, short sectnum)
{
	int j, k, startwall, endwall, x1, y1, x2, y2;

	x1 = wall[i].x;
	y1 = wall[i].y;
	x2 = wall[wall[i].point2].x;
	y2 = wall[wall[i].point2].y;

	if (wall[i].nextwall >= 0)          //Check for early exit
	{
		k = wall[i].nextwall;
		if ((wall[k].x == x2) && (wall[k].y == y2))
			if ((wall[wall[k].point2].x == x1) && (wall[wall[k].point2].y == y1))
				return(0);
	}

	wall[i].nextsector = -1;
	wall[i].nextwall = -1;
	for(j=0;j<numsectors;j++)
	{
		startwall = sector[j].wallptr;
		endwall = startwall + sector[j].wallnum - 1;
		for(k=startwall;k<=endwall;k++)
		{
			if ((wall[k].x == x2) && (wall[k].y == y2))
				if ((wall[wall[k].point2].x == x1) && (wall[wall[k].point2].y == y1))
					if (j != sectnum)
					{
						wall[i].nextsector = j;
						wall[i].nextwall = k;
						wall[k].nextsector = sectnum;
						wall[k].nextwall = i;
					}
		}
	}
	return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, -0x4(%rsp)
movslq %edi, %rax
shlq $0x5, %rax
leaq 0x19c986(%rip), %rcx    # 0x1b8a50
movl (%rcx,%rax), %edx
movl 0x4(%rcx,%rax), %r8d
movswq 0x8(%rcx,%rax), %rsi
shlq $0x5, %rsi
movl (%rcx,%rsi), %r9d
movl 0x4(%rcx,%rsi), %r10d
movswq 0xa(%rcx,%rax), %r11
testq %r11, %r11
js 0x1c11e
shlq $0x5, %r11
cmpl %r9d, (%rcx,%r11)
jne 0x1c11e
addq %rcx, %r11
cmpl %r10d, 0x4(%r11)
jne 0x1c11e
movswq 0x8(%r11), %rsi
shlq $0x5, %rsi
cmpl %edx, (%rcx,%rsi)
jne 0x1c11e
addq %rcx, %rsi
cmpl %r8d, 0x4(%rsi)
je 0x1c1cc
addq %rcx, %rax
movl $0xffffffff, 0xa(%rax)  # imm = 0xFFFFFFFF
leaq 0x3b3e31(%rip), %rsi    # 0x3cff60
movswq (%rsi), %r11
testq %r11, %r11
jle 0x1c1cc
movswq -0x4(%rsp), %rsi
movl %esi, %ebx
xorl %r14d, %r14d
leaq 0x227912(%rip), %rsi    # 0x243a60
leaq (%r14,%r14,4), %r15
movswq 0x2(%rsi,%r15,8), %r12
testq %r12, %r12
jle 0x1c1c4
leaq (%rsi,%r15,8), %r15
movswq (%r15), %r13
addq %r13, %r12
movq %r13, %r15
shlq $0x5, %r15
leaq (%rcx,%r15), %rbp
addq $0xc, %rbp
cmpl %r9d, -0xc(%rbp)
jne 0x1c1b8
cmpl %r10d, -0x8(%rbp)
jne 0x1c1b8
movswq -0x4(%rbp), %r15
shlq $0x5, %r15
cmpl %edx, (%rcx,%r15)
jne 0x1c1b8
cmpq %rbx, %r14
je 0x1c1b8
addq %rcx, %r15
cmpl %r8d, 0x4(%r15)
jne 0x1c1b8
movw %r14w, 0xc(%rax)
movw %r13w, 0xa(%rax)
movl -0x4(%rsp), %r15d
movw %r15w, (%rbp)
movw %di, -0x2(%rbp)
incq %r13
addq $0x20, %rbp
cmpq %r12, %r13
jl 0x1c177
incq %r14
cmpq %r11, %r14
jne 0x1c14e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: deletepoint
void deletepoint(short point)
{
	int i, j, k, sucksect;

	sucksect = sectorofwall(point);

	sector[sucksect].wallnum--;
	for(i=sucksect+1;i<numsectors;i++)
		sector[i].wallptr--;

	j = lastwall(point);
	k = wall[point].point2;
	wall[j].point2 = k;

	if (wall[j].nextwall >= 0)
	{
		wall[wall[j].nextwall].nextwall = -1;
		wall[wall[j].nextwall].nextsector = -1;
	}
	if (wall[point].nextwall >= 0)
	{
		wall[wall[point].nextwall].nextwall = -1;
		wall[wall[point].nextwall].nextsector = -1;
	}
	movewalls((int)point,-1L);

	checksectorpointer((short)j,(short)sucksect);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
callq 0x3cfa6
movl %eax, %ebx
cltq
leaq (%rax,%rax,4), %rax
leaq 0x22786d(%rip), %rcx    # 0x243a60
decw 0x2(%rcx,%rax,8)
leaq 0x3b3d61(%rip), %rax    # 0x3cff60
movswl (%rax), %edx
leal 0x1(%rbx), %eax
cmpl %edx, %eax
jge 0x1c22b
cltq
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0x76d86(%rip), %rax     # 0x92fa0
movl %ebx, %ecx
notl %ecx
addl %edx, %ecx
decw (%rax)
addq $0x28, %rax
decl %ecx
jne 0x1c220
movswl %bp, %r14d
movl %r14d, %edi
callq 0x2efee
movl %eax, %ebp
movswq %r14w, %rdx
shlq $0x5, %rdx
leaq 0x19c808(%rip), %rax    # 0x1b8a50
leaq (%rax,%rdx), %rcx
movzwl 0x8(%rax,%rdx), %esi
movslq %ebp, %rdx
shlq $0x5, %rdx
movw %si, 0x8(%rax,%rdx)
movswq 0xa(%rax,%rdx), %rsi
testq %rsi, %rsi
js 0x1c286
addq %rax, %rdx
shlq $0x5, %rsi
movw $0xffff, %di            # imm = 0xFFFF
movw %di, 0xa(%rax,%rsi)
movswq 0xa(%rdx), %rdx
shlq $0x5, %rdx
movw %di, 0xc(%rax,%rdx)
movswq 0xa(%rcx), %rdx
testq %rdx, %rdx
js 0x1c2ab
shlq $0x5, %rdx
movw $0xffff, %si            # imm = 0xFFFF
movw %si, 0xa(%rax,%rdx)
movswq 0xa(%rcx), %rcx
shlq $0x5, %rcx
movw %si, 0xc(%rax,%rcx)
movl %r14d, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1d6eb
movswl %bp, %edi
movswl %bx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1c0ae
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: checkautoinsert
int checkautoinsert(int dax, int day, short danumwalls)
{
	int i, x1, y1, x2, y2;

	if (danumwalls < 0)
		danumwalls = numwalls;
	for(i=0;i<danumwalls;i++)       // Check if a point should be inserted
	{
		x1 = wall[i].x;
		y1 = wall[i].y;
		x2 = wall[wall[i].point2].x;
		y2 = wall[wall[i].point2].y;

		if ((x1 != dax) || (y1 != day))
			if ((x2 != dax) || (y2 != day))
				if (((x1 <= dax) && (dax <= x2)) || ((x2 <= dax) && (dax <= x1)))
					if (((y1 <= day) && (day <= y2)) || ((y2 <= day) && (day <= y1)))
						if ((dax-x1)*(y2-y1) == (day-y1)*(x2-x1))
							return(1);          //insertpoint((short)i,dax,day);
	}
	return(0);
}

// Assembly:
pushq %rbp
pushq %rbx
testw %dx, %dx
jns 0x1cb91
leaq 0x3fa0da(%rip), %rax    # 0x416c68
movzwl (%rax), %edx
testw %dx, %dx
jle 0x1cc30
movzwl %dx, %eax
shll $0x5, %eax
xorl %ecx, %ecx
leaq 0x19bea7(%rip), %rdx    # 0x1b8a50
movl (%rdx,%rcx), %r8d
movl 0x4(%rdx,%rcx), %r9d
movl %edi, %r10d
xorl %r8d, %r10d
movl %esi, %r11d
xorl %r9d, %r11d
orl %r10d, %r11d
je 0x1cc23
movswq 0x8(%rdx,%rcx), %r11
shlq $0x5, %r11
movl (%rdx,%r11), %r10d
movl 0x4(%rdx,%r11), %r11d
movl %r10d, %ebx
xorl %edi, %ebx
movl %r11d, %ebp
xorl %esi, %ebp
orl %ebx, %ebp
je 0x1cc23
movl %edi, %ebx
subl %r8d, %ebx
jl 0x1cbf0
cmpl %edi, %r10d
jge 0x1cbfa
cmpl %r8d, %edi
jg 0x1cc23
cmpl %edi, %r10d
jg 0x1cc23
movl %esi, %ebp
subl %r9d, %ebp
jl 0x1cc06
cmpl %esi, %r11d
jge 0x1cc10
cmpl %esi, %r11d
jg 0x1cc23
cmpl %r9d, %esi
jg 0x1cc23
subl %r9d, %r11d
imull %ebx, %r11d
subl %r8d, %r10d
imull %ebp, %r10d
cmpl %r10d, %r11d
je 0x1cc35
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x1cba9
xorl %eax, %eax
popq %rbx
popq %rbp
retq
movl $0x1, %eax
jmp 0x1cc32
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: clockdir
int clockdir(short wallstart)   //Returns: 0 is CW, 1 is CCW
{
	short i, themin;
	int minx, templong, x0, x1, x2, y0, y1, y2;

	minx = 0x7fffffff;
	themin = -1;
	i = wallstart-1;
	do
	{
		i++;
		if (wall[wall[i].point2].x < minx)
		{
			minx = wall[wall[i].point2].x;
			themin = i;
		}
	}
	while ((wall[i].point2 != wallstart) && (i < MAXWALLS));

	x0 = wall[themin].x;
	y0 = wall[themin].y;
	x1 = wall[wall[themin].point2].x;
	y1 = wall[wall[themin].point2].y;
	x2 = wall[wall[wall[themin].point2].point2].x;
	y2 = wall[wall[wall[themin].point2].point2].y;

	if ((y1 >= y2) && (y1 <= y0)) return(0);
	if ((y1 >= y0) && (y1 <= y2)) return(1);

	templong = (x0-x1)*(y2-y1) - (x2-x1)*(y0-y1);
	if (templong < 0)
		return(0);
	else
		return(1);
}

// Assembly:
movw $0xffff, %cx            # imm = 0xFFFF
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq 0x19be04(%rip), %rax    # 0x1b8a50
movl %edi, %esi
movswq %si, %r8
movq %r8, %r9
shlq $0x5, %r9
movswq 0x8(%rax,%r9), %r9
movq %r9, %r10
shlq $0x5, %r10
movl (%rax,%r10), %r10d
cmpl %edx, %r10d
cmovll %r10d, %edx
cmovll %r8d, %ecx
cmpw %di, %r9w
je 0x1cc8e
incl %r8d
movswl %si, %r9d
movl %r8d, %esi
cmpl $0x4000, %r9d           # imm = 0x4000
jl 0x1cc4e
movswq %cx, %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %edx
movl 0x4(%rax,%rcx), %r8d
movswq 0x8(%rax,%rcx), %rcx
shlq $0x5, %rcx
movl (%rax,%rcx), %esi
movl 0x4(%rax,%rcx), %r9d
movswq 0x8(%rax,%rcx), %rdi
shlq $0x5, %rdi
movl (%rax,%rdi), %ecx
movl 0x4(%rax,%rdi), %r10d
movl %r10d, %edi
subl %r9d, %edi
jg 0x1ccd2
xorl %eax, %eax
cmpl %r8d, %r9d
jg 0x1ccd2
retq
movl %r9d, %r11d
subl %r8d, %r11d
jl 0x1cce4
movl $0x1, %eax
cmpl %r9d, %r10d
jge 0x1ccd1
subl %esi, %edx
imull %edx, %edi
subl %esi, %ecx
imull %r11d, %ecx
addl %edi, %ecx
notl %ecx
shrl $0x1f, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: flipwalls
void flipwalls(short numwalls, short newnumwalls)
{
	int i, j, nume, templong;

	nume = newnumwalls-numwalls;

	for(i=numwalls;i<numwalls+(nume>>1);i++)
	{
		j = numwalls+newnumwalls-i-1;
		templong = wall[i].x; wall[i].x = wall[j].x; wall[j].x = templong;
		templong = wall[i].y; wall[i].y = wall[j].y; wall[j].y = templong;
	}
}

// Assembly:
movl %esi, %ecx
subl %edi, %ecx
sarl %ecx
testl %ecx, %ecx
jle 0x1cd48
addl %edi, %ecx
movswq %di, %rax
movslq %ecx, %rcx
movq %rax, %rdx
shlq $0x5, %rdx
leaq 0x19bd36(%rip), %rdi    # 0x1b8a50
addq %rdi, %rdx
movswq %si, %rsi
shlq $0x5, %rsi
addq %rdi, %rsi
addq $-0x20, %rsi
movq (%rdx), %rdi
movq (%rsi), %r8
movq %r8, (%rdx)
movq %rdi, (%rsi)
incq %rax
addq $0x20, %rdx
addq $-0x20, %rsi
cmpq %rcx, %rax
jl 0x1cd2c
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/build.c
// Function: loopinside
short loopinside(int x, int y, short startwall)
{
	int x1, y1, x2, y2, templong;
	short i, cnt;

	cnt = clockdir(startwall);
	i = startwall;
	do
	{
		x1 = wall[i].x; x2 = wall[wall[i].point2].x;
		if ((x1 >= x) || (x2 >= x))
		{
			y1 = wall[i].y; y2 = wall[wall[i].point2].y;
			if (y1 > y2)
			{
				templong = x1, x1 = x2, x2 = templong;
				templong = y1, y1 = y2, y2 = templong;
			}
			if ((y1 <= y) && (y2 > y))
				if (x1*(y-y2)+x2*(y1-y) <= x*(y1-y2))
					cnt ^= 1;
		}
		i = wall[i].point2;
	}
	while (i != startwall);
	return(cnt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movl %edx, %edi
callq 0x1cc3c
movslq %ebx, %rdx
shlq $0x5, %rdx
leaq 0x19bce4(%rip), %rcx    # 0x1b8a50
movl (%rcx,%rdx), %esi
movl %ebx, %edx
movl %esi, %edi
movswq %dx, %r8
shlq $0x5, %r8
movzwl 0x8(%rcx,%r8), %edx
movswq %dx, %r9
shlq $0x5, %r9
movl (%rcx,%r9), %esi
cmpl %r14d, %edi
setl %r10b
cmpl %r14d, %esi
setl %r11b
testb %r11b, %r10b
jne 0x1cdf1
addq %rcx, %r8
movl 0x4(%r8), %r8d
movl 0x4(%rcx,%r9), %r11d
cmpl %r11d, %r8d
jle 0x1cdbb
movl %r11d, %r9d
movl %edi, %r10d
movl %esi, %edi
jmp 0x1cdc4
movl %r8d, %r9d
movl %esi, %r10d
movl %r11d, %r8d
movl %r9d, %r11d
subl %ebp, %r11d
jg 0x1cdf1
movl %ebp, %r15d
subl %r8d, %r15d
jge 0x1cdf1
imull %r15d, %edi
imull %r11d, %r10d
addl %edi, %r10d
subl %r8d, %r9d
imull %r14d, %r9d
xorl %edi, %edi
cmpl %r9d, %r10d
setle %dil
xorl %edi, %eax
cmpw %bx, %dx
jne 0x1cd71
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq