LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_scan_value
static BOOL
gc_scan_value(CONS* s)
/* consider a value for addition to the "scan" list, return TRUE if queued */
{
	DBUG_ENTER("gc_scan_value");
	DBUG_PRINT("gc", ("s = 16#%08lx", (ulint)s));
	if (!nilp(s)) {
		if (actorp(s)) {
			s = MK_CONS(s);
		}
		if (consp(s)) {
			gc_scan_cell(as_cell(s));
			DBUG_RETURN TRUE;
		}
	}
	DBUG_RETURN FALSE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x489e(%rip), %rax      # 0x1e0bf
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9b02(%rip), %r14      # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xe3, 0xc(%rdi)
leaq 0x2b01(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x9a2c(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0xa0c8(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x198a7
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x3479(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x198a7
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xe4, 0xc(%rax)
leaq 0x4830(%rip), %rdi      # 0x1e0cd
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b983
movl $0xee, %eax
cmpq 0x970d(%rip), %rbx      # 0x22fc0
je 0x198e3
movl %ebx, %ecx
andl $0x3, %ecx
movq %rbx, %rdi
andq $-0x4, %rdi
cmpl $0x1, %ecx
cmovneq %rbx, %rdi
testq %rdi, %rdi
sete %cl
testb $0x3, %dil
setne %dl
orb %cl, %dl
jne 0x198e3
callq 0x17d07
movl $0xeb, %eax
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_free_cells
static void
gc_free_cells()
/* move unmarked "aged" cells to "free" list after scanning */
{
	DBUG_ENTER("gc_free_cells");
	DBUG_PRINT("gc", ("%u cells marked in-use on fresh list", GC_SIZE(GC_FRESH_LIST)));
	gc_append_list(GC_FREE_LIST, GC_AGED_LIST);	
	DBUG_PRINT("gc", ("%u cells available in free list", GC_SIZE(GC_FREE_LIST)));
#if 1	/* FIXME: eventually remove these checks for better performance */
	gc_sanity_check(GC_AGED_LIST);
	gc_sanity_check(GC_SCAN_LIST);
	gc_sanity_check(GC_FRESH_LIST);
	gc_sanity_check(GC_FREE_LIST);
#endif
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x47d6(%rip), %rax      # 0x1e0da
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9a1f(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x108, 0xc(%rdi)       # imm = 0x108
leaq 0x2a1e(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x9949(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x9fe5(%rip), %r14      # 0x23930
cmpl $0x0, (%r14)
je 0x1998f
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3395(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x1998f
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x109, 0xc(%rax)       # imm = 0x109
movq 0x989f(%rip), %rsi      # 0x23220
leaq 0x4760(%rip), %rdi      # 0x1e0e8
xorl %eax, %eax
callq 0x1b983
leaq 0x98aa(%rip), %rdi      # 0x23240
leaq 0x9843(%rip), %rsi      # 0x231e0
callq 0x17913
cmpl $0x0, (%r14)
je 0x199e6
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x333e(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x199e6
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x10b, 0xc(%rax)       # imm = 0x10B
movq 0x9868(%rip), %rsi      # 0x23240
leaq 0x45e9(%rip), %rdi      # 0x1dfc8
xorl %eax, %eax
callq 0x1b983
leaq 0x97f3(%rip), %rdi      # 0x231e0
callq 0x179d6
leaq 0x9807(%rip), %rdi      # 0x23200
callq 0x179d6
leaq 0x981b(%rip), %rdi      # 0x23220
callq 0x179d6
leaq 0x982f(%rip), %rdi      # 0x23240
callq 0x179d6
movq %rsp, %rdi
movl $0x112, 0xc(%rdi)       # imm = 0x112
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/gc.c
// Function: gc_initialize
static void
gc_initialize()
{
	if (gc_phase__mark != -1U) {
		return;		/* already initialized */
	}
	DBUG_PRINT("", ("gc_initialize"));
	gc_phase__prev = GC_PHASE_0;
	gc_phase__mark = GC_PHASE_1;
	GC_SET_NEXT(GC_AGED_LIST, GC_AGED_LIST);
	GC_SET_PREV(GC_AGED_LIST, GC_AGED_LIST);
	GC_SET_NEXT(GC_SCAN_LIST, GC_SCAN_LIST);
	GC_SET_PREV(GC_SCAN_LIST, GC_SCAN_LIST);
	GC_SET_NEXT(GC_FRESH_LIST, GC_FRESH_LIST);
	GC_SET_PREV(GC_FRESH_LIST, GC_FRESH_LIST);
	GC_SET_NEXT(GC_FREE_LIST, GC_FREE_LIST);
	GC_SET_PREV(GC_FREE_LIST, GC_FREE_LIST);
	GC_SET_NEXT(GC_PERM_LIST, GC_PERM_LIST);
	GC_SET_PREV(GC_PERM_LIST, GC_PERM_LIST);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0x985f(%rip)      # 0x23298
jne 0x19b71
pushq %rbx
leaq 0x9ee9(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19a8a
leaq 0x98dd(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x28e9(%rip), %rdi      # 0x1c34a
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x19a8a
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x1d, 0xc(%rax)
leaq 0x4710(%rip), %rdi      # 0x1e193
xorl %eax, %eax
callq 0x1b983
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, 0x97fa(%rip)      # 0x23290
orq $0x40000000, %rax       # imm = 0x40000000
movq %rax, 0x97f5(%rip)      # 0x23298
leaq 0x9736(%rip), %rax      # 0x231e0
sarq $0x2, %rax
movq %rax, 0x9743(%rip)      # 0x231f8
movq 0x9734(%rip), %rcx      # 0x231f0
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9724(%rip)      # 0x231f0
leaq 0x972d(%rip), %rax      # 0x23200
sarq $0x2, %rax
movq %rax, 0x973a(%rip)      # 0x23218
movq 0x972b(%rip), %rcx      # 0x23210
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x971b(%rip)      # 0x23210
leaq 0x9724(%rip), %rax      # 0x23220
sarq $0x2, %rax
movq %rax, 0x9731(%rip)      # 0x23238
movq 0x9722(%rip), %rcx      # 0x23230
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9712(%rip)      # 0x23230
leaq 0x971b(%rip), %rax      # 0x23240
sarq $0x2, %rax
movq %rax, 0x9728(%rip)      # 0x23258
movq 0x9719(%rip), %rcx      # 0x23250
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9709(%rip)      # 0x23250
leaq 0x9712(%rip), %rax      # 0x23260
sarq $0x2, %rax
movq %rax, 0x971f(%rip)      # 0x23278
movq 0x9710(%rip), %rcx      # 0x23270
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9700(%rip)      # 0x23270
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: car
CONS*
_car(CONS* p)
{
	XDBUG_ENTER("car");
	XDBUG_PRINT("", ("p=16#%08lx", (ulint)p));
	if (nilp(p)) {
		DBUG_PRINT("car", ("ALERT! car(NIL)"));
/*		fprintf(stderr, "ALERT! car(NIL)\n"); */
		XDBUG_RETURN NIL;
	}
#if 1
	if (actorp(p)) {
		DBUG_PRINT("car", ("ALERT! use _THIS(ACTOR)"));
		fprintf(stderr, "ALERT! car(ACTOR)\n");
		abort();
	}
#endif
	assert(consp(p));
#if 0
	XDBUG_RETURN (p->first);
#else
	XDBUG_RETURN gc_first(p);
#endif
}

// Assembly:
pushq %rbx
leaq 0x96f2(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x19bce
movl %edi, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19c21
testq %rdi, %rdi
je 0x19c26
testq %rax, %rax
jne 0x19c26
popq %rbx
jmp 0x1839d
leaq 0x9d5b(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19c18
leaq 0x974f(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x2954(%rip), %rdi      # 0x1c543
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x19c18
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x35, 0xc(%rax)
leaq 0x45d7(%rip), %rdi      # 0x1e1e8
xorl %eax, %eax
callq 0x1b983
leaq 0x9681(%rip), %rax      # 0x232a0
popq %rbx
retq
callq 0x25ab
leaq 0x32d6(%rip), %rdi      # 0x1cf03
leaq 0x45ef(%rip), %rsi      # 0x1e223
leaq 0x45ef(%rip), %rcx      # 0x1e22a
movl $0x40, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: cdr
CONS*
_cdr(CONS* p)
{
	XDBUG_ENTER("cdr");
	XDBUG_PRINT("", ("p=16#%08lx", (ulint)p));
	if (nilp(p)) {
		DBUG_PRINT("cdr", ("ALERT! cdr(NIL)"));
/*		fprintf(stderr, "ALERT! cdr(NIL)\n"); */
		XDBUG_RETURN NIL;
	}
#if 1
	if (actorp(p)) {
		DBUG_PRINT("cdr", ("ALERT! use _MINE(ACTOR)"));
		fprintf(stderr, "ALERT! cdr(ACTOR)\n");
		abort();
	}
#endif
	assert(consp(p));
#if 0
	XDBUG_RETURN (p->rest);
#else
	XDBUG_RETURN gc_rest(p);
#endif
}

// Assembly:
pushq %rbx
leaq 0x9653(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x19c6d
movl %edi, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19cc0
testq %rdi, %rdi
je 0x19cc5
testq %rax, %rax
jne 0x19cc5
popq %rbx
jmp 0x18405
leaq 0x9cbc(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19cb7
leaq 0x96b0(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x28c7(%rip), %rdi      # 0x1c555
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x19cb7
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x4e, 0xc(%rax)
leaq 0x458d(%rip), %rdi      # 0x1e23d
xorl %eax, %eax
callq 0x1b983
leaq 0x95e2(%rip), %rax      # 0x232a0
popq %rbx
retq
callq 0x2617
leaq 0x3237(%rip), %rdi      # 0x1cf03
leaq 0x4550(%rip), %rsi      # 0x1e223
leaq 0x459e(%rip), %rcx      # 0x1e278
movl $0x59, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: equal
BOOL
equal(CONS* x, CONS* y)
{
	if (x == y) {
		return TRUE;
	}
	if (nilp(x) || nilp(y)) {
		return FALSE;
	}
	if (actorp(x) || actorp(y)) {
		return FALSE;
	}
	if (consp(x) && consp(y)) {
		return (BOOL)(equal(car(x), car(y)) && equal(cdr(x), cdr(y)));
	}
	return FALSE;
}

// Assembly:
cmpq %rsi, %rdi
je 0x19dbc
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9585(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
sete %cl
cmpq %rax, %rsi
sete %al
orb %cl, %al
jne 0x19db4
movl %r14d, %ecx
andl $0x3, %ecx
cmpq $0x1, %rcx
je 0x19db4
movl %ebx, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19db4
testq %r14, %r14
sete %dl
testq %rcx, %rcx
setne %cl
orb %dl, %cl
jne 0x19db4
testq %rbx, %rbx
sete %cl
testq %rax, %rax
setne %al
orb %cl, %al
jne 0x19db4
movq %r14, %rdi
callq 0x19ba6
movq %rax, %r15
movq %rbx, %rdi
callq 0x19ba6
movq %r15, %rdi
movq %rax, %rsi
callq 0x19d00
testq %rax, %rax
je 0x19db4
movq %r14, %rdi
callq 0x19c45
movq %rax, %r14
movq %rbx, %rdi
callq 0x19c45
movq %r14, %rdi
movq %rax, %rsi
callq 0x19d00
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x19db6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: append
CONS*
append(CONS* x, CONS* y)
{
	assert(consp(x));
	assert(consp(y));
	if (nilp(x)) {
		return y;
	}
	/* FIXME: consider a non-recursive implementation to minimize stack usage */
	return cons(car(x), append(cdr(x), y));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x19e29
movq %rdi, %r14
movl %r14d, %eax
andl $0x3, %eax
jne 0x19e29
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19e48
movl %ebx, %eax
andl $0x3, %eax
jne 0x19e48
leaq 0x94b3(%rip), %rax      # 0x232a0
cmpq %rax, %r14
je 0x19e20
movq %r14, %rdi
callq 0x19ba6
movq %rax, %r15
movq %r14, %rdi
callq 0x19c45
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19dc2
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19b84
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x445b(%rip), %rdi      # 0x1e28b
leaq 0x43ec(%rip), %rsi      # 0x1e223
leaq 0x4456(%rip), %rcx      # 0x1e294
movl $0x90, %edx
callq 0x2100
leaq 0x4462(%rip), %rdi      # 0x1e2b1
leaq 0x43cd(%rip), %rsi      # 0x1e223
leaq 0x4437(%rip), %rcx      # 0x1e294
movl $0x91, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: reverse
CONS*
reverse(CONS* list)
{
	CONS* rev = NIL;

	while (!nilp(list)) {
		assert(consp(list));
		rev = cons(car(list), rev);
		list = cdr(list);
	}
	return rev;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x942d(%rip), %r14      # 0x232a0
cmpq %r14, %rdi
je 0x19eb7
movq %rdi, %rbx
leaq 0x941e(%rip), %r15      # 0x232a0
movq %r15, %r14
testq %rbx, %rbx
je 0x19ec0
movl %ebx, %eax
andl $0x3, %eax
jne 0x19ec0
movq %rbx, %rdi
callq 0x19ba6
movq %rax, %rdi
movq %r14, %rsi
callq 0x19b84
movq %rax, %r14
movq %rbx, %rdi
callq 0x19c45
movq %rax, %rbx
cmpq %r15, %rax
jne 0x19e85
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x43f3(%rip), %rdi      # 0x1e2ba
leaq 0x4355(%rip), %rsi      # 0x1e223
leaq 0x43f1(%rip), %rcx      # 0x1e2c6
movl $0x9f, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: length
int
length(CONS* list)
{
	int n = 0;

	while (!nilp(list)) {
		assert(consp(list));
		++n;
		list = cdr(list);
	}
	return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x93b6(%rip), %r14      # 0x232a0
cmpq %r14, %rdi
je 0x19f11
movq %rdi, %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x19f1d
movl %eax, %ecx
andl $0x3, %ecx
jne 0x19f1d
incl %ebx
movq %rax, %rdi
callq 0x19c45
cmpq %r14, %rax
jne 0x19ef4
jmp 0x19f13
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4396(%rip), %rdi      # 0x1e2ba
leaq 0x42f8(%rip), %rsi      # 0x1e223
leaq 0x43aa(%rip), %rcx      # 0x1e2dc
movl $0xac, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: replace
CONS*
replace(CONS* form, CONS* map)
/* replace mapped items in form with corresponding values */
{
	CONS* mapping;

	if (nilp(form)) {
		form = NIL;
	} else {
		mapping = map_find(map, form);
		if (nilp(mapping)) {
			if (consp(form)) {
				/* FIXME: consider a non-recursive implementation to minimize stack usage */
				form = cons(
					replace(car(form), map), 
					replace(cdr(form), map)
				);
/* ---- FALL THRU TO RETURN
			} else {
				form = form;
*/
			}
		} else {
			form = cdr(mapping);
		}
	}
	return form;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x9358(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x19f8b
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x19fca
leaq 0x933b(%rip), %rcx      # 0x232a0
cmpq %rcx, %rax
je 0x19f77
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c45
testq %r14, %r14
setne %al
testb $0x3, %r14b
sete %cl
testb %cl, %al
jne 0x19f91
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x19ba6
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19f3c
movq %rax, %r15
movq %r14, %rdi
callq 0x19c45
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19f3c
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19b84
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: map_find
CONS*
map_find(CONS* map, CONS* key)
/* return the CONS mapping <key>, or NIL if not found */
{
	CONS* entry = NIL;

	for (;;) {
		if (nilp(map)) {
			return NIL;
		}
		assert(consp(map));
		entry = car(map);
		assert(consp(entry));
		if (car(entry) == key) {
			return entry;
		}
		map = cdr(map);
	}
	return entry;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x92c7(%rip), %r15      # 0x232a0
cmpq %r15, %rdi
je 0x1a02d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x92b5(%rip), %r12      # 0x232a0
testq %r14, %r14
je 0x1a03c
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a03c
movq %r14, %rdi
callq 0x19ba6
testq %rax, %rax
je 0x1a05b
movq %rax, %r15
andl $0x3, %eax
jne 0x1a05b
movq %r15, %rdi
callq 0x19ba6
cmpq %rbx, %rax
je 0x1a02d
movq %r14, %rdi
callq 0x19c45
movq %rax, %r14
cmpq %r12, %rax
jne 0x19feb
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x42ac(%rip), %rdi      # 0x1e2ef
leaq 0x41d9(%rip), %rsi      # 0x1e223
leaq 0x42a9(%rip), %rcx      # 0x1e2fa
movl $0xda, %edx
callq 0x2100
leaq 0x3036(%rip), %rdi      # 0x1d098
leaq 0x41ba(%rip), %rsi      # 0x1e223
leaq 0x428a(%rip), %rcx      # 0x1e2fa
movl $0xdc, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: map_get_def
CONS*
map_get_def(CONS* map, CONS* key, CONS* def)
/* return the value associated with <key>, or <def> if not found */
{
	CONS* pair = NIL;

	assert(map != NULL);
	assert(key != NULL);
	pair = map_find(map, key);
	if (nilp(pair)) {
		return def;
	}
	return cdr(pair);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1a0a7
testq %rsi, %rsi
je 0x1a0c6
movq %rdx, %rbx
callq 0x19fca
leaq 0x920c(%rip), %rcx      # 0x232a0
cmpq %rcx, %rax
je 0x1a0a2
movq %rax, %rdi
popq %rbx
jmp 0x19c45
movq %rbx, %rax
popq %rbx
retq
leaq 0x426b(%rip), %rdi      # 0x1e319
leaq 0x416e(%rip), %rsi      # 0x1e223
leaq 0x4269(%rip), %rcx      # 0x1e325
movl $0xeb, %edx
callq 0x2100
leaq 0x4282(%rip), %rdi      # 0x1e34f
leaq 0x414f(%rip), %rsi      # 0x1e223
leaq 0x424a(%rip), %rcx      # 0x1e325
movl $0xec, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: map_put
CONS*
map_put(CONS* map, CONS* key, CONS* val)
/* add a CONS mapping <key> to <val> in <map>, returning the new map */
{
	XDBUG_ENTER("map_put");
	XDBUG_PRINT("", ("map=16#%08lx", (ulint)map));
	assert(consp(map) || nilp(map));
	XDBUG_PRINT("", ("key=16#%08lx", (ulint)key));
	assert(key != NULL);
	XDBUG_PRINT("", ("val=16#%08lx", (ulint)val));
	assert(val != NULL);
	XDBUG_RETURN cons(cons(key, val), map);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1a11d
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x1a11d
testq %rsi, %rsi
je 0x1a13c
testq %rdx, %rdx
je 0x1a15b
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19b84
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x19b84
leaq 0x4237(%rip), %rdi      # 0x1e35b
leaq 0x40f8(%rip), %rsi      # 0x1e223
leaq 0x4241(%rip), %rcx      # 0x1e373
movl $0x101, %edx            # imm = 0x101
callq 0x2100
leaq 0x420c(%rip), %rdi      # 0x1e34f
leaq 0x40d9(%rip), %rsi      # 0x1e223
leaq 0x4222(%rip), %rcx      # 0x1e373
movl $0x103, %edx            # imm = 0x103
callq 0x2100
leaq 0x4237(%rip), %rdi      # 0x1e399
leaq 0x40ba(%rip), %rsi      # 0x1e223
leaq 0x4203(%rip), %rcx      # 0x1e373
movl $0x105, %edx            # imm = 0x105
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: map_put_all
CONS*
map_put_all(CONS* map, CONS* amap)
/* add all entries from <amap> to <map>, returning the new map */
{
	while (consp(amap) && !nilp(amap)) {
		CONS* entry = car(amap);
		if (consp(entry)) {
			map = map_put(map, car(entry), cdr(entry));
		}
		amap = cdr(amap);
	}
	return map;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x9113(%rip), %r13      # 0x232a0
cmpq %r13, %rsi
je 0x1a1f4
movq %rsi, %r14
testq %r14, %r14
je 0x1a1f4
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a1f4
movq %r14, %rdi
callq 0x19ba6
movq %rax, %r15
testq %rax, %rax
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x1a1e2
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
movq %r15, %rdi
callq 0x19c45
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a0ec
movq %rax, %rbx
movq %r14, %rdi
callq 0x19c45
cmpq %r13, %rax
je 0x1a1f4
movq %rax, %r14
jmp 0x1a195
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: map_def
CONS*
map_def(CONS* map, CONS* keys, CONS* values)
/* add corresponding key/value pairs to <map>, returning the new map */
{
	assert(consp(map));
	while (consp(keys) && !nilp(keys) && consp(values) && !nilp(values)) {
		map = map_put(map, car(keys), car(values));
		keys = cdr(keys);
		values = cdr(values);
	}
	return map;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a2ab
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x1a2ab
movq %rsi, %r15
leaq 0x9075(%rip), %r13      # 0x232a0
cmpq %r13, %rsi
je 0x1a29e
testq %r15, %r15
je 0x1a29e
movl %r15d, %eax
andl $0x3, %eax
jne 0x1a29e
movq %rdx, %r14
cmpq %r13, %r14
je 0x1a29e
testq %r14, %r14
je 0x1a29e
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a29e
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
movq %r14, %rdi
callq 0x19ba6
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a0ec
movq %rax, %rbx
movq %r15, %rdi
callq 0x19c45
movq %rax, %r15
movq %r14, %rdi
callq 0x19c45
cmpq %r13, %r15
je 0x1a29e
testq %r15, %r15
je 0x1a29e
movq %rax, %r14
movl %r15d, %eax
andl $0x3, %eax
je 0x1a240
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x403d(%rip), %rdi      # 0x1e2ef
leaq 0x3f6a(%rip), %rsi      # 0x1e223
leaq 0x40e5(%rip), %rcx      # 0x1e3a5
movl $0x11b, %edx            # imm = 0x11B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/cons.c
// Function: map_remove
CONS*
map_remove(CONS* map, CONS* key)
/* remove any value associated with key, returning the new map w/ all duplicates removed */
{
	CONS* m;
	CONS* p;
	CONS* k;

	m = NIL;
	while (!nilp(map)) {
		assert(consp(map));
		p = car(map);
		assert(consp(p));
		k = car(p);
		if (k != key) {
			if (nilp(map_find(m, k))) {
				m = cons(p, m);
			}
		}
		map = cdr(map);
	}
	return reverse(m);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x8fc6(%rip), %r15      # 0x232a0
cmpq %r15, %rdi
je 0x1a34c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8fb4(%rip), %r13      # 0x232a0
movq %r13, %r15
testq %r14, %r14
je 0x1a35d
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a35d
movq %r14, %rdi
callq 0x19ba6
testq %rax, %rax
je 0x1a37c
movq %rax, %r12
andl $0x3, %eax
jne 0x1a37c
movq %r12, %rdi
callq 0x19ba6
cmpq %rbx, %rax
je 0x1a33c
movq %r15, %rdi
movq %rax, %rsi
callq 0x19fca
cmpq %r13, %rax
jne 0x1a33c
movq %r12, %rdi
movq %r15, %rsi
callq 0x19b84
movq %rax, %r15
movq %r14, %rdi
callq 0x19c45
movq %rax, %r14
cmpq %r13, %rax
jne 0x1a2ef
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x19e67
leaq 0x3f8b(%rip), %rdi      # 0x1e2ef
leaq 0x3eb8(%rip), %rsi      # 0x1e223
leaq 0x4059(%rip), %rcx      # 0x1e3cb
movl $0x12e, %edx            # imm = 0x12E
callq 0x2100
leaq 0x2b80(%rip), %rdi      # 0x1cf03
leaq 0x3e99(%rip), %rsi      # 0x1e223
leaq 0x403a(%rip), %rcx      # 0x1e3cb
movl $0x130, %edx            # imm = 0x130
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8ef2(%rip), %r13      # 0x232a0
cmpq %r13, %rdi
je 0x1a417
movq %rsi, %r14
movq %r13, %r15
movq %rbx, %r12
testq %r12, %r12
je 0x1a424
movl %r12d, %eax
andl $0x3, %eax
jne 0x1a424
movq %r12, %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x19ba6
cmpq %r14, %rax
je 0x1a3f3
movq %r12, %rdi
callq 0x19c45
movq %r12, %r15
movq %rax, %r12
cmpq %r13, %rax
jne 0x1a3bc
jmp 0x1a417
leaq 0x8ea6(%rip), %r14      # 0x232a0
movq %r12, %rdi
callq 0x19c45
cmpq %r14, %r15
je 0x1a414
movq %r15, %rdi
movq %rax, %rsi
callq 0x18462
jmp 0x1a417
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3ec4(%rip), %rdi      # 0x1e2ef
leaq 0x3df1(%rip), %rsi      # 0x1e223
leaq 0x3fb3(%rip), %rcx      # 0x1e3ec
movl $0x149, %edx            # imm = 0x149
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %rax
xorl %eax, %eax
callq 0x192f2
movl 0x8a49(%rip), %esi      # 0x23920
leaq 0x2b53(%rip), %rdi      # 0x1da31
xorl %eax, %eax
callq 0x20e0
leaq 0x83b4(%rip), %rax      # 0x232a0
cmpq %rax, 0x83ad(%rip)      # 0x232a0
jne 0x1af00
cmpq %rax, 0x83ac(%rip)      # 0x232a8
jne 0x1af1f
popq %rax
retq
leaq 0x3531(%rip), %rdi      # 0x1e438
leaq 0x3315(%rip), %rsi      # 0x1e223
leaq 0x373b(%rip), %rcx      # 0x1e650
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2100
leaq 0x3538(%rip), %rdi      # 0x1e45e
leaq 0x32f6(%rip), %rsi      # 0x1e223
leaq 0x371c(%rip), %rcx      # 0x1e650
movl $0x1b6, %edx            # imm = 0x1B6
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21b0
testq %rax, %rax
je 0x1afb7
movq %rax, %r14
leaq -0x1(%rbx), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x21b0
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x36d8(%rip), %rdi      # 0x1e696
leaq 0x36de(%rip), %rsi      # 0x1e6a3
leaq 0x36de(%rip), %rcx      # 0x1e6aa
movl $0x10, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
jae 0x1b02e
movq 0x10(%rsi), %rcx
movb %dil, (%rcx,%rax)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x8(%rsi)
movb $0x0, 0x1(%rcx,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdx), %rax
addq %rsi, %rax
cmpq (%rdx), %rax
jae 0x1b082
movb (%rdi), %al
testb %al, %al
sete %cl
testq %rsi, %rsi
sete %r8b
orb %cl, %r8b
jne 0x1b076
movl $0x1, %ecx
movq 0x8(%rdx), %r8
movq 0x10(%rdx), %r9
movb %al, (%r9,%r8)
incq 0x8(%rdx)
movb (%rdi,%rcx), %al
testb %al, %al
je 0x1b076
leaq 0x1(%rcx), %r8
cmpq %rcx, %rsi
movq %r8, %rcx
jne 0x1b053
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movb $0x0, (%rcx,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x887f(%rip)      # 0x23930
je 0x1b0fd
movq 0x8276(%rip), %rbx      # 0x23330
movq 0x50(%rbx), %r14
movl 0x8(%r14), %eax
cmpl 0x24(%rbx), %eax
jg 0x1b0fd
movq 0x8(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x1b107
testl %eax, %eax
je 0x1b0fd
movq 0x38(%rbx), %rdi
movq 0x18(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x1b107
testl %eax, %eax
je 0x1b0fd
movq 0x40(%rbx), %rdi
movq (%r14), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b107
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
testq %rdi, %rdi
je 0x1b1e0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbp
movzbl (%rdi), %r14d
testl %r14d, %r14d
je 0x1b1d2
cmpl $0x3a, %r14d
je 0x1b1d2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b1c0
movq %rbx, %rdi
callq 0x20d0
movq %rax, %r15
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x5e, %r14b
sete %al
setne %cl
movl %ecx, 0xc(%rsp)
addq %rax, %rbp
movslq %r15d, %rax
movq %rax, 0x10(%rsp)
movabsq $0x400100000000001, %r13 # imm = 0x400100000000001
leaq 0x1(%rbp), %r14
movl %r15d, %eax
movzbl -0x1(%r14), %r12d
cmpq $0x3a, %r12
ja 0x1b18f
btq %r12, %r13
jb 0x1b196
incq %r14
decl %eax
jmp 0x1b17e
testl %eax, %eax
jne 0x1b1ae
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x2080
testl %eax, %eax
je 0x1b1c4
xorl %ecx, %ecx
cmpl $0x3a, %r12d
je 0x1b1c9
movq %r14, %rbp
testl %r12d, %r12d
jne 0x1b177
jmp 0x1b1c9
xorl %eax, %eax
jmp 0x1b1d2
movl $0x1, %ecx
xorl %eax, %eax
cmpl 0xc(%rsp), %ecx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x7be1(%rip), %rbx      # 0x23330
leaq 0x7b7a(%rip), %rax      # 0x232d0
cmpq %rax, %rbx
je 0x1b7f3
cmpl $0x0, 0x81ca(%rip)      # 0x23930
je 0x1b78e
callq 0x1b529
movq 0x7bbc(%rip), %rax      # 0x23330
movq 0x18(%rax), %rcx
leaq 0x300b(%rip), %rdi      # 0x1e78a
movl $0xb, %esi
movl $0x1, %edx
callq 0x2240
movq 0x58(%rbx), %rax
movq %rax, 0x7b97(%rip)      # 0x23330
movq 0x18(%rbx), %rdi
cmpq %rdi, 0x18(%rax)
je 0x1b7c5
testq %rdi, %rdi
je 0x1b7c5
movq 0x7849(%rip), %rax      # 0x22ff8
cmpq %rdi, (%rax)
je 0x1b7c5
movq 0x77fd(%rip), %rax      # 0x22fb8
cmpq %rdi, (%rax)
je 0x1b7c5
callq 0x20c0
movl 0x28(%rbx), %eax
movq 0x7b61(%rip), %rcx      # 0x23330
movl %eax, 0x28(%rcx)
movq 0x50(%rbx), %rax
movq %rax, 0x50(%rcx)
movq %rbx, %rdi
callq 0x2030
movq 0x7b47(%rip), %rax      # 0x23330
movl (%rax), %eax
movl %eax, 0x813f(%rip)      # 0x23930
popq %rbx
retq
movq 0x7b26(%rip), %rax      # 0x23320
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movl 0xc(%rax), %edx
leaq 0x2f5e(%rip), %rdi      # 0x1e769
xorl %eax, %eax
callq 0x1b812
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1b873
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x777e(%rip), %rax      # 0x22ff8
movq (%rax), %rbx
movq 0x7aac(%rip), %rax      # 0x23330
testq %rax, %rax
jne 0x1b892
leaq 0xaba(%rip), %rdx       # 0x1c34a
jmp 0x1b8af
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
cmovneq %rax, %rbx
testq %rcx, %rcx
leaq 0xa9f(%rip), %rdx       # 0x1c34a
cmovneq %rcx, %rdx
leaq 0x2fe1(%rip), %rsi      # 0x1e897
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movq %rbx, %rdi
callq 0x21c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21c0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x7a13(%rip), %rax      # 0x23330
movq %rdi, 0x50(%rax)
callq 0x1b0a6
testl %eax, %eax
je 0x1b969
testb $0x2, 0x7fff(%rip)      # 0x23930
je 0x1b969
callq 0x1b529
movq 0x79f1(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
leaq 0x2e49(%rip), %rsi      # 0x1e796
xorl %eax, %eax
callq 0x2180
movq 0x79d5(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1b96e
incl 0x8(%rbx)
popq %rbx
retq
callq 0x2060
movl (%rax), %esi
leaq 0x2f2d(%rip), %rdi      # 0x1e8a9
xorl %eax, %eax
callq 0x1b812
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1b9e4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x1b529
movq 0x7940(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq 0x50(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x2d9b(%rip), %rsi      # 0x1e79e
xorl %eax, %eax
callq 0x2180
movq 0x791f(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq 0x78ef(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x2200
movq 0x78dc(%rip), %rax      # 0x23330
movq 0x18(%rax), %rsi
movl $0xa, %edi
callq 0x2130
movq 0x78c7(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1ba82
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
callq 0x2060
movl (%rax), %esi
leaq 0x2e19(%rip), %rdi      # 0x1e8a9
xorl %eax, %eax
callq 0x1b812
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x7891(%rip), %rax      # 0x23330
movq 0x50(%rax), %rax
cmpq %rdi, %rax
jne 0x1bb07
movq %rdi, %rbx
decl 0x8(%rdi)
callq 0x1b0a6
testl %eax, %eax
je 0x1baf6
testb $0x2, 0x7e72(%rip)      # 0x23930
je 0x1baf6
callq 0x1b529
movq 0x7864(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
leaq 0x2cf9(%rip), %rsi      # 0x1e7d3
xorl %eax, %eax
callq 0x2180
movq 0x7848(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1bb22
movq 0x20(%rbx), %rax
movq 0x782f(%rip), %rcx      # 0x23330
movq %rax, 0x50(%rcx)
popq %rbx
retq
movq (%rax), %rsi
movq 0x18(%rax), %rcx
movq (%rcx), %rdx
movl 0xc(%rax), %ecx
leaq 0x2c8b(%rip), %rdi      # 0x1e7a6
xorl %eax, %eax
callq 0x1b812
callq 0x2060
movl (%rax), %esi
leaq 0x2d79(%rip), %rdi      # 0x1e8a9
xorl %eax, %eax
callq 0x1b812
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x1bc16
movq %rdi, %rbx
movl %esi, %r14d
leaq 0x2c86(%rip), %r15      # 0x1e7e0
movq %rsp, %r13
leaq 0x2c82(%rip), %rbp      # 0x1e7e6
movq 0x77c5(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
leaq 0x2c65(%rip), %rsi      # 0x1e7db
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
xorl %r12d, %r12d
cmpq %r14, %r12
jge 0x1bbb5
movzbl (%rbx,%r12), %edx
leal -0x20(%rdx), %eax
cmpb $0x5f, %al
movl $0x2e, %eax
cmovbl %edx, %eax
movb %al, (%rsp,%r12)
movq 0x778b(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
jmp 0x1bbd7
movb $0x20, (%rsp,%r12)
movq 0x776f(%rip), %rax      # 0x23330
movq 0x18(%rax), %rcx
movl $0x3, %esi
movl $0x1, %edx
movq %rbp, %rdi
callq 0x2240
incq %r12
cmpq $0x10, %r12
jne 0x1bb83
movb $0x0, 0x10(%rsp)
movq 0x7744(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
leaq 0x2bf3(%rip), %rsi      # 0x1e7ea
movq %r13, %rdx
xorl %eax, %eax
callq 0x2180
addq $0x10, %rbx
leaq -0x10(%r14), %rax
cmpq $0x10, %r14
movq %rax, %r14
jg 0x1bb64
movq 0x7713(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x2c, (%rdi)
sete %bl
addq %rdi, %rbx
xorl %r15d, %r15d
movabsq $0x100000000, %rax      # imm = 0x100000000
xorl %r12d, %r12d
movzbl (%rbx,%r15), %ecx
testl %ecx, %ecx
je 0x1bc6e
cmpl $0x3a, %ecx
je 0x1bc6e
addq %rax, %r12
incq %r15
jmp 0x1bc58
sarq $0x20, %r12
leaq 0x7cc7(%rip), %r14      # 0x23940
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
testl $0xffffff00, %r15d      # imm = 0xFFFFFF00
movl $0xff, %edx
cmoveq %r12, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
sete %cl
leaq 0x767d(%rip), %rax      # 0x23338
cmpq %rax, %rdi
sete %dl
orb %cl, %dl
jne 0x1bce6
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
sete %cl
cmpq %rax, %rdi
sete %al
orb %cl, %al
je 0x1bce7
leaq 0x2bad(%rip), %rsi      # 0x1e891
jmp 0x1bcf3
retq
callq 0x1bcae
leaq 0x2b9d(%rip), %rsi      # 0x1e890
movq 0x7636(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
xorl %eax, %eax
popq %rbx
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
cmpl %r14d, %r15d
jle 0x11cb
leal -0x1(%r15), %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x117c
movl %eax, %ebp
leal -0x1(%r14), %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x117c
movl %eax, %r12d
decl %ebx
movl %ebx, %edi
movl %r15d, %esi
movl %r14d, %edx
callq 0x117c
movl %eax, %ebx
movl %ebp, %r15d
movl %r12d, %r14d
jmp 0x118c
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x4, %edi
jne 0x1228
movq 0x8(%rbx), %rdi
callq 0x1050
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1050
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x1050
movl %ebp, %edi
movl %r14d, %esi
movl %eax, %edx
callq 0x117c
leaq 0xdff(%rip), %rdi       # 0x2015
xorl %ebx, %ebx
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x1070
movl $0x1, %ebx
jmp 0x1221
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x121e
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
leaq 0x3e72(%rip), %r15      # 0x5058
cmovneq %rdx, %r15
movl $0x30, %esi
movq %r15, %rdi
callq *(%r15)
testq %rax, %rax
je 0x1216
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
jmp 0x1218
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ddf(%rip), %rdi      # 0x3004
leaq 0x1de8(%rip), %rsi      # 0x3014
leaq 0x1de6(%rip), %rcx      # 0x3019
movl $0x2a, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x129e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x129e
movq %rdi, %r14
movq (%rdi), %r12
testq %r12, %r12
je 0x128c
movq 0x10(%r12), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq *0x8(%r14)
testl %eax, %eax
js 0x1277
je 0x127f
addq $0x8, %r12
movq (%r12), %r12
movb $0x1, %al
jmp 0x1286
movq 0x10(%r12), %r15
xorl %eax, %eax
testb %al, %al
jne 0x1258
jmp 0x128f
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1f1b(%rip), %rdi      # 0x31c0
leaq 0x1d68(%rip), %rsi      # 0x3014
leaq 0x1dba(%rip), %rcx      # 0x306d
movl $0x44, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rsi, %rbx
callq 0x12bd
testq %rax, %rax
je 0x14e5
movq %rax, %rcx
movq (%rax), %rax
cmpq %rbx, %rax
je 0x14e5
movq %rbx, (%rcx)
jmp 0x14e7
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rsi, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq %rax, 0x190(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x198(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testq %rdi, %rdi
je 0x194b
testq %rsi, %rsi
je 0x194b
movq %rsi, (%rdi)
movq $0x0, 0x190(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x198(%rdi)
movq (%rsi), %rax
testq %rax, %rax
je 0x1917
cmpq $0x0, (%rax)
je 0x1919
movq 0x190(%rdi), %rcx
cmpq $0x30, %rcx
jae 0x192c
leaq 0x1(%rcx), %rdx
movq %rdx, 0x190(%rdi)
movq %rax, 0x10(%rdi,%rcx,8)
movq (%rax), %rax
cmpq $0x0, (%rax)
movq %rdx, %rcx
jne 0x18f3
jmp 0x1919
xorl %eax, %eax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x1928
movq 0x10(%rax), %rax
jmp 0x192a
xorl %eax, %eax
popq %rcx
retq
leaq 0x1823(%rip), %rdi      # 0x3156
leaq 0x16da(%rip), %rsi      # 0x3014
leaq 0x17da(%rip), %rcx      # 0x311b
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x1040
leaq 0x17ac(%rip), %rdi      # 0x30fe
leaq 0x16bb(%rip), %rsi      # 0x3014
leaq 0x17bb(%rip), %rcx      # 0x311b
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x1040