LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x8209(%rip), %rax      # 0x2b03c
movq %rax, -0x38(%rbp)
leaq 0xc4e2(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xd0, -0x2c(%rbp)
leaq 0x6516(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0xc40c(%rip), %rax      # 0x2f270
movq %rax, -0x20(%rbp)
leaq 0xc4b1(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0xca96(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x22ee0
leaq 0xc48a(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x6e65(%rip), %rcx      # 0x29d09
movq %rcx, 0x10(%rax)
leaq 0x6e5a(%rip), %rdi      # 0x29d09
callq 0x278a0
cmpl $0x0, %eax
je 0x22ee0
leaq 0xc460(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
movq -0x8(%rbp), %rsi
leaq 0x8170(%rip), %rdi      # 0x2b049
movb $0x0, %al
callq 0x28540
jmp 0x22ee2
movq -0x8(%rbp), %rcx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0xc385(%rip), %rax      # 0x2f288
jne 0x22f77
jmp 0x22f07
leaq 0xca12(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x22f60
leaq 0xc406(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x6de1(%rip), %rcx      # 0x29d09
movq %rcx, 0x10(%rax)
leaq 0x6dd6(%rip), %rdi      # 0x29d09
callq 0x278a0
cmpl $0x0, %eax
je 0x22f60
leaq 0xc3dc(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xd4, 0xc(%rax)
leaq 0x80f7(%rip), %rdi      # 0x2b050
movb $0x0, %al
callq 0x28540
jmp 0x22f62
movl $0xd5, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
jmp 0x23002
movq -0x10(%rbp), %rax
cmpq 0xc2fe(%rip), %rax      # 0x2f280
jne 0x22f86
jmp 0x22fa5
leaq 0x80d7(%rip), %rdi      # 0x2b064
leaq 0x7b8d(%rip), %rsi      # 0x2ab21
movl $0xd7, %edx
leaq 0x80db(%rip), %rcx      # 0x2b07b
callq 0x2100
movq 0xc224(%rip), %rax      # 0x2f1d0
subq $0x1, %rax
movq %rax, 0xc219(%rip)      # 0x2f1d0
movq -0x8(%rbp), %rdi
callq 0x226a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
orq 0xc2ae(%rip), %rcx      # 0x2f288
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rsi
leaq 0xc203(%rip), %rdi      # 0x2f1f0
callq 0x227e0
movl $0xdc, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7bf6(%rip), %rax      # 0x2ac19
movq %rax, -0x30(%rbp)
leaq 0xc2f2(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x133, -0x24(%rbp)     # imm = 0x133
leaq 0x6326(%rip), %rax      # 0x2936f
movq %rax, -0x20(%rbp)
leaq 0xc21c(%rip), %rax      # 0x2f270
movq %rax, -0x18(%rbp)
leaq 0xc2c1(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x28490
callq 0x24c40
movl $0x1, %ecx
cmpq %rcx, %rax
jne 0x230ac
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq -0x38(%rbp), %rdi
movq %rax, %rsi
leaq 0xc1eb(%rip), %rdx      # 0x2f290
callq 0x1b810
jmp 0x230b1
callq 0x24f40
movl $0x139, -0x24(%rbp)     # imm = 0x139
leaq -0x30(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7b44(%rip), %rax      # 0x2ac2b
movq %rax, -0x40(%rbp)
leaq 0xc22e(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x142, -0x34(%rbp)     # imm = 0x142
leaq 0x6262(%rip), %rax      # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0xc158(%rip), %rax      # 0x2f270
movq %rax, -0x28(%rbp)
leaq 0xc1fd(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
callq 0x249e0
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x41(%rbp)
je 0x2315a
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2316c
jmp 0x2318b
leaq 0x7a7a(%rip), %rdi      # 0x2abed
leaq 0x79a7(%rip), %rsi      # 0x2ab21
movl $0x144, %edx            # imm = 0x144
leaq 0x7ab9(%rip), %rcx      # 0x2ac3f
callq 0x2100
leaq 0xc0fe(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x231af
movq -0x10(%rbp), %rdi
callq 0x22e20
movq -0x8(%rbp), %rdi
leaq -0x1aa(%rip), %rsi      # 0x23010
leaq 0xc0cf(%rip), %rdx      # 0x2f290
callq 0x1b6f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xc0b7(%rip), %rdx      # 0x2f290
callq 0x1b810
movl $0x14a, -0x34(%rbp)     # imm = 0x14A
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xc039(%rip), %rax      # 0x2f250
cmpq $0x0, %rax
jne 0x23229
leaq 0xc02c(%rip), %rdi      # 0x2f250
callq 0x23300
leaq 0xc020(%rip), %rdi      # 0x2f250
callq 0x22780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23242
jmp 0x23261
leaq 0x80d3(%rip), %rdi      # 0x2b31c
leaq 0x78d1(%rip), %rsi      # 0x2ab21
movl $0x175, %edx            # imm = 0x175
leaq 0x7a0e(%rip), %rcx      # 0x2ac6a
callq 0x2100
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
orq $0x40000000, %rcx       # imm = 0x40000000
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x232bc
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x232ce
jmp 0x232ed
leaq 0x79b3(%rip), %rdi      # 0x2ac88
leaq 0x7845(%rip), %rsi      # 0x2ab21
movl $0x17a, %edx            # imm = 0x17A
leaq 0x7982(%rip), %rcx      # 0x2ac6a
callq 0x2100
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xbd29(%rip), %rax      # 0x2f230
cmpq $0x0, %rax
jne 0x23519
leaq 0xbd1c(%rip), %rdi      # 0x2f230
callq 0x23300
leaq 0xbd10(%rip), %rdi      # 0x2f230
callq 0x22780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23532
jmp 0x23551
leaq 0x7de3(%rip), %rdi      # 0x2b31c
leaq 0x75e1(%rip), %rsi      # 0x2ab21
movl $0x189, %edx            # imm = 0x189
leaq 0x7745(%rip), %rcx      # 0x2ac91
callq 0x2100
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
orq 0xbd21(%rip), %rcx      # 0x2f288
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rsi
leaq 0xbc7f(%rip), %rdi      # 0x2f210
callq 0x227e0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x235bc
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x235ce
jmp 0x235ed
leaq 0x76b3(%rip), %rdi      # 0x2ac88
leaq 0x7545(%rip), %rsi      # 0x2ab21
movl $0x190, %edx            # imm = 0x190
leaq 0x76a9(%rip), %rcx      # 0x2ac91
callq 0x2100
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x2367a
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2368c
jmp 0x236ab
leaq 0x7ae3(%rip), %rdi      # 0x2b176
leaq 0x7487(%rip), %rsi      # 0x2ab21
movl $0x19a, %edx            # imm = 0x19A
leaq 0x7adc(%rip), %rcx      # 0x2b182
callq 0x2100
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rcx), %rax
cmpq 0xbbb4(%rip), %rax      # 0x2f280
jne 0x236d7
movq -0x10(%rbp), %rdi
callq 0x22e20
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x6446(%rip), %rax      # 0x2b095
movq %rax, -0x38(%rbp)
leaq 0xa6c6(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xf7, -0x2c(%rbp)
leaq 0x46fa(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0xa5f0(%rip), %rax      # 0x2f270
movq %rax, -0x20(%rbp)
leaq 0xa695(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq 0xa54a(%rip), %rax      # 0x2f1f0
cmpq $0x0, %rax
jne 0x24d23
jmp 0x24cae
leaq 0xac6b(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x24d07
leaq 0xa65f(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x503a(%rip), %rcx      # 0x29d09
movq %rcx, 0x10(%rax)
leaq 0x502f(%rip), %rdi      # 0x29d09
callq 0x278a0
cmpl $0x0, %eax
je 0x24d07
leaq 0xa635(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xf9, 0xc(%rax)
leaq 0x63a5(%rip), %rdi      # 0x2b0a5
movb $0x0, %al
callq 0x28540
jmp 0x24d09
movl $0xfa, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
movq $0x0, -0x8(%rbp)
jmp 0x24d9d
leaq 0xa4c6(%rip), %rdi      # 0x2f1f0
callq 0x22780
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24d3c
jmp 0x24d5b
leaq 0x65d9(%rip), %rdi      # 0x2b31c
leaq 0x5dd7(%rip), %rsi      # 0x2ab21
movl $0xfd, %edx
leaq 0x635f(%rip), %rcx      # 0x2b0b5
callq 0x2100
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x24db0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24db0
movq -0x10(%rbp), %rsi
leaq 0xa491(%rip), %rdi      # 0x2f210
callq 0x22740
movl $0x101, -0x2c(%rbp)     # imm = 0x101
leaq -0x38(%rbp), %rdi
callq 0x28660
movl $0x1, %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x6309(%rip), %rax      # 0x2b0cc
movq %rax, -0x38(%rbp)
leaq 0xa552(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xe3, -0x2c(%rbp)
leaq 0x4586(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0xa47c(%rip), %rax      # 0x2f270
movq %rax, -0x20(%rbp)
leaq 0xa521(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0xab06(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x24e70
leaq 0xa4fa(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x4ed5(%rip), %rcx      # 0x29d09
movq %rcx, 0x10(%rax)
leaq 0x4eca(%rip), %rdi      # 0x29d09
callq 0x278a0
cmpl $0x0, %eax
je 0x24e70
leaq 0xa4d0(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xe4, 0xc(%rax)
movq -0x10(%rbp), %rsi
leaq 0x6271(%rip), %rdi      # 0x2b0da
movb $0x0, %al
callq 0x28540
jmp 0x24e72
leaq 0xa417(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x24f11
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24ebd
movq -0x10(%rbp), %rax
andq $-0x4, %rax
orq $0x0, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x39(%rbp)
je 0x24edb
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24f0f
movq -0x10(%rbp), %rdi
callq 0x22e20
movl $0xeb, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
movl $0x1, %eax
movq %rax, -0x8(%rbp)
jmp 0x24f29
jmp 0x24f11
movl $0xee, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x6198(%rip), %rax      # 0x2b0e7
movq %rax, -0x28(%rbp)
leaq 0xa3c6(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x108, -0x1c(%rbp)     # imm = 0x108
leaq 0x43fa(%rip), %rax      # 0x2936f
movq %rax, -0x18(%rbp)
leaq 0xa2f0(%rip), %rax      # 0x2f270
movq %rax, -0x10(%rbp)
leaq 0xa395(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x28490
leaq 0xa97a(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x24fff
leaq 0xa36e(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x4d49(%rip), %rcx      # 0x29d09
movq %rcx, 0x10(%rax)
leaq 0x4d3e(%rip), %rdi      # 0x29d09
callq 0x278a0
cmpl $0x0, %eax
je 0x24fff
leaq 0xa344(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x109, 0xc(%rax)       # imm = 0x109
movq 0xa21f(%rip), %rsi      # 0x2f210
leaq 0x60fd(%rip), %rdi      # 0x2b0f5
movb $0x0, %al
callq 0x28540
jmp 0x25001
leaq 0xa228(%rip), %rdi      # 0x2f230
leaq 0xa1c1(%rip), %rsi      # 0x2f1d0
callq 0x22880
leaq 0xa905(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x25074
leaq 0xa2f9(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x4cd4(%rip), %rcx      # 0x29d09
movq %rcx, 0x10(%rax)
leaq 0x4cc9(%rip), %rdi      # 0x29d09
callq 0x278a0
cmpl $0x0, %eax
je 0x25074
leaq 0xa2cf(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x10b, 0xc(%rax)       # imm = 0x10B
movq 0xa1ca(%rip), %rsi      # 0x2f230
leaq 0x5f68(%rip), %rdi      # 0x2afd5
movb $0x0, %al
callq 0x28540
jmp 0x25076
leaq 0xa153(%rip), %rdi      # 0x2f1d0
callq 0x229f0
leaq 0xa167(%rip), %rdi      # 0x2f1f0
callq 0x229f0
leaq 0xa17b(%rip), %rdi      # 0x2f210
callq 0x229f0
leaq 0xa18f(%rip), %rdi      # 0x2f230
callq 0x229f0
movl $0x112, -0x1c(%rbp)     # imm = 0x112
leaq -0x28(%rbp), %rdi
callq 0x28660
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, 0xa1b8(%rip)      # 0x2f288
je 0x250d7
jmp 0x25264
jmp 0x250d9
leaq 0xa840(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x25132
leaq 0xa234(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x4275(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0x426a(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x25132
leaq 0xa20a(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1d, 0xc(%rax)
leaq 0x6075(%rip), %rdi      # 0x2b1a0
movb $0x0, %al
callq 0x28540
jmp 0x25134
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, 0xa140(%rip)      # 0x2f280
movl $0xc0000000, %eax       # imm = 0xC0000000
movq %rax, 0xa13c(%rip)      # 0x2f288
leaq 0xa07d(%rip), %rax      # 0x2f1d0
sarq $0x2, %rax
movq %rax, 0xa08a(%rip)      # 0x2f1e8
leaq 0xa06b(%rip), %rax      # 0x2f1d0
sarq $0x2, %rax
movabsq $0xc0000000, %rcx       # imm = 0xC0000000
andq 0xa066(%rip), %rcx      # 0x2f1e0
orq %rcx, %rax
movq %rax, 0xa05c(%rip)      # 0x2f1e0
leaq 0xa065(%rip), %rax      # 0x2f1f0
sarq $0x2, %rax
movq %rax, 0xa072(%rip)      # 0x2f208
leaq 0xa053(%rip), %rax      # 0x2f1f0
sarq $0x2, %rax
movabsq $0xc0000000, %rcx       # imm = 0xC0000000
andq 0xa04e(%rip), %rcx      # 0x2f200
orq %rcx, %rax
movq %rax, 0xa044(%rip)      # 0x2f200
leaq 0xa04d(%rip), %rax      # 0x2f210
sarq $0x2, %rax
movq %rax, 0xa05a(%rip)      # 0x2f228
leaq 0xa03b(%rip), %rax      # 0x2f210
sarq $0x2, %rax
movabsq $0xc0000000, %rcx       # imm = 0xC0000000
andq 0xa036(%rip), %rcx      # 0x2f220
orq %rcx, %rax
movq %rax, 0xa02c(%rip)      # 0x2f220
leaq 0xa035(%rip), %rax      # 0x2f230
sarq $0x2, %rax
movq %rax, 0xa042(%rip)      # 0x2f248
leaq 0xa023(%rip), %rax      # 0x2f230
sarq $0x2, %rax
movabsq $0xc0000000, %rcx       # imm = 0xC0000000
andq 0xa01e(%rip), %rcx      # 0x2f240
orq %rcx, %rax
movq %rax, 0xa014(%rip)      # 0x2f240
leaq 0xa01d(%rip), %rax      # 0x2f250
sarq $0x2, %rax
movq %rax, 0xa02a(%rip)      # 0x2f268
leaq 0xa00b(%rip), %rax      # 0x2f250
sarq $0x2, %rax
movabsq $0xc0000000, %rcx       # imm = 0xC0000000
andq 0xa006(%rip), %rcx      # 0x2f260
orq %rcx, %rax
movq %rax, 0x9ffc(%rip)      # 0x2f260
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x234f0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x252d7
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x25365
jmp 0x252e9
leaq 0xa630(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x25346
leaq 0xa024(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x5429(%rip), %rcx      # 0x2a733
movq %rcx, 0x10(%rax)
leaq 0x541e(%rip), %rdi      # 0x2a733
callq 0x278a0
cmpl $0x0, %eax
je 0x25346
leaq 0x9ffa(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x25, 0xc(%rax)
movq -0x18(%rbp), %rsi
leaq 0x5e6f(%rip), %rdi      # 0x2b1ae
movb $0x0, %al
callq 0x28540
jmp 0x25348
movq 0x9ca9(%rip), %rax      # 0x2eff8
movq (%rax), %rdi
leaq 0x5e78(%rip), %rsi      # 0x2b1d1
movb $0x0, %al
callq 0x2170
callq 0x2050
movl 0xa5a5(%rip), %eax      # 0x2f910
addl $0x1, %eax
movl %eax, 0xa59c(%rip)      # 0x2f910
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x9efd(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25414
jmp 0x253a9
leaq 0xa570(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x25402
leaq 0x9f64(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x419e(%rip), %rcx      # 0x29568
movq %rcx, 0x10(%rax)
leaq 0x4193(%rip), %rdi      # 0x29568
callq 0x278a0
cmpl $0x0, %eax
je 0x25402
leaq 0x9f3a(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x35, 0xc(%rax)
leaq 0x5dee(%rip), %rdi      # 0x2b1e9
movb $0x0, %al
callq 0x28540
jmp 0x25404
leaq 0x9e85(%rip), %rax      # 0x2f290
movq %rax, -0x8(%rbp)
jmp 0x25506
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x254aa
jmp 0x25432
leaq 0xa4e7(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x2548b
leaq 0x9edb(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x4115(%rip), %rcx      # 0x29568
movq %rcx, 0x10(%rax)
leaq 0x410a(%rip), %rdi      # 0x29568
callq 0x278a0
cmpl $0x0, %eax
je 0x2548b
leaq 0x9eb1(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3b, 0xc(%rax)
leaq 0x5d75(%rip), %rdi      # 0x2b1f9
movb $0x0, %al
callq 0x28540
jmp 0x2548d
movq 0x9b64(%rip), %rax      # 0x2eff8
movq (%rax), %rdi
leaq 0x5d73(%rip), %rsi      # 0x2b211
movb $0x0, %al
callq 0x2170
callq 0x2050
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x254c8
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x254da
jmp 0x254f9
leaq 0x5583(%rip), %rdi      # 0x2aa64
leaq 0x5d3c(%rip), %rsi      # 0x2b224
movl $0x40, %edx
leaq 0x5d37(%rip), %rcx      # 0x2b22b
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x23600
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x9d6d(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x255a4
jmp 0x25539
leaq 0xa3e0(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x25592
leaq 0x9dd4(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x4020(%rip), %rcx      # 0x2957a
movq %rcx, 0x10(%rax)
leaq 0x4015(%rip), %rdi      # 0x2957a
callq 0x278a0
cmpl $0x0, %eax
je 0x25592
leaq 0x9daa(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x4e, 0xc(%rax)
leaq 0x5cb3(%rip), %rdi      # 0x2b23e
movb $0x0, %al
callq 0x28540
jmp 0x25594
leaq 0x9cf5(%rip), %rax      # 0x2f290
movq %rax, -0x8(%rbp)
jmp 0x25696
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2563a
jmp 0x255c2
leaq 0xa357(%rip), %rax      # 0x2f920
cmpl $0x0, (%rax)
je 0x2561b
leaq 0x9d4b(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x3f97(%rip), %rcx      # 0x2957a
movq %rcx, 0x10(%rax)
leaq 0x3f8c(%rip), %rdi      # 0x2957a
callq 0x278a0
cmpl $0x0, %eax
je 0x2561b
leaq 0x9d21(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x54, 0xc(%rax)
leaq 0x5c3a(%rip), %rdi      # 0x2b24e
movb $0x0, %al
callq 0x28540
jmp 0x2561d
movq 0x99d4(%rip), %rax      # 0x2eff8
movq (%rax), %rdi
leaq 0x5c38(%rip), %rsi      # 0x2b266
movb $0x0, %al
callq 0x2170
callq 0x2050
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x25658
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2566a
jmp 0x25689
leaq 0x53f3(%rip), %rdi      # 0x2aa64
leaq 0x5bac(%rip), %rsi      # 0x2b224
movl $0x59, %edx
leaq 0x5bf5(%rip), %rcx      # 0x2b279
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x236f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x25728
movl $0x1, %eax
movq %rax, -0x8(%rbp)
jmp 0x25884
leaq 0x9b61(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x2575e
leaq 0x9b46(%rip), %rax      # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2576b
movq $0x0, -0x8(%rbp)
jmp 0x25884
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x257a3
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x257b0
movq $0x0, -0x8(%rbp)
jmp 0x25884
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x257ce
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2587c
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1a(%rbp)
je 0x25800
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2587c
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25380
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x25700
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1b(%rbp)
je 0x2586c
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25510
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x25700
cmpq $0x0, %rax
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x25884
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x258be
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x258d0
jmp 0x258ef
leaq 0x59b5(%rip), %rdi      # 0x2b28c
leaq 0x5946(%rip), %rsi      # 0x2b224
movl $0x90, %edx
leaq 0x59ab(%rip), %rcx      # 0x2b295
callq 0x2100
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1a(%rbp)
je 0x2590d
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2591f
jmp 0x2593e
leaq 0x598c(%rip), %rdi      # 0x2b2b2
leaq 0x58f7(%rip), %rsi      # 0x2b224
movl $0x91, %edx
leaq 0x595c(%rip), %rcx      # 0x2b295
callq 0x2100
leaq 0x994b(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25963
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25995
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x25890
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x98dd(%rip), %rax      # 0x2f290
movq %rax, -0x10(%rbp)
leaq 0x98d2(%rip), %rax      # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x259db
jmp 0x25a55
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x259f9
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25a0b
jmp 0x25a2a
leaq 0x58a9(%rip), %rdi      # 0x2b2bb
leaq 0x580b(%rip), %rsi      # 0x2b224
movl $0x9f, %edx
leaq 0x58a2(%rip), %rcx      # 0x2b2c7
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x25380
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x25290
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25510
movq %rax, -0x8(%rbp)
jmp 0x259b7
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x9816(%rip), %rax      # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x25a97
jmp 0x25b01
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0xd(%rbp)
je 0x25ab5
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25ac7
jmp 0x25ae6
leaq 0x57ed(%rip), %rdi      # 0x2b2bb
leaq 0x574f(%rip), %rsi      # 0x2b224
movl $0xac, %edx
leaq 0x57fc(%rip), %rcx      # 0x2b2dd
callq 0x2100
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25510
movq %rax, -0x8(%rbp)
jmp 0x25a73
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x9769(%rip), %rax      # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25b4b
leaq 0x974e(%rip), %rax      # 0x2f290
movq %rax, -0x8(%rbp)
jmp 0x25bf4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x25c00
movq %rax, -0x18(%rbp)
leaq 0x972d(%rip), %rax      # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25be5
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x25b95
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25be3
movq -0x8(%rbp), %rdi
callq 0x25380
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x25b10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25510
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x25b10
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq %rax, -0x8(%rbp)
jmp 0x25bf2
movq -0x18(%rbp), %rdi
callq 0x25510
movq %rax, -0x8(%rbp)
jmp 0x25bf4
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x9679(%rip), %rax      # 0x2f290
movq %rax, -0x20(%rbp)
leaq 0x966e(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25c46
leaq 0x9653(%rip), %rax      # 0x2f290
movq %rax, -0x8(%rbp)
jmp 0x25d1c
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x25c64
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25c76
jmp 0x25c95
leaq 0x5673(%rip), %rdi      # 0x2b2f0
leaq 0x55a0(%rip), %rsi      # 0x2b224
movl $0xda, %edx
leaq 0x566b(%rip), %rcx      # 0x2b2fb
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x22(%rbp)
je 0x25cc0
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25cd2
jmp 0x25cf1
leaq 0x43cb(%rip), %rdi      # 0x2a0a4
leaq 0x5544(%rip), %rsi      # 0x2b224
movl $0xdc, %edx
leaq 0x560f(%rip), %rcx      # 0x2b2fb
callq 0x2100
movq -0x20(%rbp), %rdi
callq 0x25380
cmpq -0x18(%rbp), %rax
jne 0x25d0a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25d1c
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
jmp 0x25c1b
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x9545(%rip), %rax      # 0x2f290
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x25d58
jmp 0x25d77
leaq 0x55bb(%rip), %rdi      # 0x2b31a
leaq 0x54be(%rip), %rsi      # 0x2b224
movl $0xeb, %edx
leaq 0x55b4(%rip), %rcx      # 0x2b326
callq 0x2100
cmpq $0x0, -0x18(%rbp)
je 0x25d80
jmp 0x25d9f
leaq 0x55c9(%rip), %rdi      # 0x2b350
leaq 0x5496(%rip), %rsi      # 0x2b224
movl $0xec, %edx
leaq 0x558c(%rip), %rcx      # 0x2b326
callq 0x2100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25c00
movq %rax, -0x28(%rbp)
leaq 0x94d9(%rip), %rax      # 0x2f290
cmpq %rax, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25dd5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25de2
movq -0x28(%rbp), %rdi
callq 0x25510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x25e52
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x25e7d
leaq 0x9427(%rip), %rax      # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25e7f
jmp 0x25e9e
leaq 0x54d6(%rip), %rdi      # 0x2b35c
leaq 0x5397(%rip), %rsi      # 0x2b224
movl $0x101, %edx            # imm = 0x101
leaq 0x54db(%rip), %rcx      # 0x2b374
callq 0x2100
cmpq $0x0, -0x10(%rbp)
je 0x25ea7
jmp 0x25ec6
leaq 0x54a2(%rip), %rdi      # 0x2b350
leaq 0x536f(%rip), %rsi      # 0x2b224
movl $0x103, %edx            # imm = 0x103
leaq 0x54b3(%rip), %rcx      # 0x2b374
callq 0x2100
cmpq $0x0, -0x18(%rbp)
je 0x25ecf
jmp 0x25eee
leaq 0x54c4(%rip), %rdi      # 0x2b39a
leaq 0x5347(%rip), %rsi      # 0x2b224
movl $0x105, %edx            # imm = 0x105
leaq 0x548b(%rip), %rcx      # 0x2b374
callq 0x2100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25290
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x25290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x25f3e
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1a(%rbp)
je 0x25f75
leaq 0x9335(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x25f7e
jmp 0x25ffd
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1b(%rbp)
je 0x25fa9
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25feb
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25380
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25510
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x25e20
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
jmp 0x25f20
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x26042
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x26054
jmp 0x26073
leaq 0x5295(%rip), %rdi      # 0x2b2f0
leaq 0x51c2(%rip), %rsi      # 0x2b224
movl $0x11b, %edx            # imm = 0x11B
leaq 0x5338(%rip), %rcx      # 0x2b3a6
callq 0x2100
jmp 0x26075
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1a(%rbp)
je 0x26093
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1b(%rbp)
je 0x2611f
leaq 0x91e0(%rip), %rax      # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1b(%rbp)
jne 0x2611f
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1c(%rbp)
je 0x260e8
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x1c(%rbp)
movb -0x1c(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1b(%rbp)
je 0x2611f
leaq 0x918b(%rip), %rax      # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0x26128
jmp 0x26179
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25380
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x25e20
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
jmp 0x26075
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x90e9(%rip), %rax      # 0x2f290
movq %rax, -0x18(%rbp)
leaq 0x90de(%rip), %rax      # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x261d2
jmp 0x262e0
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x29(%rbp)
je 0x261f0
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x26202
jmp 0x26221
leaq 0x50e7(%rip), %rdi      # 0x2b2f0
leaq 0x5014(%rip), %rsi      # 0x2b224
movl $0x12e, %edx            # imm = 0x12E
leaq 0x51b0(%rip), %rcx      # 0x2b3cc
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x25380
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x2a(%rbp)
je 0x2624c
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2625e
jmp 0x2627d
leaq 0x47ff(%rip), %rdi      # 0x2aa64
leaq 0x4fb8(%rip), %rsi      # 0x2b224
movl $0x130, %edx            # imm = 0x130
leaq 0x5154(%rip), %rcx      # 0x2b3cc
callq 0x2100
movq -0x20(%rbp), %rdi
callq 0x25380
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x262ce
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x25c00
leaq 0x8fe8(%rip), %rcx      # 0x2f290
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x262cc
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25290
movq %rax, -0x18(%rbp)
jmp 0x262ce
movq -0x8(%rbp), %rdi
callq 0x25510
movq %rax, -0x8(%rbp)
jmp 0x261ab
movq -0x18(%rbp), %rdi
callq 0x259a0
addq $0x30, %rsp
popq %rbp
retq
nop