LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_reduce
BEH_DECL(reduce_reduce)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);

	DBUG_ENTER("reduce_reduce");
	if (consp(expr)) {
		CONS* state;
		CONS* actor;

		/* evaluate first argument and send to apply actor */
		state = NIL;
		state = map_put(state, env_symbol, env);
		state = map_put(state, cont_symbol, cont);
		actor = ACTOR(apply_reduce, state);
		msg = NIL;
		msg = map_put(msg, env_symbol, env);
		msg = map_put(msg, cont_symbol, actor);
		msg = map_put(msg, expr_symbol, car(expr));
		SEND(a_reduce, msg);
	} else {	/* error */
		SEND(an_error, ATOM("reduce: illegal argument"));
		msg = NIL;
		msg = map_put(msg, expr_symbol, undefined_symbol);
		SEND(cont, 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 0x11685
movq %rax, %r12
movq 0x17f9c(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
movq 0x17f80(%rip), %rsi     # 0x1b140
movq %r12, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x17f84(%rip), %rsi     # 0x1b158
movq %r12, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
leaq 0x10f60(%rip), %rax     # 0x14148
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x18191(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf0, 0xc(%rdi)
leaq 0x138f2(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%rdi)
leaq 0x17f13(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
testq %r14, %r14
sete %al
testb $0x3, %r14b
setne %cl
orb %al, %cl
je 0x3281
movq 0x17f1e(%rip), %r14     # 0x1b160
leaq 0x10f0d(%rip), %rdi     # 0x14156
callq 0xea73
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
movq 0x17ee5(%rip), %rsi     # 0x1b148
movq 0x17efe(%rip), %rdx     # 0x1b168
leaq 0x18087(%rip), %rdi     # 0x1b2f8
callq 0x11b2c
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x330f
movq 0x17ed0(%rip), %rsi     # 0x1b158
leaq 0x18069(%rip), %r13     # 0x1b2f8
movq %r13, %rdi
movq %r12, %rdx
callq 0x11b2c
movq 0x17e9f(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r15, %rdx
callq 0x11b2c
leaq -0x292(%rip), %rsi      # 0x3021
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa232
movq %rax, %r15
movq 0x17e90(%rip), %rsi     # 0x1b158
movq %r13, %rdi
movq %r12, %rdx
callq 0x11b2c
movq 0x17e66(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r15, %rdx
callq 0x11b2c
movq %rax, %r15
movq 0x17e59(%rip), %r12     # 0x1b148
movq %r14, %rdi
callq 0x115e6
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x11b2c
movq 0x17e74(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x105, 0xc(%rdi)       # imm = 0x105
callq 0x1351f
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/reduce.c
// Function: reduce_literal
BEH_DECL(reduce_literal)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
/*	CONS* env = map_get(msg, env_symbol); */
	
	DBUG_ENTER("reduce_literal");
	expr = car(expr);
	DBUG_PRINT("", ("expr=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq %rax, %r14
movq 0x17def(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x17dd3(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x10dee(%rip), %rax     # 0x1416f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17ff8(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x113, 0xc(%rdi)       # imm = 0x113
leaq 0x13758(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x17d79(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
movq %rax, %r15
leaq 0x1855a(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x341b
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x341b
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x115, 0xc(%rax)       # imm = 0x115
movq %r15, %rdi
callq 0xb5b4
leaq 0x11184(%rip), %rdi     # 0x14595
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x17d26(%rip), %rsi     # 0x1b148
leaq 0x17ecf(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x117, 0xc(%rdi)       # imm = 0x117
callq 0x1351f
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/reduce.c
// Function: reduce_and_apply
BEH_DECL(reduce_and_apply)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);
	CONS* state = MINE;
	CONS* beh = map_get(state, beh_symbol);
	CONS* apply;

	DBUG_ENTER("reduce_and_apply");
	assert(funcp(beh));
	state = NIL;
	state = map_put(state, env_symbol, env);
	state = map_put(state, cont_symbol, cont);
	apply = ACTOR(MK_BEH(beh), state);
	msg = NIL;
	msg = map_put(msg, env_symbol, env);
	msg = map_put(msg, cont_symbol, apply);
	msg = map_put(msg, expr_symbol, expr);
	SEND(a_reduce_args, 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 0x11685
movq %rax, %r15
movq 0x17cc6(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
movq 0x17caa(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x17cae(%rip), %rsi     # 0x1b158
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x17cb9(%rip), %rsi     # 0x1b188
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r13
leaq 0x10c9b(%rip), %rax     # 0x1417e
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x17e98(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x129, 0xc(%rdi)       # imm = 0x129
leaq 0x135f9(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%rdi)
leaq 0x17c1a(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movl %r13d, %eax
notl %eax
testb $0x3, %al
jne 0x35d6
movq 0x17c21(%rip), %rsi     # 0x1b158
leaq 0x17dba(%rip), %rbp     # 0x1b2f8
movq %rbp, %rdi
movq %r15, %rdx
callq 0x11b2c
movq 0x17bf0(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r12, %rdx
callq 0x11b2c
sarq $0x2, %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xa232
movq %rax, %r12
movq 0x17be1(%rip), %rsi     # 0x1b158
movq %rbp, %rdi
movq %r15, %rdx
callq 0x11b2c
movq 0x17bb7(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r12, %rdx
callq 0x11b2c
movq 0x17bad(%rip), %rsi     # 0x1b148
movq %rax, %rdi
movq %r14, %rdx
callq 0x11b2c
movq 0x17be3(%rip), %rsi     # 0x1b190
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa30f
movq %rsp, %rdi
movl $0x134, 0xc(%rdi)       # imm = 0x134
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10bb2(%rip), %rdi     # 0x1418f
leaq 0x10a49(%rip), %rsi     # 0x1402d
leaq 0x10baf(%rip), %rcx     # 0x1419a
movl $0x12a, %edx            # imm = 0x12A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: eval_list
BEH_DECL(eval_list)	/* FIXME:  this is a NO-OP, we should probably just use reduce_seq() directly */
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_list");
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x17b33(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x17b06(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
leaq 0x10b6c(%rip), %rax     # 0x141ba
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17d2b(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x143, 0xc(%rdi)       # imm = 0x143
leaq 0x1348b(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x17aac(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
leaq 0x18298(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x36dd
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x36dd
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x144, 0xc(%rax)       # imm = 0x144
movq %r14, %rdi
callq 0xb5b4
leaq 0x10af1(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x17a64(%rip), %rsi     # 0x1b148
leaq 0x17c0d(%rip), %rdi     # 0x1b2f8
movq %r14, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x146, 0xc(%rdi)       # imm = 0x146
callq 0x1351f
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/reduce.c
// Function: eval_first
BEH_DECL(eval_first)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_first");
	if (consp(expr) && consp(car(expr))) {
		CONS* p = car(expr);

		if (nilp(p)) {
			expr = NIL;
		} else {
			expr = car(p);
		}
	} else {	/* error */
		SEND(an_error, ATOM("first: list required"));
		expr = undefined_symbol;
	}
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x17a08(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x179db(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x10a54(%rip), %rax     # 0x141cd
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17c00(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x158, 0xc(%rdi)       # imm = 0x158
leaq 0x13360(%rip), %r15     # 0x16b04
movq %r15, 0x10(%rdi)
leaq 0x17981(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
testq %r12, %r12
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x37ea
movq %r12, %rdi
callq 0x115e6
testq %rax, %rax
je 0x37ea
movq %r12, %rdi
callq 0x115e6
testb $0x3, %al
je 0x38a1
movq 0x1796f(%rip), %r12     # 0x1b160
leaq 0x109e0(%rip), %rdi     # 0x141d8
callq 0xea73
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa30f
movq 0x17956(%rip), %r12     # 0x1b168
leaq 0x18117(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x385e
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12afc
testl %eax, %eax
je 0x385e
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x165, 0xc(%rax)       # imm = 0x165
movq %r12, %rdi
callq 0xb5b4
leaq 0x10970(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x178e3(%rip), %rsi     # 0x1b148
leaq 0x17a8c(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x167, 0xc(%rdi)       # imm = 0x167
callq 0x1351f
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x115e6
leaq 0x17a48(%rip), %r12     # 0x1b2f8
cmpq %r12, %rax
je 0x3812
movq %rax, %rdi
callq 0x115e6
movq %rax, %r12
jmp 0x3812
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: eval_rest
BEH_DECL(eval_rest)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_rest");
	if (consp(expr) && consp(car(expr))) {
		CONS* p = car(expr);

		if (nilp(p)) {
			expr = NIL;
		} else {
			expr = cdr(p);
		}
	} else {	/* error */
		SEND(an_error, ATOM("rest: list required"));
		expr = undefined_symbol;
	}
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x1785f(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x17832(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x108cb(%rip), %rax     # 0x141ed
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17a57(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x179, 0xc(%rdi)       # imm = 0x179
leaq 0x131b7(%rip), %r15     # 0x16b04
movq %r15, 0x10(%rdi)
leaq 0x177d8(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
testq %r12, %r12
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x3993
movq %r12, %rdi
callq 0x115e6
testq %rax, %rax
je 0x3993
movq %r12, %rdi
callq 0x115e6
testb $0x3, %al
je 0x3a4a
movq 0x177c6(%rip), %r12     # 0x1b160
leaq 0x10856(%rip), %rdi     # 0x141f7
callq 0xea73
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa30f
movq 0x177ad(%rip), %r12     # 0x1b168
leaq 0x17f6e(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3a07
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12afc
testl %eax, %eax
je 0x3a07
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x186, 0xc(%rax)       # imm = 0x186
movq %r12, %rdi
callq 0xb5b4
leaq 0x107c7(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x1773a(%rip), %rsi     # 0x1b148
leaq 0x178e3(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x188, 0xc(%rdi)       # imm = 0x188
callq 0x1351f
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x115e6
leaq 0x1789f(%rip), %r12     # 0x1b2f8
cmpq %r12, %rax
je 0x39bb
movq %rax, %rdi
callq 0x11685
movq %rax, %r12
jmp 0x39bb
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: eval_prepend
BEH_DECL(eval_prepend)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_prepend");
	expr = cons(car(expr), car(cdr(expr)));
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	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 0x11685
movq 0x176b5(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x17688(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x1073f(%rip), %rax     # 0x1420b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x178af(%rip), %rbp     # 0x1b388
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x197, 0xc(%rdi)       # imm = 0x197
leaq 0x1300f(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x17630(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
movq %rax, %r13
movq %r15, %rdi
callq 0x11685
movq %rax, %rdi
callq 0x115e6
movq %r13, %rdi
movq %rax, %rsi
callq 0x115c4
movq %rax, %r15
leaq 0x17df3(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3b82
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x3b82
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x199, 0xc(%rax)       # imm = 0x199
movq %r15, %rdi
callq 0xb5b4
leaq 0x1064c(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x175bf(%rip), %rsi     # 0x1b148
leaq 0x17768(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
movq %rsp, %rdi
movl $0x19b, 0xc(%rdi)       # imm = 0x19B
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: eval_listp
BEH_DECL(eval_listp)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_listp");
	expr = consp(car(expr)) ? true_symbol : false_symbol;
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x17564(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x17537(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x105fb(%rip), %rax     # 0x14218
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1775c(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1ad, 0xc(%rdi)       # imm = 0x1AD
leaq 0x12ebc(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x174dd(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
testq %rax, %rax
je 0x3c8e
movq %r15, %rdi
callq 0x115e6
testb $0x3, %al
leaq 0x174f2(%rip), %rax     # 0x1b170
leaq 0x174f3(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
jmp 0x3c95
movq 0x174e3(%rip), %r15     # 0x1b178
leaq 0x17c94(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3ce1
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x3ce1
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1af, 0xc(%rax)       # imm = 0x1AF
movq %r15, %rdi
callq 0xb5b4
leaq 0x104ed(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x17460(%rip), %rsi     # 0x1b148
leaq 0x17609(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x1b1, 0xc(%rdi)       # imm = 0x1B1
callq 0x1351f
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/reduce.c
// Function: eval_emptyp
BEH_DECL(eval_emptyp)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_emptyp");
	expr = nilp(car(expr)) ? true_symbol : false_symbol;
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x17404(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x173d7(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x104a6(%rip), %rax     # 0x14223
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x175fc(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1c3, 0xc(%rdi)       # imm = 0x1C3
leaq 0x12d5c(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x1737d(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
cmpq 0x171f1(%rip), %rax     # 0x1afc0
leaq 0x1739a(%rip), %rax     # 0x1b170
leaq 0x1739b(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x17b45(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3e30
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x3e30
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1c5, 0xc(%rax)       # imm = 0x1C5
movq %r15, %rdi
callq 0xb5b4
leaq 0x1039e(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x17311(%rip), %rsi     # 0x1b148
leaq 0x174ba(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x1c7, 0xc(%rdi)       # imm = 0x1C7
callq 0x1351f
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/reduce.c
// Function: eval_numberp
BEH_DECL(eval_numberp)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_numberp");
	expr = numberp(car(expr)) ? true_symbol : false_symbol;
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x172b5(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x17288(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x10363(%rip), %rax     # 0x1422f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x174ad(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1d9, 0xc(%rdi)       # imm = 0x1D9
leaq 0x12c0d(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x1722e(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
notl %eax
testb $0x3, %al
leaq 0x1724e(%rip), %rax     # 0x1b170
leaq 0x1724f(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x179f9(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3f7c
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x3f7c
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1db, 0xc(%rax)       # imm = 0x1DB
movq %r15, %rdi
callq 0xb5b4
leaq 0x10252(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x171c5(%rip), %rsi     # 0x1b148
leaq 0x1736e(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x1dd, 0xc(%rdi)       # imm = 0x1DD
callq 0x1351f
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/reduce.c
// Function: eval_zerop
BEH_DECL(eval_zerop)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_zerop");
	expr = (car(expr) == NUMBER(0)) ? true_symbol : false_symbol;
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq 0x17169(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x1713c(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x10224(%rip), %rax     # 0x1423c
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17361(%rip), %r13     # 0x1b388
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1ef, 0xc(%rdi)       # imm = 0x1EF
leaq 0x12ac1(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x170e2(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
cmpq $0x3, %rax
leaq 0x17102(%rip), %rax     # 0x1b170
leaq 0x17103(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x178ad(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x40c8
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x40c8
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1f1, 0xc(%rax)       # imm = 0x1F1
movq %r15, %rdi
callq 0xb5b4
leaq 0x10106(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x17079(%rip), %rsi     # 0x1b148
leaq 0x17222(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
leaq 0x8(%rsp), %rdi
movl $0x1f3, 0xc(%rdi)       # imm = 0x1F3
callq 0x1351f
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/reduce.c
// Function: eval_equalp
BEH_DECL(eval_equalp)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_equalp");
	expr = equal(car(expr), car(cdr(expr))) ? true_symbol : false_symbol;
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	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 0x11685
movq 0x1701c(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x16fef(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0x100e2(%rip), %rax     # 0x14247
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x17216(%rip), %rbp     # 0x1b388
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x205, 0xc(%rdi)       # imm = 0x205
leaq 0x12976(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x16f97(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r15, %rdi
callq 0x115e6
movq %rax, %r13
movq %r15, %rdi
callq 0x11685
movq %rax, %rdi
callq 0x115e6
movq %r13, %rdi
movq %rax, %rsi
callq 0x11740
testq %rax, %rax
leaq 0x16f9a(%rip), %rax     # 0x1b170
leaq 0x16f9b(%rip), %rcx     # 0x1b178
cmovneq %rax, %rcx
movq (%rcx), %r15
leaq 0x17745(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x4230
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12afc
testl %eax, %eax
je 0x4230
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x207, 0xc(%rax)       # imm = 0x207
movq %r15, %rdi
callq 0xb5b4
leaq 0xff9e(%rip), %rdi      # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x16f11(%rip), %rsi     # 0x1b148
leaq 0x170ba(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
movq %rsp, %rdi
movl $0x209, 0xc(%rdi)       # imm = 0x209
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: eval_preceedp
BEH_DECL(eval_preceedp)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	CONS* arg1;
	CONS* arg2;
	
	DBUG_ENTER("eval_preceedp");
	arg1 = car(expr);
	arg2 = car(cdr(expr));
	if (numberp(arg1) && numberp(arg2)) {
		expr = (MK_INT(arg1) < MK_INT(arg2)) ? true_symbol : false_symbol;
	} else {
		SEND(an_error, ATOM("preceed?: numbers required"));
		expr = undefined_symbol;
	}
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	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 0x11685
movq 0x16eb5(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq 0x16e88(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0xff87(%rip), %rax      # 0x14253
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x170af(%rip), %rbp     # 0x1b388
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x220, 0xc(%rdi)       # imm = 0x220
leaq 0x1280f(%rip), %r15     # 0x16b04
movq %r15, 0x10(%rdi)
leaq 0x16e30(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r12, %rdi
callq 0x115e6
movq %rax, %r13
movq %r12, %rdi
callq 0x11685
movq %rax, %rdi
callq 0x115e6
movl %r13d, %ecx
notl %ecx
testb $0x3, %cl
jne 0x435d
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x435d
shrq $0x2, %r13
shrq $0x2, %rax
cmpl %eax, %r13d
leaq 0x16e23(%rip), %rax     # 0x1b170
leaq 0x16e24(%rip), %rcx     # 0x1b178
cmovlq %rax, %rcx
movq (%rcx), %r12
jmp 0x4385
movq 0x16dfc(%rip), %r12     # 0x1b160
leaq 0xfef6(%rip), %rdi      # 0x14261
callq 0xea73
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa30f
movq 0x16de3(%rip), %r12     # 0x1b168
leaq 0x175a4(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x43d1
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12afc
testl %eax, %eax
je 0x43d1
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x229, 0xc(%rax)       # imm = 0x229
movq %r12, %rdi
callq 0xb5b4
leaq 0xfdfd(%rip), %rdi      # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x16d70(%rip), %rsi     # 0x1b148
leaq 0x16f19(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa30f
movq %rsp, %rdi
movl $0x22b, 0xc(%rdi)       # imm = 0x22B
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: apply_define
BEH_DECL(apply_define)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* binding = map_get(state, ATOM("binding"));
	CONS* cont = map_get(state, cont_symbol);
	DBUG_ENTER("apply_define");

	assert(atomp(car(binding)));
	rplacd(binding, expr);
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, car(binding)));
	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 0x11685
movq 0x16904(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq %rax, %r15
leaq 0xfa63(%rip), %rdi      # 0x142cf
callq 0xea73
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x168b8(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
leaq 0xfa3b(%rip), %rax      # 0x142d7
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x16adf(%rip), %rbp     # 0x1b388
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x284, 0xc(%rdi)       # imm = 0x284
leaq 0x1223f(%rip), %r13     # 0x16b04
movq %r13, 0x10(%rdi)
leaq 0x16860(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
movq %r12, %rdi
callq 0x115e6
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x4995
movq %r12, %rdi
movq %r14, %rsi
callq 0x11732
leaq 0x1702d(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x4948
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12afc
testl %eax, %eax
je 0x4948
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x288, 0xc(%rax)       # imm = 0x288
movq %r14, %rdi
callq 0xb5b4
leaq 0xf886(%rip), %rdi      # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x167f9(%rip), %r14     # 0x1b148
movq %r12, %rdi
callq 0x115e6
leaq 0x1699a(%rip), %rdi     # 0x1b2f8
movq %r14, %rsi
movq %rax, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa30f
movq %rsp, %rdi
movl $0x28a, 0xc(%rdi)       # imm = 0x28A
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf948(%rip), %rdi      # 0x142e4
leaq 0xf68a(%rip), %rsi      # 0x1402d
leaq 0xf94e(%rip), %rcx      # 0x142f8
movl $0x286, %edx            # imm = 0x286
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_sum
BEH_DECL(reduce_sum)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);
	CONS* state;
	CONS* actor;

	DBUG_ENTER("reduce_sum");
	state = NIL;
	state = map_put(state, env_symbol, env);
	state = map_put(state, cont_symbol, cont);
	state = map_put(state, form_symbol, cdr(expr));
	state = map_put(state, ATOM("acc"), NUMBER(0));
	actor = ACTOR(apply_sum, state);
	msg = NIL;
	msg = map_put(msg, env_symbol, env);
	msg = map_put(msg, cont_symbol, actor);
	msg = map_put(msg, expr_symbol, car(expr));
	SEND(a_reduce, 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 0x11685
movq %rax, %r14
movq 0x16112(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x160f6(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %rbp
movq 0x160fa(%rip), %rsi     # 0x1b158
movq %r14, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
leaq 0xf310(%rip), %rax      # 0x14382
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x16309(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x30c, 0xc(%r14)       # imm = 0x30C
leaq 0x11a68(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x16089(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1339a
movq 0x1609a(%rip), %rsi     # 0x1b158
leaq 0x16233(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq 0x1606c(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %rbp, %rdx
callq 0x11b2c
movq %rax, %rbp
movq 0x16067(%rip), %r13     # 0x1b150
movq %r15, %rdi
callq 0x11685
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11b2c
movq %rax, %r13
leaq 0xf22f(%rip), %rdi      # 0x14338
callq 0xea73
movl $0x3, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x11b2c
leaq -0x434(%rip), %rsi      # 0x4cf1
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa232
movq %rax, %r13
movq 0x1601e(%rip), %rsi     # 0x1b158
leaq 0x161b7(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq 0x15ff0(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r13, %rdx
callq 0x11b2c
movq %rax, %r12
movq 0x15fe3(%rip), %r13     # 0x1b148
movq %r15, %rdi
callq 0x115e6
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11b2c
movq 0x15ffe(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa30f
movl $0x318, 0xc(%r14)       # imm = 0x318
movq %r14, %rdi
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_product
BEH_DECL(reduce_product)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);
	CONS* state;
	CONS* actor;

	DBUG_ENTER("reduce_product");
	state = NIL;
	state = map_put(state, env_symbol, env);
	state = map_put(state, cont_symbol, cont);
	state = map_put(state, form_symbol, cdr(expr));
	state = map_put(state, ATOM("acc"), NUMBER(1));
	actor = ACTOR(apply_product, state);
	msg = NIL;
	msg = map_put(msg, env_symbol, env);
	msg = map_put(msg, cont_symbol, actor);
	msg = map_put(msg, expr_symbol, car(expr));
	SEND(a_reduce, 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 0x11685
movq %rax, %r14
movq 0x15c55(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r15
movq 0x15c39(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %rbp
movq 0x15c3d(%rip), %rsi     # 0x1b158
movq %r14, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
leaq 0xee89(%rip), %rax      # 0x143b8
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x15e4c(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x34f, 0xc(%r14)       # imm = 0x34F
leaq 0x115ab(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x15bcc(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1339a
movq 0x15bdd(%rip), %rsi     # 0x1b158
leaq 0x15d76(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq 0x15baf(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %rbp, %rdx
callq 0x11b2c
movq %rax, %rbp
movq 0x15baa(%rip), %r13     # 0x1b150
movq %r15, %rdi
callq 0x11685
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11b2c
movq %rax, %r13
leaq 0xed72(%rip), %rdi      # 0x14338
callq 0xea73
movl $0x7, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x11b2c
leaq -0x436(%rip), %rsi      # 0x51ac
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa232
movq %rax, %r13
movq 0x15b61(%rip), %rsi     # 0x1b158
leaq 0x15cfa(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11b2c
movq 0x15b33(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r13, %rdx
callq 0x11b2c
movq %rax, %r12
movq 0x15b26(%rip), %r13     # 0x1b148
movq %r15, %rdi
callq 0x115e6
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11b2c
movq 0x15b41(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa30f
movl $0x35b, 0xc(%r14)       # imm = 0x35B
movq %r14, %rdi
callq 0x1351f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: template
BEH_DECL(template)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);
	CONS* state = MINE;
	CONS* vars = map_get(state, ATOM("vars"));
	CONS* body = map_get(state, ATOM("body"));

	DBUG_ENTER("template");
	expr = replace(body, map_def(NIL, vars, expr));		/* FIXME: check for binding to a single symbol, like eval_function */
	DBUG_PRINT("", ("expr=%s", cons_to_str(expr)));
	msg = NIL;
	msg = map_put(msg, env_symbol, env);
	msg = map_put(msg, cont_symbol, cont);
	msg = map_put(msg, expr_symbol, expr);
	SEND(a_reduce, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq %rax, %r15
movq 0x15abb(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x15a9f(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, 0x8(%rsp)
movq 0x15aa1(%rip), %rsi     # 0x1b158
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x115e6
movq %rax, %rdi
callq 0x96d9
movq %rax, %rbp
leaq 0xece7(%rip), %rdi      # 0x143c7
callq 0xea73
movq %rbp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r13
leaq 0xecd0(%rip), %rdi      # 0x143cc
callq 0xea73
movq %rbp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r14
leaq 0xecc0(%rip), %rax      # 0x143d8
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x15c61(%rip), %r15     # 0x1b388
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x36c, 0xc(%rdi)       # imm = 0x36C
leaq 0x113c2(%rip), %rbp     # 0x16b04
movq %rbp, 0x10(%rdi)
leaq 0x159e3(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x1339a
leaq 0x15b97(%rip), %rdi     # 0x1b2f8
movq %r13, %rsi
movq %r12, %rdx
callq 0x11c41
movq %r14, %rdi
movq %rax, %rsi
callq 0x1197c
movq %rax, %r12
leaq 0x161af(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x57c4
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x12afc
testl %eax, %eax
je 0x57c4
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x36e, 0xc(%rax)       # imm = 0x36E
movq %r12, %rdi
callq 0xb5b4
leaq 0xeddb(%rip), %rdi      # 0x14595
movq %rax, %rsi
xorl %eax, %eax
callq 0x1340b
movq 0x1598d(%rip), %rsi     # 0x1b158
leaq 0x15b26(%rip), %rdi     # 0x1b2f8
movq (%rsp), %rdx
callq 0x11b2c
movq 0x1595e(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq 0x8(%rsp), %rdx
callq 0x11b2c
movq 0x15952(%rip), %rsi     # 0x1b148
movq %rax, %rdi
movq %r12, %rdx
callq 0x11b2c
movq 0x15978(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa30f
leaq 0x10(%rsp), %rdi
movl $0x374, 0xc(%rdi)       # imm = 0x374
callq 0x1351f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_template
BEH_DECL(reduce_template)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
/*	CONS* env = map_get(msg, env_symbol); */
	CONS* state;
	CONS* actor;

	DBUG_ENTER("reduce_template");
	state = NIL;
	state = map_put(state, ATOM("body"), car(cdr(expr)));
	state = map_put(state, ATOM("vars"), car(expr));
	actor = ACTOR(template, state);
	msg = NIL;
	msg = map_put(msg, expr_symbol, actor);
	SEND(cont, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq %rax, %r14
movq 0x158f1(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x158d5(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, 0x8(%rsp)
leaq 0xeb50(%rip), %rax      # 0x143d1
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x15af8(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x384, 0xc(%r14)       # imm = 0x384
leaq 0x11257(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x15878(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x1339a
leaq 0xeafd(%rip), %rdi      # 0x143cc
callq 0xea73
movq %rax, %rbp
movq %r12, %rdi
callq 0x11685
movq %rax, %rdi
callq 0x115e6
leaq 0x15a0a(%rip), %r13     # 0x1b2f8
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11b2c
movq %rax, %rbp
leaq 0xeac1(%rip), %rdi      # 0x143c7
callq 0xea73
movq %rax, %r15
movq %r12, %rdi
callq 0x115e6
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x11b2c
leaq -0x2c2(%rip), %rsi      # 0x5669
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa232
movq 0x1580b(%rip), %rsi     # 0x1b148
movq %r13, %rdi
movq %rax, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xa30f
movl $0x38c, 0xc(%r14)       # imm = 0x38C
movq %r14, %rdi
callq 0x1351f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_function
BEH_DECL(reduce_function)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);
	CONS* state;
	CONS* actor;

	DBUG_ENTER("reduce_function");
	state = NIL;
	state = map_put(state, env_symbol, env);
	state = map_put(state, ATOM("body"), car(cdr(expr)));
	state = map_put(state, ATOM("vars"), car(expr));
	actor = ACTOR(function, state);
	SEND(cont, map_put(NIL, expr_symbol, actor));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11685
movq %rax, %r15
movq 0x1532c(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %r12
movq 0x15310(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, 0x8(%rsp)
movq 0x15312(%rip), %rsi     # 0x1b158
movq %r15, %rdi
xorl %edx, %edx
callq 0x11aba
movq %rax, %rbp
leaq 0xe5a5(%rip), %rax      # 0x143ff
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x1551f(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl $0x3e1, 0xc(%r15)       # imm = 0x3E1
leaq 0x10c7e(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r15)
leaq 0x1529f(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x1339a
movq 0x152b0(%rip), %rsi     # 0x1b158
leaq 0x15449(%rip), %r13     # 0x1b2f8
movq %r13, %rdi
movq %rbp, %rdx
callq 0x11b2c
movq %rax, %rbp
leaq 0xe508(%rip), %rdi      # 0x143cc
callq 0xea73
movq %rax, %r14
movq %r12, %rdi
callq 0x11685
movq %rax, %rdi
callq 0x115e6
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x11b2c
movq %rax, %r14
leaq 0xe4d3(%rip), %rdi      # 0x143c7
callq 0xea73
movq %rax, %rbp
movq %r12, %rdi
callq 0x115e6
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11b2c
leaq -0x31c(%rip), %rsi      # 0x5bfd
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa232
movq 0x1521d(%rip), %rsi     # 0x1b148
movq %r13, %rdi
movq %rax, %rdx
callq 0x11b2c
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xa30f
movl $0x3e8, 0xc(%r15)       # imm = 0x3E8
movq %r15, %rdi
callq 0x1351f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq