LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1bf30(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16800
movq %rax, %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x1bef7(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x28(%rbp)
leaq 0x15fc6(%rip), %rax     # 0x1a223
movq %rax, -0x50(%rbp)
leaq 0x1c120(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x1c3, -0x44(%rbp)     # imm = 0x1C3
leaq 0x18a2d(%rip), %rax     # 0x1ccb0
movq %rax, -0x40(%rbp)
leaq 0x1bea2(%rip), %rax     # 0x20130
movq %rax, -0x38(%rbp)
leaq 0x1c0ef(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x19910
movq -0x18(%rbp), %rdi
callq 0x16800
leaq 0x1c03b(%rip), %rcx     # 0x202f8
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x42dd
movq 0x1be99(%rip), %rax     # 0x20170
movq %rax, -0x58(%rbp)
jmp 0x42e8
movq 0x1be94(%rip), %rax     # 0x20178
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1c639(%rip), %rax     # 0x20930
cmpl $0x0, (%rax)
je 0x4355
leaq 0x1c085(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1899f(%rip), %rcx     # 0x1ccb0
movq %rcx, 0x10(%rax)
leaq 0x18994(%rip), %rdi     # 0x1ccb0
callq 0x18d20
cmpl $0x0, %eax
je 0x4355
leaq 0x1c05b(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1c5, 0xc(%rax)       # imm = 0x1C5
movq -0x18(%rbp), %rdi
callq 0xe6d0
movq %rax, %rsi
leaq 0x15e76(%rip), %rdi     # 0x1a1c4
movb $0x0, %al
callq 0x199c0
jmp 0x4357
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x1bdda(%rip), %rsi     # 0x20148
movq -0x18(%rbp), %rdx
leaq 0x1bf7f(%rip), %rdi     # 0x202f8
callq 0x172a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movl $0x1c7, -0x44(%rbp)     # imm = 0x1C7
leaq -0x50(%rbp), %rdi
callq 0x19ae0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1bd70(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16800
movq %rax, %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x1bd37(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x28(%rbp)
leaq 0x15e12(%rip), %rax     # 0x1a22f
movq %rax, -0x50(%rbp)
leaq 0x1bf60(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x1d9, -0x44(%rbp)     # imm = 0x1D9
leaq 0x1886d(%rip), %rax     # 0x1ccb0
movq %rax, -0x40(%rbp)
leaq 0x1bce2(%rip), %rax     # 0x20130
movq %rax, -0x38(%rbp)
leaq 0x1bf2f(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x19910
movq -0x18(%rbp), %rdi
callq 0x16800
andq $0x3, %rax
cmpq $0x3, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x449b
movq 0x1bcdb(%rip), %rax     # 0x20170
movq %rax, -0x58(%rbp)
jmp 0x44a6
movq 0x1bcd6(%rip), %rax     # 0x20178
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1c47b(%rip), %rax     # 0x20930
cmpl $0x0, (%rax)
je 0x4513
leaq 0x1bec7(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x187e1(%rip), %rcx     # 0x1ccb0
movq %rcx, 0x10(%rax)
leaq 0x187d6(%rip), %rdi     # 0x1ccb0
callq 0x18d20
cmpl $0x0, %eax
je 0x4513
leaq 0x1be9d(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1db, 0xc(%rax)       # imm = 0x1DB
movq -0x18(%rbp), %rdi
callq 0xe6d0
movq %rax, %rsi
leaq 0x15cb8(%rip), %rdi     # 0x1a1c4
movb $0x0, %al
callq 0x199c0
jmp 0x4515
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x1bc1c(%rip), %rsi     # 0x20148
movq -0x18(%rbp), %rdx
leaq 0x1bdc1(%rip), %rdi     # 0x202f8
callq 0x172a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movl $0x1dd, -0x44(%rbp)     # imm = 0x1DD
leaq -0x50(%rbp), %rdi
callq 0x19ae0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1bbb0(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16800
movq %rax, %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x1bb77(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x28(%rbp)
leaq 0x15c5f(%rip), %rax     # 0x1a23c
movq %rax, -0x50(%rbp)
leaq 0x1bda0(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x1ef, -0x44(%rbp)     # imm = 0x1EF
leaq 0x186ad(%rip), %rax     # 0x1ccb0
movq %rax, -0x40(%rbp)
leaq 0x1bb22(%rip), %rax     # 0x20130
movq %rax, -0x38(%rbp)
leaq 0x1bd6f(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x19910
movq -0x18(%rbp), %rdi
callq 0x16800
movl $0x3, %ecx
cmpq %rcx, %rax
jne 0x464d
movq 0x1bb29(%rip), %rax     # 0x20170
movq %rax, -0x58(%rbp)
jmp 0x4658
movq 0x1bb24(%rip), %rax     # 0x20178
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1c2c9(%rip), %rax     # 0x20930
cmpl $0x0, (%rax)
je 0x46c5
leaq 0x1bd15(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1862f(%rip), %rcx     # 0x1ccb0
movq %rcx, 0x10(%rax)
leaq 0x18624(%rip), %rdi     # 0x1ccb0
callq 0x18d20
cmpl $0x0, %eax
je 0x46c5
leaq 0x1bceb(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x1f1, 0xc(%rax)       # imm = 0x1F1
movq -0x18(%rbp), %rdi
callq 0xe6d0
movq %rax, %rsi
leaq 0x15b06(%rip), %rdi     # 0x1a1c4
movb $0x0, %al
callq 0x199c0
jmp 0x46c7
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x1ba6a(%rip), %rsi     # 0x20148
movq -0x18(%rbp), %rdx
leaq 0x1bc0f(%rip), %rdi     # 0x202f8
callq 0x172a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movl $0x1f3, -0x44(%rbp)     # imm = 0x1F3
leaq -0x50(%rbp), %rdi
callq 0x19ae0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1ba00(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16800
movq %rax, %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x1b9c7(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x28(%rbp)
leaq 0x15aba(%rip), %rax     # 0x1a247
movq %rax, -0x50(%rbp)
leaq 0x1bbf0(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x205, -0x44(%rbp)     # imm = 0x205
leaq 0x184fd(%rip), %rax     # 0x1ccb0
movq %rax, -0x40(%rbp)
leaq 0x1b972(%rip), %rax     # 0x20130
movq %rax, -0x38(%rbp)
leaq 0x1bbbf(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x19910
movq -0x18(%rbp), %rdi
callq 0x16800
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16990
movq %rax, %rdi
callq 0x16800
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x16b80
cmpq $0x0, %rax
je 0x481a
movq 0x1b95c(%rip), %rax     # 0x20170
movq %rax, -0x60(%rbp)
jmp 0x4825
movq 0x1b957(%rip), %rax     # 0x20178
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1c0fc(%rip), %rax     # 0x20930
cmpl $0x0, (%rax)
je 0x4892
leaq 0x1bb48(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x18462(%rip), %rcx     # 0x1ccb0
movq %rcx, 0x10(%rax)
leaq 0x18457(%rip), %rdi     # 0x1ccb0
callq 0x18d20
cmpl $0x0, %eax
je 0x4892
leaq 0x1bb1e(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x207, 0xc(%rax)       # imm = 0x207
movq -0x18(%rbp), %rdi
callq 0xe6d0
movq %rax, %rsi
leaq 0x15939(%rip), %rdi     # 0x1a1c4
movb $0x0, %al
callq 0x199c0
jmp 0x4894
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x1b89d(%rip), %rsi     # 0x20148
movq -0x18(%rbp), %rdx
leaq 0x1ba42(%rip), %rdi     # 0x202f8
callq 0x172a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movl $0x209, -0x44(%rbp)     # imm = 0x209
leaq -0x50(%rbp), %rdi
callq 0x19ae0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1b01d(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16800
movq %rax, %rdi
callq 0xba80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x1516f(%rip), %rdi     # 0x1a2cf
callq 0x12b60
movq -0x60(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq 0x1afbc(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x30(%rbp)
leaq 0x1513f(%rip), %rax     # 0x1a2d7
movq %rax, -0x58(%rbp)
leaq 0x1b1e5(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movl $0x284, -0x4c(%rbp)     # imm = 0x284
leaq 0x17af2(%rip), %rax     # 0x1ccb0
movq %rax, -0x48(%rbp)
leaq 0x1af67(%rip), %rax     # 0x20130
movq %rax, -0x40(%rbp)
leaq 0x1b1b4(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x19910
movq -0x28(%rbp), %rdi
callq 0x16800
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x520b
jmp 0x522a
leaq 0x150d2(%rip), %rdi     # 0x1a2e4
leaq 0x14e14(%rip), %rsi     # 0x1a02d
movl $0x286, %edx            # imm = 0x286
leaq 0x150d3(%rip), %rcx     # 0x1a2f8
callq 0x20f0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16b50
leaq 0x1b6f2(%rip), %rax     # 0x20930
cmpl $0x0, (%rax)
je 0x529c
leaq 0x1b13e(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x17a58(%rip), %rcx     # 0x1ccb0
movq %rcx, 0x10(%rax)
leaq 0x17a4d(%rip), %rdi     # 0x1ccb0
callq 0x18d20
cmpl $0x0, %eax
je 0x529c
leaq 0x1b114(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x288, 0xc(%rax)       # imm = 0x288
movq -0x18(%rbp), %rdi
callq 0xe6d0
movq %rax, %rsi
leaq 0x14f2f(%rip), %rdi     # 0x1a1c4
movb $0x0, %al
callq 0x199c0
jmp 0x529e
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x1ae93(%rip), %rax     # 0x20148
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rdi
callq 0x16800
movq -0x78(%rbp), %rsi
movq %rax, %rdx
leaq 0x1b028(%rip), %rdi     # 0x202f8
callq 0x172a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movl $0x28a, -0x4c(%rbp)     # imm = 0x28A
leaq -0x58(%rbp), %rdi
callq 0x19ae0
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/reduce.c
// Function: extend_env
static CONS*
extend_env(CONS* env, CONS* name, CONS* value)
{
	CONS* binding = NULL;

	assert(atomp(name));
	/* find first "self" binding in the current environment */
	while (!nilp(env)) {
		assert(consp(env));
		if (car(car(env)) == self_symbol) {
			break;
		}
		env = cdr(env);
	}
	assert(!nilp(env));
	/* link in new binding to immediately follow "self" */
	binding = cons(name, value);
	rplacd(env, cons(binding, cdr(env)));
	return binding;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x568a
jmp 0x56a9
leaq 0x157c3(%rip), %rdi     # 0x1ae54
leaq 0x14995(%rip), %rsi     # 0x1a02d
movl $0x292, %edx            # imm = 0x292
leaq 0x157bc(%rip), %rcx     # 0x1ae60
callq 0x20f0
jmp 0x56ab
leaq 0x1ac46(%rip), %rax     # 0x202f8
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x56cf
jmp 0x574c
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x21(%rbp)
je 0x56ed
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x56ff
jmp 0x571e
leaq 0x15783(%rip), %rdi     # 0x1ae89
leaq 0x14920(%rip), %rsi     # 0x1a02d
movl $0x295, %edx            # imm = 0x295
leaq 0x15747(%rip), %rcx     # 0x1ae60
callq 0x20f0
movq -0x8(%rbp), %rdi
callq 0x16800
movq %rax, %rdi
callq 0x16800
cmpq 0x1aa6a(%rip), %rax     # 0x201a0
jne 0x573a
jmp 0x574c
movq -0x8(%rbp), %rdi
callq 0x16990
movq %rax, -0x8(%rbp)
jmp 0x56ab
leaq 0x1aba5(%rip), %rax     # 0x202f8
cmpq %rax, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x5769
jmp 0x5788
leaq 0x15724(%rip), %rdi     # 0x1ae94
leaq 0x148b6(%rip), %rsi     # 0x1a02d
movl $0x29b, %edx            # imm = 0x29B
leaq 0x156dd(%rip), %rcx     # 0x1ae60
callq 0x20f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16710
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16990
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x16710
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x16b50
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x199bd(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1999d(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x20(%rbp)
leaq 0x13c1a(%rip), %rax     # 0x1a3d1
movq %rax, -0x58(%rbp)
leaq 0x19bc6(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movl $0x384, -0x4c(%rbp)     # imm = 0x384
leaq 0x164d3(%rip), %rax     # 0x1ccb0
movq %rax, -0x48(%rbp)
leaq 0x19948(%rip), %rax     # 0x20130
movq %rax, -0x40(%rbp)
leaq 0x19b95(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x19910
leaq 0x19aea(%rip), %rax     # 0x202f8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x13bab(%rip), %rdi     # 0x1a3cc
callq 0x12b60
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16990
movq %rax, %rdi
callq 0x16800
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x172a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x13b69(%rip), %rdi     # 0x1a3c7
callq 0x12b60
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16800
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x172a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x373(%rip), %rsi      # 0x6520
callq 0xcb70
movq %rax, -0x30(%rbp)
leaq 0x19a55(%rip), %rax     # 0x202f8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x19896(%rip), %rsi     # 0x20148
movq -0x30(%rbp), %rdx
callq 0x172a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xcc90
movl $0x38c, -0x4c(%rbp)     # imm = 0x38C
leaq -0x58(%rbp), %rdi
callq 0x19ae0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1924d(%rip), %rsi     # 0x20148
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1922d(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1922d(%rip), %rsi     # 0x20158
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x28(%rbp)
leaq 0x134c0(%rip), %rax     # 0x1a3ff
movq %rax, -0x60(%rbp)
leaq 0x1943e(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x58(%rbp)
movl $0x3e1, -0x54(%rbp)     # imm = 0x3E1
leaq 0x15d4b(%rip), %rax     # 0x1ccb0
movq %rax, -0x50(%rbp)
leaq 0x191c0(%rip), %rax     # 0x20130
movq %rax, -0x48(%rbp)
leaq 0x1940d(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x19910
leaq 0x19362(%rip), %rax     # 0x202f8
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq 0x191b3(%rip), %rsi     # 0x20158
movq -0x28(%rbp), %rdx
callq 0x172a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x13408(%rip), %rdi     # 0x1a3cc
callq 0x12b60
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16990
movq %rax, %rdi
callq 0x16800
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x172a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x133bd(%rip), %rdi     # 0x1a3c7
callq 0x12b60
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16800
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
callq 0x172a0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq -0x3ef(%rip), %rsi      # 0x6c50
callq 0xcb70
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x190e9(%rip), %rsi     # 0x20148
movq -0x38(%rbp), %rdx
leaq 0x1928e(%rip), %rdi     # 0x202f8
callq 0x172a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movl $0x3e8, -0x54(%rbp)     # imm = 0x3E8
leaq -0x60(%rbp), %rdi
callq 0x19ae0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x16990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x18038(%rip), %rsi     # 0x20140
xorl %eax, %eax
movl %eax, %edx
callq 0x171b0
movq %rax, -0x18(%rbp)
leaq 0x123c0(%rip), %rax     # 0x1a4dc
movq %rax, -0x40(%rbp)
leaq 0x18261(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x4b7, -0x34(%rbp)     # imm = 0x4B7
leaq 0x14b6e(%rip), %rax     # 0x1ccb0
movq %rax, -0x30(%rbp)
leaq 0x17fe3(%rip), %rax     # 0x20130
movq %rax, -0x28(%rbp)
leaq 0x18230(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x19910
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x17fc5(%rip), %rsi     # 0x20148
leaq 0x1816e(%rip), %rdx     # 0x202f8
movq %rdx, %rdi
callq 0x172a0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0xcc90
movq -0x10(%rbp), %rdi
movq 0x17f93(%rip), %rsi     # 0x20140
movq 0x17fe4(%rip), %rdx     # 0x20198
callq 0x172a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x17fc8(%rip), %rsi     # 0x20190
movq -0x10(%rbp), %rdx
callq 0xcc90
movl $0x4bb, -0x34(%rbp)     # imm = 0x4BB
leaq -0x40(%rbp), %rdi
callq 0x19ae0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10870
movq %rax, -0x18(%rbp)
leaq 0x10965(%rip), %rdi     # 0x1af49
callq 0x12b60
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq 0x15d01(%rip), %rdi     # 0x202f8
callq 0x172a0
movq %rax, -0x20(%rbp)
movq 0x15dd1(%rip), %rdi     # 0x203d8
movq -0x20(%rbp), %rdx
leaq 0x16de(%rip), %rsi      # 0xbcf0
callq 0xcb70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa63c
movq 0x15daf(%rip), %rdi     # 0x203d8
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9be0
cmpq $0x0, %rax
jne 0xa661
movq 0x159b5(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x108fb(%rip), %rsi     # 0x1af50
movb $0x0, %al
callq 0x2160
callq 0x2050
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x10437(%rip), %rax     # 0x1af71
movq %rax, -0x440(%rbp)
leaq 0x15840(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x438(%rbp)
movl $0x66b, -0x434(%rbp)    # imm = 0x66B
leaq 0x12147(%rip), %rax     # 0x1ccb0
movq %rax, -0x430(%rbp)
leaq 0x155b9(%rip), %rax     # 0x20130
movq %rax, -0x428(%rbp)
leaq 0x15803(%rip), %rax     # 0x20388
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x420(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x19910
callq 0xac40
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xabce
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0xabd9
movq 0x155c3(%rip), %rax     # 0x20198
movq %rax, -0x10(%rbp)
jmp 0xabdb
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2130
cmpq $0x0, %rax
je 0xac17
movq -0x418(%rbp), %rdi
leaq -0x410(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x9be0
cmpq $0x0, %rax
jne 0xac15
jmp 0xac17
jmp 0xabdb
movl $0x675, -0x434(%rbp)    # imm = 0x675
leaq -0x440(%rbp), %rdi
callq 0x19ae0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x5e1b(%rip), %rax      # 0x6fd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x5e05(%rip), %rax      # 0x6fd0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3e1d(%rip), %rsi      # 0x5004
callq 0x1080
movq %rax, -0x18(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x120e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x3e02(%rip), %rsi      # 0x5007
callq 0x1080
movq %rax, -0x20(%rbp)
jmp 0x1210
movq -0x18(%rbp), %rdi
callq 0x42e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x1269
cmpl $-0x2, -0x24(%rbp)
jne 0x1253
movq 0x5dca(%rip), %rax      # 0x6ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x3dbe(%rip), %rsi      # 0x500a
movb $0x0, %al
callq 0x1060
movl -0x24(%rbp), %edi
callq 0x2360
movzwl %ax, %edi
movq -0x20(%rbp), %rsi
callq 0x15a0
jmp 0x1210
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/mastermind/mastermind.c
// Function: display_init
static void display_init(void)
{
  initscr();
  if (has_colors()) {
    start_color();
    init_pair(CODE_ALPHA,   COLOR_RED,     COLOR_BLACK);
    init_pair(CODE_BRAVO,   COLOR_GREEN,   COLOR_BLACK);
    init_pair(CODE_CHARLIE, COLOR_YELLOW,  COLOR_BLACK);
    init_pair(CODE_DELTA,   COLOR_BLUE,    COLOR_BLACK);
    init_pair(CODE_ECHO,    COLOR_MAGENTA, COLOR_BLACK);
    init_pair(CODE_FOXTROT, COLOR_CYAN,    COLOR_BLACK);
  }
  noecho();
  keypad(stdscr, TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1090
callq 0x1030
testb $0x1, %al
jne 0x1584
jmp 0x15dd
callq 0x10c0
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1100
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1100
movl $0x3, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1100
movl $0x4, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1100
movl $0x5, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1100
movl $0x6, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x1100
callq 0x1080
movq 0x29f7(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10d0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/mastermind/mastermind.c
// Function: hidden_code_randomize
static void hidden_code_randomize(void)
{
  int i;
  srandom(time(NULL));
  for (i = 0; i < CODE_SLOTS; i++)
    hidden_code[i] = (random() % CODE_FOXTROT) + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x1060
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x1651
callq 0x10f0
movl $0x6, %ecx
cqto
idivq %rcx
addq $0x1, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x2bdd(%rip), %rax      # 0x4220
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x161f
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/mastermind/mastermind.c
// Function: guess_is_completed
static int guess_is_completed()
{
  int i;
  for (i = 0; i < CODE_SLOTS; i++) {
    if (guess[current_guess].code[i] == CODE_NONE)
      return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x1d36
movslq 0x2508(%rip), %rcx      # 0x4210
leaq 0x23c1(%rip), %rax      # 0x40d0
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1d29
movl $0x0, -0x4(%rbp)
jmp 0x1d3d
jmp 0x1d2b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1cfb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x1d97
movslq 0x24a8(%rip), %rcx      # 0x4210
leaq 0x2361(%rip), %rax      # 0x40d0
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $0x1, 0x10(%rax,%rcx,4)
je 0x1d8a
movl $0x0, -0x4(%rbp)
jmp 0x1d9e
jmp 0x1d8c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1d5b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xdf1(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movl %eax, %eax
movq %rax, -0x50(%rbp)
callq 0x11f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movl %eax, %edi
callq 0x1070
callq 0x10e0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x20(%rbp)
movl 0x2e3f(%rip), %eax      # 0x40a0
cmpl $0x0, %eax
jne 0x126d
callq 0x1350
jmp 0x125b
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x128f
pause
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1275
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
cmpq $0x1312d00, -0x30(%rbp) # imm = 0x1312D00
jae 0x1338
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movl %eax, %edx
movq -0x30(%rbp), %rcx
leaq 0x2de6(%rip), %rax      # 0x40b0
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rcx
leaq 0x2dd8(%rip), %rax      # 0x40b0
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1810
cmpl $0x0, %eax
jne 0x130c
leaq 0xd12(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x133f
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
leaq 0x2d91(%rip), %rax      # 0x40b0
movslq (%rax,%rcx,4), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x12a7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xcae(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movl %eax, %eax
movq %rax, -0x58(%rbp)
callq 0x11f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movl %eax, %edi
callq 0x1070
callq 0x10e0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x20(%rbp)
movl 0x2cdf(%rip), %eax      # 0x40a0
cmpl $0x0, %eax
jne 0x13cd
callq 0x1350
jmp 0x13bb
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x13ef
pause
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x13d5
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
cmpq $0x1312d00, -0x30(%rbp) # imm = 0x1312D00
jae 0x1479
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1880
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1437
jmp 0x1439
jmp 0x141c
movq -0x50(%rbp), %rax
movl (%rax), %eax
cmpl -0x44(%rbp), %eax
je 0x145b
leaq 0xbe0(%rip), %rdi       # 0x202b
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1480
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1407
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1200
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x14bc
leaq 0xb85(%rip), %rdi       # 0x203a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1360
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x14dc
leaq 0xb77(%rip), %rdi       # 0x204c
movb $0x0, %al
callq 0x1050
cmpl $0x0, -0x10(%rbp)
jne 0x14e8
cmpl $0x0, -0xc(%rbp)
je 0x14f8
leaq 0xb6e(%rip), %rdi       # 0x205d
movb $0x0, %al
callq 0x1050
jmp 0x1506
leaq 0xb79(%rip), %rdi       # 0x2078
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movl $0x0, 0x2b7a(%rip)      # 0x40a0
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x1d5(%rip), %rsi      # 0x1360
callq 0x1650
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x349(%rip), %rsi      # 0x1200
callq 0x1650
movl $0x1, %edi
callq 0x10d0
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, 0x2b29(%rip)      # 0x40a0
movq -0x20(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1690
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1690
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x15b2
cmpl $0x0, -0x2c(%rbp)
je 0x15c2
leaq 0xadc(%rip), %rdi       # 0x2095
movb $0x0, %al
callq 0x1050
jmp 0x15d0
leaq 0xadf(%rip), %rdi       # 0x20a8
movb $0x0, %al
callq 0x1050
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movabsq $-0x29406b2a1a85bd43, %rcx # imm = 0xD6BF94D5E57A42BD
mulq %rcx
movq %rdx, %rsi
shrq $0x18, %rsi
leaq 0xacc(%rip), %rdi       # 0x20c2
xorl %eax, %eax
callq 0x1050
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, (%rax)
je 0x1619
leaq 0xac9(%rip), %rdi       # 0x20db
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x18f0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x163c
movl -0x44(%rbp), %esi
leaq 0xadc(%rip), %rdi       # 0x2111
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stv0g[P]c11-queues/./c11threads.h
// Function: thrd_join
static inline int thrd_join(thrd_t thr, int *res)
{
	void *retval;

	if(pthread_join(thr, &retval) != 0) {
		return thrd_error;
	}
	if(res) {
		*res = (long)retval;
	}
	return thrd_success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
je 0x16bb
movl $0x3, -0x4(%rbp)
jmp 0x16d5
cmpq $0x0, -0x18(%rbp)
je 0x16ce
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
shlq $0x4, %rsi
callq 0x1a30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
xchgq %rax, (%rcx)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rax, 0x120(%rcx)
movq -0x8(%rbp), %rcx
movq %rax, 0xd8(%rcx)
movq -0x8(%rbp), %rcx
movq %rax, 0x90(%rcx)
movq -0x8(%rbp), %rcx
xchgq %rax, 0x48(%rcx)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x17d2
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1810
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x17ad
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x17ff
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1880
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x17da
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_pull
int spsc_ub_queue_pull(struct spsc_ub_queue* q, void** v)
{
	if (atomic_load_explicit(&(q->_tail->_next), memory_order_acquire)) {
		*v = q->_tail->_next->_value;
		
		//store_release(&q->_tail, q->_tail->_next);
		atomic_store_explicit(&q->_tail, q->_tail->_next, memory_order_release);
		
		return 1;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x18d8
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x18df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_destroy
int spsc_ub_queue_destroy(struct spsc_ub_queue* q)
{
	struct node* n = q->_first;

	do {
		struct node* next = n->_next;
		memory_free(q->mem, (void *) n, sizeof(struct node));
		n = next;
	} while (n);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x1a60
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x190b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_alloc_node
struct node* spsc_ub_alloc_node(struct spsc_ub_queue* q)
{
	/* First tries to allocate node from internal node cache,
	 * if attempt fails, allocates node via mmap() */

	if (q->_first != q->_tailcopy) {
		struct node* n = q->_first;
		q->_first = q->_first->_next;
		return n;
	}

	//q->_tailcopy = load_consume(q->_tail);
	q->_tailcopy = atomic_load_explicit(&q->_tail, memory_order_acquire);
	
	if (q->_first != q->_tailcopy) {
		struct node* n = q->_first;
		q->_first = q->_first->_next;
		return n;
	}

	return (struct node*) memory_alloc(q->mem, sizeof(struct node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x120(%rcx), %rax
je 0x19a6
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a20
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x120(%rcx), %rax
je 0x1a0b
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a20
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x10, %esi
callq 0x1a30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stv0g[P]c11-queues/memory.c
// Function: memory_hugepage_alloc
static void * memory_hugepage_alloc(size_t len)
{
	int prot = PROT_READ | PROT_WRITE;
	int flags = MAP_PRIVATE | MAP_ANONYMOUS;
	
#ifdef __MACH__
	flags |= VM_FLAGS_SUPERPAGE_SIZE_2MB;
#elif defined(__linux__)
	flags |= MAP_HUGETLB | MAP_LOCKED;
#endif
	
	return mmap(NULL, len, prot, flags, -1, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3, -0xc(%rbp)
movl $0x22, -0x10(%rbp)
movl -0x10(%rbp), %eax
orl $0x42000, %eax          # imm = 0x42000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r9d
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)