LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_Dispatch
int OSD_Dispatch(const char *cmd)
{
	char *workbuf, *wp, *wtp, *state;
	char *parms[MAXPARMS];
	int  numparms, restart = 0;
	osdfuncparm_t ofp;
	symbol_t *symb;
	//int i;

	workbuf = state = Bstrdup(cmd);
	if (!workbuf) return -1;

	do {
		numparms = 0;
		Bmemset(parms, 0, sizeof(parms));
		wp = strtoken(state, &wtp, &restart);
		if (!wp) {
			state = wtp;
			continue;
		}

		symb = findexactsymbol(wp);
		if (!symb) {
			OSD_Printf("Error: \"%s\" is not defined\n", wp);
			free(workbuf);
			return -1;
		}

		ofp.name = wp;
		while (wtp && !restart) {
			wp = strtoken(NULL, &wtp, &restart);
			if (wp && numparms < MAXPARMS) parms[numparms++] = wp;
		}
		ofp.numparms = numparms;
		ofp.parms    = (const char **)parms;
		ofp.raw      = cmd;
		switch (symb->func(&ofp)) {
			case OSDCMD_OK: break;
			case OSDCMD_SHOWHELP: OSD_Printf("%s\n", symb->help); break;
		}

		state = wtp;
	} while (wtp && restart);

	free(workbuf);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1048, %rsp           # imm = 0x1048
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
callq 0x6060
testq %rax, %rax
je 0x4a952
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movq %rax, 0x18(%rsp)
movq %rax, %rbp
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
xorl %esi, %esi
callq 0x62f0
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4a98d
testq %rax, %rax
je 0x4a939
movq %rax, %rbp
movq %rax, %rdi
callq 0x4aa78
testq %rax, %rax
je 0x4a959
movq %rax, %rbx
movq %rbp, 0x28(%rsp)
xorl %ebp, %ebp
cmpq $0x0, 0x10(%rsp)
je 0x4a90c
cmpl $0x0, 0xc(%rsp)
jne 0x4a90c
xorl %ebp, %ebp
xorl %edi, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4a98d
testq %rax, %rax
setne %cl
cmpl $0x200, %ebp            # imm = 0x200
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4a8fd
movslq %ebp, %rcx
incl %ebp
movq %rax, 0x40(%rsp,%rcx,8)
cmpq $0x0, 0x10(%rsp)
je 0x4a90c
cmpl $0x0, 0xc(%rsp)
je 0x4a8d0
movl %ebp, 0x20(%rsp)
movq %r15, 0x30(%rsp)
movq %r14, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
callq *0x18(%rbx)
cmpl $0x1, %eax
jne 0x4a939
movq 0x10(%rbx), %rsi
leaq 0x2e4fa(%rip), %rdi     # 0x78e2c
xorl %eax, %eax
callq 0x4a654
movq 0x10(%rsp), %rbp
xorl %ebx, %ebx
testq %rbp, %rbp
je 0x4a96f
cmpl $0x0, 0xc(%rsp)
jne 0x4a87b
jmp 0x4a96f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x4a979
leaq 0x2c0c6(%rip), %rdi     # 0x76a26
movq %rbp, %rsi
xorl %eax, %eax
callq 0x4a654
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rdi
callq 0x61c0
movl %ebx, %eax
addq $0x1048, %rsp           # imm = 0x1048
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/osd.c
// Function: strtoken
static char *strtoken(char *s, char **ptrptr, int *restart)
{
	char *p, *p2, *start;

	*restart = 0;
	if (!ptrptr) return NULL;

	// if s != NULL, we process from the start of s, otherwise
	// we just continue with where ptrptr points to
	if (s) p = s;
	else p = *ptrptr;

	if (!p) return NULL;

	// eat up any leading whitespace
	while (*p != 0 && *p != ';' && *p == ' ') p++;

	// a semicolon is an end of statement delimiter like a \0 is, so we signal
	// the caller to 'restart' for the rest of the string pointed at by *ptrptr
	if (*p == ';') {
		*restart = 1;
		*ptrptr = p+1;
		return NULL;
	}
	// or if we hit the end of the input, signal all done by nulling *ptrptr
	else if (*p == 0) {
		*ptrptr = NULL;
		return NULL;
	}

	if (*p == '\"') {
		// quoted string
		start = ++p;
		p2 = p;
		while (*p != 0) {
			if (*p == '\"') {
				p++;
				break;
			} else if (*p == '\\') {
				switch (*(++p)) {
					case 'n': *p2 = '\n'; break;
					case 'r': *p2 = '\r'; break;
					default: *p2 = *p; break;
				}
			} else {
				*p2 = *p;
			}
			p2++, p++;
		}
		*p2 = 0;
	} else {
		start = p;
		while (*p != 0 && *p != ';' && *p != ' ') p++;
	}

	// if we hit the end of input, signal all done by nulling *ptrptr
	if (*p == 0) {
		*ptrptr = NULL;
	}
	// or if we came upon a semicolon, signal caller to restart with the
	// string at *ptrptr
	else if (*p == ';') {
		*p = 0;
		*ptrptr = p+1;
		*restart = 1;
	}
	// otherwise, clip off the token and carry on
	else {
		*(p++) = 0;
		*ptrptr = p;
	}

	return start;
}

// Assembly:
movl $0x0, (%rdx)
testq %rsi, %rsi
je 0x4a9d8
movq %rdi, %rax
testq %rdi, %rdi
jne 0x4a9a3
movq (%rsi), %rax
testq %rax, %rax
jne 0x4a9ad
jmp 0x4a9d8
incq %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x4a9aa
testl %ecx, %ecx
je 0x4a9d1
cmpl $0x22, %ecx
je 0x4a9db
cmpl $0x3b, %ecx
jne 0x4aa22
movl $0x1, (%rdx)
incq %rax
movq %rax, (%rsi)
jmp 0x4a9d8
movq $0x0, (%rsi)
xorl %eax, %eax
retq
incq %rax
movq %rax, %rcx
movq %rax, %rdi
movzbl (%rcx), %r8d
cmpl $0x5c, %r8d
je 0x4a9fb
testl %r8d, %r8d
je 0x4aa47
cmpl $0x22, %r8d
jne 0x4aa17
jmp 0x4aa44
movzbl 0x1(%rcx), %r8d
incq %rcx
cmpl $0x6e, %r8d
je 0x4aa14
cmpl $0x72, %r8d
jne 0x4aa17
movb $0xd, %r8b
jmp 0x4aa17
movb $0xa, %r8b
movb %r8b, (%rdi)
incq %rdi
incq %rcx
jmp 0x4a9e4
movabsq $0x800000100000001, %rdi # imm = 0x800000100000001
movq %rax, %rcx
movzbl (%rcx), %r8d
cmpq $0x3b, %r8
ja 0x4aa3f
btq %r8, %rdi
jb 0x4aa4a
incq %rcx
jmp 0x4aa2f
incq %rcx
movb $0x0, (%rdi)
movzbl (%rcx), %edi
cmpl $0x3b, %edi
je 0x4aa5e
testl %edi, %edi
jne 0x4aa6e
movq $0x0, (%rsi)
retq
movb $0x0, (%rcx)
incq %rcx
movq %rcx, (%rsi)
movl $0x1, (%rdx)
retq
movb $0x0, (%rcx)
incq %rcx
movq %rcx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: addnewsymbol
static symbol_t *addnewsymbol(const char *name)
{
	symbol_t *newsymb, *s, *t;

	newsymb = (symbol_t *)Bmalloc(sizeof(symbol_t));
	if (!newsymb) { return NULL; }
	Bmemset(newsymb, 0, sizeof(symbol_t));

	// link it to the main chain
	if (!symbols) {
		symbols = newsymb;
	} else {
		if (Bstrcasecmp(name, symbols->name) <= 0) {
			t = symbols;
			symbols = newsymb;
			symbols->next = t;
		} else {
			s = symbols;
			while (s->next) {
				if (Bstrcasecmp(s->next->name, name) > 0) break;
				s=s->next;
			}
			t = s->next;
			s->next = newsymb;
			newsymb->next = t;
		}
	}

	return newsymb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x69a0
testq %rax, %rax
je 0x4ab21
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x5a87e2(%rip), %r15    # 0x5f32c0
testq %r15, %r15
je 0x4ab25
movq (%r15), %rsi
movq %r14, %rdi
callq 0x6880
testl %eax, %eax
jg 0x4aafb
movq %rbx, 0x5a87c7(%rip)    # 0x5f32c0
jmp 0x4ab1b
movq %r15, %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x4ab16
movq (%r15), %rdi
movq %r14, %rsi
callq 0x6880
testl %eax, %eax
jle 0x4aafb
movq %rbx, 0x8(%r12)
movq %r15, 0x8(%rbx)
jmp 0x4ab2c
xorl %ebx, %ebx
jmp 0x4ab2c
movq %rbx, 0x5a8794(%rip)    # 0x5f32c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: findsymbol
static symbol_t *findsymbol(const char *name, symbol_t *startingat)
{
	if (!startingat) startingat = symbols;
	if (!startingat) return NULL;

	for (; startingat; startingat=startingat->next)
		if (!Bstrncasecmp(name, startingat->name, Bstrlen(name))) return startingat;

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4ab4f
movq 0x5a8771(%rip), %rbx    # 0x5f32c0
testq %rbx, %rbx
je 0x4ab81
leaq 0x5ae9c5(%rip), %r14    # 0x5f9520
movq %r14, %rdi
callq 0x6420
movq %rax, %r15
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x6a40
testl %eax, %eax
je 0x4ab83
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x4ab66
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/pragmas.c
// Function: swapbuf4
void swapbuf4(void *a, void *b, int c)
{
	int *p = (int*)a, *q = (int*)b;
	int x, y;
	while ((c--) > 0) {
		x = *q;
		y = *p;
		*(q++) = y;
		*(p++) = x;
	}
}

// Assembly:
testl %edx, %edx
jle 0x4ac18
incl %edx
xorl %eax, %eax
movl (%rsi,%rax), %ecx
movl (%rdi,%rax), %r8d
movl %r8d, (%rsi,%rax)
movl %ecx, (%rdi,%rax)
decl %edx
addq $0x4, %rax
cmpl $0x1, %edx
jg 0x4abff
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/pragmas.c
// Function: clearbufbyte
void clearbufbyte(void *D, int c, int a)
{
	char *p = (char*)D;
	int m[4] = { 0xffl,0xff00l,0xff0000l,0xff000000l };
	int n[4] = { 0,8,16,24 };
	int z=0;
	while ((c--) > 0) {
		*(p++) = (char)((a & m[z])>>n[z]);
		z=(z+1)&3;
	}
}

// Assembly:
testl %esi, %esi
jle 0x4ac51
incl %esi
xorl %eax, %eax
leaq 0x2c0e8(%rip), %r8      # 0x76d10
leaq 0x2c0f1(%rip), %r9      # 0x76d20
movl %eax, %ecx
movl (%r8,%rcx,4), %r10d
andl %edx, %r10d
movb (%r9,%rcx,4), %cl
sarl %cl, %r10d
movb %r10b, (%rdi)
incq %rdi
incl %eax
andl $0x3, %eax
decl %esi
cmpl $0x1, %esi
jg 0x4ac2f
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_gettoken
char *scriptfile_gettoken(scriptfile *sf)
{
	char *start;

	skipoverws(sf);
	if (sf->textptr >= sf->eof) return NULL;

	start = sf->ltextptr = sf->textptr;
	skipovertoken(sf);
	return start;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
jae 0x4ac9d
cmpb $0x0, (%rax)
jne 0x4ac9d
incq %rax
movq %rax, 0x18(%rdi)
movq 0x18(%rdi), %rax
cmpq %rcx, %rax
jae 0x4acbf
movq %rax, 0x10(%rdi)
movq %rax, %rdx
cmpb $0x0, (%rdx)
je 0x4acbe
incq %rdx
movq %rdx, 0x18(%rdi)
cmpq %rcx, %rdx
jne 0x4acad
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getlinum
int scriptfile_getlinum (scriptfile *sf, char *ptr)
{
	int i, stp;
	ptrdiff_t ind;

	//for(i=0;i<sf->linenum;i++) if (sf->lineoffs[i] >= ind) return(i+1); //brute force algo

	ind = ((intptr_t)ptr) - ((intptr_t)sf->textbuf);

	for(stp=1;stp+stp<sf->linenum;stp+=stp); //stp = highest power of 2 less than sf->linenum
	for(i=0;stp;stp>>=1)
		if ((i+stp < sf->linenum) && (sf->lineoffs[i+stp] < ind)) i += stp;
	return(i+1); //i = index to highest lineoffs which is less than ind; convert to 1-based line numbers
}

// Assembly:
movq (%rdi), %rax
movl 0x30(%rdi), %ecx
movl $0x1, %r8d
movl %r8d, %edx
leal (%rdx,%rdx), %r8d
cmpl %ecx, %r8d
jl 0x4ad38
subq %rax, %rsi
xorl %eax, %eax
leal (%rax,%rdx), %r8d
cmpl %ecx, %r8d
jge 0x4ad68
movq 0x38(%rdi), %r9
movslq %r8d, %r10
movslq (%r9,%r10,4), %r9
cmpq %r9, %rsi
jg 0x4ad65
movl %eax, %r8d
movl %r8d, %eax
movl %edx, %r8d
sarl %r8d
cmpl $0x1, %edx
movl %r8d, %edx
ja 0x4ad49
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getnumber_radix
static int scriptfile_getnumber_radix(scriptfile *sf, int *num, int radix)
{
	skipoverws(sf);
	if (sf->textptr >= sf->eof)
	{
		buildprintf("Error on line %s:%d: unexpected eof\n",sf->filename,scriptfile_getlinum(sf,sf->textptr));
		return -1;
	}

	while ((sf->textptr[0] == '0') && (sf->textptr[1] >= '0') && (sf->textptr[1] <= '9'))
		sf->textptr++; //hack to treat octal numbers like decimal
	
	sf->ltextptr = sf->textptr;
	(*num) = (int)strtol((const char *)sf->textptr,&sf->textptr,radix);
	if (!ISWS(*sf->textptr) && *sf->textptr) {
		char *p = sf->textptr;
		skipovertoken(sf);
		buildprintf("Error on line %s:%d: expecting int, got \"%s\"\n",sf->filename,scriptfile_getlinum(sf,sf->ltextptr),p);
		return -2;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
cmpq %rax, %rcx
jae 0x4ada4
cmpb $0x0, (%rcx)
jne 0x4ada4
incq %rcx
movq %rcx, (%r14)
movq (%r14), %rsi
cmpq %rax, %rsi
jae 0x4add6
movq (%r14), %rdi
cmpb $0x30, (%rdi)
jne 0x4adff
incq %rdi
movb (%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x4adfc
movq %rdi, (%r14)
leaq 0x1(%rdi), %rax
cmpb $0x30, (%rdi)
movq %rax, %rdi
je 0x4adb7
decq %rax
movq %rax, %rdi
jmp 0x4adff
movq 0x28(%rbx), %r14
movq %rbx, %rdi
callq 0x4ad2c
leaq 0x2bf67(%rip), %rdi     # 0x76d50
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x24cb4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4ae2e
decq %rdi
movq %rdi, 0x10(%rbx)
movq %r14, %rsi
callq 0x6940
movl %eax, (%r15)
movq 0x18(%rbx), %r15
movzbl (%r15), %ecx
cmpq $0x20, %rcx
ja 0x4ae34
xorl %eax, %eax
movabsq $0x100002601, %rdx      # imm = 0x100002601
btq %rcx, %rdx
jae 0x4ae34
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rax
cmpq %rax, %r15
jae 0x4ae50
movq %r15, %rcx
cmpb $0x0, (%rcx)
je 0x4ae50
incq %rcx
movq %rcx, (%r14)
cmpq %rax, %rcx
jne 0x4ae40
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %r14
movq %rbx, %rdi
callq 0x4ad2c
leaq 0x2bf93(%rip), %rdi     # 0x76dfa
movq %r14, %rsi
movl %eax, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x24cb4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x4ae2e
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getsymbol
int scriptfile_getsymbol(scriptfile *sf, int *num)
{
	char *t, *e;
	int v;

	t = scriptfile_gettoken(sf);
	if (!t) return -1;

	v = (int)strtol(t, &e, 10);
	if (*e) {
		// looks like a string, so find it in the symbol table
		if (scriptfile_getsymbolvalue(t, num)) return 0;
		buildprintf("Error on line %s:%d: expecting symbol, got \"%s\"\n",sf->filename,scriptfile_getlinum(sf,sf->ltextptr),t);
		return -2;   // not found
	}

	*num = v;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x4ac84
testq %rax, %rax
je 0x4b0d8
movq %rax, %rbx
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x6940
movq (%r12), %rcx
cmpb $0x0, (%rcx)
je 0x4b0df
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b0f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x4b0e4
movq 0x10(%r14), %rsi
movq 0x28(%r14), %r15
movq %r14, %rdi
callq 0x4ad2c
leaq 0x2bce3(%rip), %rdi     # 0x76da5
movq %r15, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x24cb4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x4b0e4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4b0e4
movl %eax, (%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getsymbolvalue
int scriptfile_getsymbolvalue(const char *name, int *val)
{
	char *scanner = symbtab;

	if (!symbtab) return 0;
	while (scanner - symbtab < (ptrdiff_t)symbtablength) {
		if (!strcasecmp(name, scanner)) {
			*val = *(int*)(scanner + strlen(scanner) + 1);
			return 1;
		}

		scanner += strlen(scanner) + 1 + sizeof(int);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5ae626(%rip), %r13    # 0x5f9728
xorl %ebx, %ebx
testq %r13, %r13
je 0x4b15c
movq 0x5ae620(%rip), %r14    # 0x5f9730
testq %r14, %r14
jle 0x4b15c
movq %rdi, %r15
movq %rsi, (%rsp)
movq %r13, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x6880
movl %eax, %ebp
movq %r12, %rdi
callq 0x6420
testl %ebp, %ebp
je 0x4b14c
addq %rax, %r12
addq $0x5, %r12
movq %r12, %rax
subq %r13, %rax
cmpq %r14, %rax
jl 0x4b11f
jmp 0x4b15c
movl 0x1(%r12,%rax), %eax
movq (%rsp), %rcx
movl %eax, (%rcx)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getbraces
int scriptfile_getbraces(scriptfile *sf, char **braceend)
{
	int bracecnt;
	char *bracestart;

	skipoverws(sf);
	if (sf->textptr >= sf->eof)
	{
		buildprintf("Error on line %s:%d: unexpected eof\n",sf->filename,scriptfile_getlinum(sf,sf->textptr));
		return -1;
	}

	if (sf->textptr[0] != '{') {
		buildprintf("Error on line %s:%d: expecting '{'\n",sf->filename,scriptfile_getlinum(sf,sf->textptr));
		return -1;
	}
	bracestart = ++sf->textptr; bracecnt = 1;
	while (1)
	{
		if (sf->textptr >= sf->eof) return(0);
		if (sf->textptr[0] == '{') bracecnt++;
		if (sf->textptr[0] == '}') { bracecnt--; if (!bracecnt) break; }
		sf->textptr++;
	}
	(*braceend) = sf->textptr;
	sf->textptr = bracestart;
	return 0;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rdx
cmpq %rdx, %rax
jae 0x4b186
cmpb $0x0, (%rax)
jne 0x4b186
incq %rax
movq %rax, 0x18(%rdi)
pushq %rbx
movq 0x18(%rdi), %rcx
cmpq %rdx, %rcx
jae 0x4b1d9
cmpb $0x7b, (%rcx)
jne 0x4b1ee
incq %rcx
movq %rcx, 0x18(%rdi)
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x4b212
movl $0x1, %r10d
movq %rcx, %r8
movb (%r8), %r11b
xorl %r9d, %r9d
cmpb $0x7b, %r11b
sete %r9b
addl %r10d, %r9d
cmpb $0x7d, %r11b
jne 0x4b1c8
decl %r9d
je 0x4b214
incq %r8
movq %r8, 0x18(%rdi)
movl %r9d, %r10d
cmpq %rdx, %r8
jne 0x4b1ac
jmp 0x4b212
movq 0x28(%rdi), %rbx
movq %rcx, %rsi
callq 0x4ad2c
leaq 0x2bb64(%rip), %rdi     # 0x76d50
jmp 0x4b201
movq 0x28(%rdi), %rbx
movq %rcx, %rsi
callq 0x4ad2c
leaq 0x2bbd5(%rip), %rdi     # 0x76dd6
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x24cb4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
movq %r8, (%rsi)
movq %rcx, 0x18(%rdi)
jmp 0x4b212
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_fromfile
scriptfile *scriptfile_fromfile(const char *fn)
{
	int fp;
	scriptfile *sf;
	char *tx;
	unsigned int flen;

	fp = kopen4load(fn,0);
	if (fp<0) return NULL;

	flen = kfilelength(fp);
	tx = (char *) malloc(flen + 2);
	if (!tx) {
		kclose(fp);
		return NULL;
	}

	sf = (scriptfile*) malloc(sizeof(scriptfile));
	if (!sf) {
		kclose(fp);
		free(tx);
		return NULL;
	}

	kread(fp, tx, flen);
	tx[flen] = tx[flen+1] = 0;

	kclose(fp);

	scriptfile_preparse(sf,tx,flen);
	sf->filename = strdup(fn);

	return sf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x1ff50
testl %eax, %eax
js 0x4b4e7
movl %eax, %ebp
movl %eax, %edi
callq 0x204d2
movl %eax, %r12d
leal 0x2(%r12), %edi
callq 0x69a0
testq %rax, %rax
je 0x4b4cc
movq %rax, %r15
movl $0x40, %edi
callq 0x69a0
testq %rax, %rax
je 0x4b4d5
movq %rax, %r14
movl %ebp, %edi
movq %r15, %rsi
movl %r12d, %edx
callq 0x201c2
leal 0x1(%r12), %eax
xorl %ecx, %ecx
movb %cl, (%r15,%rax)
movl %r12d, %r12d
movb %cl, (%r15,%r12)
movl %ebp, %edi
callq 0x20671
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4b21d
movq %rbx, %rdi
callq 0x6060
movq %rax, 0x28(%r14)
jmp 0x4b4e7
movl %ebp, %edi
callq 0x20671
jmp 0x4b4e4
movl %ebp, %edi
callq 0x20671
movq %r15, %rdi
callq 0x61c0
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_fromstring
scriptfile *scriptfile_fromstring(const char *string)
{
	scriptfile *sf;
	char *tx;
	size_t flen;

	if (!string) return NULL;

	flen = strlen(string);

	tx = (char *) malloc(flen + 2);
	if (!tx) return NULL;

	sf = (scriptfile*) malloc(sizeof(scriptfile));
	if (!sf) {
		free(tx);
		return NULL;
	}

	memcpy(tx, string, flen);
	tx[flen] = tx[flen+1] = 0;

	scriptfile_preparse(sf,tx,flen);
	sf->filename = NULL;

	return sf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4b563
movq %rdi, %r14
callq 0x6420
movq %rax, %r15
leaq 0x2(%rax), %rdi
callq 0x69a0
testq %rax, %rax
je 0x4b563
movq %rax, %r12
movl $0x40, %edi
callq 0x69a0
testq %rax, %rax
je 0x4b55b
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x60c0
movw $0x0, (%r12,%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4b21d
movq $0x0, 0x28(%rbx)
jmp 0x4b565
movq %r12, %rdi
callq 0x61c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_close
void scriptfile_close(scriptfile *sf)
{
	if (!sf) return;
	if (sf->lineoffs) free(sf->lineoffs);
	if (sf->textbuf) free(sf->textbuf);
	if (sf->filename) free(sf->filename);
	sf->textbuf = NULL;
	sf->filename = NULL;
	free(sf);
}

// Assembly:
testq %rdi, %rdi
je 0x4b5b8
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x4b58b
callq 0x61c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4b598
callq 0x61c0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4b5a6
callq 0x61c0
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x61c0
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_addsymbolvalue
int scriptfile_addsymbolvalue(const char *name, int val)
{
	//int x;
	char *sp;
	//if (scriptfile_getsymbolvalue(name, &x)) return -1;   // already exists

	if (symbtab) {
		char *scanner = symbtab;
		while (scanner - symbtab < (ptrdiff_t)symbtablength) {
			if (!strcasecmp(name, scanner)) {
				*(int*)(scanner + strlen(scanner) + 1) = val;
				return 1;
			}

			scanner += strlen(scanner) + 1 + sizeof(int);
		}
	}
	
	sp = getsymbtabspace(strlen(name) + 1 + sizeof(int));
	if (!sp) return 0;
	strcpy(sp, name);
	sp += strlen(name)+1;
	*(int*)sp = val;
	return 1;   // added
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x5ae135(%rip), %r15    # 0x5f9728
testq %r15, %r15
je 0x4b636
movq 0x5ae131(%rip), %r12    # 0x5f9730
testq %r12, %r12
jle 0x4b636
movq %r15, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x6880
movl %eax, %ebp
movq %r13, %rdi
callq 0x6420
testl %ebp, %ebp
je 0x4b6c4
addq %rax, %r13
addq $0x5, %r13
movq %r13, %rax
subq %r15, %rax
cmpq %r12, %rax
jl 0x4b607
movq %r14, %rdi
callq 0x6420
movq 0x5ae0eb(%rip), %r12    # 0x5f9730
leaq (%rax,%r12), %rbp
addq $0x5, %rbp
movq 0x5ae0e4(%rip), %rcx    # 0x5f9738
cmpq %rcx, %rbp
jbe 0x4b692
cmpq $0x101, %rcx            # imm = 0x101
movl $0x100, %eax            # imm = 0x100
cmovaeq %rcx, %rax
movq %rax, %r13
addq %rax, %rax
cmpq %r13, %rbp
ja 0x4b669
movq %r15, %rdi
movq %r13, %rsi
callq 0x6120
testq %rax, %rax
je 0x4b6df
movq %rax, 0x5ae09d(%rip)    # 0x5f9728
movq %r13, 0x5ae0a6(%rip)    # 0x5f9738
addq 0x5ae08f(%rip), %r12    # 0x5f9728
movq %rbp, 0x5ae090(%rip)    # 0x5f9730
testq %r12, %r12
je 0x4b6c0
movq %r12, %rdi
movq %r14, %rsi
callq 0x6430
movq %r14, %rdi
callq 0x6420
movq %rax, %r13
addq %r12, %r13
jmp 0x4b6c7
xorl %eax, %eax
jmp 0x4b6d0
addq %rax, %r13
movl %ebx, 0x1(%r13)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x4b6a0
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_clearsymbols
void scriptfile_clearsymbols(void)
{
	if (symbtab) free(symbtab);
	symbtab = NULL;
	symbtablength = 0;
	symbtaballoclength = 0;
}

// Assembly:
movq 0x5ae03d(%rip), %rdi    # 0x5f9728
testq %rdi, %rdi
je 0x4b6fa
pushq %rax
callq 0x61c0
addq $0x8, %rsp
xorl %eax, %eax
movq %rax, 0x5ae025(%rip)    # 0x5f9728
movq %rax, 0x5ae026(%rip)    # 0x5f9730
movq %rax, 0x5ae027(%rip)    # 0x5f9738
retq
nop
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/glbuild.c
// Function: glbuild_enumerate_exts
static void glbuild_enumerate_exts(void (*callback)(const char *)) {
	char *workstr = NULL, *workptr = NULL, *nextptr = NULL;
	const char *ext = NULL;

#if (USE_OPENGL == USE_GL3)
	GLint extn = 0, numexts = 0;
	if (glinfo.majver >= 3) {
		glfunc.glGetIntegerv(GL_NUM_EXTENSIONS, &numexts);
	} else
#endif
	{
		const char *extstr = (const char *) glfunc.glGetString(GL_EXTENSIONS);
		workstr = workptr = strdup(extstr);
	}

	while (1) {
#if (USE_OPENGL == USE_GL3)
		if (glinfo.majver >= 3) {
			if (extn == numexts) break;
			ext = (const char *) glfunc.glGetStringi(GL_EXTENSIONS, extn);
		} else
#endif
		{
			ext = Bstrtoken(workptr, " ", &nextptr, 1);
			if (!ext) break;
		}

		callback(ext);

#if (USE_OPENGL == USE_GL3)
		if (glinfo.majver >= 3) {
			extn++;
		} else
#endif
		{
			workptr = NULL;
		}
	}

	if (workstr) free(workstr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
movl $0x1f03, %edi           # imm = 0x1F03
callq *0x5ad0c6(%rip)         # 0x5f97a0
movq %rax, %rdi
callq 0x6060
movq %rax, %r14
leaq 0x25f14(%rip), %rsi     # 0x72600
movq %rax, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x21d4f
testq %rax, %rax
je 0x4c727
leaq 0x25ef8(%rip), %r15     # 0x72600
movq %rsp, %r12
movq %rax, %rdi
callq *%rbx
xorl %edi, %edi
movq %r15, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x21d4f
testq %rax, %rax
jne 0x4c70b
testq %r14, %r14
je 0x4c734
movq %r14, %rdi
callq 0x61c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/glbuild.c
// Function: osdcmd_glinfo
static int osdcmd_glinfo(const osdfuncparm_t *parm)
{
	if (parm->numparms == 0) {
		dumpglinfo();
		buildputs("Use \"glinfo exts\" to list extensions.\n");
	} else if (strcmp(parm->parms[0], "exts") == 0) {
		dumpglexts();
	}
	return OSDCMD_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rdi)
je 0x4ca52
movq 0x10(%rdi), %rax
movq (%rax), %rdi
leaq 0x25ad6(%rip), %rsi     # 0x724eb
callq 0x68d0
testl %eax, %eax
jne 0x4cbca
leaq 0x130827(%rip), %rax    # 0x17d250
cmpl $0x0, (%rax)
je 0x4ca9d
leaq 0x2c3fb(%rip), %rdi     # 0x78e30
callq 0x32200
leaq 0xbef(%rip), %rdi       # 0x4d630
callq 0x4c6ba
leaq 0x2963f(%rip), %rdi     # 0x7608c
jmp 0x4cbc5
leaq 0x1307f7(%rip), %r12    # 0x17d250
cmpl $0x0, (%r12)
je 0x4ca7b
movl 0xc(%r12), %eax
cmpl $0x1, %eax
jne 0x4ca8c
cmpl $0x0, 0x10(%r12)
jne 0x4ca8c
leaq 0x2c240(%rip), %rax     # 0x78cb9
jmp 0x4cab0
leaq 0x2c214(%rip), %rdi     # 0x78c96
callq 0x32200
jmp 0x4cbbe
testl %eax, %eax
jle 0x4caa9
movl $0x8b8c, %edi           # imm = 0x8B8C
callq *0x5acd05(%rip)         # 0x5f97a0
jmp 0x4cab0
leaq 0x2c1f2(%rip), %rdi     # 0x78c96
jmp 0x4cbc5
leaq 0x2c1d8(%rip), %rax     # 0x78c88
movq %rax, (%rsp)
movl $0x1f02, %edi           # imm = 0x1F02
callq *0x5acce1(%rip)         # 0x5f97a0
movq %rax, 0x18(%rsp)
movl $0x1f00, %edi           # imm = 0x1F00
callq *0x5accd1(%rip)         # 0x5f97a0
movq %rax, 0x8(%rsp)
movl $0x1f01, %edi           # imm = 0x1F01
callq *0x5accc1(%rip)         # 0x5f97a0
movss 0x14(%r12), %xmm0
ucomiss 0x294a7(%rip), %xmm0    # 0x75f94
leaq 0x2c198(%rip), %rbp     # 0x78c8c
leaq 0x2c18d(%rip), %rcx     # 0x78c88
movq %rcx, %r9
cmovaq %rbp, %r9
cmpb $0x0, 0x18(%r12)
movq %rbp, %rdx
cmoveq %rcx, %rdx
movq %rdx, 0x20(%rsp)
cmpb $0x0, 0x1d(%r12)
movq %rbp, %rdx
cmoveq %rcx, %rdx
movq %rdx, 0x10(%rsp)
cmpb $0x0, 0x1a(%r12)
movq %rbp, %r13
cmoveq %rcx, %r13
cmpb $0x0, 0x1b(%r12)
movq %rbp, %rbx
cmoveq %rcx, %rbx
cmpb $0x0, 0x1c(%r12)
movq %rbp, %r14
cmoveq %rcx, %r14
cmpb $0x0, 0x19(%r12)
movq %rbp, %r15
cmoveq %rcx, %r15
cmpb $0x0, 0x1e(%r12)
movq %rbp, %r10
cmoveq %rcx, %r10
cmpb $0x0, 0x1f(%r12)
cvtss2sd %xmm0, %xmm0
movq %rbp, %r11
cmoveq %rcx, %r11
cmpb $0x0, 0x20(%r12)
cmoveq %rcx, %rbp
subq $0x8, %rsp
leaq 0x2c131(%rip), %rdi     # 0x78cbe
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq 0x8(%rsp), %r8
movb $0x1, %al
pushq %rbp
pushq %r11
pushq %r10
pushq %r15
pushq %r14
pushq %rbx
pushq %r13
pushq 0x50(%rsp)
pushq 0x68(%rsp)
callq 0x24cb4
addq $0x50, %rsp
leaq 0x2c09c(%rip), %rdi     # 0x78c61
callq 0x32200
xorl %eax, %eax
addq $0x28, %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/glbuild.c
// Function: glbuild_check_errors
void glbuild_check_errors(const char *file, int line)
{
	GLenum err;
	const char *str;

	while ((err = glfunc.glGetError()) != GL_NO_ERROR) {
		switch (err) {
			case GL_INVALID_ENUM: str = "GL_INVALID_ENUM"; break;
			case GL_INVALID_VALUE: str = "GL_INVALID_VALUE"; break;
			case GL_INVALID_OPERATION: str = "GL_INVALID_OPERATION"; break;
			case GL_INVALID_FRAMEBUFFER_OPERATION: str = "GL_INVALID_FRAMEBUFFER_OPERATION"; break;
			case GL_OUT_OF_MEMORY: str = "GL_OUT_OF_MEMORY"; break;
#ifdef GL_STACK_UNDERFLOW
			case GL_STACK_UNDERFLOW: str = "GL_STACK_UNDERFLOW"; break;
#endif
#ifdef GL_STACK_OVERFLOW
			case GL_STACK_OVERFLOW: str = "GL_STACK_OVERFLOW"; break;
#endif
			default: str = "(unknown)"; break;
		}
		debugprintf("GL error [%s:%d]: (%d) %s\n", file, line, err, str);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2bd37(%rip), %r12     # 0x7893c
leaq 0x2bdc7(%rip), %r15     # 0x789d3
leaq 0x2b81d(%rip), %rbp     # 0x78430
leaq 0x2bd58(%rip), %r13     # 0x78972
callq *0x5acb88(%rip)         # 0x5f97a8
leal -0x500(%rax), %ecx
cmpl $0x6, %ecx
ja 0x4cc41
movslq (%rbp,%rcx,4), %rcx
addq %rbp, %rcx
movq %r12, %r8
jmpq *%rcx
leaq 0x2bd0d(%rip), %r8      # 0x7894c
jmp 0x4cc75
testl %eax, %eax
je 0x4cc88
leaq 0x2bd7d(%rip), %r8      # 0x789c9
jmp 0x4cc75
leaq 0x2bd4f(%rip), %r8      # 0x789a4
jmp 0x4cc75
leaq 0x2bcff(%rip), %r8      # 0x7895d
jmp 0x4cc75
leaq 0x2bd50(%rip), %r8      # 0x789b7
jmp 0x4cc75
leaq 0x2bd23(%rip), %r8      # 0x78993
jmp 0x4cc75
movq %r13, %r8
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x6c31f
jmp 0x4cc1a
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/glbuild.c
// Function: glbuild_link_program
GLuint glbuild_link_program(int shadercount, GLuint *shaders)
{
	GLuint program;
	GLint status;
	int i;

	program = glfunc.glCreateProgram();
	if (!program) {
		return 0;
	}

	for (i = 0; i < shadercount; i++) {
		glfunc.glAttachShader(program, shaders[i]);
	}

	glfunc.glLinkProgram(program);

	glfunc.glGetProgramiv(program, GL_LINK_STATUS, &status);
	if (status == GL_FALSE) {
		GLint loglen = 0;
		GLchar *logtext = NULL;

		glfunc.glGetProgramiv(program, GL_INFO_LOG_LENGTH, &loglen);

		logtext = (GLchar *)malloc(loglen);
		glfunc.glGetProgramInfoLog(program, loglen, &loglen, logtext);
		buildprintf("glbuild_link_program: link error: %s\n", logtext);
		free(logtext);

		glfunc.glDeleteProgram(program);
		return 0;
	}

	for (i = 0; i < shadercount; i++) {
		glfunc.glDetachShader(program, shaders[i]);
	}

	return program;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq *0x5aca38(%rip)         # 0x5f9898
testl %eax, %eax
je 0x4cf27
movl %eax, %ebx
movl %ebp, %r12d
testl %ebp, %ebp
jle 0x4ce88
xorl %r15d, %r15d
movl (%r14,%r15,4), %esi
movl %ebx, %edi
callq *0x5aca08(%rip)         # 0x5f9888
incq %r15
cmpq %r15, %r12
jne 0x4ce74
movl %ebx, %edi
callq *0x5aca60(%rip)         # 0x5f98f0
leaq 0xc(%rsp), %r15
movl %ebx, %edi
movl $0x8b82, %esi           # imm = 0x8B82
movq %r15, %rdx
callq *0x5aca23(%rip)         # 0x5f98c8
cmpl $0x0, (%r15)
je 0x4cec8
testl %ebp, %ebp
jle 0x4cf29
xorl %r15d, %r15d
movl (%r14,%r15,4), %esi
movl %ebx, %edi
callq *0x5ac9fa(%rip)         # 0x5f98b8
incq %r15
cmpq %r15, %r12
jne 0x4ceb2
jmp 0x4cf29
leaq 0x8(%rsp), %r14
movl $0x0, (%r14)
movl %ebx, %edi
movl $0x8b84, %esi           # imm = 0x8B84
movq %r14, %rdx
callq *0x5ac9e4(%rip)         # 0x5f98c8
movl (%r14), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x69a0
movq %rax, %r12
movl %ebx, %edi
movl %r15d, %esi
movq %r14, %rdx
movq %rax, %rcx
callq *0x5ac9ca(%rip)         # 0x5f98d0
leaq 0x2bafe(%rip), %rdi     # 0x78a0b
movq %r12, %rsi
xorl %eax, %eax
callq 0x24cb4
movq %r12, %rdi
callq 0x61c0
movl %ebx, %edi
callq *0x5ac981(%rip)         # 0x5f98a8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/glbuild.c
// Function: glbuild_update_window_size
void glbuild_update_window_size(glbuild8bit *state, int winx, int winy)
{
	if (winx == state->winx && winy == state->winy) {
		return;
	}

	float winaspect = (float)winx / (float)winy;
	float frameaspect = (float)state->resx / (float)state->resy;
	float aspectx, aspecty;

	state->winx = winx;
	state->winy = winy;

	// Correct for aspect ratio difference between the window size
	// and the logical 8-bit surface by skewing the quad we draw.
	if (fabs(winaspect - frameaspect) < 0.01) {
		aspectx = aspecty = 1.0;
	} else if (winaspect > frameaspect) {
		// Window is wider than the frame.
		aspectx = frameaspect / winaspect;
		aspecty = 1.0;
	} else {
		// Window is narrower than the frame.
		aspectx = 1.0;
		aspecty = winaspect / frameaspect;
	}

	// Texcoord/vertex elements.
	GLfloat elements[4][4] = {
		// tx, ty,  vx, vy
		{ 0.0,        state->ty,  -aspectx, -aspecty },
		{ state->tx,  state->ty,   aspectx, -aspecty },
		{ state->tx,  0.0,         aspectx,  aspecty },
		{ 0.0,        0.0,        -aspectx,  aspecty },
	};

	glfunc.glViewport(0, 0, winx, winy);

	glfunc.glBindBuffer(GL_ARRAY_BUFFER, state->buffer_elements);
	glfunc.glBufferData(GL_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
cmpl %esi, 0x2c(%rdi)
jne 0x4d388
cmpl %ecx, 0x30(%rbx)
je 0x4d493
cvtsi2ss %edx, %xmm2
cvtsi2ss %ecx, %xmm1
cvtsi2ssl 0x24(%rbx), %xmm0
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2ssl 0x28(%rbx), %xmm1
divss %xmm1, %xmm0
movl %edx, 0x2c(%rbx)
movl %ecx, 0x30(%rbx)
movaps %xmm2, %xmm1
subss %xmm0, %xmm1
andps 0x2b0a7(%rip), %xmm1    # 0x78460
cvtss2sd %xmm1, %xmm3
movss 0x28bcf(%rip), %xmm1    # 0x75f94
movsd 0x2b0b3(%rip), %xmm4    # 0x78480
ucomisd %xmm3, %xmm4
jbe 0x4d3d8
movaps %xmm1, %xmm0
jmp 0x4d3ed
ucomiss %xmm0, %xmm2
jbe 0x4d3e3
divss %xmm2, %xmm0
jmp 0x4d3ed
divss %xmm0, %xmm2
movaps %xmm1, %xmm0
movaps %xmm2, %xmm1
xorl %eax, %eax
movq %rsp, %r14
movl %eax, (%r14)
movss 0x38(%rbx), %xmm2
movss %xmm2, 0x4(%r14)
movaps 0x2b069(%rip), %xmm3    # 0x78470
movaps %xmm0, %xmm4
xorps %xmm3, %xmm4
movss %xmm4, 0x8(%r14)
xorps %xmm1, %xmm3
movss %xmm3, 0xc(%r14)
movss 0x34(%rbx), %xmm5
movss %xmm5, 0x10(%r14)
movss %xmm2, 0x14(%r14)
movss %xmm0, 0x18(%r14)
movss %xmm3, 0x1c(%r14)
movss %xmm5, 0x20(%r14)
movl %eax, 0x24(%r14)
movss %xmm0, 0x28(%r14)
movss %xmm1, 0x2c(%r14)
movq $0x0, 0x30(%r14)
movss %xmm4, 0x38(%r14)
movss %xmm1, 0x3c(%r14)
xorl %edi, %edi
xorl %esi, %esi
callq *0x5ac353(%rip)         # 0x5f97c0
movl 0x1c(%rbx), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *0x5ac3bd(%rip)         # 0x5f9838
movl $0x40, %esi
movl $0x8892, %edi           # imm = 0x8892
movq %r14, %rdx
movl $0x88e4, %ecx           # imm = 0x88E4
callq *0x5ac3ad(%rip)         # 0x5f9840
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/glbuild.c
// Function: glbuild_delete_8bit_shader
void glbuild_delete_8bit_shader(glbuild8bit *state)
{
	if (state->program) {
#if (USE_OPENGL != USE_GL3)
		glfunc.glDisableVertexAttribArray(state->attrib_vertex);
		glfunc.glDisableVertexAttribArray(state->attrib_texcoord);
#endif
		glfunc.glUseProgram(0);	// Disable shaders, go back to fixed-function.
		glfunc.glDeleteProgram(state->program);
		state->program = 0;
	}
	if (state->paltex) {
		glfunc.glDeleteTextures(1, &state->paltex);
		state->paltex = 0;
	}
	if (state->frametex) {
		glfunc.glDeleteTextures(1, &state->frametex);
		state->frametex = 0;
	}
#if (USE_OPENGL == USE_GL3)
	if (state->vao) {
		glfunc.glBindVertexArray(0);
		glfunc.glDeleteVertexArrays(1, &state->vao);
		state->vao = 0;
	}
#endif
	if (state->buffer_indexes) {
		glfunc.glDeleteBuffers(1, &state->buffer_indexes);
		state->buffer_indexes = 0;
	}
	if (state->buffer_elements) {
		glfunc.glDeleteBuffers(1, &state->buffer_elements);
		state->buffer_elements = 0;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x4d4cf
movl 0x10(%rbx), %edi
callq *0x5ac3c0(%rip)         # 0x5f9870
movl 0x14(%rbx), %edi
callq *0x5ac3b7(%rip)         # 0x5f9870
xorl %edi, %edi
callq *0x5ac46f(%rip)         # 0x5f9930
movl (%rbx), %edi
callq *0x5ac3df(%rip)         # 0x5f98a8
movl $0x0, (%rbx)
cmpl $0x0, 0x4(%rbx)
je 0x4d4ee
leaq 0x4(%rbx), %r14
movl $0x1, %edi
movq %r14, %rsi
callq *0x5ac319(%rip)         # 0x5f9800
movl $0x0, (%r14)
cmpl $0x0, 0x8(%rbx)
je 0x4d50d
leaq 0x8(%rbx), %r14
movl $0x1, %edi
movq %r14, %rsi
callq *0x5ac2fa(%rip)         # 0x5f9800
movl $0x0, (%r14)
cmpl $0x0, 0x18(%rbx)
je 0x4d52c
leaq 0x18(%rbx), %r14
movl $0x1, %edi
movq %r14, %rsi
callq *0x5ac32b(%rip)         # 0x5f9850
movl $0x0, (%r14)
cmpl $0x0, 0x1c(%rbx)
je 0x4d54a
addq $0x1c, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq *0x5ac30c(%rip)         # 0x5f9850
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_texinvalidate
void polymost_texinvalidate (int dapicnum, int dapalnum, int dameth)
{
	PTIter iter;
	PTHead * pth;

	iter = PTIterNewMatch(
		PTITER_PICNUM | PTITER_PALNUM | PTITER_FLAGS,
		dapicnum, dapalnum, PTH_CLAMPED, (dameth & METH_CLAMPED) ? PTH_CLAMPED : 0
		);
	while ((pth = PTIterNext(iter)) != 0) {
		if (pth->pic[PTHPIC_BASE]) {
			pth->pic[PTHPIC_BASE]->flags |= PTH_DIRTY;
		}
		/*buildprintf("invalidating picnum:%d palnum:%d effects:%d skyface:%d flags:%04X repldef:%p\n",
			   pth->picnum, pth->palnum, pth->effects, pth->skyface,
			   pth->flags, pth->repldef);*/
	}
	//buildprintf("done\n");
	PTIterFree(iter);
}

// Assembly:
pushq %rbx
movl %edx, %r8d
movl %esi, %edx
movl %edi, %esi
shrl $0x2, %r8d
andl $0x1, %r8d
movl $0x7, %edi
movl $0x1, %ecx
callq 0x6580b
movq %rax, %rbx
movq %rax, %rdi
callq 0x65936
testq %rax, %rax
je 0x4d6b8
movq (%rax), %rax
testq %rax, %rax
je 0x4d6b3
orb $-0x80, 0x4(%rax)
movq %rbx, %rdi
jmp 0x4d69d
movq %rbx, %rdi
popq %rbx
jmp 0x6595e
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_texinvalidateall
void polymost_texinvalidateall (void)
{
	PTIter iter;
	PTHead * pth;

	iter = PTIterNew();
	while ((pth = PTIterNext(iter)) != 0) {
		if (pth->pic[PTHPIC_BASE]) {
			pth->pic[PTHPIC_BASE]->flags |= PTH_DIRTY;
		}
	}
	PTIterFree(iter);
	clearskins();
	//buildprintf("gltexinvalidateall()\n");
}

// Assembly:
pushq %rbx
callq 0x65926
movq %rax, %rbx
movq %rax, %rdi
callq 0x65936
testq %rax, %rax
je 0x4d6e8
movq (%rax), %rax
testq %rax, %rax
je 0x4d6e3
orb $-0x80, 0x4(%rax)
movq %rbx, %rdi
jmp 0x4d6cd
movq %rbx, %rdi
callq 0x6595e
popq %rbx
jmp 0x5de60
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_glinit
void polymost_glinit(void)
{
	glfunc.glClearColor(0,0,0,0.5); //Black Background
	glfunc.glDisable(GL_DITHER);

	glfunc.glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

	glfunc.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	if (glmultisample > 0 && glinfo.multisample) {
#if (USE_OPENGL != USE_GLES2)
#ifdef GL_NV_multisample_filter_hint
		if (glinfo.nvmultisamplehint)
			glfunc.glHint(GL_MULTISAMPLE_FILTER_HINT_NV, glnvmultisamplehint ? GL_NICEST:GL_FASTEST);
#endif

		glfunc.glEnable(GL_MULTISAMPLE);

		if (glsampleshading > 0 && glinfo.sampleshading) {
			glfunc.glMinSampleShadingARB(1.f);
			glfunc.glEnable(GL_SAMPLE_SHADING_ARB);
		}
#endif
	}

	polymost_loadshaders();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5abb9d(%rip), %rbx    # 0x5f9740
movss 0x2b6fd(%rip), %xmm3    # 0x792a8
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq *(%rbx)
movl $0xbd0, %edi            # imm = 0xBD0
callq *0x48(%rbx)
movl $0x302, %edi            # imm = 0x302
movl $0x303, %esi            # imm = 0x303
callq *0x18(%rbx)
movl $0xcf5, %edi            # imm = 0xCF5
movl $0x1, %esi
callq *0x78(%rbx)
cmpl $0x0, 0x5abdad(%rip)    # 0x5f998c
jle 0x4dc3b
leaq 0x12f668(%rip), %r14    # 0x17d250
cmpb $0x0, 0x1e(%r14)
je 0x4dc3b
cmpb $0x0, 0x1f(%r14)
je 0x4dc0d
cmpl $0x1, 0x5abd93(%rip)    # 0x5f9990
movl $0x1102, %esi           # imm = 0x1102
sbbl $0x0, %esi
movl $0x8534, %edi           # imm = 0x8534
callq *0x70(%rbx)
movl $0x809d, %edi           # imm = 0x809D
callq *0x40(%rbx)
cmpl $0x0, 0x5abd78(%rip)    # 0x5f9994
jle 0x4dc3b
cmpb $0x0, 0x20(%r14)
je 0x4dc3b
movss 0x28367(%rip), %xmm0    # 0x75f94
callq *0x90(%rbx)
movl $0x8c36, %edi           # imm = 0x8C36
callq *0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4dc44
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: resizeglcheck
void resizeglcheck (void)
{
	if (glredbluemode < lastglredbluemode) {
		glox1 = -1;
		glfunc.glColorMask(1,1,1,1);
	} else if (glredbluemode != lastglredbluemode) {
		redblueclearcnt = 0;
	}
	lastglredbluemode = glredbluemode;

#if (USE_OPENGL != USE_GLES2)
	if (lastglpolygonmode != glpolygonmode)
	{
		lastglpolygonmode = glpolygonmode;
		switch(glpolygonmode)
		{
			default:
			case 0: glfunc.glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); break;
			case 1: glfunc.glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); break;
			case 2: glfunc.glPolygonMode(GL_FRONT_AND_BACK,GL_POINT); break;
		}
	}
#endif

	if ((glox1 != windowx1) || (gloy1 != windowy1) || (glox2 != windowx2) || (gloy2 != windowy2))
	{
		glox1 = windowx1; gloy1 = windowy1;
		glox2 = windowx2; gloy2 = windowy2;

		glfunc.glViewport(windowx1,yres-(windowy2+1),windowx2-windowx1+1,windowy2-windowy1+1);
	}
}

// Assembly:
pushq %rax
movl 0x5ab6c3(%rip), %eax    # 0x5f99d0
cmpl %eax, 0x5ab66d(%rip)    # 0x5f9980
jge 0x4e33f
movl $0xbf800000, 0x5ab6a9(%rip) # imm = 0xBF800000
leaq 0x5ab41a(%rip), %rax    # 0x5f9740
movl $0x1, %edi
movl $0x1, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq *0x10(%rax)
jmp 0x4e34b
je 0x4e34b
movl $0x0, 0x5ab701(%rip)    # 0x5f9a4c
movl 0x5ab62f(%rip), %eax    # 0x5f9980
movl %eax, 0x5ab679(%rip)    # 0x5f99d0
movl 0x5ab643(%rip), %eax    # 0x5f99a0
cmpl %eax, 0x5ab669(%rip)    # 0x5f99cc
je 0x4e393
movl %eax, 0x5ab661(%rip)    # 0x5f99cc
leaq 0x5ab3ce(%rip), %rcx    # 0x5f9740
xorl %edx, %edx
cmpl $0x1, %eax
setne %dl
addl $0x1b01, %edx           # imm = 0x1B01
cmpl $0x2, %eax
movl $0x1b00, %esi           # imm = 0x1B00
cmovnel %edx, %esi
movl $0x408, %edi            # imm = 0x408
callq *0x38(%rcx)
leaq 0x3829d6(%rip), %rax    # 0x3d0d70
movl (%rax), %edi
cvtsi2ss %edi, %xmm0
movss 0x5ab620(%rip), %xmm1   # 0x5f99c8
ucomiss %xmm0, %xmm1
jne 0x4e406
jp 0x4e406
leaq 0x3847ca(%rip), %rax    # 0x3d2b80
xorps %xmm1, %xmm1
cvtsi2ssl (%rax), %xmm1
movss 0x5ab68b(%rip), %xmm2   # 0x5f9a50
ucomiss %xmm1, %xmm2
jne 0x4e406
jp 0x4e406
leaq 0x3b8c0d(%rip), %rax    # 0x406fe0
xorps %xmm1, %xmm1
cvtsi2ssl (%rax), %xmm1
movss 0x5ab672(%rip), %xmm2   # 0x5f9a54
ucomiss %xmm1, %xmm2
jne 0x4e406
jp 0x4e406
leaq 0x3b8bf4(%rip), %rax    # 0x406fe4
xorps %xmm1, %xmm1
cvtsi2ssl (%rax), %xmm1
movss 0x5ab659(%rip), %xmm2   # 0x5f9a58
ucomiss %xmm1, %xmm2
jne 0x4e406
jnp 0x4e481
leaq 0x384773(%rip), %rax    # 0x3d2b80
movl (%rax), %r8d
xorps %xmm1, %xmm1
cvtsi2ss %r8d, %xmm1
leaq 0x3b8bc1(%rip), %rax    # 0x406fe0
movl (%rax), %edx
xorps %xmm2, %xmm2
cvtsi2ss %edx, %xmm2
movss %xmm0, 0x5ab598(%rip)   # 0x5f99c8
movss %xmm1, 0x5ab618(%rip)   # 0x5f9a50
movss %xmm2, 0x5ab614(%rip)   # 0x5f9a54
leaq 0x3b8b9d(%rip), %rax    # 0x406fe4
movl (%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, 0x5ab600(%rip)   # 0x5f9a58
leaq 0x5ab2e1(%rip), %rax    # 0x5f9740
movq 0x80(%rax), %rax
leaq 0x54bc7(%rip), %r9      # 0xa3034
movl %ecx, %esi
notl %esi
addl (%r9), %esi
subl %edi, %edx
incl %edx
subl %r8d, %ecx
incl %ecx
popq %r8
jmpq *%rax
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: polymost_setview
void polymost_setview(void)
{
	memset(gdrawroomsprojmat,0,sizeof(gdrawroomsprojmat));
	gdrawroomsprojmat[0][0] = (float)ydimen; gdrawroomsprojmat[0][2] = 1.0;
	gdrawroomsprojmat[1][1] = (float)xdimen; gdrawroomsprojmat[1][2] = 1.0;
	gdrawroomsprojmat[2][2] = 1.0; gdrawroomsprojmat[2][3] = (float)ydimen;
	gdrawroomsprojmat[3][2] =-1.0;

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

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

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, 0x5ab5a1(%rip)   # 0x5f9a60
movaps %xmm0, 0x5ab5aa(%rip)   # 0x5f9a70
leaq 0x22c5c7(%rip), %rax    # 0x27aa94
cvtsi2ssl (%rax), %xmm1
movaps %xmm0, 0x5ab5a8(%rip)   # 0x5f9a80
movaps %xmm0, 0x5ab5b1(%rip)   # 0x5f9a90
movss %xmm1, 0x5ab579(%rip)   # 0x5f9a60
movl $0x3f800000, %eax       # imm = 0x3F800000
leaq 0x5533d(%rip), %rcx     # 0xa3830
cvtsi2ssl (%rcx), %xmm2
movl %eax, 0x5ab56b(%rip)    # 0x5f9a68
movss %xmm2, 0x5ab56f(%rip)   # 0x5f9a74
movl %eax, 0x5ab56d(%rip)    # 0x5f9a78
movl %eax, 0x5ab577(%rip)    # 0x5f9a88
movss %xmm1, 0x5ab573(%rip)   # 0x5f9a8c
movl $0xbf800000, %ecx       # imm = 0xBF800000
movl %ecx, 0x5ab574(%rip)    # 0x5f9a98
movaps %xmm0, 0x5ab595(%rip)   # 0x5f9ac0
movaps %xmm0, 0x5ab56e(%rip)   # 0x5f9aa0
movaps %xmm0, 0x5ab577(%rip)   # 0x5f9ab0
movaps %xmm0, 0x5ab590(%rip)   # 0x5f9ad0
movl %eax, 0x5ab586(%rip)    # 0x5f9acc
leaq 0x3b8a9f(%rip), %rdx    # 0x406fec
xorps %xmm1, %xmm1
cvtsi2ssl (%rdx), %xmm1
leaq 0x3b8a95(%rip), %rdx    # 0x406ff0
xorps %xmm2, %xmm2
cvtsi2ssl (%rdx), %xmm2
movl %eax, 0x5ab538(%rip)    # 0x5f9aa0
movss 0x2ad3c(%rip), %xmm3    # 0x792ac
divss %xmm1, %xmm3
divss %xmm2, %xmm1
movss %xmm1, 0x5ab534(%rip)   # 0x5f9ab4
movl $0x3f800347, 0x5ab53e(%rip) # imm = 0x3F800347
movl $0xb8d1c000, 0x5ab544(%rip) # imm = 0xB8D1C000
movaps %xmm0, 0x5ab545(%rip)   # 0x5f9ae0
movaps %xmm0, 0x5ab54e(%rip)   # 0x5f9af0
movaps %xmm0, 0x5ab557(%rip)   # 0x5f9b00
movaps %xmm0, 0x5ab560(%rip)   # 0x5f9b10
movss %xmm3, 0x5ab528(%rip)   # 0x5f9ae0
movss 0x2acf0(%rip), %xmm0    # 0x792b0
divss %xmm2, %xmm0
movss %xmm0, 0x5ab528(%rip)   # 0x5f9af4
movl %ecx, 0x5ab536(%rip)    # 0x5f9b08
movl %eax, 0x5ab544(%rip)    # 0x5f9b1c
movabsq $0x3f800000bf800000, %rax # imm = 0x3F800000BF800000
movq %rax, 0x5ab527(%rip)    # 0x5f9b10
retq
// File: /workspace/github_c_makefile_star2_O1/jonof[P]jftekwar/jfbuild/src/polymost.c
// Function: checkindexbuffer
static void checkindexbuffer(unsigned int size)
{
	GLushort *indexes, i;

	if (size <= elementindexbuffersize) return;

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

	elementindexbuffersize = size;
}

// Assembly:
cmpl %edi, 0x5ab19f(%rip)    # 0x5f99d8
jae 0x4e8b4
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %r14d
addq %r14, %r14
movq %r14, %rdi
callq 0x69a0
movq %rax, %r15
xorl %eax, %eax
movzwl %ax, %ecx
movw %cx, (%r15,%rcx,2)
incl %eax
movzwl %ax, %ecx
cmpl %ebx, %ecx
jb 0x4e858
leaq 0x5aaed0(%rip), %r12    # 0x5f9740
movl 0x5ab15e(%rip), %esi    # 0x5f99d4
movl $0x8893, %edi           # imm = 0x8893
callq *0xf8(%r12)
movl $0x8893, %edi           # imm = 0x8893
movq %r14, %rsi
movq %r15, %rdx
movl $0x88e4, %ecx           # imm = 0x88E4
callq *0x100(%r12)
movq %r15, %rdi
callq 0x61c0
movl %ebx, 0x5ab12f(%rip)    # 0x5f99d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq