LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: do_load
static void do_load(const char *path)
{
	FILE *pf;
	char buf[1024];
	int r, i, ch, v;

	printf("Loading from %s ...\n", path);

	pf = fopen(path, "rb");
	if (pf == NULL) {
		printf("Can't open the file %s.\n", path);
		return;
	}

	v = -1;

	while ((r = fread(buf, 1, sizeof(buf), pf)) > 0) {
		for (i = 0; i < r; i++) {
			ch = buf[i];
			if (isspace(ch)) {
				if (v >= 0) {
					insert(v);
					v = -1;
				}
			}
			else if (!isdigit(ch)) {
				printf("Invalid file format %s.\n", path);
				fclose(pf);
				return;
			}
			else {
				if (v == -1)
					v = ch - '0';
				else {
					v *= 10;
					v += ch - '0';
				}
			}
		}
	}

	if (v >= 0) {
		insert(v);
		v = -1;
	}

	fclose(pf);

	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
leaq 0x16b9(%rip), %rdi      # 0x51dd
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x14cf(%rip), %rsi      # 0x5004
movq %rbx, %rdi
callq 0x1150
testq %rax, %rax
je 0x3c25
movq %rax, %r14
movq %rsp, %rdi
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %rax, %rcx
callq 0x1080
movq %rax, %rbp
testl %ebp, %ebp
jle 0x3bf8
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
callq 0x1180
movq %rax, %r15
movl %ebp, %ebp
xorl %r13d, %r13d
movsbq (%rsp,%r13), %rax
movq (%r15), %rcx
movzwl (%rcx,%rax,2), %ecx
btl $0xd, %ecx
jb 0x3bac
btl $0xb, %ecx
jae 0x3c47
cmpl $-0x1, %r12d
je 0x3bc1
leal (%r12,%r12,4), %ecx
leal (%rax,%rcx,2), %r12d
addl $-0x30, %r12d
jmp 0x3bc7
testl %r12d, %r12d
js 0x3bc7
movl %r12d, %edi
callq 0x3922
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x3bc7
addl $-0x30, %eax
movl %eax, %r12d
incq %r13
cmpq %r13, %rbp
jne 0x3b7c
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %rsp, %rdi
movq %r14, %rcx
callq 0x1080
movq %rax, %rbp
testl %ebp, %ebp
jg 0x3b77
testl %r12d, %r12d
js 0x3bf8
movl %r12d, %edi
callq 0x3922
movq %r14, %rdi
callq 0x1090
movl 0x458a(%rip), %esi      # 0x8190
leaq 0x166e(%rip), %rdi      # 0x527b
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
leaq 0x15c6(%rip), %rdi      # 0x51f2
movq %rbx, %rsi
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
leaq 0x15bd(%rip), %rdi      # 0x520b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
movq %r14, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: do_save
static void do_save(const char *path)
{
	FILE *pf;
	int r;
	struct save_state ss = { 0 };

	printf("Saving to %s ...\n", path);

	pf = fopen(path, "wb");
	if (pf == NULL) {
		printf("Can't open the file %s.\n", path);
		return;
	}

	ss.pf = pf;
	ss.i = 0;

	r = rbtree_foreach_inorder(&tree, save_node, &ss);
	if (r != 0)
		printf("Failed to write file %s.\n", path);

	fclose(pf);

	printf("%d entries.\n", entries);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x10(%rsp)
leaq 0x1599(%rip), %rdi      # 0x5224
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x13b4(%rip), %rsi      # 0x5050
movq %rbx, %rdi
callq 0x1150
testq %rax, %rax
je 0x3d07
movq %rax, %r14
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x0, 0x8(%rdx)
leaq 0x4416(%rip), %rdi      # 0x80d8
leaq 0x214(%rip), %rsi       # 0x3edd
callq 0x1963
testl %eax, %eax
je 0x3ce3
leaq 0x155d(%rip), %rdi      # 0x5236
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
movq %r14, %rdi
callq 0x1090
movl 0x449f(%rip), %esi      # 0x8190
leaq 0x1583(%rip), %rdi      # 0x527b
xorl %eax, %eax
callq 0x10b0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x14e4(%rip), %rdi      # 0x51f2
movq %rbx, %rsi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: do_bmp
static void do_bmp(const char *path, int nil)
{
	bitmap_t *bitmap;
	printf("Creating bitmap...\n");

	bitmap = rbtree_save_as_bitmap(&tree, &asc16, nil);

	if (bitmap == NULL) {
		printf("Failed to create bitmap.\n");
		return;
	}

	if (path && strlen(path) > 0) {
		if (bitmap_save(bitmap, path) != 0) {
			bitmap_free(bitmap);
			printf("Failed to save bitmap to file %s.\n", path);
			return;
		}
	}
	else {
		if (bitmap_print(bitmap, stdout) != 0) {
			bitmap_free(bitmap);
			printf("Failed to print bitmap to \"stdout\".\n");
			return;
		}
		printf("\n");
	}

	bitmap_free(bitmap);

	printf("Done. %d entries.\n", entries);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x171e(%rip), %rdi      # 0x544d
callq 0x1070
leaq 0x439d(%rip), %rdi      # 0x80d8
leaq 0x443e(%rip), %rsi      # 0x8180
movl %ebx, %edx
callq 0x1ca1
testq %rax, %rax
je 0x3db2
movq %rax, %rbx
testq %r14, %r14
je 0x3d8b
cmpb $0x0, (%r14)
je 0x3d8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f0e
testl %eax, %eax
je 0x3dcf
movq %rbx, %rdi
callq 0x24a8
leaq 0x14d8(%rip), %rdi      # 0x5252
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
movq 0x4246(%rip), %rax      # 0x7fd8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2ca7
testl %eax, %eax
je 0x3dc5
movq %rbx, %rdi
callq 0x24a8
leaq 0x16b0(%rip), %rdi      # 0x5460
jmp 0x3db9
leaq 0x16cb(%rip), %rdi      # 0x5484
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
movl $0xa, %edi
callq 0x1040
movq %rbx, %rdi
callq 0x24a8
movl 0x43b3(%rip), %esi      # 0x8190
leaq 0x1491(%rip), %rdi      # 0x5275
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: print_node
static int print_node(rbtree_t *tree, rbnode_t *n, void *state)
{
	rbpoint_t *point = container_of(n, rbpoint_t, rbentry);
	if (n->parent == NULL) {
		printf("       %4d %5s       %4d %4d\n", ptoi(n->key),
			n->color == rbnode_red ? "r" : "b",
			point->x, point->y);
	}
	else {
		printf("%6d %4d %5s %5s %4d %4d\n",
			ptoi(n->parent->key),
			ptoi(n->key),
			n->color == rbnode_red ? "r" : "b",
			n->parent->right == n ? "r" : "l",
			point->x, point->y);
	}
	return 0;
}

// Assembly:
pushq %rax
movq 0x20(%rsi), %rdi
testq %rdi, %rdi
je 0x3e47
movl (%rdi), %eax
cmpl $0x1, 0x8(%rsi)
leaq 0x126c(%rip), %r9       # 0x507b
leaq 0x11ef(%rip), %rcx      # 0x5005
cmoveq %r9, %rcx
movl (%rsi), %edx
cmpq %rsi, 0x18(%rdi)
leaq 0x1275(%rip), %r8       # 0x509c
cmoveq %r9, %r8
movl 0x38(%rsi), %r9d
movl 0x3c(%rsi), %esi
movl %esi, (%rsp)
leaq 0x134d(%rip), %rdi      # 0x5189
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
jmp 0x3e76
movl (%rsi), %eax
cmpl $0x1, 0x8(%rsi)
leaq 0x1227(%rip), %rcx      # 0x507b
leaq 0x11aa(%rip), %rdx      # 0x5005
cmoveq %rcx, %rdx
movl 0x38(%rsi), %ecx
movl 0x3c(%rsi), %r8d
leaq 0x12fe(%rip), %rdi      # 0x516b
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: do_clean
static void do_clean()
{
	printf("Cleaning...\n");
	free_rbtree(&tree);
	rbtree_init(&tree, keycmp);
	entries = 0;
	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rax
leaq 0x161b(%rip), %rdi      # 0x549d
callq 0x1070
leaq 0x424a(%rip), %rdi      # 0x80d8
leaq 0x3b(%rip), %rsi        # 0x3ed0
xorl %edx, %edx
callq 0x19cb
movq $0x0, 0x4231(%rip) # 0x80d8
leaq -0xbc(%rip), %rax       # 0x3df2
movq %rax, 0x422b(%rip)      # 0x80e0
movl $0x0, 0x42d1(%rip)      # 0x8190
leaq 0x13b5(%rip), %rdi      # 0x527b
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: save_node
static int save_node(rbtree_t *tree, rbnode_t *n, void *state)
{
	struct save_state *ss = state;
	char *key;
	int r;

	if (ss->i > 0) {
		if ((ss->i % 8) == 0) {
			if (fwrite("\n", 1, 1, ss->pf) != 1)
				return -1;
		}
		else {
			if (fwrite("\t", 1, 1, ss->pf) != 1)
				return -1;
		}
	}

    key = keytostr(n->key);

	r = strlen(key);

	if (fwrite(key, 1, r, ss->pf) != r)
		return -1;

	ss->i++;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rdx), %eax
testl %eax, %eax
jle 0x3f23
movq (%rbx), %rcx
testb $0x7, %al
je 0x3eff
leaq 0x1353(%rip), %rdi      # 0x5250
jmp 0x3f06
leaq 0x12ea(%rip), %rdi      # 0x51f0
movl $0x1, %esi
movl $0x1, %edx
callq 0x1170
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x1, %rcx
jne 0x3f73
movl (%r14), %ecx
leaq 0x4273(%rip), %r14      # 0x81a0
leaq 0x1123(%rip), %rdx      # 0x5057
movl $0x80, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10c0
movq %r14, %rdi
callq 0x10a0
movslq %eax, %r15
movq (%rbx), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1170
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %rcx
jne 0x3f73
incl 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/GangZhuo[P]rbtree/test/test.c
// Function: next_arg
static int next_arg(char *buf, int bufsize)
{
	int i, ch;
	skip_blank();
	for (i = 0, ch = getchar();
		ch != '\n' && ch != EOF && i < bufsize;
		i++, ch = getchar()) {
		if (isblank(ch))
			break;
		buf[i] = (char)ch;
	}
	if (i < bufsize)
		buf[i] = '\0';
	if (i > 0) {
		if (ch == '\n' || ch == EOF)
			ungetc('\n', stdin);
	}
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x10f0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x3fad
cmpl $0xa, %r14d
je 0x3fad
callq 0x1180
movq (%rax), %rax
movslq %r14d, %rcx
testb $0x1, (%rax,%rcx,2)
jne 0x3f89
cmpl $-0x1, %r14d
movl $0xa, %edi
cmovnel %r14d, %edi
movq 0x401f(%rip), %r12      # 0x7fe0
movq (%r12), %rsi
callq 0x1120
callq 0x10f0
movl %eax, %r15d
xorl %r13d, %r13d
testl %ebp, %ebp
movl $0x0, %r14d
cmovgl %ebp, %r14d
cmpl $-0x1, %r15d
je 0x4014
cmpl $0xa, %r15d
je 0x4014
cmpq %r13, %r14
je 0x4021
callq 0x1180
movq (%rax), %rax
movslq %r15d, %rcx
testb $0x1, (%rax,%rcx,2)
jne 0x4014
movb %r15b, (%rbx,%r13)
incq %r13
callq 0x10f0
movl %eax, %r15d
jmp 0x3fe1
cmpl %ebp, %r13d
jge 0x401e
movb $0x0, (%rbx,%r13)
movl %r13d, %r14d
testl %r14d, %r14d
je 0x4040
cmpl $0xa, %r15d
je 0x4032
cmpl $-0x1, %r15d
jne 0x4040
movq (%r12), %rsi
movl $0xa, %edi
callq 0x1120
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13d, %r13d
movq 0x3f76(%rip), %r15      # 0x7fe0
xorl %ebp, %ebp
xorl %r12d, %r12d
movl %r13d, %eax
movl %eax, %r13d
callq 0x10f0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x40ee
cmpl $0xa, %r14d
je 0x40ee
callq 0x1180
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
testb $0x1, %al
je 0x40a4
xorl %eax, %eax
testl %r13d, %r13d
je 0x4072
jmp 0x40ee
cmpl $0x2d, %r14d
je 0x40cb
cmpl $0x2b, %r14d
je 0x40cb
btl $0xb, %eax
jae 0x4165
leal (%r12,%r12,4), %eax
leal (%r14,%rax,2), %r12d
addl $-0x30, %r12d
incl %r13d
jmp 0x406f
testl %ebp, %ebp
jne 0x41a6
testl %r13d, %r13d
jg 0x41a6
xorl %eax, %eax
cmpl $0x2d, %r14d
setne %al
leal -0x1(,%rax,2), %ebp
jmp 0x406f
testl %r13d, %r13d
jle 0x4180
movl %r12d, %r13d
negl %r13d
cmpl $-0x1, %ebp
cmovnel %r12d, %r13d
cmpl $0xa, %r14d
je 0x4110
cmpl $-0x1, %r14d
jne 0x411d
movq (%r15), %rsi
movl $0xa, %edi
callq 0x1120
movl (%rbx), %ecx
movl 0x4(%rbx), %ebp
movq 0x8(%rbx), %rax
cmpl %ecx, %ebp
jg 0x4151
addl %ebp, %ebp
movl $0x8, %ecx
cmovel %ecx, %ebp
movslq %ebp, %rsi
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x1140
testq %rax, %rax
je 0x4190
movl %ebp, 0x4(%rbx)
movq %rax, 0x8(%rbx)
movl (%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movslq %ecx, %rcx
movl %r13d, (%rax,%rcx,4)
xorl %r13d, %r13d
jmp 0x406a
callq 0x10f0
cmpl $-0x1, %eax
je 0x4174
cmpl $0xa, %eax
jne 0x4165
movl $0x16, %ebp
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x4187
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %ebx, %ebx
callq 0x1060
movl %ebp, (%rax)
jmp 0x4195
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10f0
cmpl $-0x1, %eax
je 0x4174
cmpl $0xa, %eax
jne 0x41a6
jmp 0x4174
// File: /workspace/github_c_makefile_star2_O3/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 0x1449
cmpl $0x20, %eax
je 0x144e
cmpl $0x71, %eax
je 0x1442
cmpl $0x51, %eax
jne 0x145a
xorl %edi, %edi
callq 0x1060
cmpl $0xa, %eax
jne 0x145a
leaq 0x3c73(%rip), %rdi      # 0x50c8
callq 0x17e8
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x178a
movq %rax, 0x3df0(%rip)      # 0x5268
movl 0x54(%rbx), %ecx
cmpl $0x3, %ecx
je 0x14f6
cmpl $0x2, %ecx
je 0x149a
cmpl $0x1, %ecx
jne 0x1535
movl $0x1, 0x3dc8(%rip)      # 0x5260
jmp 0x1500
movq 0x3da7(%rip), %rsi      # 0x5248
leaq 0x3e58(%rip), %r15      # 0x5300
movq (%r15), %rdx
leaq 0x3c16(%rip), %r14      # 0x50c8
movq %r14, %rdi
callq 0x1848
movq 0x3d8f(%rip), %rsi      # 0x5250
movq (%r15), %rdx
movq %r14, %rdi
callq 0x1848
movl $0x2, 0x3d8a(%rip)      # 0x5260
movl 0x3bf0(%rip), %eax      # 0x50cc
subl 0x40(%rbx), %eax
movl %eax, 0x3d8b(%rip)      # 0x5270
movl 0x3be5(%rip), %eax      # 0x50d0
subl 0x44(%rbx), %eax
movl %eax, 0x3d80(%rip)      # 0x5274
jmp 0x1535
movl $0x3, 0x3d60(%rip)      # 0x5260
leaq 0x3dd9(%rip), %rcx      # 0x52e0
movq (%rcx), %rdi
leaq 0x3def(%rip), %rcx      # 0x5300
movq (%rcx), %rsi
movq 0x3d35(%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_O3/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 0x3ba1(%rip), %rax      # 0x52e0
movq (%rax), %rax
leaq 0x3bb7(%rip), %rcx      # 0x5300
movq (%rcx), %rsi
movq 0x3afd(%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_O3/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:
movl 0x40(%rdi), %ecx
movl 0x44(%rdi), %edx
movsd 0x1878(%rip), %xmm0     # 0x3010
leaq 0x3939(%rip), %rsi      # 0x50d8
xorl %eax, %eax
leaq 0x3a70(%rip), %rdi      # 0x5218
movl %ecx, %r8d
subl 0x10(%rsi), %r8d
movl %edx, %r9d
subl 0x14(%rsi), %r9d
imull %r8d, %r8d
imull %r9d, %r9d
addl %r8d, %r9d
xorps %xmm1, %xmm1
cvtsi2sd %r9, %xmm1
sqrtsd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
cmovaq %rsi, %rax
minsd %xmm0, %xmm1
addq $0x20, %rsi
movapd %xmm1, %xmm0
cmpq %rdi, %rsi
jbe 0x17a8
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x133c
testl %eax, %eax
leaq 0xd0d(%rip), %rax       # 0x202c
leaq 0xd1c(%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_O3/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 0xcb0(%rip), %rsi       # 0x2004
callq 0x1080
testq %rax, %rax
je 0x141b
movq %rax, %rbx
leaq 0xc98(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1080
testq %rax, %rax
je 0x141b
movq %rax, %r14
leaq 0xc92(%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 0x13cc
movq %r14, %rdi
callq 0x1070
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x13cc
cmpl %eax, %r12d
je 0x139a
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13e4
movq %r14, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13fc
movq %rbx, %rdi
callq 0x1070
cmpb $-0x1, %al
jne 0x13ff
movq %r14, %rdi
callq 0x1070
cmpb $-0x1, %al
je 0x13ff
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 0xbe4(%rip), %rdi       # 0x2006
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/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 0x4370
testl %eax, %eax
jns 0x3801
movl 0x10c63(%rip), %eax     # 0x14450
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x38b3
leal 0x1(%rax), %ecx
movl %ecx, 0x10c4f(%rip)     # 0x14450
movslq %eax, %r15
leaq 0x10c55(%rip), %rax     # 0x14460
movq %rbx, (%rax,%r15,8)
leaq 0xfaea(%rip), %rax      # 0x13300
movb %r14b, (%r15,%rax)
callq 0x3280
movq (%rax), %rcx
movq %rbx, %rax
movzbl (%rax), %edx
incq %rax
cmpl $0x5f, %edx
je 0x3825
movzwl (%rcx,%rdx,2), %edx
andl $0x8, %edx
jne 0x3825
movzbl -0x1(%rax), %ecx
testb %bpl, %bpl
je 0x385c
testl %ecx, %ecx
je 0x3873
cmpl $0x3d, %ecx
jne 0x38c6
leaq 0x7aae(%rip), %rcx      # 0xb300
movq %rax, (%rcx,%r15,8)
movb $0x0, -0x1(%rax)
jmp 0x3885
testl %ecx, %ecx
jne 0x38ae
leaq 0x7a99(%rip), %rax      # 0xb300
movq $0x0, (%rax,%r15,8)
xorl %eax, %eax
jmp 0x3885
leaq 0x7a86(%rip), %rcx      # 0xb300
leaq 0x2e7e(%rip), %rax      # 0x66ff
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
leaq 0x2e7f(%rip), %rdx      # 0x670e
cmovneq %rax, %rdx
leaq 0x2e67(%rip), %rdi      # 0x6701
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f0b
callq 0x32a0
leaq 0x2e34(%rip), %rsi      # 0x66ee
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
callq 0x32c5
// File: /workspace/github_c_makefile_star2_O3/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 0x6314(%rip), %r9       # 0xa2c0
movq 0x51d5(%rip), %rsi      # 0x9188
movl 0x630b(%rip), %edx      # 0xa2c4
testq %r9, %r9
jne 0x3fce
leaq 0x23a1(%rip), %rdi      # 0x6366
xorl %eax, %eax
callq 0x3100
jmp 0x3fe7
leaq 0x1032b(%rip), %rax     # 0x14300
movl (%rax,%r9,4), %r8d
leaq 0x2391(%rip), %rdi      # 0x6371
xorl %eax, %eax
callq 0x3100
callq 0x458f
leaq 0x23a0(%rip), %rsi      # 0x6393
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O3/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 0x3280
movq (%rax), %rax
movq $-0x1, %r14
movzbl 0x1(%rbx,%r14), %ecx
incq %r14
cmpl $0x5f, %ecx
je 0x438a
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
jne 0x438a
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x450e
cmpb $0x0, 0x4dca(%rip)      # 0x9180
je 0x442c
cmpb $0x1, 0x4dc2(%rip)      # 0x9181
jne 0x449d
cmpb $0x1, 0x6f24(%rip)      # 0xb2f0
jne 0x44d9
leaq 0x1e2b(%rip), %r15      # 0x6204
leaq 0x2016(%rip), %r12      # 0x63f6
cmpb $0x0, 0x10019(%rip)     # 0x14400
movq %r12, %rsi
cmovneq %r15, %rsi
movl 0x5ecc(%rip), %edx      # 0xa2c0
leaq 0x205c(%rip), %rdi      # 0x6457
xorl %eax, %eax
callq 0x30f0
movb 0x4d79(%rip), %al       # 0x9181
movb $0x1, 0xfff1(%rip)      # 0x14400
movb $0x0, 0x6eda(%rip)      # 0xb2f0
leaq 0x2049(%rip), %rsi      # 0x6466
testb $0x1, %al
cmoveq %r12, %rsi
cmovneq %r12, %r15
jmp 0x44f5
movslq 0x1001d(%rip), %rax     # 0x14450
testq %rax, %rax
jle 0x450e
movq %r14, %rcx
negq %rcx
xorl %r15d, %r15d
leaq 0x10014(%rip), %rdx     # 0x14460
movq (%rdx,%r15,8), %rsi
movq %rsi, %rdi
testq %r14, %r14
je 0x4485
leaq (%rsi,%r14), %r8
movq %rcx, %r9
movq %rbx, %r10
movq %rsi, %rdi
movzbl (%r10), %r12d
testl %r12d, %r12d
je 0x4485
movzbl (%rdi), %r11d
cmpb %r12b, %r11b
jne 0x448b
incq %rdi
incq %r10
incq %r9
jne 0x4465
movq %r8, %rdi
movzbl (%rdi), %r11d
jmp 0x448e
subl %r12d, %r11d
testl %r11d, %r11d
je 0x44ad
incq %r15
cmpq %rax, %r15
jne 0x444c
jmp 0x450e
leaq 0x1d60(%rip), %r15      # 0x6204
leaq 0x1f4b(%rip), %rsi      # 0x63f6
jmp 0x44e7
leaq 0x6e4c(%rip), %rax      # 0xb300
movq (%rax,%r15,8), %rax
testq %rax, %rax
leaq 0x1f34(%rip), %rdx      # 0x63f6
cmovneq %rax, %rdx
leaq 0x1f9b(%rip), %rdi      # 0x6468
xorl %eax, %eax
callq 0x3f0b
movl %r15d, %ebp
jmp 0x450e
leaq 0x1f16(%rip), %r15      # 0x63f6
leaq 0x1f7f(%rip), %rsi      # 0x6466
movb $0x1, 0xff12(%rip)      # 0x14400
movb $0x0, 0x6dfb(%rip)      # 0xb2f0
leaq 0x1f61(%rip), %rdi      # 0x645d
xorl %ebp, %ebp
movl %r14d, %edx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x30f0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1f40(%rip), %rdi      # 0x6476
xorl %eax, %eax
callq 0x3f0b
movb 0x4c33(%rip), %al       # 0x9176
xorb $0x1, %al
movb %al, 0x17f15(%rip)      # 0x1c460
leaq 0x471e(%rip), %rdi      # 0x8c70
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4625
movl %eax, %ebx
movl (%r14), %esi
leaq 0x1f15(%rip), %rdi      # 0x647e
xorl %eax, %eax
callq 0x3f0b
cmpl $0x16, %ebx
movl $0x2, %eax
cmovel %eax, %ebx
cmpb $0x0, 0x17ede(%rip)     # 0x1c460
cmovnel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x4bea(%rip)      # 0x9181
jne 0x45ac
cmpb $0x1, 0xfe60(%rip)      # 0x14400
jne 0x45ac
movl $0xa, %edi
callq 0x3030
movq 0x4be5(%rip), %rbx      # 0x9198
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
jne 0x45ce
movq %rbx, %rdi
callq 0x30b0
cmpl $-0x1, %eax
je 0x45ce
popq %rbx
retq
cmpb $0x1, 0x4bcb(%rip)      # 0x91a0
jne 0x460b
leaq 0x1dcd(%rip), %rdi      # 0x63ab
xorl %eax, %eax
callq 0x3090
leaq 0x4bc4(%rip), %rdi      # 0x91b0
callq 0x3060
movq 0x4b80(%rip), %rdx      # 0x9178
leaq 0x1dcd(%rip), %rsi      # 0x63cc
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
movq 0x4b66(%rip), %rdx      # 0x9178
leaq 0x1dc0(%rip), %rsi      # 0x63d9
movl $0x2, %edi
xorl %eax, %eax
callq 0x31c0
// File: /workspace/github_c_makefile_star2_O3/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: eval_table
static Linetype
eval_table(const struct ops *ops, int *valp, const char **cpp)
{
	const struct op *op;
	const char *cp;
	int val;
	Linetype lt, rt;

	debug("eval%d", ops - eval_ops);
	cp = *cpp;
	lt = ops->inner(ops+1, valp, &cp);
	if (lt == LT_ERROR)
		return (LT_ERROR);
	for (;;) {
		cp = skipcomment(cp);
		for (op = ops->op; op->str != NULL; op++)
			if (strncmp(cp, op->str, strlen(op->str)) == 0)
				break;
		if (op->str == NULL)
			break;
		cp += strlen(op->str);
		debug("eval%d %s", ops - eval_ops, op->str);
		rt = ops->inner(ops+1, &val, &cp);
		if (rt == LT_ERROR)
			return (LT_ERROR);
		lt = op->fn(valp, lt, *valp, rt, val);
	}

	*cpp = cp;
	debug("eval%d = %d", ops - eval_ops, *valp);
	debug("eval%d lt = %s", ops - eval_ops, linetype_name[lt]);
	return (lt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x462d(%rip), %rax      # 0x8c70
movq %rdi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x2e8ba2e8ba2e8ba3, %rbx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rbx
leaq 0x1e26(%rip), %rdi      # 0x6488
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3f0b
movq (%r15), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x58(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
callq *(%r12)
movl %eax, %ebp
movl $0x16, %eax
cmpl $0x16, %ebp
je 0x47c1
movq %r13, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3fff
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq 0x8(%r12), %r13
testq %r13, %r13
je 0x4785
leaq 0x18(%r12), %rax
movq %r14, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %ebp, 0x10(%rsp)
movq %rax, %rbp
movq %r13, %rdi
callq 0x30d0
movq %rax, %r14
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3070
testl %eax, %eax
je 0x4702
movq (%rbp), %r13
addq $0x10, %rbp
testq %r13, %r13
jne 0x46d6
jmp 0x477c
addq %r14, %r15
movq %r15, 0x8(%rsp)
leaq 0x1d7e(%rip), %rdi      # 0x648f
movq %rbx, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3f0b
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq *(%r12)
cmpl $0x16, %eax
je 0x47d0
movq 0x18(%rsp), %r14
movl (%r14), %edx
movl 0x14(%rsp), %r8d
movq %r14, %rdi
movl 0x10(%rsp), %esi
movl %eax, %ecx
callq *-0x8(%rbp)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0x3fff
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq 0x8(%r12), %r13
testq %r13, %r13
movq 0x20(%rsp), %rax
jne 0x46cf
jmp 0x4785
movq 0x18(%rsp), %r14
movl 0x10(%rsp), %ebp
movq 0x30(%rsp), %rax
movq %r15, (%rax)
movl (%r14), %edx
leaq 0x1d02(%rip), %rdi      # 0x6499
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3f0b
movl %ebp, %eax
leaq 0x4406(%rip), %rcx      # 0x8bb0
movq (%rcx,%rax,8), %rdx
leaq 0x1cf0(%rip), %rdi      # 0x64a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3f0b
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x16, %eax
jmp 0x47c1
// File: /workspace/github_c_makefile_star2_O3/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 0x3fff
cmpb $0x28, (%rax)
jne 0x4dd6
xorl %ebp, %ebp
movb $0x28, %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 0x3fff
subl %r14d, %ebp
je 0x4dd6
movb (%rax), %cl
testb %cl, %cl
jne 0x4da9
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x641d(%rip)      # 0xb2e8
jne 0x4f27
callq 0x458f
cmpb $0x1, 0x42c7(%rip)      # 0x91a0
jne 0x4f33
movq 0x4296(%rip), %rsi      # 0x9178
leaq 0x42c7(%rip), %rdi      # 0x91b0
callq 0x3220
cmpl $-0x1, %eax
jne 0x4f33
leaq 0x16cd(%rip), %rdi      # 0x65c7
xorl %eax, %eax
callq 0x3090
leaq 0x42a8(%rip), %rdi      # 0x91b0
callq 0x3060
movq 0x4264(%rip), %rdx      # 0x9178
leaq 0x14b1(%rip), %rsi      # 0x63cc
movl $0x2, %edi
xorl %eax, %eax
callq 0x30e0
leaq 0x168a(%rip), %rdi      # 0x65b8
callq 0x3fa1
movzbl 0x1752e(%rip), %edi     # 0x1c468
callq 0x3240
// File: /workspace/github_c_makefile_star2_O3/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
movslq 0x5051(%rip), %rax      # 0xa2c0
cmpq $0x40, %rax
jge 0x5297
cmpl $0x3f, %eax
je 0x529c
leaq 0x1(%rax), %rcx
movl %ecx, 0x503c(%rip)      # 0xa2c0
movl 0x503a(%rip), %ecx      # 0xa2c4
leaq 0xf06f(%rip), %rdx      # 0x14300
movl %ecx, 0x4(%rdx,%rax,4)
popq %rax
retq
callq 0x3040
leaq 0x12ad(%rip), %rdi      # 0x6550
callq 0x3fa1
// File: /workspace/github_c_makefile_star2_O3/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, 0x3ed0(%rip)      # 0x9180
jne 0x53cf
cmpb %dil, 0x3eb5(%rip)      # 0x9172
je 0x5378
leaq 0x5006(%rip), %rbx      # 0xa2d0
leaq 0x12d7(%rip), %rsi      # 0x65a8
movq %rbx, %rdi
callq 0x3140
movb (%rax,%rbx), %bl
testb %bl, %bl
jne 0x52fb
cmpb $0x1, 0x3e8a(%rip)      # 0x9171
jne 0x52fb
movl 0x4ec1(%rip), %eax      # 0xa1b0
cmpl 0x4ebf(%rip), %eax      # 0xa1b4
jne 0x53d7
cmpb $0x1, 0x3e75(%rip)      # 0x9177
jne 0x5338
cmpl $0x0, 0x17159(%rip)     # 0x1c464
jle 0x5338
movq 0x3e84(%rip), %rdi      # 0x9198
movl 0x4faa(%rip), %edx      # 0xa2c4
movq 0x5fbf(%rip), %rcx      # 0xb2e0
leaq 0x1285(%rip), %rsi      # 0x65ad
xorl %eax, %eax
callq 0x3180
testl %eax, %eax
jns 0x5338
callq 0x458f
movq 0x3e59(%rip), %rsi      # 0x9198
leaq 0x4f8a(%rip), %rdi      # 0xa2d0
callq 0x3130
cmpl $-0x1, %eax
jne 0x5355
callq 0x458f
movl 0x4e55(%rip), %eax      # 0xa1b0
incl %eax
xorl %ecx, %ecx
testb %bl, %bl
movl %ecx, 0x170fd(%rip)     # 0x1c464
cmovnel %ecx, %eax
movl %eax, 0x4e40(%rip)      # 0xa1b0
movl %eax, 0x4e3e(%rip)      # 0xa1b4
jmp 0x53b5
cmpb $0x1, 0x3df1(%rip)      # 0x9170
jne 0x539e
movq 0x5f58(%rip), %rdi      # 0xb2e0
movq 0x3e09(%rip), %rsi      # 0x9198
callq 0x3130
cmpl $-0x1, %eax
jne 0x539e
callq 0x458f
movb $0x1, 0x170c3(%rip)     # 0x1c468
incl 0x170b9(%rip)           # 0x1c464
movl $0x0, 0x4dfb(%rip)      # 0xa1b0
cmpb $0x1, 0x3db7(%rip)      # 0x9173
jne 0x53cf
movq 0x3dd3(%rip), %rdi      # 0x9198
callq 0x31d0
cmpl $-0x1, %eax
je 0x53d1
popq %rbx
retq
popq %rbx
jmp 0x458f
incl 0x17087(%rip)           # 0x1c464
incl %eax
movl %eax, 0x4dcb(%rip)      # 0xa1b0
jmp 0x53b5
// File: /workspace/github_c_makefile_star2_O3/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, %rax
shlq $0x4, %rax
leaq (%r12,%rax), %r14
movq (%r12,%rax), %rsi
movq %rbx, %rdi
callq 0xc0a0
testl %eax, %eax
jle 0xc58e
movq %rbp, %r13
jmp 0xc593
movq %rbp, %r15
jns 0xc5a0
cmpq %r15, %r13
jb 0xc562
callq 0xc120
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x18(%rdi), %rdi
movq 0x20(%r13), %rbx
testq %rbx, %rbx
je 0xc641
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
cmpq %r12, -0x10(%rcx)
jne 0xc632
cmpq %r15, -0x8(%rcx)
jne 0xc632
cmpq %r14, (%rcx)
je 0xc695
incq %rax
addq $0x2018, %rcx           # imm = 0x2018
cmpq %rax, %rbx
jne 0xc621
leaq 0x1(%rbx), %rax
movq %rax, 0x20(%r13)
imulq $0x2018, %rbx, %rbp     # imm = 0x2018
leaq 0x2018(%rbp), %rsi
callq 0xc0d0
movq %rax, 0x18(%r13)
leaq (%rax,%rbp), %r13
addq $0x18, %r13
movl $0x2000, %edx           # imm = 0x2000
movq %r13, %rdi
xorl %esi, %esi
callq 0xc070
movq %r12, -0x18(%r13)
movq %r15, -0x10(%r13)
movq %r14, -0x8(%r13)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc683
// File: /workspace/github_c_makefile_star2_O3/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 0xc6d5
movq 0x18(%rdi), %rdi
addq $0x10, %rdi
xorl %r9d, %r9d
cmpq %rsi, -0x10(%rdi)
jne 0xc6c6
cmpq %rdx, -0x8(%rdi)
jne 0xc6c6
cmpq %rcx, (%rdi)
je 0xc6d6
incq %r9
addq $0x2018, %rdi           # imm = 0x2018
cmpq %r9, %r8
jne 0xc6b5
retq
movq %r9, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc5f7
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 0xc74e
incq %rbp
movq %rbp, (%r14)
cmpq %r15, 0x8(%r14)
ja 0xc75b
incq %r15
movq %r15, 0x8(%r14)
cmpq %rbx, 0x10(%r14)
ja 0xc768
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_O3/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:
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0xc7ba
movq %rsi, %r9
shrq $0x4, %r9
movq %rdx, %r10
shrq $0x4, %r10
movq %rcx, %r11
shrq $0x4, %r11
movq 0x18(%rdi), %rax
xorl %edi, %edi
cmpq %r9, (%rax)
jne 0xc7ac
cmpq %r10, 0x8(%rax)
jne 0xc7ac
cmpq %r11, 0x10(%rax)
je 0xc7bd
incq %rdi
addq $0x2018, %rax           # imm = 0x2018
cmpq %rdi, %r8
jne 0xc79b
xorl %eax, %eax
retq
testq %rdi, %rdi
js 0xc7ba
andl $0xf, %esi
andl $0xf, %edx
shll $0x8, %edx
shll $0x4, %ecx
movzbl %cl, %ecx
orl %edx, %ecx
orq %rsi, %rcx
movb 0x18(%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0xc81e
movq %rsi, %r9
shrq $0x4, %r9
movq %rdx, %r10
shrq $0x4, %r10
movq %rcx, %r11
shrq $0x4, %r11
movq 0x18(%rdi), %rax
xorl %edi, %edi
cmpq %r9, (%rax)
jne 0xc810
cmpq %r10, 0x8(%rax)
jne 0xc810
cmpq %r11, 0x10(%rax)
je 0xc821
incq %rdi
addq $0x2018, %rax           # imm = 0x2018
cmpq %rdi, %r8
jne 0xc7ff
xorl %eax, %eax
retq
testq %rdi, %rdi
js 0xc81e
andl $0xf, %esi
andl $0xf, %edx
shll $0x8, %edx
shll $0x4, %ecx
movzbl %cl, %ecx
orl %edx, %ecx
orq %rsi, %rcx
movb 0x1018(%rax,%rcx), %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc959
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xc963
movq %rax, %r15
movzbl (%rdi), %eax
cmpq $0x20, %rax
ja 0xc98b
btq %rax, %r13
jae 0xc98b
movq (%rbx), %rax
incq %rax
movzbl -0x1(%r14,%rax), %ecx
cmpq $0x20, %rcx
ja 0xc943
btq %rcx, %r13
jb 0xc948
movq %rax, (%rbx)
jmp 0xc92e
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0xc1b8
jmp 0xc96b
movq %r12, %rdi
callq 0xc17a
xorl %r15d, %r15d
movq 0x11683(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x6c4(%rip), %rsi       # 0xd043
movq %r14, %rdx
xorl %eax, %eax
callq 0xc0b0
jmp 0xc92b
callq 0xc13c
jmp 0xc96e
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
xorl %eax, %eax
movzbl (%rbx,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xc9b9
cmpl $0x20, %ecx
jne 0xc9be
incq %rax
jmp 0xc9a8
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc8d5
movq %rax, %r15
movq (%r12), %rax
movzbl (%rbx,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xc9ea
cmpl $0x20, %ecx
jne 0xc9ef
incq %rax
jmp 0xc9d9
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc8d5
movq %rax, %r12
movq (%r13), %rax
movzbl (%rbx,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xca1b
cmpl $0x20, %ecx
jne 0xca20
incq %rax
jmp 0xca0a
leaq 0x10(%rsp), %rbp
movq %rax, (%rbp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xc8d5
movq %rax, %r13
addq (%rbp), %rbx
movb (%rbx), %al
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0xca4d
cmpl $0x20, %ecx
jne 0xca52
incq %rbx
jmp 0xca3b
leaq 0x1(%rbx), %rcx
movabsq $0x100000601, %rdx      # imm = 0x100000601
cmpb $0x20, %al
ja 0xca6d
movzbl %al, %eax
btq %rax, %rdx
jb 0xca74
movb (%rcx), %al
incq %rcx
jmp 0xca60
movb $0x0, -0x1(%rcx)
movq %rbx, %rdi
callq 0xc53d
testq %rax, %rax
jne 0xcab7
movq 0x1156c(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
leaq 0x5f4(%rip), %rsi       # 0xd08a
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbx, %r9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc0b0
movq %rax, %rbp
movzbl 0x8(%rax), %r8d
movzbl 0x9(%rax), %r9d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xc6da
movq 0x1151c(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movzbl 0x8(%rbp), %r9d
movzbl 0x9(%rbp), %eax
movl %eax, (%rsp)
leaq 0x5c1(%rip), %rsi       # 0xd0b3
movq %r15, %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