LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: apply_define_beh
BEH_DECL(apply_define_beh)
{
	CONS* value = WHAT;
	CONS* to;
	CONS* name;
	CONS* env;
	CONS* p = MINE;
	CONS* msg;

	DBUG_ENTER("apply_define_beh");
	to = pr_head(p);
	p = pr_tail(p);
	name = pr_head(p);
	DBUG_PRINT("", ("name = %s", cons_to_str(name)));
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	env = pr_tail(p);
	msg = mk_empty();
	msg = mk_list(value, msg);
	msg = mk_list(name, msg);
	msg = mk_list(ATOM("define"), msg);
	msg = mk_pair(msg, env);
	msg = mk_pair(to, msg);
	SEND(env, 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 0x1518d
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %r12
leaq 0x12e42(%rip), %rax     # 0x1825f
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x19ef4(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x339, 0xc(%rdi)       # imm = 0x339
leaq 0x15599(%rip), %rbp     # 0x1a9e0
movq %rbp, 0x10(%rdi)
leaq 0x19cee(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq %r12, %rdi
callq 0x150ee
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x1518d
movq %rax, %r13
movq %rax, %rdi
callq 0x150ee
movq %rax, %r12
leaq 0x1a467(%rip), %r14     # 0x1f8f0
cmpl $0x0, (%r14)
je 0x5516
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16604
testl %eax, %eax
je 0x54d1
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x33d, 0xc(%rax)       # imm = 0x33D
movq %r12, %rdi
callq 0xf0bc
leaq 0x12bd3(%rip), %rdi     # 0x1809a
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
cmpl $0x0, (%r14)
je 0x5516
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16604
testl %eax, %eax
je 0x5516
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x33e, 0xc(%rax)       # imm = 0x33E
movq (%rsp), %rdi
callq 0xf0bc
leaq 0x12b98(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r13, %rdi
callq 0x1518d
movq %rax, %r13
leaq 0x19d68(%rip), %rsi     # 0x1f290
movq (%rsp), %rdi
callq 0x150cc
movq %r12, %rdi
movq %rax, %rsi
callq 0x150cc
movq %rax, %r14
leaq 0x12b69(%rip), %rdi     # 0x180af
callq 0x1257b
movq %rax, %rdi
movq %r14, %rsi
callq 0x150cc
movq %rax, %rdi
movq %r13, %rsi
callq 0x150cc
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x150cc
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xde17
leaq 0x10(%rsp), %rdi
movl $0x347, 0xc(%rdi)       # imm = 0x347
callq 0x17027
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: apply_set_beh
BEH_DECL(apply_set_beh)
{
	CONS* value = WHAT;
	CONS* to;
	CONS* name;
	CONS* env;
	CONS* p = MINE;
	CONS* msg;

	DBUG_ENTER("apply_set_beh");
	to = pr_head(p);
	p = pr_tail(p);
	name = pr_head(p);
	DBUG_PRINT("", ("name = %s", cons_to_str(name)));
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	env = pr_tail(p);
	msg = mk_empty();
	msg = mk_list(value, msg);
	msg = mk_list(name, msg);
	msg = mk_list(ATOM("set!"), msg);
	msg = mk_pair(msg, env);
	msg = mk_pair(to, msg);
	SEND(env, 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 0x1518d
movq %rax, (%rsp)
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %r12
leaq 0x126a2(%rip), %rax     # 0x18287
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1972c(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3a6, 0xc(%rdi)       # imm = 0x3A6
leaq 0x14dd1(%rip), %rbp     # 0x1a9e0
movq %rbp, 0x10(%rdi)
leaq 0x19526(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq %r12, %rdi
callq 0x150ee
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x1518d
movq %rax, %r13
movq %rax, %rdi
callq 0x150ee
movq %rax, %r12
leaq 0x19c9f(%rip), %r14     # 0x1f8f0
cmpl $0x0, (%r14)
je 0x5cde
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16604
testl %eax, %eax
je 0x5c99
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x3aa, 0xc(%rax)       # imm = 0x3AA
movq %r12, %rdi
callq 0xf0bc
leaq 0x1240b(%rip), %rdi     # 0x1809a
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
cmpl $0x0, (%r14)
je 0x5cde
movq (%r15), %rax
movq 0x50(%rax), %rax
movq %rbp, 0x10(%rax)
movq %rbp, %rdi
callq 0x16604
testl %eax, %eax
je 0x5cde
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x3ab, 0xc(%rax)       # imm = 0x3AB
movq (%rsp), %rdi
callq 0xf0bc
leaq 0x123d0(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r13, %rdi
callq 0x1518d
movq %rax, %r13
leaq 0x195a0(%rip), %rsi     # 0x1f290
movq (%rsp), %rdi
callq 0x150cc
movq %r12, %rdi
movq %rax, %rsi
callq 0x150cc
movq %rax, %r14
leaq 0x123a8(%rip), %rdi     # 0x180b6
callq 0x1257b
movq %rax, %rdi
movq %r14, %rsi
callq 0x150cc
movq %rax, %rdi
movq %r13, %rsi
callq 0x150cc
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x150cc
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xde17
leaq 0x10(%rsp), %rdi
movl $0x3b4, 0xc(%rdi)       # imm = 0x3B4
callq 0x17027
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: join_list_beh
BEH_DECL(join_list_beh)
{
	CONS* list = WHAT;
	CONS* to;
	CONS* value;

	DBUG_ENTER("join_list_beh");
	to = pr_head(MINE);
	value = pr_tail(MINE);
	if (is_list(list)) {
		DBUG_PRINT("", ("list = %s", cons_to_str(list)));
		DBUG_PRINT("", ("value = %s", cons_to_str(value)));
		SEND(to, mk_list(value, list));
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	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 0x1518d
movq %rax, %r14
leaq 0x120f8(%rip), %rax     # 0x182a2
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x19169(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x3f5, 0xc(%rdi)       # imm = 0x3F5
leaq 0x1480e(%rip), %rcx     # 0x1a9e0
movq %rcx, 0x10(%rdi)
leaq 0x18f63(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r13
leaq 0x196c7(%rip), %rbp     # 0x1f8f0
movl (%rbp), %eax
testq %r14, %r14
je 0x631f
movl %r14d, %ecx
andl $0x3, %ecx
jne 0x631f
testl %eax, %eax
je 0x62e8
leaq 0x190d0(%rip), %r15     # 0x1f320
movq (%r15), %rax
movq 0x50(%rax), %rax
leaq 0x14782(%rip), %rdi     # 0x1a9e0
movq %rdi, 0x10(%rax)
callq 0x16604
testl %eax, %eax
je 0x6292
movq (%r15), %rax
movq 0x50(%rax), %rax
movl $0x3f9, 0xc(%rax)       # imm = 0x3F9
movq %r14, %rdi
callq 0xf0bc
leaq 0x12028(%rip), %rdi     # 0x182b0
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
cmpl $0x0, (%rbp)
je 0x62e8
leaq 0x19081(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x14733(%rip), %rdi     # 0x1a9e0
movq %rdi, 0x10(%rax)
callq 0x16604
testl %eax, %eax
je 0x62e8
leaq 0x1905f(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3fa, 0xc(%rax)       # imm = 0x3FA
movq %r13, %rdi
callq 0xf0bc
leaq 0x11dc6(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r13, %rdi
movq %r14, %rsi
callq 0x150cc
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x400, 0xc(%rdi)       # imm = 0x400
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0x637c
leaq 0x18ff6(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x146a8(%rip), %rdi     # 0x1a9e0
movq %rdi, 0x10(%rax)
callq 0x16604
testl %eax, %eax
je 0x637c
leaq 0x18fd4(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x3fd, 0xc(%rax)       # imm = 0x3FD
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x11cee(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: next_list_beh
BEH_DECL(next_list_beh)
{
	CONS* value = WHAT;
	CONS* to;
	CONS* expr;
	CONS* env;
	CONS* p;
	CONS* msg;
	CONS* a;

	DBUG_ENTER("next_list_beh");
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	to = pr_head(MINE);
	p = pr_tail(MINE);
	expr = pr_head(p);
	DBUG_PRINT("", ("expr = %s", cons_to_str(expr)));
	env = pr_tail(p);
	a = ACTOR(join_list_beh, mk_pair(to, value));
	msg = mk_pair(expr, env);
	msg = mk_pair(a, msg);
	SEND(eval_list__actor, 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 0x1518d
movq %rax, %r14
leaq 0x11f15(%rip), %rax     # 0x182ba
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x18f6e(%rip), %r12     # 0x1f320
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x417, 0xc(%rdi)       # imm = 0x417
leaq 0x14612(%rip), %r15     # 0x1a9e0
movq %r15, 0x10(%rdi)
leaq 0x18d67(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x19503(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x6432
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x16604
testl %eax, %eax
je 0x6432
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x418, 0xc(%rax)       # imm = 0x418
movq %r14, %rdi
callq 0xf0bc
leaq 0x11c7c(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %rbp
movq %rax, %rdi
callq 0x150ee
movq %rax, %r13
leaq 0x19474(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x64cd
leaq 0x18e98(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x16604
testl %eax, %eax
je 0x64cd
leaq 0x18e7a(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x41c, 0xc(%rax)       # imm = 0x41C
movq %r13, %rdi
callq 0xf0bc
leaq 0x11c29(%rip), %rdi     # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %rbp, %rdi
callq 0x1518d
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x150cc
leaq -0x364(%rip), %rsi      # 0x6186
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdd3a
movq %rax, %r14
movq %r13, %rdi
movq %r15, %rsi
callq 0x150cc
movq %r14, %rdi
movq %rax, %rsi
callq 0x150cc
movq 0x18e6b(%rip), %rsi     # 0x1f380
movq %rbx, %rdi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x422, 0xc(%rdi)       # imm = 0x422
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: join_value_beh
BEH_DECL(join_value_beh)
{
	CONS* to;
	CONS* value;
	CONS* list;

	DBUG_ENTER("join_value_beh");
	to = pr_head(MINE);
	list = pr_tail(MINE);
	if (is_pair(WHAT) && (pr_head(WHAT) == to)) {
		DBUG_PRINT("", ("list = %s", cons_to_str(list)));
		value = pr_tail(WHAT);
		DBUG_PRINT("", ("value = %s", cons_to_str(value)));
		SEND(to, mk_list(value, list));
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x11a41(%rip), %rax     # 0x182d6
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x18a7c(%rip), %r13     # 0x1f320
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x462, 0xc(%rdi)       # imm = 0x462
leaq 0x14120(%rip), %r14     # 0x1a9e0
movq %r14, 0x10(%rdi)
leaq 0x18875(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x1518d
testq %rax, %rax
je 0x6a4e
movq 0x30(%rbx), %rdi
callq 0x1518d
testb $0x3, %al
jne 0x6a4e
movq 0x30(%rbx), %rdi
callq 0x1518d
cmpq 0x1867d(%rip), %rax     # 0x1efc0
je 0x6a4e
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x150ee
cmpq %r15, %rax
jne 0x6a4e
movq %r15, 0x8(%rsp)
leaq 0x18f81(%rip), %rbp     # 0x1f8f0
cmpl $0x0, (%rbp)
je 0x69b5
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x69b5
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x466, 0xc(%rax)       # imm = 0x466
movq %r12, %rdi
callq 0xf0bc
leaq 0x11905(%rip), %rdi     # 0x182b0
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r14, %r15
movq %r13, %r14
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0x1518d
movq %rax, %r13
cmpl $0x0, (%rbp)
je 0x6a13
movq (%r14), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x16604
testl %eax, %eax
je 0x6a13
movq (%r14), %rax
movq 0x50(%rax), %rax
movl $0x468, 0xc(%rax)       # imm = 0x468
movq %r13, %rdi
callq 0xf0bc
leaq 0x1169b(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %r13, %rdi
movq %r12, %rsi
callq 0x150cc
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xde17
leaq 0x10(%rsp), %rdi
movl $0x46e, 0xc(%rdi)       # imm = 0x46E
callq 0x17027
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18e9b(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x6aa3
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x16604
testl %eax, %eax
je 0x6aa3
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x46b, 0xc(%rax)       # imm = 0x46B
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %rdi
callq 0xf0bc
leaq 0x115c7(%rip), %rdi     # 0x18060
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: next_seq_beh
BEH_DECL(next_seq_beh)
{
	CONS* value = WHAT;
	CONS* eval = pr_head(MINE);
	CONS* msg = pr_tail(MINE);

	DBUG_ENTER("next_seq_beh");
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	SEND(eval, 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 0x1518d
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r12
leaq 0x11238(%rip), %rax     # 0x18303
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x18248(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x4d0, 0xc(%rdi)       # imm = 0x4D0
leaq 0x138ec(%rip), %r13     # 0x1a9e0
movq %r13, 0x10(%rdi)
leaq 0x18041(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x187dd(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x7158
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16604
testl %eax, %eax
je 0x7158
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x4d1, 0xc(%rax)       # imm = 0x4D1
movq %r14, %rdi
callq 0xf0bc
leaq 0x10f56(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x4d3, 0xc(%rdi)       # imm = 0x4D3
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: next_and_beh
BEH_DECL(next_and_beh)
{
	CONS* value = WHAT;
	CONS* eval = pr_head(MINE);
	CONS* msg = pr_tail(MINE);

	DBUG_ENTER("next_and_beh");
	DBUG_PRINT("", ("value = %s", cons_to_str(value)));
	if (value == FALSE_SYMBOL) {
		SEND(pr_head(msg), value);
	} else {
		SEND(eval, 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 0x1518d
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r12
leaq 0x10de4(%rip), %rax     # 0x1831d
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x17dda(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x524, 0xc(%rdi)       # imm = 0x524
leaq 0x1347e(%rip), %r13     # 0x1a9e0
movq %r13, 0x10(%rdi)
leaq 0x17bd3(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x1836f(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0x75c6
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16604
testl %eax, %eax
je 0x75c6
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x525, 0xc(%rax)       # imm = 0x525
movq %r14, %rdi
callq 0xf0bc
leaq 0x10ae8(%rip), %rdi     # 0x180a4
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
xorl %edi, %edi
callq 0x3c98
cmpq %rax, %r14
je 0x75dd
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x75ee
movq %r12, %rdi
callq 0x150ee
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x52b, 0xc(%rdi)       # imm = 0x52B
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: apply_cond_beh
BEH_DECL(apply_cond_beh)
{
	CONS* f = pr_head(MINE);
	CONS* t = pr_tail(MINE);

	DBUG_ENTER("apply_cond_beh");
	if (WHAT == FALSE_SYMBOL) {
		DBUG_PRINT("", ("false"));
		SEND(pr_head(f), pr_tail(f));
	} else {
		DBUG_PRINT("", ("true"));
		SEND(eval_seq__actor, t);
	}
	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 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r15
leaq 0x104e5(%rip), %rax     # 0x18353
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x174a5(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x5dd, 0xc(%rdi)       # imm = 0x5DD
leaq 0x12b49(%rip), %r12     # 0x1a9e0
movq %r12, 0x10(%rdi)
leaq 0x1729e(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %r13
xorl %edi, %edi
callq 0x3c98
leaq 0x17a27(%rip), %rcx     # 0x1f8f0
movl (%rcx), %ecx
cmpq %rax, %r13
je 0x7f18
testl %ecx, %ecx
je 0x7f09
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x16604
testl %eax, %eax
je 0x7f09
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x5e2, 0xc(%rax)       # imm = 0x5E2
leaq 0x10466(%rip), %rdi     # 0x18368
xorl %eax, %eax
callq 0x16f13
movq 0x17458(%rip), %rsi     # 0x1f368
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x7f6d
testl %ecx, %ecx
je 0x7f51
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x16604
testl %eax, %eax
je 0x7f51
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x5df, 0xc(%rax)       # imm = 0x5DF
leaq 0x10418(%rip), %rdi     # 0x18362
xorl %eax, %eax
callq 0x16f13
movq %r14, %rdi
callq 0x150ee
movq %rax, %r15
movq %r14, %rdi
callq 0x1518d
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x5e5, 0xc(%rdi)       # imm = 0x5E5
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: apply_cont_beh
BEH_DECL(apply_cont_beh)
{
	CONS* args = WHAT;
	CONS* to = pr_head(MINE);
	CONS* env = pr_tail(MINE);

	DBUG_ENTER("apply_cont_beh");
	DBUG_PRINT("", ("args = %s", cons_to_str(args)));
	if (have_n_args(1, args)) {
		SEND(to, lst_first(args));
	} else {
		DBUG_PRINT("", ("error"));
		FAIL(env, mk_list(ATOM("one-arg-required"), args));
	}
	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 0x1518d
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, 0x8(%rsp)
leaq 0xd873(%rip), %rax      # 0x1850c
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x14678(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x8c7, 0xc(%rdi)       # imm = 0x8C7
leaq 0xfd1c(%rip), %r13      # 0x1a9e0
movq %r13, 0x10(%rdi)
leaq 0x14471(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x14c0d(%rip), %r14     # 0x1f8f0
cmpl $0x0, (%r14)
je 0xad29
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16604
testl %eax, %eax
je 0xad29
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x8c8, 0xc(%rax)       # imm = 0x8C8
movq %r15, %rdi
callq 0xf0bc
leaq 0xd3ff(%rip), %rdi      # 0x1811e
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
movl $0x1, %edi
movq %r15, %rsi
callq 0x4f95
testq %rax, %rax
je 0xad4e
movq %r15, %rdi
callq 0x150ee
movq %rbx, %rdi
movq %r12, %rsi
jmp 0xae04
cmpl $0x0, (%r14)
je 0xad89
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16604
testl %eax, %eax
je 0xad89
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x8cc, 0xc(%rax)       # imm = 0x8CC
leaq 0xd4ab(%rip), %rdi      # 0x1822d
xorl %eax, %eax
callq 0x16f13
leaq 0xd78b(%rip), %rdi      # 0x1851b
callq 0x1257b
movq %rax, %rdi
movq %r15, %rsi
callq 0x150cc
leaq -0x832f(%rip), %rsi     # 0x2a78
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdd3a
movq %rax, %r15
leaq 0xd2ce(%rip), %rdi      # 0x1808a
callq 0x1257b
movq %rax, %r12
callq 0xd160
leaq 0x144c0(%rip), %rsi     # 0x1f290
movq %rax, %rdi
callq 0x150cc
movq %r12, %rdi
movq %rax, %rsi
callq 0x150cc
movq %rax, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x150cc
movq %r15, %rdi
movq %rax, %rsi
callq 0x150cc
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xde17
leaq 0x10(%rsp), %rdi
movl $0x8cf, 0xc(%rdi)       # imm = 0x8CF
callq 0x17027
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: apply_fail_beh
BEH_DECL(apply_fail_beh)
{
	CONS* expr = pr_head(MINE);
	CONS* env = pr_tail(MINE);
	CONS* fail = WHAT;
	CONS* state;
	CONS* msg;
	CONS* a;

	DBUG_ENTER("apply_fail_beh");
	assert(actorp(fail));
	DBUG_PRINT("", ("expr = %s", cons_to_str(expr)));
	a = ACTOR(abort_beh, NIL);
	a = ACTOR(fail_beh, a);
	state = mk_pair(UNDEFINED, a);
	state = mk_pair(env, state);
	env = ACTOR(binding_beh, state);
	msg = mk_pair(expr, env);
	msg = mk_pair(fail, msg);
	SEND(eval_list__actor, 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 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x150ee
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x150ee
movq %rax, %rdi
callq 0xd1e1
movq %rax, %rdi
callq 0x1518d
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x1518d
movq %rax, %r15
leaq 0xd16d(%rip), %rax      # 0x1854f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x13f31(%rip), %rbp     # 0x1f320
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x944, 0xc(%rdi)       # imm = 0x944
leaq 0xf5d5(%rip), %r13      # 0x1a9e0
movq %r13, 0x10(%rdi)
leaq 0x13d2a(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
movl %r15d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xb51c
leaq 0x144b7(%rip), %rax     # 0x1f8f0
cmpl $0x0, (%rax)
je 0xb47e
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x16604
testl %eax, %eax
je 0xb47e
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0x946, 0xc(%rax)       # imm = 0x946
movq %r14, %rdi
callq 0xf0bc
leaq 0xcc78(%rip), %rdi      # 0x180ec
movq %rax, %rsi
xorl %eax, %eax
callq 0x16f13
leaq -0x8d89(%rip), %rsi     # 0x26fc
leaq 0x13e04(%rip), %rdx     # 0x1f290
movq %rbx, %rdi
callq 0xdd3a
leaq -0x1cd(%rip), %rsi      # 0xb2ce
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdd3a
movq %rax, %r13
callq 0xd160
movq %rax, %rdi
movq %r13, %rsi
callq 0x150cc
movq %r12, %rdi
movq %rax, %rsi
callq 0x150cc
leaq -0x86ed(%rip), %rsi     # 0x2dde
movq %rbx, %rdi
movq %rax, %rdx
callq 0xdd3a
movq %r14, %rdi
movq %rax, %rsi
callq 0x150cc
movq %r15, %rdi
movq %rax, %rsi
callq 0x150cc
movq 0x13e8d(%rip), %rsi     # 0x1f380
movq %rbx, %rdi
movq %rax, %rdx
callq 0xde17
movq %rsp, %rdi
movl $0x94f, 0xc(%rdi)       # imm = 0x94F
callq 0x17027
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd03b(%rip), %rdi      # 0x1855e
leaq 0xce91(%rip), %rsi      # 0x183bb
leaq 0xd03a(%rip), %rcx      # 0x1856b
movl $0x945, %edx            # imm = 0x945
callq 0x2100
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: assert_reduce
static void
assert_reduce(CONFIG* cfg, 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(cfg, assert_msg, state);
	if (!expect || !reduce_line(cfg, expr, cont)) {
		fprintf(stderr, "assert_reduce: FAILED! %s -> %s\n", expr, value);
		abort();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x10ae2
movq %rax, %r12
leaq 0xc155(%rip), %rdi      # 0x18dd7
callq 0x1257b
leaq 0x12602(%rip), %rdi     # 0x1f290
movq %rax, %rsi
movq %r12, %rdx
callq 0x15634
leaq 0x637(%rip), %rsi       # 0xd2d7
movq %r15, %rdi
movq %rax, %rdx
callq 0xdd3a
testq %r12, %r12
je 0xcccf
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb762
testq %rax, %rax
je 0xcccf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x12322(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0xc0fe(%rip), %rsi      # 0x18dde
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2170
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: read_reduce_print
static void
read_reduce_print(CONFIG* cfg, FILE* in, CONS* out)
{
	char buf[1024];
	
	DBUG_ENTER("read_reduce_print");
	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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xbd2e(%rip), %rax      # 0x18dff
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x12240(%rip), %rax     # 0x1f320
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xa10, 0xc(%rdi)       # imm = 0xA10
leaq 0xd8e5(%rip), %rcx      # 0x1a9e0
movq %rcx, 0x10(%rdi)
leaq 0x1203a(%rip), %rcx     # 0x1f140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x16ea2
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x2140
testq %rax, %rax
je 0xd140
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xb762
testq %rax, %rax
jne 0xd118
leaq 0x8(%rsp), %rdi
movl $0xa16, 0xc(%rdi)       # imm = 0xA16
callq 0x17027
addq $0x438, %rsp            # imm = 0x438
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/schemer.c
// Function: undefined
static CONS*
undefined()
{
	if (undefined__value == NULL) {
		undefined__value = ATOM("_");
		assert(undefined__value != NULL);
	}
	return undefined__value;
}

// Assembly:
pushq %rax
movq 0x12220(%rip), %rax     # 0x1f388
testq %rax, %rax
jne 0xd185
leaq 0xb4b0(%rip), %rdi      # 0x18624
callq 0x1257b
movq %rax, 0x12208(%rip)     # 0x1f388
testq %rax, %rax
je 0xd187
popq %rcx
retq
leaq 0xbb71(%rip), %rdi      # 0x18cff
leaq 0xb226(%rip), %rsi      # 0x183bb
leaq 0xbb7c(%rip), %rcx      # 0x18d18
movl $0x36, %edx
callq 0x2100
nop
// File: /workspace/github_c_makefile_star2_O3/vidarr[P]ringbuffer/test/ringbuffer_test.c
// Function: test_basic_ringbuffer_create
void test_basic_ringbuffer_create() {

    Ringbuffer* buffer = 0;

    buffer = ringbuffer_create(1, 0, 0);
    assert(buffer);
    assert(capacity_func == buffer->capacity);
    assert(add_func == buffer->add);
    assert(pop_func == buffer->pop);
    assert(free_func == buffer->free);

    buffer = buffer->free(buffer);

    fprintf(stdout, "Basic ringbuffer_create OK\n");

}

// Assembly:
pushq %rax
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x116c
testq %rax, %rax
je 0x1387
leaq -0xff(%rip), %rcx       # 0x1227
cmpq %rcx, (%rax)
jne 0x13a6
leaq -0xfe(%rip), %rcx       # 0x1234
cmpq %rcx, 0x8(%rax)
jne 0x13c5
leaq -0xb6(%rip), %rcx       # 0x128d
cmpq %rcx, 0x10(%rax)
jne 0x13e4
leaq -0xa3(%rip), %rcx       # 0x12b1
cmpq %rcx, 0x18(%rax)
jne 0x1403
movq %rax, %rdi
callq 0x12b1
movq 0x3c73(%rip), %rax      # 0x4fe0
movq (%rax), %rcx
leaq 0x1d3b(%rip), %rdi      # 0x30b2
movl $0x1b, %esi
movl $0x1, %edx
popq %rax
jmp 0x1060
leaq 0x1c76(%rip), %rdi      # 0x3004
leaq 0x1c76(%rip), %rsi      # 0x300b
leaq 0x1c86(%rip), %rcx      # 0x3022
movl $0x31, %edx
callq 0x1040
leaq 0x1c99(%rip), %rdi      # 0x3046
leaq 0x1c57(%rip), %rsi      # 0x300b
leaq 0x1c67(%rip), %rcx      # 0x3022
movl $0x32, %edx
callq 0x1040
leaq 0x1c9c(%rip), %rdi      # 0x3068
leaq 0x1c38(%rip), %rsi      # 0x300b
leaq 0x1c48(%rip), %rcx      # 0x3022
movl $0x33, %edx
callq 0x1040
leaq 0x1c95(%rip), %rdi      # 0x3080
leaq 0x1c19(%rip), %rsi      # 0x300b
leaq 0x1c29(%rip), %rcx      # 0x3022
movl $0x34, %edx
callq 0x1040
leaq 0x1c8e(%rip), %rdi      # 0x3098
leaq 0x1bfa(%rip), %rsi      # 0x300b
leaq 0x1c0a(%rip), %rcx      # 0x3022
movl $0x35, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/vidarr[P]ringbuffer/test/ringbuffer_test.c
// Function: test_free
void test_free() {

    int a = 1;

    Ringbuffer* buffer = 0;
    assert(0 == free_func(0));

    buffer = ringbuffer_create(1, 0, 0);
    assert(0 == buffer->free(buffer));

    buffer = ringbuffer_create(21, 0, 0);
    assert(0 == buffer->free(buffer));

    buffer = ringbuffer_create(21, 0, 0);
    for(size_t i = 0; i < buffer->capacity(buffer); ++i) {
        buffer->add(buffer, &a);
    }
    assert(0 == buffer->free(buffer));

    size_t count = 0;
    buffer = ringbuffer_create(21, count_free, &count);
    for(size_t i = 0; i < buffer->capacity(buffer); ++i) {
        int* ip = calloc(1, sizeof(int));
        *ip = i;
        buffer->add(buffer, ip);
    }
    assert(0 == buffer->free(buffer));
    assert(21 == count);

    fprintf(stdout, "free() OK\n");

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x1, 0x4(%rsp)
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x116c
movq %rax, %rdi
callq *0x18(%rax)
testq %rax, %rax
jne 0x155d
movl $0x15, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x116c
movq %rax, %rdi
callq *0x18(%rax)
testq %rax, %rax
jne 0x157c
movl $0x15, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x116c
movq %rax, %rbx
movq %rax, %rdi
callq *(%rax)
testq %rax, %rax
je 0x14b4
xorl %r15d, %r15d
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq *0x8(%rbx)
incq %r15
movq %rbx, %rdi
callq *(%rbx)
cmpq %rax, %r15
jb 0x149e
movq %rbx, %rdi
callq *0x18(%rbx)
testq %rax, %rax
jne 0x159b
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq -0xb4(%rip), %rsi       # 0x1422
movl $0x15, %edi
callq 0x116c
movq %rax, %rbx
movq %rax, %rdi
callq *(%rax)
testq %rax, %rax
je 0x1518
xorl %r14d, %r14d
movl $0x1, %edi
movl $0x4, %esi
callq 0x1050
movl %r14d, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq *0x8(%rbx)
incq %r14
movq %rbx, %rdi
callq *(%rbx)
cmpq %rax, %r14
jb 0x14f0
movq %rbx, %rdi
callq *0x18(%rbx)
testq %rax, %rax
jne 0x15ba
cmpq $0x15, 0x8(%rsp)
jne 0x15d9
movq 0x3aa6(%rip), %rax      # 0x4fe0
movq (%rax), %rcx
leaq 0x1bc1(%rip), %rdi      # 0x3105
movl $0xa, %esi
movl $0x1, %edx
callq 0x1060
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b7b(%rip), %rdi      # 0x30df
leaq 0x1aa0(%rip), %rsi      # 0x300b
leaq 0x1b5c(%rip), %rcx      # 0x30ce
movl $0x52, %edx
callq 0x1040
leaq 0x1b5c(%rip), %rdi      # 0x30df
leaq 0x1a81(%rip), %rsi      # 0x300b
leaq 0x1b3d(%rip), %rcx      # 0x30ce
movl $0x55, %edx
callq 0x1040
leaq 0x1b3d(%rip), %rdi      # 0x30df
leaq 0x1a62(%rip), %rsi      # 0x300b
leaq 0x1b1e(%rip), %rcx      # 0x30ce
movl $0x5b, %edx
callq 0x1040
leaq 0x1b1e(%rip), %rdi      # 0x30df
leaq 0x1a43(%rip), %rsi      # 0x300b
leaq 0x1aff(%rip), %rcx      # 0x30ce
movl $0x64, %edx
callq 0x1040
leaq 0x1b19(%rip), %rdi      # 0x30f9
leaq 0x1a24(%rip), %rsi      # 0x300b
leaq 0x1ae0(%rip), %rcx      # 0x30ce
movl $0x65, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/vidarr[P]ringbuffer/test/ringbuffer_test.c
// Function: main
int main(int argc, char** argv) {

    test_ringbuffer_create();
    test_capacity();
    test_add();
    test_pop();
    test_basic_ringbuffer_create();
    test_free();

}

// Assembly:
pushq %rax
xorl %eax, %eax
callq 0x1624
xorl %eax, %eax
callq 0x16ad
xorl %eax, %eax
callq 0x1747
xorl %eax, %eax
callq 0x19b8
callq 0x130b
callq 0x1430
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-zoe/pss-demux.c
// Function: writeFile
int writeFile( FILE *input, unsigned int length, FILE *output ) {
	unsigned char dataBuffer[1024];
	unsigned int bytesLeft = length;
	
	while(bytesLeft) {
		unsigned int wantedRead;
		if(bytesLeft >= sizeof(dataBuffer))
			wantedRead = sizeof(dataBuffer);
		else
			wantedRead = bytesLeft;
		unsigned int haveRead = fread(dataBuffer, 1, wantedRead, input);
		if(haveRead != wantedRead) {
			printf("haveRead != wantedRead: %d != %d\n", haveRead, wantedRead);
			perror("This broke");
			return 0;
		}

		unsigned int haveWrite = fwrite(dataBuffer, 1, haveRead, output);
		if(haveWrite != haveRead) {
			printf("haveWrite != haveRead: %d != %d\n", haveWrite, haveRead);
			return 0;
		}
		
		bytesLeft -= haveRead;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl $0x1, %ebx
testl %esi, %esi
je 0x12a2
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x400, %ebx            # imm = 0x400
movq %rsp, %r13
cmpl %ebx, %ebp
movl $0x400, %r12d           # imm = 0x400
cmovbl %ebp, %r12d
movl $0x1, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1060
cmpl %eax, %r12d
jne 0x12b6
movl %eax, %edx
movl $0x1, %esi
movq %r13, %rdi
movq %r14, %rcx
callq 0x1110
cmpl %eax, %r12d
jne 0x128d
subl %r12d, %ebp
jne 0x1246
movl $0x1, %ebx
jmp 0x12a2
leaq 0xdb5(%rip), %rdi       # 0x2049
xorl %ebx, %ebx
movl %eax, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1090
movl %ebx, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd5f(%rip), %rdi       # 0x201c
xorl %ebx, %ebx
movl %eax, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1090
leaq 0xd6c(%rip), %rdi       # 0x203e
callq 0x10f0
jmp 0x12a2
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-zoe/pss-demux.c
// Function: vagPrepareHeader
void vagPrepareHeader( vagHeader *header, uint32_t size, char *name ) {
	header->version[3] = 0x20;
	strncpy( header->name, name, 0x10 );
	header->size[0] = (size >> 24) & 0xFF; header->size[1] = (size >> 16) & 0xFF; header->size[2] = (size >> 8) & 0xFF; header->size[3] = size & 0xFF;
	header->samplerate[0] = 0; header->samplerate[1] = 0; header->samplerate[2] = audioSamplerate[2]; header->samplerate[3] = audioSamplerate[3];
	memset( header->reserved1, 0, 4 );
	memset( header->reserved2, 0, 12 );
	if( audioNumChannels == 1 ) strncpy( header->magic, "VAGp", 4 );
	else if( audioNumChannels == 2 ) strncpy( header->magic, "VAG2", 4 );
	return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rax
movl %esi, %ebp
movq %rdi, %rbx
movb $0x20, 0x7(%rdi)
addq $0x20, %rdi
movl $0x10, %edx
movq %rax, %rsi
callq 0x1040
movl %ebp, %ecx
movl %ebp, %eax
shrl $0x18, %eax
movb %al, 0xc(%rbx)
movl %ebp, %eax
shrl $0x10, %eax
movb %al, 0xd(%rbx)
movb %ch, 0xe(%rbx)
movb %cl, 0xf(%rbx)
movw $0x0, 0x10(%rbx)
movb 0x2a8b(%rip), %al       # 0x40b3
movb %al, 0x12(%rbx)
movb 0x2a83(%rip), %al       # 0x40b4
movb %al, 0x13(%rbx)
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x1c(%rbx)
movq $0x0, 0x14(%rbx)
movzbl 0x2a6a(%rip), %eax      # 0x40b5
cmpl $0x1, %eax
je 0x165c
cmpl $0x2, %eax
jne 0x1663
movl $0x32474156, %eax       # imm = 0x32474156
jmp 0x1661
movl $0x70474156, %eax       # imm = 0x70474156
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::set_up_lowpass(int, float)
void FIR_filter::set_up_lowpass(int sample_width, float frequency_cutoff){

	filter_width = sample_width;
	sample_width--;
	
	float ncof = (2*PI*frequency_cutoff)/sample_rate;
	
	for(int n = 0; n <= sample_width; n++){
		float hd = 0.0;
		if(n != sample_width/2.0){
			hd = sin(ncof*(n-(sample_width/2.0)))/(PI*(n-(sample_width/2.0)));
		} else {
			hd = ncof/PI;
		}
		filter_coefficents.push_back(hd);
	}

}

// Assembly:
movl %esi, 0x8(%rdi)
testl %esi, %esi
jle 0x379c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
mulsd 0x2a5d(%rip), %xmm0     # 0x6110
cvtss2sd 0xc(%rdi), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
leal -0x1(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x2a46(%rip), %xmm1     # 0x6118
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
divsd 0x2a3c(%rip), %xmm0     # 0x6120
movsd %xmm0, 0x28(%rsp)
leaq 0x28(%rdi), %r15
xorpd %xmm2, %xmm2
leaq 0xc(%rsp), %r12
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm2, %xmm1
movsd 0x28(%rsp), %xmm0
movsd %xmm2, 0x18(%rsp)
jne 0x3711
jnp 0x3748
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
mulsd 0x20(%rsp), %xmm0
callq 0x2080
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x30(%rsp), %xmm3
mulsd 0x29dc(%rip), %xmm3     # 0x6120
divsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x376a
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%r14)
jmp 0x3781
movq %r15, %rdi
movq %r12, %rdx
callq 0x5336
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
addsd 0x299f(%rip), %xmm2     # 0x6128
decl %ebx
jne 0x36fd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::set_up_highpass(int, float)
void FIR_filter::set_up_highpass(int sample_width, float frequency_cutoff){

	filter_width = sample_width;
	sample_width--;
	
	float ncof = (2*PI*frequency_cutoff)/sample_rate;
	
	for(int n = 0; n <= sample_width; n++){
		float hd = 0.0;
		if(n != sample_width/2.0){
			hd = -1.0f*sin(ncof*(n-(sample_width/2.0)))/(PI*(n-(sample_width/2.0)));
		} else {
			hd = 1.0f-(ncof/PI);
		}
		filter_coefficents.push_back(hd);
	}

}

// Assembly:
movl %esi, 0x8(%rdi)
testl %esi, %esi
jle 0x38b6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
mulsd 0x294b(%rip), %xmm0     # 0x6110
cvtss2sd 0xc(%rdi), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
leal -0x1(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x2934(%rip), %xmm1     # 0x6118
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
divsd 0x293a(%rip), %xmm0     # 0x6130
addsd 0x292a(%rip), %xmm0     # 0x6128
movsd %xmm0, 0x28(%rsp)
leaq 0x28(%rdi), %r15
xorpd %xmm2, %xmm2
leaq 0xc(%rsp), %r12
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm2, %xmm1
movsd 0x28(%rsp), %xmm0
movsd %xmm2, 0x18(%rsp)
jne 0x382b
jnp 0x3862
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
mulsd 0x20(%rsp), %xmm0
callq 0x2080
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x30(%rsp), %xmm3
mulsd 0x28d2(%rip), %xmm3     # 0x6130
divsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x3884
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%r14)
jmp 0x389b
movq %r15, %rdi
movq %r12, %rdx
callq 0x5336
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
addsd 0x2885(%rip), %xmm2     # 0x6128
decl %ebx
jne 0x3817
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::set_up_bandpass(int, float, float)
void FIR_filter::set_up_bandpass(int sample_width, float frequency_cutoff_low, float frequency_cutoff_high){

	filter_width = sample_width;
	sample_width--;

	float ncofh = (2*PI*frequency_cutoff_high)/sample_rate;
	float ncofl = (2*PI*frequency_cutoff_low)/sample_rate;
	
	for(int n = 0; n <= sample_width; n++){
		float hd = 0;
		if(n != sample_width/2.0){
			float p1 = sin((ncofh)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			float p2 = sin((ncofl)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			hd = p1 - p2;
		} else {
			hd = (ncofh-ncofl)/PI;
		}
		filter_coefficents.push_back(hd);
	}

}

// Assembly:
movl %esi, 0x8(%rdi)
testl %esi, %esi
jle 0x3a31
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
movsd 0x2831(%rip), %xmm2     # 0x6110
mulsd %xmm2, %xmm0
cvtss2sd 0xc(%rdi), %xmm3
divsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
leal -0x1(%rbx), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
mulsd 0x2806(%rip), %xmm2     # 0x6118
xorps %xmm3, %xmm3
cvtss2sd %xmm1, %xmm3
movsd %xmm3, 0x20(%rsp)
subss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
divsd 0x27f1(%rip), %xmm1     # 0x6120
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x28(%rdi), %r15
xorps %xmm1, %xmm1
leaq 0x4(%rsp), %r12
movsd %xmm2, 0x8(%rsp)
ucomisd %xmm1, %xmm2
movss (%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
jne 0x3967
jnp 0x39e1
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x28(%rsp)
mulsd 0x20(%rsp), %xmm0
callq 0x2080
movapd %xmm0, 0x40(%rsp)
movsd 0x28(%rsp), %xmm1
movapd %xmm1, %xmm0
mulsd 0x2788(%rip), %xmm0     # 0x6120
movapd %xmm0, 0x30(%rsp)
mulsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm0
callq 0x2080
movsd 0x8(%rsp), %xmm2
movapd 0x40(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x30(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
subss %xmm1, %xmm0
movsd 0x10(%rsp), %xmm1
movss %xmm0, 0x4(%rsp)
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x39ff
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%r14)
jmp 0x3a16
movq %r15, %rdi
movq %r12, %rdx
callq 0x5336
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
addsd 0x270a(%rip), %xmm1     # 0x6128
decl %ebx
jne 0x3954
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::set_up_bandreject(int, float, float)
void FIR_filter::set_up_bandreject(int sample_width, float frequency_cutoff_low, float frequency_cutoff_high){

	filter_width = sample_width;
	sample_width--;

	float ncofh = (2*PI*frequency_cutoff_high)/sample_rate;
	float ncofl = (2*PI*frequency_cutoff_low)/sample_rate;
	
	for(int n = 0; n <= sample_width; n++){
		float hd = 0;
		if(n != sample_width/2.0){
			float p1 = sin((ncofl)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			float p2 = sin((ncofh)*(n-sample_width/2.0))/(PI*(n-sample_width/2.0));
			hd = p1 - p2;
		} else {
			hd = 1.0f-(ncofl-ncofh)/PI;
		}
		filter_coefficents.push_back(hd);
	}

}

// Assembly:
movl %esi, 0x8(%rdi)
testl %esi, %esi
jle 0x3bb6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
movsd 0x26b7(%rip), %xmm2     # 0x6110
mulsd %xmm2, %xmm0
cvtss2sd 0xc(%rdi), %xmm3
divsd %xmm3, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
leal -0x1(%rbx), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
mulsd 0x268c(%rip), %xmm2     # 0x6118
xorps %xmm3, %xmm3
cvtss2sd %xmm0, %xmm3
movsd %xmm3, 0x20(%rsp)
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x2687(%rip), %xmm0     # 0x6130
addsd 0x2677(%rip), %xmm0     # 0x6128
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x28(%rdi), %r15
xorps %xmm1, %xmm1
leaq 0x4(%rsp), %r12
movsd %xmm2, 0x8(%rsp)
ucomisd %xmm1, %xmm2
movss (%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
jne 0x3aec
jnp 0x3b66
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x28(%rsp)
mulsd 0x20(%rsp), %xmm0
callq 0x2080
movapd %xmm0, 0x40(%rsp)
movsd 0x28(%rsp), %xmm1
movapd %xmm1, %xmm0
mulsd 0x2603(%rip), %xmm0     # 0x6120
movapd %xmm0, 0x30(%rsp)
mulsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm0
callq 0x2080
movsd 0x8(%rsp), %xmm2
movapd 0x40(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x30(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
subss %xmm1, %xmm0
movsd 0x10(%rsp), %xmm1
movss %xmm0, 0x4(%rsp)
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x3b84
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%r14)
jmp 0x3b9b
movq %r15, %rdi
movq %r12, %rdx
callq 0x5336
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
addsd 0x2585(%rip), %xmm1     # 0x6128
decl %ebx
jne 0x3ad9
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::readUInt16(std::istream&)
uint16_t util::readUInt16(std::istream &in){
	uint16_t tmp16int = 0;
	unsigned char tmp;
	for(int i = 0; i < 2; i++){
		in >> tmp;
		tmp16int += uint16_t(tmp * pow(0x100, i));
	}
	return tmp16int;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movb $0x1, %r15b
xorl %ebp, %ebp
leaq 0x7(%rsp), %r14
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movzbl 0x7(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x21b0
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %eax
addl %eax, %ebp
movsd 0xb8c(%rip), %xmm0      # 0x6160
testb $0x1, %r15b
movl $0x0, %r15d
jne 0x5592
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/util/Util.cpp
// Function: util::readUInt32(std::istream&)
uint32_t util::readUInt32(std::istream &in){
        uint32_t tmp32int = 0;
        unsigned char tmp;
        for(int i = 0; i < 4; i++){
                in >> tmp;
                tmp32int += uint32_t(tmp * pow(0x100, i));
        }
	return tmp32int;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xf(%rsp), %r14
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movzbl 0xf(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
callq 0x21b0
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %rax
addl %eax, %ebp
addl $0x8, %r15d
cmpl $0x20, %r15d
jne 0x5605
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop