LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: newline_beh
static
BEH_DECL(newline_beh)
{
	CONS* state = MINE;
	
	DBUG_ENTER("newline_beh");
	fputc('\n', output_file);
	fflush(output_file);
	if (is_pr(state) && actorp(hd(state))) {
		SEND(hd(state), tl(state));
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
leaq 0x1e294(%rip), %rax     # 0x29840
movq %rax, -0x38(%rbp)
leaq 0x23d69(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xb68, -0x2c(%rbp)     # imm = 0xB68
leaq 0x1dd9d(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x23b63(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x23d38(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq 0x23d65(%rip), %rsi     # 0x2f368
movl $0xa, %edi
callq 0x2130
movq 0x23d54(%rip), %rdi     # 0x2f368
callq 0x21c0
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x39(%rbp)
je 0xb637
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 0xb6d1
leaq 0x23c3e(%rip), %rax     # 0x2f290
cmpq %rax, -0x10(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0xb6d1
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0xb6d1
movq -0x10(%rbp), %rdi
callq 0x25380
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb6d1
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25380
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25510
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0xb6e, -0x2c(%rbp)     # imm = 0xB6E
leaq -0x38(%rbp), %rdi
callq 0x28660
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: assert_beh
static
BEH_DECL(assert_beh)
{
	CONS* expect = MINE;
	CONS* actual = WHAT;

	DBUG_ENTER("assert_beh");
	DBUG_PRINT("", ("expect=%s", cons_to_str(expect)));
	if (equal(expect, actual)) {
		BECOME(abort_beh, NIL);
	} else {
		DBUG_PRINT("", ("actual=%s", cons_to_str(actual)));
		fprintf(stderr, "assert_beh: FAIL!\n");
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x1e11f(%rip), %rax     # 0x2984c
movq %rax, -0x40(%rbp)
leaq 0x23be8(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0xbb1, -0x34(%rbp)     # imm = 0xBB1
leaq 0x1dc1c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x239e2(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x23bb7(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
leaq 0x2419c(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0xb7e2
leaq 0x23b90(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1dbd1(%rip), %rcx     # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0x1dbc6(%rip), %rdi     # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0xb7e2
leaq 0x23b66(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xbb2, 0xc(%rax)       # imm = 0xBB2
movq -0x10(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x1e07c(%rip), %rdi     # 0x29857
movb $0x0, %al
callq 0x28540
jmp 0xb7e4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25700
cmpq $0x0, %rax
je 0xb81f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
leaq 0x1f2(%rip), %rsi       # 0xba00
leaq 0x23a7b(%rip), %rdx     # 0x2f290
callq 0x1aae0
jmp 0xb8a5
jmp 0xb821
leaq 0x240f8(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0xb886
leaq 0x23aec(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1db2d(%rip), %rcx     # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0x1db22(%rip), %rdi     # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0xb886
leaq 0x23ac2(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xbb6, 0xc(%rax)       # imm = 0xBB6
movq -0x18(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x1dfe2(%rip), %rdi     # 0x29861
movb $0x0, %al
callq 0x28540
jmp 0xb888
movq 0x23769(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x1dfd2(%rip), %rsi     # 0x2986b
movb $0x0, %al
callq 0x2170
callq 0x2050
movl $0xbba, -0x34(%rbp)     # imm = 0xBBA
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: report_beh
static
BEH_DECL(report_beh)
{
	CONS* cust = MINE;
	CONS* value = WHAT;
	
	DBUG_ENTER("report_beh");
	cust = ACTOR(newline_beh, pr(cust, value));
	SEND(value, pr(cust, ATOM("write")));
	BECOME(abort_beh, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x1df81(%rip), %rax     # 0x2987e
movq %rax, -0x40(%rbp)
leaq 0x23a18(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0xb7e, -0x34(%rbp)     # imm = 0xB7E
leaq 0x1da4c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x23812(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x239e7(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25290
movq -0x60(%rbp), %rdi
movq %rax, %rdx
leaq -0x3f0(%rip), %rsi      # 0xb580
callq 0x1b6f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x1dc5d(%rip), %rdi     # 0x295f5
callq 0x216e0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
leaq 0x30(%rip), %rsi        # 0xba00
leaq 0x238b9(%rip), %rdx     # 0x2f290
callq 0x1aae0
movl $0xb82, -0x34(%rbp)     # imm = 0xB82
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: abort_beh
static
BEH_DECL(abort_beh)
{
	char* msg = cons_to_str(WHAT);

	DBUG_ENTER("abort_beh");
	DBUG_PRINT("ABORT!", ("%s", msg));
	fprintf(stderr, "ABORT! %s\n", msg);
	abort();
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, %rdi
callq 0x1d250
movq %rax, -0x10(%rbp)
leaq 0x1dde9(%rip), %rax     # 0x29815
movq %rax, -0x38(%rbp)
leaq 0x238e9(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x48, -0x2c(%rbp)
leaq 0x1d91d(%rip), %rax     # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x236e3(%rip), %rax     # 0x2f140
movq %rax, -0x20(%rbp)
leaq 0x238b8(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0x23e9d(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0xbad9
leaq 0x23891(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1ddec(%rip), %rcx     # 0x29889
movq %rcx, 0x10(%rax)
leaq 0x1dde1(%rip), %rdi     # 0x29889
callq 0x278a0
cmpl $0x0, %eax
je 0xbad9
leaq 0x23867(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x49, 0xc(%rax)
movq -0x10(%rbp), %rsi
leaq 0x1ea93(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0xbadb
movq 0x23516(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1dda0(%rip), %rsi     # 0x29890
movb $0x0, %al
callq 0x2170
callq 0x2050
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/kernel.c
// Function: command_beh
static
BEH_DECL(command_beh)
{
	CONS* msg = MINE;
	CONS* actor = WHAT;
	
	DBUG_ENTER("command_beh");
	DBUG_PRINT("msg", ("%s", cons_to_str(msg)));
	DBUG_PRINT("actor", ("%s", cons_to_str(actor)));
	ENSURE(actorp(actor));
	SEND(actor, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25380
movq %rax, %rdi
callq 0x1a600
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
leaq 0x11e0b(%rip), %rax     # 0x29af8
movq %rax, -0x40(%rbp)
leaq 0x17628(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x12a, -0x34(%rbp)     # imm = 0x12A
leaq 0x1165c(%rip), %rax     # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x17422(%rip), %rax     # 0x2f140
movq %rax, -0x28(%rbp)
leaq 0x175f7(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
leaq 0x17bdc(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x17da2
leaq 0x175d0(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x11ed6(%rip), %rcx     # 0x29c34
movq %rcx, 0x10(%rax)
leaq 0x11ecb(%rip), %rdi     # 0x29c34
callq 0x278a0
cmpl $0x0, %eax
je 0x17da2
leaq 0x175a6(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x12b, 0xc(%rax)       # imm = 0x12B
movq -0x10(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x127ca(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x17da4
jmp 0x17da6
leaq 0x17b73(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x17e0b
leaq 0x17567(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x12e5e(%rip), %rcx     # 0x2ac25
movq %rcx, 0x10(%rax)
leaq 0x12e53(%rip), %rdi     # 0x2ac25
callq 0x278a0
cmpl $0x0, %eax
je 0x17e0b
leaq 0x1753d(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq -0x18(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0x12761(%rip), %rdi     # 0x2a565
movb $0x0, %al
callq 0x28540
jmp 0x17e0d
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x17ea3
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x122ec(%rip), %rsi    # 0x5b50
leaq 0x1744d(%rip), %rdx     # 0x2f290
callq 0x1b6f0
movq %rax, -0x48(%rbp)
leaq 0x11705(%rip), %rdi     # 0x29558
callq 0x216e0
movq %rax, -0x58(%rbp)
leaq 0x111b9(%rip), %rdi     # 0x2901c
callq 0x216e0
movq %rax, %rdi
movl $0x4b7, %esi            # imm = 0x4B7
callq 0x25290
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x25290
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1b810
movl $0x12d, -0x34(%rbp)     # imm = 0x12D
leaq -0x40(%rbp), %rdi
callq 0x28660
jmp 0x17ec4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1b810
movl $0x12f, -0x34(%rbp)     # imm = 0x12F
leaq -0x40(%rbp), %rdi
callq 0x28660
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: error_msg
BEH_DECL(error_msg)
{
	char* s;

	DBUG_ENTER("error_msg");
	s = cons_to_str(WHAT);
	DBUG_PRINT("", ("=ERROR= %s", s));
	fprintf(stderr, "=ERROR= %s\n", s);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf4bb(%rip), %rax      # 0x29c2e
movq %rax, -0x38(%rbp)
leaq 0x14ba2(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x4a, -0x2c(%rbp)
leaq 0xebd6(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x149f4(%rip), %rax     # 0x2f198
movq %rax, -0x20(%rbp)
leaq 0x14b71(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x25510
movq %rax, %rdi
callq 0x1d250
movq %rax, -0x10(%rbp)
leaq 0x1513d(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1a839
leaq 0x14b31(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xeb72(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0xeb67(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x1a839
leaq 0x14b07(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x4c, 0xc(%rax)
movq -0x10(%rbp), %rsi
leaq 0xf406(%rip), %rdi      # 0x29c38
movb $0x0, %al
callq 0x28540
jmp 0x1a83b
movq 0x147b6(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xf3f3(%rip), %rsi      # 0x29c43
movb $0x0, %al
callq 0x2170
movl $0x4e, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: abe__become
CONS*
abe__become(CONS* self, BEH beh, CONS* state)
/*
 * Update state/behavior of an actor.
 */
{
	DBUG_ENTER("become");
	assert(actorp(self));
	rplaca(MK_CONS(self), MK_FUNC(beh));
	rplacd(MK_CONS(self), state);
	DBUG_PRINT("", ("self=%s", cons_to_str(self)));
	DBUG_RETURN self;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xf237(%rip), %rax      # 0x29d32
movq %rax, -0x40(%rbp)
leaq 0x1481a(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x156, -0x34(%rbp)     # imm = 0x156
leaq 0xe84e(%rip), %rax      # 0x2936f
movq %rax, -0x30(%rbp)
leaq 0x1466c(%rip), %rax     # 0x2f198
movq %rax, -0x28(%rbp)
leaq 0x147e9(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1ab69
jmp 0x1ab88
leaq 0xf070(%rip), %rdi      # 0x29be0
leaq 0xf076(%rip), %rsi      # 0x29bed
movl $0x157, %edx            # imm = 0x157
leaq 0xf1b6(%rip), %rcx      # 0x29d39
callq 0x2100
movq -0x8(%rbp), %rdi
andq $-0x4, %rdi
orq $0x0, %rdi
movq -0x10(%rbp), %rsi
shlq $0x2, %rsi
orq $0x3, %rsi
callq 0x256a0
movq -0x8(%rbp), %rdi
andq $-0x4, %rdi
orq $0x0, %rdi
movq -0x18(%rbp), %rsi
callq 0x256d0
leaq 0x14d5f(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1ac1f
leaq 0x14753(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xe794(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0xe789(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x1ac1f
leaq 0x14729(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x15a, 0xc(%rax)       # imm = 0x15A
movq -0x8(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0xf148(%rip), %rdi      # 0x29d60
movb $0x0, %al
callq 0x28540
jmp 0x1ac21
movl $0x15b, -0x34(%rbp)     # imm = 0x15B
leaq -0x40(%rbp), %rdi
callq 0x28660
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: tv_create
CONS*
tv_create(time_t s, time_t us)
/*
 * Create a time tuple from raw time components (seconds and microseconds)
 */
{
	CONS* t = NIL;
	while (us > TICK_FREQ) {	/* normalize seconds */
		++s;
		us -= TICK_FREQ;
	}
	t = map_put(t, ATOM("us"), NUMBER(us));
	t = map_put(t, ATOM("s"), NUMBER(s));
	return t;
/*
	return cons(cons(ATOM("s"), NUMBER(tv->tv_sec)),
			cons(cons(ATOM("us"), NUMBER(tv->tv_usec)), NIL));
*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x14639(%rip), %rax     # 0x2f290
movq %rax, -0x18(%rbp)
cmpq $0xf4240, -0x10(%rbp)   # imm = 0xF4240
jle 0x1ac81
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
subq $0xf4240, %rax          # imm = 0xF4240
movq %rax, -0x10(%rbp)
jmp 0x1ac5b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xf053(%rip), %rdi      # 0x29ce3
callq 0x216e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
shlq $0x2, %rdx
orq $0x3, %rdx
callq 0x25e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xf8a6(%rip), %rdi      # 0x2a566
callq 0x216e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rdx
shlq $0x2, %rdx
orq $0x3, %rdx
callq 0x25e20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: tv_increment
CONS*
tv_increment(time_t s, time_t us, time_t d)
/*
 * Create a time tuple offset by d ticks (usecs) from raw time components
 */
{
	while (d > TICK_FREQ) {	/* avoid overflow */
		++s;
		d -= TICK_FREQ;
	}
	return tv_create(s, us + d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0xf4240, -0x18(%rbp)   # imm = 0xF4240
jle 0x1ad2a
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
subq $0xf4240, %rax          # imm = 0xF4240
movq %rax, -0x18(%rbp)
jmp 0x1ad04
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x18(%rbp), %rsi
callq 0x1ac40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: tv_compare
int
tv_compare(time_t t0s, time_t t0us, time_t t1s, time_t t1us)
/*
 * Compare raw time components(return: -1 if t0<t1, 0 if t0==t1, 1 if t0>t1)
 */
{
	if (t0s < t1s) {
		return -1;
	}
	if (t0s > t1s) {
		return 1;
	}
	if (t0us < t1us) {
		return -1;
	}
	if (t0us > t1us) {
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1ad77
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1adb7
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x1ad8a
movl $0x1, -0x4(%rbp)
jmp 0x1adb7
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x1ad9d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1adb7
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x1adb0
movl $0x1, -0x4(%rbp)
jmp 0x1adb7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: cfg_add_gc_root
void
cfg_add_gc_root(CONFIG* cfg, CONS* root)
/*
 * Add root to list of references preserved during garbage-collection.
 */
{
	DBUG_ENTER("cfg_add_gc_root");
	DBUG_PRINT("", ("root=@%p", root));
	cfg->gc_root = cons(root, cfg->gc_root);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xec1f(%rip), %rax      # 0x29ce6
movq %rax, -0x38(%rbp)
leaq 0x1424e(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0xf6, -0x2c(%rbp)
leaq 0xe282(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x140a0(%rip), %rax     # 0x2f198
movq %rax, -0x20(%rbp)
leaq 0x1421d(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
leaq 0x14802(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1b174
leaq 0x141f6(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xe237(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0xe22c(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x1b174
leaq 0x141cc(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0xf7, 0xc(%rax)
movq -0x10(%rbp), %rsi
leaq 0xeb89(%rip), %rdi      # 0x29cf6
movb $0x0, %al
callq 0x28540
jmp 0x1b176
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x25290
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0xf9, -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/actor.c
// Function: cfg_force_gc
void
cfg_force_gc(CONFIG* cfg)
/*
 * Force immediate garbage-collection. (WARNING: NOT CONCURRENT!)
 */
{
	CONS* root;

	DBUG_ENTER("cfg_force_gc");
	root = cfg_gather_roots(cfg);
	DBUG_PRINT("", ("length(root)=%d", length(root)));
	gc_full_collection(root);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xeb3c(%rip), %rax      # 0x29cff
movq %rax, -0x38(%rbp)
leaq 0x14152(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x12a, -0x2c(%rbp)     # imm = 0x12A
leaq 0xe186(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x13fa4(%rip), %rax     # 0x2f198
movq %rax, -0x20(%rbp)
leaq 0x14121(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rdi
callq 0x1b2b0
movq %rax, -0x10(%rbp)
leaq 0x146f9(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1b284
leaq 0x140ed(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xe12e(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0xe123(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x1b284
leaq 0x140c3(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq -0x10(%rbp), %rdi
callq 0x25a60
movl %eax, %esi
leaq 0xea8f(%rip), %rdi      # 0x29d0c
movb $0x0, %al
callq 0x28540
jmp 0x1b286
movq -0x10(%rbp), %rdi
callq 0x22d10
movl $0x12e, -0x2c(%rbp)     # imm = 0x12E
leaq -0x38(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: cfg_start_gc
void
cfg_start_gc(CONFIG* cfg)
/*
 * Start concurrent actor-based garbage-collection process.
 */
{
	CONS* root;

	DBUG_ENTER("cfg_start_gc");
	root = cfg_gather_roots(cfg);
	DBUG_PRINT("", ("length(root)=%d", length(root)));
	gc_actor_collection(cfg, root);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe719(%rip), %rax      # 0x29d1c
movq %rax, -0x38(%rbp)
leaq 0x13d12(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x139, -0x2c(%rbp)     # imm = 0x139
leaq 0xdd46(%rip), %rax      # 0x2936f
movq %rax, -0x28(%rbp)
leaq 0x13b64(%rip), %rax     # 0x2f198
movq %rax, -0x20(%rbp)
leaq 0x13ce1(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x28490
movq -0x8(%rbp), %rdi
callq 0x1b2b0
movq %rax, -0x10(%rbp)
leaq 0x142b9(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1b6c4
leaq 0x13cad(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xdcee(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0xdce3(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x1b6c4
leaq 0x13c83(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x13b, 0xc(%rax)       # imm = 0x13B
movq -0x10(%rbp), %rdi
callq 0x25a60
movl %eax, %esi
leaq 0xe64f(%rip), %rdi      # 0x29d0c
movb $0x0, %al
callq 0x28540
jmp 0x1b6c6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x230d0
movl $0x13d, -0x2c(%rbp)     # imm = 0x13D
leaq -0x38(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: abe__actor
CONS*
abe__actor(CONFIG* cfg, BEH beh, CONS* state)
/*
 * Create a new actor with specified state/behavior.
 */
{
	CONS* actor = NIL;

	DBUG_ENTER("actor");
	XDBUG_PRINT("", ("beh=@%p state=@%p", beh, state));
	XDBUG_PRINT("", ("state=%s", cons_to_str(state)));
	actor = MK_ACTOR(cons(MK_FUNC(beh), state));
	DBUG_PRINT("", ("actor=%s", cons_to_str(actor)));
	DBUG_RETURN actor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x13b85(%rip), %rax     # 0x2f290
movq %rax, -0x20(%rbp)
leaq 0xf50f(%rip), %rax      # 0x2ac25
movq %rax, -0x48(%rbp)
leaq 0x13bff(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x148, -0x3c(%rbp)     # imm = 0x148
leaq 0xdc33(%rip), %rax      # 0x2936f
movq %rax, -0x38(%rbp)
leaq 0x13a51(%rip), %rax     # 0x2f198
movq %rax, -0x30(%rbp)
leaq 0x13bce(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28490
movq -0x10(%rbp), %rdi
shlq $0x2, %rdi
orq $0x3, %rdi
movq -0x18(%rbp), %rsi
callq 0x25290
andq $-0x4, %rax
orq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq 0x14192(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1b7ec
leaq 0x13b86(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xdbc7(%rip), %rcx      # 0x2936f
movq %rcx, 0x10(%rax)
leaq 0xdbbc(%rip), %rdi      # 0x2936f
callq 0x278a0
cmpl $0x0, %eax
je 0x1b7ec
leaq 0x13b5c(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x14c, 0xc(%rax)       # imm = 0x14C
movq -0x20(%rbp), %rdi
callq 0x1d250
movq %rax, %rsi
leaq 0xe544(%rip), %rdi      # 0x29d29
movb $0x0, %al
callq 0x28540
jmp 0x1b7ee
movl $0x14d, -0x3c(%rbp)     # imm = 0x14D
leaq -0x48(%rbp), %rdi
callq 0x28660
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: cq_cons
static CONS*
cq_cons(CONS* a, CONS* d)	/* allocate recycleable cell */
{
	CONS* p;

	XDBUG_ENTER("cq_cons");
	if (!nilp(free_config)) {
		assert(consp(free_config));
		p = free_config;
		free_config = cdr(p);
		rplaca(p, a);
		rplacd(p, d);
	} else {
		p = gc_perm(a, d);		/* non-garbage-collected cell allocation */
	}
	if (++free_config_cnt > free_config_max) {
		free_config_max = free_config_cnt;
	}
	XDBUG_RETURN p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x137b9(%rip), %rax     # 0x2f290
cmpq %rax, 0x136ca(%rip)     # 0x2f1a8
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x1bb7e
xorl %eax, %eax
cmpq $0x0, 0x136ac(%rip)     # 0x2f1a8
movb %al, -0x19(%rbp)
je 0x1bb16
movq 0x136a0(%rip), %rax     # 0x2f1a8
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 0x1bb28
jmp 0x1bb47
leaq 0xe51f(%rip), %rdi      # 0x2a04e
leaq 0xe0b7(%rip), %rsi      # 0x29bed
movl $0x76, %edx
leaq 0xe51f(%rip), %rcx      # 0x2a061
callq 0x2100
movq 0x1365a(%rip), %rax     # 0x2f1a8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25510
movq %rax, 0x13646(%rip)     # 0x2f1a8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x256a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x256d0
jmp 0x1bb8f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23200
movq %rax, -0x18(%rbp)
movl 0x13843(%rip), %eax     # 0x2f3d8
addl $0x1, %eax
movl %eax, 0x1383a(%rip)     # 0x2f3d8
cmpl 0x13838(%rip), %eax     # 0x2f3dc
jle 0x1bbb2
movl 0x1382c(%rip), %eax     # 0x2f3d8
movl %eax, 0x1382a(%rip)     # 0x2f3dc
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: t_queue_insert
static void
t_queue_insert(CONS** qp, CONS* t, time_t t0s, time_t t0us)
{
	time_t t1s;
	time_t t1us;

	/* FIXME: this method abuses knowledge of t_queue representation */
	while (!nilp(*qp)) {
		CONS* m = (*qp)->first->first;
		t1s = MK_INT(map_get_def(m, ATOM("s"), NUMBER(0)));
		t1us = MK_INT(map_get_def(m, ATOM("us"), NUMBER(0)));
		if (tv_compare(t0s, t0us, t1s, t1us) > 0) {
			break;
		}
		qp = &((*qp)->rest);
	}
	*qp = cq_cons(t, *qp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1326d(%rip), %rcx     # 0x2f290
cmpq %rcx, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c042
jmp 0x1c0e1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xe504(%rip), %rdi      # 0x2a566
callq 0x216e0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x25d30
sarq $0x2, %rax
cltq
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0xdc52(%rip), %rdi      # 0x29ce3
callq 0x216e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x25d30
sarq $0x2, %rax
cltq
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x1ad50
cmpl $0x0, %eax
jle 0x1c0cd
jmp 0x1c0e1
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x1c018
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1bac0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/actor.c
// Function: cq_free
static CONS*
cq_free(CONS* p)				/* recycle cell */
{
	XDBUG_ENTER("cq_free");
	if (!nilp(p)) {
		rplaca(p, NIL);
		rplacd(p, free_config);
		free_config = p;
		--free_config_cnt;
	} else {
		DBUG_PRINT("cq_free", ("ALERT! cq_free(NIL)"));
	}
	XDBUG_RETURN NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1212d(%rip), %rax     # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x1d1b3
movq -0x8(%rbp), %rdi
leaq 0x1210e(%rip), %rsi     # 0x2f290
callq 0x256a0
movq -0x8(%rbp), %rdi
movq 0x12016(%rip), %rsi     # 0x2f1a8
callq 0x256d0
movq -0x8(%rbp), %rax
movq %rax, 0x12006(%rip)     # 0x2f1a8
movl 0x12230(%rip), %eax     # 0x2f3d8
addl $-0x1, %eax
movl %eax, 0x12227(%rip)     # 0x2f3d8
jmp 0x1d212
jmp 0x1d1b5
leaq 0x12764(%rip), %rax     # 0x2f920
cmpl $0x0, (%rax)
je 0x1d20e
leaq 0x12158(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0xcea9(%rip), %rcx      # 0x2a07f
movq %rcx, 0x10(%rax)
leaq 0xce9e(%rip), %rdi      # 0x2a07f
callq 0x278a0
cmpl $0x0, %eax
je 0x1d20e
leaq 0x1212e(%rip), %rax     # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x8e, 0xc(%rax)
leaq 0xce80(%rip), %rdi      # 0x2a087
movb $0x0, %al
callq 0x28540
jmp 0x1d210
jmp 0x1d212
leaq 0x12077(%rip), %rax     # 0x2f290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/emit.c
// Function: xcons_to_str
char*
xcons_to_str(CONS* cons)		/* warning: returns pointer to static buffer, do not nest calls! */
{
	XDBUG_ENTER("xcons_to_str");
	if (cons == NULL) {
		XDBUG_RETURN "<NULL>";
	}
	if (cons_sbuf == NULL) {
		cons_sbuf = new_sbuf(1024);		/* allocate 1K string buffer */
	}
	clear_sbuf(cons_sbuf);
	emit_cons(cons, 0, sbuf_emit, cons_sbuf);
	XDBUG_RETURN cons_sbuf->buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1df90
leaq 0xc37c(%rip), %rax      # 0x2a306
movq %rax, -0x8(%rbp)
jmp 0x1dfdf
cmpq $0x0, 0x11848(%rip)     # 0x2f7e0
jne 0x1dfab
movl $0x400, %edi            # imm = 0x400
callq 0x27680
movq %rax, 0x11835(%rip)     # 0x2f7e0
movq 0x1182e(%rip), %rdi     # 0x2f7e0
callq 0x27700
movq -0x10(%rbp), %rdi
movq 0x1181e(%rip), %rcx     # 0x2f7e0
xorl %esi, %esi
leaq 0x97a5(%rip), %rdx      # 0x27770
callq 0x1dff0
movq 0x11809(%rip), %rax     # 0x2f7e0
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/emit.c
// Function: child_to_str
static void
child_to_str(int depth, char* buf, CONS* cons)
{
	char tmp[CONS_BUFSZ];
	int n;
	
	XDBUG_ENTER("child_to_str");
	n = strlen(buf);
	XDBUG_PRINT("", ("n = %d", n));
	if (n < (CONS_BUFSZ - 4)) {
		depth_to_str(depth, tmp, cons);
		strncpy(buf + n, tmp, (CONS_BUFSZ - n));
/*		buf[CONS_BUFSZ - 1] = '\0'; */
		strcpy((buf + CONS_BUFSZ - 4), ":::");
	}
	XDBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movl %eax, -0x424(%rbp)
cmpl $0x3fc, -0x424(%rbp)    # imm = 0x3FC
jge 0x212f7
movl -0x4(%rbp), %edi
leaq -0x420(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d280
movq -0x10(%rbp), %rdi
movslq -0x424(%rbp), %rax
addq %rax, %rdi
leaq -0x420(%rbp), %rsi
movl $0x400, %eax            # imm = 0x400
subl -0x424(%rbp), %eax
movslq %eax, %rdx
callq 0x2070
movq -0x10(%rbp), %rdi
addq $0x400, %rdi            # imm = 0x400
addq $-0x4, %rdi
leaq 0x9631(%rip), %rsi      # 0x2a923
callq 0x2090
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/atom.c
// Function: lu_cons
CONS*
lu_cons(CONS* a, CONS* d)
/* allocate a permanent cell (not garbage-collected) */
{
	CONS* p = NULL;

	p = gc_perm(a, d);
	++lu_cons_cnt;
	XDBUG_PRINT("perm", ("allocated permanent cell #%d @%p[%p;%p]", lu_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 0x23200
movq %rax, -0x18(%rbp)
movl 0xe331(%rip), %eax      # 0x2f800
addl $0x1, %eax
movl %eax, 0xe328(%rip)      # 0x2f800
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/atom.c
// Function: lu_atom
CONS*
lu_atom(char* s)
/* lookup (or create) atom for 
 */
{
	CONS* atom;
	int c;
	
	XDBUG_ENTER("lu_atom");
	XDBUG_PRINT("", ("s@%p=%s", s, s));
	if ((s == NULL) || (*s == '\0')) {
		XDBUG_PRINT("", ("returning NIL"));
		XDBUG_RETURN NIL;
	}
	atom = NIL;
	while ((c = *s++) != '\0') {
		atom = lu_extend_atom(atom, c);
	}
	assert(atomp(atom));
	XDBUG_PRINT("", ("@%p = %s", atom, atom_str(atom)));
	XDBUG_RETURN atom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x216ff
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2170c
leaq 0xdb8a(%rip), %rax      # 0x2f290
movq %rax, -0x8(%rbp)
jmp 0x21788
leaq 0xdb7d(%rip), %rax      # 0x2f290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x21743
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x214f0
movq %rax, -0x18(%rbp)
jmp 0x21717
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x21761
jmp 0x21780
leaq 0x91bf(%rip), %rdi      # 0x2a927
leaq 0x91c4(%rip), %rsi      # 0x2a933
movl $0x5a, %edx
leaq 0x91e1(%rip), %rcx      # 0x2a95c
callq 0x2100
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/atom.c
// Function: atom_str
char*
atom_str(CONS* atom)	/* warning: returns pointer to static buffer, do not nest calls! */
/* return a string representation of an atom */
{
	static char s[256];
	CONS* p;
	int n;
	
	if ((atom == NULL) || !atomp(atom)) {
		return "";
	}
	p = MK_CONS(atom);
	p = car(p);
	n = length(p);
	while (n >= sizeof(s)) {	/* atom too long... truncate it, silently */
		p = cdr(p);
		--n;
	}
	s[n] = '\0';
	while (--n >= 0) {
		s[n] = MK_INT(car(p));
		p = cdr(p);
	}
	assert(nilp(p));
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x217cf
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x217df
leaq 0x7b99(%rip), %rax      # 0x2936f
movq %rax, -0x8(%rbp)
jmp 0x218bc
movq -0x10(%rbp), %rax
andq $-0x4, %rax
orq $0x0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25380
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25a60
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
jb 0x2182c
movq -0x18(%rbp), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21808
movslq -0x1c(%rbp), %rcx
leaq 0xdfd9(%rip), %rax      # 0x2f810
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jl 0x21875
movq -0x18(%rbp), %rdi
callq 0x25380
sarq $0x2, %rax
movb %al, %dl
movslq -0x1c(%rbp), %rcx
leaq 0xdfad(%rip), %rax      # 0x2f810
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rdi
callq 0x25510
movq %rax, -0x18(%rbp)
jmp 0x2183b
leaq 0xda14(%rip), %rax      # 0x2f290
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x21892
jmp 0x218b1
leaq 0x86a4(%rip), %rdi      # 0x29f3d
leaq 0x9093(%rip), %rsi      # 0x2a933
movl $0x76, %edx
leaq 0x90c6(%rip), %rcx      # 0x2a972
callq 0x2100
leaq 0xdf58(%rip), %rax      # 0x2f810
movq %rax, -0x8(%rbp)
movq -0x8(%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_insert_before
void
gc_insert_before(CELL* p, CELL* item)
/* insert <item> before <p> in list */
{
	GC_SET_NEXT(item, p);
	GC_SET_PREV(item, GC_PREV(p));
	GC_SET_NEXT(GC_PREV(p), item);
	GC_SET_PREV(p, item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_insert_after
void
gc_insert_after(CELL* p, CELL* item)
/* insert <item> after <p> in list */
{
	GC_SET_PREV(item, p);
	GC_SET_NEXT(item, GC_NEXT(p));
	GC_SET_PREV(GC_NEXT(p), item);
	GC_SET_NEXT(p, item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
shlq $0x2, %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_extract
CELL*
gc_extract(CELL* item)
/* extract <item> from list */
{
	GC_SET_NEXT(GC_PREV(item), GC_NEXT(item));
	GC_SET_PREV(GC_NEXT(item), GC_PREV(item));
	GC_SET_NEXT(item, item);	/* for safety */
	GC_SET_PREV(item, item);	/* for safety */
	return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
shlq $0x2, %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_pop
CELL*
gc_pop(CELL* list)
/* extract <item> from the beginning of <list> */
{
	CELL* p = GC_NEXT(list);
	
	if (p == list) {
		return NULL;		/* error - list empty */
	}
	GC_SET_SIZE(list, GC_SIZE(list) - 1);
	return gc_extract(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x227b0
movq $0x0, -0x8(%rbp)
jmp 0x227cf
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x226a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_pull
CELL*
gc_pull(CELL* list)
/* extract <item> from the end of <list> */
{
	CELL* p = GC_PREV(list);
	
	if (p == list) {
		return NULL;		/* error - list empty */
	}
	GC_SET_SIZE(list, GC_SIZE(list) - 1);
	return gc_extract(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x22850
movq $0x0, -0x8(%rbp)
jmp 0x2286f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x226a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_append_list
void
gc_append_list(CELL* to, CELL* from)
/* append <from> at the end of <to> */
{
	if (GC_NEXT(from) == from) {
		return;			/* no-op - from empty */
	}
	GC_SET_SIZE(to, GC_SIZE(to) + GC_SIZE(from));
	GC_SET_SIZE(from, 0);
	GC_SET_NEXT(GC_PREV(from), to);
	GC_SET_PREV(GC_NEXT(from), GC_PREV(to));
	GC_SET_NEXT(GC_PREV(to), GC_NEXT(from));
	GC_SET_PREV(to, GC_PREV(from));
	GC_SET_NEXT(from, from);
	GC_SET_PREV(from, from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
cmpq -0x10(%rbp), %rax
jne 0x228a3
jmp 0x2299d
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
shlq $0x2, %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x2, %rcx
sarq $0x2, %rcx
movq -0x8(%rbp), %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
sarq $0x2, %rcx
movq -0x10(%rbp), %rdx
movabsq $0xc0000000, %rax       # imm = 0xC0000000
andq 0x10(%rdx), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_count
WORD
gc_count(CELL* list)
/* count items in <list> */
{
	WORD n = 0;
	CELL* p = list;
	
	while (GC_NEXT(p) != list) {
		++n;
		p = GC_NEXT(p);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
cmpq -0x8(%rbp), %rax
je 0x229e8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x229b8
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/gc.c
// Function: gc_full_collection
void
gc_full_collection(CONS* root)
/* perform a full garbage collection (NOT CONCURRENT!) */
{
	DBUG_ENTER("gc_full_collection");
	gc_age_cells();
	assert(consp(root));
	if (!nilp(root)) {
		gc_scan_cell(as_cell(root));	/* scan "root" */
	}
	while (gc_refresh_cell() == TRUE)
		;
	gc_free_cells();
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7eb7(%rip), %rax      # 0x2abda
movq %rax, -0x30(%rbp)
leaq 0xc5f2(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x119, -0x24(%rbp)     # imm = 0x119
leaq 0x6626(%rip), %rax      # 0x2936f
movq %rax, -0x20(%rbp)
leaq 0xc51c(%rip), %rax      # 0x2f270
movq %rax, -0x18(%rbp)
leaq 0xc5c1(%rip), %rax      # 0x2f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x28490
callq 0x249e0
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x31(%rbp)
je 0x22d96
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x22da8
jmp 0x22dc7
leaq 0x7e3e(%rip), %rdi      # 0x2abed
leaq 0x7d6b(%rip), %rsi      # 0x2ab21
movl $0x11b, %edx            # imm = 0x11B
leaq 0x7e37(%rip), %rcx      # 0x2abf9
callq 0x2100
leaq 0xc4c2(%rip), %rax      # 0x2f290
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x22deb
movq -0x8(%rbp), %rdi
callq 0x22e20
jmp 0x22ded
callq 0x24c40
movl $0x1, %ecx
cmpq %rcx, %rax
jne 0x22dfe
jmp 0x22ded
callq 0x24f40
movl $0x122, -0x24(%rbp)     # imm = 0x122
leaq -0x30(%rbp), %rdi
callq 0x28660
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)