LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: reportandexit
static void reportandexit(char *errormessage)
{
    int i;
    size_t j;

    j = 0;
    for(i=0;i<cacnum;i++)
    {
        buildprintf("%d- ",i);
        if (cac[i].hand) {
            buildprintf("ptr: 0x%p, ",*cac[i].hand);
        } else {
            buildprintf("ptr: NULL, ");
        }
        buildprintf("leng: %zu, ",cac[i].leng);
        if (cac[i].lock) {
            buildprintf("lock: %d\n",*cac[i].lock);
        } else {
            buildprintf("lock: NULL\n");
        }
        j += cac[i].leng;
    }
	buildprintf("Cachesize = %zu\n",cachesize);
	buildprintf("Cacnum = %d\n",cacnum);
	buildprintf("Cache length sum = %zu\n",j);
	buildprintf("ERROR: %s\n",errormessage);
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x18c2ec(%rip), %eax    # 0x1baf20
jge 0x2ed39
movl -0xc(%rbp), %esi
leaq 0x8341c(%rip), %rdi     # 0xb2060
movb $0x0, %al
callq 0x37c90
movslq -0xc(%rbp), %rcx
leaq 0x18c60a(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x2ec8b
movslq -0xc(%rbp), %rcx
leaq 0x18c5f2(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x833e3(%rip), %rdi     # 0xb2065
movb $0x0, %al
callq 0x37c90
jmp 0x2ec99
leaq 0x833df(%rip), %rdi     # 0xb2071
movb $0x0, %al
callq 0x37c90
movslq -0xc(%rbp), %rcx
leaq 0x18c5bc(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq 0x833c7(%rip), %rdi     # 0xb207d
movb $0x0, %al
callq 0x37c90
movslq -0xc(%rbp), %rcx
leaq 0x18c598(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x2ecff
movslq -0xc(%rbp), %rcx
leaq 0x18c57f(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movzbl (%rax), %esi
leaq 0x8323e(%rip), %rdi     # 0xb1f34
movb $0x0, %al
callq 0x37c90
jmp 0x2ed0d
leaq 0x83383(%rip), %rdi     # 0xb2089
movb $0x0, %al
callq 0x37c90
movslq -0xc(%rbp), %rcx
leaq 0x18c548(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ec2b
movq 0x18c510(%rip), %rsi    # 0x1bb250
leaq 0x8334e(%rip), %rdi     # 0xb2095
movb $0x0, %al
callq 0x37c90
movl 0x18c1cc(%rip), %esi    # 0x1baf20
leaq 0x8334b(%rip), %rdi     # 0xb20a6
movb $0x0, %al
callq 0x37c90
movq -0x18(%rbp), %rsi
leaq 0x83346(%rip), %rdi     # 0xb20b3
movb $0x0, %al
callq 0x37c90
movq -0x8(%rbp), %rsi
leaq 0x8334c(%rip), %rdi     # 0xb20cb
movb $0x0, %al
callq 0x37c90
xorl %edi, %edi
callq 0x6630
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: agecache
void agecache(void)
{
	int cnt;
	unsigned char ch;

	if (agecount >= cacnum) agecount = cacnum-1;
	if (agecount < 0) return;
	for(cnt=(cacnum>>4);cnt>=0;cnt--)
	{
		ch = (*cac[agecount].lock);
		if (((ch-2)&255) < 198)
			(*cac[agecount].lock) = ch-1;

		agecount--; if (agecount < 0) agecount = cacnum-1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18bf4a(%rip), %eax    # 0x1baf24
cmpl 0x18bf40(%rip), %eax    # 0x1baf20
jl 0x2eff1
movl 0x18bf38(%rip), %eax    # 0x1baf20
subl $0x1, %eax
movl %eax, 0x18bf33(%rip)    # 0x1baf24
cmpl $0x0, 0x18bf2c(%rip)    # 0x1baf24
jge 0x2efff
jmp 0x2f0a1
movl 0x18bf1b(%rip), %eax    # 0x1baf20
sarl $0x4, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x2f0a1
movslq 0x18bf08(%rip), %rcx    # 0x1baf24
leaq 0x18c23d(%rip), %rax    # 0x1bb260
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movb (%rax), %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
subl $0x2, %eax
andl $0xff, %eax
cmpl $0xc6, %eax
jge 0x2f06a
movzbl -0x5(%rbp), %eax
subl $0x1, %eax
movb %al, %cl
movslq 0x18bece(%rip), %rdx    # 0x1baf24
leaq 0x18c203(%rip), %rax    # 0x1bb260
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movb %cl, (%rax)
movl 0x18beb4(%rip), %eax    # 0x1baf24
addl $-0x1, %eax
movl %eax, 0x18beab(%rip)    # 0x1baf24
cmpl $0x0, 0x18bea4(%rip)    # 0x1baf24
jge 0x2f091
movl 0x18be98(%rip), %eax    # 0x1baf20
subl $0x1, %eax
movl %eax, 0x18be93(%rip)    # 0x1baf24
jmp 0x2f093
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2f00b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: addsearchpath
int addsearchpath(const char *p)
{
	struct stat st;
	char *s;
	searchpath_t *srch;

	if (Bstat(p, &st) < 0) {
		if (errno == ENOENT) return -2;
		return -1;
	}
	if (!(st.st_mode & BS_IFDIR)) return -1;

	srch = (searchpath_t*)malloc(sizeof(searchpath_t));
	if (!srch) return -1;

	srch->next    = searchpathhead;
	srch->pathlen = strlen(p)+1;
	srch->path    = (char*)malloc(srch->pathlen + 1);
	if (!srch->path) {
		free(srch);
		return -1;
	}
	strcpy(srch->path, p);
	for (s=srch->path; *s; s++) ;
	s--;
	if (s<srch->path || toupperlookup[(int)(unsigned char)*s] != '/') strcat(srch->path, "/");

	searchpathhead = srch;
	if (srch->pathlen > maxsearchpathlen) maxsearchpathlen = srch->pathlen;
	buildprintf("Added %s to search path.\n", srch->path);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6100
cmpl $0x0, %eax
jge 0x2f0f6
callq 0x69c0
cmpl $0x2, (%rax)
jne 0x2f0ea
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2f2a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2a3
movl -0x88(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x2f112
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2a3
movl $0x18, %edi
callq 0x68f0
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x2f139
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2a3
movq 0x1c2128(%rip), %rcx    # 0x1f1268
movq -0xb0(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x63d0
movq %rax, %rcx
addq $0x1, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0xb0(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x1, %rdi
callq 0x68f0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0xb0(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2f1ad
movq -0xb0(%rbp), %rdi
callq 0x61c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2a3
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x63e0
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2f1f5
jmp 0x2f1e1
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x2f1d3
movq -0xa8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq -0xb0(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2f238
movq -0xa8(%rbp), %rax
movzbl (%rax), %eax
movslq %eax, %rcx
leaq 0xb11d1(%rip), %rax     # 0xe0400
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x2f24f
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x82da1(%rip), %rsi     # 0xb1feb
callq 0x6690
movq -0xb0(%rbp), %rax
movq %rax, 0x1c200b(%rip)    # 0x1f1268
movq -0xb0(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x1c2001(%rip), %rax    # 0x1f1270
jbe 0x2f283
movq -0xb0(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x1c1fed(%rip)    # 0x1f1270
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x82d3b(%rip), %rdi     # 0xb1fd0
movb $0x0, %al
callq 0x37c90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: openfrompath
int openfrompath(const char *fn, int flags, int mode)
{
	char *pfn;
	int h;

	if (findfrompath(fn, &pfn) < 0) return -1;
	h = Bopen(pfn, flags, mode);
	free(pfn);

	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2f2b0
cmpl $0x0, %eax
jge 0x2f4cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f4f0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movb $0x0, %al
callq 0x6430
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x61c0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: uninitgroupfile
void uninitgroupfile(void)
{
	int i;

	for(i=numgroupfiles-1;i>=0;i--)
		if (groupfil[i] != -1)
		{
			kfree(gfilelist[i]);
			kfree(gfileoffs[i]);
			Bclose(groupfil[i]);
			groupfil[i] = -1;
		}
	numgroupfiles = 0;

	// JBF 20040111: "close" any files open in groups
	for(i=0;i<MAXOPENFILES;i++) {
		if (filegrp[i] < 254)   // JBF 20040130: not external or ZIPped
			filehan[i] = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x1c146a(%rip), %eax    # 0x1f1278
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x2fe85
movslq -0x4(%rbp), %rcx
leaq 0xb06db(%rip), %rax     # 0xe0500
cmpl $-0x1, (%rax,%rcx,4)
je 0x2fe78
movslq -0x4(%rbp), %rcx
leaq 0x1c146a(%rip), %rax    # 0x1f12a0
movq (%rax,%rcx,8), %rdi
callq 0x35f10
movslq -0x4(%rbp), %rcx
leaq 0x1c1476(%rip), %rax    # 0x1f12c0
movq (%rax,%rcx,8), %rdi
callq 0x35f10
movslq -0x4(%rbp), %rcx
leaq 0xb06a2(%rip), %rax     # 0xe0500
movl (%rax,%rcx,4), %edi
callq 0x6220
movslq -0x4(%rbp), %rcx
leaq 0xb068f(%rip), %rax     # 0xe0500
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x2fe7a
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2fe14
movl $0x0, 0x1c13e9(%rip)    # 0x1f1278
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x2fed1
movslq -0x4(%rbp), %rcx
leaq 0x1c1439(%rip), %rax    # 0x1f12e0
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
jge 0x2fec4
movslq -0x4(%rbp), %rcx
leaq 0xb0653(%rip), %rax     # 0xe0510
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x2fec6
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2fe96
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: kzipopen
static int kzipopen(const char *filnam)
{
	unsigned int i;
	char newst[BMAX_PATH+4];

	newst[0] = '|';
	for(i=0;filnam[i] && (i < sizeof(newst)-2);i++) newst[i+1] = filnam[i];
	newst[i+1] = 0;
	return(kzopen(newst));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movb $0x7c, -0x410(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x411(%rbp)
je 0x30257
movl -0xc(%rbp), %eax
cmpq $0x402, %rax            # imm = 0x402
setb %al
movb %al, -0x411(%rbp)
movb -0x411(%rbp), %al
testb $0x1, %al
jne 0x30263
jmp 0x30287
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movb (%rax,%rcx), %cl
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movb %cl, -0x410(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3022d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movb $0x0, -0x410(%rbp,%rax)
leaq -0x410(%rbp), %rdi
callq 0x68320
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: kfilelength
int kfilelength(int handle)
{
	int i, groupnum;

	groupnum = filegrp[handle];
	if (groupnum == 255) {
		return (int)Bfilelength(filehan[handle]);
	}
#ifdef WITHKPLIB
	else if (groupnum == 254)
	{
		if (kzcurhand != handle)
		{
			if (kztell() >= 0) { filepos[kzcurhand] = kztell(); kzclose(); }
			kzcurhand = handle;
			kzipopen(filenamsav[handle]);
			kzseek(filepos[handle],SEEK_SET);
		}
		return kzfilelength();
	}
#endif
	i = filehan[handle];
	return(gfileoffs[groupnum][i+1]-gfileoffs[groupnum][i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x1c0b7a(%rip), %rax    # 0x1f12e0
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
cmpl $0xff, -0x10(%rbp)
jne 0x30791
movslq -0x8(%rbp), %rcx
leaq 0xafd8f(%rip), %rax     # 0xe0510
movl (%rax,%rcx,4), %edi
callq 0x32ef0
movl %eax, -0x4(%rbp)
jmp 0x30855
cmpl $0xfe, -0x10(%rbp)
jne 0x3080e
movl 0xafe70(%rip), %eax     # 0xe0610
cmpl -0x8(%rbp), %eax
je 0x30804
callq 0x69df0
cmpl $0x0, %eax
jl 0x307cc
callq 0x69df0
movl %eax, %edx
movslq 0xafe53(%rip), %rcx     # 0xe0610
leaq 0x1c0b5c(%rip), %rax    # 0x1f1320
movl %edx, (%rax,%rcx,4)
callq 0x69ea0
movl -0x8(%rbp), %eax
movl %eax, 0xafe3b(%rip)     # 0xe0610
movslq -0x8(%rbp), %rax
leaq 0x1c0c40(%rip), %rdi    # 0x1f1420
imulq $0x104, %rax, %rax      # imm = 0x104
addq %rax, %rdi
callq 0x30210
movslq -0x8(%rbp), %rcx
leaq 0x1c0b26(%rip), %rax    # 0x1f1320
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x69d40
callq 0x69d10
movl %eax, -0x4(%rbp)
jmp 0x30855
jmp 0x30810
movslq -0x8(%rbp), %rcx
leaq 0xafcf5(%rip), %rax     # 0xe0510
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x1c0a94(%rip), %rax    # 0x1f12c0
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movslq -0x10(%rbp), %rdx
leaq 0x1c0a79(%rip), %rcx    # 0x1f12c0
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: ktell
int ktell(int handle)
{
	int groupnum;

	groupnum = filegrp[handle];

	if (groupnum == 255) return((int)lseek(filehan[handle],0,SEEK_CUR));
#ifdef WITHKPLIB
	else if (groupnum == 254)
	{
		if (kzcurhand != handle)
		{
			if (kztell() >= 0) { filepos[kzcurhand] = kztell(); kzclose(); }
			kzcurhand = handle;
			kzipopen(filenamsav[handle]);
			kzseek(filepos[handle],SEEK_SET);
		}
		return kztell();
	}
#endif
	if (groupfil[groupnum] != -1)
		return filepos[handle];
	return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x1c0a6a(%rip), %rax    # 0x1f12e0
movzbl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jne 0x308aa
movslq -0x8(%rbp), %rcx
leaq 0xafc7f(%rip), %rax     # 0xe0510
movl (%rax,%rcx,4), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x62a0
movl %eax, -0x4(%rbp)
jmp 0x30954
cmpl $0xfe, -0xc(%rbp)
jne 0x30927
movl 0xafd57(%rip), %eax     # 0xe0610
cmpl -0x8(%rbp), %eax
je 0x3091d
callq 0x69df0
cmpl $0x0, %eax
jl 0x308e5
callq 0x69df0
movl %eax, %edx
movslq 0xafd3a(%rip), %rcx     # 0xe0610
leaq 0x1c0a43(%rip), %rax    # 0x1f1320
movl %edx, (%rax,%rcx,4)
callq 0x69ea0
movl -0x8(%rbp), %eax
movl %eax, 0xafd22(%rip)     # 0xe0610
movslq -0x8(%rbp), %rax
leaq 0x1c0b27(%rip), %rdi    # 0x1f1420
imulq $0x104, %rax, %rax      # imm = 0x104
addq %rax, %rdi
callq 0x30210
movslq -0x8(%rbp), %rcx
leaq 0x1c0a0d(%rip), %rax    # 0x1f1320
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x69d40
callq 0x69df0
movl %eax, -0x4(%rbp)
jmp 0x30954
jmp 0x30929
movslq -0xc(%rbp), %rcx
leaq 0xafbcc(%rip), %rax     # 0xe0500
cmpl $-0x1, (%rax,%rcx,4)
je 0x3094d
movslq -0x8(%rbp), %rcx
leaq 0x1c09db(%rip), %rax    # 0x1f1320
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x30954
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: kclose
void kclose(int handle)
{
	if (handle < 0) return;
	if (filegrp[handle] == 255) Bclose(filehan[handle]);
#ifdef WITHKPLIB
	else if (filegrp[handle] == 254)
	{
		kzclose();
		kzcurhand = -1;
	}
#endif
	filehan[handle] = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x30973
jmp 0x309d7
movslq -0x4(%rbp), %rcx
leaq 0x1c0962(%rip), %rax    # 0x1f12e0
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x3099e
movslq -0x4(%rbp), %rcx
leaq 0xafb7c(%rip), %rax     # 0xe0510
movl (%rax,%rcx,4), %edi
callq 0x6220
jmp 0x309c5
movslq -0x4(%rbp), %rcx
leaq 0x1c0937(%rip), %rax    # 0x1f12e0
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
jne 0x309c3
callq 0x69ea0
movl $0xffffffff, 0xafc4d(%rip) # imm = 0xFFFFFFFF
jmp 0x309c5
movslq -0x4(%rbp), %rcx
leaq 0xafb40(%rip), %rax     # 0xe0510
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: klistfree
void klistfree(CACHE1D_FIND_REC *rec)
{
	CACHE1D_FIND_REC *n;
	
	while (rec) {
		n = rec->next;
		free(rec);
		rec = n;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x30a12
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x61c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x309ec
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/cache1d.c
// Function: lzwallocate
static void lzwallocate(void)
{
	lzwbuflock[0] = lzwbuflock[1] = lzwbuflock[2] = lzwbuflock[3] = lzwbuflock[4] = 200;
	if (lzwbuf1 == NULL) allocache((void **)&lzwbuf1,LZWSIZE+(LZWSIZE>>4),&lzwbuflock[0]);
	if (lzwbuf2 == NULL) allocache((void **)&lzwbuf2,(LZWSIZE+(LZWSIZE>>4))*2,&lzwbuflock[1]);
	if (lzwbuf3 == NULL) allocache((void **)&lzwbuf3,(LZWSIZE+(LZWSIZE>>4))*2,&lzwbuflock[2]);
	if (lzwbuf4 == NULL) allocache((void **)&lzwbuf4,LZWSIZE,&lzwbuflock[3]);
	if (lzwbuf5 == NULL) allocache((void **)&lzwbuf5,LZWSIZE+(LZWSIZE>>4),&lzwbuflock[4]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $-0x38, 0x1c3da9(%rip)  # 0x1f5534
movb $-0x38, 0x1c3da1(%rip)  # 0x1f5533
movb $-0x38, 0x1c3d99(%rip)  # 0x1f5532
movb $-0x38, 0x1c3d91(%rip)  # 0x1f5531
movb $-0x38, 0x1c3d89(%rip)  # 0x1f5530
cmpq $0x0, 0x1c3d89(%rip)    # 0x1f5538
jne 0x317c9
leaq 0x1c3d80(%rip), %rdi    # 0x1f5538
movl $0x4400, %esi           # imm = 0x4400
leaq 0x1c3d6c(%rip), %rdx    # 0x1f5530
callq 0x2e6f0
cmpq $0x0, 0x1c3d6f(%rip)    # 0x1f5540
jne 0x317ef
leaq 0x1c3d66(%rip), %rdi    # 0x1f5540
movl $0x8800, %esi           # imm = 0x8800
leaq 0x1c3d4a(%rip), %rdx    # 0x1f5530
addq $0x1, %rdx
callq 0x2e6f0
cmpq $0x0, 0x1c3d51(%rip)    # 0x1f5548
jne 0x31815
leaq 0x1c3d48(%rip), %rdi    # 0x1f5548
movl $0x8800, %esi           # imm = 0x8800
leaq 0x1c3d24(%rip), %rdx    # 0x1f5530
addq $0x2, %rdx
callq 0x2e6f0
cmpq $0x0, 0x1c3d0b(%rip)    # 0x1f5528
jne 0x3183b
leaq 0x1c3d02(%rip), %rdi    # 0x1f5528
movl $0x4000, %esi           # imm = 0x4000
leaq 0x1c3cfe(%rip), %rdx    # 0x1f5530
addq $0x3, %rdx
callq 0x2e6f0
cmpq $0x0, 0x1c3cdd(%rip)    # 0x1f5520
jne 0x31861
leaq 0x1c3cd4(%rip), %rdi    # 0x1f5520
movl $0x4400, %esi           # imm = 0x4400
leaq 0x1c3cd8(%rip), %rdx    # 0x1f5530
addq $0x4, %rdx
callq 0x2e6f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: strlwr
char *strlwr(char *s)
{
    char *t = s;
    if (!s) return s;
    while (*t) { *t = tolower(*t); t++; }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32615
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3264a
jmp 0x32617
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x32642
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x6890
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x32617
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: strupr
char *strupr(char *s)
{
    char *t = s;
    if (!s) return s;
    while (*t) { *t = toupper(*t); t++; }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32685
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x326ba
jmp 0x32687
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x326b2
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x61b0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x32687
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bvasprintf
int Bvasprintf(char **ret, const char *format, va_list ap)
{
    int len;
    va_list app;

    va_copy(app, ap);
    len = vsnprintf(NULL, 0, format, app);
    va_end(app);

    if (len < 0) return -1;
    if ((*ret = malloc(len + 1)) == NULL) return -1;

    va_copy(app, ap);
    len = vsnprintf(*ret, len + 1, format, app);
    va_end(app);

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x66b0
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x24(%rbp)
jge 0x32724
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32788
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x68f0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x32748
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32788
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x66b0
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bgetsupportdir
char *Bgetsupportdir(int global)
{
    char *dir = NULL;
    
#ifdef __APPLE__
    dir = osx_getsupportdir(global);

#else
    if (!global) {
        dir = Bgethomedir();
    }
#endif
    
	return dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x328c2
callq 0x327a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bstrtoken
char *Bstrtoken(char *s, char *delim, char **ptrptr, int chop)
{
	char *p, *start;

	if (!ptrptr) return NULL;
	
	if (s) p = s;
	else p = *ptrptr;

	if (!p) return NULL;

	while (*p != 0 && strchr(delim, *p)) p++;
	if (*p == 0) {
		*ptrptr = NULL;
		return NULL;
	}
	start = p;
	while (*p != 0 && !strchr(delim, *p)) p++;
	if (*p == 0) *ptrptr = NULL;
	else {
		if (chop) *(p++) = 0;
		*ptrptr = p;
	}

	return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x32c9b
movq $0x0, -0x8(%rbp)
jmp 0x32dc3
cmpq $0x0, -0x10(%rbp)
je 0x32cac
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x32cb7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x32ccb
movq $0x0, -0x8(%rbp)
jmp 0x32dc3
jmp 0x32ccd
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x32cf8
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
callq 0x64d0
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x32d01
jmp 0x32d0f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x32ccd
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x32d33
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x32dc3
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x32d68
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
callq 0x64d0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x32d71
jmp 0x32d7f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x32d3b
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x32d98
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x32dbb
cmpl $0x0, -0x24(%rbp)
je 0x32db0
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bcanonicalisefilename
int Bcanonicalisefilename(char *filename, int removefn)
{
	char cwd[BMAX_PATH], fn[BMAX_PATH], *p;
	char *fnp = filename;
#ifdef _WIN32
	int drv = 0;
#endif
	
#ifdef _WIN32
	{
		if (filename[0] && filename[1] == ':') {
			// filename is prefixed with a drive
			drv = toupper(filename[0])-'A' + 1;
			fnp += 2;
		}
		if (!_getdcwd(drv, cwd, sizeof(cwd))) return -1;
		for (p=cwd; *p; p++) if (*p == '\\') *p = '/';
	}
#else
	if (!getcwd(cwd,sizeof(cwd))) return -1;
#endif
	p = strrchr(cwd,'/'); if (!p || p[1]) strcat(cwd, "/");
	
	strcpy(fn, fnp);
#ifdef _WIN32
	for (p=fn; *p; p++) if (*p == '\\') *p = '/';
#endif
	
	if (fn[0] != '/') {
		// we are dealing with a path relative to the current directory
		strcpy(filename, cwd);
		strcat(filename, fn);
	} else {
#ifdef _WIN32
		filename[0] = cwd[0];
		filename[1] = ':';
		filename[2] = 0;
#else
		filename[0] = 0;
#endif
		strcat(filename, fn);
	}
	fnp = filename;
#ifdef _WIN32
	fnp += 2;	// skip the drive
#endif
	
	return Bcorrectfilename(fnp,removefn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x830(%rbp)
leaq -0x420(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x6390
cmpq $0x0, %rax
jne 0x32e10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32eca
leaq -0x420(%rbp), %rdi
movl $0x2f, %esi
callq 0x6910
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x828(%rbp)
je 0x32e42
movq -0x828(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x32e55
leaq -0x420(%rbp), %rdi
leaq 0x7f19b(%rip), %rsi     # 0xb1feb
callq 0x6690
leaq -0x820(%rbp), %rdi
movq -0x830(%rbp), %rsi
callq 0x63e0
movsbl -0x820(%rbp), %eax
cmpl $0x2f, %eax
je 0x32e96
movq -0x10(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x63e0
movq -0x10(%rbp), %rdi
leaq -0x820(%rbp), %rsi
callq 0x6690
jmp 0x32ead
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x820(%rbp), %rsi
callq 0x6690
movq -0x10(%rbp), %rax
movq %rax, -0x830(%rbp)
movq -0x830(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x328d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Breaddir
struct Bdirent*	Breaddir(BDIR *dir)
{
	BDIR_real *dirr = (BDIR_real*)dir;

#ifdef _WIN32
	LARGE_INTEGER tmp;

	if (dirr->status > 0) {
		if (FindNextFile(dirr->hfind, &dirr->fid) == 0) {
			dirr->status = -1;
			return NULL;
		}
	}
	dirr->info.namlen = strlen(dirr->fid.cFileName);
	dirr->info.name = (char *)dirr->fid.cFileName;

	dirr->info.mode = 0;
	if (dirr->fid.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) dirr->info.mode |= S_IFDIR;
	else dirr->info.mode |= S_IFREG;
	if (dirr->fid.dwFileAttributes & FILE_ATTRIBUTE_READONLY) dirr->info.mode |= S_IREAD;
	else dirr->info.mode |= S_IREAD|S_IWRITE|S_IEXEC;

	tmp.HighPart = dirr->fid.nFileSizeHigh;
	tmp.LowPart = dirr->fid.nFileSizeLow;
	dirr->info.size = (off_t)tmp.QuadPart;

	tmp.HighPart = dirr->fid.ftLastWriteTime.dwHighDateTime;
	tmp.LowPart = dirr->fid.ftLastWriteTime.dwLowDateTime;
	tmp.QuadPart -= INT64_C(116444736000000000);
	dirr->info.mtime = (time_t)(tmp.QuadPart / 10000000);

	dirr->status++;

#else
	struct dirent *de;
	struct stat st;

	de = readdir(dirr->dir);
	if (de == NULL) {
		dirr->status = -1;
		return NULL;
	} else {
		dirr->status++;
	}

	dirr->info.namlen = strlen(de->d_name);
	dirr->info.name   = de->d_name;
	dirr->info.mode = 0;
	dirr->info.size = 0;
	dirr->info.mtime = 0;

	if (!fstatat(dirfd(dirr->dir), de->d_name, &st, 0)) {
		dirr->info.mode = st.st_mode;
		dirr->info.size = st.st_size;
 		dirr->info.mtime = st.st_mtime;
	}
#endif

	return &dirr->info;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33016
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rbp)
jmp 0x330c8
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
callq 0x63d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
addq $0x13, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x69b0
movl %eax, %edi
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
leaq -0xb0(%rbp), %rdx
xorl %ecx, %ecx
callq 0x63c0
cmpl $0x0, %eax
jne 0x330bc
movl -0x98(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x80(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x58(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bclosedir
int Bclosedir(BDIR *dir)
{
	BDIR_real *dirr = (BDIR_real*)dir;

#ifdef _WIN32
	FindClose(dirr->hfind);
#else
	closedir(dirr->dir);
#endif
	free(dirr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6580
movq -0x10(%rbp), %rdi
callq 0x61c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bwildmatch
int Bwildmatch (const char *i, const char *j)
{
	const char *k;
	char c0, c1;

	if (!*j) return(1);
	do
	{
		if (*j == '*')
		{
			for(k=i,j++;*k;k++) if (Bwildmatch(k,j)) return(1);
			continue;
		}
		if (!*i) return(0);
		if (*j == '?') { i++; j++; continue; }
		c0 = *i; if ((c0 >= 'a') && (c0 <= 'z')) c0 -= 32;
		c1 = *j; if ((c1 >= 'a') && (c1 <= 'z')) c1 -= 32;
#ifdef _WIN32
		if (c0 == '/') c0 = '\\';
		if (c1 == '/') c1 = '\\';
#endif
		if (c0 != c1) return(0);
		i++; j++;
	} while (*j);
	return(!*i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x33145
movl $0x1, -0x4(%rbp)
jmp 0x33276
jmp 0x33147
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x331a3
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3319e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33120
cmpl $0x0, %eax
je 0x3318e
movl $0x1, -0x4(%rbp)
jmp 0x33276
jmp 0x33190
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x33167
jmp 0x33255
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x331b8
movl $0x0, -0x4(%rbp)
jmp 0x33276
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x331de
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x33255
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x61, %eax
jl 0x33203
movsbl -0x21(%rbp), %eax
cmpl $0x7a, %eax
jg 0x33203
movsbl -0x21(%rbp), %eax
subl $0x20, %eax
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x22(%rbp)
movsbl -0x22(%rbp), %eax
cmpl $0x61, %eax
jl 0x33228
movsbl -0x22(%rbp), %eax
cmpl $0x7a, %eax
jg 0x33228
movsbl -0x22(%rbp), %eax
subl $0x20, %eax
movb %al, -0x22(%rbp)
movsbl -0x21(%rbp), %eax
movsbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
je 0x3323d
movl $0x0, -0x4(%rbp)
jmp 0x33276
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x33147
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/compat.c
// Function: Bgetsysmemsize
size_t Bgetsysmemsize(void)
{
#ifdef _WIN32
	size_t siz = 0x7fffffff;
	
        MEMORYSTATUSEX memst;
        memst.dwLength = sizeof(MEMORYSTATUSEX);
        if (GlobalMemoryStatusEx(&memst)) {
            siz = (size_t)min(INT64_C(0x7fffffff), memst.ullTotalPhys);
        }
	
	return siz;
#elif (defined(_SC_PAGE_SIZE) || defined(_SC_PAGESIZE)) && defined(_SC_PHYS_PAGES)
	size_t siz = 0x7fffffff;
	long scpagesiz, scphyspages;

#ifdef _SC_PAGE_SIZE
	scpagesiz = sysconf(_SC_PAGE_SIZE);
#else
	scpagesiz = sysconf(_SC_PAGESIZE);
#endif
	scphyspages = sysconf(_SC_PHYS_PAGES);
	if (scpagesiz >= 0 && scphyspages >= 0)
		siz = (size_t)min(INT64_C(0x7fffffff), (int64_t)scpagesiz * (int64_t)scphyspages);

	//buildprintf("Bgetsysmemsize(): %d pages of %d bytes, %d bytes of system memory\n",
	//		scphyspages, scpagesiz, siz);

	return siz;
#else
	return 0x7fffffff;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
movl $0x1e, %edi
callq 0x6570
movq %rax, -0x10(%rbp)
movl $0x55, %edi
callq 0x6570
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x332ed
cmpq $0x0, -0x18(%rbp)
jl 0x332ed
movq -0x10(%rbp), %rcx
imulq -0x18(%rbp), %rcx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rcx, %rax
jge 0x332d8
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x20(%rbp)
jmp 0x332e5
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/defs.c
// Function: loaddefinitionsfile
int loaddefinitionsfile(const char *fn)
{
	scriptfile *script;

	script = scriptfile_fromfile(fn);
	if (!script) return -1;

	defsparser(script);

	scriptfile_close(script);
	scriptfile_clearsymbols();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6fed0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x33329
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x33347
movq -0x18(%rbp), %rdi
callq 0x33350
movq -0x18(%rbp), %rdi
callq 0x700b0
callq 0x70370
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/defs.c
// Function: getatoken
static int getatoken(scriptfile *sf, tokenlist *tl, int ntokens)
{
	char *tok;
	int i;

	if (!sf) return T_ERROR;
	tok = scriptfile_gettoken(sf);
	if (!tok) return T_EOF;

	for(i=0;i<ntokens;i++) {
		if (!Bstrcasecmp(tok, tl[i].text))
			return tl[i].tokenid;
	}

	return T_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x35e63
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35eda
movq -0x10(%rbp), %rdi
callq 0x6efc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x35e80
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x35eda
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x35ed3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x67c0
cmpl $0x0, %eax
jne 0x35ec6
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x35eda
jmp 0x35ec8
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x35e87
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/engine.c
// Function: animateoffs
int animateoffs(short tilenum, short fakevar)
{
	int i, k, offs;

	(void)fakevar;

	offs = 0;
	i = (totalclocklock>>((picanm[tilenum]>>24)&15));
	if ((picanm[tilenum]&63) > 0)
	{
		switch(picanm[tilenum]&192)
		{
			case 64:
				k = (i%((picanm[tilenum]&63)<<1));
				if (k < (picanm[tilenum]&63))
					offs = k;
				else
					offs = (((picanm[tilenum]&63)<<1)-k);
				break;
			case 128:
				offs = (i%((picanm[tilenum]&63)+1));
					break;
			case 192:
				offs = -(i%((picanm[tilenum]&63)+1));
		}
	}
	return(offs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl 0x2413b9(%rip), %eax    # 0x2775b8
movswq -0x2(%rbp), %rdx
leaq 0x2413b5(%rip), %rcx    # 0x2775c0
movl (%rcx,%rdx,4), %ecx
sarl $0x18, %ecx
andl $0xf, %ecx
sarl %cl, %eax
movl %eax, -0x8(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x24139b(%rip), %rax    # 0x2775c0
movl (%rax,%rcx,4), %eax
andl $0x3f, %eax
cmpl $0x0, %eax
jle 0x3630b
movswq -0x2(%rbp), %rcx
leaq 0x241380(%rip), %rax    # 0x2775c0
movl (%rax,%rcx,4), %eax
andl $0xc0, %eax
movl %eax, -0x14(%rbp)
subl $0x40, %eax
je 0x3626d
jmp 0x36252
movl -0x14(%rbp), %eax
subl $0x80, %eax
je 0x362c7
jmp 0x3625e
movl -0x14(%rbp), %eax
subl $0xc0, %eax
je 0x362e7
jmp 0x36309
movl -0x8(%rbp), %eax
movswq -0x2(%rbp), %rdx
leaq 0x241344(%rip), %rcx    # 0x2775c0
movl (%rcx,%rdx,4), %ecx
andl $0x3f, %ecx
shll %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movswq -0x2(%rbp), %rdx
leaq 0x241327(%rip), %rcx    # 0x2775c0
movl (%rcx,%rdx,4), %ecx
andl $0x3f, %ecx
cmpl %ecx, %eax
jge 0x362ab
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x362c5
movswq -0x2(%rbp), %rcx
leaq 0x241309(%rip), %rax    # 0x2775c0
movl (%rax,%rcx,4), %eax
andl $0x3f, %eax
shll %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x36309
movl -0x8(%rbp), %eax
movswq -0x2(%rbp), %rdx
leaq 0x2412ea(%rip), %rcx    # 0x2775c0
movl (%rcx,%rdx,4), %ecx
andl $0x3f, %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
jmp 0x36309
movl -0x8(%rbp), %eax
movswq -0x2(%rbp), %rdx
leaq 0x2412ca(%rip), %rcx    # 0x2775c0
movl (%rcx,%rdx,4), %ecx
andl $0x3f, %ecx
addl $0x1, %ecx
cltd
idivl %ecx
xorl %eax, %eax
subl %edx, %eax
movl %eax, -0x10(%rbp)
jmp 0x3630b
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/engine.c
// Function: nsqrtasm
static inline unsigned int nsqrtasm(unsigned int a)
{	// JBF 20030901: This was a damn lot simpler to reverse engineer than
	// msqrtasm was. Really, it was just like simplifying an algebra equation.
	unsigned short c;

	if (a & 0xff000000) {			// test eax, 0xff000000  /  jnz short over24
		c = shlookup[(a >> 24) + 4096];	// mov ebx, eax
						// over24: shr ebx, 24
						// mov cx, word ptr shlookup[ebx*2+8192]
	} else {
		c = shlookup[a >> 12];		// mov ebx, eax
						// shr ebx, 12
						// mov cx, word ptr shlookup[ebx*2]
						// jmp short under24
	}
	a >>= c&0xff;				// under24: shr eax, cl
	a = (a&0xffff0000)|(sqrtable[a]);	// mov ax, word ptr sqrtable[eax*2]
	a >>= ((c&0xff00) >> 8);		// mov cl, ch
						// shr eax, cl
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x0, %eax
je 0x375a4
movl -0x4(%rbp), %eax
shrl $0x18, %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, %eax
movl %eax, %ecx
leaq 0x453226(%rip), %rax    # 0x48a7c0
movw (%rax,%rcx,2), %ax
movw %ax, -0x6(%rbp)
jmp 0x375bd
movl -0x4(%rbp), %eax
shrl $0xc, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x45320b(%rip), %rax    # 0x48a7c0
movw (%rax,%rcx,2), %ax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %ecx
andl $0xff, %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff0000, %eax       # imm = 0xFFFF0000
movl -0x4(%rbp), %ecx
movl %ecx, %edx
leaq 0x4553dd(%rip), %rcx    # 0x48c9c0
movzwl (%rcx,%rdx,2), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movzwl -0x6(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/engine.c
// Function: buildprintf
void buildprintf(const char *fmt, ...)
{
	char tmpstr[1024];
	va_list va, vac;

	va_start(va, fmt);

	va_copy(vac, va);
	vfprintf(stdout, fmt, vac);
	va_end(vac);

	if (logfile) {
		va_copy(vac, va);
		vfprintf(logfile, fmt, vac);
		va_end(vac);
	}

	va_copy(vac, va);
	vsnprintf(tmpstr, sizeof(tmpstr), fmt, vac);
	va_end(vac);

	initputs(tmpstr);
	OSD_Puts(tmpstr);

	va_end(va);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x510, %rsp            # imm = 0x510
testb %al, %al
je 0x37cd7
movaps %xmm0, -0x4d0(%rbp)
movaps %xmm1, -0x4c0(%rbp)
movaps %xmm2, -0x4b0(%rbp)
movaps %xmm3, -0x4a0(%rbp)
movaps %xmm4, -0x490(%rbp)
movaps %xmm5, -0x480(%rbp)
movaps %xmm6, -0x470(%rbp)
movaps %xmm7, -0x460(%rbp)
movq %r9, -0x4d8(%rbp)
movq %r8, -0x4e0(%rbp)
movq %rcx, -0x4e8(%rbp)
movq %rdx, -0x4f0(%rbp)
movq %rsi, -0x4f8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x430(%rbp), %rax
leaq -0x500(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x450(%rbp), %rax
leaq -0x430(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x97298(%rip), %rax     # 0xcefe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq 0x6a80
leaq -0x450(%rbp), %rax
cmpq $0x0, 0x3b12ee(%rip)    # 0x3e9058
je 0x37da6
leaq -0x450(%rbp), %rax
leaq -0x430(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x3b12c9(%rip), %rdi    # 0x3e9058
movq -0x8(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq 0x6a80
leaq -0x450(%rbp), %rax
movq -0x420(%rbp), %rax
movq %rax, -0x440(%rbp)
movaps -0x430(%rbp), %xmm0
movaps %xmm0, -0x450(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x410(%rbp), %rdi
movq %rdi, -0x508(%rbp)
movl $0x400, %esi            # imm = 0x400
leaq -0x450(%rbp), %rcx
callq 0x66b0
movq -0x508(%rbp), %rdi
callq 0xa50e0
movq -0x508(%rbp), %rdi
callq 0x6e420
addq $0x510, %rsp            # imm = 0x510
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/engine.c
// Function: loadtables
static int loadtables(void)
{
	int i;

	initksqrt();
    for(i=0;i<2048;i++) {
        sintable[i] = (short)(16384*sin((double)i*3.14159265358979/1024));
        reciptable[i] = divscale30(2048L,i+2048);
    }
    for(i=0;i<640;i++) {
        radarang[i] = (short)(atan(((double)i-639.5)/160)*64*1024/3.14159265358979);
        radarang[1279-i] = -radarang[i];
    }
	calcbritable();

    if (crc32once((unsigned char *)sintable, sizeof(sintable)) != 0xee1e7aba) {
        engineerrstr = "Calculation of sintable yielded unexpected results.";
        return 1;
    }
    if (crc32once((unsigned char *)radarang, sizeof(radarang)/2) != 0xee893d92) {
        engineerrstr = "Calculation of radarang yielded unexpected results.";
        return 1;
    }

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5a920
movl $0x0, -0x8(%rbp)
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jge 0x3812f
cvtsi2sdl -0x8(%rbp), %xmm0
movsd 0x7ac36(%rip), %xmm1    # 0xb2d00
mulsd %xmm1, %xmm0
movsd 0x7ac32(%rip), %xmm1    # 0xb2d08
mulsd %xmm1, %xmm0
callq 0x6360
movsd 0x7ac29(%rip), %xmm1    # 0xb2d10
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, %dx
movslq -0x8(%rbp), %rcx
leaq 0x3d37b3(%rip), %rax    # 0x40b8b0
movw %dx, (%rax,%rcx,2)
movl -0x8(%rbp), %esi
addl $0x800, %esi            # imm = 0x800
movl $0x800, %edi            # imm = 0x800
callq 0x376e0
movl %eax, %edx
movslq -0x8(%rbp), %rcx
leaq 0x449a9f(%rip), %rax    # 0x481bc0
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x380b4
movl $0x0, -0x8(%rbp)
cmpl $0x280, -0x8(%rbp)      # imm = 0x280
jge 0x381d9
cvtsi2sdl -0x8(%rbp), %xmm0
movsd 0x7ab90(%rip), %xmm1    # 0xb2ce0
addsd %xmm1, %xmm0
movsd 0x7ab8c(%rip), %xmm1    # 0xb2ce8
divsd %xmm1, %xmm0
callq 0x6bb0
movsd 0x7ab83(%rip), %xmm1    # 0xb2cf0
mulsd %xmm1, %xmm0
movsd 0x7ab7f(%rip), %xmm1    # 0xb2cf8
mulsd %xmm1, %xmm0
movsd 0x7ab7b(%rip), %xmm1    # 0xb2d00
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, %dx
movslq -0x8(%rbp), %rcx
leaq 0x4331e5(%rip), %rax    # 0x46b380
movw %dx, (%rax,%rcx,2)
movslq -0x8(%rbp), %rcx
leaq 0x4331d6(%rip), %rax    # 0x46b380
movswl (%rax,%rcx,2), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, %dx
movl $0x4ff, %eax            # imm = 0x4FF
subl -0x8(%rbp), %eax
movslq %eax, %rcx
leaq 0x4331b9(%rip), %rax    # 0x46b380
movw %dx, (%rax,%rcx,2)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x38136
callq 0x5aa00
leaq 0x3d36cb(%rip), %rdi    # 0x40b8b0
movl $0x1000, %esi           # imm = 0x1000
callq 0xa8430
cmpl $0xee1e7aba, %eax       # imm = 0xEE1E7ABA
je 0x3820d
leaq 0x7b1c4(%rip), %rax     # 0xb33c1
movq %rax, 0x1bd37c(%rip)    # 0x1f5580
movl $0x1, -0x4(%rbp)
jmp 0x38243
leaq 0x43316c(%rip), %rdi    # 0x46b380
movl $0x500, %esi            # imm = 0x500
callq 0xa8430
cmpl $0xee893d92, %eax       # imm = 0xEE893D92
je 0x3823c
leaq 0x7b1c9(%rip), %rax     # 0xb33f5
movq %rax, 0x1bd34d(%rip)    # 0x1f5580
movl $0x1, -0x4(%rbp)
jmp 0x38243
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)