LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: cntquad
static void cntquad (int x0, int y0, int z0, int x1, int y1, int z1, int x2, int y2, int z2, int face)
{
	int x, y, z;
	(void)x1; (void)y1; (void)z1; (void)face;

	x = abs(x2-x0); y = abs(y2-y0); z = abs(z2-z0);
	if (!x) x = z; else if (!y) y = z;
	if (x < y) { z = x; x = y; y = z; }
	shcnt[y*shcntp+x]++;
	if (x > gmaxx) gmaxx = x;
	if (y > gmaxy) gmaxy = y;
	garea += (x+(VOXBORDWIDTH<<1))*(y+(VOXBORDWIDTH<<1));
	gvox->qcnt++;
}

// Assembly:
movl 0x18(%rsp), %eax
movl 0x10(%rsp), %ecx
movl %ecx, %r8d
subl %esi, %r8d
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
subl %edx, %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl %esi, %ecx
movl 0x8(%rsp), %ecx
movl %r9d, %esi
cmovel %edx, %esi
movl %ecx, %r8d
subl %edi, %r8d
cmovel %r9d, %esi
movl %r8d, %eax
negl %eax
cmovsl %r8d, %eax
cmpl %edi, %ecx
cmovel %edx, %eax
cmpl %esi, %eax
movl %esi, %ecx
cmoval %eax, %ecx
cmovael %esi, %eax
movq 0x64f692(%rip), %rdx    # 0x6b30d0
movl 0x64f684(%rip), %esi    # 0x6b30c8
imull %eax, %esi
addl %ecx, %esi
movslq %esi, %rsi
incl (%rdx,%rsi,4)
cmpl 0x64f68b(%rip), %ecx    # 0x6b30e0
jle 0x63a5d
movl %ecx, 0x64f683(%rip)    # 0x6b30e0
cmpl 0x64f679(%rip), %eax    # 0x6b30dc
jle 0x63a6b
movl %eax, 0x64f671(%rip)    # 0x6b30dc
addl $0x2, %ecx
addl $0x2, %eax
imull %ecx, %eax
addl %eax, 0x64f65e(%rip)    # 0x6b30d8
movq 0x64f63f(%rip), %rax    # 0x6b30c0
incl 0x28(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: isolid
static int isolid (int x, int y, int z)
{
	if ((unsigned int)x >= (unsigned int)xsiz) return(0);
	if ((unsigned int)y >= (unsigned int)ysiz) return(0);
	if ((unsigned int)z >= (unsigned int)zsiz) return(0);
	z += x*yzsiz + y*zsiz; return(vbit[z>>5]&(1<<SHIFTMOD32(z)));
}

// Assembly:
xorl %eax, %eax
cmpl %edi, 0x64eeb0(%rip)    # 0x6b3078
jbe 0x64203
cmpl %esi, 0x64eeac(%rip)    # 0x6b307c
jbe 0x64203
movl 0x64eea8(%rip), %ecx    # 0x6b3080
cmpl %edx, %ecx
jbe 0x64203
imull 0x64eed9(%rip), %edi    # 0x6b30bc
imull %esi, %ecx
addl %edx, %ecx
addl %edi, %ecx
movq 0x64eea7(%rip), %rdx    # 0x6b3098
movl %ecx, %esi
movl $0x1, %eax
shll %cl, %eax
sarl $0x5, %esi
movslq %esi, %rcx
andl (%rdx,%rcx,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/mdsprite.c
// Function: isrectfree
static int isrectfree (int x0, int y0, int dx, int dy)
{
#if 0
	int i, j, x;
	i = y0*gvox->mytexx + x0;
	for(dy=0;dy;dy--,i+=gvox->mytexx)
		for(x=0;x<dx;x++) { j = i+x; if (zbit[j>>5]&(1<<SHIFTMOD32(j))) return(0); }
#else
	int i, c, m, m1, x;

	i = y0*mytexo5 + (x0>>5); dx += x0-1; c = (dx>>5) - (x0>>5);
	m = ~pow2m1[x0&31]; m1 = pow2m1[(dx&31)+1];
	if (!c) { for(m&=m1;dy;dy--,i+=mytexo5) if (zbit[i]&m) return(0); }
	else
	{  for(;dy;dy--,i+=mytexo5)
		{
			if (zbit[i]&m) return(0);
			for(x=1;x<c;x++) if (zbit[i+x]) return(0);
			if (zbit[i+x]&m1) return(0);
		}
	}
#endif
	return(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %eax
leal (%rdi,%rdx), %r8d
decl %r8d
movl %r8d, %r9d
andl $0x1f, %edi
andl $0x1f, %r8d
leaq 0x64eecb(%rip), %r10    # 0x6b30f0
movl (%r10,%rdi,4), %edx
movl 0x4(%r10,%r8,4), %edi
movslq 0x64ef4b(%rip), %r8     # 0x6b3180
imull %r8d, %esi
sarl $0x5, %eax
addl %eax, %esi
sarl $0x5, %r9d
notl %edx
subl %eax, %r9d
jne 0x6427c
movl $0x1, %eax
testl %ecx, %ecx
je 0x642df
movslq %esi, %rsi
shlq $0x2, %rsi
addq 0x64ef24(%rip), %rsi    # 0x6b3188
shlq $0x2, %r8
movl (%rsi), %r9d
andl %edx, %r9d
testl %edi, %r9d
jne 0x642dd
addq %r8, %rsi
decl %ecx
jne 0x64268
jmp 0x642df
testl %ecx, %ecx
je 0x642d6
movq 0x64ef01(%rip), %r10    # 0x6b3188
movslq %esi, %rsi
movl %r9d, %r11d
movslq %r9d, %rbx
leaq (%r10,%rsi,4), %r14
leaq (,%r8,4), %r15
xorl %eax, %eax
testl %edx, (%r10,%rsi,4)
jne 0x642df
movl $0x1, %r12d
cmpl $0x2, %r9d
jl 0x642c2
cmpl $0x0, (%r14,%r12,4)
jne 0x642df
incq %r12
cmpq %r12, %r11
jne 0x642b0
movq %rbx, %r12
leaq (%r10,%r12,4), %r12
testl %edi, (%r12,%rsi,4)
jne 0x642df
addq %r8, %rsi
addq %r15, %r14
decl %ecx
jne 0x6429e
movl $0x1, %eax
jmp 0x642df
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTM_InitIdent
void PTM_InitIdent(PTMIdent *id, PTHead *pth)
{
    memset(id, 0, sizeof(PTMIdent));

    if (!pth) {
        return;
    }

	if (pth->flags & PTH_HIGHTILE) {
        id->type = PTMIDENT_HIGHTILE;

		if (!pth->repldef) {
			if (polymosttexverbosity >= 1) {
				buildprintf("PolymostTex: cannot calculate texture id for pth with no repldef\n");
			}
			memset(id, 0, 16);
			return;
		}

		id->flags = pth->flags & (PTH_CLAMPED | PTH_SKYBOX);
		id->effects = (pth->palnum != pth->repldef->palnum)
            ? hictinting[pth->palnum].f : 0;
		if (pth->flags & PTH_SKYBOX) {
			// hightile + skybox + picnum ought to cover it
		    id->picnum = pth->picnum;
		} else {
		    strncpy(id->filename, pth->repldef->filename, BMAX_PATH);
		}
	} else {
		id->type = PTMIDENT_ART;
		id->flags = pth->flags & (PTH_CLAMPED);
		id->palnum = pth->palnum;
		id->picnum = pth->picnum;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x418, %edx            # imm = 0x418
xorl %esi, %esi
callq 0x62f0
testq %r14, %r14
je 0x644e6
testb $0x2, 0x38(%r14)
jne 0x64460
movl $0x0, (%rbx)
movzwl 0x38(%r14), %eax
andl $0x1, %eax
movl %eax, 0x4(%rbx)
movl 0x34(%r14), %eax
movl %eax, 0x8(%rbx)
jmp 0x644c0
movl $0x1, (%rbx)
cmpq $0x0, 0x40(%r14)
je 0x644c9
movzwl 0x38(%r14), %eax
andl $0x5, %eax
movl %eax, 0x4(%rbx)
movslq 0x34(%r14), %rax
movq 0x40(%r14), %rcx
movzbl 0x8(%rcx), %edx
xorl %ecx, %ecx
cmpl %edx, %eax
je 0x64496
leaq 0x5e379f(%rip), %rcx    # 0x647c30
movzbl 0x3(%rcx,%rax,4), %ecx
movl %ecx, 0x14(%rbx)
testb $0x4, 0x38(%r14)
jne 0x644c0
addq $0x18, %rbx
movq 0x40(%r14), %rax
movq 0x10(%rax), %rsi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6190
movl 0x30(%r14), %eax
movl %eax, 0xc(%rbx)
jmp 0x644e6
cmpl $0x0, 0x400bc(%rip)     # 0xa458c
jle 0x644e0
leaq 0x16887(%rip), %rdi     # 0x7ad60
xorl %eax, %eax
callq 0x24cb4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTM_GetHead
PTMHead * PTM_GetHead(const PTMIdent *id)
{
	PTMHash * ptmh;
	int i;
    unsigned int idcrc;

    idcrc = crc32once((unsigned char *)id, sizeof(PTMIdent));

	i = ptm_gethashhead(idcrc);
	ptmh = ptmhashhead[i];

	while (ptmh) {
        if (ptmh->idcrc == idcrc &&
            memcmp(&ptmh->id, id, sizeof(PTMIdent)) == 0) {
			return &ptmh->head;
		}
		ptmh = ptmh->next;
	}

	ptmh = (PTMHash *) malloc(sizeof(PTMHash));
	if (ptmh) {
		memset(ptmh, 0, sizeof(PTMHash));

        ptmh->idcrc = idcrc;
		memcpy(&ptmh->id, id, sizeof(PTMIdent));
		ptmh->next = ptmhashhead[i];
		ptmhashhead[i] = ptmh;
	}

	return &ptmh->head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x418, %esi            # imm = 0x418
callq 0x6e4ef
movl %eax, %ebp
movl %eax, %r15d
andl $0xfff, %r15d           # imm = 0xFFF
leaq 0x64ec7a(%rip), %r12    # 0x6b3190
movq (%r12,%r15,8), %rbx
testq %rbx, %rbx
je 0x6453e
cmpl %ebp, 0x20(%rbx)
jne 0x64539
leaq 0x24(%rbx), %rdi
movl $0x418, %edx            # imm = 0x418
movq %r14, %rsi
callq 0x6720
testl %eax, %eax
je 0x64581
movq (%rbx), %rbx
jmp 0x6451a
movl $0x440, %edi            # imm = 0x440
callq 0x69a0
movq %rax, %rbx
testq %rax, %rax
je 0x64581
movl $0x440, %edx            # imm = 0x440
movq %rbx, %rdi
xorl %esi, %esi
callq 0x62f0
movl %ebp, 0x20(%rbx)
movq %rbx, %rdi
addq $0x24, %rdi
movl $0x418, %edx            # imm = 0x418
movq %r14, %rsi
callq 0x60c0
movq (%r12,%r15,8), %rax
movq %rax, (%rbx)
movq %rbx, (%r12,%r15,8)
addq $0x8, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTMarkPrime
void PTMarkPrime(int picnum, int palnum, unsigned short flags)
{
	PTHash * pth;

	pth = pt_findhash(picnum, palnum, flags, 1);
	if (pth) {
		if (pth->primecnt == 0) {
			primecnt++;
		}
		pth->primecnt++;
	}
}

// Assembly:
pushq %rax
movl $0x1, %ecx
callq 0x653e1
testq %rax, %rax
je 0x653df
movl 0x60(%rax), %ecx
testl %ecx, %ecx
jne 0x653da
incl 0x65ddb6(%rip)          # 0x6c3190
incl %ecx
movl %ecx, 0x60(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTDoPrime
int PTDoPrime(int* done, int* total)
{
	PTHash * pth;

	if (primepos >= PTHASHHEADSIZ) {
		// done
		return 0;
	}

	if (primepos == 0) {
		int i;

		// first, unload all the textures that are not marked
		for (i=PTHASHHEADSIZ-1; i>=0; i--) {
			pth = pthashhead[i];
			while (pth) {
				if (pth->primecnt == 0) {
					pt_unload(pth);
				}
				pth = pth->next;
			}
		}
	}

	pth = pthashhead[primepos];
	while (pth) {
		if (pth->primecnt > 0) {
			primedone++;
			pt_load(pth);
		}
		pth = pth->next;
	}

	*done = primedone;
	*total = primecnt;
	primepos++;

	return (primepos < PTHASHHEADSIZ);
}

// Assembly:
movl 0x65dc3a(%rip), %ecx    # 0x6c3198
xorl %eax, %eax
cmpl $0xfff, %ecx            # imm = 0xFFF
jg 0x6564c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rsp)
leaq 0x655c0b(%rip), %r15    # 0x6bb190
testl %ecx, %ecx
jne 0x655e2
movl $0xfff, %r12d           # imm = 0xFFF
leaq 0x5941aa(%rip), %r13    # 0x5f9740
movq (%r15,%r12,8), %rbp
testq %rbp, %rbp
je 0x655dc
cmpl $0x0, 0x60(%rbp)
jne 0x655d6
movl $0x30, %ebx
movq (%rbp,%rbx), %rsi
testq %rsi, %rsi
je 0x655d0
cmpl $0x0, (%rsi)
je 0x655d0
movl $0x1, %edi
callq *0xc0(%r13)
movq (%rbp,%rbx), %rax
movl $0x0, (%rax)
addq $-0x8, %rbx
jne 0x655aa
movq (%rbp), %rbp
jmp 0x6559a
subq $0x1, %r12
jae 0x65596
movslq 0x65dbaf(%rip), %rax    # 0x6c3198
movq (%r15,%rax,8), %r15
testq %r15, %r15
movq (%rsp), %rbx
je 0x65613
cmpl $0x0, 0x60(%r15)
jle 0x6560b
incl 0x65db91(%rip)          # 0x6c3194
movq %r15, %rdi
callq 0x6564d
movq (%r15), %r15
testq %r15, %r15
jne 0x655f6
movl 0x65db7b(%rip), %eax    # 0x6c3194
movl %eax, (%r14)
movl 0x65db6e(%rip), %eax    # 0x6c3190
movl %eax, (%rbx)
movl 0x65db6e(%rip), %ecx    # 0x6c3198
leal 0x1(%rcx), %eax
movl %eax, 0x65db65(%rip)    # 0x6c3198
xorl %eax, %eax
cmpl $0xfff, %ecx            # imm = 0xFFF
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: pt_load
static int pt_load(PTHash * pth)
{
	if (pth->head.pic[PTHPIC_BASE] &&
		pth->head.pic[PTHPIC_BASE]->glpic != 0 &&
		(pth->head.pic[PTHPIC_BASE]->flags & PTH_DIRTY) == 0) {
		return 1;	// loaded
	}

	if ((pth->head.flags & PTH_HIGHTILE)) {
		// try and load from a replacement
		if (pt_load_hightile(&pth->head)) {
			return 1;
		}

		// if that failed, get the hash for the ART version and
		//   defer this to there
		pth->deferto = pt_findhash(
				pth->head.picnum, pth->head.palnum,
				(pth->head.flags & ~PTH_HIGHTILE),
				1);
		if (!pth->deferto) {
			return 0;
		}
		return pt_load(pth->deferto);
	}

	if (pt_load_art(&pth->head)) {
		return 1;
	}

	// we're SOL
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x65665
cmpl $0x0, (%rax)
je 0x65665
testb $-0x80, 0x4(%rax)
je 0x6569f
leaq 0x8(%rbx), %rdi
testb $0x2, 0x40(%rbx)
je 0x656a6
callq 0x65e38
testl %eax, %eax
jne 0x6569f
movl 0x38(%rbx), %edi
movl 0x3c(%rbx), %esi
movzwl 0x40(%rbx), %edx
andl $-0x3, %edx
movl $0x1, %ecx
callq 0x653e1
movq %rax, 0x58(%rbx)
movq %rax, %rbx
testq %rax, %rax
jne 0x65651
xorl %eax, %eax
jmp 0x656a4
movl $0x1, %eax
popq %rbx
retq
popq %rbx
jmp 0x6604c
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTReset
void PTReset(void)
{
	PTHash * pth;
	int i;

	for (i=PTHASHHEADSIZ-1; i>=0; i--) {
		pth = pthashhead[i];
		while (pth) {
			pt_unload(pth);
			pth = pth->next;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xfff, %ebx            # imm = 0xFFF
leaq 0x655acf(%rip), %r14    # 0x6bb190
leaq 0x594078(%rip), %r15    # 0x5f9740
movq (%r14,%rbx,8), %r12
testq %r12, %r12
je 0x65707
movl $0x30, %r13d
movq (%r12,%r13), %rsi
testq %rsi, %rsi
je 0x656fb
cmpl $0x0, (%rsi)
je 0x656fb
movl $0x1, %edi
callq *0xc0(%r15)
movq (%r12,%r13), %rax
movl $0x0, (%rax)
addq $-0x8, %r13
jne 0x656d7
movq (%r12), %r12
jmp 0x656cc
subq $0x1, %rbx
jae 0x656c8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTClear
void PTClear(void)
{
	PTHash * pth, * next;
	PTMHash * ptmh, * mnext;
	int i;

	for (i=PTHASHHEADSIZ-1; i>=0; i--) {
		pth = pthashhead[i];
		while (pth) {
			next = pth->next;
			pt_unload(pth);
			free(pth);
			pth = next;
		}
		pthashhead[i] = 0;
	}

	for (i=PTMHASHHEADSIZ-1; i>=0; i--) {
		ptmh = ptmhashhead[i];
		while (ptmh) {
			mnext = ptmh->next;
			free(ptmh);
			ptmh = mnext;
		}
		ptmhashhead[i] = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xfff, %r14d           # imm = 0xFFF
leaq 0x655a61(%rip), %r15    # 0x6bb190
leaq 0x59400a(%rip), %r12    # 0x5f9740
movq (%r15,%r14,8), %rbx
testq %rbx, %rbx
je 0x65782
movq (%rbx), %r13
movl $0x30, %ebp
movq (%rbx,%rbp), %rsi
testq %rsi, %rsi
je 0x6576c
cmpl $0x0, (%rsi)
je 0x6576c
movl $0x1, %edi
callq *0xc0(%r12)
movq (%rbx,%rbp), %rax
movl $0x0, (%rax)
addq $-0x8, %rbp
jne 0x65747
movq %rbx, %rdi
callq 0x61c0
movq %r13, %rbx
testq %r13, %r13
jne 0x6573f
movq $0x0, (%r15,%r14,8)
subq $0x1, %r14
jae 0x65736
movl $0xfff, %ebx            # imm = 0xFFF
leaq 0x64d9f4(%rip), %r14    # 0x6b3190
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x657b5
movq (%rdi), %r15
callq 0x61c0
movq %r15, %rdi
testq %r15, %r15
jne 0x657a5
movq $0x0, (%r14,%rbx,8)
subq $0x1, %rbx
jae 0x6579c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PT_GetHead
PTHead * PT_GetHead(int picnum, int palnum, unsigned short flags, int peek)
{
	PTHash * pth;

	pth = pt_findhash(picnum, palnum, flags, peek == 0);
	if (pth == 0) {
		return 0;
	}

	if (!pt_load(pth)) {
		return 0;
	}

	while (pth->deferto) {
		// this might happen if pt_load needs to defer to ART
		pth = pth->deferto;
	}

	return &pth->head;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movl %eax, %ecx
callq 0x653e1
testq %rax, %rax
je 0x65807
movq %rax, %rbx
movq %rax, %rdi
callq 0x6564d
testl %eax, %eax
je 0x65807
movq %rbx, %rax
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
jne 0x657f5
addq $0x8, %rax
jmp 0x65809
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: PTIterNewMatch
PTIter PTIterNewMatch(int match, int picnum, int palnum, unsigned short flagsmask, unsigned short flags)
{
	PTIter iter;

	iter = (PTIter) malloc(sizeof(struct PTIter_typ));
	if (!iter) {
		return 0;
	}

	iter->i = 0;
	iter->pth = pthashhead[0];
	iter->match = match;
	iter->picnum = picnum;
	iter->palnum = palnum;
	iter->flagsmask = flagsmask;
	iter->flags = flags;

	if ((match & PTITER_PICNUM)) {
		iter->i = pt_gethashhead(picnum);
		iter->pth = pthashhead[iter->i];
		if (iter->pth == 0) {
			iter->pth = 0;
			return iter;
		}
	}

	ptiter_seekforward(iter);

	return iter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movl %edi, %r15d
movl $0x20, %edi
callq 0x69a0
testq %rax, %rax
je 0x6588b
movq %rax, %rbx
movl $0x0, (%rax)
movq 0x65594c(%rip), %rax    # 0x6bb190
movq %rax, 0x8(%rbx)
movl %r15d, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
movl %r13d, 0x18(%rbx)
movw %r12w, 0x1c(%rbx)
movw %bp, 0x1e(%rbx)
testb $0x1, %r15b
je 0x65881
andl $0xfff, %r14d           # imm = 0xFFF
movl %r14d, (%rbx)
leaq 0x65591c(%rip), %rax    # 0x6bb190
movq (%rax,%r14,8), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6588f
movq %rbx, %rdi
callq 0x658a9
jmp 0x65897
xorl %ebx, %ebx
jmp 0x65897
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttex.c
// Function: ptiter_seekforward
static void ptiter_seekforward(PTIter iter)
{
	while (1) {
		if (iter->pth && ptiter_matches(iter)) {
			break;
		}
		if (iter->pth == 0) {
			if ((iter->match & PTITER_PICNUM)) {
				// because the hash key is based on picture number,
				// reaching the end of the hash chain means we need
				// not look further
				break;
			}
			iter->i++;
			if (iter->i >= PTHASHHEADSIZ) {
				// end of hash
				iter->pth = 0;
				iter->i = PTHASHHEADSIZ;
				break;
			}
			iter->pth = pthashhead[iter->i];
		} else {
			iter->pth = iter->pth->next;
		}
	}
}

// Assembly:
movq 0x8(%rdi), %rcx
leaq 0x6558dc(%rip), %rax    # 0x6bb190
testq %rcx, %rcx
je 0x658f2
movl 0x10(%rdi), %edx
testl %edx, %edx
je 0x65925
testb $0x1, %dl
je 0x658cd
movl 0x38(%rcx), %esi
cmpl 0x14(%rdi), %esi
jne 0x658ed
testb $0x2, %dl
je 0x658da
movl 0x3c(%rcx), %esi
cmpl 0x18(%rdi), %esi
jne 0x658ed
testb $0x4, %dl
je 0x65925
movzwl 0x1c(%rdi), %edx
andw 0x40(%rcx), %dx
cmpw 0x1e(%rdi), %dx
je 0x65925
testq %rcx, %rcx
jne 0x6590e
testb $0x1, 0x10(%rdi)
jne 0x65925
movslq (%rdi), %rdx
leaq 0x1(%rdx), %rcx
movl %ecx, (%rdi)
cmpq $0xfff, %rdx            # imm = 0xFFF
jge 0x65917
leaq (%rax,%rcx,8), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rdi)
jmp 0x658b4
movq $0x0, 0x8(%rdi)
movl $0x1000, (%rdi)         # imm = 0x1000
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: PTCacheUnloadIndex
void PTCacheUnloadIndex(void)
{
	PTCacheIndex * pci, * next;
	int i;

	for (i = 0; i < PTCACHEHASHSIZ; i++) {
		pci = cachehead[i];
		while (pci) {
			next = pci->next;
			// we needn't free pci->filename since it was alloced with pci
			free(pci);
			pci = next;
		}
		cachehead[i] = 0;
	}

	buildprintf("PolymostTexCache: cache index unloaded\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0x65c8bf(%rip), %r14    # 0x6c31b0
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x6690b
movq 0x18(%rdi), %r15
callq 0x61c0
movq %r15, %rdi
testq %r15, %r15
jne 0x668fa
movq $0x0, (%r14,%rbx,8)
incq %rbx
cmpq $0x200, %rbx            # imm = 0x200
jne 0x668f1
leaq 0x14747(%rip), %rdi     # 0x7b06d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x24cb4
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: ptcache_findhash
static PTCacheIndex * ptcache_findhash(const char * filename, int effects, int flags)
{
	PTCacheIndex * pci;

	pci = cachehead[ gethashhead(filename) ];
	if (!pci) {
		return 0;
	}

	flags &= PTH_CLAMPED;

	while (pci) {
		if (effects == pci->effects &&
		    flags == pci->flags &&
		    strcmp(pci->filename, filename) == 0) {
			return pci;
		}
		pci = pci->next;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movb (%rdi), %dl
testb %dl, %dl
je 0x6696f
leaq 0x1(%r14), %rcx
movl $0x1505, %eax           # imm = 0x1505
movq %rax, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movzbl %dl, %eax
xorq %rsi, %rax
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x6694f
andl $0x1ff, %eax            # imm = 0x1FF
jmp 0x66974
movl $0x105, %eax            # imm = 0x105
leaq 0x65c835(%rip), %rcx    # 0x6c31b0
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x669ab
andl $0x1, %ebx
cmpl %ebp, 0x8(%r15)
jne 0x669a2
cmpl 0xc(%r15), %ebx
jne 0x669a2
movq (%r15), %rdi
movq %r14, %rsi
callq 0x68d0
testl %eax, %eax
je 0x669ae
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x66987
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: ptcache_addhash
static void ptcache_addhash(const char * filename, int effects, int flags, unsigned offset)
{
	unsigned int hash = gethashhead(filename);

	// to reduce memory fragmentation we tack the filename onto the end of the block
	PTCacheIndex * pci = (PTCacheIndex *) malloc(sizeof(PTCacheIndex) + strlen(filename) + 1);

	pci->filename = (char *) pci + sizeof(PTCacheIndex);
	strcpy(pci->filename, filename);
	pci->effects = effects;
	pci->flags   = flags & (PTH_CLAMPED);
	pci->offset  = offset;
	pci->next = cachehead[hash];

	cachehead[hash] = pci;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movb (%rdi), %cl
testb %cl, %cl
je 0x66a04
leaq 0x1(%r15), %rax
movl $0x1505, %r13d          # imm = 0x1505
movq %r13, %rdx
shlq $0x5, %rdx
addq %r13, %rdx
movzbl %cl, %r13d
xorq %rdx, %r13
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x669e1
andl $0x1ff, %r13d           # imm = 0x1FF
jmp 0x66a0a
movl $0x105, %r13d           # imm = 0x105
movq %r15, %rdi
callq 0x6420
leaq 0x21(%rax), %rdi
callq 0x69a0
movq %rax, %r12
leaq 0x20(%rax), %rdi
movq %rdi, (%rax)
movq %r15, %rsi
callq 0x6430
movl %r14d, 0x8(%r12)
andl $0x1, %ebp
movl %ebp, 0xc(%r12)
movl %ebx, 0x10(%r12)
leaq 0x65c76a(%rip), %rax    # 0x6c31b0
movq (%rax,%r13,8), %rcx
movq %rcx, 0x18(%r12)
movq %r12, (%rax,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: PTCacheFreeTile
void PTCacheFreeTile(PTCacheTile * tdef)
{
	int i;

	if (tdef->filename) {
		free(tdef->filename);
	}
	for (i = 0; i < tdef->nummipmaps; i++) {
		if (tdef->mipmap[i].data) {
			free(tdef->mipmap[i].data);
		}
	}
	free(tdef);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x66d5c
callq 0x61c0
cmpl $0x0, 0x1c(%rbx)
jle 0x66d86
leaq 0x30(%rbx), %r14
xorl %r15d, %r15d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x66d76
callq 0x61c0
incq %r15
movslq 0x1c(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x66d69
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttexcache.c
// Function: PTCacheAllocNewTile
PTCacheTile * PTCacheAllocNewTile(int nummipmaps)
{
	int size = sizeof(PTCacheTile) + (nummipmaps-1) * sizeof(PTCacheTileMip);
	PTCacheTile * tdef;

	tdef = (PTCacheTile *) malloc(size);
	memset(tdef, 0, size);

	tdef->nummipmaps = nummipmaps;

	return tdef;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leal (%rbx,%rbx,2), %eax
leal 0x20(,%rax,8), %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x69a0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x62f0
movl %ebx, 0x1c(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymosttexcompress.cc
// Function: ptcompress_getstorage
int ptcompress_getstorage(int width, int height, int format)
{
	switch (format) {
		case PTCOMPRESS_DXT1:
		case PTCOMPRESS_DXT5:
			return squish::GetStorageRequirements(width, height, getsquishflags(format));
		case PTCOMPRESS_ETC1:
			return 8 * ((width + 3) / 4) * ((height + 3) / 4);
	}
	return 0;
}

// Assembly:
leal -0x1(%rdx), %eax
cmpl $0x2, %eax
jae 0x67260
leaq 0x592755(%rip), %rax    # 0x5f9988
movl (%rax), %eax
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
shll $0x5, %ecx
addl $0x220, %ecx            # imm = 0x220
cmpl $0x2, %eax
movl $0x300, %eax            # imm = 0x300
cmovnel %ecx, %eax
cmpl $0x2, %edx
je 0x6728c
cmpl $0x1, %edx
jne 0x6728f
orl $0x1, %eax
jmp 0x6728f
xorl %eax, %eax
cmpl $0x3, %edx
jne 0x6728b
leal 0x3(%rdi), %eax
addl $0x6, %edi
testl %eax, %eax
cmovnsl %eax, %edi
shrl $0x2, %edi
leal 0x3(%rsi), %eax
addl $0x6, %esi
testl %eax, %eax
cmovnsl %eax, %esi
shrl $0x2, %esi
imull %edi, %esi
shll $0x3, %esi
movl %esi, %eax
retq
orl $0x4, %eax
movl %eax, %edx
jmp 0x6affb
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::pack_color5(unsigned int, unsigned int, unsigned int, bool, unsigned int)
uint16 etc1_block::pack_color5(uint r, uint g, uint b, bool scaled, uint bias)
   {
      if (scaled)
      {
         r = (r * 31U + bias) / 255U;
         g = (g * 31U + bias) / 255U;
         b = (b * 31U + bias) / 255U;
      }

      r = rg_etc1::minimum(r, 31U);
      g = rg_etc1::minimum(g, 31U);
      b = rg_etc1::minimum(b, 31U);

      return static_cast<uint16>(b | (g << 5U) | (r << 10U));
   }

// Assembly:
movl %edi, %eax
testl %ecx, %ecx
je 0x675f5
movl %eax, %ecx
shll $0x5, %ecx
subl %eax, %ecx
addl %r8d, %ecx
movl $0x80808081, %eax       # imm = 0x80808081
imulq %rax, %rcx
shrq $0x27, %rcx
movl %esi, %edi
shll $0x5, %edi
subl %esi, %edi
addl %r8d, %edi
imulq %rax, %rdi
shrq $0x27, %rdi
movl %edx, %esi
shll $0x5, %esi
subl %edx, %esi
addl %r8d, %esi
imulq %rax, %rsi
shrq $0x27, %rsi
movl %esi, %edx
movl %edi, %esi
movl %ecx, %eax
movl $0x1f, %ecx
cmpl %ecx, %eax
cmovael %ecx, %eax
cmpl %ecx, %esi
cmovael %ecx, %esi
cmpl %ecx, %edx
cmovbl %edx, %ecx
shll $0x5, %esi
orl %ecx, %esi
shll $0xa, %eax
orl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(unsigned short, bool, unsigned int)
color_quad_u8 etc1_block::unpack_color5(uint16 packed_color5, bool scaled, uint alpha)
   {
      uint b = packed_color5 & 31U;
      uint g = (packed_color5 >> 5U) & 31U;
      uint r = (packed_color5 >> 10U) & 31U;

      if (scaled)
      {
         b = (b << 3U) | (b >> 2U);
         g = (g << 3U) | (g >> 2U);
         r = (r << 3U) | (r >> 2U);
      }

      return color_quad_u8(cNoClamp, r, g, b, rg_etc1::minimum(alpha, 255U));
   }

// Assembly:
movq %rdi, %rax
movl %esi, %edi
andl $0x1f, %edi
movl %esi, %r8d
shrl $0x5, %r8d
andl $0x1f, %r8d
shrl $0xa, %esi
andl $0x1f, %esi
testl %edx, %edx
je 0x6764b
movl %edi, %edx
shrl $0x2, %edx
leal (%rdx,%rdi,8), %edi
movl %r8d, %edx
shrl $0x2, %edx
leal (%rdx,%r8,8), %r8d
movl %esi, %edx
shrl $0x2, %edx
leal (%rdx,%rsi,8), %esi
movl $0xff, %edx
cmpl %edx, %ecx
cmovbl %ecx, %edx
movb %sil, (%rax)
movb %r8b, 0x1(%rax)
movb %dil, 0x2(%rax)
movb %dl, 0x3(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(rg_etc1::color_quad_u8&, unsigned short, unsigned short, bool, unsigned int)
bool etc1_block::unpack_color5(color_quad_u8& result, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha)
   {
      int dc_r, dc_g, dc_b;
      unpack_delta3(dc_r, dc_g, dc_b, packed_delta3);
      
      int b = (packed_color5 & 31U) + dc_b;
      int g = ((packed_color5 >> 5U) & 31U) + dc_g;
      int r = ((packed_color5 >> 10U) & 31U) + dc_r;

      bool success = true;
      if (static_cast<uint>(r | g | b) > 31U)
      {
         success = false;
         r = rg_etc1::clamp<int>(r, 0, 31);
         g = rg_etc1::clamp<int>(g, 0, 31);
         b = rg_etc1::clamp<int>(b, 0, 31);
      }

      if (scaled)
      {
         b = (b << 3U) | (b >> 2U);
         g = (g << 3U) | (g >> 2U);
         r = (r << 3U) | (r >> 2U);
      }

      result.set_noclamp_rgba(r, g, b, rg_etc1::minimum(alpha, 255U));
      return success;
   }

// Assembly:
pushq %rax
movl %edx, %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %edx, %r9d
shrl $0x3, %r9d
andl $0x7, %r9d
andl $0x7, %edx
xorl %r10d, %r10d
cmpl $0x4, %eax
setb %r10b
leal (%rax,%r10,8), %eax
xorl %r10d, %r10d
cmpl $0x4, %r9d
setb %r10b
leal (%r9,%r10,8), %r9d
xorl %r10d, %r10d
cmpl $0x4, %edx
setb %r10b
leal (%rdx,%r10,8), %edx
movl %esi, %r10d
andl $0x1f, %r10d
addl %r10d, %edx
addl $-0x8, %edx
movl %esi, %r10d
shrl $0x5, %r10d
andl $0x1f, %r10d
addl %r10d, %r9d
addl $-0x8, %r9d
shrl $0xa, %esi
andl $0x1f, %esi
addl %eax, %esi
addl $-0x8, %esi
movl %r9d, %eax
orl %edx, %eax
orl %esi, %eax
cmpl $0x20, %eax
jb 0x67755
movl $0x1f, %r10d
cmpl %r10d, %esi
cmovgel %r10d, %esi
xorl %r11d, %r11d
testl %esi, %esi
cmovlel %r11d, %esi
cmpl %r10d, %r9d
cmovgel %r10d, %r9d
testl %r9d, %r9d
cmovlel %r11d, %r9d
cmpl %r10d, %edx
cmovll %edx, %r10d
testl %r10d, %r10d
cmovlel %r11d, %r10d
movl %r10d, %edx
testb %cl, %cl
je 0x67780
leal (,%rdx,8), %ecx
sarl $0x2, %edx
orl %ecx, %edx
leal (,%r9,8), %ecx
sarl $0x2, %r9d
orl %ecx, %r9d
leal (,%rsi,8), %ecx
sarl $0x2, %esi
orl %ecx, %esi
cmpl $0x100, %esi            # imm = 0x100
jae 0x677ba
cmpl $0x100, %r9d            # imm = 0x100
jae 0x677d9
cmpl $0x100, %edx            # imm = 0x100
jae 0x677f8
cmpl $0x20, %eax
setb %al
movl $0xff, %ecx
cmpl %ecx, %r8d
cmovbl %r8d, %ecx
movb %sil, (%rdi)
movb %r9b, 0x1(%rdi)
movb %dl, 0x2(%rdi)
movb %cl, 0x3(%rdi)
popq %rcx
retq
leaq 0x13d46(%rip), %rdi     # 0x7b507
leaq 0x139e7(%rip), %rsi     # 0x7b1af
leaq 0x13d7b(%rip), %rcx     # 0x7b54a
movl $0xb3, %edx
callq 0x61b0
leaq 0x13dd6(%rip), %rdi     # 0x7b5b6
leaq 0x139c8(%rip), %rsi     # 0x7b1af
leaq 0x13d5c(%rip), %rcx     # 0x7b54a
movl $0xb4, %edx
callq 0x61b0
leaq 0x13dfe(%rip), %rdi     # 0x7b5fd
leaq 0x139a9(%rip), %rsi     # 0x7b1af
leaq 0x13d3d(%rip), %rcx     # 0x7b54a
movl $0xb5, %edx
callq 0x61b0
nop
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_delta3(int&, int&, int&, unsigned short)
void etc1_block::unpack_delta3(int& r, int& g, int& b, uint16 packed_delta3)
   {
      r = (packed_delta3 >> 6) & 7;
      g = (packed_delta3 >> 3) & 7;
      b = packed_delta3 & 7;
      if (r >= 4) r -= 8;
      if (g >= 4) g -= 8;
      if (b >= 4) b -= 8;
   }

// Assembly:
movl %ecx, %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, (%rdi)
movl %ecx, %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, (%rsi)
andl $0x7, %ecx
movl %ecx, (%rdx)
movl (%rdi), %eax
cmpl $0x4, %eax
jl 0x6783d
addl $-0x8, %eax
movl %eax, (%rdi)
movl (%rsi), %eax
cmpl $0x4, %eax
jl 0x67849
addl $-0x8, %eax
movl %eax, (%rsi)
movl (%rdx), %eax
cmpl $0x4, %eax
jl 0x67855
addl $-0x8, %eax
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color5(unsigned int&, unsigned int&, unsigned int&, unsigned short, unsigned short, bool, unsigned int)
bool etc1_block::unpack_color5(uint& r, uint& g, uint& b, uint16 packed_color5, uint16 packed_delta3, bool scaled, uint alpha)
   {
      color_quad_u8 result;
      const bool success = unpack_color5(result, packed_color5, packed_delta3, scaled, alpha);
      r = result.r;
      g = result.g;
      b = result.b;
      return success;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %eax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x30(%rsp), %r8d
leaq 0x4(%rsp), %r12
movq %r12, %rdi
movl %ecx, %esi
movl %eax, %edx
movl %r9d, %ecx
callq 0x676a8
movzbl (%r12), %ecx
movl %ecx, (%r15)
movzbl 0x1(%r12), %ecx
movl %ecx, (%r14)
movzbl 0x2(%r12), %ecx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::pack_delta3(int, int, int)
uint16 etc1_block::pack_delta3(int r, int g, int b)
   {
      RG_ETC1_ASSERT((r >= cETC1ColorDeltaMin) && (r <= cETC1ColorDeltaMax));
      RG_ETC1_ASSERT((g >= cETC1ColorDeltaMin) && (g <= cETC1ColorDeltaMax));
      RG_ETC1_ASSERT((b >= cETC1ColorDeltaMin) && (b <= cETC1ColorDeltaMax));
      if (r < 0) r += 8;
      if (g < 0) g += 8;
      if (b < 0) b += 8;
      return static_cast<uint16>(b | (g << 3) | (r << 6));
   }

// Assembly:
pushq %rax
leal 0x4(%rdi), %eax
cmpl $0x8, %eax
jae 0x678e5
leal 0x4(%rsi), %eax
cmpl $0x8, %eax
jae 0x67904
leal 0x4(%rdx), %eax
cmpl $0x8, %eax
jae 0x67923
movl %edi, %eax
shrl $0x1f, %eax
leal (%rdi,%rax,8), %eax
movl %esi, %ecx
shrl $0x1f, %ecx
leal (%rsi,%rcx,8), %ecx
movl %edx, %esi
shrl $0x1f, %esi
leal (%rdx,%rsi,8), %edx
shll $0x3, %ecx
shll $0x6, %eax
orl %ecx, %eax
orl %edx, %eax
popq %rcx
retq
leaq 0x1388c(%rip), %rdi     # 0x7b178
leaq 0x138bc(%rip), %rsi     # 0x7b1af
leaq 0x138c5(%rip), %rcx     # 0x7b1bf
movl $0x3fc, %edx            # imm = 0x3FC
callq 0x61b0
leaq 0x138f2(%rip), %rdi     # 0x7b1fd
leaq 0x1389d(%rip), %rsi     # 0x7b1af
leaq 0x138a6(%rip), %rcx     # 0x7b1bf
movl $0x3fd, %edx            # imm = 0x3FD
callq 0x61b0
leaq 0x1390a(%rip), %rdi     # 0x7b234
leaq 0x1387e(%rip), %rsi     # 0x7b1af
leaq 0x13887(%rip), %rcx     # 0x7b1bf
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x61b0
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::pack_color4(unsigned int, unsigned int, unsigned int, bool, unsigned int)
uint16 etc1_block::pack_color4(uint r, uint g, uint b, bool scaled, uint bias)
   {
      if (scaled)
      {
         r = (r * 15U + bias) / 255U;
         g = (g * 15U + bias) / 255U;
         b = (b * 15U + bias) / 255U;
      }

      r = rg_etc1::minimum(r, 15U);
      g = rg_etc1::minimum(g, 15U);
      b = rg_etc1::minimum(b, 15U);

      return static_cast<uint16>(b | (g << 4U) | (r << 8U));
   }

// Assembly:
movl %edi, %eax
testl %ecx, %ecx
je 0x679e4
leal (%rax,%rax,4), %eax
leal (%rax,%rax,2), %eax
addl %r8d, %eax
movl $0x80808081, %ecx       # imm = 0x80808081
imulq %rcx, %rax
shrq $0x27, %rax
leal (%rsi,%rsi,4), %esi
leal (%rsi,%rsi,2), %esi
addl %r8d, %esi
imulq %rcx, %rsi
shrq $0x27, %rsi
leal (%rdx,%rdx,4), %edx
leal (%rdx,%rdx,2), %edx
addl %r8d, %edx
imulq %rcx, %rdx
shrq $0x27, %rdx
movl $0xf, %ecx
cmpl %ecx, %eax
cmovael %ecx, %eax
cmpl %ecx, %esi
cmovael %ecx, %esi
cmpl %ecx, %edx
cmovbl %edx, %ecx
shll $0x4, %esi
orl %ecx, %esi
shll $0x8, %eax
orl %esi, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/rg_etc1.cpp
// Function: rg_etc1::etc1_block::unpack_color4(unsigned short, bool, unsigned int)
color_quad_u8 etc1_block::unpack_color4(uint16 packed_color4, bool scaled, uint alpha)
   {
      uint b = packed_color4 & 15U;
      uint g = (packed_color4 >> 4U) & 15U;
      uint r = (packed_color4 >> 8U) & 15U;

      if (scaled)
      {
         b = (b << 4U) | b;
         g = (g << 4U) | g;
         r = (r << 4U) | r;
      }

      return color_quad_u8(cNoClamp, r, g, b, rg_etc1::minimum(alpha, 255U));
   }

// Assembly:
pushq %rbx
movq %rdi, %rax
movl %esi, %r9d
shrl $0x8, %r9d
movl %esi, %edi
andb $0xf, %dil
movzbl %dil, %r8d
movl %r8d, %edi
shll $0x4, %edi
addl %r8d, %edi
shrb $0x4, %sil
movzbl %sil, %esi
movl %esi, %r10d
shll $0x4, %r10d
addl %esi, %r10d
andb $0xf, %r9b
movzbl %r9b, %r9d
movl %r9d, %r11d
shll $0x4, %r11d
addl %r9d, %r11d
movl $0xff, %ebx
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
testl %edx, %edx
cmovel %r9d, %r11d
movb %r11b, (%rax)
cmovel %esi, %r10d
cmovel %r8d, %edi
movb %r10b, 0x1(%rax)
movb %dil, 0x2(%rax)
movb %bl, 0x3(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::Decompress(unsigned char*, void const*, int)
void Decompress( u8* rgba, void const* block, int flags )
{
    // fix any bad flags
    flags = FixFlags( flags );

    // get the block locations
    void const* colourBlock = block;
    void const* alphaBlock = block;
    if( ( flags & ( kDxt3 | kDxt5 ) ) != 0 )
        colourBlock = reinterpret_cast< u8 const* >( block ) + 8;

    // decompress colour
    DecompressColour( rgba, colourBlock, ( flags & kDxt1 ) != 0 );

    // decompress alpha separately if necessary
    if( ( flags & kDxt3 ) != 0 )
        DecompressAlphaDxt3( rgba, alphaBlock );
    else if( ( flags & kDxt5 ) != 0 )
        DecompressAlphaDxt5( rgba, alphaBlock );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
andl $0x1f, %edx
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pcmpeqd 0x1228b(%rip), %xmm0    # 0x7d230
movq %rdi, %r14
movmskps %xmm0, %eax
testl %eax, %eax
movl $0x1, %ebp
cmovnel %edx, %ebp
xorl %eax, %eax
testb $0x6, %bpl
setne %al
leaq (%rsi,%rax,8), %rsi
movl %ebp, %edx
andl $0x1, %edx
callq 0x700d1
testb $0x2, %bpl
jne 0x6afdd
testb $0x4, %bpl
jne 0x6afec
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6e609
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x6eadf
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::GetStorageRequirements(int, int, int)
static int FixFlags( int flags )
{
    // grab the flag bits
    int method = flags & ( kDxt1 | kDxt3 | kDxt5 | kBc4 | kBc5 );
    int fit = flags & ( kColourIterativeClusterFit | kColourClusterFit | kColourRangeFit );
    int extra = flags & (kWeightColourByAlpha | kSourceBGRA);   //JonoF

    // set defaults
    if ( method != kDxt3
    &&   method != kDxt5
    &&   method != kBc4
    &&   method != kBc5 )
    {
        method = kDxt1;
    }
    if( fit != kColourRangeFit && fit != kColourIterativeClusterFit )
        fit = kColourClusterFit;

    // done
    return method | fit | extra;
}

// Assembly:
movl %edx, %eax
andl $0x1f, %eax
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pcmpeqd 0x1221f(%rip), %xmm0    # 0x7d230
movmskps %xmm0, %eax
testl %eax, %eax
setne %r8b
leal 0x3(%rdi), %eax
leal 0x6(%rdi), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
leal 0x3(%rsi), %edi
leal 0x6(%rsi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
sarl $0x2, %eax
imull %ecx, %eax
testb $0x9, %dl
sete %cl
andb %r8b, %cl
addb $0x3, %cl
shll %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/libsquish/squish.cpp
// Function: squish::CopyRGBA(unsigned char const*, unsigned char*, int)
void CopyRGBA( u8 const* source, u8* dest, int flags )
{
    if (flags & kSourceBGRA)
    {
        // convert from bgra to rgba
        dest[0] = source[2];
        dest[1] = source[1];
        dest[2] = source[0];
        dest[3] = source[3];
    }
    else
    {
        for( int i = 0; i < 4; ++i )
            *dest++ = *source++;
    }
}

// Assembly:
btl $0x9, %edx
jb 0x6b05f
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb %cl, (%rsi,%rax)
incq %rax
cmpl $0x4, %eax
jne 0x6b050
retq
movb 0x2(%rdi), %al
movb %al, (%rsi)
movb 0x1(%rdi), %al
movb %al, 0x1(%rsi)
movb (%rdi), %al
movb %al, 0x2(%rsi)
movb 0x3(%rdi), %al
movb %al, 0x3(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_msgbox
int wm_msgbox(const char *name, const char *fmt, ...)
{
	char *buf = NULL;
	int rv;
	va_list va;

	if (!name) {
		name = apptitle;
	}

	va_start(va,fmt);
	rv = Bvasprintf(&buf,fmt,va);
	va_end(va);

	if (rv < 0) return -1;

	do {
		rv = 0;

#if defined HAVE_GTK
		if (wmgtk_msgbox(name, buf) >= 0) {
			rv = 1;
			break;
		}
#endif
		if (SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, name, buf, sdl_window) >= 0) {
			rv = 1;
			break;
		}

		puts(buf);
	} while(0);

	free(buf);

	return rv;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
leaq 0x30(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x6b9b9
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
testq %rdi, %rdi
leaq 0x38bd1(%rip), %r14     # 0xa45a0
cmovneq %rdi, %r14
leaq 0x10(%rsp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rdx)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rdx)
movq %rax, %rdi
callq 0x21a90
testl %eax, %eax
js 0x6ba4c
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6d9ba
movl $0x1, %ebx
testl %eax, %eax
jns 0x6ba40
movq 0x8(%rsp), %rdx
movq 0x6608ad(%rip), %rcx    # 0x6cc2d0
movl $0x40, %edi
movq %r14, %rsi
callq 0x6ad0
testl %eax, %eax
jns 0x6ba40
movq 0x8(%rsp), %rdi
callq 0x6ab0
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
callq 0x61c0
jmp 0x6ba51
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_ynbox
int wm_ynbox(const char *name, const char *fmt, ...)
{
	char *buf = NULL;
	int rv;
	va_list va;

	if (!name) {
		name = apptitle;
	}

	va_start(va,fmt);
	rv = Bvasprintf(&buf,fmt,va);
	va_end(va);

	if (rv < 0) return -1;

	SDL_MessageBoxButtonData buttons[2] = {
		{ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 1, "Yes" },
		{ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 0, "No" },
	};
	SDL_MessageBoxData msgbox = {
		SDL_MESSAGEBOX_INFORMATION,
		sdl_window,
		name,
		buf,
		SDL_arraysize(buttons),
		buttons,
		NULL
	};

	do {
		rv = 0;

#if defined HAVE_GTK
		if ((rv = wmgtk_ynbox(name, buf)) >= 0) {
			break;
		}
#endif
		if (SDL_ShowMessageBox(&msgbox, &rv) >= 0) {
			rv = (rv == 1);
			break;
		}

		puts(buf);
		puts("   (assuming 'No')");
		rv = 0;
	} while(0);

	free(buf);

	return rv;
}

// Assembly:
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0x90(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x6bac5
movaps %xmm0, 0xc0(%rsp)
movaps %xmm1, 0xd0(%rsp)
movaps %xmm2, 0xe0(%rsp)
movaps %xmm3, 0xf0(%rsp)
movaps %xmm4, 0x100(%rsp)
movaps %xmm5, 0x110(%rsp)
movaps %xmm6, 0x120(%rsp)
movaps %xmm7, 0x130(%rsp)
leaq 0x10(%rsp), %rdi
movq $0x0, (%rdi)
leaq 0x50(%rsp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x150(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x21a90
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0x6bb9d
testq %rbx, %rbx
leaq 0x38a92(%rip), %rdi     # 0xa45a0
cmovneq %rbx, %rdi
movaps 0x26077(%rip), %xmm0    # 0x91b90
leaq 0x70(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps 0x26057(%rip), %xmm0    # 0x91b80
movaps %xmm0, (%rax)
movl $0x40, 0x18(%rsp)
movq 0x660795(%rip), %rcx    # 0x6cc2d0
movq %rcx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movl $0x2, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movl $0x0, 0xc(%rsp)
callq 0x6da3c
movl %eax, 0xc(%rsp)
testl %eax, %eax
jns 0x6bbc2
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x6630
testl %eax, %eax
js 0x6bba4
xorl %eax, %eax
cmpl $0x1, 0xc(%rsp)
sete %al
movl %eax, 0xc(%rsp)
jmp 0x6bbc2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6bbd0
movq 0x10(%rsp), %rdi
callq 0x6ab0
leaq 0x116d2(%rip), %rdi     # 0x7d287
callq 0x6ab0
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x61c0
movl 0xc(%rsp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_filechooser
int wm_filechooser(const char *initialdir, const char *initialfile, const char *type, int foropen, char **choice)
{
#if defined __APPLE__ || defined HAVE_GTK
    int rv;
    if (mouseacquired && moustat) {
        SDL_SetRelativeMouseMode(SDL_FALSE);
    }
#if defined __APPLE__
    rv = wmosx_filechooser(initialdir, initialfile, type, foropen, choice);
#elif defined HAVE_GTK
    rv = wmgtk_filechooser(initialdir, initialfile, type, foropen, choice);
#endif
    SDL_RaiseWindow(sdl_window);
    if (mouseacquired && moustat) {
        SDL_SetRelativeMouseMode(SDL_TRUE);
    }
    return rv;
#else
    (void)initialdir; (void)initialfile; (void)type; (void)foropen; (void)choice;
#endif
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x0, 0x6606e2(%rip)    # 0x6cc2d8
je 0x6bc08
testb $0x1, 0x6606da(%rip)    # 0x6cc2d9
je 0x6bc08
xorl %edi, %edi
callq 0x6540
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x6dabe
movl %eax, %ebx
movq 0x6606ac(%rip), %rdi    # 0x6cc2d0
callq 0x6890
cmpb $0x0, 0x6606a8(%rip)    # 0x6cc2d8
je 0x6bc45
testb $0x1, 0x6606a0(%rip)    # 0x6cc2d9
je 0x6bc45
movl $0x1, %edi
callq 0x6540
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_setapptitle
void wm_setapptitle(const char *name)
{
	if (name) {
		Bstrncpy(apptitle, name, sizeof(apptitle)-1);
		apptitle[ sizeof(apptitle)-1 ] = 0;
	}
#if defined HAVE_GTK
	wmgtk_setapptitle(apptitle);
#endif
}

// Assembly:
testq %rdi, %rdi
je 0x6bc7a
pushq %rax
movq %rdi, %rsi
leaq 0x3893b(%rip), %rdi     # 0xa45a0
movl $0xff, %edx
callq 0x6190
movb $0x0, 0x38a29(%rip)     # 0xa469f
addq $0x8, %rsp
leaq 0x3891f(%rip), %rdi     # 0xa45a0
jmp 0x6d9ac
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: wm_setwindowtitle
void wm_setwindowtitle(const char *name)
{
	if (name) {
		Bstrncpy(wintitle, name, sizeof(wintitle)-1);
		wintitle[ sizeof(wintitle)-1 ] = 0;
	}

	if (sdl_window) {
		SDL_SetWindowTitle(sdl_window, wintitle);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x6bcab
pushq %rax
movq %rdi, %rsi
leaq 0x66064a(%rip), %rdi    # 0x6cc2e0
movl $0xff, %edx
callq 0x6190
movb $0x0, 0x660738(%rip)    # 0x6cc3df
addq $0x8, %rsp
movq 0x66061e(%rip), %rdi    # 0x6cc2d0
testq %rdi, %rdi
je 0x6bcc3
leaq 0x660622(%rip), %rsi    # 0x6cc2e0
jmp 0x61d0
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: initsystem
int initsystem(void)
{
	SDL_version linked;
	SDL_version compiled;

	SDL_GetVersion(&linked);
	SDL_VERSION(&compiled);

	buildprintf("SDL2 system interface "
		  "(compiled with SDL version %d.%d.%d, runtime version %d.%d.%d)\n",
		linked.major, linked.minor, linked.patch,
		compiled.major, compiled.minor, compiled.patch);

	atexit(uninitsystem);

#if USE_OPENGL
	if (getenv("BUILD_NOGL")) {
		buildputs("OpenGL disabled.\n");
		glunavailable = 1;
	} else {
		glunavailable = loadgldriver(getenv("BUILD_GLDRV"));
		if (glunavailable) {
			buildputs("Failed loading OpenGL driver. GL modes will be unavailable.\n");
		}
	}

	OSD_RegisterFunction("glswapinterval", "glswapinterval: frame swap interval for OpenGL modes. 0 = no vsync, -1 = adaptive, max 2", set_glswapinterval);
#endif
	if (getenv("BUILD_USESDLRENDERER")) {
		buildputs("Will use SDL renderer if OpenGL is not available.\n");
		usesdlrenderer = 1;
	}

	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xd(%rsp), %rbx
movq %rbx, %rdi
callq 0x6680
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movzbl 0x2(%rbx), %ecx
movl $0x14, (%rsp)
leaq 0x112cd(%rip), %rdi     # 0x7d2c4
movl $0x2, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x24cb4
leaq 0xcc(%rip), %rdi        # 0x6c0da
callq 0x71090
leaq 0x11300(%rip), %rdi     # 0x7d31a
callq 0x67f0
testq %rax, %rax
je 0x6c03f
leaq 0x112fa(%rip), %rdi     # 0x7d325
callq 0x32200
leaq 0x1110b1(%rip), %rax    # 0x17d0e8
movl $0x1, (%rax)
jmp 0x6c094
leaq 0x112f1(%rip), %rdi     # 0x7d337
callq 0x67f0
movq %rax, %rbx
testq %rax, %rax
leaq 0x11618(%rip), %rsi     # 0x7d670
cmovneq %rax, %rsi
leaq 0x11623(%rip), %rdi     # 0x7d686
xorl %eax, %eax
callq 0x24cb4
movq %rbx, %rdi
callq 0x67b0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
negl %ecx
leaq 0x111066(%rip), %rdx    # 0x17d0e8
movl %ecx, (%rdx)
testl %eax, %eax
je 0x6c094
leaq 0x112b4(%rip), %rdi     # 0x7d343
callq 0x32200
leaq 0x112e5(%rip), %rdi     # 0x7d380
leaq 0x112ed(%rip), %rsi     # 0x7d38f
leaq 0xa3(%rip), %rdx        # 0x6c14c
callq 0x49014
leaq 0x11333(%rip), %rdi     # 0x7d3e8
callq 0x67f0
testq %rax, %rax
je 0x6c0d2
leaq 0x11337(%rip), %rdi     # 0x7d3fd
callq 0x32200
movb $0x1, 0x66030e(%rip)    # 0x6cc3e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/sdlayer2.c
// Function: uninitsystem
void uninitsystem(void)
{
	uninitinput();
	uninitmouse();
	uninittimer();

	shutdownvideo();
#if USE_OPENGL
	glbuild_unloadfunctions();
	unloadgldriver();
#endif
}

// Assembly:
pushq %rax
callq 0x6c1df
xorl %edi, %edi
callq 0x6c577
movb $0x0, 0x6601eb(%rip)    # 0x6cc2d9
cmpq $0x0, 0x661f02(%rip)    # 0x6cdff8
je 0x6c103
movq $0x0, 0x661ef5(%rip) # 0x6cdff8
callq 0x6c233
callq 0x4cbdb
popq %rax
jmp 0x69c0