LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/cons.c
// Function: map_cut
CONS*
map_cut(CONS* map, CONS* key)
/* destructively remove the first mapping for key, returning the new map */
{
	CONS* head;
	CONS* prev;
	
	head = map;
	prev = NIL;
	for (;;) {
		if (nilp(map)) {
			return head;
		}
		assert(consp(map));
		if (car(car(map)) == key) {
			if (nilp(prev)) {
				return cdr(map);
			}
			rplacd(prev, cdr(map));
			return head;
		}
		prev = map;
		map = cdr(map);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x8f81(%rip), %rax      # 0x2f290
movq %rax, -0x28(%rbp)
leaq 0x8f76(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2633b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2640c
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x26359
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2636b
jmp 0x2638a
leaq 0x4f7e(%rip), %rdi      # 0x2b2f0
leaq 0x4eab(%rip), %rsi      # 0x2b224
movl $0x149, %edx            # imm = 0x149
leaq 0x5068(%rip), %rcx      # 0x2b3ed
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x25380
cmpq -0x18(%rbp), %rax
jne 0x263f2
leaq 0x8ee8(%rip), %rax      # 0x2f290
cmpq %rax, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x263cb
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, -0x8(%rbp)
jmp 0x2640c
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x256d0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2640c
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
jmp 0x26313
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/cons.c
// Function: report_cons_usage
void
report_cons_usage()
{
	report_cell_usage();
	TRACE(printf("cons_cnt=%d\n", cons_cnt));
	assert((NIL)->first == NIL);
	assert((NIL)->rest == NIL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, %al
callq 0x24740
movl 0x845f(%rip), %esi      # 0x2f910
leaq 0x3553(%rip), %rdi      # 0x2aa0b
movb $0x0, %al
callq 0x20e0
leaq 0x7dca(%rip), %rax      # 0x2f290
cmpq %rax, 0x7dc3(%rip)      # 0x2f290
jne 0x274d1
jmp 0x274f0
leaq 0x3fab(%rip), %rdi      # 0x2b483
leaq 0x3d45(%rip), %rsi      # 0x2b224
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0x41ef(%rip), %rcx      # 0x2b6da
callq 0x2100
leaq 0x7d99(%rip), %rax      # 0x2f290
cmpq %rax, 0x7d9a(%rip)      # 0x2f298
jne 0x27502
jmp 0x27521
leaq 0x3fa0(%rip), %rdi      # 0x2b4a9
leaq 0x3d14(%rip), %rsi      # 0x2b224
movl $0x1b6, %edx            # imm = 0x1B6
leaq 0x41be(%rip), %rcx      # 0x2b6da
callq 0x2100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/cons.c
// Function: assert_equal_cons
BOOL
assert_equal_cons(char* msg, CONS* expect, CONS* actual)
{
	if (!equal(expect, actual)) {
		DBUG_PRINT("", ("expect=%s", cons_to_str(expect)));
		DBUG_PRINT("", ("actual=%s", cons_to_str(actual)));
		fprintf(stderr, "assert_equal_cons: FAILED! %s\n", ((msg != NULL) ? msg : ""));
		abort();
	}
	return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25700
cmpq $0x0, %rax
jne 0x27674
jmp 0x2755d
leaq 0x83bc(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x275c2
leaq 0x7db0(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1df1(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0x1de6(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x275c2
leaq 0x7d86(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1bd, 0xc(%rax)       # imm = 0x1BD
movq -0x10(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x229c(%rip), %rdi      # 0x29857
movb $0x0, %al
callq 0x28540
jmp 0x275c4
jmp 0x275c6
leaq 0x8353(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x2762b
leaq 0x7d47(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1d88(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0x1d7d(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x2762b
leaq 0x7d1d(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1be, 0xc(%rax)       # imm = 0x1BE
movq -0x18(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x223d(%rip), %rdi      # 0x29861
movb $0x0, %al
callq 0x28540
jmp 0x2762d
movq 0x79c4(%rip), %rax      # 0x2eff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2764c
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x27659
leaq 0x1d1c(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
jmp 0x27659
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x408b(%rip), %rsi      # 0x2b6f3
movb $0x0, %al
callq 0x2170
callq 0x2050
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sbuf.c
// Function: new_sbuf
SBUF*
new_sbuf(size_t size)
{
	SBUF* sbuf = (SBUF*)malloc(sizeof(SBUF));

	assert(sbuf != NULL);
	sbuf->limit = size - 1;
	sbuf->offset = 0;
	sbuf->buf = (char*)malloc(size);
	return sbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x21b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x276a3
jmp 0x276c2
leaq 0x4068(%rip), %rdi      # 0x2b712
leaq 0x406e(%rip), %rsi      # 0x2b71f
movl $0x10, %edx
leaq 0x4069(%rip), %rcx      # 0x2b726
callq 0x2100
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x21b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sbuf.c
// Function: sbuf_emit
void
sbuf_emit(char c, void* ctx)
{
	SBUF* sbuf = (SBUF*)ctx;
	
	if (sbuf->offset < sbuf->limit) {
		sbuf->buf[sbuf->offset] = c;
		++sbuf->offset;
		sbuf->buf[sbuf->offset] = '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x277d1
movb -0x1(%rbp), %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/sbuf.c
// Function: sbuf_emits
void
sbuf_emits(char* s, size_t n, void* ctx)
{
	char c;
	SBUF* sbuf = (SBUF*)ctx;
	
	if ((sbuf->offset + n) < sbuf->limit) {
		while ((c = *s++) && (n-- > 0)) {
			sbuf->buf[sbuf->offset] = c;
			++sbuf->offset;
		}
		sbuf->buf[sbuf->offset] = '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x27892
jmp 0x27813
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x2784d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x27856
jmp 0x2787e
movb -0x19(%rbp), %dl
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x27813
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: selected
static int
selected(void)
{
	return (dbug_on
	     && (dbug_cfg->ctx->depth <= dbug_cfg->maxdepth)
	     && match_set(dbug_cfg->proc_list, dbug_cfg->process)
	     && match_set(dbug_cfg->unit_list, dbug_cfg->ctx->unit->unit)
	     && match_set(dbug_cfg->fn_list, dbug_cfg->ctx->name));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
cmpl $0x0, 0x801f(%rip)      # 0x2f920
movb %al, -0x1(%rbp)
je 0x279a6
movq 0x7a0f(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movq 0x7a01(%rip), %rdx      # 0x2f320
xorl %eax, %eax
cmpl 0x24(%rdx), %ecx
movb %al, -0x1(%rbp)
jg 0x279a6
movq 0x79f0(%rip), %rax      # 0x2f320
movq 0x30(%rax), %rdi
movq 0x79e5(%rip), %rax      # 0x2f320
movq 0x8(%rax), %rsi
callq 0x279c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
je 0x279a6
movq 0x79c9(%rip), %rax      # 0x2f320
movq 0x38(%rax), %rdi
movq 0x79be(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x279c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
je 0x279a6
movq 0x799a(%rip), %rax      # 0x2f320
movq 0x40(%rax), %rdi
movq 0x798f(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x279c0
cmpl $0x0, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: match_set
static int
match_set(char *set, char *key)
{
	int sense = 1;
	int match = 1;
	int klen;
	int len;
	char *p;

	if ((set == NULL) || (*set == '\0') || (*set == ':')) {
		return 1;
	}
	if (key == NULL) {
		return 0;
	}
	match = 0;
	klen = strlen(key);
	if (*set == '^') {
		sense = !sense;
		++set;
	}
	p = set;
	for (;;) {
		while ((*p != ',') && (*p != ':') && (*p != '\0')) {
			++p;
		}
		len = (int) (p - set);
		if ((len == klen) && (strncmp(set, key, klen) == 0)) {
			match = 1;
			break;
		}
		if ((*p == ':') || (*p == '\0')) {
			break;
		}
		set = ++p;
	}
	return (match == sense);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x279fd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x279fd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x27a09
movl $0x1, -0x4(%rbp)
jmp 0x27b20
cmpq $0x0, -0x18(%rbp)
jne 0x27a1c
movl $0x0, -0x4(%rbp)
jmp 0x27b20
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x27a58
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x27a62
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x31(%rbp)
je 0x27a94
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x31(%rbp)
je 0x27a94
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x27a9d
jmp 0x27aab
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x27a62
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x27ae0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x2080
cmpl $0x0, %eax
jne 0x27ae0
movl $0x1, -0x20(%rbp)
jmp 0x27b0f
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x27af8
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x27afa
jmp 0x27b0f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x10(%rbp)
jmp 0x27a60
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_push
void
dbug_push(char *config)
{
	struct dbug_cfg_t *cfg;

	cfg = (struct dbug_cfg_t *)malloc(sizeof(struct dbug_cfg_t));
	if (cfg != (struct dbug_cfg_t *)0) {
		*cfg = *dbug_cfg;
		cfg->prev = dbug_cfg;
		dbug_cfg = cfg;
#if 0
		dbug_cfg->proc_list = "";
		dbug_cfg->unit_list = "";
		dbug_cfg->fn_list = "";
		dbug_cfg->kw_list = "";
#endif /* 0 */
		parse(config);
		dbug_on = dbug_cfg->mode;
		if (dbug_on) {
			prefix();
			fprintf(dbug_cfg->output,
				"DBUG_PUSH(\"%s\")\n", config);
			fflush(dbug_cfg->output);
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x60, %edi
callq 0x21b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27bd9
movq -0x10(%rbp), %rdi
movq 0x77c0(%rip), %rsi      # 0x2f320
movl $0x60, %edx
callq 0x2180
movq 0x77af(%rip), %rcx      # 0x2f320
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x779c(%rip)      # 0x2f320
movq -0x8(%rbp), %rdi
callq 0x27be0
movq 0x778c(%rip), %rax      # 0x2f320
movl (%rax), %eax
movl %eax, 0x7d84(%rip)      # 0x2f920
cmpl $0x0, 0x7d7d(%rip)      # 0x2f920
je 0x27bd7
callq 0x27f40
movq 0x776f(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3d58(%rip), %rsi      # 0x2b918
movb $0x0, %al
callq 0x2170
movq 0x7752(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
callq 0x21c0
jmp 0x27bd9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_pop
void
dbug_pop(void)
{
	struct dbug_cfg_t *cfg;

	cfg = dbug_cfg;
	if (cfg == &base_cfg) {
		dbug_fatal("DBUG_POP stack underflow (%s:%d)",
			dbug_cfg->ctx->unit->name,
			dbug_cfg->ctx->line);
	}
	if (dbug_on) {
		prefix();
		fprintf(dbug_cfg->output, "DBUG_POP()\n");
	}
	dbug_cfg = cfg->prev;
	if (dbug_cfg->output != cfg->output) {
		close_output(cfg->output);
	}
	dbug_cfg->line_cnt = cfg->line_cnt;
	dbug_cfg->ctx = cfg->ctx;
	free(cfg);
	dbug_on = dbug_cfg->mode;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x7101(%rip), %rax      # 0x2f320
movq %rax, -0x8(%rbp)
leaq 0x7096(%rip), %rax      # 0x2f2c0
cmpq %rax, -0x8(%rbp)
jne 0x2825e
movq 0x70e9(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq 0x70d7(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movl 0xc(%rax), %edx
leaq 0x36d2(%rip), %rdi      # 0x2b929
movb $0x0, %al
callq 0x28300
cmpl $0x0, 0x76bb(%rip)      # 0x2f920
je 0x28285
callq 0x27f40
movq 0x70ad(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
leaq 0x36cc(%rip), %rsi      # 0x2b94a
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x708c(%rip)      # 0x2f320
movq 0x7085(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x282b6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x28440
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq 0x705c(%rip), %rax      # 0x2f320
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq 0x704a(%rip), %rax      # 0x2f320
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
movq 0x7036(%rip), %rax      # 0x2f320
movl (%rax), %eax
movl %eax, 0x762e(%rip)      # 0x2f920
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_fatal
static void
dbug_fatal(char *fmt, ...)
{
	va_list va;
	FILE *f;
	char *p;

	f = stderr;
	p = "";
	if (dbug_cfg) {
		if (dbug_cfg->output) {
			f = dbug_cfg->output;
		}
		if (dbug_cfg->process) {
			p = dbug_cfg->process;
		}
	}
	fprintf(f, "\n%s(DBUG) FATAL: ", p);
	fflush(f);
	va_start(va, fmt);
	vfprintf(f, fmt, va);
	va_end(va);
	fputc('\n', f);
	fflush(f);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x28338
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x6c92(%rip), %rax      # 0x2eff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0xffb(%rip), %rax       # 0x2936f
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x6fa0(%rip)      # 0x2f320
je 0x283be
movq 0x6f97(%rip), %rax      # 0x2f320
cmpq $0x0, 0x18(%rax)
je 0x2839f
movq 0x6f89(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x6f7a(%rip), %rax      # 0x2f320
cmpq $0x0, 0x8(%rax)
je 0x283bc
movq 0x6f6c(%rip), %rax      # 0x2f320
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x283be
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x368a(%rip), %rsi      # 0x2ba57
movb $0x0, %al
callq 0x2170
movq -0x28(%rbp), %rdi
callq 0x21c0
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2200
leaq -0x20(%rbp), %rax
movq -0x28(%rbp), %rsi
movl $0xa, %edi
callq 0x2130
movq -0x28(%rbp), %rdi
callq 0x21c0
callq 0x2050
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: close_output
static int
close_output(FILE *f)
{
	int rv;

	rv = 0;
	if (f && (f != stderr) && (f != stdout)) {
		rv = fclose(f);
	}
	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x28486
movq -0x8(%rbp), %rax
movq 0x6b93(%rip), %rcx      # 0x2eff8
cmpq (%rcx), %rax
je 0x28486
movq -0x8(%rbp), %rax
movq 0x6b4b(%rip), %rcx      # 0x2efc0
cmpq (%rcx), %rax
je 0x28486
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_enter
void
dbug_enter(struct dbug_ctx_t *ctx)
{
	dbug_cfg->ctx = ctx;
	if (selected() && (dbug_on & DBUG_TRACE_ON)) {
		prefix();
		fprintf(dbug_cfg->output, ">%.31s\n", ctx->name);
		if (fflush(dbug_cfg->output) == EOF) {
			io_error();
		}
	}
	++ctx->depth;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x6e79(%rip), %rax      # 0x2f320
movq %rcx, 0x50(%rax)
callq 0x278f0
cmpl $0x0, %eax
je 0x28504
movl 0x7465(%rip), %eax      # 0x2f920
andl $0x2, %eax
cmpl $0x0, %eax
je 0x28504
callq 0x27f40
movq 0x6e51(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x3475(%rip), %rsi      # 0x2b956
movb $0x0, %al
callq 0x2170
movq 0x6e31(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
jne 0x28502
callq 0x28520
jmp 0x28504
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_print
void
dbug_print(char *fmt, ...)
{
	va_list va;

	prefix();
	fprintf(dbug_cfg->output, "%.31s: ", dbug_cfg->ctx->keyword);
	fflush(dbug_cfg->output);
	va_start(va, fmt);
	vfprintf(dbug_cfg->output, fmt, va);
	va_end(va);
	fputc('\n', dbug_cfg->output);
	if (fflush(dbug_cfg->output) == EOF) {
		io_error();
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x28575
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)
callq 0x27f40
movq 0x6d78(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq 0x6d6d(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x339c(%rip), %rsi      # 0x2b95e
movb $0x0, %al
callq 0x2170
movq 0x6d50(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
callq 0x21c0
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 0x6d1c(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2200
leaq -0x20(%rbp), %rax
movq 0x6d00(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rsi
movl $0xa, %edi
callq 0x2130
movq 0x6ceb(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
jne 0x28648
callq 0x28520
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_return
void
dbug_return(struct dbug_ctx_t *ctx)
{
	if (ctx != dbug_cfg->ctx) {
		dbug_fatal("missing DBUG_RETURN detected in '%s' (%s:%d)",
			dbug_cfg->ctx->name,
			dbug_cfg->ctx->unit->name,
			dbug_cfg->ctx->line);
	}
	--ctx->depth;
	if (selected() && (dbug_on & DBUG_TRACE_ON)) {
		prefix();
		fprintf(dbug_cfg->output, "<%.31s\n", ctx->name);
		if (fflush(dbug_cfg->output) == EOF) {
			io_error();
		}
	}
	dbug_cfg->ctx = ctx->caller;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x6ca9(%rip), %rcx      # 0x2f320
cmpq 0x50(%rcx), %rax
je 0x286b9
movq 0x6c9c(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movq (%rax), %rsi
movq 0x6c8e(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdx
movq 0x6c7c(%rip), %rax      # 0x2f320
movq 0x50(%rax), %rax
movl 0xc(%rax), %ecx
leaq 0x32b4(%rip), %rdi      # 0x2b966
movb $0x0, %al
callq 0x28300
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
callq 0x278f0
cmpl $0x0, %eax
je 0x2871f
movl 0x724a(%rip), %eax      # 0x2f920
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2871f
callq 0x27f40
movq 0x6c36(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x3297(%rip), %rsi      # 0x2b993
movb $0x0, %al
callq 0x2170
movq 0x6c16(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
jne 0x2871d
callq 0x28520
jmp 0x2871f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq 0x6bf2(%rip), %rax      # 0x2f320
movq %rcx, 0x50(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_hexdump
void
dbug_hexdump(void *p, int n)
{
	unsigned char *bp = p;
	char asc[16 + 1];
	int i;
	int c;

	while (n > 0) {
		fprintf(dbug_cfg->output, "%p  ", bp);
		for (i = 0; i < 16; ++i) {
			if (i < n) {
				c = bp[i];
				if ((c >= ' ') && (c < 0x7F)) {
					asc[i] = c;
				} else {
					asc[i] = '.';
				}
				fprintf(dbug_cfg->output, " %02x", c);
			} else {
				asc[i] = ' ';
				fprintf(dbug_cfg->output, "   ");
			}
		}
		asc[16] = '\0';
		fprintf(dbug_cfg->output, "  |%16.16s|\n", asc);
		bp += 16;
		n -= 16;
	}
	fflush(dbug_cfg->output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x28855
movq 0x6bb8(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3224(%rip), %rsi      # 0x2b99b
movb $0x0, %al
callq 0x2170
movl $0x0, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jge 0x2881a
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x287e8
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
cmpl $0x20, -0x38(%rbp)
jl 0x287c1
cmpl $0x7f, -0x38(%rbp)
jge 0x287c1
movl -0x38(%rbp), %eax
movb %al, %cl
movslq -0x34(%rbp), %rax
movb %cl, -0x30(%rbp,%rax)
jmp 0x287ca
movslq -0x34(%rbp), %rax
movb $0x2e, -0x30(%rbp,%rax)
movq 0x6b4f(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movl -0x38(%rbp), %edx
leaq 0x31c1(%rip), %rsi      # 0x2b9a0
movb $0x0, %al
callq 0x2170
jmp 0x2880a
movslq -0x34(%rbp), %rax
movb $0x20, -0x30(%rbp,%rax)
movq 0x6b28(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
leaq 0x31a3(%rip), %rsi      # 0x2b9a6
movb $0x0, %al
callq 0x2170
jmp 0x2880c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x28785
movb $0x0, -0x20(%rbp)
movq 0x6afb(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
leaq -0x30(%rbp), %rdx
leaq 0x3176(%rip), %rsi      # 0x2b9aa
movb $0x0, %al
callq 0x2170
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl $0x10, %eax
movl %eax, -0xc(%rbp)
jmp 0x28757
movq 0x6ac4(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
callq 0x21c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: open_output
static FILE *
open_output(char *p)
{
	FILE *f;

	f = (FILE *)0;
	p = mk_string(p);
	if (p[0] == '\0') {
		f = stderr;
	} else if ((p[0] == '-') && (p[1] == '\0')) {
		f = stdout;
	} else {
		if (p[0] == '!') {
			f = fopen(++p, "w");
		} else {
			f = fopen(p, "a");
		}
		if (f == NULL) {
			dbug_fatal("can't open output file '%s'", p);
		}
	}
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28940
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x288b0
movq 0x6754(%rip), %rax      # 0x2eff8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x28934
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x288d9
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x288d9
movq 0x66f0(%rip), %rax      # 0x2efc0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x28932
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x28903
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq %rdi, -0x8(%rbp)
leaq 0x30e6(%rip), %rsi      # 0x2b9de
callq 0x21d0
movq %rax, -0x10(%rbp)
jmp 0x28917
movq -0x8(%rbp), %rdi
leaq 0xff0(%rip), %rsi       # 0x298fe
callq 0x21d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28930
movq -0x8(%rbp), %rsi
leaq 0x30b7(%rip), %rdi      # 0x2b9e0
movb $0x0, %al
callq 0x28300
jmp 0x28932
jmp 0x28934
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: mk_string
static char *
mk_string(char *p)
{
	static char buf[256];
	char *q;
	int n;

	if (*p == ',') {			/* skip leading comma, if any */
		++p;
	}
	for (q = p; *q && (*q != ':'); ++q)	/* find the end of the token */
		;
	n = (int)(q - p);
	if (n > (sizeof(buf) - 1)) {		/* safegaurd the copy size */
		n = (sizeof(buf) - 1);
	}
	memset(buf, '\0', sizeof(buf));
	strncpy(buf, p, n);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x28964
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x2898d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x28996
jmp 0x289a6
jmp 0x28998
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2896c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0xff, %rax
jbe 0x289c7
movl $0xff, -0x14(%rbp)
leaq 0x6f62(%rip), %rdi      # 0x2f930
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2110
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq 0x6f47(%rip), %rdi      # 0x2f930
callq 0x2070
leaq 0x6f3b(%rip), %rax      # 0x2f930
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/dbug.c
// Function: call_trace
static void
call_trace(struct dbug_ctx_t *ctx)
{
	if (ctx && (ctx != &base_ctx)) {
		if (ctx->caller && (ctx->caller != &base_ctx)) {
			call_trace(ctx->caller);
			fprintf(dbug_cfg->output, ",%.31s", ctx->name);
		} else {
			fprintf(dbug_cfg->output, "%.31s", ctx->name);
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x28a8d
leaq 0x690e(%rip), %rax      # 0x2f328
cmpq %rax, -0x8(%rbp)
je 0x28a8d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x28a6b
movq -0x8(%rbp), %rax
leaq 0x68f2(%rip), %rcx      # 0x2f328
cmpq %rcx, 0x20(%rax)
je 0x28a6b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x28a00
movq 0x68d0(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x2fee(%rip), %rsi      # 0x2ba50
movb $0x0, %al
callq 0x2170
jmp 0x28a8b
movq 0x68ae(%rip), %rax      # 0x2f320
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x2fcd(%rip), %rsi      # 0x2ba51
movb $0x0, %al
callq 0x2170
jmp 0x28a8d
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wtakuo[P]SVM/cbench.c
// Function: tak
int tak (int x, int y, int z) {
    if (x <= y)
        return y;
    else
        return tak(tak(x - 1, y, z),
                   tak(y - 1, z, x),
                   tak(z - 1, x, y));
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
jg 0x1184
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x11d9
movl 0x10(%rsp), %edi
subl $0x1, %edi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x1160
movl %eax, (%rsp)
movl 0xc(%rsp), %edi
subl $0x1, %edi
movl 0x8(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x1160
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %edi
subl $0x1, %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x1160
movl (%rsp), %edi
movl 0x4(%rsp), %esi
movl %eax, %edx
callq 0x1160
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtakuo[P]SVM/cbench.c
// Function: main
int main (int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "usage: %s x y z\n", argv[0]);
        return EXIT_FAILURE;
    }
    int x = atoi(argv[1]);
    int y = atoi(argv[2]);
    int z = atoi(argv[3]);

    printf(">>> %d\n", tak(x, y, z));

    return EXIT_SUCCESS;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x4, 0x20(%rsp)
je 0x1236
movq 0x2de5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0xddf(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, 0x24(%rsp)
jmp 0x1295
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1050
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1050
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x1160
movl %eax, %esi
leaq 0xd8f(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1030
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_create
struct rb_table *
rb_create (rb_comparison_func *compare, void *param,
            struct libavl_allocator *allocator)
{
  struct rb_table *tree;

  assert (compare != NULL);

  if (allocator == NULL)
    allocator = &rb_allocator_default;

  tree = allocator->libavl_malloc (allocator, sizeof *tree);
  if (tree == NULL)
    return NULL;

  tree->rb_root = NULL;
  tree->rb_compare = compare;
  tree->rb_param = param;
  tree->rb_alloc = allocator;
  tree->rb_count = 0;
  tree->rb_generation = 0;

  return tree;
}

// 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)
je 0x11ad
jmp 0x11cc
leaq 0x2e50(%rip), %rdi      # 0x4004
leaq 0x2e59(%rip), %rsi      # 0x4014
movl $0x2a, %edx
leaq 0x2e52(%rip), %rcx      # 0x4019
callq 0x1040
cmpq $0x0, -0x20(%rbp)
jne 0x11de
leaq 0x4e7e(%rip), %rax      # 0x6058
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1205
movq $0x0, -0x8(%rbp)
jmp 0x1254
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_find
void *
rb_find (const struct rb_table *tree, const void *item)
{
  const struct rb_node *p;

  assert (tree != NULL && item != NULL);
  for (p = tree->rb_root; p != NULL; )
    {
      int cmp = tree->rb_compare (item, p->rb_data, tree->rb_param);

      if (cmp < 0)
        p = p->rb_link[0];
      else if (cmp > 0)
        p = p->rb_link[1];
      else /* |cmp == 0| */
        return p->rb_data;
    }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1280
cmpq $0x0, -0x18(%rbp)
je 0x1280
jmp 0x129f
leaq 0x2f39(%rip), %rdi      # 0x41c0
leaq 0x2d86(%rip), %rsi      # 0x4014
movl $0x44, %edx
leaq 0x2dd3(%rip), %rcx      # 0x406d
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x130b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x12e5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1309
cmpl $0x0, -0x24(%rbp)
jle 0x12f9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1307
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1313
jmp 0x1309
jmp 0x12aa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_replace
void *
rb_replace (struct rb_table *table, void *item)
{
  void **p = rb_probe (table, item);
  if (p == NULL || *p == item)
    return NULL;
  else
    {
      void *r = *p;
      *p = item;
      return r;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1320
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1995
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x199f
movq $0x0, -0x8(%rbp)
jmp 0x19bd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_init
void
rb_t_init (struct rb_traverser *trav, struct rb_table *tree)
{
  trav->rb_table = tree;
  trav->rb_node = NULL;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x198(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_first
void *
rb_t_first (struct rb_traverser *trav, struct rb_table *tree)
{
  struct rb_node *x;

  assert (tree != NULL && trav != NULL);

  trav->rb_table = tree;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;

  x = tree->rb_root;
  if (x != NULL)
    while (x->rb_link[0] != NULL)
      {
        assert (trav->rb_height < RB_MAX_HEIGHT);
        trav->rb_stack[trav->rb_height++] = x;
        x = x->rb_link[0];
      }
  trav->rb_node = x;

  return x != NULL ? x->rb_data : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2490
cmpq $0x0, -0x8(%rbp)
je 0x2490
jmp 0x24af
leaq 0x1c67(%rip), %rdi      # 0x40fe
leaq 0x1b76(%rip), %rsi      # 0x4014
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x1c71(%rip), %rcx      # 0x411b
callq 0x1040
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x255e
jmp 0x24f0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x255c
movq -0x8(%rbp), %rax
cmpq $0x30, 0x190(%rax)
jae 0x250a
jmp 0x2529
leaq 0x1c45(%rip), %rdi      # 0x4156
leaq 0x1afc(%rip), %rsi      # 0x4014
movl $0x1e7, %edx            # imm = 0x1E7
leaq 0x1bf7(%rip), %rcx      # 0x411b
callq 0x1040
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x190(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x190(%rsi)
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24f0
jmp 0x255e
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x257f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2587
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x2587
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_last
void *
rb_t_last (struct rb_traverser *trav, struct rb_table *tree)
{
  struct rb_node *x;

  assert (tree != NULL && trav != NULL);

  trav->rb_table = tree;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;

  x = tree->rb_root;
  if (x != NULL)
    while (x->rb_link[1] != NULL)
      {
        assert (trav->rb_height < RB_MAX_HEIGHT);
        trav->rb_stack[trav->rb_height++] = x;
        x = x->rb_link[1];
      }
  trav->rb_node = x;

  return x != NULL ? x->rb_data : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x25c0
cmpq $0x0, -0x8(%rbp)
je 0x25c0
jmp 0x25df
leaq 0x1b37(%rip), %rdi      # 0x40fe
leaq 0x1a46(%rip), %rsi      # 0x4014
movl $0x1f8, %edx            # imm = 0x1F8
leaq 0x1b9c(%rip), %rcx      # 0x4176
callq 0x1040
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2690
jmp 0x2620
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x268e
movq -0x8(%rbp), %rax
cmpq $0x30, 0x190(%rax)
jae 0x263b
jmp 0x265a
leaq 0x1b14(%rip), %rdi      # 0x4156
leaq 0x19cb(%rip), %rsi      # 0x4014
movl $0x202, %edx            # imm = 0x202
leaq 0x1b21(%rip), %rcx      # 0x4176
callq 0x1040
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x190(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x190(%rsi)
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2620
jmp 0x2690
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x26b1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x26b9
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x26b9
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_find
void *
rb_t_find (struct rb_traverser *trav, struct rb_table *tree, void *item)
{
  struct rb_node *p, *q;

  assert (trav != NULL && tree != NULL && item != NULL);
  trav->rb_table = tree;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;
  for (p = tree->rb_root; p != NULL; p = q)
    {
      int cmp = tree->rb_compare (item, p->rb_data, tree->rb_param);

      if (cmp < 0)
        q = p->rb_link[0];
      else if (cmp > 0)
        q = p->rb_link[1];
      else /* |cmp == 0| */
        {
          trav->rb_node = p;
          return p->rb_data;
        }

      assert (trav->rb_height < RB_MAX_HEIGHT);
      trav->rb_stack[trav->rb_height++] = p;
    }

  trav->rb_height = 0;
  trav->rb_node = NULL;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x26fb
cmpq $0x0, -0x18(%rbp)
je 0x26fb
cmpq $0x0, -0x20(%rbp)
je 0x26fb
jmp 0x271a
leaq 0x1aae(%rip), %rdi      # 0x41b0
leaq 0x190b(%rip), %rsi      # 0x4014
movl $0x215, %edx            # imm = 0x215
leaq 0x1ac8(%rip), %rcx      # 0x41dd
callq 0x1040
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2826
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x2791
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x27c4
cmpl $0x0, -0x34(%rbp)
jle 0x27a5
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x27c2
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2849
jmp 0x27c4
movq -0x10(%rbp), %rax
cmpq $0x30, 0x190(%rax)
jae 0x27d4
jmp 0x27f3
leaq 0x197b(%rip), %rdi      # 0x4156
leaq 0x1832(%rip), %rsi      # 0x4014
movl $0x227, %edx            # imm = 0x227
leaq 0x19ef(%rip), %rcx      # 0x41dd
callq 0x1040
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x190(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x190(%rsi)
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2752
movq -0x10(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_insert
void *
rb_t_insert (struct rb_traverser *trav, struct rb_table *tree, void *item)
{
  void **p;

  assert (trav != NULL && tree != NULL && item != NULL);

  p = rb_probe (tree, item);
  if (p != NULL)
    {
      trav->rb_table = tree;
      trav->rb_node =
        ((struct rb_node *)
         ((char *) p - offsetof (struct rb_node, rb_data)));
      trav->rb_generation = tree->rb_generation - 1;
      return *p;
    }
  else
    {
      rb_t_init (trav, tree);
      return NULL;
    }
}

// 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)
je 0x288b
cmpq $0x0, -0x18(%rbp)
je 0x288b
cmpq $0x0, -0x20(%rbp)
je 0x288b
jmp 0x28aa
leaq 0x191e(%rip), %rdi      # 0x41b0
leaq 0x177b(%rip), %rsi      # 0x4014
movl $0x23c, %edx            # imm = 0x23C
leaq 0x197a(%rip), %rcx      # 0x421f
callq 0x1040
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1320
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2901
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $-0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2916
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2420
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_copy
void *
rb_t_copy (struct rb_traverser *trav, const struct rb_traverser *src)
{
  assert (trav != NULL && src != NULL);

  if (trav != src)
    {
      trav->rb_table = src->rb_table;
      trav->rb_node = src->rb_node;
      trav->rb_generation = src->rb_generation;
      if (trav->rb_generation == trav->rb_table->rb_generation)
        {
          trav->rb_height = src->rb_height;
          memcpy (trav->rb_stack, (const void *) src->rb_stack,
                  sizeof *trav->rb_stack * trav->rb_height);
        }
    }

  return trav->rb_node != NULL ? trav->rb_node->rb_data : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2940
cmpq $0x0, -0x10(%rbp)
je 0x2940
jmp 0x295f
leaq 0x191c(%rip), %rdi      # 0x4263
leaq 0x16c6(%rip), %rsi      # 0x4014
movl $0x253, %edx            # imm = 0x253
leaq 0x1925(%rip), %rcx      # 0x427f
callq 0x1040
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x29f5
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
jne 0x29f3
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x190(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rax
movq 0x190(%rax), %rdx
shlq $0x3, %rdx
callq 0x1060
jmp 0x29f5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a12
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a1a
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x2a1a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)