LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/gc.c
// Function: gc_scan_cell
static void
gc_scan_cell(CELL* p)
/* move a live cell (from the "aged" list) to the "scan" list */
{
	WORD mark;

	DBUG_ENTER("gc_scan_cell");
	DBUG_PRINT("gc", ("p = %p", p));
	mark = GC_MARK(p);
	if (mark == gc_phase__mark) {
		DBUG_PRINT("gc", ("cell already marked"));
		DBUG_RETURN;		/* cell already marked in this phase */
	}
	assert(mark == gc_phase__prev);
	GC_SET_SIZE(GC_AGED_LIST, GC_SIZE(GC_AGED_LIST) - 1);
	p = gc_extract(p);	
	GC_SET_MARK(p, gc_phase__mark);
	gc_put(GC_SCAN_LIST, p);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6ba2(%rip), %rax      # 0x1e00f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xceb6(%rip), %r14      # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xd0, 0xc(%rdi)
leaq 0x4eb5(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xcde0(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0xd47c(%rip), %r15      # 0x24930
cmpl $0x0, (%r15)
je 0x174f4
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x582c(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x174f4
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
leaq 0x6b32(%rip), %rdi      # 0x1e01c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x10(%rbx), %rax
andl $0xc0000000, %eax       # imm = 0xC0000000
movq 0xcd94(%rip), %r12      # 0x24298
cmpq %r12, %rax
jne 0x1754d
movl $0xd5, %ebx
cmpl $0x0, (%r15)
je 0x17589
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x57d2(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x17589
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd4, 0xc(%rax)
leaq 0x6adf(%rip), %rdi      # 0x1e023
xorl %eax, %eax
callq 0x1b0f0
jmp 0x17589
cmpq 0xcd3c(%rip), %rax      # 0x24290
jne 0x175a0
decq 0xcc83(%rip)            # 0x241e0
movq %rbx, %rdi
callq 0x16fbb
movq 0x10(%rbx), %rax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
orq %r12, %rax
movq %rax, 0x10(%rbx)
leaq 0xcc84(%rip), %rdi      # 0x24200
movq %rbx, %rsi
callq 0x17042
movl $0xdc, %ebx
movq %rsp, %rdi
movl %ebx, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6a90(%rip), %rdi      # 0x1e037
leaq 0x655a(%rip), %rsi      # 0x1db08
leaq 0x6a99(%rip), %rcx      # 0x1e04e
movl $0xd7, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/gc.c
// Function: gc_scanning_actor
BEH_DECL(gc_scanning_actor)
{
	DBUG_ENTER("gc_scanning_actor");
	if (gc_refresh_cell() == TRUE) {
		SEND(SELF, NIL);			/* more aged cells to scan */
	} else {
		gc_free_cells();			/* scanning complete */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x662b(%rip), %rax      # 0x1dbf9
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xcd53(%rip), %rax      # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x133, 0xc(%rdi)       # imm = 0x133
leaq 0x4d52(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xcc7d(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
callq 0x18cd4
cmpq $0x1, %rax
je 0x17622
callq 0x18ed5
jmp 0x1763d
movq 0x30(%rbx), %rdi
callq 0x191fb
leaq 0xcc6e(%rip), %rdx      # 0x242a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12494
leaq 0x8(%rsp), %rdi
movl $0x139, 0xc(%rdi)       # imm = 0x139
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x65a3(%rip), %rax      # 0x1dc0b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xccbb(%rip), %rax      # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x142, 0xc(%rdi)       # imm = 0x142
leaq 0x4cba(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xcbe5(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
callq 0x18adf
testq %r14, %r14
je 0x17709
movl %r14d, %eax
andl $0x3, %eax
jne 0x17709
cmpq 0xc8ff(%rip), %r14      # 0x23fc0
je 0x176cb
movq %r14, %rdi
callq 0x17458
leaq -0x113(%rip), %rsi      # 0x175bf
leaq 0xcbc7(%rip), %r14      # 0x242a0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x123b7
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x12494
movq %rsp, %rdi
movl $0x14a, 0xc(%rdi)       # imm = 0x14A
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x64bd(%rip), %rdi      # 0x1dbcd
leaq 0x63f1(%rip), %rsi      # 0x1db08
leaq 0x6501(%rip), %rcx      # 0x1dc1f
movl $0x144, %edx            # imm = 0x144
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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, 0xcb26(%rip)      # 0x24260
jne 0x17748
leaq 0xcb1d(%rip), %rdi      # 0x24260
callq 0x177bf
leaq 0xcb11(%rip), %rdi      # 0x24260
callq 0x17020
testq %rax, %rax
je 0x17781
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 0x177a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6b73(%rip), %rdi      # 0x1e2fb
leaq 0x6379(%rip), %rsi      # 0x1db08
leaq 0x64b4(%rip), %rcx      # 0x1dc4a
movl $0x175, %edx            # imm = 0x175
callq 0x2100
leaq 0x64c1(%rip), %rdi      # 0x1dc68
leaq 0x635a(%rip), %rsi      # 0x1db08
leaq 0x6495(%rip), %rcx      # 0x1dc4a
movl $0x17a, %edx            # imm = 0x17A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x6916(%rip), %rax      # 0x1e0ed
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xcb4c(%rip), %r12      # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x155, 0xc(%rdi)       # imm = 0x155
leaq 0x4b4a(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xca75(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
callq 0x1900c
leaq 0xca1c(%rip), %rax      # 0x24240
cmpq %rax, %rbx
leaq 0x5848(%rip), %rax      # 0x1d076
leaq 0x68c7(%rip), %r14      # 0x1e0fc
cmoveq %rax, %r14
pushq $0x20
popq %rdi
movl $0x81, %esi
callq 0x2160
movq %rax, %r15
addq $0x10, %r15
andq $-0x20, %r15
leaq 0xd0d8(%rip), %r13      # 0x24930
cmpl $0x0, (%r13)
je 0x178a3
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x5486(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x178a3
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x15f, 0xc(%rax)       # imm = 0x15F
leaq 0x6875(%rip), %rdi      # 0x1e106
movl $0x80, %esi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1b0f0
xorl %ebp, %ebp
cmpq $0x1000, %rbp           # imm = 0x1000
je 0x178c9
leaq (%r15,%rbp), %rsi
andq $0x3fffffff, 0x10(%r15,%rbp) # imm = 0x3FFFFFFF
movq %rbx, %rdi
callq 0x17042
addq $0x20, %rbp
jmp 0x178a5
cmpl $0x0, (%r13)
je 0x1790f
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0x5415(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x1790f
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x166, 0xc(%rax)       # imm = 0x166
movq (%rbx), %rsi
leaq 0x6826(%rip), %rdi      # 0x1e12b
movq %r14, %rdx
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0x167, 0xc(%rdi)       # imm = 0x167
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xc900(%rip)      # 0x24240
jne 0x1794e
leaq 0xc8f7(%rip), %rdi      # 0x24240
callq 0x177bf
leaq 0xc8eb(%rip), %rdi      # 0x24240
callq 0x17020
testq %rax, %rax
je 0x1799b
movq %rax, %r15
movq 0x10(%rax), %rax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
orq 0xc926(%rip), %rax      # 0x24298
movq %rax, 0x10(%r15)
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
leaq 0xc89c(%rip), %rdi      # 0x24220
movq %r15, %rsi
callq 0x17042
testb $0x3, %r15b
jne 0x179ba
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6959(%rip), %rdi      # 0x1e2fb
leaq 0x615f(%rip), %rsi      # 0x1db08
leaq 0x62c1(%rip), %rcx      # 0x1dc71
movl $0x189, %edx            # imm = 0x189
callq 0x2100
leaq 0x62a7(%rip), %rdi      # 0x1dc68
leaq 0x6140(%rip), %rsi      # 0x1db08
leaq 0x62a2(%rip), %rcx      # 0x1dc71
movl $0x190, %edx            # imm = 0x190
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x17a22
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x17a22
movq 0x10(%rbx), %rax
andl $0xc0000000, %eax       # imm = 0xC0000000
cmpq 0xc87d(%rip), %rax      # 0x24290
jne 0x17a1d
movq %rbx, %rdi
callq 0x17458
movq %rbx, %rax
popq %rbx
retq
leaq 0x6720(%rip), %rdi      # 0x1e149
leaq 0x60d8(%rip), %rsi      # 0x1db08
leaq 0x671e(%rip), %rcx      # 0x1e155
movl $0x19a, %edx            # imm = 0x19A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x5387(%rip), %rax      # 0x1e068
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xb642(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf7, 0xc(%rdi)
leaq 0x3641(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb56c(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq $0x0, 0xb4d7(%rip)      # 0x24200
je 0x18d6d
leaq 0xb4ce(%rip), %rdi      # 0x24200
callq 0x17020
testq %rax, %rax
je 0x18dd0
movq %rax, %rbx
movq (%rax), %rdi
callq 0x18def
movq 0x8(%rbx), %rdi
callq 0x18def
leaq 0xb4c5(%rip), %rdi      # 0x24220
movq %rbx, %rsi
callq 0x17018
pushq $0x1
popq %rbx
movl $0x101, %ebp            # imm = 0x101
jmp 0x18dbb
leaq 0xbbbc(%rip), %rax      # 0x24930
movl $0xfa, %ebp
cmpl $0x0, (%rax)
je 0x18db9
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3f68(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x18db9
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0xf9, 0xc(%rax)
leaq 0x52ca(%rip), %rdi      # 0x1e078
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1b0f0
jmp 0x18dbb
xorl %ebx, %ebx
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1b1f2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5524(%rip), %rdi      # 0x1e2fb
leaq 0x4d2a(%rip), %rsi      # 0x1db08
leaq 0x52a3(%rip), %rcx      # 0x1e088
movl $0xfd, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x529f(%rip), %rax      # 0x1e09f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xb523(%rip), %r14      # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xe3, 0xc(%rdi)
leaq 0x3522(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb44d(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0xbae9(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x18e86
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x3e9a(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x18e86
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xe4, 0xc(%rax)
leaq 0x5231(%rip), %rdi      # 0x1e0ad
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
movl $0xee, %eax
cmpq 0xb12e(%rip), %rbx      # 0x23fc0
je 0x18ec2
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 0x18ec2
callq 0x17458
movl $0xeb, %eax
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x51d7(%rip), %rax      # 0x1e0ba
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xb440(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x108, 0xc(%rdi)       # imm = 0x108
leaq 0x343f(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb36a(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0xba06(%rip), %r14      # 0x24930
cmpl $0x0, (%r14)
je 0x18f6e
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3db6(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x18f6e
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x109, 0xc(%rax)       # imm = 0x109
movq 0xb2c0(%rip), %rsi      # 0x24220
leaq 0x5161(%rip), %rdi      # 0x1e0c8
xorl %eax, %eax
callq 0x1b0f0
leaq 0xb2cb(%rip), %rdi      # 0x24240
leaq 0xb264(%rip), %rsi      # 0x241e0
callq 0x1706c
cmpl $0x0, (%r14)
je 0x18fc5
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x3d5f(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x18fc5
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x10b, 0xc(%rax)       # imm = 0x10B
movq 0xb289(%rip), %rsi      # 0x24240
leaq 0x4fea(%rip), %rdi      # 0x1dfa8
xorl %eax, %eax
callq 0x1b0f0
leaq 0xb214(%rip), %rdi      # 0x241e0
callq 0x17128
leaq 0xb228(%rip), %rdi      # 0x24200
callq 0x17128
leaq 0xb23c(%rip), %rdi      # 0x24220
callq 0x17128
leaq 0xb250(%rip), %rdi      # 0x24240
callq 0x17128
movq %rsp, %rdi
movl $0x112, 0xc(%rdi)       # imm = 0x112
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xb280(%rip)      # 0x24298
jne 0x19150
pushq %rbx
leaq 0xb90a(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x19069
leaq 0xb2fe(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x330a(%rip), %rdi      # 0x1c34a
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x19069
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x1d, 0xc(%rax)
leaq 0x5111(%rip), %rdi      # 0x1e173
xorl %eax, %eax
callq 0x1b0f0
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, 0xb21b(%rip)      # 0x24290
orq $0x40000000, %rax       # imm = 0x40000000
movq %rax, 0xb216(%rip)      # 0x24298
leaq 0xb157(%rip), %rax      # 0x241e0
sarq $0x2, %rax
movq %rax, 0xb164(%rip)      # 0x241f8
movq 0xb155(%rip), %rcx      # 0x241f0
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0xb145(%rip)      # 0x241f0
leaq 0xb14e(%rip), %rax      # 0x24200
sarq $0x2, %rax
movq %rax, 0xb15b(%rip)      # 0x24218
movq 0xb14c(%rip), %rcx      # 0x24210
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0xb13c(%rip)      # 0x24210
leaq 0xb145(%rip), %rax      # 0x24220
sarq $0x2, %rax
movq %rax, 0xb152(%rip)      # 0x24238
movq 0xb143(%rip), %rcx      # 0x24230
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0xb133(%rip)      # 0x24230
leaq 0xb13c(%rip), %rax      # 0x24240
sarq $0x2, %rax
movq %rax, 0xb149(%rip)      # 0x24258
movq 0xb13a(%rip), %rcx      # 0x24250
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0xb12a(%rip)      # 0x24250
leaq 0xb133(%rip), %rax      # 0x24260
sarq $0x2, %rax
movq %rax, 0xb140(%rip)      # 0x24278
movq 0xb131(%rip), %rcx      # 0x24270
andl $0xc0000000, %ecx       # imm = 0xC0000000
orq %rax, %rcx
movq %rcx, 0xb121(%rip)      # 0x24270
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/cons.c
// Function: cons
CONS*
cons(CONS* a, CONS* d)
{
	CONS* p = NULL;

	p = gc_cons(a, d);
#if 1
	if (!consp(p)) {
		DBUG_PRINT("cons", ("ALERT! alignment error! p=16#%08lx", (ulint)p));
		fprintf(stderr, "ALERT! alignment error\n");
		abort();
	}
#endif
	++cons_cnt;
	XDBUG_PRINT("cons", ("allocated free cell #%d @%p[%p;%p]", cons_cnt, p, a, d));
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1792d
movq %rax, %rbx
testq %rax, %rax
je 0x1918d
movl %ebx, %eax
andl $0x3, %eax
jne 0x1918d
incl 0xb79e(%rip)            # 0x24920
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb79c(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x191da
leaq 0xb190(%rip), %r14      # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x4554(%rip), %rdi      # 0x1d702
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x191da
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x25, 0xc(%rax)
leaq 0x4fbd(%rip), %rdi      # 0x1e18d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0xae17(%rip), %rax      # 0x23ff8
movq (%rax), %rcx
leaq 0x4fc5(%rip), %rdi      # 0x1e1b0
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0xb09d(%rip), %rax      # 0x242a0
cmpq %rax, %rdi
je 0x1922b
movl %edi, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x1927e
testq %rdi, %rdi
je 0x192e9
testq %rax, %rax
jne 0x192e9
popq %rbx
jmp 0x179d9
leaq 0xb6fe(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x19275
leaq 0xb0f2(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x32f7(%rip), %rdi      # 0x1c543
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x19275
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x35, 0xc(%rax)
leaq 0x4f5a(%rip), %rdi      # 0x1e1c8
xorl %eax, %eax
callq 0x1b0f0
leaq 0xb024(%rip), %rax      # 0x242a0
popq %rbx
retq
leaq 0xb6ab(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x192c8
leaq 0xb09f(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x32a4(%rip), %rdi      # 0x1c543
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x192c8
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x3b, 0xc(%rax)
leaq 0x4f17(%rip), %rdi      # 0x1e1d8
xorl %eax, %eax
callq 0x1b0f0
movq 0xad29(%rip), %rax      # 0x23ff8
movq (%rax), %rcx
leaq 0x4f17(%rip), %rdi      # 0x1e1f0
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
callq 0x2050
leaq 0x3c13(%rip), %rdi      # 0x1cf03
leaq 0x4f0c(%rip), %rsi      # 0x1e203
leaq 0x4f0c(%rip), %rcx      # 0x1e20a
pushq $0x40
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0xaf92(%rip), %rax      # 0x242a0
cmpq %rax, %rdi
je 0x19336
movl %edi, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x19389
testq %rdi, %rdi
je 0x193f4
testq %rax, %rax
jne 0x193f4
popq %rbx
jmp 0x17a41
leaq 0xb5f3(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x19380
leaq 0xafe7(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x31fe(%rip), %rdi      # 0x1c555
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x19380
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x4e, 0xc(%rax)
leaq 0x4ea4(%rip), %rdi      # 0x1e21d
xorl %eax, %eax
callq 0x1b0f0
leaq 0xaf19(%rip), %rax      # 0x242a0
popq %rbx
retq
leaq 0xb5a0(%rip), %rax      # 0x24930
cmpl $0x0, (%rax)
je 0x193d3
leaq 0xaf94(%rip), %rbx      # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x31ab(%rip), %rdi      # 0x1c555
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x193d3
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x54, 0xc(%rax)
leaq 0x4e61(%rip), %rdi      # 0x1e22d
xorl %eax, %eax
callq 0x1b0f0
movq 0xac1e(%rip), %rax      # 0x23ff8
movq (%rax), %rcx
leaq 0x4e61(%rip), %rdi      # 0x1e245
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
callq 0x2050
leaq 0x3b08(%rip), %rdi      # 0x1cf03
leaq 0x4e01(%rip), %rsi      # 0x1e203
leaq 0x4e4f(%rip), %rcx      # 0x1e258
pushq $0x59
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x194e9
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xae58(%rip), %rax      # 0x242a0
cmpq %rax, %rdi
sete %cl
cmpq %rax, %rsi
sete %al
orb %cl, %al
jne 0x194e1
movl %r14d, %ecx
andl $0x3, %ecx
cmpq $0x1, %rcx
je 0x194e1
movl %ebx, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x194e1
testq %r14, %r14
sete %dl
testq %rcx, %rcx
setne %cl
orb %dl, %cl
jne 0x194e1
testq %rbx, %rbx
sete %cl
testq %rax, %rax
setne %al
orb %cl, %al
jne 0x194e1
movq %r14, %rdi
callq 0x191fb
movq %rax, %r15
movq %rbx, %rdi
callq 0x191fb
movq %r15, %rdi
movq %rax, %rsi
callq 0x1942d
testq %rax, %rax
je 0x194e1
movq %r14, %rdi
callq 0x19306
movq %rax, %r14
movq %rbx, %rdi
callq 0x19306
movq %r14, %rdi
movq %rax, %rsi
callq 0x1942d
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
jmp 0x194e3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19554
movq %rdi, %r14
movl %r14d, %eax
andl $0x3, %eax
jne 0x19554
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19573
movl %ebx, %eax
andl $0x3, %eax
jne 0x19573
leaq 0xad88(%rip), %rax      # 0x242a0
cmpq %rax, %r14
je 0x1954b
movq %r14, %rdi
callq 0x191fb
movq %rax, %r15
movq %r14, %rdi
callq 0x19306
movq %rax, %rdi
movq %rbx, %rsi
callq 0x194ed
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19164
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4d10(%rip), %rdi      # 0x1e26b
leaq 0x4ca1(%rip), %rsi      # 0x1e203
leaq 0x4d0b(%rip), %rcx      # 0x1e274
movl $0x90, %edx
callq 0x2100
leaq 0x4d17(%rip), %rdi      # 0x1e291
leaq 0x4c82(%rip), %rsi      # 0x1e203
leaq 0x4cec(%rip), %rcx      # 0x1e274
movl $0x91, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0xacff(%rip), %r15      # 0x242a0
movq %r15, %r14
cmpq %r15, %rbx
je 0x195d8
testq %rbx, %rbx
je 0x195e1
movl %ebx, %eax
andl $0x3, %eax
jne 0x195e1
movq %rbx, %rdi
callq 0x191fb
movq %rax, %rdi
movq %r14, %rsi
callq 0x19164
movq %rax, %r14
movq %rbx, %rdi
callq 0x19306
movq %rax, %rbx
jmp 0x195a4
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4cb2(%rip), %rdi      # 0x1e29a
leaq 0x4c14(%rip), %rsi      # 0x1e203
leaq 0x4cb0(%rip), %rcx      # 0x1e2a6
movl $0x9f, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ebx, %ebx
leaq 0xac93(%rip), %r14      # 0x242a0
cmpq %r14, %rdi
je 0x1962a
testq %rdi, %rdi
je 0x19634
movl %edi, %eax
andl $0x3, %eax
jne 0x19634
incl %ebx
callq 0x19306
movq %rax, %rdi
jmp 0x1960d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4c5f(%rip), %rdi      # 0x1e29a
leaq 0x4bc1(%rip), %rsi      # 0x1e203
leaq 0x4c73(%rip), %rcx      # 0x1e2bc
movl $0xac, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0xac41(%rip), %rax      # 0x242a0
cmpq %rax, %rdi
je 0x196a2
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x196e1
leaq 0xac24(%rip), %rcx      # 0x242a0
cmpq %rcx, %rax
je 0x1968e
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19306
testq %r14, %r14
setne %al
testb $0x3, %r14b
sete %cl
testb %cl, %al
jne 0x196a8
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x191fb
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19653
movq %rax, %r15
movq %r14, %rdi
callq 0x19306
movq %rax, %rdi
movq %rbx, %rsi
callq 0x19653
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19164
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xabaa(%rip), %r12      # 0x242a0
cmpq %r12, %r14
je 0x19737
testq %r14, %r14
je 0x19768
movl %r14d, %eax
andl $0x3, %eax
jne 0x19768
movq %r14, %rdi
callq 0x191fb
testq %rax, %rax
je 0x19749
movq %rax, %r15
andl $0x3, %eax
jne 0x19749
movq %r15, %rdi
callq 0x191fb
cmpq %rbx, %rax
je 0x1973a
movq %r14, %rdi
callq 0x19306
movq %rax, %r14
jmp 0x196f6
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3948(%rip), %rdi      # 0x1d098
leaq 0x4aac(%rip), %rsi      # 0x1e203
leaq 0x4b7c(%rip), %rcx      # 0x1e2da
movl $0xdc, %edx
callq 0x2100
leaq 0x4b60(%rip), %rdi      # 0x1e2cf
leaq 0x4a8d(%rip), %rsi      # 0x1e203
leaq 0x4b5d(%rip), %rcx      # 0x1e2da
movl $0xda, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x197b4
testq %rsi, %rsi
je 0x197d3
movq %rdx, %rbx
callq 0x196e1
leaq 0xaaff(%rip), %rcx      # 0x242a0
cmpq %rcx, %rax
je 0x197af
movq %rax, %rdi
popq %rbx
jmp 0x19306
movq %rbx, %rax
popq %rbx
retq
leaq 0x4b3e(%rip), %rdi      # 0x1e2f9
leaq 0x4a41(%rip), %rsi      # 0x1e203
leaq 0x4b3c(%rip), %rcx      # 0x1e305
movl $0xeb, %edx
callq 0x2100
leaq 0x4b55(%rip), %rdi      # 0x1e32f
leaq 0x4a22(%rip), %rsi      # 0x1e203
leaq 0x4b1d(%rip), %rcx      # 0x1e305
movl $0xec, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x1982a
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
jne 0x1982a
testq %rsi, %rsi
je 0x19849
testq %rdx, %rdx
je 0x19868
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19164
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x19164
leaq 0x4b0a(%rip), %rdi      # 0x1e33b
leaq 0x49cb(%rip), %rsi      # 0x1e203
leaq 0x4b14(%rip), %rcx      # 0x1e353
movl $0x101, %edx            # imm = 0x101
callq 0x2100
leaq 0x4adf(%rip), %rdi      # 0x1e32f
leaq 0x49ac(%rip), %rsi      # 0x1e203
leaq 0x4af5(%rip), %rcx      # 0x1e353
movl $0x103, %edx            # imm = 0x103
callq 0x2100
leaq 0x4b0a(%rip), %rdi      # 0x1e379
leaq 0x498d(%rip), %rsi      # 0x1e203
leaq 0x4ad6(%rip), %rcx      # 0x1e353
movl $0x105, %edx            # imm = 0x105
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
leaq 0xaa03(%rip), %r13      # 0x242a0
cmpq %r13, %rbx
je 0x198fb
testq %rbx, %rbx
je 0x198fb
movl %ebx, %eax
andl $0x3, %eax
jne 0x198fb
movq %rbx, %rdi
callq 0x191fb
movq %rax, %r15
testq %rax, %rax
sete %al
testb $0x3, %r15b
setne %cl
orb %al, %cl
jne 0x198ee
movq %r15, %rdi
callq 0x191fb
movq %rax, %r12
movq %r15, %rdi
callq 0x19306
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x197f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x19306
movq %rax, %rbx
jmp 0x1989d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1999e
movq %rdi, %r15
movl %r15d, %eax
andl $0x3, %eax
jne 0x1999e
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xa96e(%rip), %r13      # 0x242a0
cmpq %r13, %r14
je 0x19991
testq %r14, %r14
je 0x19991
movl %r14d, %eax
andl $0x3, %eax
jne 0x19991
cmpq %r13, %rbx
je 0x19991
testq %rbx, %rbx
je 0x19991
movl %ebx, %eax
andl $0x3, %eax
jne 0x19991
movq %r14, %rdi
callq 0x191fb
movq %rax, %r12
movq %rbx, %rdi
callq 0x191fb
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x197f9
movq %rax, %r15
movq %r14, %rdi
callq 0x19306
movq %rax, %r14
movq %rbx, %rdi
callq 0x19306
movq %rax, %rbx
jmp 0x19932
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x492a(%rip), %rdi      # 0x1e2cf
leaq 0x4857(%rip), %rsi      # 0x1e203
leaq 0x49d2(%rip), %rcx      # 0x1e385
movl $0x11b, %edx            # imm = 0x11B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa8cd(%rip), %r13      # 0x242a0
movq %r13, %r15
cmpq %r13, %r14
je 0x19a35
testq %r14, %r14
je 0x19a46
movl %r14d, %eax
andl $0x3, %eax
jne 0x19a46
movq %r14, %rdi
callq 0x191fb
testq %rax, %rax
je 0x19a65
movq %rax, %r12
andl $0x3, %eax
jne 0x19a65
movq %r12, %rdi
callq 0x191fb
cmpq %rbx, %rax
je 0x19a28
movq %r15, %rdi
movq %rax, %rsi
callq 0x196e1
cmpq %r13, %rax
jne 0x19a28
movq %r12, %rdi
movq %r15, %rsi
callq 0x19164
movq %rax, %r15
movq %r14, %rdi
callq 0x19306
movq %rax, %r14
jmp 0x199d6
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x19592
leaq 0x4882(%rip), %rdi      # 0x1e2cf
leaq 0x47af(%rip), %rsi      # 0x1e203
leaq 0x4950(%rip), %rcx      # 0x1e3ab
movl $0x12e, %edx            # imm = 0x12E
callq 0x2100
leaq 0x3497(%rip), %rdi      # 0x1cf03
leaq 0x4790(%rip), %rsi      # 0x1e203
leaq 0x4931(%rip), %rcx      # 0x1e3ab
movl $0x130, %edx            # imm = 0x130
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %rbx
leaq 0xa806(%rip), %r13      # 0x242a0
movq %rdi, %rax
movq %r13, %r14
cmpq %r13, %rax
je 0x19afb
movq %rax, %r12
testq %rax, %rax
je 0x19b08
movl %r12d, %eax
andl $0x3, %eax
jne 0x19b08
movq %r12, %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x191fb
cmpq %r15, %rax
je 0x19ad7
movq %r12, %rdi
callq 0x19306
movq %r12, %r14
jmp 0x19aa0
leaq 0xa7c2(%rip), %r15      # 0x242a0
movq %r12, %rdi
callq 0x19306
cmpq %r15, %r14
je 0x19af8
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a9e
jmp 0x19afb
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x47c0(%rip), %rdi      # 0x1e2cf
leaq 0x46ed(%rip), %rsi      # 0x1e203
leaq 0x48af(%rip), %rcx      # 0x1e3cc
movl $0x149, %edx            # imm = 0x149
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x188e8
movl 0xa387(%rip), %esi      # 0x24920
leaq 0x3471(%rip), %rdi      # 0x1da11
xorl %eax, %eax
callq 0x20e0
leaq 0x9cf2(%rip), %rax      # 0x242a0
cmpq %rax, 0x9ceb(%rip)      # 0x242a0
jne 0x1a5c2
cmpq %rax, 0x9cea(%rip)      # 0x242a8
jne 0x1a5e1
popq %rax
retq
leaq 0x3e4f(%rip), %rdi      # 0x1e418
leaq 0x3c33(%rip), %rsi      # 0x1e203
leaq 0x4059(%rip), %rcx      # 0x1e630
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x2100
leaq 0x3e56(%rip), %rdi      # 0x1e43e
leaq 0x3c14(%rip), %rsi      # 0x1e203
leaq 0x403a(%rip), %rcx      # 0x1e630
movl $0x1b6, %edx            # imm = 0x1B6
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/cons.c
// Function: assert_equal_cons
BOOL
assert_equal_cons(char* msg, CONS* expect, CONS* actual)
{
	if (!equal(expect, actual)) {
		DBUG_PRINT("", ("expect=%s", cons_to_str(expect)));
		DBUG_PRINT("", ("actual=%s", cons_to_str(actual)));
		fprintf(stderr, "assert_equal_cons: FAILED! %s\n", ((msg != NULL) ? msg : ""));
		abort();
	}
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1942d
testq %rax, %rax
je 0x1a636
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa2f3(%rip), %rbp      # 0x24930
cmpl $0x0, (%rbp)
je 0x1a6db
leaq 0x9ce2(%rip), %r13      # 0x24330
movq (%r13), %rax
movq 0x50(%rax), %rax
leaq 0x1ced(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x1a695
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1bd, 0xc(%rax)       # imm = 0x1BD
movq %r12, %rdi
callq 0x13708
leaq 0x21a7(%rip), %rdi      # 0x1c832
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
cmpl $0x0, (%rbp)
je 0x1a6db
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x1a6db
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1be, 0xc(%rax)       # imm = 0x1BE
movq %r14, %rdi
callq 0x13708
leaq 0x216b(%rip), %rdi      # 0x1c83c
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x9916(%rip), %rax      # 0x23ff8
movq (%rax), %rdi
testq %rbx, %rbx
leaq 0x1c5b(%rip), %rdx      # 0x1c34a
cmovneq %rbx, %rdx
leaq 0x3f4f(%rip), %rsi      # 0x1e649
xorl %eax, %eax
callq 0x2180
callq 0x2050
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x21b0
testq %rax, %rax
je 0x1a742
movq %rax, %r14
leaq -0x1(%rbx), %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x21b0
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f2d(%rip), %rdi      # 0x1e676
leaq 0x3f33(%rip), %rsi      # 0x1e683
leaq 0x3f33(%rip), %rcx      # 0x1e68a
pushq $0x10
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x1a7b4
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_O2/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 0x1a7f2
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
testb %r8b, %r8b
je 0x1a7ea
cmpq %rcx, %rsi
je 0x1a7ea
movq 0x10(%rdx), %r9
movb %r8b, (%r9,%rax)
movq 0x8(%rdx), %rax
incq %rax
movq %rax, 0x8(%rdx)
incq %rcx
jmp 0x1a7c4
movq 0x10(%rdx), %rcx
movb $0x0, (%rcx,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, 0xa10f(%rip)      # 0x24930
je 0x1a86d
movq 0x9b06(%rip), %rbx      # 0x24330
movq 0x50(%rbx), %r14
movl 0x8(%r14), %eax
cmpl 0x24(%rbx), %eax
jg 0x1a86d
movq 0x8(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x1a877
testl %eax, %eax
je 0x1a86d
movq 0x38(%rbx), %rdi
movq 0x18(%r14), %rax
movq 0x8(%rax), %rsi
callq 0x1a877
testl %eax, %eax
je 0x1a86d
movq 0x40(%rbx), %rdi
movq (%r14), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a877
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: match_set
static int
match_set(char *set, char *key)
{
	int sense = 1;
	int match = 1;
	int klen;
	int len;
	char *p;

	if ((set == NULL) || (*set == '\0') || (*set == ':')) {
		return 1;
	}
	if (key == NULL) {
		return 0;
	}
	match = 0;
	klen = strlen(key);
	if (*set == '^') {
		sense = !sense;
		++set;
	}
	p = set;
	for (;;) {
		while ((*p != ',') && (*p != ':') && (*p != '\0')) {
			++p;
		}
		len = (int) (p - set);
		if ((len == klen) && (strncmp(set, key, klen) == 0)) {
			match = 1;
			break;
		}
		if ((*p == ':') || (*p == '\0')) {
			break;
		}
		set = ++p;
	}
	return (match == sense);
}

// Assembly:
pushq $0x1
popq %rax
testq %rdi, %rdi
je 0x1a94c
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 0x1a93e
cmpl $0x3a, %r14d
je 0x1a93e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a92e
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 0x1a8fd
btq %r12, %r13
jb 0x1a904
incq %r14
decl %eax
jmp 0x1a8ec
testl %eax, %eax
jne 0x1a91c
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x2080
testl %eax, %eax
je 0x1a932
xorl %ecx, %ecx
cmpl $0x3a, %r12d
je 0x1a935
movq %r14, %rbp
testl %r12d, %r12d
jne 0x1a8e5
jmp 0x1a935
xorl %eax, %eax
jmp 0x1a93e
pushq $0x1
popq %rcx
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_O2/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 0x9474(%rip), %rbx      # 0x24330
leaq 0x940d(%rip), %rax      # 0x242d0
cmpq %rax, %rbx
je 0x1af5c
cmpl $0x0, 0x9a5d(%rip)      # 0x24930
je 0x1aef7
callq 0x1ac8b
movq 0x944f(%rip), %rax      # 0x24330
movq 0x18(%rax), %rcx
leaq 0x387e(%rip), %rdi      # 0x1e76a
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
movq 0x58(%rbx), %rax
movq %rax, 0x942e(%rip)      # 0x24330
movq 0x18(%rbx), %rdi
cmpq %rdi, 0x18(%rax)
je 0x1af35
testq %rdi, %rdi
je 0x1af35
movq 0x90e0(%rip), %rcx      # 0x23ff8
cmpq %rdi, (%rcx)
je 0x1af35
movq 0x9094(%rip), %rcx      # 0x23fb8
cmpq %rdi, (%rcx)
je 0x1af35
callq 0x20c0
movq 0x93fb(%rip), %rax      # 0x24330
movl 0x28(%rbx), %ecx
movl %ecx, 0x28(%rax)
movq 0x50(%rbx), %rcx
movq %rcx, 0x50(%rax)
movq %rbx, %rdi
callq 0x2030
movq 0x93de(%rip), %rax      # 0x24330
movl (%rax), %eax
movl %eax, 0x99d6(%rip)      # 0x24930
popq %rbx
retq
movq 0x93bd(%rip), %rax      # 0x24320
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movl 0xc(%rax), %edx
leaq 0x37d5(%rip), %rdi      # 0x1e749
xorl %eax, %eax
callq 0x1af7b