LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x11655
movq 0x173b0(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq 0x17383(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0x10452(%rip), %rax     # 0x14223
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x175a8(%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 0x12d08(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x17329(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r15, %rdi
callq 0x115b6
cmpq 0x1719d(%rip), %rax     # 0x1afc0
leaq 0x17346(%rip), %rax     # 0x1b170
leaq 0x17347(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x17af1(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3e84
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12a94
testl %eax, %eax
je 0x3e84
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1c5, 0xc(%rax)       # imm = 0x1C5
movq %r15, %rdi
callq 0xb5ac
leaq 0x1034a(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x172bd(%rip), %rsi     # 0x1b148
leaq 0x17466(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa327
leaq 0x8(%rsp), %rdi
movl $0x1c7, 0xc(%rdi)       # imm = 0x1C7
callq 0x134a7
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq 0x17261(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq 0x17234(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0x1030f(%rip), %rax     # 0x1422f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17459(%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 0x12bb9(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x171da(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r15, %rdi
callq 0x115b6
notl %eax
testb $0x3, %al
leaq 0x171fa(%rip), %rax     # 0x1b170
leaq 0x171fb(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x179a5(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x3fd0
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12a94
testl %eax, %eax
je 0x3fd0
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1db, 0xc(%rax)       # imm = 0x1DB
movq %r15, %rdi
callq 0xb5ac
leaq 0x101fe(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x17171(%rip), %rsi     # 0x1b148
leaq 0x1731a(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa327
leaq 0x8(%rsp), %rdi
movl $0x1dd, 0xc(%rdi)       # imm = 0x1DD
callq 0x134a7
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq 0x17115(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq 0x170e8(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0x101d0(%rip), %rax     # 0x1423c
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1730d(%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 0x12a6d(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x1708e(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r15, %rdi
callq 0x115b6
cmpq $0x3, %rax
leaq 0x170ae(%rip), %rax     # 0x1b170
leaq 0x170af(%rip), %rcx     # 0x1b178
cmoveq %rax, %rcx
movq (%rcx), %r15
leaq 0x17859(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x411c
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12a94
testl %eax, %eax
je 0x411c
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x1f1, 0xc(%rax)       # imm = 0x1F1
movq %r15, %rdi
callq 0xb5ac
leaq 0x100b2(%rip), %rdi     # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x17025(%rip), %rsi     # 0x1b148
leaq 0x171ce(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa327
leaq 0x8(%rsp), %rdi
movl $0x1f3, 0xc(%rdi)       # imm = 0x1F3
callq 0x134a7
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq 0x16fc8(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq 0x16f9b(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0x1008e(%rip), %rax     # 0x14247
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x171c2(%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 0x12922(%rip), %r12     # 0x16b04
movq %r12, 0x10(%rdi)
leaq 0x16f43(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r15, %rdi
callq 0x115b6
movq %rax, %r13
movq %r15, %rdi
callq 0x11655
movq %rax, %rdi
callq 0x115b6
movq %r13, %rdi
movq %rax, %rsi
callq 0x11710
testq %rax, %rax
leaq 0x16f46(%rip), %rax     # 0x1b170
leaq 0x16f47(%rip), %rcx     # 0x1b178
cmovneq %rax, %rcx
movq (%rcx), %r15
leaq 0x176f1(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x4284
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12a94
testl %eax, %eax
je 0x4284
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x207, 0xc(%rax)       # imm = 0x207
movq %r15, %rdi
callq 0xb5ac
leaq 0xff4a(%rip), %rdi      # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x16ebd(%rip), %rsi     # 0x1b148
leaq 0x17066(%rip), %rdi     # 0x1b2f8
movq %r15, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa327
movq %rsp, %rdi
movl $0x209, 0xc(%rdi)       # imm = 0x209
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq 0x16e61(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq 0x16e34(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0xff33(%rip), %rax      # 0x14253
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1705b(%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 0x127bb(%rip), %r15     # 0x16b04
movq %r15, 0x10(%rdi)
leaq 0x16ddc(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r12, %rdi
callq 0x115b6
movq %rax, %r13
movq %r12, %rdi
callq 0x11655
movq %rax, %rdi
callq 0x115b6
movl %r13d, %ecx
notl %ecx
testb $0x3, %cl
jne 0x43b1
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x43b1
shrq $0x2, %r13
shrq $0x2, %rax
cmpl %eax, %r13d
leaq 0x16dcf(%rip), %rax     # 0x1b170
leaq 0x16dd0(%rip), %rcx     # 0x1b178
cmovlq %rax, %rcx
movq (%rcx), %r12
jmp 0x43d9
movq 0x16da8(%rip), %r12     # 0x1b160
leaq 0xfea2(%rip), %rdi      # 0x14261
callq 0xea8c
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa327
movq 0x16d8f(%rip), %r12     # 0x1b168
leaq 0x17550(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x4425
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12a94
testl %eax, %eax
je 0x4425
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x229, 0xc(%rax)       # imm = 0x229
movq %r12, %rdi
callq 0xb5ac
leaq 0xfda9(%rip), %rdi      # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x16d1c(%rip), %rsi     # 0x1b148
leaq 0x16ec5(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa327
movq %rsp, %rdi
movl $0x22b, 0xc(%rdi)       # imm = 0x22B
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq 0x168b0(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq %rax, %r15
leaq 0xfa0f(%rip), %rdi      # 0x142cf
callq 0xea8c
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x16864(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
leaq 0xf9e7(%rip), %rax      # 0x142d7
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x16a8b(%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 0x121eb(%rip), %r13     # 0x16b04
movq %r13, 0x10(%rdi)
leaq 0x1680c(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r12, %rdi
callq 0x115b6
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x49e9
movq %r12, %rdi
movq %r14, %rsi
callq 0x11702
leaq 0x16fd9(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x499c
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12a94
testl %eax, %eax
je 0x499c
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x288, 0xc(%rax)       # imm = 0x288
movq %r14, %rdi
callq 0xb5ac
leaq 0xf832(%rip), %rdi      # 0x141c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x167a5(%rip), %r14     # 0x1b148
movq %r12, %rdi
callq 0x115b6
leaq 0x16946(%rip), %rdi     # 0x1b2f8
movq %r14, %rsi
movq %rax, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa327
movq %rsp, %rdi
movl $0x28a, 0xc(%rdi)       # imm = 0x28A
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf8f4(%rip), %rdi      # 0x142e4
leaq 0xf636(%rip), %rsi      # 0x1402d
leaq 0xf8fa(%rip), %rcx      # 0x142f8
movl $0x286, %edx            # imm = 0x286
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0x11655
movq %rax, %r14
movq 0x160be(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
movq 0x160a2(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %rbp
movq 0x160a6(%rip), %rsi     # 0x1b158
movq %r14, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
leaq 0xf2bc(%rip), %rax      # 0x14382
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x162b5(%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 0x11a14(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x16035(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x13322
movq 0x16046(%rip), %rsi     # 0x1b158
leaq 0x161df(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11afc
movq 0x16018(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %rbp, %rdx
callq 0x11afc
movq %rax, %rbp
movq 0x16013(%rip), %r13     # 0x1b150
movq %r15, %rdi
callq 0x11655
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11afc
movq %rax, %r13
leaq 0xf1db(%rip), %rdi      # 0x14338
callq 0xea8c
movl $0x3, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x11afc
leaq -0x434(%rip), %rsi      # 0x4d45
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa24a
movq %rax, %r13
movq 0x15fca(%rip), %rsi     # 0x1b158
leaq 0x16163(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11afc
movq 0x15f9c(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r13, %rdx
callq 0x11afc
movq %rax, %r12
movq 0x15f8f(%rip), %r13     # 0x1b148
movq %r15, %rdi
callq 0x115b6
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11afc
movq 0x15faa(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa327
movl $0x318, 0xc(%r14)       # imm = 0x318
movq %r14, %rdi
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq %rax, %r14
movq 0x15c01(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
movq 0x15be5(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %rbp
movq 0x15be9(%rip), %rsi     # 0x1b158
movq %r14, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
leaq 0xee35(%rip), %rax      # 0x143b8
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x15df8(%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 0x11557(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x15b78(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x13322
movq 0x15b89(%rip), %rsi     # 0x1b158
leaq 0x15d22(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11afc
movq 0x15b5b(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %rbp, %rdx
callq 0x11afc
movq %rax, %rbp
movq 0x15b56(%rip), %r13     # 0x1b150
movq %r15, %rdi
callq 0x11655
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11afc
movq %rax, %r13
leaq 0xed1e(%rip), %rdi      # 0x14338
callq 0xea8c
movl $0x7, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x11afc
leaq -0x436(%rip), %rsi      # 0x5200
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa24a
movq %rax, %r13
movq 0x15b0d(%rip), %rsi     # 0x1b158
leaq 0x15ca6(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11afc
movq 0x15adf(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq %r13, %rdx
callq 0x11afc
movq %rax, %r12
movq 0x15ad2(%rip), %r13     # 0x1b148
movq %r15, %rdi
callq 0x115b6
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x11afc
movq 0x15aed(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa327
movl $0x35b, 0xc(%r14)       # imm = 0x35B
movq %r14, %rdi
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq %rax, %r15
movq 0x15a67(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x15a4b(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, 0x8(%rsp)
movq 0x15a4d(%rip), %rsi     # 0x1b158
movq %r15, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq %rax, %rbp
leaq 0xec93(%rip), %rdi      # 0x143c7
callq 0xea8c
movq %rbp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r13
leaq 0xec7c(%rip), %rdi      # 0x143cc
callq 0xea8c
movq %rbp, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0xec6c(%rip), %rax      # 0x143d8
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x15c0d(%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 0x1136e(%rip), %rbp     # 0x16b04
movq %rbp, 0x10(%rdi)
leaq 0x1598f(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
leaq 0x15b43(%rip), %rdi     # 0x1b2f8
movq %r13, %rsi
movq %r12, %rdx
callq 0x11c11
movq %r14, %rdi
movq %rax, %rsi
callq 0x1194c
movq %rax, %r12
leaq 0x1615b(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x5818
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x12a94
testl %eax, %eax
je 0x5818
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x36e, 0xc(%rax)       # imm = 0x36E
movq %r12, %rdi
callq 0xb5ac
leaq 0xed87(%rip), %rdi      # 0x14595
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq 0x15939(%rip), %rsi     # 0x1b158
leaq 0x15ad2(%rip), %rdi     # 0x1b2f8
movq (%rsp), %rdx
callq 0x11afc
movq 0x1590a(%rip), %rsi     # 0x1b140
movq %rax, %rdi
movq 0x8(%rsp), %rdx
callq 0x11afc
movq 0x158fe(%rip), %rsi     # 0x1b148
movq %rax, %rdi
movq %r12, %rdx
callq 0x11afc
movq 0x15924(%rip), %rsi     # 0x1b180
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa327
leaq 0x10(%rsp), %rdi
movl $0x374, 0xc(%rdi)       # imm = 0x374
callq 0x134a7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq %rax, %r14
movq 0x1589d(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x15881(%rip), %rsi     # 0x1b140
movq %r14, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, 0x8(%rsp)
leaq 0xeafc(%rip), %rax      # 0x143d1
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x15aa4(%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 0x11203(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x15824(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x13322
leaq 0xeaa9(%rip), %rdi      # 0x143cc
callq 0xea8c
movq %rax, %rbp
movq %r12, %rdi
callq 0x11655
movq %rax, %rdi
callq 0x115b6
leaq 0x159b6(%rip), %r13     # 0x1b2f8
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11afc
movq %rax, %rbp
leaq 0xea6d(%rip), %rdi      # 0x143c7
callq 0xea8c
movq %rax, %r15
movq %r12, %rdi
callq 0x115b6
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x11afc
leaq -0x2c2(%rip), %rsi      # 0x56bd
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa24a
movq 0x157b7(%rip), %rsi     # 0x1b148
movq %r13, %rdi
movq %rax, %rdx
callq 0x11afc
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xa327
movl $0x38c, 0xc(%r14)       # imm = 0x38C
movq %r14, %rdi
callq 0x134a7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq %rax, %r15
movq 0x152dc(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x152c0(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, 0x8(%rsp)
movq 0x152c2(%rip), %rsi     # 0x1b158
movq %r15, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %rbp
leaq 0xe555(%rip), %rax      # 0x143ff
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x154cf(%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 0x10c2e(%rip), %rcx     # 0x16b04
movq %rcx, 0x10(%r15)
leaq 0x1524f(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x13322
movq 0x15260(%rip), %rsi     # 0x1b158
leaq 0x153f9(%rip), %r13     # 0x1b2f8
movq %r13, %rdi
movq %rbp, %rdx
callq 0x11afc
movq %rax, %rbp
leaq 0xe4b8(%rip), %rdi      # 0x143cc
callq 0xea8c
movq %rax, %r14
movq %r12, %rdi
callq 0x11655
movq %rax, %rdi
callq 0x115b6
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x11afc
movq %rax, %r14
leaq 0xe483(%rip), %rdi      # 0x143c7
callq 0xea8c
movq %rax, %rbp
movq %r12, %rdi
callq 0x115b6
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x11afc
leaq -0x31c(%rip), %rsi      # 0x5c4d
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa24a
movq 0x151cd(%rip), %rsi     # 0x1b148
movq %r13, %rdi
movq %rax, %rdx
callq 0x11afc
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xa327
movl $0x3e8, 0xc(%r15)       # imm = 0x3E8
movq %r15, %rdi
callq 0x134a7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq 0x15172(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq 0x15145(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
leaq 0xe400(%rip), %rax      # 0x1440f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1536c(%rip), %rbp     # 0x1b388
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3fc, 0xc(%rdi)       # imm = 0x3FC
leaq 0x10acc(%rip), %r13     # 0x16b04
movq %r13, 0x10(%rdi)
leaq 0x150ed(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movq %r12, %rdi
callq 0x115b6
movq %rax, %r15
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x6122
leaq 0x158c2(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x60b3
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12a94
testl %eax, %eax
je 0x60b3
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x3ff, 0xc(%rax)       # imm = 0x3FF
movq %r15, %rdi
callq 0xb5ac
leaq 0xe370(%rip), %rdi      # 0x14419
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq %r12, %rdi
callq 0x11655
movq %rax, %rdi
callq 0x115b6
movq %rax, %r12
leaq 0x15863(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x6112
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12a94
testl %eax, %eax
je 0x6112
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x401, 0xc(%rax)       # imm = 0x401
movq %r12, %rdi
callq 0xb5ac
leaq 0xe31a(%rip), %rdi      # 0x14422
movq %rax, %rsi
xorl %eax, %eax
callq 0x13393
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa327
jmp 0x614a
movq 0x15037(%rip), %r15     # 0x1b160
leaq 0xe2f9(%rip), %rdi      # 0x14429
callq 0xea8c
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa327
movq 0x1501e(%rip), %r12     # 0x1b168
movq 0x14ff7(%rip), %rsi     # 0x1b148
leaq 0x151a0(%rip), %rdi     # 0x1b2f8
movq %r12, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa327
movq %rsp, %rdi
movl $0x409, 0xc(%rdi)       # imm = 0x409
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dalnefre[P]kernel_abe/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 0x11655
movq %rax, %r15
movq 0x1451f(%rip), %rsi     # 0x1b140
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
leaq 0xd8a7(%rip), %rax      # 0x144dc
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x14746(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%r14)
movl $0x4b7, 0xc(%r14)       # imm = 0x4B7
leaq 0xfea5(%rip), %rcx      # 0x16b04
movq %rcx, 0x10(%r14)
leaq 0x144c6(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x13322
movq 0x144c7(%rip), %rsi     # 0x1b148
leaq 0x14670(%rip), %rdi     # 0x1b2f8
movq %rdi, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa327
movq 0x1449b(%rip), %rsi     # 0x1b140
movq 0x144ec(%rip), %rdx     # 0x1b198
movq %r15, %rdi
callq 0x11afc
movq 0x144d5(%rip), %rsi     # 0x1b190
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa327
movl $0x4bb, 0xc(%r14)       # imm = 0x4BB
movq %r14, %rdi
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11655
movq 0x13b2e(%rip), %rsi     # 0x1b148
movq %rax, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x115b6
movq %rax, %rdi
callq 0x9721
movq %rax, %r15
leaq 0xcec1(%rip), %rdi      # 0x14503
callq 0xea8c
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r12
movq 0x13ae2(%rip), %rsi     # 0x1b140
movq %r15, %rdi
xorl %edx, %edx
callq 0x11a8a
movq %rax, %r15
leaq 0xceed(%rip), %rax      # 0x1455f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x13d09(%rip), %rbp     # 0x1b388
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x54f, 0xc(%rdi)       # imm = 0x54F
leaq 0xf469(%rip), %r13      # 0x16b04
movq %r13, 0x10(%rdi)
leaq 0x13a8a(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
movl %r12d, %eax
notl %eax
testb $0x3, %al
jne 0x77ac
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x77cb
leaq 0x1425a(%rip), %rax     # 0x1b930
cmpl $0x0, (%rax)
je 0x7725
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12a94
testl %eax, %eax
je 0x7725
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x552, 0xc(%rax)       # imm = 0x552
movq %r12, %r13
shrq $0x2, %r13
movq %r14, %rdi
callq 0xb5ac
leaq 0xce78(%rip), %rdi      # 0x14590
movl %r13d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x13393
leaq 0xcb18(%rip), %rdi      # 0x14244
callq 0xea8c
movq %rax, %r13
leaq 0xcdc8(%rip), %rbp      # 0x14503
movq %rbp, %rdi
callq 0xea8c
leaq 0x13bae(%rip), %rdi     # 0x1b2f8
movq %r13, %rsi
movq %rax, %rdx
callq 0x11afc
movq %rax, %r13
movq %rbp, %rdi
callq 0xea8c
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x11afc
movq 0x139d3(%rip), %rsi     # 0x1b148
movq %rax, %rdi
movq %r14, %rdx
callq 0x11afc
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa327
movq %rsp, %rdi
movl $0x558, 0xc(%rdi)       # imm = 0x558
callq 0x134a7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcd5e(%rip), %rdi      # 0x14511
leaq 0xc873(%rip), %rsi      # 0x1402d
leaq 0xcda7(%rip), %rcx      # 0x14568
movl $0x550, %edx            # imm = 0x550
callq 0x2100
leaq 0xcdae(%rip), %rdi      # 0x14580
leaq 0xc854(%rip), %rsi      # 0x1402d
leaq 0xcd88(%rip), %rcx      # 0x14568
movl $0x551, %edx            # imm = 0x551
callq 0x2100
// File: /workspace/github_c_makefile_star2_O1/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 0xcfbd
movq %rax, %r15
leaq 0xc724(%rip), %rdi      # 0x14f1e
callq 0xea8c
leaq 0x12af2(%rip), %rdi     # 0x1b2f8
movq %rax, %rsi
movq %r15, %rdx
callq 0x11afc
movq 0x12bc0(%rip), %rdi     # 0x1b3d8
leaq 0xff8(%rip), %rsi       # 0x9817
movq %rax, %rdx
callq 0xa24a
testq %r15, %r15
je 0x8849
movq 0x12ba5(%rip), %rdi     # 0x1b3d8
movq %r14, %rsi
movq %rax, %rdx
callq 0x7f5d
testq %rax, %rax
je 0x8849
popq %rbx
popq %r14
popq %r15
retq
movq 0x127a8(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0xc6cb(%rip), %rsi      # 0x14f25
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2170
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0xc2f0(%rip), %rax      # 0x14f46
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x12723(%rip), %rax     # 0x1b388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x66b, 0xc(%rdi)       # imm = 0x66B
leaq 0xde84(%rip), %rcx      # 0x16b04
movq %rcx, 0x10(%rdi)
leaq 0x124a5(%rip), %rcx     # 0x1b130
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x13322
callq 0x8cff
movq %rax, %r15
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x8cb2
movq 0x124e6(%rip), %r14     # 0x1b198
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x2140
testq %rax, %rax
je 0x8cdf
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7f5d
testq %rax, %rax
jne 0x8cb7
leaq 0x8(%rsp), %rdi
movl $0x675, 0xc(%rdi)       # imm = 0x675
callq 0x134a7
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebp
movq 0x15df1(%rip), %rax     # 0x16fd0
movq (%rax), %rbx
cmpl $0x2, %edi
jl 0x11fc
movq 0x8(%r15), %rdi
leaq 0x1e12(%rip), %rsi      # 0x3004
callq 0x1080
movq %rax, %r14
jmp 0x1206
movq 0x15dd5(%rip), %rax     # 0x16fd8
movq (%rax), %r14
cmpl $0x3, %ebp
jl 0x121e
movq 0x10(%r15), %rdi
leaq 0x1df1(%rip), %rsi      # 0x3007
callq 0x1080
movq %rax, %rbx
movq %r14, %rdi
callq 0x2728
movl %eax, %ebp
cmpl $-0x2, %eax
je 0x1246
cmpl $-0x1, %ebp
je 0x1250
movl %ebp, %edi
callq 0x1acc
movzwl %ax, %edi
movq %rbx, %rsi
callq 0x1467
jmp 0x121e
movq %r14, %rdi
callq 0x10b0
jmp 0x1232
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
leaq 0xe20(%rip), %rdi       # 0x203a
callq 0x1040
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movslq %eax, %rbx
imulq $0x10624dd3, %rbx, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %ebx
cmpl $0x0, 0x2e47(%rip)      # 0x40a0
jne 0x1262
callq 0x1070
jmp 0x1252
testl %ebx, %ebx
je 0x1270
movslq %ebx, %rax
pause
decq %rax
jne 0x1269
movl $0x1, %r12d
movb $0x1, %r13b
leaq 0x2e30(%rip), %r14      # 0x40b0
xorl %r15d, %r15d
xorl %ebx, %ebx
leal (%r12,%r15), %eax
movl %eax, (%r14)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x1634
movl %eax, %ebp
testl %eax, %eax
je 0x12a6
movq %r12, %r15
movl (%r14), %r12d
jmp 0x12b2
leaq 0xd96(%rip), %rdi       # 0x2043
callq 0x1040
testl %ebp, %ebp
je 0x12d4
cmpq $0x1312cff, %rbx        # imm = 0x1312CFF
leaq 0x1(%rbx), %rax
setb %r13b
addq $0x4, %r14
movq %rax, %rbx
cmpq $0x1312d00, %rax        # imm = 0x1312D00
jne 0x1285
movzbl %r13b, %eax
andl $0x1, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: consumer
int consumer(void *ctx)
{
	printf("consumer\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();
	
	/* Dequeue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		int fib = n1 + n2;
		int *pulled;
		
		while (!spsc_ub_queue_pull(q, (void **) &pulled)) {
			//printf("Queue empty: %d\n", temp);
			//return -1;
		}
		
		if (*pulled != fib) {
			printf("Pulled != fib\n");
			return -1;
		}		
		
		n1 = n2; n2 = fib;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xd51(%rip), %rdi       # 0x2055
callq 0x1040
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movslq %eax, %r14
imulq $0x10624dd3, %r14, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %r14d
cmpl $0x0, 0x2d5c(%rip)      # 0x40a0
jne 0x134d
callq 0x1070
jmp 0x133d
testl %r14d, %r14d
je 0x135c
movslq %r14d, %rax
pause
decq %rax
jne 0x1355
movl $0x1, %ecx
movb $0x1, 0x7(%rsp)
xorl %edx, %edx
leaq 0x10(%rsp), %r14
xorl %r15d, %r15d
movq %rcx, %rbp
movq %rdx, 0x8(%rsp)
leaq (%rcx,%rdx), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x166c
testl %eax, %eax
je 0x137c
movq 0x10(%rsp), %rax
movl (%rax), %r12d
cmpl %r13d, %r12d
jne 0x13a0
movq %rbp, %rdx
movslq %r13d, %rcx
jmp 0x13b4
leaq 0xcb7(%rip), %rdi       # 0x205e
callq 0x1040
movq %rbp, %rcx
movq 0x8(%rsp), %rdx
cmpl %r13d, %r12d
jne 0x13d4
cmpq $0x1312cff, %r15        # imm = 0x1312CFF
leaq 0x1(%r15), %rax
setb 0x7(%rsp)
movq %rax, %r15
cmpq $0x1312d00, %rax        # imm = 0x1312D00
jne 0x1370
movzbl 0x7(%rsp), %eax
andl $0x1, %eax
negl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: test_single_threaded
int test_single_threaded(struct spsc_ub_queue *q)
{
	int resp, resc;
	
	resp = producer(q);
	if (resp)
		printf("Enqueuing failed\n");
	
	resc = consumer(q);
	if (resc)
		printf("Consumer failed\n");
	
	if (resc || resp)
		printf("Single Thread Test Failed\n");
	else
		printf("Single Thread Test Complete\n");
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x1204
movl %eax, %ebx
testl %eax, %eax
je 0x140b
leaq 0xc66(%rip), %rdi       # 0x206c
callq 0x1040
movq %r14, %rdi
callq 0x12ec
movl %eax, %ebp
testl %eax, %eax
je 0x1425
leaq 0xc5d(%rip), %rdi       # 0x207d
callq 0x1040
orl %ebx, %ebp
leaq 0xc5f(%rip), %rax       # 0x208d
leaq 0xc74(%rip), %rdi       # 0x20a9
cmoveq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: test_multi_threaded
int test_multi_threaded(struct spsc_ub_queue *q)
{
	thrd_t thrp, thrc;
	int resp, resc;
	
	g_start = 0;
	
	thrd_create(&thrp, consumer, q);	/** @todo Why producer thread runs earlier? */
	thrd_create(&thrc, producer, q);
	
	sleep(1);

	uint64_t start_tsc_time, end_tsc_time;

	start_tsc_time = rdtscp();
	g_start = 1;

	thrd_join(thrp, &resp);
	thrd_join(thrc, &resc);
	
	end_tsc_time = rdtscp();

	if (resc || resp)
		printf("Queue Test failed\n");
	else
		printf("Two-thread Test Complete\n");

	printf("cycles/op for rdtsc %lu\n", (end_tsc_time - start_tsc_time)/N);
	
	if (q->_tail->_next != NULL)
		printf("slots in use? There is something wrong with the test\n");
	
	int ret = spsc_ub_queue_destroy(q);
	if (ret)
		printf("Failed to destroy queue: %d\n", ret);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, 0x2c41(%rip)      # 0x40a0
leaq -0x17a(%rip), %rdx      # 0x12ec
leaq 0x18(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x10c0
leaq -0x27b(%rip), %rdx      # 0x1204
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r14
movl $0x1, 0x2bef(%rip)      # 0x40a0
movq (%r15), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x10d0
movq (%r15), %r13
movq (%r12), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x10d0
orl (%r15), %r13d
leaq 0xbfd(%rip), %rax       # 0x20dc
leaq 0xbdd(%rip), %rdi       # 0x20c3
cmovneq %rax, %rdi
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r15
callq 0x1040
subq %r14, %r15
movabsq $-0x29406b2a1a85bd43, %rcx # imm = 0xD6BF94D5E57A42BD
movq %r15, %rax
mulq %rcx
shrq $0x18, %rdx
leaq 0xaeb(%rip), %rdi       # 0x2004
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1060
movq 0x48(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x153b
leaq 0xbb8(%rip), %rdi       # 0x20ee
callq 0x1040
movq %rbx, %rdi
callq 0x169a
testl %eax, %eax
je 0x1557
leaq 0xacf(%rip), %rdi       # 0x201d
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_init
int spsc_ub_queue_init(struct spsc_ub_queue* q, size_t size, const struct memtype *mem)
{
	q->mem = mem;
	struct node* n = memory_alloc(q->mem, sizeof(struct node) * size);
	n->_next = NULL;
	q->_tail = q->_head = q->_first= q->_tailcopy = n;
	
	/** Alloc memory at start for total size for efficiency */
	void *v = NULL;
	for(unsigned long i = 0; i < size; i++)		/** @todo fix this hack in bounded implementation */
		spsc_ub_queue_push(q, v);
	for(unsigned long i = 0; i < size; i++)
		spsc_ub_queue_pull(q, &v);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, (%rdi)
shlq $0x4, %rsi
movq %rdx, %rdi
callq 0x170c
xorl %ecx, %ecx
xchgq %rcx, (%rax)
movq %rax, 0x120(%r14)
movq %rax, 0xd8(%r14)
movq %rax, 0x90(%r14)
xchgq %rax, 0x48(%r14)
testq %rbx, %rbx
je 0x162c
movq %rbx, %r15
movq %r14, %rdi
callq 0x16ca
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq 0x90(%r14), %rcx
movq %rax, (%rcx)
movq %rax, 0x90(%r14)
decq %r15
jne 0x15dc
movq 0x48(%r14), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1627
movq 0x48(%r14), %rax
movq (%rax), %rax
movq 0x48(%r14), %rax
movq (%rax), %rax
movq %rax, 0x48(%r14)
decq %rbx
jne 0x1609
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_push
int spsc_ub_queue_push(struct spsc_ub_queue* q, void * v)
{
	struct node* n = spsc_ub_alloc_node(q);
	
	atomic_store_explicit(&(n->_next), NULL, memory_order_release);
	//n->_next = NULL;
	n->_value = v;
	
	//store_release(&(q->_head->_next), n);
	atomic_store_explicit(&(q->_head->_next), n, memory_order_release);
	
	q->_head = n;
	
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16ca
movq $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq 0x90(%r14), %rcx
movq %rax, (%rcx)
movq %rax, 0x90(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq