LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_setview
void polymost_setview(void)
{
	memset(gdrawroomsprojmat,0,sizeof(gdrawroomsprojmat));
	gdrawroomsprojmat[0][0] = (float)ydimen; gdrawroomsprojmat[0][2] = 1.0;
	gdrawroomsprojmat[1][1] = (float)xdimen; gdrawroomsprojmat[1][2] = 1.0;
	gdrawroomsprojmat[2][2] = 1.0; gdrawroomsprojmat[2][3] = (float)ydimen;
	gdrawroomsprojmat[3][2] =-1.0;

	memset(grotatespriteprojmat,0,sizeof(grotatespriteprojmat));
	grotatespriteprojmat[0][0] = grotatespriteprojmat[2][3] = 1.0;
	grotatespriteprojmat[1][1] = ((float)xdim)/((float)ydim);
	grotatespriteprojmat[2][2] = 1.0001;
	grotatespriteprojmat[3][2] = 1-grotatespriteprojmat[2][2];

	memset(gorthoprojmat,0,sizeof(gorthoprojmat));
	gorthoprojmat[0][0] = 2/(float)xdim;
	gorthoprojmat[1][1] = -2/(float)ydim;
	gorthoprojmat[2][2] = -1.0;
	gorthoprojmat[3][3] = 1.0;
	gorthoprojmat[3][0] = -1.0;
	gorthoprojmat[3][1] = 1.0;
}

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, 0x5a9e3f(%rip)   # 0x5faa60
movaps %xmm0, 0x5a9e48(%rip)   # 0x5faa70
leaq 0x22ae65(%rip), %rax    # 0x27ba94
cvtsi2ssl (%rax), %xmm1
movaps %xmm0, 0x5a9e46(%rip)   # 0x5faa80
movaps %xmm0, 0x5a9e4f(%rip)   # 0x5faa90
movss %xmm1, 0x5a9e17(%rip)   # 0x5faa60
movl $0x3f800000, %eax       # imm = 0x3F800000
leaq 0x53bdb(%rip), %rcx     # 0xa4830
cvtsi2ssl (%rcx), %xmm2
movl %eax, 0x5a9e09(%rip)    # 0x5faa68
movss %xmm2, 0x5a9e0d(%rip)   # 0x5faa74
movl %eax, 0x5a9e0b(%rip)    # 0x5faa78
movl %eax, 0x5a9e15(%rip)    # 0x5faa88
movss %xmm1, 0x5a9e11(%rip)   # 0x5faa8c
movl $0xbf800000, %ecx       # imm = 0xBF800000
movl %ecx, 0x5a9e12(%rip)    # 0x5faa98
movaps %xmm0, 0x5a9e13(%rip)   # 0x5faaa0
movaps %xmm0, 0x5a9e1c(%rip)   # 0x5faab0
movaps %xmm0, 0x5a9e25(%rip)   # 0x5faac0
movaps %xmm0, 0x5a9e2e(%rip)   # 0x5faad0
movl %eax, 0x5a9df8(%rip)    # 0x5faaa0
leaq 0x3b733d(%rip), %rdx    # 0x407fec
xorps %xmm1, %xmm1
cvtsi2ssl (%rdx), %xmm1
leaq 0x3b7333(%rip), %rdx    # 0x407ff0
xorps %xmm2, %xmm2
cvtsi2ssl (%rdx), %xmm2
movss 0x298c0(%rip), %xmm3    # 0x7a58c
divss %xmm1, %xmm3
divss %xmm2, %xmm1
movss %xmm1, 0x5a9dd8(%rip)   # 0x5faab4
movsd 0x298ec(%rip), %xmm1    # 0x7a5d0
movsd %xmm1, 0x5a9ddc(%rip)   # 0x5faac8
movl $0xb8d1c000, 0x5a9de2(%rip) # imm = 0xB8D1C000
movaps %xmm0, 0x5a9de3(%rip)   # 0x5faae0
movaps %xmm0, 0x5a9dec(%rip)   # 0x5faaf0
movaps %xmm0, 0x5a9df5(%rip)   # 0x5fab00
movaps %xmm0, 0x5a9dfe(%rip)   # 0x5fab10
movss %xmm3, 0x5a9dc6(%rip)   # 0x5faae0
movss 0x2986e(%rip), %xmm0    # 0x7a590
divss %xmm2, %xmm0
movss %xmm0, 0x5a9dc6(%rip)   # 0x5faaf4
movl %ecx, 0x5a9dd4(%rip)    # 0x5fab08
movl %eax, 0x5a9de2(%rip)    # 0x5fab1c
movsd 0x2989e(%rip), %xmm0    # 0x7a5e0
movsd %xmm0, 0x5a9dc6(%rip)   # 0x5fab10
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: checkindexbuffer
static void checkindexbuffer(unsigned int size)
{
	GLushort *indexes, i;

	if (size <= elementindexbuffersize) return;

	indexes = (GLushort *) malloc(sizeof(GLushort)*size);
	for (i = 0; i < size; i++) indexes[i] = i;
	glfunc.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementindexbuffer);
	glfunc.glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort)*size, indexes, GL_STATIC_DRAW);
	free(indexes);

	elementindexbuffersize = size;
}

// Assembly:
cmpl %edi, 0x5a9a3e(%rip)    # 0x5fa9d8
jae 0x51015
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %r14d
addq %r14, %r14
movq %r14, %rdi
callq 0x69a0
movq %rax, %r15
xorl %eax, %eax
movzwl %ax, %ecx
movw %cx, (%r15,%rcx,2)
incl %eax
movzwl %ax, %ecx
cmpl %ebx, %ecx
jb 0x50fb9
leaq 0x5a976f(%rip), %r12    # 0x5fa740
movl 0x5a99fd(%rip), %esi    # 0x5fa9d4
movl $0x8893, %edi           # imm = 0x8893
callq *0xf8(%r12)
movl $0x8893, %edi           # imm = 0x8893
movq %r14, %rsi
movq %r15, %rdx
movl $0x88e4, %ecx           # imm = 0x88E4
callq *0x100(%r12)
movq %r15, %rdi
callq 0x61c0
movl %ebx, 0x5a99ce(%rip)    # 0x5fa9d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_nextpage
static void polymost_palfade(void)
{
	struct polymostdrawauxcall draw;
	struct polymostvboitem vboitem[4];

	if ((rendmode != 3) || (qsetmode != 200)) return;
	if (palfadedelta == 0) return;

	draw.mode = 2;	// Solid colour.

	draw.colour.r = palfadergb.r / 255.f;
	draw.colour.g = palfadergb.g / 255.f;
	draw.colour.b = palfadergb.b / 255.f;
	draw.colour.a = palfadedelta / 255.f;

	vboitem[0].v.x = 0.f;
	vboitem[0].v.y = 0.f;
	vboitem[0].v.z = 0.f;

	vboitem[1].v.x = (float)xdim;
	vboitem[1].v.y = 0.f;
	vboitem[1].v.z = 0.f;

	vboitem[2].v.x = (float)xdim;
	vboitem[2].v.y = (float)ydim;
	vboitem[2].v.z = 0.f;

	vboitem[3].v.x = 0.f;
	vboitem[3].v.y = (float)ydim;
	vboitem[3].v.z = 0.f;

	draw.indexcount = 4;
	draw.indexes = NULL;
	draw.elementcount = 4;
	draw.elementvbo = vboitem;

	glfunc.glDisable(GL_DEPTH_TEST);
	glfunc.glEnable(GL_BLEND);

	polymost_drawaux_glcall(GL_TRIANGLE_FAN, &draw);
}

// Assembly:
movl 0x5a9934(%rip), %eax    # 0x5fa950
xorl $0x3, %eax
leaq 0x167a02(%rip), %rcx    # 0x1b8a28
movl (%rcx), %ecx
xorl $0xc8, %ecx
orl %eax, %ecx
setne %cl
leaq 0x167a09(%rip), %rax    # 0x1b8a43
movb (%rax), %al
testb %al, %al
sete %dl
orb %cl, %dl
jne 0x5114c
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movabsq $0x400000002, %rcx      # imm = 0x400000002
leaq 0x1679db(%rip), %rdx    # 0x1b8a3f
movzwl 0x1(%rdx), %esi
movd %esi, %xmm0
leaq 0x8(%rsp), %rbx
movzbl (%rdx), %edx
movd %edx, %xmm1
movdqa 0x29570(%rip), %xmm2    # 0x7a5f0
pandn %xmm1, %xmm2
pslld $0x8, %xmm0
por %xmm2, %xmm0
pand 0x2956b(%rip), %xmm0    # 0x7a600
movq %rcx, 0x24(%rbx)
movzbl %al, %eax
movd %eax, %xmm1
pslld $0x18, %xmm1
por %xmm0, %xmm1
pxor %xmm0, %xmm0
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
cvtdq2ps %xmm1, %xmm0
divps 0x29551(%rip), %xmm0    # 0x7a610
movups %xmm0, 0x4(%rbx)
xorl %eax, %eax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
movl %eax, 0x8(%rcx)
leaq 0x3b6f15(%rip), %rdx    # 0x407fec
xorps %xmm0, %xmm0
cvtsi2ssl (%rdx), %xmm0
movss %xmm0, 0x14(%rcx)
movq %rax, 0x18(%rcx)
movss %xmm0, 0x28(%rcx)
leaq 0x3b6efd(%rip), %rdx    # 0x407ff0
xorps %xmm0, %xmm0
cvtsi2ssl (%rdx), %xmm0
movss %xmm0, 0x2c(%rcx)
movl %eax, 0x30(%rcx)
movl %eax, 0x3c(%rcx)
movss %xmm0, 0x40(%rcx)
movl %eax, 0x44(%rcx)
movq %rax, 0x30(%rbx)
movl $0x4, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
leaq 0x5a961d(%rip), %r14    # 0x5fa740
movl $0xb71, %edi            # imm = 0xB71
callq *0x48(%r14)
movl $0xbe2, %edi            # imm = 0xBE2
callq *0x40(%r14)
movl $0x6, %edi
movq %rbx, %rsi
callq 0x5d891
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_bunchfront
static int polymost_bunchfront (int b1, int b2)
{
	double x1b1, x1b2, x2b1, x2b2;
	int b1f, b2f, i;

	b1f = bunchfirst[b1]; x1b1 = dxb1[b1f]; x2b2 = dxb2[bunchlast[b2]]; if (x1b1 >= x2b2) return(-1);
	b2f = bunchfirst[b2]; x1b2 = dxb1[b2f]; x2b1 = dxb2[bunchlast[b1]]; if (x1b2 >= x2b1) return(-1);

	if (x1b1 >= x1b2)
	{
		for(i=b2f;dxb2[i]<=x1b1;i=p2[i]);
		return(wallfront(b1f,i));
	}
	for(i=b1f;dxb2[i]<=x1b2;i=p2[i]);
	return(wallfront(i,b2f));
}

// Assembly:
movslq %edi, %rcx
leaq 0x37df8d(%rip), %rdx    # 0x3d77c0
movswq (%rdx,%rcx,2), %rdi
leaq 0x5a53a1(%rip), %r8     # 0x5febe0
movsd (%r8,%rdi,8), %xmm0
movslq %esi, %rsi
leaq 0x37ff71(%rip), %r9     # 0x3d97c0
movswq (%r9,%rsi,2), %r10
leaq 0x5ad385(%rip), %rax    # 0x606be0
ucomisd (%rax,%r10,8), %xmm0
jae 0x5989c
movswq (%rdx,%rsi,2), %rsi
movsd (%r8,%rsi,8), %xmm1
movswq (%r9,%rcx,2), %rcx
ucomisd (%rax,%rcx,8), %xmm1
jae 0x5989c
ucomisd %xmm1, %xmm0
jae 0x598a2
ucomisd (%rax,%rdi,8), %xmm1
jb 0x598bc
leaq 0x385f42(%rip), %rcx    # 0x3df7d0
movswq (%rcx,%rdi,2), %rdi
ucomisd (%rax,%rdi,8), %xmm1
jae 0x5988e
jmp 0x598bc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
ucomisd (%rax,%rsi,8), %xmm0
jb 0x598bc
leaq 0x385f20(%rip), %rcx    # 0x3df7d0
movswq (%rcx,%rsi,2), %rsi
ucomisd (%rax,%rsi,8), %xmm0
jae 0x598b0
jmp 0x24143
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_plotpixel
int polymost_plotpixel(int x, int y, unsigned char col)
{
	palette_t colour;
	struct polymostdrawauxcall draw;
	struct polymostvboitem vboitem[1];

	if ((rendmode != 3) || (qsetmode != 200)) return(-1);

	setpolymost2dview();	// disables blending, texturing, and depth testing
	glfunc.glDepthMask(GL_FALSE);	// disable writing to the z-buffer
	glfunc.glEnable(GL_BLEND);

	draw.mode = 2;	// Solid colour.

	colour = curpalette[col];
	if (!usegammabrightness) {
		colour.r = britable[curbrightness][ colour.r ];
		colour.g = britable[curbrightness][ colour.g ];
		colour.b = britable[curbrightness][ colour.b ];
	}
	draw.colour.r = colour.r / 255.f;
	draw.colour.g = colour.g / 255.f;
	draw.colour.b = colour.b / 255.f;
	draw.colour.a = 1.f;

	vboitem[0].v.x = (GLfloat)x;
	vboitem[0].v.y = (GLfloat)y;
	vboitem[0].v.z = 0.f;

	draw.indexcount = 1;
	draw.indexes = NULL;
	draw.elementcount = 1;
	draw.elementvbo = vboitem;

	polymost_drawaux_glcall(GL_POINTS, &draw);

	glfunc.glDepthMask(GL_TRUE);	// re-enable writing to the z-buffer

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
cmpl $0x3, 0x59c6bd(%rip)    # 0x5fa950
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x5e3c6
leaq 0x15a783(%rip), %rax    # 0x1b8a28
cmpl $0xc8, (%rax)
jne 0x5e3c6
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %ebp
callq 0x3da9c
leaq 0x59c47b(%rip), %r12    # 0x5fa740
xorl %ebx, %ebx
xorl %edi, %edi
callq *0xa0(%r12)
movl $0xbe2, %edi            # imm = 0xBE2
callq *0x40(%r12)
movl $0x2, 0x3c(%rsp)
movzbl %r15b, %eax
leaq 0x3d86c2(%rip), %rcx    # 0x4369b0
movd (%rcx,%rax,4), %xmm0
movb 0x2(%rcx,%rax,4), %al
leaq 0x4648e(%rip), %rcx     # 0xa478c
cmpl $0x0, (%rcx)
jne 0x5e341
movzbl %al, %eax
leaq 0x15a6f7(%rip), %rcx    # 0x1b8a04
movslq (%rcx), %rcx
movd %xmm0, %edx
movl $0xff, %esi
movl %edx, %edi
andl %esi, %edi
shlq $0x8, %rcx
addq 0x34cb0(%rip), %rcx     # 0x92fd8
movzbl (%rdi,%rcx), %edi
shrl $0x8, %edx
andl %esi, %edx
movb (%rax,%rcx), %al
movzbl (%rdx,%rcx), %ecx
shll $0x8, %ecx
orl %edi, %ecx
movd %ecx, %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
divps 0x1c449(%rip), %xmm0    # 0x7a7a0
leaq 0x18(%rsp), %rsi
movlps %xmm0, 0x4(%rsi)
movzbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1c22e(%rip), %xmm0    # 0x7a5a0
movss %xmm0, 0xc(%rsi)
movl $0x3f800000, 0x10(%rsi) # imm = 0x3F800000
movd %r14d, %xmm0
movd %ebp, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movq %rsp, %rax
movlps %xmm0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x1, %ecx
movl %ecx, 0x28(%rsi)
movq $0x0, 0x30(%rsi)
movl %ecx, 0x38(%rsi)
movq %rax, 0x40(%rsi)
xorl %edi, %edi
callq 0x5d891
movl $0x1, %edi
callq *0xa0(%r12)
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_precache
void polymost_precache(int dapicnum, int dapalnum, int datype)
{
	// dapicnum and dapalnum are like you'd expect
	// datype is 0 for a wall/floor/ceiling and 1 for a sprite
	//    basically this just means walls are repeating
	//    while sprites are clamped
	int mid;
	unsigned short flags;

	if (rendmode < 3) return;

	if (!palookup[dapalnum]) return;//dapalnum = 0;

		//FIXME
	//buildprintf("precached %d %d type %d\n", dapicnum, dapalnum, datype);
	flags = (datype & 1) ? PTH_CLAMPED :0;
	if (usehightile) flags |= PTH_HIGHTILE;
	PTMarkPrime(dapicnum, dapalnum, flags);

	if (datype == 0) return;

	mid = md_tilehasmodel(dapicnum);
	if (mid < 0 || models[mid]->mdnum < 2) return;

	{
		int i,j=0;

		if (models[mid]->mdnum == 3)
			j = ((md3model *)models[mid])->head.numsurfs;

		for (i=0;i<=j;i++)
			mdloadskin((md2model*)models[mid], 0, dapalnum, i);
	}
}

// Assembly:
cmpl $0x3, 0x59c56f(%rip)    # 0x5fa950
jl 0x5e485
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %esi, %rax
leaq 0x33a6e5(%rip), %rcx    # 0x398ae0
cmpq $0x0, (%rcx,%rax,8)
je 0x5e47d
movl %edx, %r14d
movl %edi, %ebp
movl %edx, %eax
andl $0x1, %eax
leal 0x2(%rax), %edx
cmpl $0x0, 0x470fe(%rip)     # 0xa5514
cmovel %eax, %edx
movl %ebx, %esi
callq 0x670e3
testl %r14d, %r14d
je 0x5e47d
movl %ebp, %edi
callq 0x6095d
testl %eax, %eax
js 0x5e47d
leaq 0x5eabf1(%rip), %r14    # 0x649028
movq (%r14), %rcx
movl %eax, %r15d
movq (%rcx,%r15,8), %rax
movl (%rax), %ecx
cmpl $0x2, %ecx
jl 0x5e47d
xorl %ebp, %ebp
movl $0x0, %r12d
cmpl $0x3, %ecx
jne 0x5e461
movl 0xac(%rax), %r12d
testl %r12d, %r12d
js 0x5e47d
incl %r12d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x60e84
incl %ebp
cmpl %ebp, %r12d
jne 0x5e464
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: osdcmd_gltexturemode
static int osdcmd_gltexturemode(const osdfuncparm_t *parm)
{
	int m;
	const char *p;

	if (parm->numparms != 1) {
		buildprintf("Current texturing mode is %s\n", glfiltermodes[gltexfiltermode].name);
		buildprintf("  Vaild modes are:\n");
		for (m = 0; m < (int)numglfiltermodes; m++)
			buildprintf("     %d - %s\n",m,glfiltermodes[m].name);

		return OSDCMD_OK;
	}

	m = (int)strtol(parm->parms[0], (char **)&p, 10);
	if (p == parm->parms[0]) {
		// string
		for (m = 0; m < (int)numglfiltermodes; m++) {
			if (!Bstrcasecmp(parm->parms[0], glfiltermodes[m].name)) break;
		}
		if (m == numglfiltermodes) m = gltexfiltermode;   // no change
	} else {
		if (m < 0) m = 0;
		else if (m >= (int)numglfiltermodes) m = numglfiltermodes - 1;
	}

	if (m != gltexfiltermode) {
		gltexfiltermode = m;
		gltexapplyprops();
	}

	buildprintf("Texture filtering mode changed to %s\n", glfiltermodes[gltexfiltermode].name );

	return OSDCMD_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, (%rdi)
jne 0x5eb49
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x6940
movq 0x10(%rbx), %rcx
movq (%rcx), %rbx
cmpq %rbx, (%r14)
je 0x5eba4
testl %eax, %eax
js 0x5ebcc
cmpl $0x5, %eax
movl $0x5, %r14d
cmovbl %eax, %r14d
jmp 0x5ebe3
movslq 0x46a34(%rip), %rax     # 0xa5584
shlq $0x4, %rax
leaq 0x469c5(%rip), %r15     # 0xa5520
movq (%rax,%r15), %rsi
leaq 0x1c7d5(%rip), %rdi     # 0x7b33b
xorl %eax, %eax
callq 0x25221
leaq 0x1c7e5(%rip), %rdi     # 0x7b359
xorl %eax, %eax
callq 0x25221
leaq 0x1c7eb(%rip), %rbx     # 0x7b36d
xorl %r14d, %r14d
movq (%r15), %rdx
movq %rbx, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x25221
incq %r14
addq $0x10, %r15
cmpq $0x6, %r14
jne 0x5eb85
jmp 0x5ec1f
leaq 0x46975(%rip), %r15     # 0xa5520
xorl %r14d, %r14d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6880
testl %eax, %eax
je 0x5ebd1
decq %r14
addq $0x10, %r15
cmpq $-0x6, %r14
jne 0x5ebae
jmp 0x5ebd7
xorl %r14d, %r14d
jmp 0x5ebe3
cmpq $-0x6, %r14
jne 0x5ebe0
movl 0x469a6(%rip), %r14d    # 0xa5584
jmp 0x5ebe3
negl %r14d
cmpl 0x4699a(%rip), %r14d    # 0xa5584
je 0x5ebff
movl %r14d, 0x46991(%rip)    # 0xa5584
callq 0x4fe6a
movl 0x46985(%rip), %r14d    # 0xa5584
movslq %r14d, %rax
shlq $0x4, %rax
leaq 0x46913(%rip), %rcx     # 0xa5520
movq (%rax,%rcx), %rsi
leaq 0x1c763(%rip), %rdi     # 0x7b37b
xorl %eax, %eax
callq 0x25221
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: osdcmd_gltextureanisotropy
static int osdcmd_gltextureanisotropy(const osdfuncparm_t *parm)
{
	int l;
	const char *p;

	if (parm->numparms != 1) {
		buildprintf("Current texture anisotropy is %d\n", glanisotropy);
		buildprintf("  Maximum is %f\n", glinfo.maxanisotropy);

		return OSDCMD_OK;
	}

	l = (int)strtol(parm->parms[0], (char **)&p, 10);
	if (l < 0 || l > glinfo.maxanisotropy) l = 0;

	if (l != gltexfiltermode) {
		glanisotropy = l;
		gltexapplyprops();
	}

	buildprintf("Texture anisotropy changed to %d\n", glanisotropy );

	return OSDCMD_OK;
}

// Assembly:
pushq %rax
cmpl $0x1, (%rdi)
jne 0x5ec85
movq 0x10(%rdi), %rax
movq (%rax), %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x6940
testl %eax, %eax
js 0x5ec5a
cvtsi2ss %eax, %xmm0
leaq 0x11f5fc(%rip), %rcx    # 0x17e250
ucomiss 0x14(%rcx), %xmm0
jbe 0x5ec5c
xorl %eax, %eax
cmpl 0x46922(%rip), %eax     # 0xa5584
je 0x5ec6f
movl %eax, 0x59bd1a(%rip)    # 0x5fa984
callq 0x4fe6a
movl 0x59bd0f(%rip), %esi    # 0x5fa984
leaq 0x1c758(%rip), %rdi     # 0x7b3d4
xorl %eax, %eax
callq 0x25221
jmp 0x5ecb3
movl 0x59bcf9(%rip), %esi    # 0x5fa984
leaq 0x1c70f(%rip), %rdi     # 0x7b3a1
xorl %eax, %eax
callq 0x25221
leaq 0x11f5b0(%rip), %rax    # 0x17e250
cvtss2sd 0x14(%rax), %xmm0
leaq 0x1c717(%rip), %rdi     # 0x7b3c3
movb $0x1, %al
callq 0x25221
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_load_shader
static GLuint polymost_load_shader(GLuint shadertype, const char *defaultsrc, const char *filename)
{
	const GLchar *shadersrc = defaultsrc;
	GLuint shader = 0;

#ifdef SHADERDEV
	GLchar *fileshadersrc = NULL;
	long shadersrclen = 0;
	BFILE *shaderfh = NULL;

	shaderfh = fopen(filename, "rb");
	if (shaderfh) {
		fseek(shaderfh, 0, SEEK_END);
		shadersrclen = ftell(shaderfh);
		fseek(shaderfh, 0, SEEK_SET);

		fileshadersrc = (GLchar *)malloc(shadersrclen + 1);
		shadersrclen = fread(fileshadersrc, 1, shadersrclen, shaderfh);
		fileshadersrc[shadersrclen] = 0;

		fclose(shaderfh);
		shaderfh = NULL;

		buildprintf("polymost_load_shader: loaded %s (%ld bytes)\n", filename, shadersrclen);
		shadersrc = fileshadersrc;
	}
#endif

	shader = glbuild_compile_shader(shadertype, shadersrc);

#ifdef SHADERDEV
	if (fileshadersrc) {
		free(fileshadersrc);
		fileshadersrc = NULL;
	}
#endif

	return shader;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebx
leaq 0x18ab9(%rip), %rsi     # 0x777aa
movq %rdx, %rdi
callq 0x6ce0
testq %rax, %rax
je 0x5ed8e
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x6c70
movq %r15, %rdi
callq 0x6280
movq %rax, %r13
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6c70
leaq 0x1(%r13), %rdi
callq 0x69a0
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x6550
movq %rax, %r13
movb $0x0, (%r12,%rax)
movq %r15, %rdi
callq 0x6480
leaq 0x1c3d6(%rip), %rdi     # 0x7b137
movq %r14, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x25221
movl %ebx, %edi
movq %r12, %rsi
callq 0x4f41f
movl %eax, %ebx
movq %r12, %rdi
callq 0x61c0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %ebx, %edi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4f41f
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: drawtrap
static void drawtrap (float x0, float x1, float y0, float x2, float x3, float y1,
	struct polymostdrawpolycall *draw)
{
	float px[4], py[4];
	int i, n;
	struct polymostvboitem vboitem[4];

	if (y0 == y1) return;
	px[0] = x0; py[0] = y0;  py[2] = y1;
		  if (x0 == x1) { px[1] = x3; py[1] = y1; px[2] = x2; n = 3; }
	else if (x2 == x3) { px[1] = x1; py[1] = y0; px[2] = x3; n = 3; }
	else               { px[1] = x1; py[1] = y0; px[2] = x3; px[3] = x2; py[3] = y1; n = 4; }

	for(i=0;i<n;i++)
	{
		px[i] = min(max(px[i],trapextx[0]),trapextx[1]);
		vboitem[i].t.s = px[i]*gux + py[i]*guy + guo;
		vboitem[i].t.t = px[i]*gvx + py[i]*gvy + gvo;
		vboitem[i].v.x = px[i];
		vboitem[i].v.y = py[i];
		vboitem[i].v.z = 0.f;
	}
	draw->indexcount = n;
	draw->elementcount = n;
	draw->elementvbo = vboitem;
	polymost_drawpoly_glcall(GL_TRIANGLE_FAN, draw);
	draw->elementvbo = NULL;
}

// Assembly:
ucomiss %xmm5, %xmm2
jne 0x5f840
jp 0x5f840
retq
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movss %xmm0, (%rsp)
movss %xmm2, 0x10(%rsp)
movss %xmm5, 0x18(%rsp)
ucomiss %xmm1, %xmm0
jne 0x5f879
jp 0x5f879
movss %xmm4, 0x4(%rsp)
movss %xmm5, 0x14(%rsp)
movss %xmm3, 0x8(%rsp)
movl $0x3, %eax
jmp 0x5f8a8
ucomiss %xmm4, %xmm3
movss %xmm1, 0x4(%rsp)
movss %xmm2, 0x14(%rsp)
movss %xmm4, 0x8(%rsp)
movl $0x3, %eax
jne 0x5f897
jnp 0x5f8a8
movss %xmm3, 0xc(%rsp)
movss %xmm5, 0x1c(%rsp)
movl $0x4, %eax
movss 0x5d7358(%rip), %xmm0   # 0x636c08
movss 0x5d7354(%rip), %xmm1   # 0x636c0c
movl %eax, %ecx
movsd 0x59b2b6(%rip), %xmm2   # 0x5fab78
movhpd 0x59b2c6(%rip), %xmm2   # xmm2 = xmm2[0],mem[0]
movsd 0x59b296(%rip), %xmm3   # 0x5fab68
movhpd 0x59b2a6(%rip), %xmm3   # xmm3 = xmm3[0],mem[0]
movsd 0x59b28e(%rip), %xmm4   # 0x5fab70
movhpd 0x59b29e(%rip), %xmm4   # xmm4 = xmm4[0],mem[0]
leaq 0x2c(%rsp), %rdx
xorl %esi, %esi
movss (%rsp,%rsi,4), %xmm5
maxss %xmm0, %xmm5
minss %xmm1, %xmm5
xorps %xmm6, %xmm6
cvtss2sd %xmm5, %xmm6
movss 0x10(%rsp,%rsi,4), %xmm7
xorps %xmm8, %xmm8
cvtss2sd %xmm7, %xmm8
movlhps %xmm8, %xmm8            # xmm8 = xmm8[0,0]
mulpd %xmm4, %xmm8
movlhps %xmm6, %xmm6            # xmm6 = xmm6[0,0]
mulpd %xmm3, %xmm6
addpd %xmm8, %xmm6
addpd %xmm2, %xmm6
cvtpd2ps %xmm6, %xmm6
movss %xmm5, (%rsp,%rsi,4)
movlpd %xmm6, (%rdx)
movss %xmm5, -0xc(%rdx)
movss %xmm7, -0x8(%rdx)
movl $0x0, -0x4(%rdx)
incq %rsi
addq $0x14, %rdx
cmpq %rsi, %rcx
jne 0x5f8f1
movl %eax, 0x44(%rbx)
movl %eax, 0x4c(%rbx)
leaq 0x20(%rsp), %rax
movq %rax, 0x50(%rbx)
movl $0x6, %edi
movq %rbx, %rsi
callq 0x50d4b
movq $0x0, 0x50(%rbx)
addq $0x70, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/hightile.c
// Function: hicfindsubst
hicreplctyp * hicfindsubst(int picnum, int palnum, int skybox)
{
	hicreplctyp *hr;

	if (!hicfirstinit) return NULL;
	if ((unsigned int)picnum >= (unsigned int)MAXTILES) return NULL;

	do {
		for (hr = hicreplc[picnum]; hr; hr = hr->next) {
			if (hr->palnum == palnum) {
				if (skybox) {
					if (hr->skybox && !hr->skybox->ignore) return hr;
				} else {
					if (!hr->ignore) return hr;
				}
			}
		}

		if (palnum == 0) break;
		palnum = 0;
	} while (1);

	return NULL;	// no replacement found
}

// Assembly:
xorl %eax, %eax
cmpl $0x23ff, %edi           # imm = 0x23FF
ja 0x5f9e2
cmpl $0x0, 0x5d727b(%rip)    # 0x636c10
je 0x5f9e2
movl %edi, %eax
leaq 0x5d7280(%rip), %rcx    # 0x636c20
movq (%rcx,%rax,8), %rcx
testq %rcx, %rcx
je 0x5f9d7
movq %rcx, %rax
movzbl 0x8(%rax), %edi
cmpl %edi, %esi
jne 0x5f9cf
testl %edx, %edx
je 0x5f9c9
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x5f9cf
cmpq $0x0, (%rdi)
jne 0x5f9cf
jmp 0x5f9e2
cmpb $0x0, 0x9(%rax)
je 0x5f9e2
movq (%rax), %rax
testq %rax, %rax
jne 0x5f9ac
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %esi
jne 0x5f9a4
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/hightile.c
// Function: hicinit
void hicinit(void)
{
	int i,j;
	hicreplctyp *hr, *next;

	for (i=0;i<MAXPALOOKUPS;i++) {	// all tints should be 100%
		hictinting[i].r = hictinting[i].g = hictinting[i].b = 0xff;
		hictinting[i].f = 0;
	}

	if (hicfirstinit) {
		for (i=MAXTILES-1;i>=0;i--) {
			for (hr=hicreplc[i]; hr; ) {
				next = hr->next;

				if (hr->skybox) {
					for (j=5;j>=0;j--) {
						if (hr->skybox->face[j]) {
							free(hr->skybox->face[j]);
						}
					}
					free(hr->skybox);
				}
				if (hr->filename) free(hr->filename);
				free(hr);

				hr = next;
			}
		}
	}
	memset(hicreplc,0,sizeof(hicreplc));

	hicfirstinit = 1;
}

// Assembly:
xorl %eax, %eax
leaq 0x5e9234(%rip), %rcx    # 0x648c20
movl $0xffffff, (%rax,%rcx)  # imm = 0xFFFFFF
addq $0x4, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x5f9ec
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, 0x5d7201(%rip)    # 0x636c10
je 0x5fa7c
movl $0x23ff, %r14d          # imm = 0x23FF
leaq 0x5d7202(%rip), %r15    # 0x636c20
movq (%r15,%r14,8), %rbx
testq %rbx, %rbx
je 0x5fa76
movq (%rbx), %r12
cmpq $0x0, 0x20(%rbx)
je 0x5fa58
movl $0x30, %r13d
movq 0x20(%rbx), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
je 0x5fa49
callq 0x61c0
addq $-0x8, %r13
jne 0x5fa37
movq 0x20(%rbx), %rdi
callq 0x61c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5fa66
callq 0x61c0
movq %rbx, %rdi
callq 0x61c0
movq %r12, %rbx
testq %r12, %r12
jne 0x5fa27
subq $0x1, %r14
jae 0x5fa1e
leaq 0x5d719d(%rip), %rdi    # 0x636c20
movl $0x12000, %edx          # imm = 0x12000
xorl %esi, %esi
callq 0x62f0
movl $0x1, 0x5d7177(%rip)    # 0x636c10
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/hightile.c
// Function: hicsetpalettetint
void hicsetpalettetint(int palnum, unsigned char r, unsigned char g, unsigned char b, unsigned char effect)
{
	if ((unsigned int)palnum >= (unsigned int)MAXPALOOKUPS) return;
	if (!hicfirstinit) hicinit();

	hictinting[palnum].r = r;
	hictinting[palnum].g = g;
	hictinting[palnum].b = b;
	hictinting[palnum].f = effect & HICEFFECTMASK;
}

// Assembly:
cmpl $0xff, %edi
ja 0x5faf6
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
cmpl $0x0, 0x5d7148(%rip)    # 0x636c10
jne 0x5facf
callq 0x5f9e3
movl %r12d, %eax
leaq 0x5e9147(%rip), %rcx    # 0x648c20
movb %r15b, (%rcx,%rax,4)
movb %r14b, 0x1(%rcx,%rax,4)
movb %bpl, 0x2(%rcx,%rax,4)
andb $0x3, %bl
movb %bl, 0x3(%rcx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/hightile.c
// Function: hicsetsubsttex
int hicsetsubsttex(int picnum, int palnum, char *filen, float alphacut, unsigned char flags)
{
	hicreplctyp *hr, *hrn;

	if ((unsigned int)picnum >= (unsigned int)MAXTILES) return -1;
	if ((unsigned int)palnum >= (unsigned int)MAXPALOOKUPS) return -1;
	if (!hicfirstinit) hicinit();

	for (hr = hicreplc[picnum]; hr; hr = hr->next) {
		if (hr->palnum == palnum)
			break;
	}

	if (!hr) {
		// no replacement yet defined
		hrn = (hicreplctyp *)calloc(1,sizeof(hicreplctyp));
		if (!hrn) return -1;
		hrn->palnum = palnum;
	} else hrn = hr;

	// store into hicreplc the details for this replacement
	if (hrn->filename) free(hrn->filename);

	hrn->filename = strdup(filen);
	if (!hrn->filename) {
		if (hrn->skybox) return -1;	// don't free the base structure if there's a skybox defined
		if (hr == NULL) free(hrn);	// not yet a link in the chain
		return -1;
	}
	hrn->ignore = 0;
	hrn->alphacut = min(alphacut,1.0);
	hrn->flags = flags;
	if (hr == NULL) {
		hrn->next = hicreplc[picnum];
		hicreplc[picnum] = hrn;
	}

	//printf("Replacement [%d,%d]: %s\n", picnum, palnum, hicreplc[i]->filename);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rdx, %r14
cmpl $0x2400, %edi           # imm = 0x2400
setae %al
cmpl $0x100, %esi            # imm = 0x100
setae %dl
orb %al, %dl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x5fbe6
movl %esi, %r12d
movl %edi, %r15d
movl %ecx, (%rsp)
cmpl $0x0, 0x5d70d6(%rip)    # 0x636c10
jne 0x5fb41
callq 0x5f9e3
movl %r15d, %eax
leaq 0x5d70d5(%rip), %rcx    # 0x636c20
leaq (%rcx,%rax,8), %rbp
movq %rbp, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x5fb6a
movzbl 0x8(%r13), %eax
cmpl %r12d, %eax
jne 0x5fb52
movq %r13, %r15
jmp 0x5fb85
movl $0x1, %edi
movl $0x28, %esi
callq 0x6930
testq %rax, %rax
je 0x5fbe6
movq %rax, %r15
movb %r12b, 0x8(%rax)
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x5fb93
callq 0x61c0
movq %r14, %rdi
callq 0x6060
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x5fbd8
xorl %ebx, %ebx
movss 0x4(%rsp), %xmm0
minss 0x17560(%rip), %xmm0    # 0x77114
movb $0x0, 0x9(%r15)
movss %xmm0, 0x18(%r15)
movl (%rsp), %eax
movb %al, 0xa(%r15)
testq %r13, %r13
jne 0x5fbe6
movq (%rbp), %rax
movq %rax, (%r15)
movq %r15, (%rbp)
jmp 0x5fbe6
orq 0x20(%r15), %r13
jne 0x5fbe6
movq %r15, %rdi
callq 0x61c0
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/hightile.c
// Function: hicclearsubst
int hicclearsubst(int picnum, int palnum)
{
	hicreplctyp *hr, *hrn = NULL;

	if ((unsigned int)picnum >= (unsigned int)MAXTILES) return -1;
	if ((unsigned int)palnum >= (unsigned int)MAXPALOOKUPS) return -1;
	if (!hicfirstinit) return 0;

	for (hr = hicreplc[picnum]; hr; hrn = hr, hr = hr->next) {
		if (hr->palnum == palnum)
			break;
	}

	if (!hr) return 0;

	if (hr->filename) free(hr->filename);
	if (hr->skybox) {
		int i;
		for (i=5;i>=0;i--)
			if (hr->skybox->face[i])
				free(hr->skybox->face[i]);
		free(hr->skybox);
	}

	if (hrn) hrn->next = hr->next;
	else hicreplc[picnum] = hr->next;
	free(hr);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x2400, %edi           # imm = 0x2400
setae %al
cmpl $0x100, %esi            # imm = 0x100
setae %cl
orb %al, %cl
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x5fe2f
cmpl $0x0, 0x5d6e63(%rip)    # 0x636c10
je 0x5fe2d
movl %edi, %eax
leaq 0x5d6e68(%rip), %rcx    # 0x636c20
leaq (%rcx,%rax,8), %r15
xorl %ebx, %ebx
movq %r15, %r14
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0x5fe2f
movq %rax, %r12
movzbl 0x8(%r14), %ecx
movq %r14, %rax
cmpl %esi, %ecx
jne 0x5fdc3
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x5fde8
callq 0x61c0
cmpq $0x0, 0x20(%r14)
je 0x5fe16
movl $0x30, %r13d
movq 0x20(%r14), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
je 0x5fe07
callq 0x61c0
addq $-0x8, %r13
jne 0x5fdf5
movq 0x20(%r14), %rdi
callq 0x61c0
testq %r12, %r12
movq (%r14), %rax
cmovneq %r12, %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0x61c0
jmp 0x5fe2f
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: freeallmodels
void freeallmodels (void)
{
	int i;

	if (models)
	{
		for(i=0;i<nextmodelid;i++) mdfree(models[i]);
		free(models); models = NULL;
		nummodelsalloced = 0;
		nextmodelid = 0;
	}

	memset(tile2model,-1,sizeof(tile2model));

	if (vertlist)
	{
		free(vertlist);
		vertlist = NULL;
		allocmodelverts = maxmodelverts = 0;
	}
	if (elementvbo) {
		free(elementvbo);
		elementvbo = NULL;
		allocelementvbo = maxelementvbo = 0;
	}

}

// Assembly:
pushq %rbx
movq 0x5e91e4(%rip), %rdi    # 0x649028
testq %rdi, %rdi
je 0x5fe98
cmpl $0x0, 0x5e91d4(%rip)    # 0x649024
jle 0x5fe7a
xorl %ebx, %ebx
movq 0x5e91cd(%rip), %rax    # 0x649028
movq (%rax,%rbx,8), %rdi
callq 0x5ff04
incq %rbx
movslq 0x5e91b6(%rip), %rax    # 0x649024
cmpq %rax, %rbx
jl 0x5fe54
movq 0x5e91ae(%rip), %rdi    # 0x649028
callq 0x61c0
movq $0x0, 0x5e919e(%rip) # 0x649028
xorl %eax, %eax
movl %eax, 0x5e919e(%rip)    # 0x649030
movl %eax, 0x5e918c(%rip)    # 0x649024
leaq 0x5e91a1(%rip), %rdi    # 0x649040
movl $0x1b000, %edx          # imm = 0x1B000
movl $0xff, %esi
callq 0x62f0
movq 0x60418b(%rip), %rdi    # 0x664040
testq %rdi, %rdi
je 0x5fed8
callq 0x61c0
movq $0x0, 0x604176(%rip) # 0x664040
xorl %eax, %eax
movl %eax, 0x604176(%rip)    # 0x664048
movl %eax, 0x604174(%rip)    # 0x66404c
movq 0x604171(%rip), %rdi    # 0x664050
testq %rdi, %rdi
je 0x5ff02
callq 0x61c0
movq $0x0, 0x60415c(%rip) # 0x664050
xorl %eax, %eax
movl %eax, 0x60415c(%rip)    # 0x664058
movl %eax, 0x60415a(%rip)    # 0x66405c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md_loadmodel
int md_loadmodel (const char *fn)
{
	mdmodel *vm, **ml;

	if (!mdinited) mdinit();

	if (nextmodelid >= nummodelsalloced)
	{
		ml = (mdmodel **)realloc(models,(nummodelsalloced+MODELALLOCGROUP)*sizeof(mdmodel*)); if (!ml) return(-1);
		models = ml; nummodelsalloced += MODELALLOCGROUP;
	}

	vm = mdload(fn); if (!vm) return(-1);
	models[nextmodelid++] = vm;
	return(nextmodelid-1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x5e8eca(%rip)    # 0x649020
jne 0x60177
leaq 0x60bf01(%rip), %rdi    # 0x66c060
movl $0x48000, %edx          # imm = 0x48000
xorl %esi, %esi
callq 0x62f0
callq 0x5fe3c
movb $0x1, 0x5e8ea9(%rip)    # 0x649020
movslq 0x5e8eb2(%rip), %r14    # 0x649030
cmpl %r14d, 0x5e8e9f(%rip)   # 0x649024
jl 0x601b5
movq 0x5e8e9a(%rip), %rdi    # 0x649028
leaq 0x800(,%r14,8), %rsi
callq 0x6120
testq %rax, %rax
je 0x601e2
addq $0x100, %r14            # imm = 0x100
movq %rax, 0x5e8e7a(%rip)    # 0x649028
movl %r14d, 0x5e8e7b(%rip)   # 0x649030
movq %rbx, %rdi
callq 0x601ef
testq %rax, %rax
je 0x601e2
movq %rax, %rcx
movq 0x5e8e5c(%rip), %rdx    # 0x649028
movslq 0x5e8e51(%rip), %rax    # 0x649024
leal 0x1(%rax), %esi
movl %esi, 0x5e8e48(%rip)    # 0x649024
movq %rcx, (%rdx,%rax,8)
jmp 0x601e7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md_setmisc
int md_setmisc (int modelid, float scale, int shadeoff, float zadd)
{
	mdmodel *m;

	if (!mdinited) mdinit();

	if ((unsigned int)modelid >= (unsigned int)nextmodelid) return -1;
	m = models[modelid];
	m->bscale = scale;
	m->shadeoff = shadeoff;
	m->zadd = zadd;

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
cmpb $0x0, 0x5e872b(%rip)    # 0x649020
jne 0x6092c
leaq 0x60b762(%rip), %rdi    # 0x66c060
movl $0x48000, %edx          # imm = 0x48000
xorl %esi, %esi
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
callq 0x62f0
callq 0x5fe3c
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
movb $0x1, 0x5e86f4(%rip)    # 0x649020
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ebp, 0x5e86ed(%rip)    # 0x649024
jbe 0x60956
movq 0x5e86e8(%rip), %rax    # 0x649028
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
movss %xmm0, 0xc(%rax)
movl %ebx, 0x4(%rax)
movss %xmm1, 0x10(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md_defineframe
int md_defineframe (int modelid, const char *framename, int tilenume, int skinnum)
{
	md2model *m;
	int i;

	if (!mdinited) mdinit();

	if ((unsigned int)modelid >= (unsigned int)nextmodelid) return(-1);
	if ((unsigned int)tilenume >= (unsigned int)MAXTILES) return(-2);
	if (!framename) return(-3);

	m = (md2model *)models[modelid];
	if (m->mdnum == 1) {
		tile2model[tilenume].modelid = modelid;
		tile2model[tilenume].framenum = tile2model[tilenume].skinnum = 0;
		return 0;
	}

	i = framename2index((mdmodel*)m,framename);
	if (i == m->numframes) return(-3);   // frame name invalid

	tile2model[tilenume].modelid = modelid;
	tile2model[tilenume].framenum = i;
	tile2model[tilenume].skinnum = skinnum;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %ebx
cmpb $0x0, 0x5e8686(%rip)    # 0x649020
jne 0x609bb
leaq 0x60b6bd(%rip), %rdi    # 0x66c060
movl $0x48000, %edx          # imm = 0x48000
xorl %esi, %esi
callq 0x62f0
callq 0x5fe3c
movb $0x1, 0x5e8665(%rip)    # 0x649020
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl %ebx, 0x5e865d(%rip)    # 0x649024
jbe 0x60a43
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
cmpl $0x23ff, %r14d          # imm = 0x23FF
ja 0x60a43
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
testq %r15, %r15
je 0x60a43
movq 0x5e863e(%rip), %rax    # 0x649028
movslq %ebx, %rcx
movq (%rax,%rcx,8), %r13
xorl %eax, %eax
cmpl $0x1, (%r13)
jne 0x60a08
movl $0x8, %ecx
movl $0x4, %edx
xorl %ebp, %ebp
jmp 0x60a23
movq %r13, %rdi
movq %r15, %rsi
callq 0x60a55
cmpl 0x20(%r13), %eax
je 0x60a43
movl $0x4, %ecx
movl $0x8, %edx
movl %r14d, %esi
leaq (%rsi,%rsi,2), %rsi
leaq 0x5e860f(%rip), %rdi    # 0x649040
leaq (%rdi,%rsi,4), %r8
movl %ebx, (%rdi,%rsi,4)
movl %eax, (%rdx,%r8)
movl %ebp, (%rcx,%r8)
xorl %r12d, %r12d
movl %r12d, %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/mdsprite.c
// Function: framename2index
static int framename2index (mdmodel *vm, const char *nam)
{
	int i = 0;

	switch(vm->mdnum)
	{
		case 2:
			{
			md2model *m = (md2model *)vm;
			md2frame_t *fr;
			for(i=0;i<m->numframes;i++)
			{
				fr = (md2frame_t *)&m->frames[i*m->framebytes];
				if (!Bstrcmp(fr->name, nam)) break;
			}
			}
			break;
		case 3:
			{
			md3model *m = (md3model *)vm;
			for(i=0;i<m->numframes;i++)
				if (!Bstrcmp(m->head.frames[i].nam,nam)) break;
			}
			break;
	}
	return(i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movl (%rdi), %eax
xorl %ebx, %ebx
cmpl $0x2, %eax
je 0x60aa2
cmpl $0x3, %eax
jne 0x60ad6
movl 0x20(%rdi), %r12d
testl %r12d, %r12d
jle 0x60ad6
movq 0xb8(%rdi), %r15
addq $0x28, %r15
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x68d0
testl %eax, %eax
je 0x60ad6
incq %rbx
addq $0x38, %r15
cmpq %rbx, %r12
jne 0x60a85
jmp 0x60ad3
movl 0x20(%rdi), %r12d
testl %r12d, %r12d
jle 0x60ad6
movq 0x70(%rdi), %r15
movslq 0x64(%rdi), %r13
addq $0x18, %r15
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x68d0
testl %eax, %eax
je 0x60ad6
incq %rbx
addq %r13, %r15
cmpq %rbx, %r12
jne 0x60ab9
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md_defineanimation
int md_defineanimation (int modelid, const char *framestart, const char *frameend, int fpssc, int flags)
{
	md2model *m;
	mdanim_t ma, *map;
	int i;

	if (!mdinited) mdinit();

	if ((unsigned int)modelid >= (unsigned int)nextmodelid) return(-1);

	memset(&ma, 0, sizeof(ma));
	m = (md2model *)models[modelid];
	if (m->mdnum < 2) return 0;

		//find index of start frame
	i = framename2index((mdmodel*)m,framestart);
	if (i == m->numframes) return -2;
	ma.startframe = i;

		//find index of finish frame which must trail start frame
	i = framename2index((mdmodel*)m,frameend);
	if (i == m->numframes) return -3;
	ma.endframe = i;

	ma.fpssc = fpssc;
	ma.flags = flags;

	map = (mdanim_t*)calloc(1,sizeof(mdanim_t));
	if (!map) return(-4);
	memcpy(map, &ma, sizeof(ma));

	map->next = m->animations;
	m->animations = map;

	return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %r15d
cmpb $0x0, 0x5e851e(%rip)    # 0x649020
jne 0x60b23
leaq 0x60b555(%rip), %rdi    # 0x66c060
movl $0x48000, %edx          # imm = 0x48000
xorl %esi, %esi
callq 0x62f0
callq 0x5fe3c
movb $0x1, 0x5e84fd(%rip)    # 0x649020
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r15d, 0x5e84f5(%rip)   # 0x649024
jbe 0x60bb5
movq 0x5e84ec(%rip), %rax    # 0x649028
movslq %r15d, %rcx
movq (%rax,%rcx,8), %r15
xorl %eax, %eax
cmpl $0x2, (%r15)
jl 0x60bb5
movq %r15, %rdi
movq %r12, %rsi
callq 0x60a55
movl %eax, %r12d
movl 0x20(%r15), %r13d
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl %r13d, %r12d
je 0x60bb5
movq %r15, %rdi
movq %r14, %rsi
callq 0x60a55
movl %eax, %r14d
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpl %r13d, %r14d
je 0x60bb5
movl $0x1, %edi
movl $0x18, %esi
callq 0x6930
testq %rax, %rax
je 0x60bb0
movl %r12d, (%rax)
movl %r14d, 0x4(%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
movq 0x40(%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x40(%r15)
xorl %eax, %eax
jmp 0x60bb5
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
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/mdsprite.c
// Function: md_defineskin
int md_defineskin (int modelid, const char *skinfn, int palnum, int skinnum, int surfnum)
{
	mdskinmap_t *sk, *skl;
	md2model *m;

	if (!mdinited) mdinit();

	if ((unsigned int)modelid >= (unsigned int)nextmodelid) return -1;
	if (!skinfn) return -2;
	if ((unsigned)palnum >= (unsigned)MAXPALOOKUPS) return -3;

	m = (md2model *)models[modelid];
	if (m->mdnum < 2) return 0;
	if (m->mdnum == 2) surfnum = 0;

	skl = NULL;
	for (sk = m->skinmap; sk; skl = sk, sk = sk->next)
		if (sk->palette == (unsigned char)palnum && skinnum == sk->skinnum && surfnum == sk->surfnum) break;
	if (!sk) {
		sk = (mdskinmap_t *)calloc(1,sizeof(mdskinmap_t));
		if (!sk) return -4;

		if (!skl) m->skinmap = sk;
		else skl->next = sk;
	} else if (sk->fn) free(sk->fn);

	sk->palette = (unsigned char)palnum;
	sk->skinnum = skinnum;
	sk->surfnum = surfnum;
	sk->fn = (char *)malloc(strlen(skinfn)+1);
	if (!sk->fn) return(-4);
	strcpy(sk->fn, skinfn);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %rbx
movl %edi, %r12d
cmpb $0x0, 0x5e843b(%rip)    # 0x649020
jne 0x60c06
leaq 0x60b472(%rip), %rdi    # 0x66c060
movl $0x48000, %edx          # imm = 0x48000
xorl %esi, %esi
callq 0x62f0
callq 0x5fe3c
movb $0x1, 0x5e841a(%rip)    # 0x649020
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r12d, 0x5e8412(%rip)   # 0x649024
jbe 0x60c9f
testq %rbx, %rbx
je 0x60c9a
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpl $0xff, %r15d
ja 0x60c9f
movq 0x5e83f6(%rip), %rax    # 0x649028
movslq %r12d, %rcx
movq (%rax,%rcx,8), %r13
movl (%r13), %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x60c9f
xorl %eax, %eax
cmpl $0x2, %ecx
cmovel %eax, %ebp
movq 0x48(%r13), %rax
testq %rax, %rax
je 0x60cae
movq %rax, %r12
movzbl (%rax), %eax
cmpl %r15d, %eax
jne 0x60c6e
cmpl %r14d, 0x4(%r12)
jne 0x60c6e
cmpl 0x8(%r12), %ebp
je 0x60ccb
movq 0x38(%r12), %rax
testq %rax, %rax
jne 0x60c55
movl $0x1, %edi
movl $0x40, %esi
callq 0x6930
testq %rax, %rax
je 0x60d12
movq %rax, 0x38(%r12)
movq %rax, %r12
jmp 0x60cda
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
movl $0x40, %esi
callq 0x6930
testq %rax, %rax
je 0x60d12
movq %rax, %r12
movq %rax, 0x48(%r13)
jmp 0x60cda
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x60cda
callq 0x61c0
movb %r15b, (%r12)
movl %r14d, 0x4(%r12)
movl %ebp, 0x8(%r12)
movq %rbx, %rdi
callq 0x6420
leaq 0x1(%rax), %rdi
callq 0x69a0
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x60d12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6430
xorl %eax, %eax
jmp 0x60c9f
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x60c9f
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md_definehud
int md_definehud (int modelid, int tilex, double xadd, double yadd, double zadd, double angadd, int flags)
{
	if (!mdinited) mdinit();

	if ((unsigned int)modelid >= (unsigned int)nextmodelid) return -1;
	if ((unsigned int)tilex >= (unsigned int)MAXTILES) return -2;

	hudmem[(flags>>2)&1][tilex].xadd = xadd;
	hudmem[(flags>>2)&1][tilex].yadd = yadd;
	hudmem[(flags>>2)&1][tilex].zadd = zadd;
	hudmem[(flags>>2)&1][tilex].angadd = ((short)angadd)|2048;
	hudmem[(flags>>2)&1][tilex].flags = (short)flags;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
cmpb $0x0, 0x5e82f1(%rip)    # 0x649020
jne 0x60d7c
leaq 0x60b328(%rip), %rdi    # 0x66c060
movl $0x48000, %edx          # imm = 0x48000
xorl %esi, %esi
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, (%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x62f0
callq 0x5fe3c
movapd 0x10(%rsp), %xmm0
movapd 0x20(%rsp), %xmm1
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
movb $0x1, 0x5e82a4(%rip)    # 0x649020
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r14d, 0x5e829c(%rip)   # 0x649024
jbe 0x60de5
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x23ff, %ebp           # imm = 0x23FF
ja 0x60de5
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
cvtpd2ps %xmm0, %xmm0
movl %ebx, %eax
shrl $0x2, %eax
andl $0x1, %eax
movl %ebp, %ecx
leaq (%rax,%rax,8), %rax
shll $0xe, %eax
leaq 0x60b2a9(%rip), %rdx    # 0x66c060
addq %rax, %rdx
shlq $0x4, %rcx
xorps %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm1
movlpd %xmm0, (%rcx,%rdx)
movss %xmm1, 0x8(%rcx,%rdx)
cvttsd2si %xmm3, %eax
orl $0x800, %eax            # imm = 0x800
movw %ax, 0xc(%rcx,%rdx)
movw %bx, 0xe(%rcx,%rdx)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md_undefinemodel
int md_undefinemodel(int modelid)
{
	int i;
	if (!mdinited) return 0;
	if ((unsigned int)modelid >= (unsigned int)nextmodelid) return -1;

	for (i=MAXTILES-1; i>=0; i--)
		if (tile2model[i].modelid == modelid)
			tile2model[i].modelid = -1;

	if (models) {
		mdfree(models[modelid]);
		models[modelid] = NULL;
	}

	return 0;
}

// Assembly:
cmpb $0x0, 0x5e81fc(%rip)    # 0x649020
je 0x60e81
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edi, 0x5e81f3(%rip)    # 0x649024
jbe 0x60e80
movl $0x1aff4, %eax          # imm = 0x1AFF4
leaq 0x5e8201(%rip), %rcx    # 0x649040
cmpl %edi, (%rax,%rcx)
jne 0x60e4b
movl $0xffffffff, (%rax,%rcx) # imm = 0xFFFFFFFF
addq $-0xc, %rax
cmpq $-0xc, %rax
jne 0x60e3f
movq 0x5e81cc(%rip), %rax    # 0x649028
testq %rax, %rax
je 0x60e81
pushq %rbx
movslq %edi, %rbx
movq (%rax,%rbx,8), %rdi
callq 0x5ff04
movq 0x5e81b3(%rip), %rax    # 0x649028
movq $0x0, (%rax,%rbx,8)
xorl %eax, %eax
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: voxfree
void voxfree (voxmodel *m)
{
	if (!m) return;
	if (m->mytex) free(m->mytex);
	if (m->quad) free(m->quad);
	if (m->texid) free(m->texid);
	free(m);
}

// Assembly:
testq %rdi, %rdi
je 0x614c9
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x614a4
callq 0x61c0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x614b2
callq 0x61c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x614c0
callq 0x61c0
movq %rbx, %rdi
popq %rbx
jmp 0x61c0
retq
// File: /workspace/github_c_makefile_star2_O3/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: md2free
static void md2free (md2model *m)
{
	mdanim_t *anim, *nanim = NULL;
	mdskinmap_t *sk, *nsk = NULL;

	if (!m) return;

	for(anim=m->animations; anim; anim=nanim)
	{
		nanim = anim->next;
		free(anim);
	}
	for(sk=m->skinmap; sk; sk=nsk)
	{
		nsk = sk->next;
		free(sk->fn);
		free(sk);
	}

	if (m->frames) free(m->frames);
	if (m->uvs) free(m->uvs);
	if (m->tris) free(m->tris);
	if (m->basepath) free(m->basepath);
	if (m->skinfn) free(m->skinfn);

	if (m->tex) free(m->tex);

	free(m);
}

// Assembly:
testq %rdi, %rdi
je 0x653fa
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x6536a
movq 0x10(%rdi), %r14
callq 0x61c0
movq %r14, %rdi
testq %r14, %r14
jne 0x65359
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x65390
movq 0x10(%r14), %rdi
movq 0x38(%r14), %r15
callq 0x61c0
movq %r14, %rdi
callq 0x61c0
movq %r15, %r14
testq %r15, %r15
jne 0x65373
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x6539e
callq 0x61c0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x653ac
callq 0x61c0
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x653bd
callq 0x61c0
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x653ce
callq 0x61c0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x653df
callq 0x61c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x653ed
callq 0x61c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x61c0
retq