LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/network/network_connect.c
// Function: docallback
static int
docallback(void * cookie)
{
	struct connect_cookie * C = cookie;
	int rc;

	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, C->s);

	/* Free the cookie. */
	free(C);

	/* Return status from upstream callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %esi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2040
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/network/network_connect.c
// Function: dofailed
static int
dofailed(struct connect_cookie * C)
{

	/* Close the socket which failed to connect. */
	if (close(C->s))
		warnp("close");

	/* We don't have an open socket any more. */
	C->s = -1;

	/* This address didn't work. */
	C->sas++;

	/* Try other addresses until we run out of options. */
	return (tryconnect(C));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edi
callq 0x2190
cmpl $0x0, %eax
je 0x4ee6
jmp 0x4eaf
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4ed4
leaq 0x5599(%rip), %rdi      # 0xa459
movb $0x0, %al
callq 0x7a60
callq 0x20a0
movl $0x0, (%rax)
jmp 0x4ee2
leaq 0x557e(%rip), %rdi      # 0xa459
movb $0x0, %al
callq 0x7cb0
jmp 0x4ee4
jmp 0x4ee6
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x4b80
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../libcperciva/util/sock_util.c
// Function: sock_addr_validate
int
sock_addr_validate(const char * addr)
{

	/* Sanity check. */
	assert(addr != NULL);

	/* Check for an empty address. */
	if (strlen(addr) == 0) {
		warn0("Empty socket address.");
		goto err0;
	}

	/*
	 * If this isn't a UNIX socket address, check for a missing hostname.
	 * Since UNIX socket addresses start with a '/', they won't begin with
	 * a ':' and thus there's no need to check for '/' explicitly.
	 */
	if (addr[0] == ':') {
		warn0("No host in \"%s\"", addr);
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7905
jmp 0x7924
leaq 0x3102(%rip), %rdi      # 0xaa0e
leaq 0x3108(%rip), %rsi      # 0xaa1b
movl $0x15e, %edx            # imm = 0x15E
leaq 0x314b(%rip), %rcx      # 0xaa6a
callq 0x2170
movq -0x10(%rbp), %rdi
callq 0x2110
cmpq $0x0, %rax
jne 0x7950
jmp 0x7935
leaq 0x3153(%rip), %rdi      # 0xaa8f
movb $0x0, %al
callq 0x7cb0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x7986
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x797d
jmp 0x795e
movq -0x10(%rbp), %rsi
leaq 0x313c(%rip), %rdi      # 0xaaa5
movb $0x0, %al
callq 0x7cb0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x7986
movl $0x0, -0x4(%rbp)
jmp 0x798d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/hello.c
// Function: main
int
main(void)
{
    int me, npes;
    struct utsname u;

    uname(&u);

    shmem_init();

    me = shmem_my_pe();
    npes = shmem_n_pes();

    printf("%s: Hello from PE %4d of %4d\n", u.nodename, me, npes);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movl $0x0, 0x194(%rsp)
leaq 0x6(%rsp), %rdi
callq 0x1040
callq 0x1080
callq 0x1070
movl %eax, 0x190(%rsp)
callq 0x1050
movl %eax, 0x18c(%rsp)
leaq 0x6(%rsp), %rsi
addq $0x41, %rsi
movl 0x190(%rsp), %edx
movl 0x18c(%rsp), %ecx
leaq 0xe1d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1060
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
retq
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dif_bf2
static inline void
ct_dif_bf2(unsigned s,
       complex double * restrict out,
       complex double w)
{
  complex double a = out[0];
  complex double b = out[s];
  out[0] = a + b;
  out[s] = (a - b) * w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
addsd %xmm3, %xmm1
addsd %xmm2, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm0
subsd %xmm3, %xmm1
movsd %xmm1, -0x80(%rbp)
subsd %xmm0, %xmm2
movsd %xmm2, -0x78(%rbp)
movsd -0x10(%rbp), %xmm4
movsd %xmm4, -0x70(%rbp)
movsd -0x8(%rbp), %xmm5
movsd %xmm5, -0x68(%rbp)
movaps %xmm1, %xmm0
mulsd %xmm4, %xmm0
movaps %xmm2, %xmm3
mulsd %xmm5, %xmm3
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm2
subsd %xmm3, %xmm0
movsd %xmm0, -0x60(%rbp)
addsd %xmm2, %xmm1
movsd %xmm1, -0x58(%rbp)
ucomisd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
jnp 0x220c
movsd -0x58(%rbp), %xmm1
movsd -0x60(%rbp), %xmm0
ucomisd %xmm1, %xmm1
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
jnp 0x220c
movsd -0x68(%rbp), %xmm3
movsd -0x70(%rbp), %xmm2
movsd -0x78(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
callq 0x2280
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x8/scan.c
// Function: max_subtree_n
int max_subtree_n(const int a[], int n)
{
	int sofar;
	int curr;
	int i;

	/* assumes we have at least one positive entry */
	sofar = curr = 0;
	for (i = 0; i < n; i++) {
		curr = max(curr+a[i], 0);
		sofar = max(sofar, curr);
	}
	return sofar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11bd
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
addl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x11d0
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x11d0
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1184
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x8/scan_test.c
// Function: test_max_subtree_n
int test_max_subtree_n(int *i)
{
	const struct test {
		const char	*name;
		const int	array[10];
		int		want;
	} tests[] = {
		{
			.name	= "31,-41,59,26,-53,58,97,-93,-23,84",
			.array	= {31, -41, 59, 26, -53, 58, 97, -93, -23, 84},
			.want	= 187,
		},
		{ /* sentry */ },
	};
	const struct test *t;
	int fail = 0;

	for (t = tests; t->name; t++) {
		int got;

		printf("%3d) %-25s: %-45s", ++(*i), "test_max_subtree_n", t->name);
		got = max_subtree_n(t->array, 10);
		if (got != t->want) {
			printf("FAIL, got(%d)!=want(%d)\n", got, t->want);
			fail++;
		} else
			puts("PASS");
	}
	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x2af6(%rip), %rsi      # 0x3d10
movl $0x70, %edx
callq 0x1050
movl $0x0, -0x8c(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12f5
movq -0x8(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
movl %esi, (%rax)
movq -0x88(%rbp), %rax
movq (%rax), %rcx
leaq 0xdc0(%rip), %rdi       # 0x2026
leaq 0xdcb(%rip), %rdx       # 0x2038
movb $0x0, %al
callq 0x1040
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movl $0xa, %esi
callq 0x1160
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %eax
movq -0x88(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0x12d0
movl -0x90(%rbp), %esi
movq -0x88(%rbp), %rax
movl 0x30(%rax), %edx
leaq 0xd93(%rip), %rdi       # 0x204b
movb $0x0, %al
callq 0x1040
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x12dc
leaq 0xd8d(%rip), %rdi       # 0x2064
callq 0x1030
jmp 0x12de
movq -0x88(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
jmp 0x1239
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x8/bisect.c
// Function: _max_subtree_logn
static int __max_subtree_logn(const int a[], int l, int u)
{
	int left, right, sum;
	int m;
	int i;

	if (l > u)
		return -1;
	else if (l == u)
		return a[l];

	/* get the middle max */
	m = (l+u)/2;
	left = sum = 0;
	for (i = m; i >= l; i--) {
		sum += a[i];
		left = max(left, sum);
	}
	right = sum = 0;
	for (i = m+1; i <= u; i++) {
		sum += a[i];
		right = max(right, sum);
	}

	return max3(left+right, __max_subtree_logn(a, l, m), __max_subtree_logn(a, m+1, u));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x1366
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1460
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x1381
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x1460
jmp 0x1383
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x13da
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x1470
movl %eax, -0x1c(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13a8
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x1423
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x1470
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13f1
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x1340
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
addl $0x1, %esi
movl -0x18(%rbp), %edx
callq 0x1340
movl -0x34(%rbp), %edi
movl -0x30(%rbp), %esi
movl %eax, %edx
callq 0x14a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x8/bisect_test.c
// Function: test_max_subtree_logn
int test_max_subtree_logn(int *i)
{
	const struct test {
		const char	*name;
		const int	array[10];
		int		want;
	} tests[] = {
		{
			.name	= "31,-41,59,26,-53,58,97,-93,-23,84",
			.array	= {31, -41, 59, 26, -53, 58, 97, -93, -23, 84},
			.want	= 187,
		},
		{ /* sentry */ },
	};
	const struct test *t;
	int fail = 0;

	for (t = tests; t->name; t++) {
		int got;

		printf("%3d) %-25s: %-45s", ++(*i), "test_max_subtree_logn", t->name);
		got = max_subtree_logn(t->array, 10);
		if (got != t->want) {
			printf("FAIL, got(%d)!=want(%d)\n", got, t->want);
			fail++;
		} else
			puts("PASS");
	}
	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x2896(%rip), %rsi      # 0x3d80
movl $0x70, %edx
callq 0x1050
movl $0x0, -0x8c(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15c5
movq -0x8(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
movl %esi, (%rax)
movq -0x88(%rbp), %rax
movq (%rax), %rcx
leaq 0xaf0(%rip), %rdi       # 0x2026
leaq 0xb2c(%rip), %rdx       # 0x2069
movb $0x0, %al
callq 0x1040
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
movl $0xa, %esi
callq 0x1310
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %eax
movq -0x88(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0x15a0
movl -0x90(%rbp), %esi
movq -0x88(%rbp), %rax
movl 0x30(%rax), %edx
leaq 0xac3(%rip), %rdi       # 0x204b
movb $0x0, %al
callq 0x1040
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x15ac
leaq 0xabd(%rip), %rdi       # 0x2064
callq 0x1030
jmp 0x15ae
movq -0x88(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
jmp 0x1509
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x8/main_test.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls, Chapter 0x8\n");
	printf("===============================\n");

	if (test_max_subtree_n(&i))
		fail++;
	if (test_max_subtree_logn(&i))
		fail++;

	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xa7b(%rip), %rdi       # 0x207f
movb $0x0, %al
callq 0x1040
leaq 0xa8e(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1040
leaq 0xa5f(%rip), %rdi       # 0x207f
movb $0x0, %al
callq 0x1040
leaq -0xc(%rbp), %rdi
callq 0x1200
cmpl $0x0, %eax
je 0x163e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x14d0
cmpl $0x0, %eax
je 0x1655
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: createStack
Stack createStack(int size)
{
    Stack s;
    s=(Stack)malloc(sizeof(StackNode));
    if(s==NULL)
    {
        fatal("stack malloc failed.");
    }
    s->next=NULL;
    return s;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11bc
leaq 0xe4d(%rip), %rdi       # 0x2004
callq 0x11e0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: popStack
void popStack(Stack s)
{
    assert(s!=NULL);
    PStackNode node=s->next;
    s->next=s->next->next;
    free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12d5
jmp 0x12f4
leaq 0xd3d(%rip), %rdi       # 0x2019
leaq 0xd3e(%rip), %rsi       # 0x2021
movl $0x41, %edx
leaq 0xd6a(%rip), %rcx       # 0x2059
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: pushStack
void pushStack(int value, Stack s)
{
	PStackNode newNode;
    newNode=(PStackNode)malloc(sizeof(StackNode));
    if(newNode==NULL)
    {
        fatal("new node malloc failed");
    }
    newNode->value=value;
    newNode->next=s->next;
    s->next=newNode;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1360
leaq 0xce7(%rip), %rdi       # 0x2042
callq 0x11e0
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_list/stack.c
// Function: printStack
void printStack(Stack s){
    assert(s!=NULL);
    if(isEmptyStack(s)){
        printf("stack is empty.\n");
        return;
    }
    
    printf("stack: ");
    PStackNode node=s->next;
    while(node!=NULL){
        printf("%d ", node->value);
        node=node->next;
    }
    printf("\n");
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13e5
jmp 0x1404
leaq 0xc2d(%rip), %rdi       # 0x2019
leaq 0xc2e(%rip), %rsi       # 0x2021
movl $0x53, %edx
leaq 0xc7b(%rip), %rcx       # 0x207a
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x12a0
cmpl $0x0, %eax
je 0x1422
leaq 0xc78(%rip), %rdi       # 0x2091
movb $0x0, %al
callq 0x1040
jmp 0x1473
leaq 0xc79(%rip), %rdi       # 0x20a2
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1465
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xc5a(%rip), %rdi       # 0x20aa
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x143c
leaq 0xc34(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_list/main.c
// Function: main
int main(int argc, char** argv)
{
    
    Stack s;
    s=createStack(0);
    int i;
    for(i=0;i<10;i++){
        pushStack(rand()%100,s);
    }
    
    printStack(s);
    printf("Top: %d\n",topStack(s));
    popStack(s);
    popStack(s);
    printStack(s);
    printf("Top: %d\n",topStack(s));
    clearStack(s);
    printStack(s);
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x1190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x14d1
callq 0x1080
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, %edi
movq -0x18(%rbp), %rsi
callq 0x1330
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14a8
movq -0x18(%rbp), %rdi
callq 0x13d0
movq -0x18(%rbp), %rdi
callq 0x1390
movl %eax, %esi
leaq 0xbd2(%rip), %rdi       # 0x20be
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x12c0
movq -0x18(%rbp), %rdi
callq 0x12c0
movq -0x18(%rbp), %rdi
callq 0x13d0
movq -0x18(%rbp), %rdi
callq 0x1390
movl %eax, %esi
leaq 0xb9e(%rip), %rdi       # 0x20be
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1260
movq -0x18(%rbp), %rdi
callq 0x13d0
xorl %edi, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/ggets.c
// Function: fggets
int fggets(char* *ln, FILE *f)
{
   int     cursize, ch, ix;
   char   *buffer, *temp;

   *ln = NULL; /* default */
   if (NULL == (buffer = malloc(INITSIZE))) return NOMEM;
   cursize = INITSIZE;

   ix = 0;
   while ((EOF != (ch = getc(f))) && ('\n' != ch)) {
      if (ix >= (cursize - 1)) { /* extend buffer */
         cursize += DELTASIZE;
         if (NULL == (temp = realloc(buffer, (size_t)cursize))) {
            /* ran out of memory, return partial line */
            buffer[ix] = '\0';
            *ln = buffer;
            return NOMEM;
         }
         buffer = temp;
      }
      buffer[ix++] = ch;
   }
   if ((EOF == ch) && (0 == ix)) {
      free(buffer);
      return EOF;
   }

   buffer[ix] = '\0';
   if (NULL == (temp = realloc(buffer, (size_t)ix + 1))) {
      *ln = buffer;  /* without reducing it */
   }
   else *ln = temp;
   return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x70, %edi
callq 0x1120
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x12cf
movl $0x1, -0x4(%rbp)
jmp 0x13fa
movl $0x70, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1180
movl %eax, %edx
movl %edx, -0x20(%rbp)
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
je 0x1307
movl $0xa, %eax
cmpl -0x20(%rbp), %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1310
jmp 0x138d
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x136e
movl -0x1c(%rbp), %eax
addl $0x80, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1130
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x1366
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x13fa
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x12dd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x20(%rbp), %eax
jne 0x13b0
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jne 0x13b0
movq -0x30(%rbp), %rdi
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13fa
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rsi
addq $0x1, %rsi
callq 0x1130
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x13e8
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x13f3
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_new
aa *aa_new(ftype comp)
{
    aa *tree;

    if (comp == NULL) {
        return NULL;
    }

    if ((tree = malloc(sizeof(aa))) == NULL) {
        return NULL;
    }

    tree->comp = comp;
    tree->root = tree->cursor = NULL;

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x147d
movq $0x0, -0x8(%rbp)
jmp 0x14c6
movl $0xe0, %edi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x149b
movq $0x0, -0x8(%rbp)
jmp 0x14c6
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_add
int aa_add(aa * tree, void *data, int (*dup) (void *orig, void *new))
{
    int rval;

    if (tree == NULL)
        return 1;

    if ((rval = setjmp(tree->env)) == 0) {
        tree->root = insert(tree->root, data, dup, tree->comp, tree->env);
    } else {
        return rval;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14f4
movl $0x1, -0x4(%rbp)
jmp 0x1548
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x10d0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x1539
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %r8
addq $0x18, %r8
callq 0x1560
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1541
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1548
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: insert
static struct node *insert(struct node *t, void *data, ftype dup,
                           ftype comp, jmp_buf env)
{
    if (t == NULL) {
        if ((t = malloc(sizeof(struct node))) == NULL) {
            longjmp(env, 2);
        }

        t->data = data;
        t->level = 1;
        t->left = NULL;
        t->right = NULL;
        return t;
    } else if (comp(data, t->data) == -1) {
        t->left = insert(t->left, data, dup, comp, env);
    } else if (comp(data, t->data) == 1) {
        t->right = insert(t->right, data, dup, comp, env);
    } else if (dup == NULL) {
        longjmp(env, 3);
    } else {
        if (dup(t->data, data) == 0) {
            return t;
        } else {
            longjmp(env, 4);
        }
    }

    t = skew(t);
    t = split(t);
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15e0
movl $0x20, %edi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x15a5
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x1140
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16cf
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
cmpl $-0x1, %eax
jne 0x1624
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1560
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x16ab
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
cmpl $0x1, %eax
jne 0x1665
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1560
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x16a9
cmpq $0x0, -0x20(%rbp)
jne 0x167a
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x1140
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x169b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16cf
movq -0x30(%rbp), %rdi
movl $0x4, %esi
callq 0x1140
jmp 0x16ab
jmp 0x16ad
movq -0x10(%rbp), %rdi
callq 0x2250
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_delete
int aa_delete(aa * tree, void *data, int (*dup) (void *orig, void *data),
              void (*del) (void *))
{
    int rval;

    if (tree == NULL)
        return 1;

    if ((rval = setjmp(tree->env)) == 0) {
        tree->root = delete(tree->root, data, dup, tree->comp, del, tree->env);
    } else {
        return rval;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1708
movl $0x1, -0x4(%rbp)
jmp 0x1760
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x10d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x1751
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %r9
addq $0x18, %r9
callq 0x1770
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1759
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1760
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: find
static void *find(struct node *t, void *data, ftype comp)
{
    if (t == NULL) {
        return NULL;
    }

    if (t->data == NULL) {
        return NULL;
    }

    if (comp(data, t->data) == -1) {
        return find(t->left, data, comp);
    } else if (comp(data, t->data) == 1) {
        return find(t->right, data, comp);
    } else {
        return t->data;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a88
movq $0x0, -0x8(%rbp)
jmp 0x1b0d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1a9d
movq $0x0, -0x8(%rbp)
jmp 0x1b0d
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
cmpl $-0x1, %eax
jne 0x1acf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1a60
movq %rax, -0x8(%rbp)
jmp 0x1b0d
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
cmpl $0x1, %eax
jne 0x1b01
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1a60
movq %rax, -0x8(%rbp)
jmp 0x1b0d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_traverse
int aa_traverse(aa * tree, void *(*func) (void *data), trav t)
{
    if (tree == NULL) {
        return 1;
    }

    switch (t) {
    case TRAV_IN:
        inorder(tree->root, func);
        break;
    case TRAV_POST:
        postorder(tree->root, func);
        break;
    case TRAV_PRE:
        preorder(tree->root, func);
        break;
    default:
        return 2;
        break;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b43
movl $0x1, -0x4(%rbp)
jmp 0x1ba9
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x1b63
jmp 0x1b4f
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x1b75
jmp 0x1b59
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x1b87
jmp 0x1b99
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bc0
jmp 0x1ba2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c30
jmp 0x1ba2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ca0
jmp 0x1ba2
movl $0x2, -0x4(%rbp)
jmp 0x1ba9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: inorder
static void inorder(struct node *node, void *(*func) (void *data))
{
    if (node == NULL)
        return;

    if (node->left)
        inorder(node->left, func);

    node->data = func(node->data);

    if (node->right)
        inorder(node->right, func);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1bd9
jmp 0x1c2a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1bf5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bc0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1c2a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bc0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: postorder
static void postorder(struct node *node, void *(*func) (void *data))
{
    if (node == NULL)
        return;

    if (node->left)
        postorder(node->left, func);

    if (node->right)
        postorder(node->right, func);

    node->data = func(node->data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1c49
jmp 0x1c9a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1c65
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c30
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1c81
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c30
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: preorder
static void preorder(struct node *node, void *(*func) (void *data))
{
    if (node == NULL)
        return;

    node->data = func(node->data);

    if (node->left)
        preorder(node->left, func);

    if (node->right)
        preorder(node->right, func);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1cb9
jmp 0x1d0a
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1cee
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1d0a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_free
void aa_free(aa * tree)
{
    if (tree == NULL) {
        return;
    }

    freetree(tree->root);
    free(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1d75
jmp 0x1d8a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1d90
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: freetree
static void freetree(struct node *node)
{
    if (node == NULL)
        return;

    if (node->left)
        freetree(node->left);

    if (node->right)
        freetree(node->right);

    free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1da5
jmp 0x1dde
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1dbd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1d90
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1dd5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1d90
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_get_here
void *aa_get_here(aa * tree)
{
    if (tree == NULL) {
        return NULL;
    }

    if (tree->cursor == NULL) {
        return NULL;
    }

    return tree->cursor->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e09
movq $0x0, -0x8(%rbp)
jmp 0x1e2e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1e1e
movq $0x0, -0x8(%rbp)
jmp 0x1e2e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_set_here
int aa_set_here(aa * tree, void *data, int (*dup) (void *orig, void *data))
{
    if (tree == NULL) {
        return 1;
    }

    if (tree->cursor == NULL) {
        return 2;
    }

    if (tree->comp(data, tree->cursor->data) == 0) {
        if (dup != NULL) {
            if (dup(tree->cursor->data, data) == 0) {
                return 0;
            } else {
                return 4;
            }

        } else {
            return 3;
        }

    } else {
        tree->cursor->data = data;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e67
movl $0x1, -0x4(%rbp)
jmp 0x1eee
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1e7b
movl $0x2, -0x4(%rbp)
jmp 0x1eee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x1ed7
cmpq $0x0, -0x20(%rbp)
je 0x1ece
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x1ec5
movl $0x0, -0x4(%rbp)
jmp 0x1eee
movl $0x4, -0x4(%rbp)
jmp 0x1eee
movl $0x3, -0x4(%rbp)
jmp 0x1eee
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_has_left
int aa_has_left(aa * tree)
{
    if (tree == NULL) {
        return -1;
    } else if ((tree->cursor == NULL) || (tree->cursor->left == NULL)) {
        return 0;
    } else {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f18
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f42
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1f32
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1f3b
movl $0x0, -0x4(%rbp)
jmp 0x1f42
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_has_right
int aa_has_right(aa * tree)
{
    if (tree == NULL) {
        return -1;
    } else if ((tree->cursor == NULL) || (tree->cursor->right == NULL)) {
        return 0;
    } else {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f68
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f92
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1f82
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1f8b
movl $0x0, -0x4(%rbp)
jmp 0x1f92
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_go_left
int aa_go_left(aa * tree)
{
    if (tree == NULL) {
        return 1;
    } else if ((tree->cursor == NULL) || (tree->cursor->left == NULL)) {
        return 1;
    } else {
        tree->cursor = tree->cursor->left;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1fb8
movl $0x1, -0x4(%rbp)
jmp 0x1ff6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1fd2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1fdb
movl $0x1, -0x4(%rbp)
jmp 0x1ff6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_go_right
int aa_go_right(aa * tree)
{
    if (tree == NULL) {
        return 1;
    } else if ((tree->cursor == NULL) || (tree->cursor->right == NULL)) {
        return 1;
    } else {
        tree->cursor = tree->cursor->right;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2018
movl $0x1, -0x4(%rbp)
jmp 0x2056
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2032
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x203b
movl $0x1, -0x4(%rbp)
jmp 0x2056
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_to_root
int aa_to_root(aa * tree)
{
    if (tree == NULL) {
        return 1;
    } else {
        tree->cursor = tree->root;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2078
movl $0x1, -0x4(%rbp)
jmp 0x208e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: aa_print
int aa_print(aa * tree, FILE * fp, void (*printer) (FILE *, void *))
{
    if (!tree)
        return -1;

    if (tree->root == NULL)
        return -2;

    fprintf(fp, "digraph aa_tree {\n");
    fprintf(fp, "node [shape = record];\n");
    tree_print(tree->root, 1, printer, fp);
    fprintf(fp, "}\n");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x20c4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x212d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x20d7
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x212d
movq -0x18(%rbp), %rdi
leaq 0x1f32(%rip), %rsi      # 0x4014
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rdi
leaq 0x1f33(%rip), %rsi      # 0x4027
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2140
movq -0x18(%rbp), %rdi
leaq 0x1f20(%rip), %rsi      # 0x403f
movb $0x0, %al
callq 0x1100
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: tree_print
static void tree_print(struct node *node, unsigned long long int n,
                       void (*printer) (FILE *, void *), FILE * fp)
{
    unsigned long long int pn = n / 2;

    fprintf(fp, "node%llu [label = \"<f0> | <f1> ", n);
    printer(fp, node->data);
    fprintf(fp, "|<f2> \"];\n");

    if (pn != 0) {
        if (n % 2 == 0) {
            fprintf(fp, "\"node%llu\":f0 -> \"node%llu\":f1;\n", pn, n);
        } else {
            fprintf(fp, "\"node%llu\":f2 -> \"node%llu\":f1;\n", pn, n);
        }
    }

    if (node->left)
        tree_print(node->left, 2 * n, printer, fp);

    if (node->right)
        tree_print(node->right, 2 * n + 1, printer, fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1ed0(%rip), %rsi      # 0x4042
movb $0x0, %al
callq 0x1100
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x20(%rbp), %rdi
leaq 0x1ecc(%rip), %rsi      # 0x4062
movb $0x0, %al
callq 0x1100
cmpq $0x0, -0x28(%rbp)
je 0x21ea
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x21ce
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1ea8(%rip), %rsi      # 0x406d
movb $0x0, %al
callq 0x1100
jmp 0x21e8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1ead(%rip), %rsi      # 0x408e
movb $0x0, %al
callq 0x1100
jmp 0x21ea
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2211
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
shlq %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2140
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x223c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
shlq %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2140
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: skew
static struct node *skew(struct node *t)
{
    struct node *l;

    if (t == NULL)
        return NULL;

    if (t->left == NULL)
        return t;

    if (t->left->level == t->level) {
        l = t->left;
        t->left = l->right;
        l->right = t;
        return l;
    } else {
        return t;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2269
movq $0x0, -0x8(%rbp)
jmp 0x22ca
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x227e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22ca
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x22c2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22ca
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: split
static struct node *split(struct node *t)
{
    struct node *r;

    if (t == NULL)
        return NULL;

    if ((t->right == NULL) || (t->right->right == NULL))
        return t;

    if (t->level == t->right->right->level) {
        r = t->right;
        t->right = r->left;
        r->left = t;
        r->level++;
        return r;
    } else {
        return t;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x22e9
movq $0x0, -0x8(%rbp)
jmp 0x2368
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2303
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x230d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2368
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x2360
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2368
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: successor
static void *successor(struct node *t)
{
    t = t->right;

    while (t->left != NULL) {
        t = t->left;
    }

    return t->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x239d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2384
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: predecessor
static void *predecessor(struct node *t)
{
    t = t->left;

    while (t->right != NULL) {
        t = t->right;
    }

    return t->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x23dd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x23c4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chbarts[P]aa-tree/aa-tree.c
// Function: decrease_level
static struct node *decrease_level(struct node *t)
{
    int should_be;

    should_be = min(t->left->level, t->right->level) + 1;

    if (should_be < t->level) {
        t->level = should_be;
        if (should_be < t->right->level) {
            t->right->level = should_be;
        }
    }

    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %esi
callq 0x2460
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x244d
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x244b
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, (%rax)
jmp 0x244d
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)