LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/kplib.c
// Function: filnamcmp
static int filnamcmp (const char *st0, const char *st1)
{
	int i;
	char ch0, ch1;

	for(i=0;st0[i];i++)
	{
		ch0 = st0[i]; if ((ch0 >= 'a') && (ch0 <= 'z')) ch0 -= 32;
		ch1 = st1[i]; if ((ch1 >= 'a') && (ch1 <= 'z')) ch1 -= 32;
		if (ch0 == '/') ch0 = '\\';
		if (ch1 == '/') ch1 = '\\';
		if (ch0 != ch1) return(-1);
	}
	if (!st1[i]) return(0);
	return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x6bed8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x61, %eax
jl 0x6be6f
movsbl -0x1d(%rbp), %eax
cmpl $0x7a, %eax
jg 0x6be6f
movsbl -0x1d(%rbp), %eax
subl $0x20, %eax
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1e(%rbp)
movsbl -0x1e(%rbp), %eax
cmpl $0x61, %eax
jl 0x6be99
movsbl -0x1e(%rbp), %eax
cmpl $0x7a, %eax
jg 0x6be99
movsbl -0x1e(%rbp), %eax
subl $0x20, %eax
movb %al, -0x1e(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x2f, %eax
jne 0x6bea6
movb $0x5c, -0x1d(%rbp)
movsbl -0x1e(%rbp), %eax
cmpl $0x2f, %eax
jne 0x6beb3
movb $0x5c, -0x1e(%rbp)
movsbl -0x1d(%rbp), %eax
movsbl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
je 0x6bec8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6bef6
jmp 0x6beca
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6be33
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x6beef
movl $0x0, -0x4(%rbp)
jmp 0x6bef6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/kplib.c
// Function: getcputype
static int getcputype (void)
{
	int i, cpb[4], cpid[4];
	if (!testflag(0x200000)) return(0);
	cpuid(0,cpid); if (!cpid[0]) return(0);
	cpuid(1,cpb); i = (cpb[3]&~((1<<22)|(1<<30)|(1<<31)));
	cpuid(0x80000000,cpb);
	if (((unsigned int)cpb[0]) > 0x80000000)
	{
		cpuid(0x80000001,cpb);
		i |= (cpb[3]&(1<<31));
		if (!((cpid[1]^0x68747541)|(cpid[3]^0x69746e65)|(cpid[2]^0x444d4163))) //AuthenticAMD
			i |= (cpb[3]&((1<<22)|(1<<30)));
	}
	if (i&(1<<25)) i |= (1<<22); //SSE implies MMX+ support
	return(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x200000, %edi         # imm = 0x200000
callq 0x6bff0
cmpl $0x0, %eax
jne 0x6bf23
movl $0x0, -0x4(%rbp)
jmp 0x6bfdd
leaq -0x30(%rbp), %rsi
xorl %edi, %edi
callq 0x6c000
cmpl $0x0, -0x30(%rbp)
jne 0x6bf40
movl $0x0, -0x4(%rbp)
jmp 0x6bfdd
leaq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x6c000
movl -0x14(%rbp), %eax
andl $0x3fbfffff, %eax       # imm = 0x3FBFFFFF
movl %eax, -0x8(%rbp)
leaq -0x20(%rbp), %rsi
movl $0x80000000, %edi       # imm = 0x80000000
callq 0x6c000
cmpl $0x80000000, -0x20(%rbp) # imm = 0x80000000
jbe 0x6bfbf
leaq -0x20(%rbp), %rsi
movl $0x80000001, %edi       # imm = 0x80000001
callq 0x6c000
movl -0x14(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
xorl $0x68747541, %eax       # imm = 0x68747541
movl -0x24(%rbp), %ecx
xorl $0x69746e65, %ecx       # imm = 0x69746E65
orl %ecx, %eax
movl -0x28(%rbp), %ecx
xorl $0x444d4163, %ecx       # imm = 0x444D4163
orl %ecx, %eax
cmpl $0x0, %eax
jne 0x6bfbd
movl -0x14(%rbp), %eax
andl $0x40400000, %eax       # imm = 0x40400000
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x6bfbf
movl -0x8(%rbp), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0x6bfd7
movl -0x8(%rbp), %eax
orl $0x400000, %eax         # imm = 0x400000
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_Cleanup
void OSD_Cleanup(void)
{
	symbol_t *s;

	for (; symbols; symbols=s) {
		s=symbols->next;
		Bfree(symbols);
	}

	osdinited=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x57b0a0(%rip)    # 0x5e7290
je 0x6c21a
movq 0x57b097(%rip), %rax    # 0x5e7290
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x57b088(%rip), %rdi    # 0x5e7290
callq 0x61c0
movq -0x8(%rbp), %rax
movq %rax, 0x57b078(%rip)    # 0x5e7290
jmp 0x6c1e8
movb $0x0, 0x57b077(%rip)    # 0x5e7298
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_Init
void OSD_Init(void)
{
    if (osdinited) return;
	osdinited=1;

	Bmemset(osdtext, 0, TEXTSIZE);
	osdlines=1;

	atexit(OSD_Cleanup);

	OSD_RegisterFunction("listsymbols","listsymbols: lists all the recognized symbols",osdcmd_listsymbols);
	OSD_RegisterFunction("help","help: displays help on the named symbol",osdcmd_help);
	OSD_RegisterFunction("osdrows","osdrows: sets the number of visible lines of the OSD",osdcmd_osdvars);
	OSD_RegisterFunction("clear","clear: clear the OSD",osdcmd_clear);
	OSD_RegisterFunction("echo","echo: write text to the OSD",osdcmd_echo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x57b05d(%rip)    # 0x5e7298
je 0x6c242
jmp 0x6c2f4
movb $0x1, 0x57b04f(%rip)    # 0x5e7298
leaq 0x57b050(%rip), %rdi    # 0x5e72a0
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x62d0
movl $0x1, 0x7504a(%rip)     # 0xe12b0
leaq -0x8d(%rip), %rdi       # 0x6c1e0
callq 0xaef40
leaq 0x478b3(%rip), %rdi     # 0xb3b2c
leaq 0x478b8(%rip), %rsi     # 0xb3b38
leaq 0x2b9(%rip), %rdx       # 0x6c540
callq 0x6c300
leaq 0x43f48(%rip), %rdi     # 0xb01db
leaq 0x478cc(%rip), %rsi     # 0xb3b66
leaq 0x2ff(%rip), %rdx       # 0x6c5a0
callq 0x6c300
leaq 0x478e1(%rip), %rdi     # 0xb3b8e
leaq 0x478e2(%rip), %rsi     # 0xb3b96
leaq 0x365(%rip), %rdx       # 0x6c620
callq 0x6c300
leaq 0x47904(%rip), %rdi     # 0xb3bcb
leaq 0x47903(%rip), %rsi     # 0xb3bd1
leaq 0x40b(%rip), %rdx       # 0x6c6e0
callq 0x6c300
leaq 0x467f3(%rip), %rdi     # 0xb2ad4
leaq 0x478fe(%rip), %rsi     # 0xb3be6
leaq 0x451(%rip), %rdx       # 0x6c740
callq 0x6c300
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: osdcmd_listsymbols
static int osdcmd_listsymbols(const osdfuncparm_t *parm)
{
	symbol_t *i;

	(void)parm;

	OSD_Printf("Symbol listing:\n");
	for (i=symbols; i!=NULL; i=i->next)
		OSD_Printf("     %s\n", i->name);

	return OSDCMD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x478de(%rip), %rdi     # 0xb3e31
movb $0x0, %al
callq 0x6e340
movq 0x57ad2f(%rip), %rax    # 0x5e7290
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6c58f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x49a55(%rip), %rdi     # 0xb5fcf
movb $0x0, %al
callq 0x6e340
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6c565
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: osdcmd_help
static int osdcmd_help(const osdfuncparm_t *parm)
{
	symbol_t *symb;

	if (parm->numparms != 1) return OSDCMD_SHOWHELP;
	symb = findexactsymbol(parm->parms[0]);
	if (!symb) {
		OSD_Printf("Help Error: \"%s\" is not a defined variable or function\n", parm->parms[0]);
	} else {
		OSD_Printf("%s\n", symb->help);
	}

	return OSDCMD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x6c5be
movl $0x1, -0x4(%rbp)
jmp 0x6c611
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x6ea70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6c5f4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
leaq 0x47857(%rip), %rdi     # 0xb3e42
movb $0x0, %al
callq 0x6e340
jmp 0x6c60a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x499d1(%rip), %rdi     # 0xb5fd4
movb $0x0, %al
callq 0x6e340
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: osdcmd_osdvars
static int osdcmd_osdvars(const osdfuncparm_t *parm)
{
	int showval = (parm->numparms < 1);

	if (!Bstrcasecmp(parm->name, "osdrows")) {
		if (showval) { OSD_Printf("osdrows is %d\n", osdrows); return OSDCMD_OK; }
		else {
			osdrows = atoi(parm->parms[0]);
			if (osdrows < 1) osdrows = 1;
			else if (osdrows > osdmaxrows) osdrows = osdmaxrows;
			return OSDCMD_OK;
		}
	}
	return OSDCMD_SHOWHELP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x47541(%rip), %rsi     # 0xb3b8e
callq 0x67c0
cmpl $0x0, %eax
jne 0x6c6ca
cmpl $0x0, -0x14(%rbp)
je 0x6c67a
movl 0x74cb1(%rip), %esi     # 0xe1314
leaq 0x47810(%rip), %rdi     # 0xb3e7a
movb $0x0, %al
callq 0x6e340
movl $0x0, -0x4(%rbp)
jmp 0x6c6d1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x62e0
movl %eax, 0x74c84(%rip)     # 0xe1314
cmpl $0x1, 0x74c7d(%rip)     # 0xe1314
jge 0x6c6a5
movl $0x1, 0x74c71(%rip)     # 0xe1314
jmp 0x6c6c1
movl 0x74c69(%rip), %eax     # 0xe1314
cmpl 0x74c5f(%rip), %eax     # 0xe1310
jle 0x6c6bf
movl 0x74c57(%rip), %eax     # 0xe1310
movl %eax, 0x74c55(%rip)     # 0xe1314
jmp 0x6c6c1
movl $0x0, -0x4(%rbp)
jmp 0x6c6d1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: osdcmd_clear
static int osdcmd_clear(const osdfuncparm_t *parm)
{
	if (parm->numparms != 0) return OSDCMD_SHOWHELP;
	Bmemset(osdtext, 0, TEXTSIZE);
	osdlines=1;
	osdhead=0;
	osdpos=0;

	return OSDCMD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6c6fe
movl $0x1, -0x4(%rbp)
jmp 0x6c736
leaq 0x57ab9b(%rip), %rdi    # 0x5e72a0
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x62d0
movl $0x1, 0x74b95(%rip)     # 0xe12b0
movl $0x0, 0x57ebaf(%rip)    # 0x5eb2d4
movl $0x0, 0x57eba1(%rip)    # 0x5eb2d0
movl $0x0, -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/osd.c
// Function: osdcmd_echo
static int osdcmd_echo(const osdfuncparm_t *parm)
{
	int i;

	if (parm->numparms == 0) return OSDCMD_SHOWHELP;
	for (i = 0; i < parm->numparms; i++) {
		if (i) OSD_Puts(" ");
		OSD_Puts(parm->parms[i]);
	}
	OSD_Puts("\n");

	return OSDCMD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6c75e
movl $0x1, -0x4(%rbp)
jmp 0x6c7b5
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6c7a2
cmpl $0x0, -0x14(%rbp)
je 0x6c782
leaq 0x42dc3(%rip), %rdi     # 0xaf540
callq 0x6e420
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6e420
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c765
leaq 0x46753(%rip), %rdi     # 0xb2efc
callq 0x6e420
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_SetFunctions
void OSD_SetFunctions(
		void (*drawchar)(int,int,char,int,int),
		void (*drawstr)(int,int,char*,int,int,int),
		void (*drawcursor)(int,int,int,int),
		int (*colwidth)(int),
		int (*rowheight)(int),
		void (*clearbg)(int,int),
		int (*gtime)(void),
		void (*showosd)(int)
	)
{
	drawosdchar = drawchar;
	drawosdstr = drawstr;
	drawosdcursor = drawcursor;
	getcolumnwidth = colwidth;
	getrowheight = rowheight;
	clearbackground = clearbg;
	gettime = gtime;
	onshowosd = showosd;

	if (!drawosdchar) drawosdchar = _internal_drawosdchar;
	if (!drawosdstr) drawosdstr = _internal_drawosdstr;
	if (!drawosdcursor) drawosdcursor = _internal_drawosdcursor;
	if (!getcolumnwidth) getcolumnwidth = _internal_getcolumnwidth;
	if (!getrowheight) getrowheight = _internal_getrowheight;
	if (!clearbackground) clearbackground = _internal_clearbackground;
	if (!gettime) gettime = _internal_gettime;
	if (!onshowosd) onshowosd = _internal_onshowosd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x74ac9(%rip)     # 0xe12b8
movq -0x10(%rbp), %rax
movq %rax, 0x74ac6(%rip)     # 0xe12c0
movq -0x18(%rbp), %rax
movq %rax, 0x74ac3(%rip)     # 0xe12c8
movq -0x20(%rbp), %rax
movq %rax, 0x74ac0(%rip)     # 0xe12d0
movq -0x28(%rbp), %rax
movq %rax, 0x74abd(%rip)     # 0xe12d8
movq -0x30(%rbp), %rax
movq %rax, 0x74aba(%rip)     # 0xe12e0
movq 0x10(%rbp), %rax
movq %rax, 0x74ab7(%rip)     # 0xe12e8
movq 0x18(%rbp), %rax
movq %rax, 0x74ab4(%rip)     # 0xe12f0
cmpq $0x0, 0x74a74(%rip)     # 0xe12b8
jne 0x6c854
leaq 0xb3(%rip), %rax        # 0x6c900
movq %rax, 0x74a64(%rip)     # 0xe12b8
cmpq $0x0, 0x74a64(%rip)     # 0xe12c0
jne 0x6c86c
leaq 0x18b(%rip), %rax       # 0x6c9f0
movq %rax, 0x74a54(%rip)     # 0xe12c0
cmpq $0x0, 0x74a54(%rip)     # 0xe12c8
jne 0x6c884
leaq 0x2a3(%rip), %rax       # 0x6cb20
movq %rax, 0x74a44(%rip)     # 0xe12c8
cmpq $0x0, 0x74a44(%rip)     # 0xe12d0
jne 0x6c89c
leaq 0x33b(%rip), %rax       # 0x6cbd0
movq %rax, 0x74a34(%rip)     # 0xe12d0
cmpq $0x0, 0x74a34(%rip)     # 0xe12d8
jne 0x6c8b4
leaq 0x343(%rip), %rax       # 0x6cbf0
movq %rax, 0x74a24(%rip)     # 0xe12d8
cmpq $0x0, 0x74a24(%rip)     # 0xe12e0
jne 0x6c8cc
leaq 0x34b(%rip), %rax       # 0x6cc10
movq %rax, 0x74a14(%rip)     # 0xe12e0
cmpq $0x0, 0x74a14(%rip)     # 0xe12e8
jne 0x6c8e4
leaq 0x343(%rip), %rax       # 0x6cc20
movq %rax, 0x74a04(%rip)     # 0xe12e8
cmpq $0x0, 0x74a04(%rip)     # 0xe12f0
jne 0x6c8fc
leaq 0x33b(%rip), %rax       # 0x6cc30
movq %rax, 0x749f4(%rip)     # 0xe12f0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: internal_drawosdchar
static void _internal_drawosdchar(int x, int y, char ch, int shade, int pal)
{
	char st[2] = { 0,0 };
	int colour, shadow;

	(void)shade;

	st[0] = ch;

	if (qsetmode == 200) {
		colour = palmap256[pal%4];
		shadow = palmap256[0];
	} else {
		colour = palmap16[pal%4];
		shadow = palmap16[0];
		// printext256 happens to work in 2D mode.
	}
	printext256(4+(x*8)+1,4+(y*14)+1, shadow, -1, st, 2);
	printext256(4+(x*8),4+(y*14), colour, -1, st, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
leaq -0x16(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x62d0
movb -0x9(%rbp), %al
movb %al, -0x16(%rbp)
leaq 0x188c51(%rip), %rax    # 0x1f5588
cmpl $0xc8, (%rax)
jne 0x6c965
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x749cc(%rip), %rax     # 0xe1320
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl 0x749c0(%rip), %eax     # 0xe1320
movl %eax, -0x20(%rbp)
jmp 0x6c989
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x749b6(%rip), %rax     # 0xe1330
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl 0x749aa(%rip), %eax     # 0xe1330
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %edi
shll $0x3, %edi
addl $0x4, %edi
addl $0x1, %edi
imull $0xe, -0x8(%rbp), %esi
addl $0x4, %esi
addl $0x1, %esi
movl -0x20(%rbp), %eax
leaq -0x16(%rbp), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x2, %r9d
movswl %ax, %edx
callq 0x59a30
movl -0x4(%rbp), %edi
shll $0x3, %edi
addl $0x4, %edi
imull $0xe, -0x8(%rbp), %esi
addl $0x4, %esi
movl -0x1c(%rbp), %eax
leaq -0x16(%rbp), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x2, %r9d
movswl %ax, %edx
callq 0x59a30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: internal_drawosdstr
static void _internal_drawosdstr(int x, int y, char *ch, int len, int shade, int pal)
{
	char st[1024];
	int colour, shadow;

	(void)shade;

	if (len>1023) len=1023;
	memcpy(st,ch,len);
	st[len]=0;

	if (qsetmode == 200) {
		colour = palmap256[pal%4];
		shadow = palmap256[0];
	} else {
		colour = palmap16[pal%4];
		shadow = palmap16[0];
		// printext256 happens to work in 2D mode.
	}
	printext256(4+(x*8)+1,4+(y*14)+1, shadow, -1, st, 2);
	printext256(4+(x*8),4+(y*14), colour, -1, st, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
cmpl $0x3ff, -0x14(%rbp)     # imm = 0x3FF
jle 0x6ca20
movl $0x3ff, -0x14(%rbp)     # imm = 0x3FF
leaq -0x420(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x60c0
movslq -0x14(%rbp), %rax
movb $0x0, -0x420(%rbp,%rax)
leaq 0x188b41(%rip), %rax    # 0x1f5588
cmpl $0xc8, (%rax)
jne 0x6ca7b
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x748bc(%rip), %rax     # 0xe1320
movl (%rax,%rcx,4), %eax
movl %eax, -0x424(%rbp)
movl 0x748ad(%rip), %eax     # 0xe1320
movl %eax, -0x428(%rbp)
jmp 0x6caa5
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x748a0(%rip), %rax     # 0xe1330
movl (%rax,%rcx,4), %eax
movl %eax, -0x424(%rbp)
movl 0x74891(%rip), %eax     # 0xe1330
movl %eax, -0x428(%rbp)
movl -0x4(%rbp), %edi
shll $0x3, %edi
addl $0x4, %edi
addl $0x1, %edi
imull $0xe, -0x8(%rbp), %esi
addl $0x4, %esi
addl $0x1, %esi
movl -0x428(%rbp), %eax
leaq -0x420(%rbp), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x2, %r9d
movswl %ax, %edx
callq 0x59a30
movl -0x4(%rbp), %edi
shll $0x3, %edi
addl $0x4, %edi
imull $0xe, -0x8(%rbp), %esi
addl $0x4, %esi
movl -0x424(%rbp), %eax
leaq -0x420(%rbp), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x2, %r9d
movswl %ax, %edx
callq 0x59a30
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: internal_drawosdcursor
static void _internal_drawosdcursor(int x, int y, int type, int lastkeypress)
{
	char st[2] = { '\x16', 0 };  // solid lower third of character cell
	int colour, yoff = 2;

	unsigned blinkcycle = gettime() - (unsigned)lastkeypress;
	if (blinkcycle % 1000 > 500) return;  // blink each half-second.

	if (type) {
		st[0] = '\xdb';  // solid block
		yoff = 0;
	}

	if (qsetmode == 200) {
		colour = palmap256[2];
	} else {
		colour = palmap16[2];
		// printext256 happens to work in 2D mode.
	}
	printext256(4+(x*8),4+(y*14)+yoff, colour, -1, st, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movw 0x4734e(%rip), %ax      # 0xb3e89
movw %ax, -0x12(%rbp)
movl $0x2, -0x1c(%rbp)
callq *0x7479c(%rip)          # 0xe12e8
subl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
cmpl $0x1f4, %edx            # imm = 0x1F4
jbe 0x6cb68
jmp 0x6cbc9
cmpl $0x0, -0xc(%rbp)
je 0x6cb79
movb $-0x25, -0x12(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x188a08(%rip), %rax    # 0x1f5588
cmpl $0xc8, (%rax)
jne 0x6cb93
movl 0x7479a(%rip), %eax     # 0xe1328
movl %eax, -0x18(%rbp)
jmp 0x6cb9c
movl 0x7479f(%rip), %eax     # 0xe1338
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %edi
shll $0x3, %edi
addl $0x4, %edi
imull $0xe, -0x8(%rbp), %esi
addl $0x4, %esi
addl -0x1c(%rbp), %esi
movl -0x18(%rbp), %eax
leaq -0x12(%rbp), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x2, %r9d
movswl %ax, %edx
callq 0x59a30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_SetParameters
void OSD_SetParameters(
		int promptshade, int promptpal,
		int editshade, int editpal,
		int textshade, int textpal
	)
{
	osdpromptshade = promptshade;
	osdpromptpal   = promptpal;
	osdeditshade   = editshade;
	osdeditpal     = editpal;
	osdtextshade   = textshade;
	osdtextpal     = textpal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x57e63f(%rip)    # 0x5eb2a0
movl -0x8(%rbp), %eax
movl %eax, 0x7468e(%rip)     # 0xe12f8
movl -0xc(%rbp), %eax
movl %eax, 0x57e631(%rip)    # 0x5eb2a4
movl -0x10(%rbp), %eax
movl %eax, 0x74680(%rip)     # 0xe12fc
movl -0x14(%rbp), %eax
movl %eax, 0x57e623(%rip)    # 0x5eb2a8
movl -0x18(%rbp), %eax
movl %eax, 0x74672(%rip)     # 0xe1300
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_CaptureKey
int OSD_CaptureKey(int sc)
{
	int prev = osdkey;
	if (sc >= 0) {
		osdkey = sc;
	}
	return prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0x74667(%rip), %eax     # 0xe1304
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x6ccaf
movl -0x4(%rbp), %eax
movl %eax, 0x74655(%rip)     # 0xe1304
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_HandleChar
int OSD_HandleChar(int ch)
{
	if (!osdinited) return ch;
	if (!osdvisible) return ch;

	if (ch < 32 || ch == 127) {
		switch (ch) {
			case 1:		// control a. jump to beginning of line
				OSD_Manipulate(OSDOP_START); break;
			case 2:		// control b, move one character left
				OSD_Manipulate(OSDOP_LEFT); break;
			case 3:		// control c, cancel
				OSD_Manipulate(OSDOP_CANCEL); break;
			case 5:		// control e, jump to end of line
				OSD_Manipulate(OSDOP_END); break;
			case 6:		// control f, move one character right
				OSD_Manipulate(OSDOP_RIGHT); break;
			case 8:
			case 127:	// control h, backspace
				OSD_Manipulate(OSDOP_BACKSPACE); break;
			case 9:		// tab
				OSD_Manipulate(OSDOP_COMPLETE); break;
			case 11:	// control k, delete all to end of line
				OSD_Manipulate(OSDOP_DELETE_END); break;
			case 12:	// control l, clear screen
				break;
			case 13:	// control m, enter
				OSD_Manipulate(OSDOP_SUBMIT); break;
			case 16:	// control p, previous (ie. up arrow)
				OSD_Manipulate(OSDOP_HISTORY_UP); break;
				break;
			case 20:	// control t, swap previous two chars
				break;
			case 21:	// control u, delete all to beginning
				OSD_Manipulate(OSDOP_DELETE_START); break;
			case 23:	// control w, delete one word back
				OSD_Manipulate(OSDOP_DELETE_WORD); break;
		}
	} else {	// text char
		OSD_InsertChar(ch);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpb $0x0, 0x57a5c6(%rip)    # 0x5e7298
jne 0x6ccdf
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6cdce
cmpb $0x0, 0x57e5c6(%rip)    # 0x5eb2ac
jne 0x6ccf3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6cdce
cmpl $0x20, -0x8(%rbp)
jl 0x6cd03
cmpl $0x7f, -0x8(%rbp)
jne 0x6cdbf
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x7e, %eax
ja 0x6cdbd
movq -0x10(%rbp), %rax
leaq 0x46bbe(%rip), %rcx     # 0xb38e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %edi, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0x2, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0xb, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0x1, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0x4, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0x6, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0xc, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0x9, %edi
callq 0x6cde0
jmp 0x6cdbd
jmp 0x6cdbd
movl $0xd, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0xe, %edi
callq 0x6cde0
jmp 0x6cdbd
jmp 0x6cdbd
movl $0x8, %edi
callq 0x6cde0
jmp 0x6cdbd
movl $0xa, %edi
callq 0x6cde0
jmp 0x6cdc7
movl -0x8(%rbp), %edi
callq 0x6da60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_InsertChar
static void OSD_InsertChar(int ch)
{
	if (!osdovertype && osdeditlen == EDITLENGTH)	// buffer full, can't insert another char
		return;

	if (!osdovertype) {
		if (osdeditcursor < osdeditlen)
			Bmemmove(osdeditbuf+osdeditcursor+1, osdeditbuf+osdeditcursor, osdeditlen-osdeditcursor);
		osdeditlen++;
	} else {
		if (osdeditcursor == osdeditlen)
			osdeditlen++;
	}
	osdeditbuf[osdeditcursor] = ch;
	osdeditcursor++;
	if (osdeditcursor>osdeditwinend) {
		osdeditwinstart++;
		osdeditwinend++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x57d856(%rip)    # 0x5eb2c8
jne 0x6da85
cmpl $0x1ff, 0x57d85e(%rip)  # imm = 0x1FF
jne 0x6da85
jmp 0x6db57
cmpl $0x0, 0x57d83c(%rip)    # 0x5eb2c8
jne 0x6dae7
movl 0x57da4c(%rip), %eax    # 0x5eb4e0
cmpl 0x57d842(%rip), %eax    # 0x5eb2dc
jge 0x6dad6
movslq 0x57da3d(%rip), %rax    # 0x5eb4e0
leaq 0x57d836(%rip), %rdi    # 0x5eb2e0
addq %rax, %rdi
addq $0x1, %rdi
movslq 0x57da28(%rip), %rax    # 0x5eb4e0
leaq 0x57d821(%rip), %rsi    # 0x5eb2e0
addq %rax, %rsi
movl 0x57d814(%rip), %eax    # 0x5eb2dc
subl 0x57da12(%rip), %eax    # 0x5eb4e0
movslq %eax, %rdx
callq 0x6190
movl 0x57d800(%rip), %eax    # 0x5eb2dc
addl $0x1, %eax
movl %eax, 0x57d7f7(%rip)    # 0x5eb2dc
jmp 0x6db06
movl 0x57d9f3(%rip), %eax    # 0x5eb4e0
cmpl 0x57d7e9(%rip), %eax    # 0x5eb2dc
jne 0x6db04
movl 0x57d7e1(%rip), %eax    # 0x5eb2dc
addl $0x1, %eax
movl %eax, 0x57d7d8(%rip)    # 0x5eb2dc
jmp 0x6db06
movl -0x4(%rbp), %eax
movb %al, %dl
movslq 0x57d9ce(%rip), %rcx    # 0x5eb4e0
leaq 0x57d7c7(%rip), %rax    # 0x5eb2e0
movb %dl, (%rax,%rcx)
movl 0x57d9be(%rip), %eax    # 0x5eb4e0
addl $0x1, %eax
movl %eax, 0x57d9b5(%rip)    # 0x5eb4e0
movl 0x57d9af(%rip), %eax    # 0x5eb4e0
cmpl 0x737e1(%rip), %eax     # 0xe1318
jle 0x6db57
movl 0x57d799(%rip), %eax    # 0x5eb2d8
addl $0x1, %eax
movl %eax, 0x57d790(%rip)    # 0x5eb2d8
movl 0x737ca(%rip), %eax     # 0xe1318
addl $0x1, %eax
movl %eax, 0x737c1(%rip)     # 0xe1318
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_ShowDisplay
void OSD_ShowDisplay(int onf)
{
	if (onf < 0) {
		onf = !osdvisible;
	}
	osdvisible = (onf != 0);
	osdeditcontrol = 0;
	osdeditshift = 0;

	grabmouse(osdvisible == 0);
	onshowosd(osdvisible);
	releaseallbuttons();
	bflushchars();

	if (osdvisible) {
		findwhite();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6dec5
cmpb $0x0, 0x57d3f4(%rip)    # 0x5eb2ac
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, 0x57d3d5(%rip)     # 0x5eb2ac
movl $0x0, 0x57d3d3(%rip)    # 0x5eb2b4
movl $0x0, 0x57d3c5(%rip)    # 0x5eb2b0
movsbl 0x57d3ba(%rip), %eax    # 0x5eb2ac
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
callq 0xa5460
movq 0x733e7(%rip), %rax     # 0xe12f0
movsbl 0x57d39c(%rip), %edi    # 0x5eb2ac
callq *%rax
callq 0xa55c0
callq 0x2dee0
cmpb $0x0, 0x57d389(%rip)    # 0x5eb2ac
je 0x6df2a
callq 0x6e0d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_ResizeDisplay
void OSD_ResizeDisplay(int w, int h)
{
	int newcols;
	int newmaxlines;
	char newtext[TEXTSIZE];
	int i,j,k;

	newcols = getcolumnwidth(w);
	newmaxlines = TEXTSIZE / newcols;

	j = min(newmaxlines, osdmaxlines);
	k = min(newcols, osdcols);

	memset(newtext, 0, TEXTSIZE);
	for (i=0;i<j;i++) {
		memcpy(newtext+newcols*i, osdtext+osdcols*i, k);
	}

	memcpy(osdtext, newtext, TEXTSIZE);
	osdcols = newcols;
	osdmaxlines = newmaxlines;
	osdmaxrows = getrowheight(h)-2;

	if (osdrows > osdmaxrows) osdrows = osdmaxrows;

	osdpos = 0;
	osdhead = 0;
	osdeditwinstart = 0;
	osdeditwinend = editlinewidth;

	if (osdvisible) {
		findwhite();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4030, %rsp           # imm = 0x4030
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x73388(%rip), %rax     # 0xe12d0
movl -0x4(%rbp), %edi
callq *%rax
movl %eax, -0xc(%rbp)
movl $0x4000, %eax           # imm = 0x4000
cltd
idivl -0xc(%rbp)
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x733a3(%rip), %eax     # 0xe1308
jge 0x6df72
movl -0x10(%rbp), %eax
movl %eax, -0x4020(%rbp)
jmp 0x6df7e
movl 0x73390(%rip), %eax     # 0xe1308
movl %eax, -0x4020(%rbp)
movl -0x4020(%rbp), %eax
movl %eax, -0x4018(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x73379(%rip), %eax     # 0xe130c
jge 0x6dfa0
movl -0xc(%rbp), %eax
movl %eax, -0x4024(%rbp)
jmp 0x6dfac
movl 0x73366(%rip), %eax     # 0xe130c
movl %eax, -0x4024(%rbp)
movl -0x4024(%rbp), %eax
movl %eax, -0x401c(%rbp)
leaq -0x4010(%rbp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x62d0
movl $0x0, -0x4014(%rbp)
movl -0x4014(%rbp), %eax
cmpl -0x4018(%rbp), %eax
jge 0x6e02f
leaq -0x4010(%rbp), %rdi
movl -0xc(%rbp), %eax
imull -0x4014(%rbp), %eax
cltq
addq %rax, %rdi
movl 0x7330d(%rip), %eax     # 0xe130c
imull -0x4014(%rbp), %eax
cltq
leaq 0x579291(%rip), %rsi    # 0x5e72a0
addq %rax, %rsi
movslq -0x401c(%rbp), %rdx
callq 0x60c0
movl -0x4014(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4014(%rbp)
jmp 0x6dfd5
leaq -0x4010(%rbp), %rsi
leaq 0x579263(%rip), %rdi    # 0x5e72a0
movl $0x4000, %edx           # imm = 0x4000
callq 0x60c0
movl -0xc(%rbp), %eax
movl %eax, 0x732bc(%rip)     # 0xe130c
movl -0x10(%rbp), %eax
movl %eax, 0x732af(%rip)     # 0xe1308
movq 0x73278(%rip), %rax     # 0xe12d8
movl -0x8(%rbp), %edi
callq *%rax
subl $0x2, %eax
movl %eax, 0x732a2(%rip)     # 0xe1310
movl 0x732a0(%rip), %eax     # 0xe1314
cmpl 0x73296(%rip), %eax     # 0xe1310
jle 0x6e088
movl 0x7328e(%rip), %eax     # 0xe1310
movl %eax, 0x7328c(%rip)     # 0xe1314
movl $0x0, 0x57d23e(%rip)    # 0x5eb2d0
movl $0x0, 0x57d238(%rip)    # 0x5eb2d4
movl $0x0, 0x57d232(%rip)    # 0x5eb2d8
movl 0x73260(%rip), %eax     # 0xe130c
subl $0x1, %eax
subl $0x3, %eax
movl %eax, 0x73260(%rip)     # 0xe1318
cmpb $0x0, 0x57d1ed(%rip)    # 0x5eb2ac
je 0x6e0c6
callq 0x6e0d0
addq $0x4030, %rsp           # imm = 0x4030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: findwhite
static void findwhite(void)
{
	if (qsetmode == 200) {
		palmap256[0] = getclosestcol(0,0,0);    // black
		palmap256[1] = getclosestcol(63,63,63);	// white
		palmap256[2] = getclosestcol(42,42,42);	// light grey
		palmap256[3] = getclosestcol(21,21,63);	// light blue
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1874ad(%rip), %rax    # 0x1f5588
cmpl $0xc8, (%rax)
jne 0x6e133
xorl %edx, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x37750
movl %eax, 0x7322c(%rip)     # 0xe1320
movl $0x3f, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x37750
movl %eax, 0x7321c(%rip)     # 0xe1324
movl $0x2a, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x37750
movl %eax, 0x7320c(%rip)     # 0xe1328
movl $0x15, %esi
movl $0x3f, %edx
movl %esi, %edi
callq 0x37750
movl %eax, 0x731f9(%rip)     # 0xe132c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_Printf
void OSD_Printf(const char *fmt, ...)
{
	char tmpstr[1024];
	va_list va;

	if (!osdinited) return;

	va_start(va, fmt);
	vsnprintf(tmpstr, sizeof(tmpstr), fmt, va);
	va_end(va);

	OSD_Puts(tmpstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
testb %al, %al
je 0x6e387
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdx, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x578ee3(%rip)    # 0x5e7298
jne 0x6e3b9
jmp 0x6e40f
leaq -0x430(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x430(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x66b0
leaq -0x430(%rbp), %rax
leaq -0x410(%rbp), %rdi
callq 0x6e420
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_Puts
void OSD_Puts(const char *str)
{
    const char *chp;

	if (!osdinited) return;

	for (chp = str; *chp; chp++) {
		if (*chp == '\r') osdpos=0;
		else if (*chp == '\n') {
			osdpos=0;
			linefeed();
		} else {
			osdtext[osdpos++] = *chp;
			if (osdpos == osdcols) {
				osdpos = 0;
				linefeed();
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x578e65(%rip)    # 0x5e7298
jne 0x6e43a
jmp 0x6e4dc
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6e4dc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x6e467
movl $0x0, 0x57ce6b(%rip)    # 0x5eb2d0
jmp 0x6e4c9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x6e484
movl $0x0, 0x57ce53(%rip)    # 0x5eb2d0
callq 0x6e4f0
jmp 0x6e4c7
movq -0x10(%rbp), %rax
movb (%rax), %dl
movl 0x57ce40(%rip), %eax    # 0x5eb2d0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x57ce35(%rip)    # 0x5eb2d0
movslq %eax, %rcx
leaq 0x578dfb(%rip), %rax    # 0x5e72a0
movb %dl, (%rax,%rcx)
movl 0x57ce22(%rip), %eax    # 0x5eb2d0
cmpl 0x72e58(%rip), %eax     # 0xe130c
jne 0x6e4c5
movl $0x0, 0x57ce10(%rip)    # 0x5eb2d0
callq 0x6e4f0
jmp 0x6e4c7
jmp 0x6e4c9
jmp 0x6e4cb
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6e442
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: OSD_DispatchQueued
void OSD_DispatchQueued(void)
{
	int cmd;

	if (!osdexeccount) return;

	cmd=osdexeccount-1;
	osdexeccount=0;

	for (; cmd>=0; cmd--) {
		OSD_Dispatch((const char *)osdhistorybuf[cmd]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x57cf75(%rip)    # 0x5eb4e4
jne 0x6e573
jmp 0x6e5b1
movl 0x57cf6b(%rip), %eax    # 0x5eb4e4
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl $0x0, 0x57cf5b(%rip)    # 0x5eb4e4
cmpl $0x0, -0x4(%rbp)
jl 0x6e5b1
movslq -0x4(%rbp), %rax
leaq 0x57cf56(%rip), %rdi    # 0x5eb4f0
shlq $0x9, %rax
addq %rax, %rdi
callq 0x6e5c0
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e589
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/osd.c
// Function: findexactsymbol
static symbol_t *findexactsymbol(const char *name)
{
	symbol_t *startingat;
	if (!symbols) return NULL;

	startingat = symbols;

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

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x57880c(%rip)    # 0x5e7290
jne 0x6ea90
movq $0x0, -0x8(%rbp)
jmp 0x6ead9
movq 0x5787f9(%rip), %rax    # 0x5e7290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ead1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x67c0
cmpl $0x0, %eax
jne 0x6eac1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6ead9
jmp 0x6eac3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ea9b
movq $0x0, -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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x20, %edi
callq 0x68f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6eb1e
movq $0x0, -0x8(%rbp)
jmp 0x6ebf4
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x62d0
cmpq $0x0, 0x57875a(%rip)    # 0x5e7290
jne 0x6eb48
movq -0x18(%rbp), %rax
movq %rax, 0x57874d(%rip)    # 0x5e7290
jmp 0x6ebec
movq -0x10(%rbp), %rdi
movq 0x57873d(%rip), %rax    # 0x5e7290
movq (%rax), %rsi
callq 0x67c0
cmpl $0x0, %eax
jg 0x6eb87
movq 0x578729(%rip), %rax    # 0x5e7290
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x57871a(%rip)    # 0x5e7290
movq -0x28(%rbp), %rcx
movq 0x57870f(%rip), %rax    # 0x5e7290
movq %rcx, 0x8(%rax)
jmp 0x6ebea
movq 0x578702(%rip), %rax    # 0x5e7290
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6ebc6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x67c0
cmpl $0x0, %eax
jle 0x6ebb8
jmp 0x6ebc6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6eb92
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x6ebec
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ec22
movq 0x578672(%rip), %rax    # 0x5e7290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6ec33
movq $0x0, -0x8(%rbp)
jmp 0x6ec8f
jmp 0x6ec35
cmpq $0x0, -0x18(%rbp)
je 0x6ec87
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63d0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x6970
cmpl $0x0, %eax
jne 0x6ec77
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6ec8f
jmp 0x6ec79
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6ec35
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x6ee5b
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x20(%rbp)
movl %ecx, (%rax)
jmp 0x6ee0f
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x45063(%rip), %rax     # 0xb3ee0
movq %rax, -0x30(%rbp)
movq 0x45060(%rip), %rax     # 0xb3ee8
movq %rax, -0x28(%rbp)
movq 0x4505d(%rip), %rax     # 0xb3ef0
movq %rax, -0x40(%rbp)
movq 0x4505a(%rip), %rax     # 0xb3ef8
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x6eeef
movl -0x10(%rbp), %eax
movslq -0x44(%rbp), %rcx
andl -0x30(%rbp,%rcx,4), %eax
movslq -0x44(%rbp), %rcx
movl -0x40(%rbp,%rcx,4), %ecx
sarl %cl, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
andl $0x3, %eax
movl %eax, -0x44(%rbp)
jmp 0x6eea9
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f020
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x6eff1
movq $0x0, -0x8(%rbp)
jmp 0x6f016
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f060
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_peektoken
char *scriptfile_peektoken(scriptfile *sf)
{
	scriptfile dupe;

	memcpy(&dupe, sf, sizeof(scriptfile));

	skipoverws(&dupe);
	if (dupe.textptr >= dupe.eof) return NULL;
	return dupe.textptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x40, %edx
callq 0x60c0
leaq -0x50(%rbp), %rdi
callq 0x6f020
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x6f0eb
movq $0x0, -0x8(%rbp)
jmp 0x6f0f3
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getstring
int scriptfile_getstring(scriptfile *sf, char **retst)
{
	(*retst) = scriptfile_gettoken(sf);
	if (*retst == NULL)
	{
		buildprintf("Error on line %s:%d: unexpected eof\n",sf->filename,scriptfile_getlinum(sf,sf->textptr));
		return(-2);
	}
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6efc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6f167
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x6f180
movq -0x20(%rbp), %rsi
movl %eax, %edx
leaq 0x44db9(%rip), %rdi     # 0xb3f10
movb $0x0, %al
callq 0x37c90
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x6f16e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x6f1c1
jmp 0x6f1b6
movl -0x18(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x6f1a5
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x6f20d
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x6f201
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
cmpq -0x20(%rbp), %rax
jge 0x6f201
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x6f203
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x18(%rbp)
jmp 0x6f1c8
movl -0x14(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/jfbuild/src/scriptfile.c
// Function: scriptfile_getdouble
int scriptfile_getdouble(scriptfile *sf, double *num)
{
	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;
	}
	
	sf->ltextptr = sf->textptr;

	// On Linux, locale settings interfere with interpreting x.y format numbers
	//(*num) = strtod((const char *)sf->textptr,&sf->textptr);
	(*num) = parsedouble(sf->textptr, &sf->textptr);
	
	if (!ISWS(*sf->textptr) && *sf->textptr) {
		char *p = sf->textptr;
		skipovertoken(sf);
		buildprintf("Error on line %s:%d: expecting float, got \"%s\"\n",sf->filename,scriptfile_getlinum(sf,sf->ltextptr),p);
		return -2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f020
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x6f4a8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x6f180
movq -0x28(%rbp), %rsi
movl %eax, %edx
leaq 0x44a7b(%rip), %rdi     # 0xb3f10
movb $0x0, %al
callq 0x37c90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6f587
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x6f590
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x6f580
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x6f580
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x6f580
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x6f580
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6f580
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f060
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x6f180
movq -0x30(%rbp), %rsi
movl %eax, %edx
movq -0x20(%rbp), %rcx
leaq 0x449c5(%rip), %rdi     # 0xb3f35
movb $0x0, %al
callq 0x37c90
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x6f587
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq