LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]rbtree/test/test.c
// Function: read_values
static int read_values(array_t *arr)
{
	int r, v;
	while ((r = next_value(&v)) == 0) {
		if (arr->cap <= arr->entries) {
			int cap = arr->cap << 1, *p;
			if (cap == 0)
				cap = 8;
			p = realloc(arr->array, cap * sizeof(int));
			if (p == NULL)
				return -1;
			arr->cap = cap;
			arr->array = p;
		}
		arr->array[arr->entries++] = v;
	}
	if (r && errno == EOF)
		return 0;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movl %r15d, %eax
movl %eax, %r15d
callq 0x10e0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x3f1f
cmpl $0xa, %r14d
je 0x3f1f
callq 0x1170
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
testb $0x1, %al
je 0x3ed4
xorl %eax, %eax
testl %r15d, %r15d
je 0x3ea2
jmp 0x3f1f
cmpl $0x2d, %r14d
je 0x3efa
cmpl $0x2b, %r14d
je 0x3efa
btl $0xb, %eax
jae 0x3fb3
leal (%rbp,%rbp,4), %eax
leal (%r14,%rax,2), %ebp
addl $-0x30, %ebp
incl %r15d
jmp 0x3e9f
testl %r12d, %r12d
jne 0x3fcf
testl %r15d, %r15d
jg 0x3fcf
xorl %eax, %eax
cmpl $0x2d, %r14d
setne %al
leal -0x1(,%rax,2), %r12d
jmp 0x3e9f
testl %r15d, %r15d
jle 0x3f59
movl %ebp, %r13d
negl %r13d
cmpl $-0x1, %r12d
cmovnel %ebp, %r13d
xorl %ebp, %ebp
movb $0x1, %r15b
cmpl $0xa, %r14d
je 0x3f43
cmpl $-0x1, %r14d
jne 0x3f6c
movq 0x4096(%rip), %rax      # 0x7fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1110
jmp 0x3f6c
callq 0x1060
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
testb %r15b, %r15b
je 0x3fe0
movl 0x4(%rbx), %ebp
cmpl (%rbx), %ebp
jg 0x3f9e
addl %ebp, %ebp
movl $0x8, %eax
cmovel %eax, %ebp
movq 0x8(%rbx), %rdi
movslq %ebp, %rsi
shlq $0x2, %rsi
callq 0x1130
testq %rax, %rax
je 0x3fef
movl %ebp, 0x4(%rbx)
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movl %r13d, (%rax,%rcx,4)
jmp 0x3e97
callq 0x10e0
cmpl $0xa, %eax
je 0x3fc2
cmpl $-0x1, %eax
jne 0x3fb3
callq 0x1060
movl $0x16, (%rax)
jmp 0x3f64
callq 0x10e0
cmpl $0xa, %eax
je 0x3fc2
cmpl $-0x1, %eax
jne 0x3fcf
jmp 0x3fc2
callq 0x1060
xorl %ecx, %ecx
cmpl $-0x1, (%rax)
cmovel %ecx, %ebp
jmp 0x3ff4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/stickman.c
// Function: HandleKeyPress
void HandleKeyPress(XKeyEvent* pevent)
{
	char charback;

	XLookupString(pevent, &charback, 1, NULL, NULL);
	switch (charback) {
	case 'q':
	case 'Q':
		exit(0);
	case ' ':
	case '\n':
		DumpSkel(&bones);
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rbx
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1050
movzbl (%rbx), %eax
cmpl $0x1f, %eax
jle 0x1453
cmpl $0x20, %eax
je 0x1458
cmpl $0x71, %eax
je 0x144c
cmpl $0x51, %eax
jne 0x1464
xorl %edi, %edi
callq 0x1060
cmpl $0xa, %eax
jne 0x1464
leaq 0x3c71(%rip), %rdi      # 0x50d0
callq 0x1850
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/stickman.c
// Function: HandleButtonPress
void HandleButtonPress(XButtonEvent* pevent)
{
	targetray=FindNearestRay(pevent);
	switch (pevent->button) {
/*
** Button 1 rotates the selected segment about its anchor.
*/
	case 1:
		ButtonDown=1;
		FlashRay (targetray);
		break;
/*
** Button 2 drags the whole body around.
*/
	case 2:
		DrawSkel(&bones, set_gc, buffer[0]);
		DrawSkel(&bones, dotted_gc, buffer[0]);
		ButtonDown=2;
		offsetx=bones.waistx-pevent->x;
		offsety=bones.waisty-pevent->y;
		break;
/*
** Button 3 prints the current variables to the screen.
*/

	case 3:
		ButtonDown=3;
		FlashRay (targetray);
		break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x17b8
movq %rax, 0x3de6(%rip)      # 0x5268
movl 0x54(%rbx), %ecx
cmpl $0x3, %ecx
je 0x1500
cmpl $0x2, %ecx
je 0x14a4
cmpl $0x1, %ecx
jne 0x153f
movl $0x1, 0x3dbe(%rip)      # 0x5260
jmp 0x150a
movq 0x3d9d(%rip), %rsi      # 0x5248
leaq 0x3e4e(%rip), %r15      # 0x5300
movq (%r15), %rdx
leaq 0x3c14(%rip), %r14      # 0x50d0
movq %r14, %rdi
callq 0x18b0
movq 0x3d85(%rip), %rsi      # 0x5250
movq (%r15), %rdx
movq %r14, %rdi
callq 0x18b0
movl $0x2, 0x3d80(%rip)      # 0x5260
movl 0x3bee(%rip), %eax      # 0x50d4
subl 0x40(%rbx), %eax
movl %eax, 0x3d81(%rip)      # 0x5270
movl 0x3be3(%rip), %eax      # 0x50d8
subl 0x44(%rbx), %eax
movl %eax, 0x3d76(%rip)      # 0x5274
jmp 0x153f
movl $0x3, 0x3d56(%rip)      # 0x5260
leaq 0x3dcf(%rip), %rcx      # 0x52e0
movq (%rcx), %rdi
leaq 0x3de5(%rip), %rcx      # 0x5300
movq (%rcx), %rsi
movq 0x3d2b(%rip), %rdx      # 0x5250
movl 0x10(%rax), %ecx
movl 0x14(%rax), %r8d
movq 0x18(%rax), %rax
movl 0x10(%rax), %r9d
movl 0x14(%rax), %eax
movl %eax, (%rsp)
callq 0x10d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/stickman.c
// Function: FlashRay
void FlashRay(RayPtr targetray)
{
/*
 *	XDrawLine(	dpy, buffer[0], set_gc,
 * targetray->x, targetray->y,
 * targetray->anchor->x, targetray->anchor->y);
 */

	XDrawLine(dpy, buffer[0], dotted_gc,
		targetray->x, targetray->y,
		targetray->anchor->x, targetray->anchor->y);
}

// Assembly:
pushq %rax
leaq 0x3b81(%rip), %rax      # 0x52e0
movq (%rax), %rax
leaq 0x3b97(%rip), %rcx      # 0x5300
movq (%rcx), %rsi
movq 0x3add(%rip), %rdx      # 0x5250
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %r8d
movq 0x18(%rdi), %rdi
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %edi
movl %edi, (%rsp)
movq %rax, %rdi
callq 0x10d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/stickman.c
// Function: FindNearestRay
RayPtr FindNearestRay(XButtonEvent* pevent) {
	RayPtr retval=NULL;
	double olddist, newdist;
	int x, y;
	RayPtr stepray;
	int stepsize=sizeof(Ray);

	x=pevent->x;
	y=pevent->y;

	olddist=99999;
/*
** Yes, I KNOW the following is a disgusting way to step through all the
** ray elements of the "bones" data structure. So there! Neah neah neah.
*/
	for (stepray=&(bones.torso); stepray <= &(bones.ltricep); stepray=(RayPtr) ((long) stepray+(long) stepsize)) {
		newdist=(FindDistance(x, y, stepray));
		if (newdist < olddist) {
			retval=stepray;
			olddist=newdist;
		}
	}
	return (retval);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x40(%rdi), %ebp
movl 0x44(%rdi), %r14d
movsd 0x183d(%rip), %xmm2     # 0x3010
leaq 0x3906(%rip), %r15      # 0x50e0
xorl %ebx, %ebx
xorpd %xmm1, %xmm1
leaq 0x3a39(%rip), %r12      # 0x5220
movl %ebp, %eax
subl 0x10(%r15), %eax
movl %r14d, %ecx
subl 0x14(%r15), %ecx
imull %eax, %eax
imull %ecx, %ecx
addl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
ucomisd %xmm1, %xmm0
jb 0x1810
sqrtsd %xmm0, %xmm0
jmp 0x1825
movsd %xmm2, 0x8(%rsp)
callq 0x1150
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
cmovaq %r15, %rbx
minsd %xmm2, %xmm0
addq $0x20, %r15
movapd %xmm0, %xmm2
cmpq %r12, %r15
jbe 0x17e7
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/CSerxzm[P]WindowstoLinuxInterface/src/COMP.c
// Function: main
int main(int argc, char **argv)
{
	char lines[argc+1][255];
    predealLine(argc, argv, lines);
    char* filename1 = lines[1];
    char* filename2 = lines[2];
    int flag = comp(filename1, filename2);
	if(!flag) {
		printf("文件的大小不同\n");
	}
	else {
		printf("文件比较无误\n");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leal 0x1(%rdi), %eax
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %r14    # imm = 0x1FFFFFFFFF0
andq %rcx, %r14
movq %rsp, %r15
movq %r15, %rbx
subq %r14, %rbx
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x11bc
negq %r14
leaq (%r15,%r14), %rdi
addq $0xff, %rdi
addq $0x1fe, %rbx            # imm = 0x1FE
movq %rbx, %rsi
callq 0x1338
testl %eax, %eax
leaq 0xd11(%rip), %rax       # 0x202c
leaq 0xd20(%rip), %rdi       # 0x2042
cmoveq %rax, %rdi
callq 0x1030
xorl %eax, %eax
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/CSerxzm[P]WindowstoLinuxInterface/src/COMP.c
// Function: comp
int comp(char* filename1, char*filename2) 
{
	FILE *file1;
	FILE *file2;
	char ch1, ch2;
	int flag = 1;
	if((file1=fopen(filename1, "r"))==NULL) {
    		printf("文件不能打开");
    		exit(0);
	}
	if((file2=fopen(filename2, "r"))==NULL) {
    		printf("文件不能打开");
    		exit(0);
	}
	printf("比较 %s 和 %s \n", filename1, filename2);
	while((ch1 = fgetc(file1)) != EOF && (ch2 = fgetc(file2)) != EOF) {
    	if(ch1 == ch2)
    		continue;
    	else {
    		flag = 0;
    		break;
    	}
	}
	if( ((ch1 = fgetc(file1)) != EOF && (ch2 = fgetc(file2)) == EOF) || 
	    ((ch1 = fgetc(file1)) == EOF && (ch2 = fgetc(file2)) != EOF) ) {
		flag = 0;
	}
	fclose(file1);
	fclose(file2);
	return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xcb4(%rip), %rsi       # 0x2004
callq 0x1080
testq %rax, %rax
je 0x1417
movq %rax, %rbx
leaq 0xc9c(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1080
testq %rax, %rax
je 0x1417
movq %rax, %r14
leaq 0xc96(%rip), %rdi       # 0x2019
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1060
movl $0x1, %r15d
movq %rbx, %rdi
callq 0x1070
movl %eax, %r12d
shll $0x18, %r12d
cmpl $0xff000000, %r12d      # imm = 0xFF000000
je 0x13c8
movq %r14, %rdi
callq 0x1070
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x13c8
cmpl %eax, %r12d
je 0x1396
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13e0
movq %r14, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13f8
movq %rbx, %rdi
callq 0x1070
cmpb $-0x1, %al
jne 0x13fb
movq %r14, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13fb
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbe8(%rip), %rdi       # 0x2006
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: addsym
static void
addsym(bool ignorethis, bool definethis, char *sym)
{
	int symind;
	char *val;

	symind = findsym(sym);
	if (symind < 0) {
		if (nsyms >= MAXSYMS)
			errx(2, "too many symbols");
		symind = nsyms++;
	}
	symname[symind] = sym;
	ignore[symind] = ignorethis;
	val = sym + (skipsym(sym) - sym);
	if (definethis) {
		if (*val == '=') {
			value[symind] = val+1;
			*val = '\0';
		} else if (*val == '\0')
			value[symind] = "1";
		else
			usage();
	} else {
		if (*val != '\0')
			usage();
		value[symind] = NULL;
	}
	debug("addsym %s=%s", symname[symind],
	    value[symind] ? value[symind] : "undef");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movq %rdx, %rdi
callq 0x43f9
testl %eax, %eax
jns 0x3822
movl 0x10c42(%rip), %eax     # 0x14450
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x38e1
leal 0x1(%rax), %ecx
movl %ecx, 0x10c2e(%rip)     # 0x14450
movslq %eax, %r15
leaq 0x10c34(%rip), %rax     # 0x14460
movq %rbx, (%rax,%r15,8)
leaq 0xfac9(%rip), %rax      # 0x13300
movb %r14b, (%r15,%rax)
callq 0x3290
movq (%rax), %rcx
movq %rbx, %rax
movzbl (%rax), %edx
incq %rax
cmpl $0x5f, %edx
je 0x3846
movzwl (%rcx,%rdx,2), %edx
andl $0x8, %edx
jne 0x3846
movzbl -0x1(%rax), %ecx
testb %bpl, %bpl
je 0x3881
testl %ecx, %ecx
je 0x3896
cmpl $0x3d, %ecx
jne 0x38f4
leaq 0x7a89(%rip), %rcx      # 0xb300
movq %rax, (%rcx,%r15,8)
movb $0x0, -0x1(%rax)
jmp 0x38a8
testl %ecx, %ecx
jne 0x38dc
leaq 0x7a74(%rip), %rax      # 0xb300
movq $0x0, (%rax,%r15,8)
jmp 0x38a8
leaq 0x7a63(%rip), %rax      # 0xb300
leaq 0x2e6e(%rip), %rcx      # 0x6712
movq %rcx, (%rax,%r15,8)
leaq 0x7a51(%rip), %rax      # 0xb300
movq (%rax,%r15,8), %rax
testq %rax, %rax
leaq 0x2e64(%rip), %rdx      # 0x6721
cmovneq %rax, %rdx
leaq 0x2e4c(%rip), %rdi      # 0x6714
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f2f
callq 0x32b0
leaq 0x2e19(%rip), %rsi      # 0x6701
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
callq 0x32d5
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: error
static void
error(const char *msg)
{
	if (depth == 0)
		warnx("%s: %d: %s", filename, linenum, msg);
	else
		warnx("%s: %d: %s (#if line %d depth %d)",
		    filename, linenum, msg, stifline[depth], depth);
	closeout();
	errx(2, "output may be truncated");
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movslq 0x62f0(%rip), %r9       # 0xa2c0
movq 0x51b1(%rip), %rsi      # 0x9188
movl 0x62e7(%rip), %edx      # 0xa2c4
testq %r9, %r9
jne 0x3ff2
leaq 0x237f(%rip), %rdi      # 0x6368
xorl %eax, %eax
callq 0x3100
jmp 0x400b
leaq 0x10307(%rip), %rax     # 0x14300
movl (%rax,%r9,4), %r8d
leaq 0x236f(%rip), %rdi      # 0x6373
xorl %eax, %eax
callq 0x3100
callq 0x45ed
leaq 0x237e(%rip), %rsi      # 0x6395
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: findsym
static int
findsym(const char *str)
{
	const char *cp;
	int symind;

	cp = skipsym(str);
	if (cp == str)
		return (-1);
	if (symlist) {
		if (symdepth && firstsym)
			printf("%s%3d", zerosyms ? "" : "\n", depth);
		firstsym = zerosyms = false;
		printf("%s%.*s%s",
		    symdepth ? " " : "",
		    (int)(cp-str), str,
		    symdepth ? "" : "\n");
		/* we don't care about the value of the symbol */
		return (0);
	}
	for (symind = 0; symind < nsyms; ++symind) {
		if (strlcmp(symname[symind], str, cp-str) == 0) {
			debug("findsym %s %s", symname[symind],
			    value[symind] ? value[symind] : "");
			return (symind);
		}
	}
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x3290
movq (%rax), %rax
movq $-0x1, %r14
movzbl 0x1(%rbx,%r14), %ecx
incq %r14
cmpl $0x5f, %ecx
je 0x4413
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
jne 0x4413
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x456c
cmpb $0x0, 0x4d41(%rip)      # 0x9180
je 0x44d1
cmpb $0x1, 0x4d35(%rip)      # 0x9181
jne 0x4484
cmpb $0x1, 0x6e9b(%rip)      # 0xb2f0
jne 0x4484
leaq 0x1da6(%rip), %rax      # 0x6204
cmpb $0x0, 0xff9b(%rip)      # 0x14400
leaq 0x1f96(%rip), %rsi      # 0x6402
cmovneq %rax, %rsi
movl 0x5e4a(%rip), %edx      # 0xa2c0
leaq 0x1fed(%rip), %rdi      # 0x646a
xorl %eax, %eax
callq 0x30f0
movb $0x1, 0xff75(%rip)      # 0x14400
leaq 0x1fe7(%rip), %rsi      # 0x6479
leaq 0x1f69(%rip), %rax      # 0x6402
cmpb $0x0, 0x4ce1(%rip)      # 0x9181
cmoveq %rax, %rsi
movb $0x0, 0x6e45(%rip)      # 0xb2f0
leaq 0x1d52(%rip), %r8       # 0x6204
cmovneq %rax, %r8
leaq 0x1fb3(%rip), %rdi      # 0x6470
xorl %ebp, %ebp
movl %r14d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x30f0
jmp 0x456c
movslq 0xff78(%rip), %rax      # 0x14450
testq %rax, %rax
jle 0x456c
movq %r14, %rcx
negq %rcx
xorl %r15d, %r15d
leaq 0xff6f(%rip), %rdx      # 0x14460
movq (%rdx,%r15,8), %rsi
movq %rsi, %rdi
testq %r14, %r14
je 0x452a
leaq (%rsi,%r14), %r8
movq %rcx, %r9
movq %rbx, %r10
movq %rsi, %rdi
movzbl (%r10), %r12d
testl %r12d, %r12d
je 0x452a
movzbl (%rdi), %r11d
cmpb %r12b, %r11b
jne 0x4530
incq %rdi
incq %r10
incq %r9
jne 0x450a
movq %r8, %rdi
movzbl (%rdi), %r11d
jmp 0x4533
subl %r12d, %r11d
testl %r11d, %r11d
je 0x4542
incq %r15
cmpq %rax, %r15
jne 0x44f1
jmp 0x456c
leaq 0x6db7(%rip), %rax      # 0xb300
movq (%rax,%r15,8), %rax
testq %rax, %rax
leaq 0x1eab(%rip), %rdx      # 0x6402
cmovneq %rax, %rdx
leaq 0x1f19(%rip), %rdi      # 0x647b
xorl %eax, %eax
callq 0x3f2f
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: ifeval
static Linetype
ifeval(const char **cpp)
{
	int ret;
	int val = 0;

	debug("eval %s", *cpp);
	constexpr = killconsts ? false : true;
	ret = eval_table(eval_ops, &val, cpp);
	debug("eval = %d", val);
	return (constexpr ? LT_IF : ret == LT_ERROR ? LT_IF : ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movq (%rdi), %rsi
leaq 0x1ef5(%rip), %rdi      # 0x6489
xorl %eax, %eax
callq 0x3f2f
movb 0x4bd5(%rip), %al       # 0x9176
xorb $0x1, %al
movb %al, 0x17eb7(%rip)      # 0x1c460
leaq 0x46c0(%rip), %rdi      # 0x8c70
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4683
movl %eax, %ebx
movl (%r14), %esi
leaq 0x1eca(%rip), %rdi      # 0x6491
xorl %eax, %eax
callq 0x3f2f
cmpl $0x16, %ebx
movl $0x2, %eax
cmovel %eax, %ebx
cmpb $0x0, 0x17e80(%rip)     # 0x1c460
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: closeout
static void
closeout(void)
{
	if (symdepth && !zerosyms)
		printf("\n");
	if (ferror(output) || fclose(output) == EOF) {
		if (overwriting) {
			warn("couldn't write to temporary file");
			unlink(tempname);
			errx(2, "%s unchanged", ofilename);
		} else {
			err(2, "couldn't write to %s", ofilename);
		}
	}
}

// Assembly:
pushq %rbx
cmpb $0x1, 0x4b8c(%rip)      # 0x9181
jne 0x460a
cmpb $0x1, 0xfe02(%rip)      # 0x14400
jne 0x460a
movl $0xa, %edi
callq 0x3030
movq 0x4b87(%rip), %rbx      # 0x9198
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
jne 0x462c
movq %rbx, %rdi
callq 0x30b0
cmpl $-0x1, %eax
je 0x462c
popq %rbx
retq
cmpb $0x1, 0x4b6d(%rip)      # 0x91a0
jne 0x4669
leaq 0x1d71(%rip), %rdi      # 0x63ad
xorl %eax, %eax
callq 0x3090
leaq 0x4b66(%rip), %rdi      # 0x91b0
callq 0x3060
movq 0x4b22(%rip), %rdx      # 0x9178
leaq 0x1d71(%rip), %rsi      # 0x63ce
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
movq 0x4b08(%rip), %rdx      # 0x9178
leaq 0x1d64(%rip), %rsi      # 0x63db
movl $0x2, %edi
xorl %eax, %eax
callq 0x31d0
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: skipargs
static const char *
skipargs(const char *cp)
{
	const char *ocp = cp;
	int level = 0;
	cp = skipcomment(cp);
	if (*cp != '(')
		return (cp);
	do {
		if (*cp == '(')
			level++;
		if (*cp == ')')
			level--;
		cp = skipcomment(cp+1);
	} while (level != 0 && *cp != '\0');
	if (level == 0)
		return (cp);
	else
	/* Rewind and re-detect the syntax error later. */
		return (ocp);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4023
cmpb $0x28, (%rax)
jne 0x4eab
xorl %ebp, %ebp
movb (%rax), %cl
xorl %edx, %edx
cmpb $0x28, %cl
sete %dl
addl %edx, %ebp
xorl %r14d, %r14d
cmpb $0x29, %cl
sete %r14b
incq %rax
movq %rax, %rdi
callq 0x4023
subl %r14d, %ebp
je 0x4eab
cmpb $0x0, (%rax)
jne 0x4e7d
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: done
static void
done(void)
{
	if (incomment)
		error("EOF in comment");
	closeout();
	if (overwriting && rename(tempname, ofilename) == -1) {
		warn("couldn't rename temporary file");
		unlink(tempname);
		errx(2, "%s unchanged", ofilename);
	}
	exit(exitstat);
}

// Assembly:
pushq %rax
cmpl $0x0, 0x6348(%rip)      # 0xb2e8
jne 0x4ffc
callq 0x45ed
cmpb $0x1, 0x41f2(%rip)      # 0x91a0
jne 0x5008
movq 0x41c1(%rip), %rsi      # 0x9178
leaq 0x41f2(%rip), %rdi      # 0x91b0
callq 0x3230
cmpl $-0x1, %eax
jne 0x5008
leaq 0x160b(%rip), %rdi      # 0x65da
xorl %eax, %eax
callq 0x3090
leaq 0x41d3(%rip), %rdi      # 0x91b0
callq 0x3060
movq 0x418f(%rip), %rdx      # 0x9178
leaq 0x13de(%rip), %rsi      # 0x63ce
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
leaq 0x15c8(%rip), %rdi      # 0x65cb
callq 0x3fc5
movzbl 0x17459(%rip), %edi     # 0x1c468
callq 0x3250
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: nest
static void
nest(void)
{
	if (depth > MAXDEPTH-1)
		abort(); /* bug */
	if (depth == MAXDEPTH-1)
		error("Too many levels of nesting");
	depth += 1;
	stifline[depth] = linenum;
}

// Assembly:
pushq %rax
movl 0x4f7d(%rip), %eax      # 0xa2c0
cmpl $0x40, %eax
jge 0x5371
cmpl $0x3f, %eax
je 0x5376
movslq 0x4f6c(%rip), %rax      # 0xa2c0
leaq 0x1(%rax), %rcx
movl %ecx, 0x4f62(%rip)      # 0xa2c0
movl 0x4f60(%rip), %ecx      # 0xa2c4
leaq 0xef95(%rip), %rdx      # 0x14300
movl %ecx, 0x4(%rdx,%rax,4)
popq %rax
retq
callq 0x3040
leaq 0x11e6(%rip), %rdi      # 0x6563
callq 0x3fc5
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: flushline
static void
flushline(bool keep)
{
	if (symlist)
		return;
	if (keep ^ complement) {
		bool blankline = tline[strspn(tline, " \t\r\n")] == '\0';
		if (blankline && compblank && blankcount != blankmax) {
			delcount += 1;
			blankcount += 1;
		} else {
			if (lnnum && delcount > 0 &&
			    fprintf(output, "#line %d%s", linenum, newline) < 0)
				closeout();
			if (fputs(tline, output) == EOF)
				closeout();
			delcount = 0;
			blankmax = blankcount = blankline ? blankcount + 1 : 0;
		}
	} else {
		if (lnblank && fputs(newline, output) == EOF)
			closeout();
		exitstat = 1;
		delcount += 1;
		blankcount = 0;
	}
	if (debugging && fflush(output) == EOF)
		closeout();
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x3df6(%rip)      # 0x9180
jne 0x54a9
cmpb %dil, 0x3ddb(%rip)      # 0x9172
je 0x5452
leaq 0x4f2c(%rip), %rbx      # 0xa2d0
leaq 0x1210(%rip), %rsi      # 0x65bb
movq %rbx, %rdi
callq 0x3140
movb (%rax,%rbx), %bl
testb %bl, %bl
jne 0x53d5
cmpb $0x1, 0x3db0(%rip)      # 0x9171
jne 0x53d5
movl 0x4de7(%rip), %eax      # 0xa1b0
cmpl 0x4de5(%rip), %eax      # 0xa1b4
jne 0x54b1
cmpb $0x1, 0x3d9b(%rip)      # 0x9177
jne 0x5412
cmpl $0x0, 0x1707f(%rip)     # 0x1c464
jle 0x5412
movq 0x3daa(%rip), %rdi      # 0x9198
movl 0x4ed0(%rip), %edx      # 0xa2c4
movq 0x5ee5(%rip), %rcx      # 0xb2e0
leaq 0x11be(%rip), %rsi      # 0x65c0
xorl %eax, %eax
callq 0x3190
testl %eax, %eax
jns 0x5412
callq 0x45ed
movq 0x3d7f(%rip), %rsi      # 0x9198
leaq 0x4eb0(%rip), %rdi      # 0xa2d0
callq 0x3130
cmpl $-0x1, %eax
jne 0x542f
callq 0x45ed
movl 0x4d7b(%rip), %eax      # 0xa1b0
incl %eax
xorl %ecx, %ecx
testb %bl, %bl
movl %ecx, 0x17023(%rip)     # 0x1c464
cmovnel %ecx, %eax
movl %eax, 0x4d66(%rip)      # 0xa1b0
movl %eax, 0x4d64(%rip)      # 0xa1b4
jmp 0x548f
cmpb $0x1, 0x3d17(%rip)      # 0x9170
jne 0x5478
movq 0x5e7e(%rip), %rdi      # 0xb2e0
movq 0x3d2f(%rip), %rsi      # 0x9198
callq 0x3130
cmpl $-0x1, %eax
jne 0x5478
callq 0x45ed
movb $0x1, 0x16fe9(%rip)     # 0x1c468
incl 0x16fdf(%rip)           # 0x1c464
movl $0x0, 0x4d21(%rip)      # 0xa1b0
cmpb $0x1, 0x3cdd(%rip)      # 0x9173
jne 0x54a9
movq 0x3cf9(%rip), %rdi      # 0x9198
callq 0x31e0
cmpl $-0x1, %eax
je 0x54ab
popq %rbx
retq
popq %rbx
jmp 0x45ed
incl 0x16fad(%rip)           # 0x1c464
incl %eax
movl %eax, 0x4cf1(%rip)      # 0xa1b0
jmp 0x548f
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: nbt_write_int
int nbt_write_int(FILE *f, int32_t val) {
	char bytes[] = {
		(val & 0xff000000l) >> 24, (val & 0x00ff0000l) >> 16,
		(val & 0x0000ff00l) >> 8, val & 0x000000ffl,
	};
	return fwrite(bytes, 1, 4, f) == 4;
}

// Assembly:
pushq %rax
movq %rdi, %rcx
bswapl %esi
leaq 0x4(%rsp), %rdi
movl %esi, (%rdi)
movl $0x1, %esi
movl $0x4, %edx
callq 0xc100
xorl %ecx, %ecx
cmpq $0x4, %rax
sete %cl
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: mappings_lookup
struct mapping *mappings_lookup(const char *name) {
	size_t start = 0;
	size_t end = legacy_mappings_len - 1;
	while (1) {
		size_t mid = (end - start) / 2 + start;
		struct mapping *m = &legacy_mappings[mid];
		int cmp = strcmp(name, m->name);
		if (cmp > 0) {
			start = mid;
		} else if (cmp < 0) {
			end = mid;
		} else {
			return m;
		}

		if (start >= end) {
			fprintf(stderr, "nothing found\n");
			return NULL;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x191ee(%rip), %rax     # 0x25740
movq (%rax), %r15
decq %r15
xorl %r13d, %r13d
leaq 0x11b3e(%rip), %r12     # 0x1e0a0
movq %r15, %rbp
subq %r13, %rbp
shrq %rbp
addq %r13, %rbp
movq %rbp, %r14
shlq $0x4, %r14
movq (%r12,%r14), %rsi
movq %rbx, %rdi
callq 0xc0a0
testl %eax, %eax
jle 0xc58a
movq %rbp, %r13
jmp 0xc58f
jns 0xc5a7
movq %rbp, %r15
movb $0x1, %al
cmpq %r15, %r13
jb 0xc5b0
callq 0xc120
movq $0x0, (%rsp)
xorl %eax, %eax
jmp 0xc5b0
addq %r12, %r14
xorl %eax, %eax
movq %r14, (%rsp)
testb %al, %al
jne 0xc562
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: blocks_find_or_create_chunk
size_t blocks_find_or_create_chunk(struct blocks *blocks, size_t chunkx, size_t chunky, size_t chunkz) {
	for (size_t i = 0; i < blocks->chunkcount; ++i) {
		struct blockchunk *chunk = &blocks->chunks[i];
		if (chunk->x == chunkx && chunk->y == chunky && chunk->z == chunkz) {
			return i;
		}
	}

	size_t idx = blocks->chunkcount;
	blocks->chunkcount += 1;
	blocks->chunks = realloc(blocks->chunks, sizeof(struct blockchunk) * blocks->chunkcount);
	struct blockchunk *chunk = &blocks->chunks[idx];
	memset(chunk->blocks, 0, sizeof(chunk->blocks));
	memset(chunk->data, 0, sizeof(chunk->data));
	chunk->x = chunkx;
	chunk->y = chunky;
	chunk->z = chunkz;
	return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdi), %r13
testq %r13, %r13
setne %cl
je 0xc671
movq 0x18(%r12), %rdx
addq $0x10, %rdx
xorl %esi, %esi
cmpq %r15, -0x10(%rdx)
jne 0xc652
cmpq %r14, -0x8(%rdx)
jne 0xc652
cmpq %rbx, (%rdx)
jne 0xc652
xorl %edi, %edi
movq %rsi, %rax
jmp 0xc655
movb $0x1, %dil
testb %dil, %dil
je 0xc671
incq %rsi
cmpq %r13, %rsi
setb %cl
addq $0x2018, %rdx           # imm = 0x2018
cmpq %rsi, %r13
jne 0xc63a
jmp 0xc671
testb $0x1, %cl
jne 0xc6c5
leaq 0x1(%r13), %rax
movq %rax, 0x20(%r12)
movq 0x18(%r12), %rdi
imulq $0x2018, %r13, %rbp     # imm = 0x2018
leaq 0x2018(%rbp), %rsi
callq 0xc0d0
movq %rax, 0x18(%r12)
leaq (%rax,%rbp), %r12
addq $0x18, %r12
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rdi
xorl %esi, %esi
callq 0xc070
movq %r15, -0x18(%r12)
movq %r14, -0x10(%r12)
movq %rbx, -0x8(%r12)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: blocks_find_chunk
ssize_t blocks_find_chunk(struct blocks *blocks, size_t chunkx, size_t chunky, size_t chunkz) {
	for (size_t i = 0; i < blocks->chunkcount; ++i) {
		struct blockchunk *chunk = &blocks->chunks[i];
		if (chunk->x == chunkx && chunk->y == chunky && chunk->z == chunkz) {
			return i;
		}
	}

	return -1;
}

// Assembly:
movq 0x20(%rdi), %r8
movq $-0x1, %rax
testq %r8, %r8
je 0xc71f
movq 0x18(%rdi), %rdi
addq $0x10, %rdi
xorl %r9d, %r9d
cmpq %rsi, -0x10(%rdi)
jne 0xc708
cmpq %rdx, -0x8(%rdi)
jne 0xc708
cmpq %rcx, (%rdi)
jne 0xc708
xorl %r11d, %r11d
movq %r9, %r10
jmp 0xc70b
movb $0x1, %r11b
testb %r11b, %r11b
je 0xc720
incq %r9
addq $0x2018, %rdi           # imm = 0x2018
cmpq %r9, %r8
jne 0xc6ef
retq
movq %r10, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: blocks_set
void blocks_set(struct blocks *blocks, size_t x, size_t y, size_t z, uint8_t id, uint8_t data) {
	size_t chunkx = x / CHUNK_SIZE;
	size_t chunky = y / CHUNK_SIZE;
	size_t chunkz = z / CHUNK_SIZE;
	size_t relx = x % CHUNK_SIZE;
	size_t rely = y % CHUNK_SIZE;
	size_t relz = z % CHUNK_SIZE;
	size_t chunkidx = blocks_find_or_create_chunk(blocks, chunkx, chunky, chunkz);
	blockchunk_set(&blocks->chunks[chunkidx], relx, rely, relz, id, data);
	if (x >= blocks->width) blocks->width = x + 1;
	if (y >= blocks->height) blocks->height = y + 1;
	if (z >= blocks->length) blocks->length = z + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r14
shrq $0x4, %rsi
shrq $0x4, %rdx
shrq $0x4, %rcx
movl %ebp, %r12d
andl $0xf, %r12d
callq 0xc60c
imulq $0x2018, %rax, %rax     # imm = 0x2018
addq 0x18(%r14), %rax
movl %r15d, %ecx
andl $0xf, %ecx
shll $0x8, %ecx
orq %r12, %rcx
movl %ebx, %edx
shll $0x4, %edx
movzbl %dl, %edx
orq %rcx, %rdx
movb %r13b, 0x18(%rax,%rdx)
movl 0x4(%rsp), %ecx
movb %cl, 0x1018(%rax,%rdx)
cmpq %rbp, (%r14)
ja 0xc798
incq %rbp
movq %rbp, (%r14)
cmpq %r15, 0x8(%r14)
ja 0xc7a5
incq %r15
movq %r15, 0x8(%r14)
cmpq %rbx, 0x10(%r14)
ja 0xc7b2
incq %rbx
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: blocks_get_id
uint8_t blocks_get_id(struct blocks *blocks, size_t x, size_t y, size_t z) {
	size_t chunkx = x / CHUNK_SIZE;
	size_t chunky = y / CHUNK_SIZE;
	size_t chunkz = z / CHUNK_SIZE;
	size_t relx = x % CHUNK_SIZE;
	size_t rely = y % CHUNK_SIZE;
	size_t relz = z % CHUNK_SIZE;
	ssize_t chunkidx = blocks_find_chunk(blocks, chunkx, chunky, chunkz);
	if (chunkidx < 0) {
		return 0;
	}

	return blockchunk_get_id(&blocks->chunks[chunkidx], relx, rely, relz);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r8
movq $-0x1, %rax
testq %r8, %r8
je 0xc82b
movq %rsi, %r9
shrq $0x4, %r9
movq %rdx, %r10
shrq $0x4, %r10
movq %rcx, %r11
shrq $0x4, %r11
movq 0x18(%rdi), %rbx
addq $0x10, %rbx
xorl %r14d, %r14d
cmpq %r9, -0x10(%rbx)
jne 0xc80f
cmpq %r10, -0x8(%rbx)
jne 0xc80f
cmpq %r11, (%rbx)
jne 0xc80f
xorl %ebp, %ebp
movq %r14, %r15
jmp 0xc812
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc828
incq %r14
addq $0x2018, %rbx           # imm = 0x2018
cmpq %r14, %r8
jne 0xc7f7
jmp 0xc82b
movq %r15, %rax
testq %rax, %rax
js 0xc856
andl $0xf, %esi
andl $0xf, %edx
shll $0x8, %edx
orq %rsi, %rdx
shll $0x4, %ecx
movzbl %cl, %ecx
orq %rdx, %rcx
imulq $0x2018, %rax, %rax     # imm = 0x2018
addq 0x18(%rdi), %rax
movb 0x18(%rax,%rcx), %al
jmp 0xc858
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: blocks_get_data
uint8_t blocks_get_data(struct blocks *blocks, size_t x, size_t y, size_t z) {
	size_t chunkx = x / CHUNK_SIZE;
	size_t chunky = y / CHUNK_SIZE;
	size_t chunkz = z / CHUNK_SIZE;
	size_t relx = x % CHUNK_SIZE;
	size_t rely = y % CHUNK_SIZE;
	size_t relz = z % CHUNK_SIZE;
	ssize_t chunkidx = blocks_find_chunk(blocks, chunkx, chunky, chunkz);
	if (chunkidx < 0) {
		return 0;
	}

	return blockchunk_get_data(&blocks->chunks[chunkidx], relx, rely, relz);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r8
movq $-0x1, %rax
testq %r8, %r8
je 0xc8c9
movq %rsi, %r9
shrq $0x4, %r9
movq %rdx, %r10
shrq $0x4, %r10
movq %rcx, %r11
shrq $0x4, %r11
movq 0x18(%rdi), %rbx
addq $0x10, %rbx
xorl %r14d, %r14d
cmpq %r9, -0x10(%rbx)
jne 0xc8ad
cmpq %r10, -0x8(%rbx)
jne 0xc8ad
cmpq %r11, (%rbx)
jne 0xc8ad
xorl %ebp, %ebp
movq %r14, %r15
jmp 0xc8b0
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc8c6
incq %r14
addq $0x2018, %rbx           # imm = 0x2018
cmpq %r14, %r8
jne 0xc895
jmp 0xc8c9
movq %r15, %rax
testq %rax, %rax
js 0xc8f7
andl $0xf, %esi
andl $0xf, %edx
shll $0x8, %edx
orq %rsi, %rdx
shll $0x4, %ecx
movzbl %cl, %ecx
orq %rdx, %rcx
imulq $0x2018, %rax, %rax     # imm = 0x2018
addq 0x18(%rdi), %rax
movb 0x1018(%rax,%rcx), %al
jmp 0xc8f9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: scdef_read_num
size_t scdef_read_num(char *line, size_t *idx) {
	char *end;
	char *start = &line[*idx];
	long num = strtol(start, &end, 10);

	if (num < 0) {
		fprintf(stderr, "Error: Expected positive number\n");
		fprintf(stderr, "  Here: ... %s", start);
		fprintf(stderr, "  Line: %s", line);
		num = 0;
	} else if (end == start) {
		fprintf(stderr, "Error: Expected number\n");
		fprintf(stderr, "  Here: ... %s", start);
		fprintf(stderr, "  Line: %s", line);
		num = 0;
	} else if (end[0] != '\0' && !scdef_is_space(end[0])) {
		fprintf(stderr, "Error: Expected space after number\n");
		fprintf(stderr, "  Here: ... %s", end);
		fprintf(stderr, "  Line: %s", line);
	}

	scdef_skip_to_space(line, idx);
	return num;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
addq %rdi, %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movl $0xa, %edx
callq 0xc0c0
movabsq $0x100000601, %r13      # imm = 0x100000601
testq %rax, %rax
js 0xca17
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xca21
movq %rax, %r15
movzbl (%rdi), %eax
cmpq $0x20, %rax
ja 0xca49
btq %rax, %r13
jae 0xca49
movq (%rbx), %rax
incq %rax
movzbl -0x1(%r14,%rax), %ecx
cmpq $0x20, %rcx
ja 0xca01
btq %rcx, %r13
jb 0xca06
movq %rax, (%rbx)
jmp 0xc9ec
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0xc1b8
jmp 0xca29
movq %r12, %rdi
callq 0xc17a
xorl %r15d, %r15d
movq 0x115c5(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x606(%rip), %rsi       # 0xd043
movq %r14, %rdx
xorl %eax, %eax
callq 0xc0b0
jmp 0xc9e9
callq 0xc13c
jmp 0xca2c
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: scdef_read_line
void scdef_read_line(struct blocks *blocks, char *line) {
	size_t idx = 0;
	scdef_skip_space(line, &idx);
	size_t x = scdef_read_num(line, &idx);
	scdef_skip_space(line, &idx);
	size_t y = scdef_read_num(line, &idx);
	scdef_skip_space(line, &idx);
	size_t z = scdef_read_num(line, &idx);
	scdef_skip_space(line, &idx);

	char *name = &line[idx];
	scdef_skip_to_space(line, &idx);
	line[idx] = '\0';

	struct mapping *m = mappings_lookup(name);
	if (m == NULL) {
		fprintf(stderr, "(%zu,%zu,%zu): Unknown block name: '%s'\n", x, y, z, name);
	} else {
		blocks_set(blocks, x, y, z, m->id, m->data);
		fprintf(stderr, "(%zu,%zu,%zu): %u:%u\n", x, y, z, m->id, m->data);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xca78
cmpl $0x20, %ecx
jne 0xca7d
incq %rax
jmp 0xca66
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc993
movq %rax, %r14
movq (%r12), %rax
movzbl (%r15,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xcaaa
cmpl $0x20, %ecx
jne 0xcaaf
incq %rax
jmp 0xca98
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %r15, %rdi
movq %r13, %rsi
callq 0xc993
movq %rax, %r12
movq (%r13), %rax
movzbl (%r15,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xcadc
cmpl $0x20, %ecx
jne 0xcae1
incq %rax
jmp 0xcaca
leaq 0x10(%rsp), %rbp
movq %rax, (%rbp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xc993
movq %rax, %r13
movq (%rbp), %rax
movzbl (%r15,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xcb0e
cmpl $0x20, %ecx
jne 0xcb13
incq %rax
jmp 0xcafc
movq %rax, 0x10(%rsp)
leaq (%r15,%rax), %rbp
movabsq $0x100000601, %rcx      # imm = 0x100000601
movzbl (%r15,%rax), %edx
cmpq $0x20, %rdx
ja 0xcb37
btq %rdx, %rcx
jb 0xcb3c
incq %rax
jmp 0xcb26
movq %rax, 0x10(%rsp)
movb $0x0, (%r15,%rax)
movq %rbp, %rdi
callq 0xc53d
testq %rax, %rax
jne 0xcb85
movq 0x1149e(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x526(%rip), %rsi       # 0xd08a
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbp, %r9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc0b0
movq %rax, %r15
movzbl 0x8(%rax), %r8d
movzbl 0x9(%rax), %r9d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xc724
movq 0x1144e(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movzbl 0x8(%r15), %r9d
movzbl 0x9(%r15), %eax
movl %eax, (%rsp)
leaq 0x4f2(%rip), %rsi       # 0xd0b3
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0xc0b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mortie[P]makeschem/makeschem.c
// Function: main
int main(int argc, char **argv) {
	if (argc != 3) {
		printf("Usage: %s <input|-> [output|-]\n", argv[0]);
		return EXIT_FAILURE;
	}

	FILE *in = stdin;
	if (strcmp(argv[1], "-") != 0) {
		in = fopen(argv[1], "r");
		if (in == NULL) {
			perror(argv[1]);
			return EXIT_FAILURE;
		}
	}

	FILE *out = stdout;
	if (strcmp(argv[2], "-") != 0) {
		out = fopen(argv[2], "w");
		if (out == NULL) {
			perror(argv[2]);
			return EXIT_FAILURE;
		}
	}

	struct blocks blocks;
	blocks_init(&blocks);
	scdef_read(&blocks, in);
	if (!schem_write(&blocks, out)) {
		if (ferror(out)) {
			perror("write");
		} else {
			fprintf(stderr, "Error: Write failed.\n");
		}
		free(blocks.chunks);
		return EXIT_FAILURE;
	}

	free(blocks.chunks);
	return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0xcf89
movq 0x110fe(%rip), %rax     # 0x1dfd8
movq (%rax), %r14
movq 0x8(%rbx), %r15
leaq 0x23b(%rip), %rsi       # 0xd123
movq %r15, %rdi
callq 0xc0a0
testl %eax, %eax
je 0xcf0f
leaq 0xa174(%rip), %rsi      # 0x1706f
movq %r15, %rdi
callq 0xc0e0
movq %rax, %r14
testq %rax, %rax
je 0xcfc0
movq 0x110ba(%rip), %rax     # 0x1dfd0
movq (%rax), %r15
movq 0x10(%rbx), %r12
leaq 0x1ff(%rip), %rsi       # 0xd123
movq %r12, %rdi
callq 0xc0a0
testl %eax, %eax
je 0xcf47
leaq 0xc4f2(%rip), %rsi      # 0x19429
movq %r12, %rdi
callq 0xc0e0
movq %rax, %r15
testq %rax, %rax
je 0xcfc6
xorps %xmm0, %xmm0
movq %rsp, %rbx
movups %xmm0, 0x18(%rbx)
movl $0x1, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rax, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcbe0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcc37
xorl %ebx, %ebx
testl %eax, %eax
je 0xcfad
movq 0x18(%rsp), %rdi
callq 0xc030
jmp 0xcf9f
movq (%rbx), %rsi
leaq 0x170(%rip), %rdi       # 0xd103
xorl %eax, %eax
callq 0xc060
movl $0x1, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0xc040
testl %eax, %eax
jne 0xcfd1
callq 0xc1f6
jmp 0xcfdd
movq 0x8(%rbx), %rdi
jmp 0xcfca
movq 0x10(%rbx), %rdi
callq 0xc0f0
jmp 0xcf9a
leaq 0x14d(%rip), %rdi       # 0xd125
callq 0xc0f0
movl $0x1, %ebx
jmp 0xcf7d
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: usage
static void usage(const char* message)
{
 if (*message=='-')
  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
 else
  fprintf(stderr,"%s: %s\n",progname,message);
 fprintf(stderr,
  "usage: %s [options] [filenames]\n"
  "Available options are:\n"
  "  -l       list (use -l -l for full listing)\n"
  "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
  "  -p       parse only\n"
  "  -s       strip debug information\n"
  "  -v       show version information\n"
  "  --       stop handling options\n"
  "  -        stop handling options and process stdin\n"
  ,progname,Output);
 exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbx
movq %rdi, %rcx
cmpb $0x2d, (%rdi)
movq 0x1a88a(%rip), %rbx     # 0x1eff0
movq (%rbx), %rdi
movq 0x1a9e8(%rip), %rdx     # 0x1f158
leaq 0x11a04(%rip), %rax     # 0x1617b
leaq 0x11d12(%rip), %rsi     # 0x16490
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x4160
movq (%rbx), %rdi
movq 0x1a9c5(%rip), %rdx     # 0x1f158
leaq 0x119ff(%rip), %rsi     # 0x16199
leaq 0x1a9c7(%rip), %rcx     # 0x1f168
xorl %eax, %eax
callq 0x4160
movl $0x1, %edi
callq 0x4230
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/luac.c
// Function: PrintConstant
static void PrintConstant(const Proto* f, int i)
{
 const TValue* o=&f->k[i];
 switch (ttypenv(o))
 {
  case LUA_TNIL:
	printf("nil");
	break;
  case LUA_TBOOLEAN:
	printf(bvalue(o) ? "true" : "false");
	break;
  case LUA_TNUMBER:
	printf(LUA_NUMBER_FMT,nvalue(o));
	break;
  case LUA_TSTRING:
	PrintString(rawtsvalue(o));
	break;
  default:				/* cannot happen */
	printf("? type=%d",ttype(o));
	break;
 }
}

// Assembly:
movq 0x10(%rdi), %rax
movslq %esi, %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %esi
movl %esi, %edx
andl $0xf, %edx
cmpl $0x4, %edx
ja 0x52cb
addq %rcx, %rax
leaq 0x10f22(%rip), %rcx     # 0x160b0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x12119(%rip), %rdi     # 0x172b7
jmp 0x51c7
movsd (%rax), %xmm0
leaq 0x11254(%rip), %rdi     # 0x163ff
movb $0x1, %al
jmp 0x4110
cmpl $0x0, (%rax)
leaq 0x1123d(%rip), %rax     # 0x163f9
leaq 0x11231(%rip), %rdi     # 0x163f4
cmoveq %rax, %rdi
xorl %eax, %eax
jmp 0x4110
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rax), %rbp
movq 0x10(%rbp), %r15
movl $0x22, %edi
callq 0x4040
testq %r15, %r15
je 0x52b3
leaq 0x10eca(%rip), %rbx     # 0x160c4
leaq 0x11220(%rip), %r12     # 0x16421
xorl %r14d, %r14d
movzbl 0x18(%rbp,%r14), %r13d
leal -0x7(%r13), %eax
cmpl $0x6, %eax
ja 0x5225
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
leaq 0x111f2(%rip), %rdi     # 0x16415
jmp 0x5273
cmpl $0x5c, %r13d
je 0x524c
cmpl $0x22, %r13d
jne 0x5284
leaq 0x111d7(%rip), %rdi     # 0x1640f
jmp 0x5273
leaq 0x111e6(%rip), %rdi     # 0x16427
jmp 0x5273
leaq 0x111da(%rip), %rdi     # 0x16424
jmp 0x5273
leaq 0x111bf(%rip), %rdi     # 0x16412
jmp 0x5273
leaq 0x111c2(%rip), %rdi     # 0x1641e
jmp 0x5273
leaq 0x111b3(%rip), %rdi     # 0x16418
jmp 0x5273
leaq 0x111ad(%rip), %rdi     # 0x1641b
jmp 0x5273
movq %r12, %rdi
xorl %eax, %eax
callq 0x4110
incq %r14
cmpq %r14, %r15
jne 0x5204
jmp 0x52b3
callq 0x4280
movq (%rax), %rax
movl %r13d, %ecx
testb $0x40, 0x1(%rax,%rcx,2)
jne 0x52a9
leaq 0x1118d(%rip), %rdi     # 0x1642a
movl %r13d, %esi
xorl %eax, %eax
callq 0x4110
jmp 0x527a
movl %r13d, %edi
callq 0x4040
jmp 0x527a
movl $0x22, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4040
andl $0x3f, %esi
leaq 0x11130(%rip), %rdi     # 0x16405
xorl %eax, %eax
jmp 0x4110
// File: /workspace/github_c_makefile_star2_O1/TomCrypto[P]avxfish/src/test.c
// Function: avxfish_test
static int avxfish_test(const char* output, const char* input, const char *key, const char *tweak) {
  __attribute__((aligned(64))) uint64_t input_bytes[16];
  __attribute__((aligned(64))) uint64_t subkeys[336];

  threefish1024_key_schedule(key, tweak, subkeys);
  memcpy(input_bytes, input, sizeof(input_bytes));
  avxfish(input_bytes, subkeys);

  return (memcmp(input_bytes, output, sizeof(input_bytes)) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0xb40, %rsp            # imm = 0xB40
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rsp), %r15
movq %rdx, %rdi
movq %rcx, %rsi
movq %r15, %rdx
callq 0x4025c0
movq %rsp, %r12
movl $0x80, %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x401048
movq %r12, %rdi
movq %r15, %rsi
callq 0x4016c0
movl $0x80, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x401028
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/source/memory.c
// Function: gcinit
void gcinit(int staticsz, int dynamicsz)
{
  /*
     allocate the memory areas 
   */
  staticBase = (struct object *) malloc(staticsz * sizeof(struct object));
  spaceOne = (struct object *) malloc(dynamicsz * sizeof(struct object));
  spaceTwo = (struct object *) malloc(dynamicsz * sizeof(struct object));
  if((staticBase == 0) || (spaceOne == 0) || (spaceTwo == 0))
    sysError("not enough memory for space allocations\n", 0);

  staticTop = staticBase + staticsz;
  staticPointer = staticTop;

  spaceOneSize = spaceTwoSize = dynamicsz;
  memoryBase = spaceOne;
  memoryPointer = memoryBase + spaceOneSize;
  if(lstDebugging)
  {
    printf("space one 0x%p, top 0x%p,"
           " space two 0x%p , top 0x%p\n",
           spaceOne, (spaceOne + spaceOneSize),
           spaceTwo, (spaceTwo + spaceTwoSize));
  }
  inSpaceOne = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %edi, %r14
shlq $0x4, %r14
movq %r14, %rdi
callq 0x2220
movq %rax, %r15
movq %rax, 0x4112b(%rip)     # 0x459f8
movslq %ebx, %r13
movq %r13, %rbx
shlq $0x4, %rbx
movq %rbx, %rdi
callq 0x2220
movq %rax, %r12
movq %rax, 0x410ef(%rip)     # 0x459d8
movq %rbx, %rdi
callq 0x2220
movq %rax, 0x410f0(%rip)     # 0x459e8
testq %r15, %r15
setne %cl
testq %r12, %r12
setne %dl
andb %cl, %dl
testq %rax, %rax
setne %al
testb %al, %dl
jne 0x491e
leaq 0x2a2d(%rip), %rdi      # 0x7344
xorl %esi, %esi
callq 0x4340
addq 0x410d3(%rip), %r14     # 0x459f8
movq %r14, 0x410d4(%rip)     # 0x45a00
movq %r14, 0x410d5(%rip)     # 0x45a08
movq %r13, 0x410b6(%rip)     # 0x459f0
movq %r13, 0x4109f(%rip)     # 0x459e0
movq 0x41090(%rip), %rsi     # 0x459d8
movq %rsi, 0x410c1(%rip)     # 0x45a10
leaq (%rsi,%rbx), %rdx
movq %rdx, 0x410be(%rip)     # 0x45a18
leaq 0x422f3(%rip), %rax     # 0x46c54
cmpl $0x0, (%rax)
je 0x4981
movq 0x4107b(%rip), %rcx     # 0x459e8
addq %rcx, %rbx
leaq 0x29f6(%rip), %rdi      # 0x736d
movq %rbx, %r8
xorl %eax, %eax
callq 0x2130
movb $0x1, 0x41098(%rip)     # 0x45a20
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/source/memory.c
// Function: gcexpand
void gcexpand(int multiplier)
{
  struct object *space;
  size_t spaceSize;

  /* figure out where to expand */
  if (inSpaceOne)
  {
    space = spaceTwo;
  }
  else
  {
    space = spaceOne;
  }
  spaceSize = (spaceOneSize > spaceTwoSize) ? spaceOneSize : spaceTwoSize;
  spaceSize *= multiplier;

  /* expand it */
  space = realloc(space, spaceSize * sizeof(struct object));
  if (!space)
  {
    sysError("failed to expand memory", NULL);
  }

  if (inSpaceOne)
  {
    spaceTwo = space;
    spaceTwoSize = spaceSize;
  }
  else
  {
    spaceOne = space;
    spaceOneSize = spaceSize;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x41047(%rip), %r15     # 0x459e8
cmpb $0x0, 0x41078(%rip)     # 0x45a20
leaq 0x41029(%rip), %r14     # 0x459d8
movq %r14, %rax
cmovneq %r15, %rax
movq (%rax), %rax
movq 0x41020(%rip), %rcx     # 0x459e0
movq 0x41029(%rip), %rdx     # 0x459f0
cmpq %rdx, %rcx
cmovaq %rcx, %rdx
movslq %edi, %r12
imulq %rdx, %r12
movq %r12, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x49fa
leaq 0x29af(%rip), %rdi      # 0x73a2
xorl %esi, %esi
callq 0x4340
cmpb $0x0, 0x4101f(%rip)     # 0x45a20
cmovneq %r15, %r14
leaq 0x40fe4(%rip), %rax     # 0x459f0
leaq 0x40fcd(%rip), %rcx     # 0x459e0
cmovneq %rax, %rcx
movq %rbx, (%r14)
movq %r12, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/source/memory.c
// Function: staticAllocate
struct object  *staticAllocate(int sz)
{
  staticPointer = WORDSDOWN(staticPointer, sz + 2);
  if(staticPointer < staticBase)
  {
    sysError("insufficient static memory", 0);
  }
  SETSIZE(staticPointer, sz);
  return (staticPointer);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leal (,%rbx,8), %eax
movl $0xfffffff0, %ecx       # imm = 0xFFFFFFF0
subl %eax, %ecx
movslq %ecx, %rax
addq 0x40c78(%rip), %rax     # 0x45a08
movq %rax, 0x40c71(%rip)     # 0x45a08
cmpq 0x40c5a(%rip), %rax     # 0x459f8
jae 0x4dae
leaq 0x2613(%rip), %rdi      # 0x73ba
xorl %esi, %esi
callq 0x4340
shll $0x2, %ebx
movq 0x40c50(%rip), %rax     # 0x45a08
movl %ebx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/GregorR[P]lstg/source/memory.c
// Function: staticIAllocate
struct object  *staticIAllocate(int sz)
{
  int             trueSize;
  struct object  *result;

  trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
  result = staticAllocate(trueSize);
  SETSIZE(result, sz);
  result->size |= FLAG_BIN;
  return result;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leal 0x7(%rbx), %eax
leal 0xe(%rbx), %edi
testl %eax, %eax
cmovnsl %eax, %edi
sarl $0x3, %edi
callq 0x4d75
leal 0x2(,%rbx,4), %ecx
movl %ecx, (%rax)
popq %rbx
retq