LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: assert_eval
static void
assert_eval(CONS* expr, CONS* expect)
{
	CONS* cust;

	prompt();
	cust = ACTOR(newline_beh, NIL);
	SEND(expr, pr(cust, ATOM("write")));  /* echo expr to console */
	cust = ACTOR(assert_beh, expect);
	cust = ACTOR(report_beh, cust);
	SEND(expr, pr(cust, pr(ATOM("eval"), a_ground_env)));
	run_test(M_limit);
	assert(_THIS(cust) == abort_beh);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1e7b3(%rip), %rcx     # 0x23378
leaq 0x176c5(%rip), %rdi     # 0x1c291
movl $0x3, %esi
movl $0x1, %edx
callq 0x2240
movq 0x1e796(%rip), %rdi     # 0x23378
callq 0x21c0
movq 0x1e7b2(%rip), %rdi     # 0x233a0
leaq 0x44b8(%rip), %rsi      # 0x90ad
leaq 0x1e6a4(%rip), %rdx     # 0x232a0
callq 0x1283a
movq %rax, %r15
movq 0x1e795(%rip), %r12     # 0x233a0
leaq 0x179be(%rip), %rdi     # 0x1c5d0
callq 0x1707c
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12917
movq 0x1e769(%rip), %rdi     # 0x233a0
leaq 0x4557(%rip), %rsi      # 0x9195
movq %r14, %rdx
callq 0x1283a
movq 0x1e753(%rip), %rdi     # 0x233a0
leaq 0x465d(%rip), %rsi      # 0x92b1
movq %rax, %rdx
callq 0x1283a
movq %rax, %r14
movq 0x1e73a(%rip), %r15     # 0x233a0
leaq 0x1792c(%rip), %rdi     # 0x1c599
callq 0x1707c
movq 0x1e74f(%rip), %rsi     # 0x233c8
movq %rax, %rdi
callq 0x19b84
movq %r14, %rdi
movq %rax, %rsi
callq 0x19b84
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12917
movl 0x1e500(%rip), %edi     # 0x231a0
callq 0x42ae
movq %r14, %rdi
callq 0x11cd8
leaq 0x46f7(%rip), %rcx      # 0x93ab
cmpq %rcx, %rax
jne 0x4cc5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x17b15(%rip), %rdi     # 0x1c7e1
leaq 0x17349(%rip), %rsi     # 0x1c01c
leaq 0x17b20(%rip), %rcx     # 0x1c7fa
movl $0xbc9, %edx            # imm = 0xBC9
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: read_eval_print_loop
static CONS*
read_eval_print_loop(FILE* f, BOOL interactive)
{
	CONS* cust;
	CONS* expr;
	
	DBUG_ENTER("read_eval_print_loop");
	input_file = f;
	current_source = file_source(input_file);
	for (;;) {
		if (interactive) {
			prompt();
		}
		expr = read_sexpr(current_source);
		if (expr == NUMBER(EOF)) {
			DBUG_RETURN a_inert;  /* end of input */
		} else if (!actorp(expr)) {
			DBUG_RETURN expr;  /* error */
		}
		cust = a_sink;
		if (interactive) {
			cust = ACTOR(report_beh, cust);
		}
		SEND(expr, pr(cust, pr(ATOM("eval"), a_ground_env)));  /* evaluate */
		run_repl(M_limit);  /* actor dispatch loop */
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x170ee(%rip), %rax     # 0x1cba6
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d86b(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb8b, 0xc(%rdi)       # imm = 0xB8B
leaq 0x1686a(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1d665(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movq %r14, 0x1d891(%rip)     # 0x23390
movq %r14, %rdi
callq 0x326b
movq %rax, 0x1d8ca(%rip)     # 0x233d8
leaq 0x16a84(%rip), %r14     # 0x1c599
leaq 0x16775(%rip), %r12     # 0x1c291
testq %rbx, %rbx
je 0x5b46
movq 0x1d850(%rip), %rcx     # 0x23378
movl $0x3, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x2240
movq 0x1d837(%rip), %rdi     # 0x23378
callq 0x21c0
movq 0x1d88b(%rip), %rdi     # 0x233d8
callq 0x3431
cmpq $-0x1, %rax
je 0x5bcf
movq %rax, %r13
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x5bd6
movq 0x1d866(%rip), %rbp     # 0x233d0
testq %rbx, %rbx
je 0x5b88
movq 0x1d82a(%rip), %rdi     # 0x233a0
leaq 0x3734(%rip), %rsi      # 0x92b1
movq %rbp, %rdx
callq 0x1283a
movq %rax, %rbp
movq 0x1d811(%rip), %r15     # 0x233a0
movq %r14, %rdi
callq 0x1707c
movq 0x1d82a(%rip), %rsi     # 0x233c8
movq %rax, %rdi
callq 0x19b84
movq %rbp, %rdi
movq %rax, %rsi
callq 0x19b84
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x12917
movl 0x1d5db(%rip), %edi     # 0x231a0
callq 0x4146
jmp 0x5b1c
movl $0xb94, %eax            # imm = 0xB94
jmp 0x5bdb
movl $0xb96, %eax            # imm = 0xB96
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: throw_beh
static
BEH_DECL(throw_beh)
{
	char* msg = cons_to_str(WHAT);

	DBUG_ENTER("throw_beh");
	DBUG_PRINT("FAIL!", ("%s", msg));
	fprintf(output_file, "FAIL! %s\n", msg);
	fflush(output_file);
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x30(%rdi), %rdi
callq 0x19c45
movq %rax, %rdi
callq 0x13b9c
movq %rax, %rbx
leaq 0x16951(%rip), %rax     # 0x1c568
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d70c(%rip), %r14     # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x37, 0xc(%rdi)
leaq 0x1670b(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1d506(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x1dcd2(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x5c9d
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x16901(%rip), %rdi     # 0x1c572
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x5c9d
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x38, 0xc(%rax)
leaq 0x178c1(%rip), %rdi     # 0x1d554
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b983
movq 0x1d6d4(%rip), %rdi     # 0x23378
leaq 0x168cd(%rip), %rsi     # 0x1c578
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
movq 0x1d6bc(%rip), %rdi     # 0x23378
callq 0x21c0
movq %rsp, %rdi
movl $0x3b, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: pair_comb_beh
static
BEH_DECL(pair_comb_beh)
{
	CONS* state = MINE;
	CONS* cust;
/*
	CONS* right;
	CONS* env;
*/
	CONS* comb = WHAT;

	DBUG_ENTER("pair_comb_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
/*
	ENSURE(is_pr(tl(state)));
	right = hd(tl(state));
	env = tl(tl(state));
	SEND(cust, pr(cust, pr(ATOM("comb"), pr(right, env))));
*/
	SEND(comb, pr(cust, pr(ATOM("comb"), 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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r14
leaq 0x15d34(%rip), %rax     # 0x1c5f0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1ca65(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x407, 0xc(%rdi)       # imm = 0x407
leaq 0x15a64(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1c85f(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq 0x1c6bb(%rip), %r15     # 0x22fc0
je 0x6961
testq %r15, %r15
je 0x6961
movl %r15d, %eax
andl $0x3, %eax
jne 0x6961
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
leaq 0x15cd8(%rip), %rdi     # 0x1c5fe
callq 0x1707c
movq %rax, %r13
movq %r15, %rdi
callq 0x19c45
movq %r13, %rdi
movq %rax, %rsi
callq 0x19b84
movq %r12, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x411, %eax            # imm = 0x411
jmp 0x69c0
leaq -0xd73(%rip), %rsi      # 0x5bf5
leaq 0x1c931(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x15bb2(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x1568c(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x1023, %esi           # imm = 0x1023
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x408, %eax            # imm = 0x408
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: pair_match_beh
static
BEH_DECL(pair_match_beh)
{
	CONS* cust = MINE;
	CONS* msg = WHAT;

	DBUG_ENTER("pair_match_beh");
	ENSURE(actorp(cust));
	if (is_pr(msg)
	&& (hd(msg) == a_inert)
	&& (tl(msg) == a_inert)) {
		SEND(cust, a_inert);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0x15964(%rip), %rax     # 0x1c612
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1c675(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x436, 0xc(%rdi)       # imm = 0x436
leaq 0x15674(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1c46f(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x6d56
movl $0x43d, %ebp            # imm = 0x43D
cmpq 0x1c2bb(%rip), %r15     # 0x22fc0
je 0x6db5
testq %r15, %r15
je 0x6db5
movl %r15d, %eax
andl $0x3, %eax
jne 0x6db5
movq %r15, %rdi
callq 0x19ba6
cmpq 0x1c679(%rip), %rax     # 0x233a8
jne 0x6db5
movq %r15, %rdi
callq 0x19c45
movq 0x1c664(%rip), %rdx     # 0x233a8
cmpq %rdx, %rax
jne 0x6db5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12917
jmp 0x6db5
leaq -0x1168(%rip), %rsi     # 0x5bf5
leaq 0x1c53c(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x157bd(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x15297(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x10df, %esi           # imm = 0x10DF
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x437, %ebp            # imm = 0x437
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: pair_copy_beh
static
BEH_DECL(pair_copy_beh)
{
	CONS* cust = MINE;
	CONS* head_tail = WHAT;

	DBUG_ENTER("pair_copy_beh");
	ENSURE(actorp(cust));
	if (is_pr(head_tail)) {
		SEND(cust, ACTOR(pair_type, head_tail));  /* immutable */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0x1563c(%rip), %rax     # 0x1c735
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1c22a(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x44b, 0xc(%rdi)       # imm = 0x44B
leaq 0x15229(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1c024(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x718d
movl $0x450, %ebp            # imm = 0x450
cmpq 0x1be70(%rip), %r15     # 0x22fc0
je 0x71ec
testq %r15, %r15
je 0x71ec
movl %r15d, %eax
andl $0x3, %eax
jne 0x71ec
leaq -0x3620(%rip), %rsi     # 0x3b52
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1283a
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
jmp 0x71ec
leaq -0x159f(%rip), %rsi     # 0x5bf5
leaq 0x1c105(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x15386(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x14e60(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x1133, %esi           # imm = 0x1133
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x44c, %ebp            # imm = 0x44C
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: pair_map_beh
static
BEH_DECL(pair_map_beh)
{
	CONS* cust = MINE;
	CONS* head_tail = WHAT;

	DBUG_ENTER("pair_map_beh");
	ENSURE(actorp(cust));
	if (is_pr(head_tail)) {
		SEND(cust, ACTOR(cons_type, head_tail));  /* mutable */
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0x1550d(%rip), %rax     # 0x1c743
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1c0ed(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x45e, 0xc(%rdi)       # imm = 0x45E
leaq 0x150ec(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1bee7(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x72ca
movl $0x463, %ebp            # imm = 0x463
cmpq 0x1bd33(%rip), %r15     # 0x22fc0
je 0x7329
testq %r15, %r15
je 0x7329
movl %r15d, %eax
andl $0x3, %eax
jne 0x7329
leaq -0x15d7(%rip), %rsi     # 0x5cd8
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1283a
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
jmp 0x7329
leaq -0x16dc(%rip), %rsi     # 0x5bf5
leaq 0x1bfc8(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x15249(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x14d23(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x117f, %esi           # imm = 0x117F
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x45f, %ebp            # imm = 0x45F
movq %rsp, %rdi
movl %ebp, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: tag_beh
static
BEH_DECL(tag_beh)
{
	CONS* cust = MINE;
	CONS* msg = WHAT;

	DBUG_ENTER("tag_beh");
	assert(actorp(cust));
	SEND(cust, pr(SELF, msg));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0x14ba4(%rip), %rax     # 0x1c692
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1b833(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1a1, 0xc(%rdi)       # imm = 0x1A1
leaq 0x14832(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1b62d(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7b78
movq 0x30(%rbx), %rdi
callq 0x19ba6
movq %rax, %rdi
movq %r15, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
leaq 0x8(%rsp), %rdi
movl $0x1a4, 0xc(%rdi)       # imm = 0x1A4
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x14ad0(%rip), %rdi     # 0x1c64f
leaq 0x14496(%rip), %rsi     # 0x1c01c
leaq 0x14b0d(%rip), %rcx     # 0x1c69a
movl $0x1a2, %edx            # imm = 0x1A2
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: join_beh
static
BEH_DECL(join_beh)
{
	CONS* state = MINE;
	CONS* cust;
	CONS* k_first;
	CONS* k_rest;
	CONS* msg = WHAT;

	DBUG_ENTER("join_beh");
	assert(is_pr(state));
	cust = hd(state);
	assert(actorp(cust));
	assert(is_pr(tl(state)));
	k_first = hd(tl(state));
	k_rest = tl(tl(state));

	if (is_pr(msg)) {
		if (hd(msg) == k_first) {
			BECOME(join_rest_beh, pr(cust, pr(k_rest, tl(msg))));
		} else if (hd(msg) == k_rest) {
			BECOME(join_first_beh, pr(cust, pr(k_first, tl(msg))));
		}
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r14
leaq 0x14ae2(%rip), %rax     # 0x1c6b1
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1b754(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x187, 0xc(%rdi)       # imm = 0x187
leaq 0x14753(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1b54e(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq 0x1b3aa(%rip), %r12     # 0x22fc0
je 0x7d70
testq %r12, %r12
je 0x7d70
movl %r12d, %eax
andl $0x3, %eax
jne 0x7d70
movq %r12, %rdi
callq 0x19ba6
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x7d8f
movq %r12, %rdi
callq 0x19c45
testq %rax, %rax
je 0x7d51
movq %r12, %rdi
callq 0x19c45
testb $0x3, %al
jne 0x7d51
movq %r12, %rdi
callq 0x19c45
cmpq 0x1b348(%rip), %rax     # 0x22fc0
je 0x7d51
movq %r12, %rdi
callq 0x19c45
andl $0x3, %eax
cmpl $0x1, %eax
je 0x7d51
movq %r12, %rdi
callq 0x19c45
movq %rax, %rdi
callq 0x19ba6
movq %rax, %r13
movq %r12, %rdi
callq 0x19c45
movq %rax, %rdi
callq 0x19c45
cmpq 0x1b304(%rip), %r14     # 0x22fc0
je 0x7d33
testq %r14, %r14
je 0x7d33
movq %rax, %r12
movl %r14d, %eax
andl $0x3, %eax
jne 0x7d33
movq %r14, %rdi
callq 0x19ba6
cmpq %r13, %rax
je 0x7cf4
movq %r14, %rdi
callq 0x19ba6
cmpq %r12, %rax
jne 0x7d33
leaq 0x350(%rip), %rbp       # 0x803f
movq %r13, %r12
jmp 0x7cfb
leaq 0xb3(%rip), %rbp        # 0x7dae
movq 0x30(%rbx), %rdi
callq 0x19ba6
movq %rax, %rbx
movq %r14, %rdi
callq 0x19c45
movq %r12, %rdi
movq %rax, %rsi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11f20
movq %rsp, %rdi
movl $0x196, 0xc(%rdi)       # imm = 0x196
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14904(%rip), %rdi     # 0x1c65c
leaq 0x142bd(%rip), %rsi     # 0x1c01c
leaq 0x14954(%rip), %rcx     # 0x1c6ba
movl $0x18b, %edx            # imm = 0x18B
callq 0x2100
leaq 0x148b3(%rip), %rdi     # 0x1c62a
leaq 0x1429e(%rip), %rsi     # 0x1c01c
leaq 0x14935(%rip), %rcx     # 0x1c6ba
movl $0x188, %edx            # imm = 0x188
callq 0x2100
leaq 0x148b9(%rip), %rdi     # 0x1c64f
leaq 0x1427f(%rip), %rsi     # 0x1c01c
leaq 0x14916(%rip), %rcx     # 0x1c6ba
movl $0x18a, %edx            # imm = 0x18A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: printable
static char*
printable(CONS* p)		/* WARNING! you must free this storage manually */
{
	char* s;
	char* t;
	
	s = cons_to_str(p);  /* pointer to static buffer */
	if (atomp(p)) { ++s; }  /* skip leading '#' */
	t = NEWxN(char, strlen(s) + 1);
	return strcpy(t, s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13b9c
andl $0x3, %ebx
xorl %r14d, %r14d
cmpl $0x2, %ebx
sete %r14b
addq %rax, %r14
movq %r14, %rdi
callq 0x20d0
leaq 0x1(%rax), %rsi
movl $0x1, %edi
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: dotted_tail_beh
static
BEH_DECL(dotted_tail_beh)
{
	CONS* state = MINE;
	CONS* cust;
	CONS* last;
	CONS* ok = WHAT;

	DBUG_ENTER("dotted_tail_beh");
	ENSURE(is_pr(state));
	cust = hd(state);
	ENSURE(actorp(cust));
	last = tl(state);
	
	if (ok == a_true) {
		CONS* k_close = ACTOR(dotted_close_beh, cust);
		SEND(last, pr(k_close, ATOM("write")));
	} else {
		SEND(cust, ok);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r14
leaq 0x13e2c(%rip), %rax     # 0x1c798
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1a9b7(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x200, 0xc(%rdi)       # imm = 0x200
leaq 0x139b6(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1a7b1(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq 0x1a60d(%rip), %r15     # 0x22fc0
je 0x89fc
testq %r15, %r15
je 0x89fc
movl %r15d, %eax
andl $0x3, %eax
jne 0x89fc
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8a60
movq %r15, %rdi
callq 0x19c45
cmpq 0x1a9a0(%rip), %r14     # 0x23388
je 0x8ac1
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
jmp 0x8af9
leaq -0x2e0e(%rip), %rsi     # 0x5bf5
leaq 0x1a896(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x13b17(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x135f1(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x807, %esi            # imm = 0x807
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x201, %eax            # imm = 0x201
jmp 0x8b03
leaq -0x2e72(%rip), %rsi     # 0x5bf5
leaq 0x1a832(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x13ab3(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x1358d(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x80f, %esi            # imm = 0x80F
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x203, %eax            # imm = 0x203
jmp 0x8b03
movq %rax, %r15
leaq 0x4f(%rip), %rsi        # 0x8b1a
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1283a
movq %rax, %r14
leaq 0x13af0(%rip), %rdi     # 0x1c5d0
callq 0x1707c
movq %r14, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x20c, %eax            # imm = 0x20C
movq %rsp, %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: dotted_close_beh
static
BEH_DECL(dotted_close_beh)
{
	CONS* cust = MINE;
	CONS* ok = WHAT;

	DBUG_ENTER("dotted_close_beh");
	ENSURE(actorp(cust));
	
	if (ok == a_true) {
		SINK* sink = current_sink;
		SEND(cust, (sink->put)(sink, NUMBER(')')));
	} else {
		SEND(cust, ok);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0x13c5b(%rip), %rax     # 0x1c7a8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a7d4(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1e2, 0xc(%rdi)       # imm = 0x1E2
leaq 0x137d3(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1a5ce(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x8bca
cmpq 0x1a7e7(%rip), %r15     # 0x23388
jne 0x8bb5
movq 0x1a80e(%rip), %rdi     # 0x233b8
movl $0xa7, %esi
callq *0x8(%rdi)
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12917
movl $0x1eb, %eax            # imm = 0x1EB
jmp 0x8c29
leaq -0x2fdc(%rip), %rsi     # 0x5bf5
leaq 0x1a6c8(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x13949(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0x13423(%rip), %rdi     # 0x1c01c
callq 0x1707c
movl $0x78f, %esi            # imm = 0x78F
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x1e3, %eax            # imm = 0x1E3
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: newline_beh
static
BEH_DECL(newline_beh)
{
	CONS* state = MINE;
	
	DBUG_ENTER("newline_beh");
	fputc('\n', output_file);
	fflush(output_file);
	if (is_pr(state) && actorp(hd(state))) {
		SEND(hd(state), tl(state));
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
leaq 0x13747(%rip), %rax     # 0x1c81b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a24d(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xb68, 0xc(%rdi)       # imm = 0xB68
leaq 0x1324c(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x1a047(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movq 0x1a25b(%rip), %rsi     # 0x23378
movl $0xa, %edi
callq 0x2130
movq 0x1a24a(%rip), %rdi     # 0x23378
callq 0x21c0
cmpq 0x19e86(%rip), %r14     # 0x22fc0
je 0x917a
testq %r14, %r14
je 0x917a
movl %r14d, %eax
andl $0x3, %eax
jne 0x917a
movq %r14, %rdi
callq 0x19ba6
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x917a
movq %r14, %rdi
callq 0x19ba6
movq %rax, %r15
movq %r14, %rdi
callq 0x19c45
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12917
leaq 0x8(%rsp), %rdi
movl $0xb6e, 0xc(%rdi)       # imm = 0xB6E
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/kernel.c
// Function: assert_beh
static
BEH_DECL(assert_beh)
{
	CONS* expect = MINE;
	CONS* actual = WHAT;

	DBUG_ENTER("assert_beh");
	DBUG_PRINT("", ("expect=%s", cons_to_str(expect)));
	if (equal(expect, actual)) {
		BECOME(abort_beh, NIL);
	} else {
		DBUG_PRINT("", ("actual=%s", cons_to_str(actual)));
		fprintf(stderr, "assert_beh: FAIL!\n");
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r14
leaq 0x1365b(%rip), %rax     # 0x1c827
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1a155(%rip), %r13     # 0x23330
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xbb1, 0xc(%rdi)       # imm = 0xBB1
leaq 0x13153(%rip), %r12     # 0x1c34a
movq %r12, 0x10(%rdi)
leaq 0x19f4e(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x1a71a(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x925b
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x1b084
testl %eax, %eax
je 0x925b
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0xbb2, 0xc(%rax)       # imm = 0xBB2
movq %r15, %rdi
callq 0x13b9c
leaq 0x135e1(%rip), %rdi     # 0x1c832
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
movq %r15, %rdi
movq %r14, %rsi
callq 0x19d00
testq %rax, %rax
je 0x92a9
movq 0x30(%rbx), %rdi
callq 0x19ba6
leaq 0x130(%rip), %rsi       # 0x93ab
leaq 0x1a01e(%rip), %rdx     # 0x232a0
movq %rax, %rdi
callq 0x11f20
leaq 0x8(%rsp), %rdi
movl $0xbba, 0xc(%rdi)       # imm = 0xBBA
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x22df
// File: /workspace/github_c_makefile_star2_O1/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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0x13573(%rip), %rax     # 0x1c859
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x1a03d(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0xb7e, 0xc(%r14)       # imm = 0xB7E
leaq 0x1303a(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%r14)
leaq 0x19e35(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1b912
movq %r12, %rdi
movq %r15, %rsi
callq 0x19b84
leaq -0x290(%rip), %rsi      # 0x90ad
movq %rbx, %rdi
movq %rax, %rdx
callq 0x1283a
movq %rax, %r12
leaq 0x1327e(%rip), %rdi     # 0x1c5d0
callq 0x1707c
movq %r12, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12917
movq 0x30(%rbx), %rdi
callq 0x19ba6
leaq 0x2b(%rip), %rsi        # 0x93ab
leaq 0x19f19(%rip), %rdx     # 0x232a0
movq %rax, %rdi
callq 0x11f20
movl $0xb82, 0xc(%r14)       # imm = 0xB82
movq %r14, %rdi
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19c45
movq %rax, %rdi
callq 0x13b9c
movq %rax, %rbx
leaq 0x13423(%rip), %rax     # 0x1c7f0
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x19f56(%rip), %r14     # 0x23330
movq (%r14), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x48, 0xc(%rdi)
leaq 0x12f55(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x19d50(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x1a51c(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x9453
movq (%r14), %rax
movq 0x50(%rax), %rax
leaq 0x1343d(%rip), %rdi     # 0x1c864
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x9453
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x49, 0xc(%rax)
leaq 0x1410b(%rip), %rdi     # 0x1d554
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1b983
movq 0x19b9e(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
leaq 0x13407(%rip), %rsi     # 0x1c86b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
movq 0x171a1(%rip), %r14     # 0x233b8
leaq 0x10804(%rip), %rax     # 0x1ca22
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17103(%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 0x10102(%rip), %rcx     # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x16efd(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq 0x16d59(%rip), %r15     # 0x22fc0
je 0xc313
testq %r15, %r15
je 0xc313
movl %r15d, %eax
andl $0x3, %eax
jne 0xc313
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xc377
movq 0x30(%rbx), %rdi
callq 0x19c45
cmpq 0x16d17(%rip), %rax     # 0x22fc0
je 0xc3d8
leaq -0x66c1(%rip), %rsi     # 0x5bf5
leaq 0x16fe3(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x10264(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xfd3e(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x2587, %esi           # imm = 0x2587
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x961, %eax            # imm = 0x961
jmp 0xc3f7
leaq -0x6725(%rip), %rsi     # 0x5bf5
leaq 0x16f7f(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x10200(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xfcda(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x257b, %esi           # imm = 0x257B
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x95e, %eax            # imm = 0x95E
jmp 0xc3f7
leaq -0x6789(%rip), %rsi     # 0x5bf5
leaq 0x16f1b(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0x1019c(%rip), %rdi     # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xfc76(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x2583, %esi           # imm = 0x2583
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x960, %eax            # imm = 0x960
jmp 0xc3f7
movl $0x2b, %esi
movq %r14, %rdi
callq *0x8(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x964, %eax            # imm = 0x964
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0xcf3c(%rip), %rax      # 0x1c971
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x138ec(%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 0xc8ea(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x136e5(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x13eb1(%rip), %r13     # 0x23930
cmpl $0x0, (%r13)
je 0xfaca
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xd08e(%rip), %rdi      # 0x1cb23
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0xfaca
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9ce, 0xc(%rax)       # imm = 0x9CE
movq %r14, %rdi
callq 0x13b9c
leaq 0xda94(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
cmpl $0x0, (%r13)
je 0xfb15
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xcea5(%rip), %rdi      # 0x1c985
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0xfb15
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x9cf, 0xc(%rax)       # imm = 0x9CF
movq %r15, %rdi
callq 0x13b9c
leaq 0xda49(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
cmpq 0x134a4(%rip), %r15     # 0x22fc0
je 0xfb8f
testq %r15, %r15
je 0xfb8f
movl %r15d, %eax
andl $0x3, %eax
jne 0xfb8f
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
movq %r15, %rdi
callq 0x19c45
movq %rax, %r15
movq 0x13888(%rip), %r13     # 0x233d0
leaq 0xca4a(%rip), %rdi      # 0x1c599
callq 0x1707c
movq %rax, %rdi
movq %r14, %rsi
callq 0x19b84
movq %r13, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x12917
movq 0x30(%rbx), %rdi
callq 0x19ba6
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x12917
leaq 0x8(%rsp), %rdi
movl $0x9d7, 0xc(%rdi)       # imm = 0x9D7
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r14
leaq 0xcdbc(%rip), %rax      # 0x1c9a1
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1373c(%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 0xc73b(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x13536(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq 0x13392(%rip), %r15     # 0x22fc0
je 0xfce0
testq %r15, %r15
je 0xfce0
movl %r15d, %eax
andl $0x3, %eax
jne 0xfce0
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xfd41
movq %r15, %rdi
callq 0x19c45
movq %rax, %rdi
callq 0x19ba6
movq %rax, %r13
movq %r15, %rdi
callq 0x19c45
movq %rax, %rdi
callq 0x19c45
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x19b84
leaq -0xc146(%rip), %rsi     # 0x3b52
movq %rbx, %rdi
movq %rax, %rdx
callq 0x1283a
movq %rax, %r14
leaq 0xc8ec(%rip), %rdi      # 0x1c599
callq 0x1707c
movq %rax, %rdi
movq %r15, %rsi
callq 0x19b84
movq %r12, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x2cb, %eax            # imm = 0x2CB
jmp 0xfda0
leaq -0xa0f2(%rip), %rsi     # 0x5bf5
leaq 0x135b2(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0xc833(%rip), %rdi      # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xc30d(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0xb13, %esi            # imm = 0xB13
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x2c4, %eax            # imm = 0x2C4
jmp 0xfda0
leaq -0xa153(%rip), %rsi     # 0x5bf5
leaq 0x13551(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0xc7d2(%rip), %rdi      # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xc2ac(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0xb1b, %esi            # imm = 0xB1B
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x2c6, %eax            # imm = 0x2C6
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r14
leaq 0xcc79(%rip), %rax      # 0x1ca6b
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1352f(%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 0xc52e(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x13329(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
cmpq 0x13185(%rip), %r15     # 0x22fc0
je 0xfeb5
testq %r15, %r15
je 0xfeb5
movl %r15d, %eax
andl $0x3, %eax
jne 0xfeb5
movq %r15, %rdi
callq 0x19ba6
movq %rax, %r12
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xff19
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xff7a
leaq 0xca55(%rip), %rdi      # 0x1c8cc
callq 0x1707c
movq %rax, %r13
movq %r15, %rdi
callq 0x19c45
movq %r13, %rdi
movq %rax, %rsi
callq 0x19b84
movq %r12, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x8ec, %eax            # imm = 0x8EC
jmp 0xffd9
leaq -0xa2c7(%rip), %rsi     # 0x5bf5
leaq 0x133dd(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0xc65e(%rip), %rdi      # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xc138(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x239b, %esi           # imm = 0x239B
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x8e6, %eax            # imm = 0x8E6
jmp 0xffd9
leaq -0xa32b(%rip), %rsi     # 0x5bf5
leaq 0x13379(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0xc5fa(%rip), %rdi      # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xc0d4(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x23a3, %esi           # imm = 0x23A3
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x8e8, %eax            # imm = 0x8E8
jmp 0xffd9
leaq -0xa38c(%rip), %rsi     # 0x5bf5
leaq 0x13318(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0xc599(%rip), %rdi      # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xc073(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x23a7, %esi           # imm = 0x23A7
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x8e9, %eax            # imm = 0x8E9
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r15
leaq 0xc825(%rip), %rax      # 0x1cad3
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x13073(%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 0xc071(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x12e6c(%rip), %rcx     # 0x23150
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
leaq 0x13638(%rip), %r13     # 0x23930
cmpl $0x0, (%r13)
je 0x10343
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xc911(%rip), %rdi      # 0x1cc1f
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x10343
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x12b, 0xc(%rax)       # imm = 0x12B
movq %r14, %rdi
callq 0x13b9c
leaq 0xd21b(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
cmpl $0x0, (%r13)
je 0x1038e
movq (%r12), %rax
movq 0x50(%rax), %rax
leaq 0xd8cc(%rip), %rdi      # 0x1dc25
movq %rdi, 0x10(%rax)
callq 0x1b084
testl %eax, %eax
je 0x1038e
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x12c, 0xc(%rax)       # imm = 0x12C
movq %r15, %rdi
callq 0x13b9c
leaq 0xd1d0(%rip), %rdi      # 0x1d554
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x103ae
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12917
movl $0x12f, %eax            # imm = 0x12F
jmp 0x1040d
leaq -0xa7c0(%rip), %rsi     # 0x5bf5
leaq 0x12ee4(%rip), %rdx     # 0x232a0
movq %rbx, %rdi
callq 0x1283a
movq %rax, %r14
leaq 0xc165(%rip), %rdi      # 0x1c533
callq 0x1707c
movq %rax, %r15
leaq 0xbc3f(%rip), %rdi      # 0x1c01c
callq 0x1707c
movl $0x4b7, %esi            # imm = 0x4B7
movq %rax, %rdi
callq 0x19b84
movq %r15, %rdi
movq %rax, %rsi
callq 0x19b84
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12917
movl $0x12d, %eax            # imm = 0x12D
leaq 0x8(%rsp), %rdi
movl %eax, 0xc(%rdi)
callq 0x1ba97
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11cf2
andq $-0x4, %rdi
callq 0x1839d
sarq $0x2, %rax
popq %rcx
retq
leaq 0xaed2(%rip), %rdi      # 0x1cbcb
leaq 0xaed8(%rip), %rsi      # 0x1cbd8
leaq 0xaed9(%rip), %rcx      # 0x1cbe0
movl $0x13, %edx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r14
leaq 0xae0a(%rip), %rdi      # 0x1cc3a
callq 0x1707c
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1a07a
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x19ba6
movq %rax, %rdi
callq 0x11d11
movq %rax, %r15
leaq 0xade1(%rip), %rdi      # 0x1cc41
callq 0x1707c
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1a07a
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x19c45
movq %rax, %r12
leaq 0xadc1(%rip), %rax      # 0x1cc49
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1149b(%rip), %rax     # 0x23330
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x60, 0xc(%rdi)
leaq 0xa49a(%rip), %rcx      # 0x1c34a
movq %rcx, 0x10(%rdi)
leaq 0x112ed(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movq %r14, %rdi
movq %r12, %rsi
callq 0x19d00
testq %rax, %rax
je 0x11f12
movq 0x30(%rbx), %rdi
callq 0x19ba6
leaq -0x1a4(%rip), %rsi      # 0x11d44
leaq 0x113b1(%rip), %rdx     # 0x232a0
movq %rax, %rdi
callq 0x11f20
movq %rsp, %rdi
movl $0x68, 0xc(%rdi)
callq 0x1ba97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x243d
// File: /workspace/github_c_makefile_star2_O1/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 0xaddf(%rip), %rax      # 0x1cd1d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x113e5(%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 0xa3e3(%rip), %r15      # 0x1c34a
movq %r15, 0x10(%rdi)
leaq 0x11236(%rip), %rcx     # 0x231a8
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1b912
movl %ebx, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1201c
movq %rbx, %r13
andq $-0x4, %r13
leaq 0x3(,%r12,4), %rsi
movq %r13, %rdi
callq 0x19ce4
movq %r13, %rdi
movq %r14, %rsi
callq 0x19cf2
leaq 0x1197a(%rip), %rax     # 0x23930
cmpl $0x0, (%rax)
je 0x11ffb
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x1b084
testl %eax, %eax
je 0x11ffb
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x15a, 0xc(%rax)       # imm = 0x15A
movq %rbx, %rdi
callq 0x13b9c
leaq 0xad5a(%rip), %rdi      # 0x1cd4b
movq %rax, %rsi
xorl %eax, %eax
callq 0x1b983
movq %rsp, %rdi
movl $0x15b, 0xc(%rdi)       # imm = 0x15B
callq 0x1ba97
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaba8(%rip), %rdi      # 0x1cbcb
leaq 0xabae(%rip), %rsi      # 0x1cbd8
leaq 0xacf3(%rip), %rcx      # 0x1cd24
movl $0x157, %edx            # imm = 0x157
callq 0x2100