LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x5557
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5529
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x1b2e(%rip), %rdi      # 0x7036
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1160
cmpq $0x1, %rax
je 0x5527
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x55b2
jmp 0x5555
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x1e8e(%rip), %rdi      # 0x73c5
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1160
cmpq $0x1, %rax
je 0x5553
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x55b2
jmp 0x5555
jmp 0x5557
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x55c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1080
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x34(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1160
movslq -0x34(%rbp), %rcx
cmpq %rcx, %rax
je 0x559e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x55b2
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x5ed0
movl $0x0, -0x10(%rbp)
callq 0x10d0
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0xa, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x5c45
xorl %eax, %eax
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x5c45
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5c4e
jmp 0x5c8b
callq 0x1170
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5c68
jmp 0x5c8b
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
callq 0x10d0
movl %eax, -0x14(%rbp)
jmp 0x5c23
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5c9f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x10(%rbp)
jle 0x5cc7
cmpl $0xa, -0x14(%rbp)
je 0x5cb1
cmpl $-0x1, -0x14(%rbp)
jne 0x5cc5
movq 0x4328(%rip), %rax      # 0x9fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1100
jmp 0x5cc7
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5f50
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x5d7b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x5d58
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x5d19
movl $0x8, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x2, %rsi
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5d42
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d9a
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x5cdc
cmpl $0x0, -0x14(%rbp)
je 0x5d94
callq 0x1050
cmpl $-0x1, (%rax)
jne 0x5d94
movl $0x0, -0x4(%rbp)
jmp 0x5d9a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_insert
static void do_insert(array_t *values)
{
	int i;
	for (i = 0; i < values->entries; i++) {
		insert(values->array[i]);
	}
	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ded
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x4bf0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5dc3
movl 0x438d(%rip), %esi      # 0xa180
leaq 0x1649(%rip), %rdi      # 0x7443
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_delete
static void do_delete(array_t *values)
{
	int i;
	for (i = 0; i < values->entries; i++) {
		delete(values->array[i]);
	}
	printf("%d entries.\n", entries);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5e4d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x4cb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e23
movl 0x432d(%rip), %esi      # 0xa180
leaq 0x15e9(%rip), %rdi      # 0x7443
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: do_lookup
static void do_lookup(array_t *values)
{
	int i;
	printf("parent node color   dir    x    y\n");
	for (i = 0; i < values->entries; i++) {
		lookup(values->array[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1471(%rip), %rdi      # 0x72f4
movb $0x0, %al
callq 0x1090
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5ebb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x4d50
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e91
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: skip_blank
static void skip_blank()
{
	int ch;
	while ((ch = getchar()) != '\n' && ch != EOF && isblank(ch));
	if (ch == EOF)
		ch = '\n';
	ungetc(ch, stdin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x10d0
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x5(%rbp)
je 0x5f13
xorl %eax, %eax
cmpl $-0x1, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x5f13
callq 0x1170
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x5f1c
jmp 0x5f1e
jmp 0x5ed8
cmpl $-0x1, -0x4(%rbp)
jne 0x5f2b
movl $0xa, -0x4(%rbp)
movl -0x4(%rbp), %edi
movq 0x40ab(%rip), %rax      # 0x9fe0
movq (%rax), %rsi
callq 0x1100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]rbtree/test/test.c
// Function: next_value
static int next_value(int *pv)
{
	int nread = 0, negative = 0, ch, v = 0;
	while ((ch = getchar()) != '\n' && ch != EOF) {
		if (isblank(ch)) {
			if (nread == 0)
				continue;
			else
				break;
		}
		else if (ch == '-' || ch == '+') {
			if (negative || nread > 0) {
				clean_input_buffer();
				errno = EINVAL;
				return -1;
			}
			negative = ((ch == '-') ? -1 : 1);
		}
		else if (isdigit(ch)) {
			v *= 10;
			v += ch - '0';
			nread++;
		}
		else {
			clean_input_buffer();
			errno = EINVAL;
			return -1;
		}
	}
	if (nread > 0) {
		if (negative == -1)
			v = -v;
		*pv = v;
		if (ch == '\n' || ch == EOF)
			ungetc('\n', stdin);
		return 0;
	}
	errno = EOF;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
callq 0x10d0
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x5f8f
cmpl $-0x1, -0x1c(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5f9b
jmp 0x6066
callq 0x1170
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5fc0
cmpl $0x0, -0x14(%rbp)
jne 0x5fbb
jmp 0x5f71
jmp 0x6066
cmpl $0x2d, -0x1c(%rbp)
je 0x5fcc
cmpl $0x2b, -0x1c(%rbp)
jne 0x600c
cmpl $0x0, -0x18(%rbp)
jne 0x5fd8
cmpl $0x0, -0x14(%rbp)
jle 0x5ff4
callq 0x60d0
callq 0x1050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60be
movl -0x1c(%rbp), %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2d, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x605f
callq 0x1170
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x6044
imull $0xa, -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x30, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x605d
callq 0x60d0
callq 0x1050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60be
jmp 0x605f
jmp 0x6061
jmp 0x5f71
cmpl $0x0, -0x14(%rbp)
jle 0x60ac
cmpl $-0x1, -0x18(%rbp)
jne 0x607a
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0xa, -0x1c(%rbp)
je 0x608f
cmpl $-0x1, -0x1c(%rbp)
jne 0x60a3
movq 0x3f4a(%rip), %rax      # 0x9fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1100
movl $0x0, -0x4(%rbp)
jmp 0x60be
callq 0x1050
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %r8, %rcx
callq 0x1050
movsbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xa, %eax
je 0x1539
jmp 0x1514
movl -0x10(%rbp), %eax
subl $0x20, %eax
je 0x1539
jmp 0x151e
movl -0x10(%rbp), %eax
subl $0x51, %eax
je 0x1532
jmp 0x1528
movl -0x10(%rbp), %eax
subl $0x71, %eax
jne 0x1545
jmp 0x1532
xorl %edi, %edi
callq 0x1060
leaq 0x3b90(%rip), %rdi      # 0x50d0
callq 0x1a10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1950
movq %rax, 0x3cfc(%rip)      # 0x5268
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x1598
jmp 0x157d
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x15b3
jmp 0x1587
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x161f
jmp 0x1635
movl $0x1, 0x3cbe(%rip)      # 0x5260
movq 0x3cbf(%rip), %rdi      # 0x5268
callq 0x1880
jmp 0x1635
movq 0x3c8e(%rip), %rsi      # 0x5248
leaq 0x3d3f(%rip), %rax      # 0x5300
movq (%rax), %rdx
leaq 0x3b05(%rip), %rdi      # 0x50d0
callq 0x1ab0
movq 0x3c79(%rip), %rsi      # 0x5250
leaq 0x3d22(%rip), %rax      # 0x5300
movq (%rax), %rdx
leaq 0x3ae8(%rip), %rdi      # 0x50d0
callq 0x1ab0
movl $0x2, 0x3c69(%rip)      # 0x5260
movl 0x3ad7(%rip), %eax      # 0x50d4
movq -0x8(%rbp), %rcx
subl 0x40(%rcx), %eax
movl %eax, 0x3c66(%rip)      # 0x5270
movl 0x3ac8(%rip), %eax      # 0x50d8
movq -0x8(%rbp), %rcx
subl 0x44(%rcx), %eax
movl %eax, 0x3c57(%rip)      # 0x5274
jmp 0x1635
movl $0x3, 0x3c37(%rip)      # 0x5260
movq 0x3c38(%rip), %rdi      # 0x5268
callq 0x1880
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x3a4d(%rip), %rax      # 0x52e0
movq (%rax), %rdi
leaq 0x3a63(%rip), %rax      # 0x5300
movq (%rax), %rsi
movq 0x39a9(%rip), %rdx      # 0x5250
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x10(%rax), %r9d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rax), %eax
movl %eax, (%rsp)
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/stickman.c
// Function: FindDistance
double FindDistance(int x, int y, RayPtr rayp) {
	int a, b;
	double asq, bsq, retval;

	a=x-rayp->x;
	b=y-rayp->y;

	asq=a*a;
	bsq=b*b;

	retval=sqrt (asq+bsq);

	return (retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
callq 0x1150
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x20, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x28(%rbp)
movsd 0x1689(%rip), %xmm0     # 0x3010
movsd %xmm0, -0x18(%rbp)
leaq 0x373d(%rip), %rax      # 0x50d0
addq $0x10, %rax
movq %rax, -0x30(%rbp)
leaq 0x372e(%rip), %rax      # 0x50d0
addq $0x150, %rax            # imm = 0x150
cmpq %rax, -0x30(%rbp)
ja 0x19f7
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x18e0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19e4
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x19e6
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x199b
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x40(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11b0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0xff, %rcx
movq %rcx, -0x28(%rbp)
addq $0x1fe, %rax            # imm = 0x1FE
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1410
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x13ec
leaq 0xc21(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
jmp 0x13fa
leaq 0xc28(%rip), %rdi       # 0x201b
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xbfd(%rip), %rsi       # 0x202f
callq 0x1080
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1456
leaq 0xbe9(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x1090
movq -0x10(%rbp), %rdi
leaq 0xbce(%rip), %rsi       # 0x202f
callq 0x1080
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1485
leaq 0xbba(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
callq 0x1090
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xbb0(%rip), %rdi       # 0x2044
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1060
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x29(%rbp)
je 0x14cc
movq -0x20(%rbp), %rdi
callq 0x1060
movb %al, -0x22(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x14d5
jmp 0x14ea
movsbl -0x21(%rbp), %eax
movsbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jne 0x14e3
jmp 0x149b
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1512
movq -0x20(%rbp), %rdi
callq 0x1060
movb %al, -0x22(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x153a
movq -0x18(%rbp), %rdi
callq 0x1060
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
jne 0x1541
movq -0x20(%rbp), %rdi
callq 0x1060
movb %al, -0x22(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1541
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, -0x1(%rbp)
andb $0x1, %al
movb %al, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x47e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3862
cmpl $0x1000, 0x10c07(%rip)  # imm = 0x1000
jl 0x384e
movl $0x2, %edi
leaq 0x2e8f(%rip), %rsi      # 0x66d6
movb $0x0, %al
callq 0x30e0
movl 0x10bec(%rip), %eax     # 0x14440
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x10be1(%rip)     # 0x14440
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x10bdf(%rip), %rax     # 0x14450
movq %rdx, (%rax,%rcx,8)
movb -0x1(%rbp), %dl
movslq -0x14(%rbp), %rcx
andb $0x1, %dl
leaq 0xfa7a(%rip), %rax      # 0x13300
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x2(%rbp)
je 0x390e
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x38e1
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movslq -0x14(%rbp), %rcx
leaq 0x7a2c(%rip), %rax      # 0xb300
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x390c
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3905
movslq -0x14(%rbp), %rcx
leaq 0x7a08(%rip), %rax      # 0xb300
leaq 0x2de8(%rip), %rdx      # 0x66e7
movq %rdx, (%rax,%rcx,8)
jmp 0x390a
callq 0x39a0
jmp 0x390c
jmp 0x3932
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x391f
callq 0x39a0
movslq -0x14(%rbp), %rcx
leaq 0x79d6(%rip), %rax      # 0xb300
movq $0x0, (%rax,%rcx,8)
movslq -0x14(%rbp), %rcx
leaq 0x10b13(%rip), %rax     # 0x14450
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x79b0(%rip), %rax      # 0xb300
cmpq $0x0, (%rax,%rcx,8)
je 0x396c
movslq -0x14(%rbp), %rcx
leaq 0x799e(%rip), %rax      # 0xb300
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x3979
leaq 0x2d83(%rip), %rax      # 0x66f6
movq %rax, -0x38(%rbp)
jmp 0x3979
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x2d61(%rip), %rdi      # 0x66e9
movb $0x0, %al
callq 0x4020
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: version
static void
version(void)
{
	const char *c = copyright;
	for (;;) {
		while (*++c != '$')
			if (*c == '\0')
				exit(0);
		while (*++c != '$')
			putc(*c, stderr);
		putc('\n', stderr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2721(%rip), %rax      # 0x6100
movq %rax, -0x8(%rbp)
jmp 0x39e5
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x24, %eax
je 0x3a12
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3a10
xorl %edi, %edi
callq 0x3250
jmp 0x39e5
jmp 0x3a14
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x24, %eax
je 0x3a44
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
movq 0x55be(%rip), %rax      # 0x8ff8
movq (%rax), %rsi
callq 0x3180
jmp 0x3a14
movq 0x55ad(%rip), %rax      # 0x8ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3180
jmp 0x39e3
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: process
static void
process(void)
{
	/* When compressing blank lines, act as if the file
	   is preceded by a large number of blank lines. */
	blankmax = blankcount = 1000;
	for (;;) {
		Linetype lineval = parseline();
		trans_table[ifstate[depth]][lineval]();
		debug("process line %d %s -> %s depth %d",
		    linenum, linetype_name[lineval],
		    ifstate_name[ifstate[depth]], depth);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x3e8, 0x673e(%rip)    # imm = 0x3E8
movl $0x3e8, 0x6738(%rip)    # imm = 0x3E8
callq 0x3b00
movl %eax, -0x4(%rbp)
movslq 0x6835(%rip), %rcx      # 0xa2c0
leaq 0x672e(%rip), %rax      # 0xa1c0
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x4932(%rip), %rax      # 0x83d0
imulq $0xb8, %rcx, %rcx
addq %rcx, %rax
movl -0x4(%rbp), %ecx
callq *(%rax,%rcx,8)
movl 0x6810(%rip), %esi      # 0xa2c4
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x5040(%rip), %rax      # 0x8b00
movq (%rax,%rcx,8), %rdx
movslq 0x67f5(%rip), %rcx      # 0xa2c0
leaq 0x66ee(%rip), %rax      # 0xa1c0
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x50e2(%rip), %rax      # 0x8bc0
movq (%rax,%rcx,8), %rcx
movl 0x67d7(%rip), %r8d      # 0xa2c0
leaq 0x27ef(%rip), %rdi      # 0x62df
movb $0x0, %al
callq 0x4020
jmp 0x3a7c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: debug
static void
debug(const char *msg, ...)
{
	va_list ap;

	if (debugging) {
		va_start(ap, msg);
		vwarnx(msg, ap);
		va_end(ap);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x4055
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
testb $0x1, 0x50f0(%rip)      # 0x9173
je 0x40ba
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x30c0
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x61dd(%rip)      # 0xa2c0
jne 0x4106
movq 0x509c(%rip), %rsi      # 0x9188
movl 0x61d2(%rip), %edx      # 0xa2c4
movq -0x8(%rbp), %rcx
leaq 0x2239(%rip), %rdi      # 0x6336
movb $0x0, %al
callq 0x3110
jmp 0x413e
movq 0x507b(%rip), %rsi      # 0x9188
movl 0x61b1(%rip), %edx      # 0xa2c4
movq -0x8(%rbp), %rcx
movslq 0x61a2(%rip), %rdi      # 0xa2c0
leaq 0x101db(%rip), %rax     # 0x14300
movl (%rax,%rdi,4), %r8d
movl 0x6190(%rip), %r9d      # 0xa2c0
leaq 0x220a(%rip), %rdi      # 0x6341
movb $0x0, %al
callq 0x3110
callq 0x4a50
movl $0x2, %edi
leaq 0x2214(%rip), %rsi      # 0x6363
movb $0x0, %al
callq 0x30e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/unifdef/unifdef.c
// Function: strlcmp
static int
strlcmp(const char *s, const char *t, size_t n)
{
	while (n-- && *t != '\0')
		if (*s != *t)
			return ((unsigned char)*s - (unsigned char)*t);
		else
			++s, ++t;
	return ((unsigned char)*s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0x477a
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4783
jmp 0x47c4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x47aa
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x47ce
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4750
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x480f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4988
testb $0x1, 0x496a(%rip)      # 0x9180
je 0x48ce
testb $0x1, 0x495e(%rip)      # 0x9181
je 0x485d
testb $0x1, 0x6ac4(%rip)      # 0xb2f0
je 0x485d
movb 0x4924(%rip), %cl       # 0x9158
leaq 0x1d53(%rip), %rsi      # 0x658e
leaq 0x1b92(%rip), %rax      # 0x63d4
testb $0x1, %cl
cmovneq %rax, %rsi
movl 0x5a71(%rip), %edx      # 0xa2c0
leaq 0x1be6(%rip), %rdi      # 0x643c
movb $0x0, %al
callq 0x3100
movb $0x0, 0x48f4(%rip)      # 0x9158
movb $0x0, 0x6a85(%rip)      # 0xb2f0
movb 0x4910(%rip), %cl       # 0x9181
leaq 0x1b5c(%rip), %rsi      # 0x63d4
leaq 0x1d4d(%rip), %rax      # 0x65cc
testb $0x1, %cl
cmovneq %rax, %rsi
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movb 0x48e3(%rip), %dil      # 0x9181
leaq 0x1ce9(%rip), %r8       # 0x658e
leaq 0x1b28(%rip), %rax      # 0x63d4
testb $0x1, %dil
cmovneq %rax, %r8
leaq 0x1b87(%rip), %rdi      # 0x6442
movb $0x0, %al
callq 0x3100
movl $0x0, -0x4(%rbp)
jmp 0x4988
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xfb62(%rip), %eax      # 0x14440
jge 0x4981
movslq -0x1c(%rbp), %rcx
leaq 0xfb61(%rip), %rax      # 0x14450
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x4740
cmpl $0x0, %eax
jne 0x4971
movslq -0x1c(%rbp), %rcx
leaq 0xfb39(%rip), %rax      # 0x14450
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x69d6(%rip), %rax      # 0xb300
cmpq $0x0, (%rax,%rcx,8)
je 0x4946
movslq -0x1c(%rbp), %rcx
leaq 0x69c4(%rip), %rax      # 0xb300
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x4953
leaq 0x1a87(%rip), %rax      # 0x63d4
movq %rax, -0x30(%rbp)
jmp 0x4953
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq 0x1ae9(%rip), %rdi      # 0x644b
movb $0x0, %al
callq 0x4020
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4988
jmp 0x4973
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x48d5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x1a98(%rip), %rdi      # 0x6459
movb $0x0, %al
callq 0x4020
movb 0x47a8(%rip), %dl       # 0x9176
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x17a67(%rip)      # 0x1c450
movq -0x8(%rbp), %rdx
leaq 0x427c(%rip), %rdi      # 0x8c70
leaq -0x10(%rbp), %rsi
callq 0x4af0
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %esi
leaq 0x1a57(%rip), %rdi      # 0x6461
movb $0x0, %al
callq 0x4020
testb $0x1, 0x17a38(%rip)     # 0x1c450
je 0x4a24
movl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a40
cmpl $0x16, -0xc(%rbp)
jne 0x4a34
movl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x4a3a
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
testb $0x1, 0x4726(%rip)      # 0x9181
je 0x4a74
testb $0x1, 0x46f4(%rip)      # 0x9158
jne 0x4a74
leaq 0x1b21(%rip), %rdi      # 0x658e
movb $0x0, %al
callq 0x3100
movq 0x471d(%rip), %rdi      # 0x9198
callq 0x30a0
cmpl $0x0, %eax
jne 0x4a96
movq 0x470c(%rip), %rdi      # 0x9198
callq 0x30b0
cmpl $-0x1, %eax
jne 0x4aed
testb $0x1, 0x4703(%rip)      # 0x91a0
je 0x4ad3
leaq 0x18d5(%rip), %rdi      # 0x637b
movb $0x0, %al
callq 0x3090
leaq 0x46fc(%rip), %rdi      # 0x91b0
callq 0x3050
movq 0x46b8(%rip), %rdx      # 0x9178
movl $0x2, %edi
leaq 0x18d0(%rip), %rsi      # 0x639c
movb $0x0, %al
callq 0x30e0
movq 0x469e(%rip), %rdx      # 0x9178
movl $0x2, %edi
leaq 0x18c3(%rip), %rsi      # 0x63a9
movb $0x0, %al
callq 0x31d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0x554e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x55c5
jmp 0x5550
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x5565
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x557a
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x4160
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x55a6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x5550
cmpl $0x0, -0x1c(%rbp)
jne 0x55bd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x55c5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpl $0x0, 0x5c0d(%rip)      # 0xb2e8
je 0x56e9
leaq 0xeb7(%rip), %rdi       # 0x659b
callq 0x40d0
callq 0x4a50
testb $0x1, 0x3aab(%rip)      # 0x91a0
je 0x5743
movq 0x3a7a(%rip), %rsi      # 0x9178
leaq 0x3aab(%rip), %rdi      # 0x91b0
callq 0x3230
cmpl $-0x1, %eax
jne 0x5743
leaq 0xe94(%rip), %rdi       # 0x65aa
movb $0x0, %al
callq 0x3090
leaq 0x3a8c(%rip), %rdi      # 0x91b0
callq 0x3050
movq 0x3a48(%rip), %rdx      # 0x9178
movl $0x2, %edi
leaq 0xc60(%rip), %rsi       # 0x639c
movb $0x0, %al
callq 0x30e0
movl 0x16d0f(%rip), %edi     # 0x1c458
callq 0x3250
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpl $0x3f, 0x4925(%rip)     # 0xa2c0
jle 0x59a2
callq 0x3030
cmpl $0x3f, 0x4917(%rip)     # 0xa2c0
jne 0x59b7
leaq 0xb81(%rip), %rdi       # 0x6533
callq 0x40d0
movl 0x4903(%rip), %eax      # 0xa2c0
addl $0x1, %eax
movl %eax, 0x48fa(%rip)      # 0xa2c0
movl 0x48f8(%rip), %edx      # 0xa2c4
movslq 0x48ed(%rip), %rcx      # 0xa2c0
leaq 0xe926(%rip), %rax      # 0x14300
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, 0x3789(%rip)      # 0x9180
je 0x59fe
jmp 0x5b82
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x3766(%rip), %cl       # 0x9172
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x5b1a
leaq 0x48ac(%rip), %rdi      # 0xa2d0
leaq 0xb60(%rip), %rsi       # 0x658b
callq 0x3150
movq %rax, %rcx
leaq 0x4896(%rip), %rax      # 0xa2d0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x2(%rbp)
je 0x5a89
testb $0x1, 0x371b(%rip)      # 0x9171
je 0x5a89
movl 0x4752(%rip), %eax      # 0xa1b0
cmpl 0x4750(%rip), %eax      # 0xa1b4
je 0x5a89
movl 0x169e8(%rip), %eax     # 0x1c454
addl $0x1, %eax
movl %eax, 0x169df(%rip)     # 0x1c454
movl 0x4735(%rip), %eax      # 0xa1b0
addl $0x1, %eax
movl %eax, 0x472c(%rip)      # 0xa1b0
jmp 0x5b18
testb $0x1, 0x36e7(%rip)      # 0x9177
je 0x5ac7
cmpl $0x0, 0x169bb(%rip)     # 0x1c454
jle 0x5ac7
movq 0x36f6(%rip), %rdi      # 0x9198
movl 0x481c(%rip), %edx      # 0xa2c4
movq 0x5831(%rip), %rcx      # 0xb2e0
leaq 0xada(%rip), %rsi       # 0x6590
movb $0x0, %al
callq 0x3190
cmpl $0x0, %eax
jge 0x5ac7
callq 0x4a50
movq 0x36ca(%rip), %rsi      # 0x9198
leaq 0x47fb(%rip), %rdi      # 0xa2d0
callq 0x3140
cmpl $-0x1, %eax
jne 0x5ae4
callq 0x4a50
movl $0x0, 0x16966(%rip)     # 0x1c454
testb $0x1, -0x2(%rbp)
je 0x5b02
movl 0x46b6(%rip), %eax      # 0xa1b0
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5b09
xorl %eax, %eax
movl %eax, -0x8(%rbp)
jmp 0x5b09
movl -0x8(%rbp), %eax
movl %eax, 0x469e(%rip)      # 0xa1b0
movl %eax, 0x469c(%rip)      # 0xa1b4
jmp 0x5b63
testb $0x1, 0x364f(%rip)      # 0x9170
je 0x5b40
movq 0x57b6(%rip), %rdi      # 0xb2e0
movq 0x3667(%rip), %rsi      # 0x9198
callq 0x3140
cmpl $-0x1, %eax
jne 0x5b40
callq 0x4a50
movl $0x1, 0x1690e(%rip)     # 0x1c458
movl 0x16904(%rip), %eax     # 0x1c454
addl $0x1, %eax
movl %eax, 0x168fb(%rip)     # 0x1c454
movl $0x0, 0x464d(%rip)      # 0xa1b0
testb $0x1, 0x3609(%rip)      # 0x9173
je 0x5b82
movq 0x3625(%rip), %rdi      # 0x9198
callq 0x31e0
cmpl $-0x1, %eax
jne 0x5b82
callq 0x4a50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/rotozoom.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Rotozoom";

    scg_app_t app;
    scg_app_init(&app, config);

    scg_image_t *src_image = scg_image_new_from_bmp("assets/2ndreal.bmp");
    if (src_image == NULL) {
        return -1;
    }

    while (scg_app_process_events(&app)) {
        float32_t scale = 0.5f + sinf(app.elapsed_time * 0.5f) * 2.0f;
        float32_t angle = app.elapsed_time;
        draw(app.draw_target, src_image, angle, scale);

        scg_app_present(&app);
    }

    scg_image_free(src_image);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49e0
leaq 0xe83(%rip), %rax       # 0x758c
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a30
leaq 0xe68(%rip), %rdi       # 0x75a2
callq 0x2c10
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x675c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67fa
jmp 0x675e
leaq -0xa0(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x6770
jmp 0x67db
movss 0x88c(%rip), %xmm0      # 0x7004
mulss -0x98(%rbp), %xmm0
callq 0x21d0
addss %xmm0, %xmm0
movss 0x873(%rip), %xmm1      # 0x7004
addss %xmm1, %xmm0
movss %xmm0, -0xac(%rbp)
movss -0x98(%rbp), %xmm0
movss %xmm0, -0xb0(%rbp)
movq -0x68(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movss -0xb0(%rbp), %xmm0
movss -0xac(%rbp), %xmm1
callq 0x6810
leaq -0xa0(%rbp), %rdi
callq 0x5800
jmp 0x675e
movq -0xa8(%rbp), %rdi
callq 0x4670
leaq -0xa0(%rbp), %rdi
callq 0x5cb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
andq %rcx, %rax
sarq $0x18, %rax
movb %al, -0x10(%rbp)
movslq -0xc(%rbp), %rax
andq $0xff0000, %rax         # imm = 0xFF0000
sarq $0x10, %rax
movb %al, -0xf(%rbp)
movslq -0xc(%rbp), %rax
andq $0xff00, %rax           # imm = 0xFF00
sarq $0x8, %rax
movb %al, -0xe(%rbp)
movslq -0xc(%rbp), %rax
andq $0xff, %rax
movb %al, -0xd(%rbp)
leaq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0xc0f0
cmpq $0x4, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x1a245(%rip), %rax     # 0x26730
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
shrq %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
leaq 0x12b7c(%rip), %rax     # 0x1f090
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0xc090
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0xc542
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc55e
cmpl $0x0, -0x34(%rbp)
jge 0xc552
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xc55c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc58f
jmp 0xc55e
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0xc58a
movq 0x12a89(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x1a8b(%rip), %rsi      # 0xe004
movb $0x0, %al
callq 0xc0a0
movq $0x0, -0x8(%rbp)
jmp 0xc58f
jmp 0xc4f6
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)