LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
movq 0x171b5(%rip), %r14     # 0x233b8
leaq 0x10818(%rip), %rax     # 0x1ca22
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17117(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x95d, 0xc(%rdi)       # imm = 0x95D
leaq 0x10116(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x16f11(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq 0x16d6d(%rip), %r15     # 0x22fc0
je 0xc2ff
testq %r15, %r15
je 0xc2ff
movl %r15d, %eax
andl $0x3, %eax
jne 0xc2ff
movq %r15, %rdi
callq 0x19c72
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xc363
movq 0x30(%rbx), %rdi
callq 0x19d11
cmpq 0x16d2b(%rip), %rax     # 0x22fc0
je 0xc3c4
leaq -0x66fa(%rip), %rsi     # 0x5ba8
leaq 0x16ff7(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x10278(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xfd52(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x2587, %esi           # imm = 0x2587
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x961, %eax            # imm = 0x961
jmp 0xc3e3
leaq -0x675e(%rip), %rsi     # 0x5ba8
leaq 0x16f93(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x10214(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xfcee(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x257b, %esi           # imm = 0x257B
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x95e, %eax            # imm = 0x95E
jmp 0xc3e3
leaq -0x67c2(%rip), %rsi     # 0x5ba8
leaq 0x16f2f(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0x101b0(%rip), %rdi     # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xfc8a(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x2583, %esi           # imm = 0x2583
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x960, %eax            # imm = 0x960
jmp 0xc3e3
movl $0x2b, %esi
movq %r14, %rdi
callq *0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x964, %eax            # imm = 0x964
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0xcf14(%rip), %rax      # 0x1c971
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x138c4(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x9cc, 0xc(%rdi)       # imm = 0x9CC
leaq 0xc8c2(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x136bd(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x13e89(%rip), %r13     # 0x23930
cmpl $0x0, (%r13)
je 0xfb41
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xd062(%rip), %rdi      # 0x1cb23
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0xfaf6
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9ce, 0xc(%rax)       # imm = 0x9CE
movq %r14, %rdi
callq 0x13c40
leaq 0xda68(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
cmpl $0x0, (%r13)
je 0xfb41
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xce79(%rip), %rdi      # 0x1c985
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0xfb41
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9cf, 0xc(%rax)       # imm = 0x9CF
movq %r15, %rdi
callq 0x13c40
leaq 0xda1d(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
cmpq 0x13478(%rip), %r15     # 0x22fc0
je 0xfbbb
testq %r15, %r15
je 0xfbbb
movl %r15d, %eax
andl $0x3, %eax
jne 0xfbbb
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
movq %r15, %rdi
callq 0x19d11
movq %rax, %r15
movq 0x1385c(%rip), %r13     # 0x233d0
leaq 0xca1e(%rip), %rdi      # 0x1c599
callq 0x170ff
movq %rax, %rdi
movq %r14, %rsi
callq 0x19c50
movq %r13, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1299b
movq 0x30(%rbx), %rdi
callq 0x19c72
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1299b
leaq 0x8(%rsp), %rdi
movl $0x9d7, 0xc(%rdi)       # imm = 0x9D7
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/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 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r14
leaq 0xcd90(%rip), %rax      # 0x1c9a1
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x13710(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x2c3, 0xc(%rdi)       # imm = 0x2C3
leaq 0xc70f(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1350a(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq 0x13366(%rip), %r15     # 0x22fc0
je 0xfd0c
testq %r15, %r15
je 0xfd0c
movl %r15d, %eax
andl $0x3, %eax
jne 0xfd0c
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xfd6d
movq %r15, %rdi
callq 0x19d11
movq %rax, %rdi
callq 0x19c72
movq %rax, %r13
movq %r15, %rdi
callq 0x19d11
movq %rax, %rdi
callq 0x19d11
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x19c50
leaq -0xc150(%rip), %rsi     # 0x3b74
movq %rbx, %rdi
movq %rax, %rdx
callq 0x128be
movq %rax, %r14
leaq 0xc8c0(%rip), %rdi      # 0x1c599
callq 0x170ff
movq %rax, %rdi
movq %r15, %rsi
callq 0x19c50
movq %r12, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x2cb, %eax            # imm = 0x2CB
jmp 0xfdcc
leaq -0xa16b(%rip), %rsi     # 0x5ba8
leaq 0x13586(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0xc807(%rip), %rdi      # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xc2e1(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0xb13, %esi            # imm = 0xB13
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x2c4, %eax            # imm = 0x2C4
jmp 0xfdcc
leaq -0xa1cc(%rip), %rsi     # 0x5ba8
leaq 0x13525(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0xc7a6(%rip), %rdi      # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xc280(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0xb1b, %esi            # imm = 0xB1B
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x2c6, %eax            # imm = 0x2C6
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/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 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r14
leaq 0xcc4d(%rip), %rax      # 0x1ca6b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x13503(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x8e5, 0xc(%rdi)       # imm = 0x8E5
leaq 0xc502(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x132fd(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
cmpq 0x13159(%rip), %r15     # 0x22fc0
je 0xfee1
testq %r15, %r15
je 0xfee1
movl %r15d, %eax
andl $0x3, %eax
jne 0xfee1
movq %r15, %rdi
callq 0x19c72
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xff45
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xffa6
leaq 0xca29(%rip), %rdi      # 0x1c8cc
callq 0x170ff
movq %rax, %r13
movq %r15, %rdi
callq 0x19d11
movq %r13, %rdi
movq %rax, %rsi
callq 0x19c50
movq %r12, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x8ec, %eax            # imm = 0x8EC
jmp 0x10005
leaq -0xa340(%rip), %rsi     # 0x5ba8
leaq 0x133b1(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0xc632(%rip), %rdi      # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xc10c(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x239b, %esi           # imm = 0x239B
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x8e6, %eax            # imm = 0x8E6
jmp 0x10005
leaq -0xa3a4(%rip), %rsi     # 0x5ba8
leaq 0x1334d(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0xc5ce(%rip), %rdi      # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xc0a8(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x23a3, %esi           # imm = 0x23A3
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x8e8, %eax            # imm = 0x8E8
jmp 0x10005
leaq -0xa405(%rip), %rsi     # 0x5ba8
leaq 0x132ec(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0xc56d(%rip), %rdi      # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xc047(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x23a7, %esi           # imm = 0x23A7
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x8e9, %eax            # imm = 0x8E9
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/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 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r15
leaq 0xc7f9(%rip), %rax      # 0x1cad3
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x13047(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x12a, 0xc(%rdi)       # imm = 0x12A
leaq 0xc045(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x12e40(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x1360c(%rip), %r13     # 0x23930
cmpl $0x0, (%r13)
je 0x103be
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xc8e1(%rip), %rdi      # 0x1cc1f
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x10373
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x12b, 0xc(%rax)       # imm = 0x12B
movq %r14, %rdi
callq 0x13c40
leaq 0xd1eb(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
cmpl $0x0, (%r13)
je 0x103be
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xd89c(%rip), %rdi      # 0x1dc25
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x103be
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq %r15, %rdi
callq 0x13c40
leaq 0xd1a0(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x103de
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1299b
movl $0x12f, %eax            # imm = 0x12F
jmp 0x1043d
leaq -0xa83d(%rip), %rsi     # 0x5ba8
leaq 0x12eb4(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x128be
movq %rax, %r14
leaq 0xc135(%rip), %rdi      # 0x1c533
callq 0x170ff
movq %rax, %r15
leaq 0xbc0f(%rip), %rdi      # 0x1c01c
callq 0x170ff
movl $0x4b7, %esi            # imm = 0x4B7
movq %rax, %rdi
callq 0x19c50
movq %r15, %rdi
movq %rax, %rsi
callq 0x19c50
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1299b
movl $0x12d, %eax            # imm = 0x12D
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/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 0x11d46
andq $-0x4, %rdi
callq 0x18421
sarq $0x2, %rax
popq %rcx
retq
leaq 0xae7e(%rip), %rdi      # 0x1cbcb
leaq 0xae84(%rip), %rsi      # 0x1cbd8
leaq 0xae85(%rip), %rcx      # 0x1cbe0
movl $0x13, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r14
leaq 0xadb4(%rip), %rdi      # 0x1cc3a
callq 0x170ff
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1a146
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x11d65
movq %rax, %r15
leaq 0xad8b(%rip), %rdi      # 0x1cc41
callq 0x170ff
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1a146
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19d11
movq %rax, %r13
leaq 0xad6b(%rip), %rax      # 0x1cc49
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x11443(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x60, 0xc(%rdi)
leaq 0xa442(%rip), %r12      # 0x1c34a
movq %r12, 0x10(%rdi)
leaq 0x11295(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movq %r14, %rdi
movq %r13, %rsi
callq 0x19dcc
testq %rax, %rax
je 0x11f6e
movq 0x30(%rbx), %rdi
callq 0x19c72
leaq -0x1a8(%rip), %rsi      # 0x11d98
leaq 0x11359(%rip), %rdx     # 0x232a0
movq %rax, %rdi
callq 0x11fbe
leaq 0x8(%rsp), %rdi
movl $0x68, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x119bb(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x11f85
movq %r13, %rdi
movq %r14, %rsi
callq 0x2490
movq 0x1106c(%rip), %rax     # 0x22ff8
movq (%rax), %rbx
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x11fa5
movq %r15, %rdi
callq 0x1715e
movq %rax, %r12
leaq 0xaca8(%rip), %rsi      # 0x1cc54
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2180
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 0xad41(%rip), %rax      # 0x1cd1d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x11347(%rip), %rbp     # 0x23330
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x156, 0xc(%rdi)       # imm = 0x156
leaq 0xa345(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x11198(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x120ba
movq %rbx, %r13
andq $-0x4, %r13
leaq 0x3(,%r12,4), %rsi
movq %r13, %rdi
callq 0x19db0
movq %r13, %rdi
movq %r14, %rsi
callq 0x19dbe
leaq 0x118dc(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x12099
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12099
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x15a, 0xc(%rax)       # imm = 0x15A
movq %rbx, %rdi
callq 0x13c40
leaq 0xacbc(%rip), %rdi      # 0x1cd4b
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq %rsp, %rdi
movl $0x15b, 0xc(%rdi)       # imm = 0x15B
callq 0x1bbab
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xab0a(%rip), %rdi      # 0x1cbcb
leaq 0xab10(%rip), %rsi      # 0x1cbd8
leaq 0xac55(%rip), %rcx      # 0x1cd24
movl $0x157, %edx            # imm = 0x157
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0xf4241, %rsi          # imm = 0xF4241
jl 0x12130
xorl %eax, %eax
movq %r14, %rcx
subq $0x1e8480, %rcx         # imm = 0x1E8480
cmovaeq %rcx, %rax
addq $0xf423f, %rax          # imm = 0xF423F
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
mulq %rcx
shrq $0x12, %rdx
addq %rdx, %rbx
incq %rbx
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
movq $-0xf4240, %rcx         # imm = 0xFFF0BDC0
addq %r14, %rcx
addq %rax, %rcx
movq %rcx, %r14
leaq 0xab97(%rip), %rdi      # 0x1ccce
callq 0x170ff
leaq 0x3(,%r14,4), %rdx
leaq 0x11155(%rip), %rdi     # 0x232a0
movq %rax, %rsi
callq 0x1a1b8
movq %rax, %r14
leaq 0xb3f8(%rip), %rdi      # 0x1d555
callq 0x170ff
leaq 0x3(,%rbx,4), %rdx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a1b8
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdx, %rcx
cmpq $0xf4241, %rdx          # imm = 0xF4241
jl 0x121cc
xorl %eax, %eax
movq %rcx, %rdx
subq $0x1e8480, %rdx         # imm = 0x1E8480
cmovaeq %rdx, %rax
addq $0xf423f, %rax          # imm = 0xF423F
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
mulq %rdx
shrq $0x12, %rdx
addq %rdx, %rdi
incq %rdi
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
movq $-0xf4240, %rdx         # imm = 0xFFF0BDC0
addq %rcx, %rdx
addq %rax, %rdx
movq %rdx, %rcx
addq %rsi, %rcx
movq %rcx, %rsi
jmp 0x120d9
// File: /workspace/github_c_makefile_star2_O3/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 0xa8e6(%rip), %rax      # 0x1ccd1
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x10f38(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf6, 0xc(%rdi)
leaq 0x9f36(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x10d89(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x114fd(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x12470
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12470
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0xf7, 0xc(%rax)
leaq 0xa87b(%rip), %rdi      # 0x1cce1
movq %r14, %rsi
xorl %eax, %eax
callq 0x1ba97
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x19c50
movq %rax, 0x20(%rbx)
movq %rsp, %rdi
movl $0xf9, 0xc(%rdi)
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa83c(%rip), %rax      # 0x1ccea
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10e73(%rip), %r15     # 0x23330
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x12a, 0xc(%rdi)       # imm = 0x12A
leaq 0x9e72(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x10cc5(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movq %rbx, %rdi
callq 0x12567
movq %rax, %rbx
leaq 0x1142e(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x12544
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12544
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq %rbx, %rdi
callq 0x19fab
leaq 0xa7bc(%rip), %rdi      # 0x1ccf7
movl %eax, %esi
xorl %eax, %eax
callq 0x1ba97
movq %rbx, %rdi
callq 0x17cd6
leaq 0x8(%rsp), %rdi
movl $0x12e, 0xc(%rdi)       # imm = 0x12E
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa506(%rip), %rax      # 0x1cd07
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x10b22(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x139, 0xc(%rdi)       # imm = 0x139
leaq 0x9b20(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x10973(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
movq %rbx, %rdi
callq 0x12567
movq %rax, %r14
leaq 0x110dc(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x12898
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12898
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x13b, 0xc(%rax)       # imm = 0x13B
movq %r14, %rdi
callq 0x19fab
leaq 0xa468(%rip), %rdi      # 0x1ccf7
movl %eax, %esi
xorl %eax, %eax
callq 0x1ba97
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18014
movq %rsp, %rdi
movl $0x13d, 0xc(%rdi)       # imm = 0x13D
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb34f(%rip), %rax      # 0x1dc25
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x10a4d(%rip), %r12     # 0x23330
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x148, 0xc(%rdi)       # imm = 0x148
leaq 0x9a4b(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x1089e(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x3(,%r15,4), %rdi
movq %rbx, %rsi
callq 0x19c50
movq %rax, %rbx
andq $-0x4, %rbx
incq %rbx
leaq 0x10ff8(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x1297d
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x1297d
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x14c, 0xc(%rax)       # imm = 0x14C
movq %rbx, %rdi
callq 0x13c40
leaq 0xa3a1(%rip), %rdi      # 0x1cd14
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq %rsp, %rdi
movl $0x14d, 0xc(%rdi)       # imm = 0x14D
callq 0x1bbab
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa39a(%rip), %rax      # 0x1cd53
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1096a(%rip), %r13     # 0x23330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x167, 0xc(%rdi)       # imm = 0x167
leaq 0x9968(%rip), %r14      # 0x1c34a
movq %r14, 0x10(%rdi)
leaq 0x107bb(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0x10f2f(%rip), %rbp     # 0x23930
cmpl $0x0, (%rbp)
je 0x12a47
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12a47
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x168, 0xc(%rax)       # imm = 0x168
movq %r12, %rdi
callq 0x13c40
leaq 0xa31b(%rip), %rdi      # 0x1cd58
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movl %r12d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x12b66
cmpl $0x0, (%rbp)
je 0x12a9c
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12a9c
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x16a, 0xc(%rax)       # imm = 0x16A
movq %r15, %rdi
callq 0x13c40
leaq 0xa308(%rip), %rdi      # 0x1cd9a
movq %rax, %rsi
xorl %eax, %eax
callq 0x1ba97
movq %r12, %rdi
movq %r15, %rsi
callq 0x12b85
movq %rax, %r15
movq %rbx, %rdi
callq 0x19c72
cmpq 0x10507(%rip), %rax     # 0x22fc0
je 0x12ae2
movq %rbx, %rdi
callq 0x19d11
movq %rax, %r12
leaq 0x107d3(%rip), %rsi     # 0x232a0
movq %r15, %rdi
callq 0x12b85
movq %r12, %rdi
movq %rax, %rsi
callq 0x19dbe
jmp 0x12afc
leaq 0x107b7(%rip), %rsi     # 0x232a0
movq %r15, %rdi
callq 0x12b85
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19db0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19dbe
incl 0x28(%rbx)
cmpl $0x0, (%rbp)
je 0x12b48
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x1b188
testl %eax, %eax
je 0x12b48
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x16f, 0xc(%rax)       # imm = 0x16F
movl 0x28(%rbx), %esi
leaq 0xa260(%rip), %rdi      # 0x1cda1
xorl %eax, %eax
callq 0x1ba97
movq %rsp, %rdi
movl $0x170, 0xc(%rdi)       # imm = 0x170
callq 0x1bbab
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa1f5(%rip), %rdi      # 0x1cd62
leaq 0xa064(%rip), %rsi      # 0x1cbd8
leaq 0xa1f6(%rip), %rcx      # 0x1cd71
movl $0x169, %edx            # imm = 0x169
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0x10621(%rip), %rbx     # 0x231b8
cmpq 0x10422(%rip), %rbx     # 0x22fc0
je 0x12bd3
testq %rbx, %rbx
je 0x12c07
movl %ebx, %eax
andl $0x3, %eax
jne 0x12c07
movq %rbx, %rdi
callq 0x19d11
movq %rax, 0x105fd(%rip)     # 0x231b8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19db0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19dbe
jmp 0x12be1
movq %r15, %rdi
movq %r14, %rsi
callq 0x180e8
movq %rax, %rbx
movl 0x10801(%rip), %ecx     # 0x233e8
leal 0x1(%rcx), %eax
movl %eax, 0x107f8(%rip)     # 0x233e8
cmpl 0x107f6(%rip), %ecx     # 0x233ec
jl 0x12bfe
movl %eax, 0x107ee(%rip)     # 0x233ec
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa434(%rip), %rdi      # 0x1d042
leaq 0x9fc3(%rip), %rsi      # 0x1cbd8
leaq 0xa439(%rip), %rcx      # 0x1d055
movl $0x76, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0xf3fa(%rip), %rdi      # 0x22fc0
je 0x13bf5
movq %rdi, %rbx
leaq 0xf6ce(%rip), %rsi      # 0x232a0
callq 0x19db0
movq 0xf5da(%rip), %rsi      # 0x231b8
movq %rbx, %rdi
callq 0x19dbe
movq %rbx, 0xf5cb(%rip)      # 0x231b8
decl 0xf7f5(%rip)            # 0x233e8
popq %rbx
retq
leaq 0xfd34(%rip), %rax      # 0x23930
cmpl $0x0, (%rax)
je 0x13bf3
leaq 0xf728(%rip), %rbx      # 0x23330
movq (%rbx), %rax
movq 0x50(%rax), %rax
leaq 0x945d(%rip), %rdi      # 0x1d073
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x13bf3
movq (%rbx), %rax
movq 0x50(%rax), %rax
movl $0x8e, 0xc(%rax)
leaq 0x9443(%rip), %rdi      # 0x1d07b
xorl %eax, %eax
popq %rbx
jmp 0x1ba97
// File: /workspace/github_c_makefile_star2_O3/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 0x147a0
pushq %rbx
movq %rdi, %rbx
movq 0xf093(%rip), %rdi      # 0x237f0
testq %rdi, %rdi
jne 0x14776
movl $0x400, %edi            # imm = 0x400
callq 0x1b078
movq %rax, %rdi
movq %rax, 0xf07a(%rip)      # 0x237f0
callq 0x1b0d6
movq 0xf06e(%rip), %rcx      # 0x237f0
leaq 0x697f(%rip), %rdx      # 0x1b108
movq %rbx, %rdi
xorl %esi, %esi
callq 0x147a8
movq 0xf056(%rip), %rax      # 0x237f0
movq 0x10(%rax), %rax
popq %rbx
retq
leaq 0x8b5d(%rip), %rax      # 0x1d304
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdx, %rbx
testl %esi, %esi
js 0x16f24
movq %rcx, %r14
movl %esi, %r15d
movl %edi, %ebp
movabsq $0x100000000, %r13      # imm = 0x100000000
decl %ebp
incl %r15d
leaq 0xc404(%rip), %r12      # 0x232a0
movq %r14, %rdi
callq 0x19c72
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x16dfd
movq %rbx, %rdi
callq 0x20d0
cmpl $0x3fc, %eax            # imm = 0x3FC
jg 0x16eee
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 0x19d11
movq %rax, %r14
cmpq %r12, %rax
je 0x16f8d
movl %r14d, %eax
andl $0x3, %eax
cmpq $0x1, %rax
je 0x16f8d
testq %r14, %r14
je 0x16f8d
testq %rax, %rax
jne 0x16f8d
decl %r15d
testl %r15d, %r15d
jg 0x16e9c
movq %rbx, %rdi
callq 0x20d0
cmpl $0x3fb, %eax            # imm = 0x3FB
jg 0x16f7e
movq %rax, %rcx
shlq $0x20, %rcx
cltq
movb $0x2e, %dl
movb %dl, (%rbx,%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rcx, %rax
sarq $0x20, %rax
movb %dl, (%rbx,%rax)
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
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 0x16dfd
// File: /workspace/github_c_makefile_star2_O3/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 0xc84e(%rip), %rax      # 0x23818
testq %rax, %rax
jne 0x16ff3
leaq 0xc2ca(%rip), %rdi      # 0x232a0
movq %rdi, %rsi
callq 0x180e8
incl 0xc82c(%rip)            # 0x23810
andq $-0x4, %rax
orq $0x2, %rax
movq %rax, 0xc825(%rip)      # 0x23818
cmpq 0xbfc6(%rip), %r14      # 0x22fc0
movq %r14, %rbx
cmoveq %rax, %rbx
testq %r14, %r14
cmoveq %rax, %rbx
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x170e0
movslq %ebp, %rax
leaq 0x3(,%rax,4), %r14
andq $-0x4, %rbx
movq %rbx, %rdi
callq 0x19d11
cmpq 0xbf8c(%rip), %rax      # 0x22fc0
je 0x1706d
movq %rax, %r15
leaq 0xc260(%rip), %r12      # 0x232a0
movq %r15, %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x19c72
movq %rax, %rdi
callq 0x19c72
movq %r15, %rdi
cmpq %r14, %rax
je 0x170c4
callq 0x19d11
movq %rax, %r15
cmpq %r12, %rax
jne 0x17040
movq %rbx, %rdi
callq 0x19c72
movq %r14, %rdi
movq %rax, %rsi
callq 0x180e8
incl 0xc78a(%rip)            # 0x23810
leaq 0xc213(%rip), %rsi      # 0x232a0
movq %rax, %rdi
callq 0x180e8
movq %rax, %r14
incl 0xc772(%rip)            # 0x23810
movq %rbx, %rdi
callq 0x19d11
movq %r14, %rdi
movq %rax, %rsi
callq 0x180e8
incl 0xc759(%rip)            # 0x23810
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19dbe
jmp 0x170cc
callq 0x19c72
movq %rax, %r14
andq $-0x4, %r14
orq $0x2, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6875(%rip), %rdi      # 0x1d95c
leaq 0x687a(%rip), %rsi      # 0x1d968
leaq 0x687a(%rip), %rcx      # 0x1d96f
movl $0x2e, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 0xc199(%rip), %rax      # 0x232a0
testq %rdi, %rdi
je 0x1713d
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x1713d
incq %rbx
leaq 0xc181(%rip), %rax      # 0x232a0
movsbl %cl, %esi
movq %rax, %rdi
callq 0x16fb6
movb (%rbx), %cl
incq %rbx
testb %cl, %cl
jne 0x1711f
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x1713f
popq %rbx
retq
leaq 0x6816(%rip), %rdi      # 0x1d95c
leaq 0x681b(%rip), %rsi      # 0x1d968
leaq 0x683d(%rip), %rcx      # 0x1d991
movl $0x5a, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
leaq 0x51de(%rip), %rax      # 0x1c34a
testq %rdi, %rdi
je 0x1721f
movl %edi, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x1721f
andq $-0x4, %rdi
callq 0x19c72
movq %rax, %rbx
movq %rax, %rdi
callq 0x19fab
movl %eax, %ebp
cmpl $0x100, %eax            # imm = 0x100
jb 0x171c3
movl %ebp, %r14d
movq %rbx, %rdi
callq 0x19d11
movq %rax, %rbx
decl %r14d
cmpl $0xff, %r14d
ja 0x171a3
movb $0x0, 0xc75e(%rip)      # 0x2391f
jmp 0x171d4
movl %ebp, %eax
leaq 0xc654(%rip), %rcx      # 0x23820
movb $0x0, (%rax,%rcx)
testl %ebp, %ebp
je 0x1720f
movl $0xff, %r14d
cmpl %r14d, %ebp
cmovbl %ebp, %r14d
incq %r14
leaq 0xc635(%rip), %r15      # 0x23820
movq %rbx, %rdi
callq 0x19c72
shrl $0x2, %eax
movb %al, -0x2(%r14,%r15)
movq %rbx, %rdi
callq 0x19d11
movq %rax, %rbx
decq %r14
cmpq $0x1, %r14
ja 0x171eb
cmpq 0xbdaa(%rip), %rbx      # 0x22fc0
jne 0x1722a
leaq 0xc601(%rip), %rax      # 0x23820
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5d00(%rip), %rdi      # 0x1cf31
leaq 0x6730(%rip), %rsi      # 0x1d968
leaq 0x6768(%rip), %rcx      # 0x1d9a7
movl $0x76, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x18(%rdi), %rax
shlq $0x2, %rax
cmpq %rdi, %rax
je 0x178e3
decq (%rdi)
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
shlq $0x2, %rdx
sarq $0x2, %rdx
movq %rdx, 0x18(,%rcx,4)
shlq $0x2, %rcx
sarq $0x2, %rcx
movq 0x18(%rax), %rdx
movq 0x10(,%rdx,4), %rsi
andl $0xc0000000, %esi       # imm = 0xC0000000
orq %rcx, %rsi
movq %rsi, 0x10(,%rdx,4)
movq %rax, %rcx
sarq $0x2, %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rdx
andl $0xc0000000, %edx       # imm = 0xC0000000
orq %rcx, %rdx
movq %rdx, 0x10(%rax)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5ef5(%rip), %rax      # 0x1dbda
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb63c(%rip), %rax      # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x119, 0xc(%rdi)       # imm = 0x119
leaq 0x463b(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb566(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
callq 0x19574
testq %rbx, %rbx
je 0x17d70
movl %ebx, %eax
andl $0x3, %eax
jne 0x17d70
cmpq 0xb281(%rip), %rbx      # 0x22fc0
je 0x17d49
movq %rbx, %rdi
callq 0x17d8f
callq 0x19769
cmpq $0x1, %rax
je 0x17d49
callq 0x199c2
leaq 0x8(%rsp), %rdi
movl $0x122, 0xc(%rdi)       # imm = 0x122
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
retq
leaq 0x5e76(%rip), %rdi      # 0x1dbed
leaq 0x5daa(%rip), %rsi      # 0x1db28
leaq 0x5e74(%rip), %rcx      # 0x1dbf9
movl $0x11b, %edx            # imm = 0x11B
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_scan_cell
static void
gc_scan_cell(CELL* p)
/* move a live cell (from the "aged" list) to the "scan" list */
{
	WORD mark;

	DBUG_ENTER("gc_scan_cell");
	DBUG_PRINT("gc", ("p = %p", p));
	mark = GC_MARK(p);
	if (mark == gc_phase__mark) {
		DBUG_PRINT("gc", ("cell already marked"));
		DBUG_RETURN;		/* cell already marked in this phase */
	}
	assert(mark == gc_phase__prev);
	GC_SET_SIZE(GC_AGED_LIST, GC_SIZE(GC_AGED_LIST) - 1);
	p = gc_extract(p);	
	GC_SET_MARK(p, gc_phase__mark);
	gc_put(GC_SCAN_LIST, p);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x628d(%rip), %rax      # 0x1e02f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb57f(%rip), %r14      # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xd0, 0xc(%rdi)
leaq 0x457e(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb4a9(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
leaq 0xbb45(%rip), %r15      # 0x23930
cmpl $0x0, (%r15)
je 0x17e2b
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x4ef5(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x17e2b
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd1, 0xc(%rax)
leaq 0x621b(%rip), %rdi      # 0x1e03c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1ba97
movq 0x10(%rbx), %rcx
movl %ecx, %edx
andl $0xc0000000, %edx       # imm = 0xC0000000
movq 0xb45a(%rip), %rax      # 0x23298
cmpq %rax, %rdx
jne 0x17e92
movl $0xd5, %ebx
cmpl $0x0, (%r15)
je 0x17f49
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x4e94(%rip), %rdi      # 0x1ccf4
movq %rdi, 0x10(%rax)
callq 0x1b188
testl %eax, %eax
je 0x17f49
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0xd4, 0xc(%rax)
leaq 0x61bd(%rip), %rdi      # 0x1e043
xorl %eax, %eax
callq 0x1ba97
jmp 0x17f49
cmpq 0xb3f7(%rip), %rdx      # 0x23290
jne 0x17f60
decq 0xb33a(%rip)            # 0x231e0
movq 0x18(%rbx), %rdx
shlq $0x2, %rdx
sarq $0x2, %rdx
movq %rdx, 0x18(,%rcx,4)
shlq $0x2, %rcx
sarq $0x2, %rcx
movq 0x18(%rbx), %rdx
movq 0x10(,%rdx,4), %rsi
andl $0xc0000000, %esi       # imm = 0xC0000000
orq %rcx, %rsi
movq %rsi, 0x10(,%rdx,4)
movq %rbx, %rcx
sarq $0x2, %rcx
movl %ecx, %edx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
orq %rax, %rdx
movq %rdx, 0x10(%rbx)
incq 0xb304(%rip)            # 0x23200
leaq 0xb2fd(%rip), %rdx      # 0x23200
sarq $0x2, %rdx
movq %rdx, 0x18(%rbx)
movq 0xb2fe(%rip), %rdx      # 0x23210
shlq $0x2, %rdx
sarq $0x2, %rdx
andl $0xc0000000, %eax       # imm = 0xC0000000
orq %rdx, %rax
movq %rax, 0x10(%rbx)
movq 0xb2e3(%rip), %rax      # 0x23210
movq %rcx, 0x18(,%rax,4)
andl $0xc0000000, %eax       # imm = 0xC0000000
orq %rcx, %rax
movq %rax, 0xb2cc(%rip)      # 0x23210
movl $0xdc, %ebx
leaq 0x8(%rsp), %rdi
movl %ebx, 0xc(%rdi)
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x60f0(%rip), %rdi      # 0x1e057
leaq 0x5bba(%rip), %rsi      # 0x1db28
leaq 0x60f9(%rip), %rcx      # 0x1e06e
movl $0xd7, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/gc.c
// Function: gc_scanning_actor
BEH_DECL(gc_scanning_actor)
{
	DBUG_ENTER("gc_scanning_actor");
	if (gc_refresh_cell() == TRUE) {
		SEND(SELF, NIL);			/* more aged cells to scan */
	} else {
		gc_free_cells();			/* scanning complete */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x5c8b(%rip), %rax      # 0x1dc19
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xb393(%rip), %rax      # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x133, 0xc(%rdi)       # imm = 0x133
leaq 0x4392(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0xb2bd(%rip), %rcx      # 0x23280
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1ba26
callq 0x19769
cmpq $0x1, %rax
je 0x17fe2
callq 0x199c2
jmp 0x17ffd
movq 0x30(%rbx), %rdi
callq 0x19c72
leaq 0xb2ae(%rip), %rdx      # 0x232a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1299b
leaq 0x8(%rsp), %rdi
movl $0x139, 0xc(%rdi)       # imm = 0x139
callq 0x1bbab
addq $0x30, %rsp
popq %rbx
retq