LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0x13b56(%rip), %rax     # 0x1c859
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x1b620(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0xb7e, 0xc(%r14)       # imm = 0xB7E
leaq 0x1361d(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%r14)
leaq 0x1b418(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1b079
movq %r12, %rdi
movq %r15, %rsi
callq 0x19164
leaq -0x2ec(%rip), %rsi      # 0x8a6e
movq %rbx, %rdi
movq %rax, %rdx
callq 0x123b7
movq %rax, %r12
leaq 0x13861(%rip), %rdi     # 0x1c5d0
callq 0x1691f
movq %r12, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12494
movq 0x30(%rbx), %rdi
callq 0x191fb
leaq 0x2b(%rip), %rsi        # 0x8dc8
leaq 0x1b4fc(%rip), %rdx     # 0x242a0
movq %rax, %rdi
callq 0x11b16
movl $0xb82, 0xc(%r14)       # imm = 0xB82
movq %r14, %rdi
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq 0x30(%rdi), %rdi
callq 0x19306
movq %rax, %rdi
callq 0x13708
movq %rax, %rbx
leaq 0x13a06(%rip), %rax     # 0x1c7f0
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b539(%rip), %r14     # 0x24330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x48, 0xc(%rdi)
leaq 0x13538(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1b333(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x1baff(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x8e70
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x13a20(%rip), %rdi     # 0x1c864
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x8e70
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x49, 0xc(%rax)
leaq 0x146ce(%rip), %rdi     # 0x1d534
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x1b181(%rip), %rax     # 0x23ff8
movq (%rax), %rdi
leaq 0x139ea(%rip), %rsi     # 0x1c86b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: newline_args_beh
static
BEH_DECL(newline_args_beh)
{
	CONS* state = MINE;
	CONS* cust;
	SINK* sink = current_sink;

	DBUG_ENTER("newline_args_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
	ENSURE(actorp(cust));
	ENSURE(nilp(WHAT));

	SEND(cust, (sink->put)(sink, NUMBER('\n')));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r15
movq 0x18791(%rip), %r14     # 0x243b8
leaq 0x10df4(%rip), %rax     # 0x1ca22
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x186f3(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x95d, 0xc(%rdi)       # imm = 0x95D
leaq 0x106f2(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x184ed(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq 0x18349(%rip), %r15     # 0x23fc0
je 0xbd23
testq %r15, %r15
je 0xbd23
movl %r15d, %eax
andl $0x3, %eax
jne 0xbd23
movq %r15, %rdi
callq 0x191fb
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xbd84
movq 0x30(%rbx), %rdi
callq 0x19306
cmpq 0x18307(%rip), %rax     # 0x23fc0
je 0xbde5
leaq -0x66fa(%rip), %rsi     # 0x55cc
leaq 0x185d3(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x10854(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x1032e(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x2587, %esi           # imm = 0x2587
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x961, %eax            # imm = 0x961
jmp 0xbe02
leaq -0x675e(%rip), %rsi     # 0x55cc
leaq 0x1856f(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x107f0(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x102ca(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x257b, %esi           # imm = 0x257B
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x95e, %eax            # imm = 0x95E
jmp 0xbe02
leaq -0x67bf(%rip), %rsi     # 0x55cc
leaq 0x1850e(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0x1078f(%rip), %rdi     # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0x10269(%rip), %rdi     # 0x1c01c
callq 0x1691f
movl $0x2583, %esi           # imm = 0x2583
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x960, %eax            # imm = 0x960
jmp 0xbe02
pushq $0x2b
popq %rsi
movq %r14, %rdi
callq *0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x964, %eax            # imm = 0x964
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: concurrent_args_beh
static
BEH_DECL(concurrent_args_beh)
{
	CONS* env = MINE;
	CONS* args = WHAT;

	DBUG_ENTER("concurrent_args_beh");

	DBUG_PRINT("env", ("%s", cons_to_str(env)));
	DBUG_PRINT("args", ("%s", cons_to_str(args)));
	if (is_pr(args)) {
		CONS* first = hd(args);
		CONS* rest = tl(args);

		SEND(first, pr(a_sink, pr(ATOM("eval"), env)));
		SEND(SELF, rest);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0xd51a(%rip), %rax      # 0x1c971
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x14eca(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9cc, 0xc(%rdi)       # imm = 0x9CC
leaq 0xcec8(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x14cc3(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x1548f(%rip), %r13     # 0x24930
cmpl $0x0, (%r13)
je 0xf53b
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xd668(%rip), %rdi      # 0x1cb23
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0xf4f0
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9ce, 0xc(%rax)       # imm = 0x9CE
movq %r14, %rdi
callq 0x13708
leaq 0xe04e(%rip), %rdi      # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
cmpl $0x0, (%r13)
je 0xf53b
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xd47f(%rip), %rdi      # 0x1c985
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0xf53b
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9cf, 0xc(%rax)       # imm = 0x9CF
movq %r15, %rdi
callq 0x13708
leaq 0xe003(%rip), %rdi      # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
cmpq 0x14a7e(%rip), %r15     # 0x23fc0
je 0xf5b5
testq %r15, %r15
je 0xf5b5
movl %r15d, %eax
andl $0x3, %eax
jne 0xf5b5
movq %r15, %rdi
callq 0x191fb
movq %rax, %r12
movq %r15, %rdi
callq 0x19306
movq %rax, %r15
movq 0x14e62(%rip), %r13     # 0x243d0
leaq 0xd024(%rip), %rdi      # 0x1c599
callq 0x1691f
movq %rax, %rdi
movq %r14, %rsi
callq 0x19164
movq %r13, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x12494
movq 0x30(%rbx), %rdi
callq 0x191fb
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x12494
leaq 0x8(%rsp), %rdi
movl $0x9d7, 0xc(%rdi)       # imm = 0x9D7
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: appl_args_beh
static
BEH_DECL(appl_args_beh)
{
	CONS* state = MINE;
	CONS* cust;
	CONS* comb;
	CONS* env;
	CONS* args = WHAT;
	CONS* expr;

	DBUG_ENTER("appl_args_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
	ENSURE(actorp(cust));
	comb = hd(tl(state));
	env = tl(tl(state));
	expr = ACTOR(pair_type, pr(comb, args));
	SEND(expr, pr(cust, pr(ATOM("eval"), env)));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r14
leaq 0xd396(%rip), %rax      # 0x1c9a1
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x14d16(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x2c3, 0xc(%rdi)       # imm = 0x2C3
leaq 0xcd15(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x14b10(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq 0x1496c(%rip), %r15     # 0x23fc0
je 0xf706
testq %r15, %r15
je 0xf706
movl %r15d, %eax
andl $0x3, %eax
jne 0xf706
movq %r15, %rdi
callq 0x191fb
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xf767
movq %r15, %rdi
callq 0x19306
movq %rax, %rdi
callq 0x191fb
movq %rax, %r13
movq %r15, %rdi
callq 0x19306
movq %rax, %rdi
callq 0x19306
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x19164
leaq -0xc053(%rip), %rsi     # 0x366b
movq %rbx, %rdi
movq %rax, %rdx
callq 0x123b7
movq %rax, %r14
leaq 0xcec6(%rip), %rdi      # 0x1c599
callq 0x1691f
movq %rax, %rdi
movq %r15, %rsi
callq 0x19164
movq %r12, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x2cb, %eax            # imm = 0x2CB
jmp 0xf7c6
leaq -0xa141(%rip), %rsi     # 0x55cc
leaq 0x14b8c(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0xce0d(%rip), %rdi      # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0xc8e7(%rip), %rdi      # 0x1c01c
callq 0x1691f
movl $0xb13, %esi            # imm = 0xB13
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x2c4, %eax            # imm = 0x2C4
jmp 0xf7c6
leaq -0xa1a2(%rip), %rsi     # 0x55cc
leaq 0x14b2b(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0xcdac(%rip), %rdi      # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0xc886(%rip), %rdi      # 0x1c01c
callq 0x1691f
movl $0xb1b, %esi            # imm = 0xB1B
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x2c6, %eax            # imm = 0x2C6
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/kernel.c
// Function: if_test_beh
static
BEH_DECL(if_test_beh)
{
	CONS* state = MINE;
	CONS* cust;
	CONS* bool = WHAT;

	DBUG_ENTER("if_test_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
	ENSURE(actorp(cust));
	ENSURE(actorp(bool));

	SEND(bool, pr(cust, pr(ATOM("if"), tl(state))));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r14
leaq 0xd253(%rip), %rax      # 0x1ca6b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x14b09(%rip), %rax     # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x8e5, 0xc(%rdi)       # imm = 0x8E5
leaq 0xcb08(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x14903(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
cmpq 0x1475f(%rip), %r15     # 0x23fc0
je 0xf8db
testq %r15, %r15
je 0xf8db
movl %r15d, %eax
andl $0x3, %eax
jne 0xf8db
movq %r15, %rdi
callq 0x191fb
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xf93f
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xf9a0
leaq 0xd02f(%rip), %rdi      # 0x1c8cc
callq 0x1691f
movq %rax, %r13
movq %r15, %rdi
callq 0x19306
movq %r13, %rdi
movq %rax, %rsi
callq 0x19164
movq %r12, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x8ec, %eax            # imm = 0x8EC
jmp 0xf9ff
leaq -0xa316(%rip), %rsi     # 0x55cc
leaq 0x149b7(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0xcc38(%rip), %rdi      # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0xc712(%rip), %rdi      # 0x1c01c
callq 0x1691f
movl $0x239b, %esi           # imm = 0x239B
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x8e6, %eax            # imm = 0x8E6
jmp 0xf9ff
leaq -0xa37a(%rip), %rsi     # 0x55cc
leaq 0x14953(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0xcbd4(%rip), %rdi      # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0xc6ae(%rip), %rdi      # 0x1c01c
callq 0x1691f
movl $0x23a3, %esi           # imm = 0x23A3
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x8e8, %eax            # imm = 0x8E8
jmp 0xf9ff
leaq -0xa3db(%rip), %rsi     # 0x55cc
leaq 0x148f2(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0xcb73(%rip), %rdi      # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0xc64d(%rip), %rdi      # 0x1c01c
callq 0x1691f
movl $0x23a7, %esi           # imm = 0x23A7
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x8e9, %eax            # imm = 0x8E9
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %r15
leaq 0xcdff(%rip), %rax      # 0x1cad3
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1464d(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x12a, 0xc(%rdi)       # imm = 0x12A
leaq 0xc64b(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x14446(%rip), %rcx     # 0x24150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x14c12(%rip), %r13     # 0x24930
cmpl $0x0, (%r13)
je 0xfdb8
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xcee7(%rip), %rdi      # 0x1cc1f
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0xfd6d
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x12b, 0xc(%rax)       # imm = 0x12B
movq %r14, %rdi
callq 0x13708
leaq 0xd7d1(%rip), %rdi      # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
cmpl $0x0, (%r13)
je 0xfdb8
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xde82(%rip), %rdi      # 0x1dc05
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0xfdb8
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq %r15, %rdi
callq 0x13708
leaq 0xd786(%rip), %rdi      # 0x1d534
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xfdd8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12494
movl $0x12f, %eax            # imm = 0x12F
jmp 0xfe37
leaq -0xa813(%rip), %rsi     # 0x55cc
leaq 0x144ba(%rip), %rdx     # 0x242a0
movq %rbx, %rdi
callq 0x123b7
movq %rax, %r14
leaq 0xc73b(%rip), %rdi      # 0x1c533
callq 0x1691f
movq %rax, %r15
leaq 0xc215(%rip), %rdi      # 0x1c01c
callq 0x1691f
movl $0x4b7, %esi            # imm = 0x4B7
movq %rax, %rdi
callq 0x19164
movq %r15, %rdi
movq %rax, %rsi
callq 0x19164
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12494
movl $0x12d, %eax            # imm = 0x12D
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/actor.c
// Function: this
BEH
_this(CONS* self)
{
	CONS* p;

	XDBUG_ENTER("this");
	assert(actorp(self));
	p = MK_CONS(self);
#if 0
	XDBUG_RETURN MK_BEH(p->first);
#else
	XDBUG_RETURN MK_BEH(gc_first(p));
#endif
}

// Assembly:
pushq %rax
movl %edi, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1173e
andq $-0x4, %rdi
callq 0x179d9
sarq $0x2, %rax
popq %rcx
retq
leaq 0xb486(%rip), %rdi      # 0x1cbcb
leaq 0xb48c(%rip), %rsi      # 0x1cbd8
leaq 0xb48d(%rip), %rcx      # 0x1cbe0
pushq $0x13
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/actor.c
// Function: mine
CONS*
_mine(CONS* self)
{
	CONS* p;

	XDBUG_ENTER("mine");
	assert(actorp(self));
	p = MK_CONS(self);
#if 0
	XDBUG_RETURN (p->rest);
#else
	XDBUG_RETURN gc_rest(p);
#endif
}

// Assembly:
movl %edi, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1176e
andq $-0x4, %rdi
jmp 0x17a41
pushq %rax
leaq 0xb455(%rip), %rdi      # 0x1cbcb
leaq 0xb45b(%rip), %rsi      # 0x1cbd8
leaq 0xb46e(%rip), %rcx      # 0x1cbf2
pushq $0x22
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xb3b7(%rip), %rax      # 0x1cc19
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x12abf(%rip), %r15     # 0x24330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x4a, 0xc(%rdi)
leaq 0xaabe(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x12911(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq 0x30(%rbx), %rdi
callq 0x19306
movq %rax, %rdi
callq 0x13708
movq %rax, %rbx
leaq 0x13071(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x118fa
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x118fa
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x4c, 0xc(%rax)
leaq 0xb333(%rip), %rdi      # 0x1cc23
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x126f7(%rip), %rax     # 0x23ff8
movq (%rax), %rdi
leaq 0xb323(%rip), %rsi      # 0x1cc2e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
leaq 0x8(%rsp), %rdi
movl $0x4e, 0xc(%rdi)
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/actor.c
// Function: assert_msg
BEH_DECL(assert_msg)
{
	CONS* expect = map_get(MINE, ATOM("expect"));
	CONS* message = map_get(MINE, ATOM("message"));
	CONS* actual = WHAT;

	DBUG_ENTER("assert_msg");
	if (!equal(expect, actual)) {
		DBUG_PRINT("", ("expect=%s", cons_to_str(expect)));
		DBUG_PRINT("", ("actual=%s", cons_to_str(actual)));
		fprintf(stderr, "assert_msg: FAILED! %s\n", (atomp(message) ? atom_str(message) : ""));
		abort();
	}
	BECOME(sink_beh, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq 0x30(%rdi), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %rbx
leaq 0xb2de(%rip), %rdi      # 0x1cc3a
callq 0x1691f
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x19787
movq %rax, %r13
movq 0x30(%r12), %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x1175b
movq %rax, %rbx
leaq 0xb2b4(%rip), %rdi      # 0x1cc41
callq 0x1691f
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x19787
movq %rax, %rbx
movq 0x30(%r12), %rdi
callq 0x19306
movq %rax, %r15
leaq 0xb293(%rip), %rax      # 0x1cc49
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1296d(%rip), %rbp     # 0x24330
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x60, 0xc(%rdi)
leaq 0xa96b(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x127be(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq %r13, %rdi
movq %r15, %rsi
callq 0x1942d
testq %rax, %rax
je 0x11a45
movq 0x30(%r12), %rdi
callq 0x191fb
leaq -0x28c(%rip), %rsi      # 0x1178c
leaq 0x12881(%rip), %rdx     # 0x242a0
movq %rax, %rdi
callq 0x11b16
movq %rsp, %rdi
movl $0x68, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12ee4(%rip), %r12     # 0x24930
cmpl $0x0, (%r12)
je 0x11ade
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x11a97
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x62, 0xc(%rax)
movq %r13, %rdi
callq 0x13708
leaq 0xada5(%rip), %rdi      # 0x1c832
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
cmpl $0x0, (%r12)
je 0x11ade
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x11ade
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x63, 0xc(%rax)
movq %r15, %rdi
callq 0x13708
leaq 0xad68(%rip), %rdi      # 0x1c83c
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x12513(%rip), %rax     # 0x23ff8
movq (%rax), %r15
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x11afd
movq %rbx, %rdi
callq 0x1697e
movq %rax, %r14
leaq 0xb150(%rip), %rsi      # 0x1cc54
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2180
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xb1e9(%rip), %rax      # 0x1cd1d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x127ef(%rip), %rbp     # 0x24330
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x156, 0xc(%rdi)       # imm = 0x156
leaq 0xa7ed(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x12640(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x11c12
movq %rbx, %r13
andq $-0x4, %r13
leaq 0x3(,%r12,4), %rsi
movq %r13, %rdi
callq 0x19411
movq %r13, %rdi
movq %r14, %rsi
callq 0x1941f
leaq 0x12d84(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x11bf1
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x11bf1
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x15a, 0xc(%rax)       # imm = 0x15A
movq %rbx, %rdi
callq 0x13708
leaq 0xb164(%rip), %rdi      # 0x1cd4b
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0x15b, 0xc(%rdi)       # imm = 0x15B
callq 0x1b1f2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xafb2(%rip), %rdi      # 0x1cbcb
leaq 0xafb8(%rip), %rsi      # 0x1cbd8
leaq 0xb0fd(%rip), %rcx      # 0x1cd24
movl $0x157, %edx            # imm = 0x157
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xadd6(%rip), %rax      # 0x1ccd1
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x12428(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf6, 0xc(%rdi)
leaq 0xa426(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x12279(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x129ed(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x11f80
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x11f80
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xf7, 0xc(%rax)
leaq 0xad6b(%rip), %rdi      # 0x1cce1
movq %r14, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x19164
movq %rax, 0x20(%rbx)
movq %rsp, %rdi
movl $0xf9, 0xc(%rdi)
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xad2c(%rip), %rax      # 0x1ccea
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x12363(%rip), %r15     # 0x24330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x12a, 0xc(%rdi)       # imm = 0x12A
leaq 0xa362(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x121b5(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq %rbx, %rdi
callq 0x12077
movq %rax, %rbx
leaq 0x1291e(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x12054
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x12054
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq %rbx, %rdi
callq 0x19600
leaq 0xacac(%rip), %rdi      # 0x1ccf7
movl %eax, %esi
xorl %eax, %eax
callq 0x1b0f0
movq %rbx, %rdi
callq 0x1739f
leaq 0x8(%rsp), %rdi
movl $0x12e, 0xc(%rdi)       # imm = 0x12E
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xaa0d(%rip), %rax      # 0x1cd07
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x12029(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x139, 0xc(%rdi)       # imm = 0x139
leaq 0xa027(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x11e7a(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
movq %rbx, %rdi
callq 0x12077
movq %rax, %r14
leaq 0x125e3(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x12391
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x12391
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x13b, 0xc(%rax)       # imm = 0x13B
movq %r14, %rdi
callq 0x19600
leaq 0xa96f(%rip), %rdi      # 0x1ccf7
movl %eax, %esi
xorl %eax, %eax
callq 0x1b0f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17654
movq %rsp, %rdi
movl $0x13d, 0xc(%rdi)       # imm = 0x13D
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
leaq 0xb836(%rip), %rax      # 0x1dc05
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x11f54(%rip), %r12     # 0x24330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x148, 0xc(%rdi)       # imm = 0x148
leaq 0x9f52(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x11da5(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x3(,%r15,4), %rdi
movq %rbx, %rsi
callq 0x19164
movq %rax, %rbx
andq $-0x4, %rbx
incq %rbx
leaq 0x124ff(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x12476
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x12476
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x14c, 0xc(%rax)       # imm = 0x14C
movq %rbx, %rdi
callq 0x13708
leaq 0xa8a8(%rip), %rdi      # 0x1cd14
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0x14d, 0xc(%rdi)       # imm = 0x14D
callq 0x1b1f2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/actor.c
// Function: abe__send
void
abe__send(CONFIG* cfg, CONS* target, CONS* msg)
/*
 * Queue an asynchronous message for the target actor.
 */
{
	CONS* entry = NIL;
	CONS* cq = CONFIG_QUEUE(cfg);

	DBUG_ENTER("send");
	DBUG_PRINT("", ("target=%s", cons_to_str(target)));
	assert(actorp(target));
	DBUG_PRINT("", ("msg=%s", cons_to_str(msg)));
	entry = cq_cons(target, msg);
	CQ_PUT(cq, cq_cons(entry, NIL));
	XDBUG_PRINT("", ("queue=%s", cons_to_str(CQ_PEEK(cq))));
	++cfg->q_count;
	DBUG_PRINT("", ("%d message(s) queued", cfg->q_count));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa8a1(%rip), %rax      # 0x1cd53
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x11e71(%rip), %r13     # 0x24330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x167, 0xc(%rdi)       # imm = 0x167
leaq 0x9e6f(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x11cc2(%rip), %rcx     # 0x241a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
leaq 0x12436(%rip), %rbp     # 0x24930
cmpl $0x0, (%rbp)
je 0x12540
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x12540
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x168, 0xc(%rax)       # imm = 0x168
movq %r12, %rdi
callq 0x13708
leaq 0xa822(%rip), %rdi      # 0x1cd58
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movl %r12d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1265f
cmpl $0x0, (%rbp)
je 0x12595
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x12595
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x16a, 0xc(%rax)       # imm = 0x16A
movq %r15, %rdi
callq 0x13708
leaq 0xa80f(%rip), %rdi      # 0x1cd9a
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b0f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x1267e
movq %rax, %r15
movq %rbx, %rdi
callq 0x191fb
cmpq 0x11a0e(%rip), %rax     # 0x23fc0
je 0x125db
movq %rbx, %rdi
callq 0x19306
movq %rax, %r12
leaq 0x11cda(%rip), %rsi     # 0x242a0
movq %r15, %rdi
callq 0x1267e
movq %r12, %rdi
movq %rax, %rsi
callq 0x1941f
jmp 0x125f5
leaq 0x11cbe(%rip), %rsi     # 0x242a0
movq %r15, %rdi
callq 0x1267e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19411
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1941f
incl 0x28(%rbx)
cmpl $0x0, (%rbp)
je 0x12641
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1a7f4
testl %eax, %eax
je 0x12641
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x16f, 0xc(%rax)       # imm = 0x16F
movl 0x28(%rbx), %esi
leaq 0xa767(%rip), %rdi      # 0x1cda1
xorl %eax, %eax
callq 0x1b0f0
movq %rsp, %rdi
movl $0x170, 0xc(%rdi)       # imm = 0x170
callq 0x1b1f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa6fc(%rip), %rdi      # 0x1cd62
leaq 0xa56b(%rip), %rsi      # 0x1cbd8
leaq 0xa6fd(%rip), %rcx      # 0x1cd71
movl $0x169, %edx            # imm = 0x169
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x11b28(%rip), %rbx     # 0x241b8
cmpq 0x11929(%rip), %rbx     # 0x23fc0
je 0x126cc
testq %rbx, %rbx
je 0x12700
movl %ebx, %eax
andl $0x3, %eax
jne 0x12700
movq %rbx, %rdi
callq 0x19306
movq %rax, 0x11b04(%rip)     # 0x241b8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19411
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1941f
jmp 0x126da
movq %r15, %rdi
movq %r14, %rsi
callq 0x17728
movq %rax, %rbx
movl 0x11d08(%rip), %ecx     # 0x243e8
leal 0x1(%rcx), %eax
movl %eax, 0x11cff(%rip)     # 0x243e8
cmpl 0x11cfd(%rip), %ecx     # 0x243ec
jl 0x126f7
movl %eax, 0x11cf5(%rip)     # 0x243ec
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa93b(%rip), %rdi      # 0x1d042
leaq 0xa4ca(%rip), %rsi      # 0x1cbd8
leaq 0xa940(%rip), %rcx      # 0x1d055
pushq $0x76
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpq 0x10934(%rip), %rdi     # 0x23fc0
je 0x136bb
movq %rdi, %rbx
leaq 0x10c08(%rip), %rsi     # 0x242a0
callq 0x19411
movq 0x10b14(%rip), %rsi     # 0x241b8
movq %rbx, %rdi
callq 0x1941f
movq %rbx, 0x10b05(%rip)     # 0x241b8
decl 0x10d2f(%rip)           # 0x243e8
popq %rbx
retq
leaq 0x1126e(%rip), %rax     # 0x24930
cmpl $0x0, (%rax)
je 0x136b9
leaq 0x10c62(%rip), %rbx     # 0x24330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x9997(%rip), %rdi      # 0x1d073
movq %rdi, 0x10(%rax)
callq 0x1a7f4
testl %eax, %eax
je 0x136b9
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x8e, 0xc(%rax)
leaq 0x997d(%rip), %rdi      # 0x1d07b
xorl %eax, %eax
popq %rbx
jmp 0x1b0f0
nop
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x1410f
pushq %rbx
movq %rdi, %rbx
movq 0x10724(%rip), %rdi     # 0x247f0
testq %rdi, %rdi
jne 0x140e5
movl $0x400, %edi            # imm = 0x400
callq 0x1a708
movq %rax, %rdi
movq %rax, 0x1070b(%rip)     # 0x247f0
callq 0x1a75f
movq 0x106ff(%rip), %rcx     # 0x247f0
leaq 0x6696(%rip), %rdx      # 0x1a78e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14117
movq 0x106e7(%rip), %rax     # 0x247f0
movq 0x10(%rax), %rax
popq %rbx
retq
leaq 0x91ce(%rip), %rax      # 0x1d2e4
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x20d0
movq %rax, %r15
cmpl $0x3fb, %r15d           # imm = 0x3FB
jg 0x166b4
movq %rsp, %r12
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
callq 0x13723
movslq %r15d, %rax
leaq (%rbx,%rax), %rdi
movl $0x400, %edx            # imm = 0x400
subl %eax, %edx
movq %r12, %rsi
callq 0x2070
movl $0x3a3a3a, 0x3fc(%rbx)  # imm = 0x3A3A3A
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/emit.c
// Function: tail_to_str
static void
tail_to_str(int depth, int length, char* buf, CONS* cons)
{
	int n;

	XDBUG_ENTER("tail_to_str");
#if 0
	child_to_str((depth - 1), buf, car(cons));
	n = strlen(buf);
	if (n < (CONS_BUFSZ - 3)) {
		buf[n++] = ',';
		buf[n++] = ' ';
		buf[n] = '\0';
	}
	child_to_str((depth - 1), buf, cdr(cons));
#else
	if (length < 0) {			/* length limit */
		n = strlen(buf);
		if (n < (CONS_BUFSZ - 4)) {
			buf[n++] = '.';
			buf[n++] = '.';
			buf[n++] = '.';
			buf[n] = '\0';
		}
	} else {
		child_to_str((depth - 1), buf, car(cons));
		n = strlen(buf);
		if (n < (CONS_BUFSZ - 3)) {
			buf[n++] = ',';
			buf[n++] = ' ';
			buf[n] = '\0';
		}
		cons = cdr(cons);	/* advance to tail */
		if (nilp(cons) || actorp(cons) || !consp(cons)) {
			child_to_str((depth - 1), buf, cons);
		} else {
			tail_to_str(depth, (length - 1), buf, cons);
		}
	}
#endif
	XDBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %ebp
movabsq $0x100000000, %r13      # imm = 0x100000000
decl %ebp
incl %r15d
leaq 0xdbb0(%rip), %r12      # 0x242a0
decl %r15d
js 0x16790
movq %r14, %rdi
callq 0x191fb
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x16659
movq %rbx, %rdi
callq 0x20d0
cmpl $0x3fc, %eax            # imm = 0x3FC
jg 0x1674b
movq %rax, %rcx
shlq $0x20, %rcx
cltq
movb $0x2c, (%rbx,%rax)
leaq (%rcx,%r13), %rax
sarq $0x20, %rax
movb $0x20, (%rbx,%rax)
movabsq $0x200000000, %rax      # imm = 0x200000000
addq %rax, %rcx
sarq $0x20, %rcx
movb $0x0, (%rbx,%rcx)
movq %r14, %rdi
callq 0x19306
movq %rax, %r14
cmpq %r12, %rax
je 0x16775
movl %r14d, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x16775
testq %r14, %r14
je 0x16775
testq %rax, %rax
je 0x166f0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16659
movq %rbx, %rdi
callq 0x20d0
cmpl $0x3fb, %eax            # imm = 0x3FB
jg 0x167e1
movq %rax, %rcx
shlq $0x20, %rcx
cltq
movb $0x2e, %dl
movb %dl, (%rbx,%rax)
addq %rcx, %r13
sarq $0x20, %r13
movb %dl, (%rbx,%r13)
movabsq $0x200000000, %rax      # imm = 0x200000000
addq %rcx, %rax
sarq $0x20, %rax
movb %dl, (%rbx,%rax)
movabsq $0x300000000, %rax      # imm = 0x300000000
addq %rcx, %rax
sarq $0x20, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/atom.c
// Function: lu_extend_atom
CONS*
lu_extend_atom(CONS* atom, int c)
/* return <atom> + <c> as a new atom, or atom of <c> if <atom> is NIL */
{
	CONS* root;
	CONS* node;
	CONS* ch = NUMBER(c);

	XDBUG_ENTER("lu_extend_atom");
	XDBUG_PRINT("", ("atom@%p = %s", atom, atom_str(atom)));
	XDBUG_PRINT("", ("c = %c(%d)", (isprint(c)?c:' '), c));
	if (lu_atom_root == NULL) {
		root = lu_cons(NIL, NIL);
		XDBUG_PRINT("", ("lu_atom_root = %p[%p;%p]", root, car(root), cdr(root)));
		lu_atom_root = MK_ATOM(root);
	}
	if ((atom == NULL) || nilp(atom)) {
		atom = lu_atom_root;
	}
	assert(atomp(atom));
	root = MK_CONS(atom);
	XDBUG_PRINT("", ("root = %p[%p;%p]", root, car(root), cdr(root)));
	node = cdr(root);
	for (;;) {
		XDBUG_PRINT("", ("node = %p[%p;%p]", node, car(node), cdr(node)));
		if (nilp(node)) {
			/* suffix not found, extend suffix list with new character */
			XDBUG_PRINT("", ("extending suffix list"));
			node = lu_cons(ch, car(root));
			node = lu_cons(node, NIL);
			rplacd(root, lu_cons(node, cdr(root)));
			break;
		}
		if (car(car(car(node))) == ch) {
			/* suffix found, return "atom" node */
			XDBUG_PRINT("", ("matched suffix list"));
			node = car(node);
			break;
		}
		node = cdr(node);
	}
	atom = MK_ATOM(node);
	assert(atomp(atom));
	XDBUG_RETURN atom;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0xe006(%rip), %rax      # 0x24818
testq %rax, %rax
jne 0x16835
leaq 0xda82(%rip), %rdi      # 0x242a0
movq %rdi, %rsi
callq 0x167f0
andq $-0x4, %rax
orq $0x2, %rax
movq %rax, 0xdfe3(%rip)      # 0x24818
cmpq 0xd784(%rip), %r14      # 0x23fc0
movq %r14, %rbx
cmoveq %rax, %rbx
testq %r14, %r14
cmoveq %rax, %rbx
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x16902
movslq %ebp, %rax
leaq 0x3(,%rax,4), %r14
andq $-0x4, %rbx
leaq 0xda32(%rip), %r12      # 0x242a0
movq %rbx, %r15
movq %r15, %rdi
callq 0x19306
cmpq %r12, %rax
je 0x168ab
movq %rax, %r15
movq %rax, %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x191fb
movq %rax, %rdi
callq 0x191fb
cmpq %r14, %rax
jne 0x16871
movq %r15, %rdi
callq 0x191fb
movq %rax, %r14
jmp 0x168ee
movq %rbx, %rdi
callq 0x191fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x167f0
leaq 0xd9db(%rip), %rsi      # 0x242a0
movq %rax, %rdi
callq 0x167f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x19306
movq %r14, %rdi
movq %rax, %rsi
callq 0x167f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1941f
andq $-0x4, %r14
orq $0x2, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7033(%rip), %rdi      # 0x1d93c
leaq 0x7038(%rip), %rsi      # 0x1d948
leaq 0x7038(%rip), %rcx      # 0x1d94f
pushq $0x2e
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0xd979(%rip), %rax      # 0x242a0
testq %rdi, %rdi
je 0x1695f
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x1695f
incq %rbx
leaq 0xd961(%rip), %rax      # 0x242a0
testb %cl, %cl
je 0x16955
movsbl %cl, %esi
movq %rax, %rdi
callq 0x167fe
movb (%rbx), %cl
incq %rbx
jmp 0x1693f
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x16961
popq %rbx
retq
leaq 0x6fd4(%rip), %rdi      # 0x1d93c
leaq 0x6fd9(%rip), %rsi      # 0x1d948
leaq 0x6ffb(%rip), %rcx      # 0x1d971
pushq $0x5a
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x59bd(%rip), %r14      # 0x1c34a
testq %rdi, %rdi
je 0x16a1d
movl %edi, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x16a1d
andq $-0x4, %rdi
callq 0x191fb
movq %rax, %rbx
movq %rax, %rdi
callq 0x19600
movl %eax, %ebp
movl %eax, %r14d
cmpl $0x100, %r14d           # imm = 0x100
jb 0x169d2
movq %rbx, %rdi
callq 0x19306
movq %rax, %rbx
decl %r14d
jmp 0x169b9
movl $0xff, %r15d
cmpl %r15d, %ebp
cmovbl %ebp, %r15d
leaq 0xde3a(%rip), %r14      # 0x24820
movb $0x0, (%r15,%r14)
testq %r15, %r15
jle 0x16a14
leaq -0x1(%r15), %r12
movq %rbx, %rdi
callq 0x191fb
shrl $0x2, %eax
movb %al, -0x1(%r15,%r14)
movq %rbx, %rdi
callq 0x19306
movq %rax, %rbx
movq %r12, %r15
jmp 0x169eb
cmpq 0xd5a5(%rip), %rbx      # 0x23fc0
jne 0x16a29
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6501(%rip), %rdi      # 0x1cf31
leaq 0x6f11(%rip), %rsi      # 0x1d948
leaq 0x6f49(%rip), %rcx      # 0x1d987
pushq $0x76
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x18(%rdi), %rbx
shlq $0x2, %rbx
cmpq %rdi, %rbx
je 0x1703b
decq (%rdi)
movq %rbx, %rdi
callq 0x16fbb
jmp 0x1703d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x10(%rdi), %rbx
shlq $0x2, %rbx
cmpq %rdi, %rbx
je 0x17065
decq (%rdi)
movq %rbx, %rdi
callq 0x16fbb
jmp 0x17067
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x680c(%rip), %rax      # 0x1dbba
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xcf73(%rip), %rax      # 0x24330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x119, 0xc(%rdi)       # imm = 0x119
leaq 0x4f72(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xce9d(%rip), %rcx      # 0x24280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b079
callq 0x18adf
testq %rbx, %rbx
je 0x17439
movl %ebx, %eax
andl $0x3, %eax
jne 0x17439
cmpq 0xcbb8(%rip), %rbx      # 0x23fc0
je 0x17412
movq %rbx, %rdi
callq 0x17458
callq 0x18cd4
cmpq $0x1, %rax
je 0x17412
callq 0x18ed5
leaq 0x8(%rsp), %rdi
movl $0x122, 0xc(%rdi)       # imm = 0x122
callq 0x1b1f2
addq $0x30, %rsp
popq %rbx
retq
leaq 0x678d(%rip), %rdi      # 0x1dbcd
leaq 0x66c1(%rip), %rsi      # 0x1db08
leaq 0x678b(%rip), %rcx      # 0x1dbd9
movl $0x11b, %edx            # imm = 0x11B
callq 0x2100