LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_actor_collection
void
gc_actor_collection(CONFIG* cfg, CONS* root)
/* initiate actor-based (CONCURRENT) garbage collection */
{
	CONS* actor;

	DBUG_ENTER("gc_actor_collection");
	gc_age_cells();			/* cells allocated after this are "fresh" */
	assert(consp(root));
	if (!nilp(root)) {
		gc_scan_cell(as_cell(root));	/* scan "root" */
	}
	actor = CFG_ACTOR(cfg, gc_scanning_actor, NIL);
	CFG_SEND(cfg, actor, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5c03(%rip), %rax      # 0x1dc2b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xb2fb(%rip), %rax      # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x142, 0xc(%rdi)       # imm = 0x142
leaq 0x42fa(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb225(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
callq 0x19574
testq %r14, %r14
je 0x180c9
movl %r14d, %eax
andl $0x3, %eax
jne 0x180c9
cmpq 0xaf3f(%rip), %r14      # 0x22fc0
je 0x1808b
movq %r14, %rdi
callq 0x17d8f
leaq -0x113(%rip), %rsi      # 0x17f7f
leaq 0xb207(%rip), %r14      # 0x232a0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x128be
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1299b
movq %rsp, %rdi
movl $0x14a, 0xc(%rdi)       # imm = 0x14A
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x5b1d(%rip), %rdi      # 0x1dbed
leaq 0x5a51(%rip), %rsi      # 0x1db28
leaq 0x5b61(%rip), %rcx      # 0x1dc3f
movl $0x144, %edx            # imm = 0x144
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_perm
CONS*
gc_perm(CONS* first, CONS* rest)
/* allocate and initialize a permanent cell (never garbage collected) */
{
	CELL* p;
	CONS* s;

	if (GC_SIZE(GC_PERM_LIST) == 0) {
		gc_allocate_cells(GC_PERM_LIST);
	}
	p = gc_pop(GC_PERM_LIST);
	assert(p != NULL);
	GC_SET_MARK(p, GC_PHASE_X);
	GC_SET_FIRST(p, first);
	GC_SET_REST(p, rest);
	s = as_cons(p);
	assert(consp(s));
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xb166(%rip)      # 0x23260
jne 0x18108
leaq 0xb15d(%rip), %rdi      # 0x23260
callq 0x1817f
leaq 0xb151(%rip), %rdi      # 0x23260
callq 0x17879
testq %rax, %rax
je 0x18141
movq 0x10(%rax), %rcx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
orq $0x40000000, %rcx       # imm = 0x40000000
movq %rcx, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
testb $0x3, %al
jne 0x18160
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x61d3(%rip), %rdi      # 0x1e31b
leaq 0x59d9(%rip), %rsi      # 0x1db28
leaq 0x5b14(%rip), %rcx      # 0x1dc6a
movl $0x175, %edx            # imm = 0x175
callq 0x2100
leaq 0x5b21(%rip), %rdi      # 0x1dc88
leaq 0x59ba(%rip), %rsi      # 0x1db28
leaq 0x5af5(%rip), %rcx      # 0x1dc6a
movl $0x17a, %edx            # imm = 0x17A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_allocate_cells
static void
gc_allocate_cells(CELL* list_head)
/* allocate a new block of free cells */
{
	size_t n;
	CELL* p;
	char* tag;

	DBUG_ENTER("gc_alloc_cells");
	gc_initialize();
	tag = ((list_head == GC_FREE_LIST) ? "free" : "permanent");
#if 1
	n = ((1 << 12) / sizeof(CELL));		/* 4Kb allocation */
#else
	n = ((1 << 8) / sizeof(CELL));		/* 256b allocation */
#endif
	p = NEWxN(CELL, n + 1);
	p = as_cell((as_word(p) + (sizeof(CELL) >> 1)) & ~(sizeof(CELL) - 1));
	DBUG_PRINT("gc", ("%u %s cells allocated starting at %p", n, tag, p));
	while (n > 0) {
		--n;
		GC_SET_MARK(p, GC_PHASE_Z);
		gc_put(list_head, p);
		++p;
	}
	DBUG_PRINT("gc", ("%u cells available in %s list", GC_SIZE(list_head), tag));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5f77(%rip), %rax      # 0x1e10d
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb18b(%rip), %r12      # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x155, 0xc(%rdi)       # imm = 0x155
leaq 0x4189(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb0b4(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
callq 0x19af9
leaq 0xb05b(%rip), %rax      # 0x23240
cmpq %rax, %rbx
leaq 0x4e87(%rip), %rax      # 0x1d076
leaq 0x5f26(%rip), %r14      # 0x1e11c
cmoveq %rax, %r14
movl $0x20, %edi
movl $0x81, %esi
callq 0x2160
movq %rax, %r15
addq $0x10, %r15
andq $-0x20, %r15
leaq 0xb715(%rip), %r13      # 0x23930
cmpl $0x0, (%r13)
je 0x18266
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x4ac3(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x18266
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x15f, 0xc(%rax)       # imm = 0x15F
leaq 0x5ed2(%rip), %rdi      # 0x1e126
movl $0x80, %esi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1ba97
movq %rbx, %rcx
sarq $0x2, %rcx
movq (%rbx), %rax
xorl %edx, %edx
leaq (%r15,%rdx), %rsi
andq $0x3fffffff, 0x10(%r15,%rdx) # imm = 0x3FFFFFFF
movq %rcx, 0x18(%r15,%rdx)
movq 0x10(%rbx), %rdi
shlq $0x2, %rdi
sarq $0x2, %rdi
movq %rdi, 0x10(%r15,%rdx)
sarq $0x2, %rsi
movq 0x10(%rbx), %rdi
movq %rsi, 0x18(,%rdi,4)
andl $0xc0000000, %edi       # imm = 0xC0000000
orq %rsi, %rdi
movq %rdi, 0x10(%rbx)
addq $0x20, %rdx
cmpq $0x1000, %rdx           # imm = 0x1000
jne 0x18272
subq $-0x80, %rax
movq %rax, (%rbx)
cmpl $0x0, (%r13)
je 0x1830c
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x4a18(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x1830c
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x166, 0xc(%rax)       # imm = 0x166
movq (%rbx), %rsi
leaq 0x5e49(%rip), %rdi      # 0x1e14b
movq %r14, %rdx
xorl %eax, %eax
callq 0x1ba97
leaq 0x8(%rsp), %rdi
movl $0x167, 0xc(%rdi)       # imm = 0x167
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_cons
CONS*
gc_cons(CONS* first, CONS* rest)
/* allocate and initialize a new "cons" cell */
{
	CELL* p;
	CONS* s;

	if (GC_SIZE(GC_FREE_LIST) == 0) {
		gc_allocate_cells(GC_FREE_LIST);
	}
	p = gc_pop(GC_FREE_LIST);
	assert(p != NULL);
	GC_SET_MARK(p, gc_phase__mark);
	GC_SET_FIRST(p, first);
	GC_SET_REST(p, rest);
	gc_put(GC_FRESH_LIST, p);
	/* FIXME: start gc scan if too few free cells remain */
	s = as_cons(p);
	assert(consp(s));
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xaf03(%rip)      # 0x23240
jne 0x1834b
leaq 0xaefa(%rip), %rdi      # 0x23240
callq 0x1817f
leaq 0xaeee(%rip), %rdi      # 0x23240
callq 0x17879
testq %rax, %rax
je 0x183e3
movq 0x10(%rax), %rcx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movq 0xaf27(%rip), %rdx      # 0x23298
orq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
leaq 0xae9a(%rip), %rcx      # 0x23220
incq 0xae93(%rip)            # 0x23220
sarq $0x2, %rcx
movq %rcx, 0x18(%rax)
movq 0xae94(%rip), %rcx      # 0x23230
shlq $0x2, %rcx
sarq $0x2, %rcx
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0x10(%rax)
movq %rax, %rcx
sarq $0x2, %rcx
movq 0xae71(%rip), %rdx      # 0x23230
movq %rcx, 0x18(,%rdx,4)
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0xae59(%rip)      # 0x23230
testb $0x3, %al
jne 0x18402
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5f31(%rip), %rdi      # 0x1e31b
leaq 0x5737(%rip), %rsi      # 0x1db28
leaq 0x5899(%rip), %rcx      # 0x1dc91
movl $0x189, %edx            # imm = 0x189
callq 0x2100
leaq 0x587f(%rip), %rdi      # 0x1dc88
leaq 0x5718(%rip), %rsi      # 0x1db28
leaq 0x587a(%rip), %rcx      # 0x1dc91
movl $0x190, %edx            # imm = 0x190
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_check_access
static CELL*
gc_check_access(CONS* cell)
/* ensure that accessed cells are considered "live" */
{
	CELL* p;

	assert(consp(cell));
	p = as_cell(cell);
	if (GC_MARK(p) == gc_phase__prev) {
		gc_scan_cell(p);	/* any "aged" cell accessed must be "live", so scan it */
	}
	return p;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1846a
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x1846a
movq 0x10(%rbx), %rax
andl $0xc0000000, %eax       # imm = 0xC0000000
cmpq 0xae35(%rip), %rax      # 0x23290
jne 0x18465
movq %rbx, %rdi
callq 0x17d8f
movq %rbx, %rax
popq %rbx
retq
leaq 0x5cf8(%rip), %rdi      # 0x1e169
leaq 0x56b0(%rip), %rsi      # 0x1db28
leaq 0x5cf6(%rip), %rcx      # 0x1e175
movl $0x19a, %edx            # imm = 0x19A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_refresh_cell
static BOOL
gc_refresh_cell()
/* process a cell from the "scan" list, return FALSE if none remain */
{
	CELL* p;

	DBUG_ENTER("gc_refresh_cell");
	if (GC_SIZE(GC_SCAN_LIST) == 0) {
		DBUG_PRINT("gc", ("empty scan list"));
		DBUG_RETURN FALSE;
	}
	p = gc_pop(GC_SCAN_LIST);
	assert(p != NULL);
	gc_scan_value(GC_FIRST(p));
	gc_scan_value(GC_REST(p));
	gc_push(GC_FRESH_LIST, p);
	DBUG_RETURN TRUE;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
leaq 0x4912(%rip), %rax      # 0x1e088
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9bad(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf7, 0xc(%rdi)
leaq 0x2bac(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x9ad7(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq $0x0, 0x9a42(%rip)      # 0x23200
je 0x1985a
leaq 0x9a35(%rip), %rdi      # 0x23200
callq 0x17879
testq %rax, %rax
je 0x198bd
movq %rax, %rbx
movq (%rax), %rdi
callq 0x198dc
movq 0x8(%rbx), %rdi
callq 0x198dc
incq 0x9a2c(%rip)            # 0x23220
leaq 0x9a25(%rip), %rax      # 0x23220
sarq $0x2, %rax
movq 0x10(%rbx), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x10(%rbx)
movq 0x9a21(%rip), %rax      # 0x23238
shlq $0x2, %rax
sarq $0x2, %rax
movq %rax, 0x18(%rbx)
sarq $0x2, %rbx
movq 0x9a0a(%rip), %rax      # 0x23238
movq 0x10(,%rax,4), %rcx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rbx, %rcx
movq %rcx, 0x10(,%rax,4)
movq %rbx, 0x99ea(%rip)      # 0x23238
movl $0x1, %ebx
movl $0x101, %ebp            # imm = 0x101
jmp 0x198a8
leaq 0xa0cf(%rip), %rax      # 0x23930
movl $0xfa, %ebp
cmpl $0x0, (%rax)
je 0x198a6
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x347b(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x198a6
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xf9, 0xc(%rax)
leaq 0x47fd(%rip), %rdi      # 0x1e098
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1ba97
jmp 0x198a8
xorl %ebx, %ebx
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1bbab
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4a57(%rip), %rdi      # 0x1e31b
leaq 0x425d(%rip), %rsi      # 0x1db28
leaq 0x47d6(%rip), %rcx      # 0x1e0a8
movl $0xfd, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x47d2(%rip), %rax      # 0x1e0bf
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9a36(%rip), %r14      # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xe3, 0xc(%rdi)
leaq 0x2a35(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x9960(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x9ffc(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19973
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x33ad(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x19973
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xe4, 0xc(%rax)
leaq 0x4764(%rip), %rdi      # 0x1e0cd
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1ba97
movl $0xee, %eax
cmpq 0x9641(%rip), %rbx      # 0x22fc0
je 0x199af
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 0x199af
callq 0x17d8f
movl $0xeb, %eax
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x470a(%rip), %rax      # 0x1e0da
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x9953(%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 0x2952(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x987d(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x9f19(%rip), %r14      # 0x23930
cmpl $0x0, (%r14)
je 0x19a5b
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x32c9(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x19a5b
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x109, 0xc(%rax)       # imm = 0x109
movq 0x97d3(%rip), %rsi      # 0x23220
leaq 0x4694(%rip), %rdi      # 0x1e0e8
xorl %eax, %eax
callq 0x1ba97
leaq 0x97de(%rip), %rdi      # 0x23240
leaq 0x9777(%rip), %rsi      # 0x231e0
callq 0x1799b
cmpl $0x0, (%r14)
je 0x19ab2
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3272(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x19ab2
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x10b, 0xc(%rax)       # imm = 0x10B
movq 0x979c(%rip), %rsi      # 0x23240
leaq 0x451d(%rip), %rdi      # 0x1dfc8
xorl %eax, %eax
callq 0x1ba97
leaq 0x9727(%rip), %rdi      # 0x231e0
callq 0x17a5e
leaq 0x973b(%rip), %rdi      # 0x23200
callq 0x17a5e
leaq 0x974f(%rip), %rdi      # 0x23220
callq 0x17a5e
leaq 0x9763(%rip), %rdi      # 0x23240
callq 0x17a5e
movq %rsp, %rdi
movl $0x112, 0xc(%rdi)       # imm = 0x112
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x9793(%rip)      # 0x23298
jne 0x19c3d
pushq %rbx
leaq 0x9e1d(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19b56
leaq 0x9811(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x281d(%rip), %rdi      # 0x1c34a
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x19b56
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x1d, 0xc(%rax)
leaq 0x4644(%rip), %rdi      # 0x1e193
xorl %eax, %eax
callq 0x1ba97
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, 0x972e(%rip)      # 0x23290
orq $0x40000000, %rax       # imm = 0x40000000
movq %rax, 0x9729(%rip)      # 0x23298
leaq 0x966a(%rip), %rax      # 0x231e0
sarq $0x2, %rax
movq %rax, 0x9677(%rip)      # 0x231f8
movq 0x9668(%rip), %rcx      # 0x231f0
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9658(%rip)      # 0x231f0
leaq 0x9661(%rip), %rax      # 0x23200
sarq $0x2, %rax
movq %rax, 0x966e(%rip)      # 0x23218
movq 0x965f(%rip), %rcx      # 0x23210
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x964f(%rip)      # 0x23210
leaq 0x9658(%rip), %rax      # 0x23220
sarq $0x2, %rax
movq %rax, 0x9665(%rip)      # 0x23238
movq 0x9656(%rip), %rcx      # 0x23230
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9646(%rip)      # 0x23230
leaq 0x964f(%rip), %rax      # 0x23240
sarq $0x2, %rax
movq %rax, 0x965c(%rip)      # 0x23258
movq 0x964d(%rip), %rcx      # 0x23250
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x963d(%rip)      # 0x23250
leaq 0x9646(%rip), %rax      # 0x23260
sarq $0x2, %rax
movq %rax, 0x9653(%rip)      # 0x23278
movq 0x9644(%rip), %rcx      # 0x23270
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0x9634(%rip)      # 0x23270
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9626(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x19c9a
movl %edi, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19ced
testq %rdi, %rdi
je 0x19cf2
testq %rax, %rax
jne 0x19cf2
popq %rbx
jmp 0x18421
leaq 0x9c8f(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19ce4
leaq 0x9683(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x2888(%rip), %rdi      # 0x1c543
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x19ce4
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x35, 0xc(%rax)
leaq 0x450b(%rip), %rdi      # 0x1e1e8
xorl %eax, %eax
callq 0x1ba97
leaq 0x95b5(%rip), %rax      # 0x232a0
popq %rbx
retq
callq 0x25b9
leaq 0x320a(%rip), %rdi      # 0x1cf03
leaq 0x4523(%rip), %rsi      # 0x1e223
leaq 0x4523(%rip), %rcx      # 0x1e22a
movl $0x40, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x9587(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x19d39
movl %edi, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19d8c
testq %rdi, %rdi
je 0x19d91
testq %rax, %rax
jne 0x19d91
popq %rbx
jmp 0x18489
leaq 0x9bf0(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x19d83
leaq 0x95e4(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x27fb(%rip), %rdi      # 0x1c555
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x19d83
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x4e, 0xc(%rax)
leaq 0x44c1(%rip), %rdi      # 0x1e23d
xorl %eax, %eax
callq 0x1ba97
leaq 0x9516(%rip), %rax      # 0x232a0
popq %rbx
retq
callq 0x2625
leaq 0x316b(%rip), %rdi      # 0x1cf03
leaq 0x4484(%rip), %rsi      # 0x1e223
leaq 0x44d2(%rip), %rcx      # 0x1e278
movl $0x59, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x19e88
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94b9(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
sete %cl
cmpq %rax, %rsi
sete %al
orb %cl, %al
jne 0x19e80
movl %r14d, %ecx
andl $0x3, %ecx
cmpq $0x1, %rcx
je 0x19e80
movl %ebx, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19e80
testq %r14, %r14
sete %dl
testq %rcx, %rcx
setne %cl
orb %dl, %cl
jne 0x19e80
testq %rbx, %rbx
sete %cl
testq %rax, %rax
setne %al
orb %cl, %al
jne 0x19e80
movq %r14, %rdi
callq 0x19c72
movq %rax, %r15
movq %rbx, %rdi
callq 0x19c72
movq %r15, %rdi
movq %rax, %rsi
callq 0x19dcc
testq %rax, %rax
je 0x19e80
movq %r14, %rdi
callq 0x19d11
movq %rax, %r14
movq %rbx, %rdi
callq 0x19d11
movq %r14, %rdi
movq %rax, %rsi
callq 0x19dcc
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x19e82
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19ef5
movq %rdi, %r14
movl %r14d, %eax
andl $0x3, %eax
jne 0x19ef5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19f14
movl %ebx, %eax
andl $0x3, %eax
jne 0x19f14
leaq 0x93e7(%rip), %rax      # 0x232a0
cmpq %rax, %r14
je 0x19eec
movq %r14, %rdi
callq 0x19c72
movq %rax, %r15
movq %r14, %rdi
callq 0x19d11
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19e8e
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x438f(%rip), %rdi      # 0x1e28b
leaq 0x4320(%rip), %rsi      # 0x1e223
leaq 0x438a(%rip), %rcx      # 0x1e294
movl $0x90, %edx
callq 0x2100
leaq 0x4396(%rip), %rdi      # 0x1e2b1
leaq 0x4301(%rip), %rsi      # 0x1e223
leaq 0x436b(%rip), %rcx      # 0x1e294
movl $0x91, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x9361(%rip), %r14      # 0x232a0
cmpq %r14, %rdi
je 0x19f83
movq %rdi, %rbx
leaq 0x9352(%rip), %r15      # 0x232a0
movq %r15, %r14
testq %rbx, %rbx
je 0x19f8c
movl %ebx, %eax
andl $0x3, %eax
jne 0x19f8c
movq %rbx, %rdi
callq 0x19c72
movq %rax, %rdi
movq %r14, %rsi
callq 0x19c50
movq %rax, %r14
movq %rbx, %rdi
callq 0x19d11
movq %rax, %rbx
cmpq %r15, %rax
jne 0x19f51
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4327(%rip), %rdi      # 0x1e2ba
leaq 0x4289(%rip), %rsi      # 0x1e223
leaq 0x4325(%rip), %rcx      # 0x1e2c6
movl $0x9f, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x92ea(%rip), %r14      # 0x232a0
cmpq %r14, %rdi
je 0x19fdd
movq %rdi, %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x19fe9
movl %eax, %ecx
andl $0x3, %ecx
jne 0x19fe9
incl %ebx
movq %rax, %rdi
callq 0x19d11
cmpq %r14, %rax
jne 0x19fc0
jmp 0x19fdf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x42ca(%rip), %rdi      # 0x1e2ba
leaq 0x422c(%rip), %rsi      # 0x1e223
leaq 0x42de(%rip), %rcx      # 0x1e2dc
movl $0xac, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x928c(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x1a057
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x1a096
leaq 0x926f(%rip), %rcx      # 0x232a0
cmpq %rcx, %rax
je 0x1a043
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19d11
testq %r14, %r14
setne %al
testb $0x3, %r14b
sete %cl
testb %cl, %al
jne 0x1a05d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x19c72
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a008
movq %rax, %r15
movq %r14, %rdi
callq 0x19d11
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a008
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O3/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 0x91fb(%rip), %r15      # 0x232a0
cmpq %r15, %rdi
je 0x1a0f9
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x91e9(%rip), %r12      # 0x232a0
testq %r14, %r14
je 0x1a108
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a108
movq %r14, %rdi
callq 0x19c72
testq %rax, %rax
je 0x1a127
movq %rax, %r15
andl $0x3, %eax
jne 0x1a127
movq %r15, %rdi
callq 0x19c72
cmpq %rbx, %rax
je 0x1a0f9
movq %r14, %rdi
callq 0x19d11
movq %rax, %r14
cmpq %r12, %rax
jne 0x1a0b7
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x41e0(%rip), %rdi      # 0x1e2ef
leaq 0x410d(%rip), %rsi      # 0x1e223
leaq 0x41dd(%rip), %rcx      # 0x1e2fa
movl $0xda, %edx
callq 0x2100
leaq 0x2f6a(%rip), %rdi      # 0x1d098
leaq 0x40ee(%rip), %rsi      # 0x1e223
leaq 0x41be(%rip), %rcx      # 0x1e2fa
movl $0xdc, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x1a173
testq %rsi, %rsi
je 0x1a192
movq %rdx, %rbx
callq 0x1a096
leaq 0x9140(%rip), %rcx      # 0x232a0
cmpq %rcx, %rax
je 0x1a16e
movq %rax, %rdi
popq %rbx
jmp 0x19d11
movq %rbx, %rax
popq %rbx
retq
leaq 0x419f(%rip), %rdi      # 0x1e319
leaq 0x40a2(%rip), %rsi      # 0x1e223
leaq 0x419d(%rip), %rcx      # 0x1e325
movl $0xeb, %edx
callq 0x2100
leaq 0x41b6(%rip), %rdi      # 0x1e34f
leaq 0x4083(%rip), %rsi      # 0x1e223
leaq 0x417e(%rip), %rcx      # 0x1e325
movl $0xec, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x1a1e9
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x1a1e9
testq %rsi, %rsi
je 0x1a208
testq %rdx, %rdx
je 0x1a227
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19c50
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x19c50
leaq 0x416b(%rip), %rdi      # 0x1e35b
leaq 0x402c(%rip), %rsi      # 0x1e223
leaq 0x4175(%rip), %rcx      # 0x1e373
movl $0x101, %edx            # imm = 0x101
callq 0x2100
leaq 0x4140(%rip), %rdi      # 0x1e34f
leaq 0x400d(%rip), %rsi      # 0x1e223
leaq 0x4156(%rip), %rcx      # 0x1e373
movl $0x103, %edx            # imm = 0x103
callq 0x2100
leaq 0x416b(%rip), %rdi      # 0x1e399
leaq 0x3fee(%rip), %rsi      # 0x1e223
leaq 0x4137(%rip), %rcx      # 0x1e373
movl $0x105, %edx            # imm = 0x105
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x9047(%rip), %r13      # 0x232a0
cmpq %r13, %rsi
je 0x1a2c0
movq %rsi, %r14
testq %r14, %r14
je 0x1a2c0
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a2c0
movq %r14, %rdi
callq 0x19c72
movq %rax, %r15
testq %rax, %rax
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x1a2ae
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
movq %r15, %rdi
callq 0x19d11
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a1b8
movq %rax, %rbx
movq %r14, %rdi
callq 0x19d11
cmpq %r13, %rax
je 0x1a2c0
movq %rax, %r14
jmp 0x1a261
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a377
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x1a377
movq %rsi, %r15
leaq 0x8fa9(%rip), %r13      # 0x232a0
cmpq %r13, %rsi
je 0x1a36a
testq %r15, %r15
je 0x1a36a
movl %r15d, %eax
andl $0x3, %eax
jne 0x1a36a
movq %rdx, %r14
cmpq %r13, %r14
je 0x1a36a
testq %r14, %r14
je 0x1a36a
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a36a
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
movq %r14, %rdi
callq 0x19c72
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a1b8
movq %rax, %rbx
movq %r15, %rdi
callq 0x19d11
movq %rax, %r15
movq %r14, %rdi
callq 0x19d11
cmpq %r13, %r15
je 0x1a36a
testq %r15, %r15
je 0x1a36a
movq %rax, %r14
movl %r15d, %eax
andl $0x3, %eax
je 0x1a30c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3f71(%rip), %rdi      # 0x1e2ef
leaq 0x3e9e(%rip), %rsi      # 0x1e223
leaq 0x4019(%rip), %rcx      # 0x1e3a5
movl $0x11b, %edx            # imm = 0x11B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x8efa(%rip), %r15      # 0x232a0
cmpq %r15, %rdi
je 0x1a418
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8ee8(%rip), %r13      # 0x232a0
movq %r13, %r15
testq %r14, %r14
je 0x1a429
movl %r14d, %eax
andl $0x3, %eax
jne 0x1a429
movq %r14, %rdi
callq 0x19c72
testq %rax, %rax
je 0x1a448
movq %rax, %r12
andl $0x3, %eax
jne 0x1a448
movq %r12, %rdi
callq 0x19c72
cmpq %rbx, %rax
je 0x1a408
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a096
cmpq %r13, %rax
jne 0x1a408
movq %r12, %rdi
movq %r15, %rsi
callq 0x19c50
movq %rax, %r15
movq %r14, %rdi
callq 0x19d11
movq %rax, %r14
cmpq %r13, %rax
jne 0x1a3bb
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x19f33
leaq 0x3ebf(%rip), %rdi      # 0x1e2ef
leaq 0x3dec(%rip), %rsi      # 0x1e223
leaq 0x3f8d(%rip), %rcx      # 0x1e3cb
movl $0x12e, %edx            # imm = 0x12E
callq 0x2100
leaq 0x2ab4(%rip), %rdi      # 0x1cf03
leaq 0x3dcd(%rip), %rsi      # 0x1e223
leaq 0x3f6e(%rip), %rcx      # 0x1e3cb
movl $0x130, %edx            # imm = 0x130
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x8e29(%rip), %rax      # 0x232a0
cmpq %rax, %rdi
je 0x1a4e8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8e17(%rip), %r13      # 0x232a0
movq %r13, %r15
movq %rdi, %r12
testq %r12, %r12
je 0x1a4f2
movl %r12d, %eax
andl $0x3, %eax
jne 0x1a4f2
movq %r12, %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x19c72
cmpq %r14, %rax
je 0x1a4c6
movq %r12, %rdi
callq 0x19d11
movq %r12, %r15
movq %rax, %r12
cmpq %r13, %rax
jne 0x1a48f
jmp 0x1a4e5
leaq 0x8dd3(%rip), %r14      # 0x232a0
movq %r12, %rdi
callq 0x19d11
cmpq %r14, %r15
je 0x1a4e8
movq %r15, %rdi
movq %rax, %rsi
callq 0x184e6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3df6(%rip), %rdi      # 0x1e2ef
leaq 0x3d23(%rip), %rsi      # 0x1e223
leaq 0x3ee5(%rip), %rcx      # 0x1e3ec
movl $0x149, %edx            # imm = 0x149
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x1937d
movl 0x897b(%rip), %esi      # 0x23920
leaq 0x2a85(%rip), %rdi      # 0x1da31
xorl %eax, %eax
callq 0x20e0
leaq 0x82e6(%rip), %rax      # 0x232a0
cmpq %rax, 0x82df(%rip)      # 0x232a0
jne 0x1afce
cmpq %rax, 0x82de(%rip)      # 0x232a8
jne 0x1afed
popq %rax
retq
leaq 0x3463(%rip), %rdi      # 0x1e438
leaq 0x3247(%rip), %rsi      # 0x1e223
leaq 0x366d(%rip), %rcx      # 0x1e650
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2100
leaq 0x346a(%rip), %rdi      # 0x1e45e
leaq 0x3228(%rip), %rsi      # 0x1e223
leaq 0x364e(%rip), %rcx      # 0x1e650
movl $0x1b6, %edx            # imm = 0x1B6
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19dcc
testq %rax, %rax
je 0x1b035
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x88f4(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x1b04c
movq %r15, %rdi
movq %r14, %rsi
callq 0x2691
movq 0x7fa5(%rip), %rax      # 0x22ff8
movq (%rax), %rdi
testq %rbx, %rbx
leaq 0x12ea(%rip), %rdx      # 0x1c34a
cmovneq %rbx, %rdx
leaq 0x35fe(%rip), %rsi      # 0x1e669
xorl %eax, %eax
callq 0x2180
callq 0x2050
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1b0b7
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 0x35d8(%rip), %rdi      # 0x1e696
leaq 0x35de(%rip), %rsi      # 0x1e6a3
leaq 0x35de(%rip), %rcx      # 0x1e6aa
movl $0x10, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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
leaq (%rax,%rsi), %rcx
cmpq (%rdx), %rcx
jae 0x1b185
movb (%rdi), %cl
testb %cl, %cl
sete %r8b
testq %rsi, %rsi
sete %r9b
orb %r8b, %r9b
jne 0x1b17d
movl $0x1, %r8d
movq 0x10(%rdx), %r9
movb %cl, (%r9,%rax)
movq 0x8(%rdx), %rax
incq %rax
movq %rax, 0x8(%rdx)
movb (%rdi,%r8), %cl
testb %cl, %cl
je 0x1b17d
leaq 0x1(%r8), %r9
cmpq %r8, %rsi
movq %r9, %r8
jne 0x1b156
movq 0x10(%rdx), %rcx
movb $0x0, (%rcx,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, 0x877b(%rip)      # 0x23930
je 0x1b201
movq 0x8172(%rip), %rbx      # 0x23330
movq 0x50(%rbx), %r14
movl 0x8(%r14), %eax
cmpl 0x24(%rbx), %eax
jg 0x1b201
movq 0x8(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x1b20b
testl %eax, %eax
je 0x1b201
movq 0x38(%rbx), %rdi
movq 0x18(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x1b20b
testl %eax, %eax
je 0x1b201
movq 0x40(%rbx), %rdi
movq (%r14), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b20b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b2e4
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 0x1b2d6
cmpl $0x3a, %r14d
je 0x1b2d6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b2c4
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 0x1b293
btq %r12, %r13
jb 0x1b29a
incq %r14
decl %eax
jmp 0x1b282
testl %eax, %eax
jne 0x1b2b2
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x2080
testl %eax, %eax
je 0x1b2c8
xorl %ecx, %ecx
cmpl $0x3a, %r12d
je 0x1b2cd
movq %r14, %rbp
testl %r12d, %r12d
jne 0x1b27b
jmp 0x1b2cd
xorl %eax, %eax
jmp 0x1b2d6
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_O3/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 0x7acd(%rip), %rbx      # 0x23330
leaq 0x7a66(%rip), %rax      # 0x232d0
cmpq %rax, %rbx
je 0x1b907
cmpl $0x0, 0x80b6(%rip)      # 0x23930
je 0x1b8a2
callq 0x1b629
movq 0x7aa8(%rip), %rax      # 0x23330
movq 0x18(%rax), %rcx
leaq 0x2ef7(%rip), %rdi      # 0x1e78a
movl $0xb, %esi
movl $0x1, %edx
callq 0x2240
movq 0x58(%rbx), %rax
movq %rax, 0x7a83(%rip)      # 0x23330
movq 0x18(%rbx), %rdi
cmpq %rdi, 0x18(%rax)
je 0x1b8e0
testq %rdi, %rdi
je 0x1b8e0
movq 0x7735(%rip), %rcx      # 0x22ff8
cmpq %rdi, (%rcx)
je 0x1b8e0
movq 0x76e9(%rip), %rcx      # 0x22fb8
cmpq %rdi, (%rcx)
je 0x1b8e0
callq 0x20c0
movq 0x7a50(%rip), %rax      # 0x23330
movl 0x28(%rbx), %ecx
movl %ecx, 0x28(%rax)
movq 0x50(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rbx, %rdi
callq 0x2030
movq 0x7a33(%rip), %rax      # 0x23330
movl (%rax), %eax
movl %eax, 0x802b(%rip)      # 0x23930
popq %rbx
retq
movq 0x7a12(%rip), %rax      # 0x23320
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movl 0xc(%rax), %edx
leaq 0x2e4a(%rip), %rdi      # 0x1e769
xorl %eax, %eax
callq 0x1b926
// File: /workspace/github_c_makefile_star2_O3/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 0x1b987
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 0x766a(%rip), %rax      # 0x22ff8
movq (%rax), %rbx
movq 0x7998(%rip), %rax      # 0x23330
testq %rax, %rax
jne 0x1b9a6
leaq 0x9a6(%rip), %rdx       # 0x1c34a
jmp 0x1b9c3
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
cmovneq %rax, %rbx
testq %rcx, %rcx
leaq 0x98b(%rip), %rdx       # 0x1c34a
cmovneq %rcx, %rdx
leaq 0x2ecd(%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_O3/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 0x78ff(%rip), %rax      # 0x23330
movq %rdi, 0x50(%rax)
callq 0x1b1aa
testl %eax, %eax
je 0x1ba7d
testb $0x2, 0x7eeb(%rip)      # 0x23930
je 0x1ba7d
callq 0x1b629
movq 0x78dd(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
leaq 0x2d35(%rip), %rsi      # 0x1e796
xorl %eax, %eax
callq 0x2180
movq 0x78c1(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1ba82
incl 0x8(%rbx)
popq %rbx
retq
callq 0x2060
movl (%rax), %esi
leaq 0x2e19(%rip), %rdi      # 0x1e8a9
xorl %eax, %eax
callq 0x1b926
// File: /workspace/github_c_makefile_star2_O3/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 0x1baf8
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 0x1b629
movq 0x782c(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq 0x50(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x2c87(%rip), %rsi      # 0x1e79e
xorl %eax, %eax
callq 0x2180
movq 0x780b(%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 0x77db(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x2200
movq 0x77c8(%rip), %rax      # 0x23330
movq 0x18(%rax), %rsi
movl $0xa, %edi
callq 0x2130
movq 0x77b3(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1bb96
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
callq 0x2060
movl (%rax), %esi
leaq 0x2d05(%rip), %rdi      # 0x1e8a9
xorl %eax, %eax
callq 0x1b926
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x777a(%rip), %r14      # 0x23330
movq 0x50(%r14), %rax
cmpq %rdi, %rax
jne 0x1bc24
movq %rdi, %rbx
decl 0x8(%rdi)
callq 0x1b1aa
testl %eax, %eax
je 0x1bc14
testb $0x2, 0x7d5b(%rip)      # 0x23930
je 0x1bc14
callq 0x1b629
movq 0x774d(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
leaq 0x2be2(%rip), %rsi      # 0x1e7d3
xorl %eax, %eax
callq 0x2180
movq 0x7731(%rip), %rax      # 0x23330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1bc3f
movq 0x771c(%rip), %r14      # 0x23330
movq 0x20(%rbx), %rax
movq %rax, 0x50(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rax), %rsi
movq 0x18(%rax), %rcx
movq (%rcx), %rdx
movl 0xc(%rax), %ecx
leaq 0x2b6e(%rip), %rdi      # 0x1e7a6
xorl %eax, %eax
callq 0x1b926
callq 0x2060
movl (%rax), %esi
leaq 0x2c5c(%rip), %rdi      # 0x1e8a9
xorl %eax, %eax
callq 0x1b926