LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x10e46
movq 0x16c13(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x16be6(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xfc6f(%rip), %rax      # 0x131ed
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x16e0b(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x179, 0xc(%rdi)       # imm = 0x179
leaq 0x1253b(%rip), %r15     # 0x15ae4
movq %r15, 0x10(%rdi)
leaq 0x16b8c(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
testq %r12, %r12
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x35ef
movq %r12, %rdi
callq 0x10d3b
testq %rax, %rax
je 0x35ef
movq %r12, %rdi
callq 0x10d3b
testb $0x3, %al
je 0x36a6
movq 0x16b7a(%rip), %r12     # 0x1a170
leaq 0xfbfa(%rip), %rdi      # 0x131f7
callq 0xe45f
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x16b61(%rip), %r12     # 0x1a178
leaq 0x17322(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3663
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12334
testl %eax, %eax
je 0x3663
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x186, 0xc(%rax)       # imm = 0x186
movq %r12, %rdi
callq 0xb248
leaq 0xfb6b(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16aee(%rip), %rsi     # 0x1a158
leaq 0x16c97(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x188, 0xc(%rdi)       # imm = 0x188
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x10d3b
leaq 0x16c53(%rip), %r12     # 0x1a308
cmpq %r12, %rax
je 0x3617
movq %rax, %rdi
callq 0x10e46
movq %rax, %r12
jmp 0x3617
// File: /workspace/github_c_makefile_star2_O2/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 0x10e46
movq 0x16a69(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x16a3c(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xfae3(%rip), %rax      # 0x1320b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x16c63(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x197, 0xc(%rdi)       # imm = 0x197
leaq 0x12393(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x169e4(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
movq %rax, %r13
movq %r15, %rdi
callq 0x10e46
movq %rax, %rdi
callq 0x10d3b
movq %r13, %rdi
movq %rax, %rsi
callq 0x10ca4
movq %rax, %r15
leaq 0x171a7(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x37de
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x37de
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x199, 0xc(%rax)       # imm = 0x199
movq %r15, %rdi
callq 0xb248
leaq 0xf9f0(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16973(%rip), %rsi     # 0x1a158
leaq 0x16b1c(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x19b, 0xc(%rdi)       # imm = 0x19B
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x16918(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x168eb(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xf99f(%rip), %rax      # 0x13218
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x16b10(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1ad, 0xc(%rdi)       # imm = 0x1AD
leaq 0x12240(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x16891(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
testq %rax, %rax
je 0x38ea
movq %r15, %rdi
callq 0x10d3b
testb $0x3, %al
leaq 0x168a6(%rip), %rax     # 0x1a180
leaq 0x168a7(%rip), %rcx     # 0x1a188
cmoveq %rax, %rcx
movq (%rcx), %r15
jmp 0x38f1
movq 0x16897(%rip), %r15     # 0x1a188
leaq 0x17048(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x393d
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x393d
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1af, 0xc(%rax)       # imm = 0x1AF
movq %r15, %rdi
callq 0xb248
leaq 0xf891(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16814(%rip), %rsi     # 0x1a158
leaq 0x169bd(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x1b1, 0xc(%rdi)       # imm = 0x1B1
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x167b8(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x1678b(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xf84a(%rip), %rax      # 0x13223
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x169b0(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1c3, 0xc(%rdi)       # imm = 0x1C3
leaq 0x120e0(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x16731(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
cmpq 0x16595(%rip), %rax     # 0x19fc0
leaq 0x1674e(%rip), %rax     # 0x1a180
leaq 0x1674f(%rip), %rcx     # 0x1a188
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x16ef9(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3a8c
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x3a8c
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1c5, 0xc(%rax)       # imm = 0x1C5
movq %r15, %rdi
callq 0xb248
leaq 0xf742(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x166c5(%rip), %rsi     # 0x1a158
leaq 0x1686e(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x1c7, 0xc(%rdi)       # imm = 0x1C7
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x16669(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x1663c(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xf707(%rip), %rax      # 0x1322f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x16861(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1d9, 0xc(%rdi)       # imm = 0x1D9
leaq 0x11f91(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x165e2(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
notl %eax
testb $0x3, %al
leaq 0x16602(%rip), %rax     # 0x1a180
leaq 0x16603(%rip), %rcx     # 0x1a188
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x16dad(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3bd8
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x3bd8
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1db, 0xc(%rax)       # imm = 0x1DB
movq %r15, %rdi
callq 0xb248
leaq 0xf5f6(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16579(%rip), %rsi     # 0x1a158
leaq 0x16722(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x1dd, 0xc(%rdi)       # imm = 0x1DD
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x1651d(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x164f0(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xf5c8(%rip), %rax      # 0x1323c
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x16715(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1ef, 0xc(%rdi)       # imm = 0x1EF
leaq 0x11e45(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x16496(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
cmpq $0x3, %rax
leaq 0x164b6(%rip), %rax     # 0x1a180
leaq 0x164b7(%rip), %rcx     # 0x1a188
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x16c61(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3d24
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x3d24
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1f1, 0xc(%rax)       # imm = 0x1F1
movq %r15, %rdi
callq 0xb248
leaq 0xf4aa(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x1642d(%rip), %rsi     # 0x1a158
leaq 0x165d6(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x1f3, 0xc(%rdi)       # imm = 0x1F3
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x163d0(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x163a3(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xf486(%rip), %rax      # 0x13247
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x165ca(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x205, 0xc(%rdi)       # imm = 0x205
leaq 0x11cfa(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x1634b(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
movq %rax, %r13
movq %r15, %rdi
callq 0x10e46
movq %rax, %rdi
callq 0x10d3b
movq %r13, %rdi
movq %rax, %rsi
callq 0x10f6d
testq %rax, %rax
leaq 0x1634e(%rip), %rax     # 0x1a180
leaq 0x1634f(%rip), %rcx     # 0x1a188
cmovneq %rax, %rcx
movq (%rcx), %r15
leaq 0x16af9(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3e8c
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x3e8c
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x207, 0xc(%rax)       # imm = 0x207
movq %r15, %rdi
callq 0xb248
leaq 0xf342(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x162c5(%rip), %rsi     # 0x1a158
leaq 0x1646e(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x209, 0xc(%rdi)       # imm = 0x209
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x16269(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x1623c(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xf32b(%rip), %rax      # 0x13253
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x16463(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x220, 0xc(%rdi)       # imm = 0x220
leaq 0x11b93(%rip), %r15     # 0x15ae4
movq %r15, 0x10(%rdi)
leaq 0x161e4(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r12, %rdi
callq 0x10d3b
movq %rax, %r13
movq %r12, %rdi
callq 0x10e46
movq %rax, %rdi
callq 0x10d3b
movl %r13d, %ecx
notl %ecx
testb $0x3, %cl
jne 0x3fb9
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x3fb9
shrq $0x2, %r13
shrq $0x2, %rax
cmpl %eax, %r13d
leaq 0x161d7(%rip), %rax     # 0x1a180
leaq 0x161d8(%rip), %rcx     # 0x1a188
cmovlq %rax, %rcx
movq (%rcx), %r12
jmp 0x3fe1
movq 0x161b0(%rip), %r12     # 0x1a170
leaq 0xf29a(%rip), %rdi      # 0x13261
callq 0xe45f
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x16197(%rip), %r12     # 0x1a178
leaq 0x16958(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x402d
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12334
testl %eax, %eax
je 0x402d
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x229, 0xc(%rax)       # imm = 0x229
movq %r12, %rdi
callq 0xb248
leaq 0xf1a1(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16124(%rip), %rsi     # 0x1a158
leaq 0x162cd(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x22b, 0xc(%rdi)       # imm = 0x22B
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq 0x15cb8(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r15
leaq 0xee07(%rip), %rdi      # 0x132cf
callq 0xe45f
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x15c6c(%rip), %rsi     # 0x1a150
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
leaq 0xeddf(%rip), %rax      # 0x132d7
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x15e93(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x284, 0xc(%rdi)       # imm = 0x284
leaq 0x115c3(%rip), %r13     # 0x15ae4
movq %r13, 0x10(%rdi)
leaq 0x15c14(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r12, %rdi
callq 0x10d3b
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x45f1
movq %r12, %rdi
movq %r14, %rsi
callq 0x10f5f
leaq 0x163e1(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x45a4
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12334
testl %eax, %eax
je 0x45a4
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x288, 0xc(%rax)       # imm = 0x288
movq %r14, %rdi
callq 0xb248
leaq 0xec2a(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x15bad(%rip), %r14     # 0x1a158
movq %r12, %rdi
callq 0x10d3b
leaq 0x15d4e(%rip), %rdi     # 0x1a308
movq %r14, %rsi
movq %rax, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x28a, 0xc(%rdi)       # imm = 0x28A
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xecec(%rip), %rdi      # 0x132e4
leaq 0xea2e(%rip), %rsi      # 0x1302d
leaq 0xecf2(%rip), %rcx      # 0x132f8
movl $0x286, %edx            # imm = 0x286
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/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 0x10e46
movq %rax, %r14
movq 0x154d0(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x154b4(%rip), %rsi     # 0x1a150
movq %r14, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %rbp
movq 0x154b8(%rip), %rsi     # 0x1a168
movq %r14, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0xe6be(%rip), %rax      # 0x13382
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x156c7(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x30c, 0xc(%r14)       # imm = 0x30C
leaq 0x10df6(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%r14)
leaq 0x15447(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x12bb9
movq 0x15458(%rip), %rsi     # 0x1a168
leaq 0x155f1(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq 0x1542a(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %rbp, %rdx
callq 0x11339
movq %rax, %rbp
movq 0x15425(%rip), %r13     # 0x1a160
movq %r15, %rdi
callq 0x10e46
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11339
movq %rax, %r13
leaq 0xe5dd(%rip), %rdi      # 0x13338
callq 0xe45f
pushq $0x3
popq %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x11339
leaq -0x432(%rip), %rsi      # 0x4943
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9ef7
movq %rax, %r13
movq 0x153de(%rip), %rsi     # 0x1a168
leaq 0x15577(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq 0x153b0(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r13, %rdx
callq 0x11339
movq %rax, %r12
movq 0x153a3(%rip), %r13     # 0x1a158
movq %r15, %rdi
callq 0x10d3b
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11339
movq 0x153be(%rip), %rsi     # 0x1a190
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
movl $0x318, 0xc(%r14)       # imm = 0x318
movq %r14, %rdi
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq %rax, %r14
movq 0x15015(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x14ff9(%rip), %rsi     # 0x1a150
movq %r14, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %rbp
movq 0x14ffd(%rip), %rsi     # 0x1a168
movq %r14, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0xe239(%rip), %rax      # 0x133b8
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x1520c(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x34f, 0xc(%r14)       # imm = 0x34F
leaq 0x1093b(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%r14)
leaq 0x14f8c(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x12bb9
movq 0x14f9d(%rip), %rsi     # 0x1a168
leaq 0x15136(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq 0x14f6f(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %rbp, %rdx
callq 0x11339
movq %rax, %rbp
movq 0x14f6a(%rip), %r13     # 0x1a160
movq %r15, %rdi
callq 0x10e46
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11339
movq %rax, %r13
leaq 0xe122(%rip), %rdi      # 0x13338
callq 0xe45f
pushq $0x7
popq %rdx
movq %r13, %rdi
movq %rax, %rsi
callq 0x11339
leaq -0x434(%rip), %rsi      # 0x4dfc
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9ef7
movq %rax, %r13
movq 0x14f23(%rip), %rsi     # 0x1a168
leaq 0x150bc(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq 0x14ef5(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r13, %rdx
callq 0x11339
movq %rax, %r12
movq 0x14ee8(%rip), %r13     # 0x1a158
movq %r15, %rdi
callq 0x10d3b
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11339
movq 0x14f03(%rip), %rsi     # 0x1a190
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
movl $0x35b, 0xc(%r14)       # imm = 0x35B
movq %r14, %rdi
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq %rax, %r15
movq 0x14e7d(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x14e61(%rip), %rsi     # 0x1a150
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, 0x8(%rsp)
movq 0x14e63(%rip), %rsi     # 0x1a168
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %rbp
leaq 0xe099(%rip), %rdi      # 0x133c7
callq 0xe45f
movq %rbp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r13
leaq 0xe082(%rip), %rdi      # 0x133cc
callq 0xe45f
movq %rbp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xe072(%rip), %rax      # 0x133d8
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x15023(%rip), %r15     # 0x1a398
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x36c, 0xc(%rdi)       # imm = 0x36C
leaq 0x10754(%rip), %rbp     # 0x15ae4
movq %rbp, 0x10(%rdi)
leaq 0x14da5(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
leaq 0x14f59(%rip), %rdi     # 0x1a308
movq %r13, %rsi
movq %r12, %rdx
callq 0x11448
movq %r14, %rdi
movq %rax, %rsi
callq 0x11193
movq %rax, %r12
leaq 0x15571(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x5412
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x12334
testl %eax, %eax
je 0x5412
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x36e, 0xc(%rax)       # imm = 0x36E
movq %r12, %rdi
callq 0xb248
leaq 0xe18d(%rip), %rdi      # 0x13595
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x14d4f(%rip), %rsi     # 0x1a168
leaq 0x14ee8(%rip), %rdi     # 0x1a308
movq (%rsp), %rdx
callq 0x11339
movq 0x14d20(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq 0x8(%rsp), %rdx
callq 0x11339
movq 0x14d14(%rip), %rsi     # 0x1a158
movq %rax, %rdi
movq %r12, %rdx
callq 0x11339
movq 0x14d3a(%rip), %rsi     # 0x1a190
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
leaq 0x10(%rsp), %rdi
movl $0x374, 0xc(%rdi)       # imm = 0x374
callq 0x12d32
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq %rax, %r14
movq 0x14cb3(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x14c97(%rip), %rsi     # 0x1a150
movq %r14, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, 0x8(%rsp)
leaq 0xdf02(%rip), %rax      # 0x133d1
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x14eba(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x384, 0xc(%r14)       # imm = 0x384
leaq 0x105e9(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%r14)
leaq 0x14c3a(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x12bb9
leaq 0xdeaf(%rip), %rdi      # 0x133cc
callq 0xe45f
movq %rax, %rbp
movq %r12, %rdi
callq 0x10e46
movq %rax, %rdi
callq 0x10d3b
leaq 0x14dcc(%rip), %r13     # 0x1a308
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11339
movq %rax, %rbp
leaq 0xde73(%rip), %rdi      # 0x133c7
callq 0xe45f
movq %rax, %r15
movq %r12, %rdi
callq 0x10d3b
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x11339
leaq -0x2c2(%rip), %rsi      # 0x52b7
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9ef7
movq 0x14bcd(%rip), %rsi     # 0x1a158
movq %r13, %rdi
movq %rax, %rdx
callq 0x11339
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x9fd4
movl $0x38c, 0xc(%r14)       # imm = 0x38C
movq %r14, %rdi
callq 0x12d32
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/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 0x10e46
movq %rax, %r15
movq 0x146ee(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x146d2(%rip), %rsi     # 0x1a150
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, 0x8(%rsp)
movq 0x146d4(%rip), %rsi     # 0x1a168
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %rbp
leaq 0xd957(%rip), %rax      # 0x133ff
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x148e1(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r15)
movl $0x3e1, 0xc(%r15)       # imm = 0x3E1
leaq 0x10010(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%r15)
leaq 0x14661(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x12bb9
movq 0x14672(%rip), %rsi     # 0x1a168
leaq 0x1480b(%rip), %r13     # 0x1a308
movq %r13, %rdi
movq %rbp, %rdx
callq 0x11339
movq %rax, %rbp
leaq 0xd8ba(%rip), %rdi      # 0x133cc
callq 0xe45f
movq %rax, %r14
movq %r12, %rdi
callq 0x10e46
movq %rax, %rdi
callq 0x10d3b
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x11339
movq %rax, %r14
leaq 0xd885(%rip), %rdi      # 0x133c7
callq 0xe45f
movq %rax, %rbp
movq %r12, %rdi
callq 0x10d3b
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11339
leaq -0x31c(%rip), %rsi      # 0x584b
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9ef7
movq 0x145df(%rip), %rsi     # 0x1a158
movq %r13, %rdi
movq %rax, %rdx
callq 0x11339
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x9fd4
movl $0x3e8, 0xc(%r15)       # imm = 0x3E8
movq %r15, %rdi
callq 0x12d32
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: eval_send
BEH_DECL(eval_send)
{
	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* actor;

	DBUG_ENTER("eval_send");
	actor = car(expr);
	if (actorp(actor)) {
		DBUG_PRINT("", ("actor=%s", cons_to_str(actor)));
		expr = car(cdr(expr));
		DBUG_PRINT("", ("msg=%s", cons_to_str(expr)));
		SEND(actor, expr);
		/* FIXME: should send return NIL, rather than the message sent? */
	} else {	/* error */
		SEND(an_error, ATOM("send: actor required"));
		expr = undefined_symbol;
	}
	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 0x10e46
movq 0x14584(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x14557(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xd802(%rip), %rax      # 0x1340f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1477e(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3fc, 0xc(%rdi)       # imm = 0x3FC
leaq 0xfeae(%rip), %r13      # 0x15ae4
movq %r13, 0x10(%rdi)
leaq 0x144ff(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r12, %rdi
callq 0x10d3b
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x5d20
leaq 0x14cd4(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x5cb1
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12334
testl %eax, %eax
je 0x5cb1
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x3ff, 0xc(%rax)       # imm = 0x3FF
movq %r15, %rdi
callq 0xb248
leaq 0xd772(%rip), %rdi      # 0x13419
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq %r12, %rdi
callq 0x10e46
movq %rax, %rdi
callq 0x10d3b
movq %rax, %r12
leaq 0x14c75(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x5d10
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12334
testl %eax, %eax
je 0x5d10
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x401, 0xc(%rax)       # imm = 0x401
movq %r12, %rdi
callq 0xb248
leaq 0xd71c(%rip), %rdi      # 0x13422
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9fd4
jmp 0x5d48
movq 0x14449(%rip), %r15     # 0x1a170
leaq 0xd6fb(%rip), %rdi      # 0x13429
callq 0xe45f
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x14430(%rip), %r12     # 0x1a178
movq 0x14409(%rip), %rsi     # 0x1a158
leaq 0x145b2(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x409, 0xc(%rdi)       # imm = 0x409
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_background
BEH_DECL(reduce_background)
{
	CONS* msg = WHAT;
	CONS* cont = map_get(msg, cont_symbol);

	DBUG_ENTER("reduce_background");
	SEND(cont, map_put(NIL, expr_symbol, NIL));
	msg = map_put(msg, cont_symbol, a_sink);		/* add to inbound message */
	SEND(a_reduce_args, msg);		/* FIXME: use parallel evaluation, rather than sequential, when available */
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq %rax, %r15
movq 0x13940(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0xccb8(%rip), %rax      # 0x134dc
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x13b67(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x4b7, 0xc(%r14)       # imm = 0x4B7
leaq 0xf296(%rip), %rcx      # 0x15ae4
movq %rcx, 0x10(%r14)
leaq 0x138e7(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x12bb9
movq 0x138e8(%rip), %rsi     # 0x1a158
leaq 0x13a91(%rip), %rdi     # 0x1a308
movq %rdi, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x138bc(%rip), %rsi     # 0x1a150
movq 0x1390d(%rip), %rdx     # 0x1a1a8
movq %r15, %rdi
callq 0x11339
movq 0x138f6(%rip), %rsi     # 0x1a1a0
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
movl $0x4bb, 0xc(%r14)       # imm = 0x4BB
movq %r14, %rdi
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: eval_par
BEH_DECL(eval_par)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* i = map_get(state, ATOM("i"));
	CONS* collect = map_get(state, cont_symbol);

	DBUG_ENTER("eval_par");
	assert(numberp(i));
	assert(actorp(collect));
	DBUG_PRINT("", ("i=%d expr=%s", MK_INT(i), cons_to_str(expr)));
	msg = NIL;
	msg = map_put(msg, ATOM("op"), ATOM("i"));
	msg = map_put(msg, ATOM("i"), i);
	msg = map_put(msg, expr_symbol, expr);
	SEND(collect, 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 0x10e46
movq 0x12f4f(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r15
leaq 0xc2d2(%rip), %rdi      # 0x13503
callq 0xe45f
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x12f03(%rip), %rsi     # 0x1a150
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
leaq 0xc2fe(%rip), %rax      # 0x1355f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1312a(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x54f, 0xc(%rdi)       # imm = 0x54F
leaq 0xe85a(%rip), %r13      # 0x15ae4
movq %r13, 0x10(%rdi)
leaq 0x12eab(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movl %r12d, %eax
notl %eax
testb $0x3, %al
jne 0x739b
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x73ba
leaq 0x1367b(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x7314
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12334
testl %eax, %eax
je 0x7314
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x552, 0xc(%rax)       # imm = 0x552
movq %r12, %r13
shrq $0x2, %r13
movq %r14, %rdi
callq 0xb248
leaq 0xc289(%rip), %rdi      # 0x13590
movl %r13d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x12c30
leaq 0xbf29(%rip), %rdi      # 0x13244
callq 0xe45f
movq %rax, %r13
leaq 0xc1d9(%rip), %rbp      # 0x13503
movq %rbp, %rdi
callq 0xe45f
leaq 0x12fcf(%rip), %rdi     # 0x1a308
movq %r13, %rsi
movq %rax, %rdx
callq 0x11339
movq %rax, %r13
movq %rbp, %rdi
callq 0xe45f
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x11339
movq 0x12df4(%rip), %rsi     # 0x1a158
movq %rax, %rdi
movq %r14, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x558, 0xc(%rdi)       # imm = 0x558
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc16f(%rip), %rdi      # 0x13511
leaq 0xbc84(%rip), %rsi      # 0x1302d
leaq 0xc1b8(%rip), %rcx      # 0x13568
movl $0x550, %edx            # imm = 0x550
callq 0x2100
leaq 0xc1bf(%rip), %rdi      # 0x13580
leaq 0xbc65(%rip), %rsi      # 0x1302d
leaq 0xc199(%rip), %rcx      # 0x13568
movl $0x551, %edx            # imm = 0x551
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: assert_reduce
static void
assert_reduce(char* expr, char* value)
{
	CONS* expect;
	CONS* state;
	CONS* cont;
	
	expect = str_to_cons(value);
	state = map_put(NIL, ATOM("expect"), expect);
	cont = CFG_ACTOR(reduce_cfg, assert_msg, state);
	if (!expect || !reduce_line(reduce_cfg, expr, cont)) {
		fprintf(stderr, "assert_reduce: FAILED! %s -> %s\n", expr, value);
		abort();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xca42
movq %rax, %r15
leaq 0xbb37(%rip), %rdi      # 0x13f1e
callq 0xe45f
leaq 0x11f15(%rip), %rdi     # 0x1a308
movq %rax, %rsi
movq %r15, %rdx
callq 0x11339
movq 0x11fe3(%rip), %rdi     # 0x1a3e8
leaq 0x1064(%rip), %rsi      # 0x9470
movq %rax, %rdx
callq 0x9ef7
testq %r15, %r15
je 0x8436
movq 0x11fc8(%rip), %rdi     # 0x1a3e8
movq %r14, %rsi
movq %rax, %rdx
callq 0x7b4c
testq %rax, %rax
je 0x8436
popq %rbx
popq %r14
popq %r15
retq
movq 0x11bbb(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbade(%rip), %rsi      # 0x13f25
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2170
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: read_reduce_print
static void
read_reduce_print(FILE* in, CONS* out)
{
	char buf[1024];
	CONFIG* cfg;
	
	DBUG_ENTER("read_reduce_print");
	cfg = init_reduce();
	if ((out == NULL) || !actorp(out)) {
		out = a_sink;
	}
	while (fgets(buf, sizeof(buf), in)) {
		if (!reduce_line(cfg, buf, out)) {
			break;
		}
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb773(%rip), %rax      # 0x13f46
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x11bb6(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x66b, 0xc(%rdi)       # imm = 0x66B
leaq 0xd2e7(%rip), %rcx      # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x11938(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
callq 0x887c
movq %rax, %r15
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x882f
movq 0x11979(%rip), %r14     # 0x1a1a8
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x2140
testq %rax, %rax
je 0x885c
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7b4c
testq %rax, %rax
jne 0x8834
leaq 0x8(%rsp), %rdi
movl $0x675, 0xc(%rdi)       # imm = 0x675
callq 0x12d32
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/vampirefrog[P]x68ksjis/utf82sjis.c
// Function: main
int main(int argc, char **argv) {
	FILE *in = stdin, *out = stdout;
	if(argc > 1) in = fopen(argv[1], "rb");
	if(argc > 2) out = fopen(argv[2], "wb");

	int b;
	while((b = utf8_fgetc(in)) != EOF) {
		if(b == -2) fprintf(stderr, "Invalid char found at %d\n", ftell(in));
		sjis_fputc(unicode_char_to_sjis(b), out);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x15e22(%rip), %rax     # 0x16fd0
movq (%rax), %rbx
cmpl $0x2, %edi
jl 0x11e8
movq %rsi, %r15
movl %edi, %ebp
movq 0x8(%rsi), %rdi
leaq 0x1e3e(%rip), %rsi      # 0x3004
callq 0x1080
movq %rax, %r14
cmpl $0x2, %ebp
je 0x11f2
movq 0x10(%r15), %rdi
leaq 0x1e29(%rip), %rsi      # 0x3007
callq 0x1080
movq %rax, %rbx
jmp 0x11f2
movq 0x15de9(%rip), %rax     # 0x16fd8
movq (%rax), %r14
movq 0x15dff(%rip), %r13     # 0x16ff8
leaq 0x1e0a(%rip), %r15      # 0x300a
movq %r14, %rdi
callq 0x2636
movl %eax, %ebp
cmpl $-0x2, %eax
je 0x1228
cmpl $-0x1, %ebp
je 0x1246
movl %ebp, %edi
callq 0x19e9
movzwl %ax, %edi
movq %rbx, %rsi
callq 0x1431
jmp 0x1200
movq (%r13), %r12
movq %r14, %rdi
callq 0x1070
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x1214
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/kobolt[P]curses-collection/mastermind/mastermind.c
// Function: guess_is_correct
static int guess_is_correct()
{
  int i;
  for (i = 0; i < CODE_SLOTS; i++) {
    if (guess[current_guess].hint[i] != HINT_CODE_AND_POSITION)
      return 0;
  }
  return 1;
}

// Assembly:
movslq 0x2994(%rip), %rax      # 0x4210
shlq $0x5, %rax
leaq 0x2849(%rip), %rcx      # 0x40d0
addq %rax, %rcx
addq $0x10, %rcx
xorl %edx, %edx
pushq $0x1
popq %rax
cmpq $0x4, %rdx
je 0x18a5
cmpl $0x1, (%rcx,%rdx,4)
leaq 0x1(%rdx), %rdx
je 0x1893
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: producer
int producer(void *ctx)
{
	printf("producer\n"); //DELETEME
	struct spsc_ub_queue *q = (struct spsc_ub_queue *) ctx;
	
	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();
	
		/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();
	
	/* Enqueue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		fibs[count] = n1 + n2;
		
		void *fibptr = (void *) &fibs[count];
		
		if (!spsc_ub_queue_push(q, fibptr)) {
			printf("Queue push failed\n");
			return -1;
		}
			
		n1 = n2; n2 = fibs[count];
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe29(%rip), %rdi       # 0x203a
callq 0x1040
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2e65(%rip)      # 0x40a0
jne 0x1244
callq 0x1070
jmp 0x1234
movslq %ebp, %rax
subq $0x1, %rax
jb 0x1251
pause
jmp 0x1247
pushq $0x1
popq %rbp
xorl %r15d, %r15d
leaq 0x2e52(%rip), %r14      # 0x40b0
xorl %eax, %eax
cmpq $0x1312d00, %r15        # imm = 0x1312D00
je 0x1297
addl %ebp, %eax
movl %eax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15b9
testl %eax, %eax
je 0x128b
movl %ebp, %eax
movl (%r14), %ebp
incq %r15
addq $0x4, %r14
jmp 0x1260
leaq 0xdb1(%rip), %rdi       # 0x2043
callq 0x1040
xorl %eax, %eax
cmpq $0x1312d00, %r15        # imm = 0x1312D00
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq