LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: abort_beh
BEH_DECL(abort_beh)
{
	char* s = cons_to_str(WHAT);

	DBUG_ENTER("abort_beh");
	DBUG_PRINT("", ("ABORT! %s", s));
	fprintf(stderr, "ABORT! %s\n", s);
	abort();
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, %rdi
callq 0x14080
movq %rax, -0x10(%rbp)
leaq 0x1dc98(%rip), %rax     # 0x20004
movq %rax, -0x38(%rbp)
leaq 0x23f99(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x5e, -0x2c(%rbp)
leaq 0x207fa(%rip), %rax     # 0x22b8c
movq %rax, -0x28(%rbp)
leaq 0x23d93(%rip), %rax     # 0x26130
movq %rax, -0x20(%rbp)
leaq 0x23f68(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1f2c0
leaq 0x2451d(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0x2419
leaq 0x23f41(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x207af(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x207a4(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0x2419
leaq 0x23f17(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x5f, 0xc(%rax)
movq -0x10(%rbp), %rsi
leaq 0x1dbfc(%rip), %rdi     # 0x2000e
movb $0x0, %al
callq 0x1f370
jmp 0x241b
movq 0x23bd6(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1dbe8(%rip), %rsi     # 0x20018
movb $0x0, %al
callq 0x2160
callq 0x2050
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: println_beh
BEH_DECL(println_beh)
{
	DBUG_ENTER("println_beh");
	DBUG_PRINT("", ("WHAT = %s", cons_to_str(WHAT)));
	if (!nilp(MINE)) {
		printf("%s ", cons_to_str(MINE));
	}
	printf("%s\n", cons_to_str(WHAT));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1dbd0(%rip), %rax     # 0x20023
movq %rax, -0x30(%rbp)
leaq 0x23eb2(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x67, -0x24(%rbp)
leaq 0x20713(%rip), %rax     # 0x22b8c
movq %rax, -0x20(%rbp)
leaq 0x23cac(%rip), %rax     # 0x26130
movq %rax, -0x18(%rbp)
leaq 0x23e81(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f2c0
leaq 0x24436(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0x2514
leaq 0x23e5a(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x206c8(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x206bd(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0x2514
leaq 0x23e30(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x68, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x1db22(%rip), %rdi     # 0x2002f
movb $0x0, %al
callq 0x1f370
jmp 0x2516
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
leaq 0x23d4e(%rip), %rcx     # 0x26280
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x2573
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x1dacd(%rip), %rdi     # 0x20039
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x1e957(%rip), %rdi     # 0x20ee9
movb $0x0, %al
callq 0x20d0
movl $0x6d, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f490
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: one_shot_beh
BEH_DECL(one_shot_beh)
{
	DBUG_ENTER("one_shot_beh");
	SEND(MINE, WHAT);
	BECOME(sink_beh, NIL);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1da7a(%rip), %rax     # 0x2003d
movq %rax, -0x30(%rbp)
leaq 0x23d42(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x7b, -0x24(%rbp)
leaq 0x205a3(%rip), %rax     # 0x22b8c
movq %rax, -0x20(%rbp)
leaq 0x23b3c(%rip), %rax     # 0x26130
movq %rax, -0x18(%rbp)
leaq 0x23d11(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f2c0
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x12640
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
leaq 0xee38(%rip), %rsi      # 0x114a0
leaq 0x23c11(%rip), %rdx     # 0x26280
callq 0x11910
movl $0x7e, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f490
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: label_beh
BEH_DECL(label_beh)
{
	CONS* to = pr_head(MINE);
	CONS* label = pr_tail(MINE);
	CONS* value = WHAT;

	DBUG_ENTER("label_beh");
	SEND(to, mk_pair(label, value));
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c1b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c340
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, -0x20(%rbp)
leaq 0x1d954(%rip), %rax     # 0x2004a
movq %rax, -0x48(%rbp)
leaq 0x23c0f(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x8d, -0x3c(%rbp)
leaq 0x20470(%rip), %rax     # 0x22b8c
movq %rax, -0x38(%rbp)
leaq 0x23a09(%rip), %rax     # 0x26130
movq %rax, -0x30(%rbp)
leaq 0x23bde(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1f2c0
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c0c0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x12640
movl $0x8f, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1f490
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: command_beh
BEH_DECL(command_beh)
{
	DBUG_ENTER("command_beh");
	if (actorp(WHAT)) {
		SEND(WHAT, MINE);
	} else {
		DBUG_PRINT("", ("Ignored! %s", cons_to_str(WHAT)));
		abort();
	}
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1d8b1(%rip), %rax     # 0x20054
movq %rax, -0x30(%rbp)
leaq 0x23b62(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x9a, -0x24(%rbp)
leaq 0x203c3(%rip), %rax     # 0x22b8c
movq %rax, -0x20(%rbp)
leaq 0x2395c(%rip), %rax     # 0x26130
movq %rax, -0x18(%rbp)
leaq 0x23b31(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f2c0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
andq $0x3, %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2858
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x12640
jmp 0x28d2
jmp 0x285a
leaq 0x2407f(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0x28cb
leaq 0x23aa3(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x20311(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x20306(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0x28cb
leaq 0x23a79(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x9e, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x1d79c(%rip), %rdi     # 0x20060
movb $0x0, %al
callq 0x1f370
jmp 0x28cd
callq 0x2050
movl $0xa1, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f490
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: boolean
static CONS*
boolean(BOOL p)
{
	if (true__value == false__value) {
		true__value = ATOM("#t");
		false__value = ATOM("#f");
		assert(true__value != false__value);
	}
	return (p ? true__value : false__value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2201d(%rip), %rax     # 0x26380
cmpq 0x2201e(%rip), %rax     # 0x26388
jne 0x43c5
leaq 0x1c2c5(%rip), %rdi     # 0x20638
callq 0x18510
movq %rax, 0x22001(%rip)     # 0x26380
leaq 0x1c2b5(%rip), %rdi     # 0x2063b
callq 0x18510
movq %rax, 0x21ff6(%rip)     # 0x26388
movq 0x21fe7(%rip), %rax     # 0x26380
cmpq 0x21fe8(%rip), %rax     # 0x26388
je 0x43a4
jmp 0x43c3
leaq 0x1c9ad(%rip), %rdi     # 0x20d58
leaq 0x1c009(%rip), %rsi     # 0x203bb
movl $0x44, %edx
leaq 0x1c9b6(%rip), %rcx     # 0x20d74
callq 0x20f0
jmp 0x43c5
cmpq $0x0, -0x8(%rbp)
je 0x43d9
movq 0x21fad(%rip), %rax     # 0x26380
movq %rax, -0x10(%rbp)
jmp 0x43e4
movq 0x21fa8(%rip), %rax     # 0x26388
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: apply_form_beh
BEH_DECL(apply_form_beh)
{
	CONS* expr = WHAT;
	CONS* to = pr_head(MINE);
	CONS* env = pr_tail(MINE);
	CONS* msg;

	DBUG_ENTER("apply_form_beh");
	DBUG_PRINT("", ("expr = %s", cons_to_str(expr)));
	msg = mk_pair(expr, env);
	msg = mk_pair(to, msg);
	SEND(eval__actor, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c1b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c340
movq %rax, -0x20(%rbp)
leaq 0x1b6bf(%rip), %rax     # 0x201d5
movq %rax, -0x50(%rbp)
leaq 0x217ef(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x221, -0x44(%rbp)     # imm = 0x221
leaq 0x1e050(%rip), %rax     # 0x22b8c
movq %rax, -0x40(%rbp)
leaq 0x215e9(%rip), %rax     # 0x26130
movq %rax, -0x38(%rbp)
leaq 0x217be(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1f2c0
leaq 0x21d73(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0x4bcb
leaq 0x21797(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1e005(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x1dffa(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0x4bcb
leaq 0x2176d(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x222, 0xc(%rax)       # imm = 0x222
movq -0x10(%rbp), %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x1b528(%rip), %rdi     # 0x200ec
movb $0x0, %al
callq 0x1f370
jmp 0x4bcd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c0c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c0c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq 0x2176e(%rip), %rsi     # 0x26368
movq -0x28(%rbp), %rdx
callq 0x12640
movl $0x226, -0x44(%rbp)     # imm = 0x226
leaq -0x50(%rbp), %rdi
callq 0x1f490
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dalnefre[P]kernel_abe/schemer.c
// Function: have_n_args
static BOOL
have_n_args(int n, CONS* args)
{
	while (!is_empty(args)) {
		if (!is_pair(args)) {
			return FALSE;
		}
		args = pr_tail(args);
		--n;
	}
	return ((n == 0) ? TRUE : FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x203aa(%rip), %rax     # 0x26280
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5ef3
jmp 0x5f61
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x5f11
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5f3c
leaq 0x20358(%rip), %rax     # 0x26280
cmpq %rax, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5f46
movq $0x0, -0x8(%rbp)
jmp 0x5f76
movq -0x18(%rbp), %rdi
callq 0x1c340
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5ecf
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmoveq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c1b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c340
movq %rax, -0x20(%rbp)
leaq 0x174dd(%rip), %rax     # 0x20303
movq %rax, -0x48(%rbp)
leaq 0x1d4df(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x4d0, -0x3c(%rbp)     # imm = 0x4D0
leaq 0x19d40(%rip), %rax     # 0x22b8c
movq %rax, -0x38(%rbp)
leaq 0x1d2d9(%rip), %rax     # 0x26130
movq %rax, -0x30(%rbp)
leaq 0x1d4ae(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1f2c0
leaq 0x1da63(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0x8edb
leaq 0x1d487(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x19cf5(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x19cea(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0x8edb
leaq 0x1d45d(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x4d1, 0xc(%rax)       # imm = 0x4D1
movq -0x10(%rbp), %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x171d0(%rip), %rdi     # 0x200a4
movb $0x0, %al
callq 0x1f370
jmp 0x8edd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12640
movl $0x4d3, -0x3c(%rbp)     # imm = 0x4D3
leaq -0x48(%rbp), %rdi
callq 0x1f490
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c1b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c340
movq %rax, -0x20(%rbp)
leaq 0x16ec7(%rip), %rax     # 0x2031d
movq %rax, -0x48(%rbp)
leaq 0x1ceaf(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x524, -0x3c(%rbp)     # imm = 0x524
leaq 0x19710(%rip), %rax     # 0x22b8c
movq %rax, -0x38(%rbp)
leaq 0x1cca9(%rip), %rax     # 0x26130
movq %rax, -0x30(%rbp)
leaq 0x1ce7e(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1f2c0
leaq 0x1d433(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0x950b
leaq 0x1ce57(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x196c5(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x196ba(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0x950b
leaq 0x1ce2d(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x525, 0xc(%rax)       # imm = 0x525
movq -0x10(%rbp), %rdi
callq 0x14080
movq %rax, %rsi
leaq 0x16ba0(%rip), %rdi     # 0x200a4
movb $0x0, %al
callq 0x1f370
jmp 0x950d
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x4350
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jne 0x954d
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c1b0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x12640
jmp 0x955e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12640
movl $0x52b, -0x3c(%rbp)     # imm = 0x52B
leaq -0x48(%rbp), %rdi
callq 0x1f490
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c1b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c1b0
movq %rax, %rdi
callq 0x11430
movq %rax, %rdi
callq 0x1c340
movq %rax, -0x18(%rbp)
leaq 0x1616e(%rip), %rax     # 0x20353
movq %rax, -0x40(%rbp)
leaq 0x1c120(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x5dd, -0x34(%rbp)     # imm = 0x5DD
leaq 0x18981(%rip), %rax     # 0x22b8c
movq %rax, -0x30(%rbp)
leaq 0x1bf1a(%rip), %rax     # 0x26130
movq %rax, -0x28(%rbp)
leaq 0x1c0ef(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f2c0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1c340
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x4350
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0xa2ec
jmp 0xa261
leaq 0x1c678(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0xa2ba
leaq 0x1c09c(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1890a(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x188ff(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0xa2ba
leaq 0x1c072(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x5df, 0xc(%rax)       # imm = 0x5DF
leaq 0x160af(%rip), %rdi     # 0x20362
movb $0x0, %al
callq 0x1f370
jmp 0xa2bc
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c1b0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c340
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x12640
jmp 0xa35d
jmp 0xa2ee
leaq 0x1c5eb(%rip), %rax     # 0x268e0
cmpl $0x0, (%rax)
je 0xa347
leaq 0x1c00f(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
leaq 0x1887d(%rip), %rcx     # 0x22b8c
movq %rcx, 0x10(%rax)
leaq 0x18872(%rip), %rdi     # 0x22b8c
callq 0x1e6d0
cmpl $0x0, %eax
je 0xa347
leaq 0x1bfe5(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl $0x5e2, 0xc(%rax)       # imm = 0x5E2
leaq 0x16028(%rip), %rdi     # 0x20368
movb $0x0, %al
callq 0x1f370
jmp 0xa349
movq -0x8(%rbp), %rdi
movq 0x1c004(%rip), %rsi     # 0x26358
movq -0x18(%rbp), %rdx
callq 0x12640
movl $0x5e5, -0x34(%rbp)     # imm = 0x5E5
leaq -0x40(%rbp), %rdi
callq 0x1f490
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16220
movq %rax, -0x20(%rbp)
leaq 0x100ad(%rip), %rdi     # 0x20e05
callq 0x18510
movq %rax, %rsi
movq -0x20(%rbp), %rdx
leaq 0x15515(%rip), %rdi     # 0x26280
callq 0x1cc50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x91d(%rip), %rsi       # 0x116a0
callq 0x12520
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10daa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xf080
cmpq $0x0, %rax
jne 0x10dcf
movq 0x15247(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x10049(%rip), %rsi     # 0x20e0c
movb $0x0, %al
callq 0x2160
callq 0x2050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xfb8f(%rip), %rax      # 0x20e2d
movq %rax, -0x448(%rbp)
leaq 0x15064(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x440(%rbp)
movl $0xa10, -0x43c(%rbp)    # imm = 0xA10
leaq 0x118bf(%rip), %rax     # 0x22b8c
movq %rax, -0x438(%rbp)
leaq 0x14e55(%rip), %rax     # 0x26130
movq %rax, -0x430(%rbp)
leaq 0x15027(%rip), %rax     # 0x26310
movq (%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x428(%rbp)
leaq -0x448(%rbp), %rdi
callq 0x1f2c0
leaq -0x420(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2130
cmpq $0x0, %rax
je 0x1133c
movq -0x8(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf080
cmpq $0x0, %rax
jne 0x1133a
jmp 0x1133c
jmp 0x11303
movl $0xa16, -0x43c(%rbp)    # imm = 0xA16
leaq -0x448(%rbp), %rdi
callq 0x1f490
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpq $0x0, 0x1500c(%rip)     # 0x26378
jne 0x113ae
leaq 0xf2c1(%rip), %rdi      # 0x20636
callq 0x18510
movq %rax, 0x14ff7(%rip)     # 0x26378
cmpq $0x0, 0x14fef(%rip)     # 0x26378
je 0x1138d
jmp 0x113ac
leaq 0xf999(%rip), %rdi      # 0x20d2d
leaq 0xf020(%rip), %rsi      # 0x203bb
movl $0x36, %edx
leaq 0xf99f(%rip), %rcx      # 0x20d46
callq 0x20f0
jmp 0x113ae
movq 0x14fc3(%rip), %rax     # 0x26378
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eitijupaenoithoowohd[P]TBezierInterpolation/TBezierInterpolation.c
// Function: SegmentCalc
void SegmentCalc(Segment *seg,double t, Point2D *p)
{
	double t2 = t * t;
	double t3 = t2 * t;
	double nt = 1.0 - t;
	double nt2 = nt * nt;
	double nt3 = nt2 * nt;
	p->x = nt3 * seg->points[0].x + 3.0 * t * nt2 * seg->points[1].x + 3.0 * t2 * nt * seg->points[2].x + t3 * seg->points[3].x;
	p->y = nt3 * seg->points[0].y + 3.0 * t * nt2 * seg->points[1].y + 3.0 * t2 * nt * seg->points[2].y + t3 * seg->points[3].y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xcf9(%rip), %xmm0      # 0x2010
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd (%rax), %xmm2
movsd 0xcb4(%rip), %xmm1      # 0x2008
mulsd -0x10(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xc91(%rip), %xmm1      # 0x2008
mulsd -0x20(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd 0x30(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm2
movsd 0xc42(%rip), %xmm1      # 0x2008
mulsd -0x10(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
movq -0x8(%rbp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xc1f(%rip), %xmm1      # 0x2008
mulsd -0x20(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd 0x38(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eitijupaenoithoowohd[P]TBezierInterpolation/TBezierInterpolation.c
// Function: main
int main()
{

	Point2D values[POINTS_LEN] = {
		{0.0, 0.0},
		{20.0, 0.0},
		{45.0, -47.0},
		{53.0, 335.0},
		{57.0, 26.0},
		{62.0, 387.0},
		{74.0, 104.0},
		{89.0, 0.0},
		{95.0, 100.0},
		{100.0, 0.0}
	};

	Segment spline[100];

	Point2D p = {0.0,0.0};

	CalculateSpline(values,POINTS_LEN, spline);

	for(int i = 0; i < POINTS_LEN - 1; i++) {
		for (int j = 0; j < RESOLUTION; j++) {
			SegmentCalc(&spline[i],(double)j / (double)RESOLUTION, &p);
			printf("%lf %lf\n", p.x, p.y);
		}
	}

	printf("%lf %lf\n", values[POINTS_LEN - 1].x,values[POINTS_LEN - 1].y);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x19d0, %rsp           # imm = 0x19D0
movl $0x0, -0x4(%rbp)
leaq -0xb0(%rbp), %rdi
leaq 0x4e0(%rip), %rsi       # 0x2040
movl $0xa0, %edx
callq 0x1050
leaq -0x19c0(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1040
leaq -0xb0(%rbp), %rdi
leaq -0x19b0(%rbp), %rdx
movl $0xa, %esi
callq 0x1430
movl $0x0, -0x19c4(%rbp)
cmpl $0x9, -0x19c4(%rbp)
jge 0x1c39
movl $0x0, -0x19c8(%rbp)
cmpl $0x20, -0x19c8(%rbp)
jge 0x1c23
movslq -0x19c4(%rbp), %rax
leaq -0x19b0(%rbp), %rdi
shlq $0x6, %rax
addq %rax, %rdi
cvtsi2sdl -0x19c8(%rbp), %xmm0
movsd 0x444(%rip), %xmm1      # 0x2028
divsd %xmm1, %xmm0
leaq -0x19c0(%rbp), %rsi
callq 0x12e0
movsd -0x19c0(%rbp), %xmm0
movsd -0x19b8(%rbp), %xmm1
leaq 0x4d5(%rip), %rdi       # 0x20e0
movb $0x2, %al
callq 0x1030
movl -0x19c8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c8(%rbp)
jmp 0x1bb6
jmp 0x1c25
movl -0x19c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c4(%rbp)
jmp 0x1b9f
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq 0x496(%rip), %rdi       # 0x20e0
movb $0x2, %al
callq 0x1030
xorl %eax, %eax
addq $0x19d0, %rsp           # imm = 0x19D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1190
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x158e
jmp 0x15ad
leaq 0x1a6f(%rip), %rdi      # 0x3004
leaq 0x1a6f(%rip), %rsi      # 0x300b
movl $0x31, %edx
leaq 0x1a7a(%rip), %rcx      # 0x3022
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x298(%rip), %rax      # 0x1320
cmpq (%rcx), %rax
jne 0x15bf
jmp 0x15de
leaq 0x1a80(%rip), %rdi      # 0x3046
leaq 0x1a3e(%rip), %rsi      # 0x300b
movl $0x32, %edx
leaq 0x1a49(%rip), %rcx      # 0x3022
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x289(%rip), %rax      # 0x1360
cmpq 0x8(%rcx), %rax
jne 0x15f1
jmp 0x1610
leaq 0x1a70(%rip), %rdi      # 0x3068
leaq 0x1a0c(%rip), %rsi      # 0x300b
movl $0x33, %edx
leaq 0x1a17(%rip), %rcx      # 0x3022
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x1eb(%rip), %rax      # 0x1430
cmpq 0x10(%rcx), %rax
jne 0x1623
jmp 0x1642
leaq 0x1a56(%rip), %rdi      # 0x3080
leaq 0x19da(%rip), %rsi      # 0x300b
movl $0x34, %edx
leaq 0x19e5(%rip), %rcx      # 0x3022
callq 0x1040
movq -0x8(%rbp), %rcx
leaq -0x19d(%rip), %rax      # 0x14b0
cmpq 0x18(%rcx), %rax
jne 0x1655
jmp 0x1674
leaq 0x1a3c(%rip), %rdi      # 0x3098
leaq 0x19a8(%rip), %rsi      # 0x300b
movl $0x35, %edx
leaq 0x19b3(%rip), %rcx      # 0x3022
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
movq 0x3953(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1a1b(%rip), %rsi      # 0x30b2
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vidarr[P]ringbuffer/test/ringbuffer_test.c
// Function: count_free
void count_free(void* int_pointer, void* count) {

    int* ip = (int*) int_pointer;
    free(ip);
    size_t* c = (size_t*) count;
    *c = *c + 1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x19d0
movb $0x0, %al
callq 0x1a90
movb $0x0, %al
callq 0x1b80
movb $0x0, %al
callq 0x1e60
callq 0x1560
callq 0x1700
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x424(%rbp)
cmpl $0x0, -0x424(%rbp)
je 0x134f
movl -0x424(%rbp), %eax
cmpq $0x400, %rax            # imm = 0x400
jb 0x1276
movl $0x400, -0x428(%rbp)    # imm = 0x400
jmp 0x1282
movl -0x424(%rbp), %eax
movl %eax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
movl -0x428(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1060
movl %eax, -0x42c(%rbp)
movl -0x42c(%rbp), %eax
cmpl -0x428(%rbp), %eax
je 0x12e2
movl -0x42c(%rbp), %esi
movl -0x428(%rbp), %edx
leaq 0xdda(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x1090
leaq 0xdee(%rip), %rdi       # 0x20c2
callq 0x1100
movl $0x0, -0x4(%rbp)
jmp 0x1356
leaq -0x420(%rbp), %rdi
movl -0x42c(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1120
movl %eax, -0x430(%rbp)
movl -0x430(%rbp), %eax
cmpl -0x42c(%rbp), %eax
je 0x1336
movl -0x430(%rbp), %esi
movl -0x42c(%rbp), %edx
leaq 0xda7(%rip), %rdi       # 0x20cd
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
jmp 0x1356
movl -0x42c(%rbp), %ecx
movl -0x424(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x424(%rbp)
jmp 0x124f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/pss-demux.c
// Function: mpegDumpVideoStream
void mpegDumpVideoStream( FILE *f, unsigned int offset, FILE *o ) {
	fseek( f, offset, SEEK_SET );
	uint32_t streamSize, headSize;
	mpegPesHeader pesHead;
	mpegPrivate1ExtensionHead extHead;
	fread( &pesHead, sizeof(pesHead), 1, f );
	headSize = pesHead.size[0] << 8 | pesHead.size[1];
	fread( &extHead, sizeof(extHead), 1, f );
	fseek( f, extHead.size, SEEK_CUR );
	streamSize = headSize - 3 - extHead.size; // subtract 3 for extHead size that is included in pesHead but not extHead
	writeFile( f, streamSize, o );
	fseek( f, offset+headSize+6, SEEK_SET );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10e0
movq -0x8(%rbp), %rcx
leaq -0x26(%rbp), %rdi
movl $0x6, %esi
movl $0x1, %edx
callq 0x1060
movzbl -0x22(%rbp), %eax
shll $0x8, %eax
movzbl -0x21(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x29(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x1060
movq -0x8(%rbp), %rdi
movzbl -0x27(%rbp), %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x10e0
movl -0x20(%rbp), %eax
subl $0x3, %eax
movzbl -0x27(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1230
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl -0x20(%rbp), %eax
addl $0x6, %eax
movl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb $0x20, 0x7(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x1040
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xe(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x11(%rax)
movb 0x292f(%rip), %cl       # 0x40c3
movq -0x8(%rbp), %rax
movb %cl, 0x12(%rax)
movb 0x2923(%rip), %cl       # 0x40c4
movq -0x8(%rbp), %rax
movb %cl, 0x13(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x10a0
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x10a0
movzbl 0x28ee(%rip), %eax      # 0x40c5
cmpl $0x1, %eax
jne 0x17f3
movq -0x8(%rbp), %rdi
leaq 0x932(%rip), %rsi       # 0x2119
movl $0x4, %edx
callq 0x1040
jmp 0x1816
movzbl 0x28cb(%rip), %eax      # 0x40c5
cmpl $0x2, %eax
jne 0x1814
movq -0x8(%rbp), %rdi
leaq 0x914(%rip), %rsi       # 0x211e
movl $0x4, %edx
callq 0x1040
jmp 0x1816
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/pss-demux.c
// Function: vagWriteHeader
void vagWriteHeader( vagHeader header, FILE *o ) {
	fwrite( header.magic, 4, 1, o );
	fwrite( header.version, 4, 1, o );
	fwrite( header.reserved1, 4, 1, o );
	fwrite( header.size, 4, 1, o );
	fwrite( header.samplerate, 4, 1, o );
	fwrite( header.reserved2, 12, 1, o );
	fwrite( header.name, 0x10, 1, o );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
addq $0x14, %rdi
movq -0x8(%rbp), %rcx
movl $0xc, %esi
movl $0x1, %edx
callq 0x1120
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rcx
movl $0x10, %esi
movl $0x1, %edx
callq 0x1120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/ascon128v11/ref/ascon.c
// Function: load64
void load64(u64* x, u8* S) {
  int i;
  *x = 0;
  for (i = 0; i < 8; ++i)
    *x |= ((u64) S[i]) << (56 - i * 8);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, -0x14(%rsp)
cmpl $0x8, -0x14(%rsp)
jge 0x1221
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl -0x14(%rsp), %edx
shll $0x3, %edx
movl $0x38, %ecx
subl %edx, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x11de
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/filter/FIR_filter.cpp
// Function: FIR_filter::proccess_byte(char)
bool FIR_filter::proccess_byte(char byte){

	filter_buffer.push_back(byte);

	if(filter_buffer.size() >= filter_coefficents.size()){

		float result = 0.0f;

		int n = filter_coefficents.size()-1;
		for(std::list<char>::iterator it = filter_buffer.begin(); it != filter_buffer.end(); it++){
			result += (*it)*filter_coefficents[n];
			n--;
		}

		output_buffer.push_back(result);

		filter_buffer.pop_front();

		return true;

	}

	return false;

}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x48(%rsp)
movb %al, 0x47(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
leaq 0x47(%rsp), %rsi
callq 0x6fb0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x6ff0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
callq 0x7020
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0x56c5
movq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, 0x40(%rsp)
addq $0x28, %rdi
callq 0x7020
movq 0x10(%rsp), %rdi
subq $0x1, %rax
movl %eax, 0x3c(%rsp)
addq $0x10, %rdi
callq 0x7040
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x7090
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7070
testb $0x1, %al
jne 0x5634
jmp 0x569d
leaq 0x30(%rsp), %rdi
callq 0x70c0
movq 0x10(%rsp), %rdi
movsbl (%rax), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xc(%rsp)
addq $0x28, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x70e0
movss 0xc(%rsp), %xmm0
movss (%rax), %xmm2
movss 0x40(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x3c(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x7100
movq %rax, 0x20(%rsp)
jmp 0x560c
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
leaq 0x40(%rsp), %rsi
callq 0x7130
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x7170
movb $0x1, 0x57(%rsp)
jmp 0x56ca
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rsp)
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x49a8(%rip), %xmm0     # 0xa108
mulsd %xmm1, %xmm0
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x5865
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
cvtsi2sdl 0x10(%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm1
movsd 0x4962(%rip), %xmm2     # 0xa110
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jne 0x57bc
jp 0x57bc
jmp 0x5823
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
cvtsi2sdl 0x1c(%rsp), %xmm2
movsd 0x4936(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x30b0
cvtsi2sdl 0x10(%rsp), %xmm2
cvtsi2sdl 0x1c(%rsp), %xmm1
movsd 0x4911(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd 0x4909(%rip), %xmm1     # 0xa118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x5843
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x48e3(%rip), %xmm1     # 0xa118
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x28, %rdi
leaq 0xc(%rsp), %rsi
callq 0x7200
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5783
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rsp)
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4858(%rip), %xmm0     # 0xa108
mulsd %xmm1, %xmm0
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x59d0
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
cvtsi2sdl 0x10(%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm1
movsd 0x4812(%rip), %xmm2     # 0xa110
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jne 0x590c
jp 0x590c
jmp 0x5982
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
cvtsi2sdl 0x1c(%rsp), %xmm2
movsd 0x47e6(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x30b0
movaps %xmm0, %xmm1
movsd 0x47e2(%rip), %xmm0     # 0xa128
mulsd %xmm1, %xmm0
cvtsi2sdl 0x10(%rsp), %xmm2
cvtsi2sdl 0x1c(%rsp), %xmm1
movsd 0x47b2(%rip), %xmm3     # 0xa110
divsd %xmm3, %xmm1
subsd %xmm1, %xmm2
movsd 0x47aa(%rip), %xmm1     # 0xa118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x59ae
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x4784(%rip), %xmm0     # 0xa118
divsd %xmm0, %xmm1
movsd 0x4780(%rip), %xmm0     # 0xa120
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rsp), %rdi
addq $0x28, %rdi
leaq 0xc(%rsp), %rsi
callq 0x7200
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x58d3
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)