LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dalnefre[P]kernel_abe/life.c
// Function: main
int
main(int argc, char** argv)
{
	int c;
	int counter = 35;

	DBUG_ENTER("main");
	DBUG_PROCESS(argv[0]);
	while ((c = getopt(argc, argv, "n:#:V")) != EOF) {
		switch(c) {
		case 'n':	counter = atoi(optarg);	break;
		case '#':	DBUG_PUSH(optarg);		break;
		case 'V':	banner();				exit(EXIT_SUCCESS);
		case '?':							usage();
		default:							usage();
		}
	}
	banner();

	test_life(counter);	/* this test involves running the dispatch loop */

	report_cons_stats();
	DBUG_RETURN (exit(EXIT_SUCCESS), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xa541(%rip), %rax      # 0xe227
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0xf705(%rip), %r12      # 0x133f8
movq (%r12), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x1c2, 0xc(%rdi)       # imm = 0x1C2
leaq 0xc0f5(%rip), %rcx      # 0xfe04
movq %rcx, 0x10(%rdi)
leaq 0xf516(%rip), %rcx      # 0x13230
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0xdb0e
movq (%r12), %rax
movq 0x18(%rax), %rcx
movq 0xf2c2(%rip), %rdx      # 0x12ff8
testq %rcx, %rcx
jne 0x3d3e
movq (%rdx), %rcx
movq %rcx, 0x18(%rax)
callq 0x20c0
movq (%r12), %rcx
movl %eax, 0x10(%rcx)
movq (%rbx), %rax
movq %rax, 0x8(%rcx)
movl $0x23, %r14d
leaq 0xa4ca(%rip), %r15      # 0xe22c
movq 0xf26f(%rip), %r13      # 0x12fd8
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21c0
cmpl $0x23, %eax
jne 0x3d95
movq (%r12), %rax
movq 0x50(%rax), %rax
movl $0x1c7, 0xc(%rax)       # imm = 0x1C7
movq (%r13), %rdi
callq 0xd3cd
jmp 0x3d69
cmpl $0x6d, %eax
jle 0x3dad
cmpl $0x6e, %eax
jne 0x3dc3
movq (%r13), %rdi
callq 0x21e0
movl %eax, %r14d
jmp 0x3d69
cmpl $-0x1, %eax
je 0x3dec
cmpl $0x3f, %eax
je 0x3dc3
cmpl $0x56, %eax
jne 0x3dc3
callq 0x3ca9
jmp 0x3e0d
movq 0xf22e(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0xa425(%rip), %rsi      # 0xe1f9
leaq 0xf465(%rip), %rdx      # 0x13240
xorl %eax, %eax
callq 0x2170
movl $0x1, %edi
callq 0x2200
callq 0x3ca9
movl %r14d, %edi
callq 0x3ba5
callq 0x3c6f
movq %rsp, %rdi
movl $0x1d2, 0xc(%rdi)       # imm = 0x1D2
callq 0xdc93
xorl %edi, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O3/aparrish[P]rwet-examples-c/cat.c
// Function: main
int main() {
	char* line = NULL;
	int len = 0;
	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);
		printf("%s", line);
		free(line);
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
movq 0x2e3b(%rip), %r15      # 0x3fe0
movq (%r15), %rdi
callq 0x1050
testl %eax, %eax
jne 0x11ed
leaq 0x8(%rsp), %rbx
leaq 0xe47(%rip), %r14       # 0x2004
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x11fc
movq 0x8(%rsp), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq 0x8(%rsp), %rdi
callq 0x1030
movq (%r15), %rdi
callq 0x1050
testl %eax, %eax
je 0x11bd
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: new_trie
static Node *new_trie(int degree, int *nkeys) {
    Node *root = new_node(0, degree);
    /* Create nodes for single pixels. */
    for (*nkeys = 0; *nkeys < degree; (*nkeys)++)
        root->children[*nkeys] = new_node(*nkeys, degree);
    *nkeys += 2; /* skip clear code and stop code */
    return root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movslq %edi, %r12
leaq 0x8(,%r12,8), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x20f0
movq %rax, %r14
testl %r12d, %r12d
jle 0x292c
movl %ebp, %r12d
xorl %r13d, %r13d
movl $0x1, %edi
movq %r15, %rsi
callq 0x20f0
testq %rax, %rax
je 0x291a
movw %r13w, (%rax)
movq %rax, 0x8(%r14,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x2904
addl $0x2, %ebp
jmp 0x2931
movl $0x2, %ebp
movl %ebp, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yahya-tamur[P]Visualising-Complex-Functions/params.cc
// Function: function(std::complex<long double>)
std::complex<long double> function(std::complex<long double> z) {
    std::complex<long double> ans = 0;
    for (long double i = 0; i < 100; i += 1) {
        ans += std::pow(std::complex<long double>(i, 0), -z);
    }
    return ans;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
fldt 0xe0(%rsp)
fchs
fstpt 0x5c(%rsp)
fldt 0xf0(%rsp)
fchs
fstpt 0x50(%rsp)
fldz
movl $0x64, %ebp
fld %st(0)
fld %st(1)
fld %st(1)
fstpt 0x68(%rsp)
fxch %st(2)
fstpt 0x44(%rsp)
fxch %st(1)
fstpt 0x74(%rsp)
fstpt 0xa0(%rsp)
fldz
fstpt 0xb0(%rsp)
fldt 0x5c(%rsp)
fstpt 0x80(%rsp)
fldt 0x50(%rsp)
fstpt 0x90(%rsp)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps 0xa0(%rsp), %xmm0
movaps 0xb0(%rsp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x21e0
fldt 0x68(%rsp)
fldt 0x74(%rsp)
faddp %st, %st(2)
fldt 0x44(%rsp)
faddp %st, %st(3)
fxch %st(2)
fstpt 0x44(%rsp)
fldt 0x44(%rsp)
fld1
faddp %st, %st(3)
decl %ebp
fxch %st(2)
fxch %st(1)
jne 0x35c5
fstp %st(1)
fstpt (%rbx)
fstpt 0x10(%rbx)
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aparrish[P]rwet-examples-c/ut_string_helpers.c
// Function: split_new
UT_array* split_new(const char* src, const char* delimiter) {
	char* src_copy;
	char* word;
	UT_array* tokens;

	utarray_new(tokens, &ut_str_icd);

	/* don't modify original string */
	src_copy = (char*)malloc(strlen(src)+1);
	strcpy(src_copy, src);
	if (src_copy == NULL) return NULL;

	word = strtok(src_copy, delimiter);
	while (word != NULL) {
		/* utarray_push_back copies the string */
		utarray_push_back(tokens, &word);
		word = strtok(NULL, delimiter);
	}

	free(src_copy);
	return tokens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r12
movl $0x1, %edi
movl $0x30, %esi
callq 0x1070
movq %rax, %rbx
movups 0x300b(%rip), %xmm0     # 0x4dd0
movups %xmm0, 0x8(%rax)
movups 0x3010(%rip), %xmm0     # 0x4de0
movups %xmm0, 0x18(%rax)
movq %r12, %rdi
callq 0x1050
leaq 0x1(%rax), %rdi
callq 0x10a0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x1040
testq %r15, %r15
je 0x1f07
movq %r15, %rdi
movq %r14, %rsi
callq 0x10d0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1efd
movq %r15, 0x18(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x10(%rsp)
addq $0x8, %rbx
movq %rbx, 0x20(%rsp)
xorl %edx, %edx
movl $0x8, %ebp
leaq 0x332(%rip), %rcx       # 0x216d
movl $0x8, %r13d
xorl %r14d, %r14d
xorl %ebx, %ebx
leal 0x1(%rbx), %r15d
cmpl %r14d, %r15d
jbe 0x1e8d
testl %r14d, %r14d
leal (%r14,%r14), %eax
movl %eax, %r14d
cmovel %r13d, %r14d
cmpl %r14d, %r15d
ja 0x1e4f
movl %r14d, %eax
imulq %rax, %rbp
movq %rdx, %rdi
movq %rbp, %rsi
callq 0x10c0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq %rdx, 0x28(%rax)
testq %rdx, %rdx
je 0x1f1b
movq 0x18(%rax), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rbp
movl %ebx, %edi
imulq %rbp, %rdi
testq %rcx, %rcx
movq %rdx, 0x30(%rsp)
je 0x1eb4
addq %rdx, %rdi
leaq 0x8(%rsp), %rsi
movq %rcx, %r12
callq *%rcx
jmp 0x1ec7
movq %rcx, %r12
addq %rdx, %rdi
leaq 0x8(%rsp), %rsi
movq %rbp, %rdx
callq 0x1090
xorl %edi, %edi
movq 0x28(%rsp), %rsi
callq 0x10d0
movq %rax, 0x8(%rsp)
movl %r15d, %ebx
testq %rax, %rax
movq %r12, %rcx
movq 0x30(%rsp), %rdx
jne 0x1e46
movq 0x10(%rsp), %rbx
movl %r15d, (%rbx)
movl %r14d, 0x4(%rbx)
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x1030
jmp 0x1f09
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, (%rax)
movl %r14d, 0x4(%rax)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/aparrish[P]rwet-examples-c/ut_string_helpers.c
// Function: slice_new
UT_array* slice_new(const UT_array* src, int start, int end) {

	int i = start;
	UT_array* slice = NULL;
	utarray_new(slice, &ut_str_icd);
	char** elem = NULL;

	if (end > utarray_len(src))
		end = utarray_len(src);

	for (i = start; i < end; i++) {
		elem = (char**)utarray_eltptr(src, i);
		utarray_push_back(slice, elem);
	}

	return slice;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x1070
movups 0x2e8a(%rip), %xmm0     # 0x4de0
movups %xmm0, 0x18(%rax)
movups 0x2e6f(%rip), %xmm0     # 0x4dd0
movups %xmm0, 0x8(%rax)
movl (%r14), %ecx
cmpl %ebx, %ecx
cmovbl %ecx, %ebx
movl %ebx, 0x4(%rsp)
cmpl %ebp, %ebx
jle 0x206b
movq %r14, 0x20(%rsp)
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movslq %ebp, %rbx
xorl %ecx, %ecx
movl $0x8, %eax
movq %rax, 0x10(%rsp)
leaq 0x1cb(%rip), %r8        # 0x216d
movl $0x8, %r14d
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x20(%rsp), %rax
cmpl %ebx, (%rax)
jbe 0x1fc5
movq 0x8(%rax), %rbp
imulq %rbx, %rbp
addq 0x28(%rax), %rbp
jmp 0x1fc7
xorl %ebp, %ebp
leal 0x1(%r13), %r12d
cmpl %r15d, %r12d
jbe 0x200c
testl %r15d, %r15d
leal (%r15,%r15), %eax
movl %eax, %r15d
cmovel %r14d, %r15d
cmpl %r15d, %r12d
ja 0x1fd0
movl %r15d, %eax
movq 0x10(%rsp), %rsi
imulq %rax, %rsi
movq %rcx, %rdi
callq 0x10c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
testq %rcx, %rcx
je 0x207a
movq 0x18(%rax), %r8
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movl %r13d, %edi
imulq %rdx, %rdi
testq %r8, %r8
movq %rcx, 0x30(%rsp)
movq %rdx, 0x10(%rsp)
movq %r8, 0x28(%rsp)
je 0x203a
addq %rcx, %rdi
movq %rbp, %rsi
callq *%r8
jmp 0x2045
addq %rcx, %rdi
movq %rbp, %rsi
callq 0x1090
incq %rbx
movl %r12d, %r13d
cmpl %ebx, 0x4(%rsp)
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
jne 0x1fae
movq 0x8(%rsp), %rax
movl %r12d, (%rax)
movl %r15d, 0x4(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, (%rax)
movl %r15d, 0x4(%rax)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/aparrish[P]rwet-examples-c/ut_string_helpers.c
// Function: join_new
int join_new(char** s, const UT_array* src, const char* separator) {
	int len, i, separator_len, offset, src_len;
	char** elem = NULL;

	separator_len = strlen(separator);
	src_len = utarray_len(src);

	/* calculate the size for the needed buffer (length of all strings in src,
	   plus src_len * separator_len - 1 */
	len = 0;
	for (i = 0; i < src_len; i++) {
		len += strlen(*(char**)utarray_eltptr(src, i));
	}
	len += (src_len - 1) * separator_len;

	*s = (char*)malloc(len + 1);

	/* s = char**
   * *s = char*
   * **s char */

	/* blit chars into allocated buffer */
	offset = 0;
	for (i = 0; i < src_len; i++) {
		elem = (char**)utarray_eltptr(src, i);	
		if (i < src_len - 1) {
			offset += sprintf((*s) + offset, "%s%s", *elem, separator);
		}
		else {
			sprintf((*s) + offset, "%s", *elem);
		}
	}

	return len;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdx, %rdi
callq 0x1050
movq %rax, (%rsp)
movslq (%r14), %r15
testq %r15, %r15
jle 0x20dc
movq 0x8(%r14), %rbp
movq 0x28(%r14), %r12
xorl %ebx, %ebx
movq %r15, %r13
movq (%r12), %rdi
callq 0x1050
addl %eax, %ebx
addq %rbp, %r12
decq %r13
jne 0x20c7
jmp 0x20de
xorl %ebx, %ebx
leal -0x1(%r15), %ebp
movq (%rsp), %rcx
imull %ebp, %ecx
movl %ebx, %eax
addl %ecx, %eax
movl %eax, (%rsp)
leal (%rbx,%rcx), %eax
incl %eax
movslq %eax, %rdi
callq 0x10a0
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
testl %r15d, %r15d
movq 0x10(%rsp), %r13
jle 0x215b
movl %ebp, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq 0x8(%r14), %rcx
imulq %r12, %rcx
movslq %ebx, %rdi
movq 0x8(%rsp), %rdx
addq (%rdx), %rdi
movq (%rax,%rcx), %rdx
cmpq %rbp, %r12
jae 0x214b
leaq 0xf3c(%rip), %rsi       # 0x3079
movq %r13, %rcx
xorl %eax, %eax
callq 0x10e0
addl %eax, %ebx
jmp 0x2153
movq %rdx, %rsi
callq 0x1040
incq %r12
cmpq %r12, %r15
jne 0x2116
movl (%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/unlink1.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	int i;
	tmpfiles = (char(*)[sizeof(template)])malloc(sizeof(template) * nr_tasks);
	assert(tmpfiles);

	for (i = 0; i < nr_tasks; i++) {
		strcpy(tmpfiles[i], template);
		char *tmpfile = tmpfiles[i];
		int fd = mkstemp(tmpfile);

		assert(fd >= 0);
		close(fd);
		unlink(tmpfile);
	}

	local_nr_tasks = nr_tasks;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq (,%rdi,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x21b0
movq %rax, 0xe500(%rip)      # 0x111a8
testq %rax, %rax
je 0x2d35
testq %rbx, %rbx
je 0x2d06
xorl %r15d, %r15d
movabsq $0x5858585858582e, %r12 # imm = 0x5858585858582E
movq %rbx, %r13
movq 0xe4db(%rip), %rax      # 0x111a8
leaq (%rax,%r15), %r14
movups 0x62e(%rip), %xmm0      # 0x3306
movups %xmm0, (%rax,%r15)
movq %r12, 0x10(%rax,%r15)
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
js 0x2d16
movl %eax, %edi
callq 0x2140
movq %r14, %rdi
callq 0x2080
addq $0x18, %r15
decq %r13
jne 0x2cc6
movl %ebx, 0xe4a4(%rip)      # 0x111b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x601(%rip), %rdi       # 0x331e
leaq 0x5ad(%rip), %rsi       # 0x32d1
leaq 0x5b6(%rip), %rcx       # 0x32e1
movl $0x1b, %edx
callq 0x2120
leaq 0x58c(%rip), %rdi       # 0x32c8
leaq 0x58e(%rip), %rsi       # 0x32d1
leaq 0x597(%rip), %rcx       # 0x32e1
movl $0x14, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/unlink1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char *tmpfile = tmpfiles[nr];

	while (1) {
		int fd = open(tmpfile, O_RDWR|O_CREAT, 0600);
		assert(fd >= 0);
		close(fd);
		unlink(tmpfile);

		(*iterations)++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq (%rsi,%rsi,2), %r14
shlq $0x3, %r14
addq 0xe43e(%rip), %r14      # 0x111a8
movq %r14, %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x2210
testl %eax, %eax
js 0x2d96
movl %eax, %edi
callq 0x2140
movq %r14, %rdi
callq 0x2080
incq (%rbx)
jmp 0x2d6a
leaq 0x581(%rip), %rdi       # 0x331e
leaq 0x52d(%rip), %rsi       # 0x32d1
leaq 0x57b(%rip), %rcx       # 0x3326
movl $0x2a, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/unlink1.c
// Function: testcase_cleanup
void testcase_cleanup(void)
{
	int i;
	for (i = 0; i < local_nr_tasks; i++) {
		unlink(tmpfiles[i]);
	}
	free(tmpfiles);
}

// Assembly:
cmpl $0x0, 0xe3f4(%rip)      # 0x111b0
jle 0x2df0
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0xe3da(%rip), %rdi      # 0x111a8
addq %rbx, %rdi
callq 0x2080
incq %r14
movslq 0xe3d0(%rip), %rax      # 0x111b0
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x2dc7
addq $0x8, %rsp
popq %rbx
popq %r14
movq 0xe3b1(%rip), %rdi      # 0x111a8
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./Utilities.h
// Function: safeCopyToBuffer(char*&, char const*, int&, int&)
void safeCopyToBuffer(char *&dest_root, const char *source, int &index, int &max_buffer) {
   int len = strlen(source);
   if (len == 0) return;

   while (index + len >= max_buffer) {
      int old_max = max_buffer;
      max_buffer *= 2;
      dest_root = (char *)realloc(dest_root, max_buffer * sizeof(char));

      // null terminate the new memory
      memset(&dest_root[old_max], '\0', max_buffer - old_max);
   }

   strncpy(&dest_root[index], source, len);
   index += len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rdi
callq 0x20a0
movq %rax, %r15
testl %r15d, %r15d
je 0x27f0
movq %r14, (%rsp)
movl (%rbx), %eax
leal (%rax,%r15), %ecx
movl (%r12), %r14d
movq (%r13), %rbp
cmpl %r14d, %ecx
jl 0x27db
leal (%r14,%r14), %eax
movl %eax, (%r12)
movslq %eax, %rsi
movq %rbp, %rdi
callq 0x22f0
movq %rax, %rbp
movq %rax, (%r13)
movslq %r14d, %rax
leaq (%rax,%rbp), %rdi
movl (%r12), %r14d
movl %r14d, %ecx
subl %eax, %ecx
movslq %ecx, %rdx
xorl %esi, %esi
callq 0x20f0
movl (%rbx), %eax
leal (%rax,%r15), %ecx
jmp 0x279a
movslq %eax, %rdi
addq %rbp, %rdi
movslq %r15d, %rdx
movq (%rsp), %rsi
callq 0x20d0
addl %r15d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::~OrderBook()
~OrderBook() {
      for (auto it = buy_book_map_.begin(); it != buy_book_map_.end(); ++it) {
         it->second.clearLevel();
      }
      for (auto it = sell_book_map_.begin(); it != sell_book_map_.end(); ++it) {
         it->second.clearLevel();
      }
      buy_book_map_.clear();
      sell_book_map_.clear();
      while (!orders_.empty()) {
         auto it = orders_.begin();
         delete it->second;
         orders_.erase(it);
      }
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xf0(%rdi), %r14
leaq 0xe0(%rdi), %r15
cmpq %r15, %r14
je 0x2cc0
leaq 0x28(%r14), %rdi
callq 0x30d4
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %r15, %rax
jne 0x2ca7
movq 0x120(%rbx), %r14
leaq 0x110(%rbx), %r15
cmpq %r15, %r14
je 0x2cec
leaq 0x28(%r14), %rdi
callq 0x30d4
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %r15, %rax
jne 0x2cd3
leaq 0xd8(%rbx), %r14
leaq 0x108(%rbx), %r15
movq %r14, %rdi
callq 0x31ce
movq %r15, %rdi
callq 0x31ce
leaq 0x138(%rbx), %r12
cmpq $0x0, 0x150(%rbx)
je 0x2d38
movq 0x148(%rbx), %r13
movq 0x10(%r13), %rdi
callq 0x21c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x3232
jmp 0x2d11
movq %r12, %rdi
callq 0x32e4
movq %r15, %rdi
callq 0x3346
movq %r14, %rdi
callq 0x3346
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x311a
jmp 0x2d65
jmp 0x2d65
movq %rax, %rdi
callq 0x2a68
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./CountedOrderList.h
// Function: OrderBook::CountedOrderList<OrderLevelEntry>::clearLevel()
void clearLevel() {
      NODE *head = DLList<NODE>::getHead();
      while (head != DLList<NODE>::getTail()) {
         removeNode(head);
         head = head->previous_;
      }
      removeNode(head);
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpq 0x10(%rdi), %r14
je 0x3101
movl 0x10(%r14), %eax
subl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3170
movq 0x20(%r14), %r14
cmpq 0x10(%rbx), %r14
jne 0x30e5
movl 0x10(%r14), %eax
subl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3170
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./Logger.h
// Function: Logger::~Logger()
~Logger() {
      // Guard against it never being used or being stopped elsewhere
      if (thread_ == 0) return;

      exit_ = true;
      thread_->join();
      delete thread_;
      thread_ = 0;
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x314c
movb $0x1, %al
xchgb %al, (%rbx)
callq 0x2300
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x313f
cmpq $0x0, (%rdi)
jne 0x3162
callq 0x21c0
movq $0x0, 0x8(%rbx)
leaq 0x60(%rbx), %rdi
callq 0x2f74
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x2f74
callq 0x2060
movq %rax, %rdi
callq 0x2a68
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./DLList.h
// Function: OrderBook::DLList<OrderLevelEntry>::removeNode(OrderLevelEntry*)
void removeNode(NODE *target) {
      // Skip self and delete if straddled
      if (target->previous_ != 0 && target->next_ != 0) {
         target->previous_->next_ = target->next_;
         target->next_->previous_ = target->previous_;
      }
      // Edge - tail deleted
      else if (target == tail_ && target->next_ != 0) {
         tail_ = target->next_;
         tail_->previous_ = 0;
      }
      // Edge - head deleted
      else if (target == head_ && target->previous_ != 0) {
         head_ = target->previous_;
         head_->next_ = 0;
      }
      // Edge - single element list
      else {
         head_ = 0;
         tail_ = 0;
         return;
      }
   }

// Assembly:
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x318f
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x318f
movq %rcx, 0x18(%rax)
movq 0x18(%rsi), %rcx
movq %rax, 0x20(%rcx)
retq
cmpq %rsi, 0x10(%rdi)
je 0x31b7
leaq 0x8(%rdi), %rcx
testq %rax, %rax
je 0x31b0
cmpq %rsi, 0x8(%rdi)
jne 0x31b0
movq %rax, (%rcx)
movq $0x0, 0x18(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
retq
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x3195
movq %rcx, 0x10(%rdi)
movq $0x0, 0x20(%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::addOrder(OrderLevelEntry*)
void addOrder(ORDERTYPE* ole) {
      checkCross();

      auto ooit = orders_.find(ole->order_id_);
      if (ooit != orders_.end()) {
         FHErrorTracker::instance()->duplicateAdd();
         delete ole;
         return;
      }

      OrderListMap &map = ole->order_side_ == eS_Buy ? buy_book_map_ : sell_book_map_;

      std::pair<typename OrderListMap::iterator, bool> ret;
      ret = map.insert(
         std::pair<unsigned long long, CountedOrderList<ORDERTYPE>>(
            ole->order_price_, CountedOrderList<ORDERTYPE>()));
      ret.first->second.addNode(ole);
      orders_[ole->order_id_] = ole;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x5286
leaq 0x138(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52ec
testq %rax, %rax
je 0x3d9f
leaq 0x7432(%rip), %r14      # 0xb1c0
movq (%r14), %rax
testq %rax, %rax
je 0x3dfb
movl (%rax), %ecx
incl %ecx
jmp 0x3e1f
leaq 0x108(%r15), %rax
addq $0xd8, %r15
cmpl $0x1, 0x14(%rbx)
cmovneq %rax, %r15
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rsi
movups %xmm0, 0x10(%rsi)
movq 0x8(%rbx), %rax
movq %rax, (%rsi)
leaq 0x6fa9(%rip), %rax      # 0xad78
movq %rax, 0x8(%rsi)
movl $0x0, 0x20(%rsi)
movq %r15, %rdi
callq 0x5958
movl 0x10(%rbx), %ecx
addl %ecx, 0x40(%rax)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x3e32
movq %rbx, 0x18(%rcx)
movq %rcx, 0x20(%rbx)
jmp 0x3e36
movl $0x28, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%r14)
movl $0x1, %ecx
movl %ecx, (%rax)
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x21c0
movq %rbx, 0x38(%rax)
movq %rbx, 0x30(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ab6
movq %rbx, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::removeOrder(OrderLevelEntry*)
void removeOrder(ORDERTYPE* ole) {
      checkCross();

      // Confirm cancel of existing.  Don't check fields against record on books:
      // wasn't requested.  Trivial to do.
      auto ooit = orders_.find(ole->order_id_);
      if (ooit == orders_.end()) {
         FHErrorTracker::instance()->badCancel();
         delete ole;
         return;
      }

      OrderListMap &map = ooit->second->order_side_ == eS_Buy ? buy_book_map_ : sell_book_map_;

      typename OrderListMap::iterator pit = map.find(ooit->second->order_price_);
      if (pit == map.end()) {
         fprintf(stderr, "OrderBook:: CATASTROPHIC ERROR.  Cancel for order on price level (%llu) not found.  Skipping!\n", ooit->second->order_price_);
         delete ole;
         return;
      }
      pit->second.removeNode(ooit->second);
      delete ooit->second;
      orders_.erase(ooit);
      delete ole;

      if (pit->second.getQuantity() == 0) {
         map.erase(pit);
      }
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5286
leaq 0x138(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x52ec
testq %rax, %rax
je 0x416f
movq %rax, %r12
movq 0x10(%rax), %rsi
leaq 0x108(%r14), %rax
addq $0xd8, %r14
cmpl $0x1, 0x14(%rsi)
cmovneq %rax, %r14
movq 0x10(%r14), %rax
movq 0x8(%rsi), %rdx
testq %rax, %rax
je 0x41b6
leaq 0x8(%r14), %rcx
movq %rcx, %r13
xorl %edi, %edi
cmpq %rdx, 0x20(%rax)
setb %dil
cmovaeq %rax, %r13
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x4106
cmpq %rcx, %r13
je 0x41b6
cmpq 0x20(%r13), %rdx
jb 0x41b6
leaq 0x28(%r13), %rdi
movl 0x10(%rsi), %eax
subl %eax, 0x40(%r13)
callq 0x3170
movq 0x10(%r12), %rdi
callq 0x21c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x3232
movq %rbx, %rdi
callq 0x21c0
cmpl $0x0, 0x40(%r13)
je 0x41a2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x704a(%rip), %r14      # 0xb1c0
movq (%r14), %rax
testq %rax, %rax
jne 0x419d
movl $0x28, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%r14)
incl 0x8(%rax)
jmp 0x41ce
movq %r14, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5348
movq 0x6e1b(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x306c(%rip), %rsi      # 0x7233
xorl %eax, %eax
callq 0x2270
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21c0
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./OrderBook.h
// Function: OrderBook::OrderBook<unsigned int, OrderLevelEntry>::printMidpoint()
void printMidpoint() {
      if (sell_book_map_.empty() || buy_book_map_.empty()) {
         logger_.print("NAN\n");
         return;
      }

      unsigned long long sell_min = sell_book_map_.begin()->first;
      unsigned long long buy_max = buy_book_map_.rbegin()->first;
      double midpoint = (sell_min + buy_max) / 200.;
      char buffer[20];
      sprintf(buffer, "%.2f\n", midpoint);
      logger_.print(buffer);
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x130(%rdi)
je 0x4297
cmpq $0x0, 0x100(%rbx)
je 0x4297
movq 0x120(%rbx), %rax
movq 0x20(%rax), %r14
leaq 0xe0(%rbx), %rdi
callq 0x2200
addq 0x20(%rax), %r14
movq %r14, %xmm1
punpckldq 0x2e00(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2e08(%rip), %xmm1     # 0x7040
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd 0x2dd4(%rip), %xmm0     # 0x7020
leaq 0x2faa(%rip), %rsi      # 0x71fd
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0x2050
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x20a0
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x335a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5220
movq (%rsp), %rdi
jmp 0x42cb
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2feb(%rip), %rsi      # 0x7292
leaq 0x2fe8(%rip), %rdx      # 0x7296
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x335a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5220
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x42d5
callq 0x21c0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x42f5
movq %rax, %rbx
jmp 0x42ff
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x42ff
callq 0x21c0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./Logger.h
// Function: Logger::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print(std::string msg) {
      // lazy init creation
      // Optimizeable.  For now, keep interface clean and hide temporal coupling
      // from users.
      if (thread_ == 0) {
         init();
      }
      // mutex protects against messing with messages_ while logging thread
      // is copying out to it's own queue
      std::lock_guard<std::mutex> lock(mutex_);
      messages_.push(msg);
      messages_available_ = true;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x523a
movq %rbx, %rdi
callq 0x5380
leaq 0xb0(%rbx), %r14
movq %r14, %rdi
callq 0x2290
testl %eax, %eax
jne 0x526b
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x564a
movb $0x1, %al
xchgb %al, 0x1(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2170
movl %eax, %edi
callq 0x2130
movq %rax, %rbx
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./Logger.h
// Function: Logger::runLogger()
void runLogger() {
      while (TRUE) {
         if (messages_available_ == true) {
            copyMessages();
            printMessages();
         }
         if (exit_ == true) {
            copyMessages();
            printMessages();
            return;
         }
      }
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x1(%rbx), %al
testb $0x1, %al
je 0x53f3
movq %rbx, %rdi
callq 0x5480
movq %rbx, %rdi
callq 0x552a
movb (%rbx), %al
testb $0x1, %al
je 0x53dc
movq %rbx, %rdi
callq 0x5480
movq %rbx, %rdi
popq %rbx
jmp 0x552a
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./Logger.h
// Function: Logger::copyMessages()
void copyMessages() {
      // Just copy them all out.  Deal with strcpy costs here in bulk.
      // Could optimize later if it becomes a problem and blocks enqueue
      std::lock_guard<std::mutex> lock(mutex_);
      while (messages_.size() != 0) {
         messages_to_print_.push(messages_.front());
         messages_.pop();
      }
      messages_available_ = false;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xb0(%rdi), %rbx
movq %rbx, %rdi
callq 0x2290
testl %eax, %eax
jne 0x550f
leaq 0x10(%r14), %r15
leaq 0x60(%r14), %r12
movq 0x58(%r14), %rax
movq %rax, %rcx
subq 0x38(%r14), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0x40(%r14), %rax
subq 0x48(%r14), %rax
shlq $0x4, %rcx
sarq $0x5, %rax
addq %rcx, %rax
movq 0x20(%r14), %rsi
movq 0x30(%r14), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
addq %rax, %rcx
je 0x54f6
movq %r12, %rdi
callq 0x564a
movq %r15, %rdi
callq 0x5594
jmp 0x54a6
xorl %eax, %eax
xchgb %al, 0x1(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2170
movl %eax, %edi
callq 0x2130
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_c_makefile_star2_O3/aspone[P]OrderBook/./CountedOrderList.h
// Function: OrderBook::CountedOrderList<OrderLevelEntry>::printLevel(char, char*&, int&, int&)
void printLevel(char tag, char *&buffer, int &index, int &max_buffer) {
      NODE *tail = DLList<NODE>::getTail();
      while (tail != DLList<NODE>::getHead()) {
         // Need interim so I know len of level print
         // char level[50];
         // sprintf(level, "%c %u ", tag, tail->order_qty_);
         // safeCopyToBuffer(buffer, level, index, max_buffer);

         if (index + 50 > max_buffer) growBuffer(buffer, max_buffer);
         index += sprintf(&buffer[index], "%c %u ", tag, tail->order_qty_);

         tail = tail->next_;
      }
      // Need interim so I know len of level print
      // char level[50];
      // sprintf(level, "%c %u ", tag, tail->order_qty_);
      // safeCopyToBuffer(buffer, level, index, max_buffer);

      if (index + 50 > max_buffer) growBuffer(buffer, max_buffer);
      index += sprintf(&buffer[index], "%c %u ", tag, tail->order_qty_);
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq 0x10(%rdi), %rbp
movl (%rcx), %eax
movsbl %sil, %ecx
movl %ecx, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
cmpq 0x8(%rdi), %rbp
je 0x618a
leal 0x32(%rax), %ecx
movslq (%r14), %r12
movq (%r15), %r13
cmpl %r12d, %ecx
jle 0x615c
leaq (%r12,%r12), %rsi
movl %esi, (%r14)
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq %rax, (%r15)
leaq (%rax,%r12), %rdi
movslq (%r14), %rdx
subq %r12, %rdx
xorl %esi, %esi
callq 0x20f0
movl (%rbx), %eax
movslq %eax, %rdi
addq %r13, %rdi
movl 0x10(%rbp), %ecx
leaq 0x1131(%rip), %rsi      # 0x729d
movl 0xc(%rsp), %edx
xorl %eax, %eax
callq 0x2050
addl (%rbx), %eax
movl %eax, (%rbx)
movq 0x18(%rbp), %rbp
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rbp
jne 0x6126
leal 0x32(%rax), %ecx
movslq (%r14), %r13
movq (%r15), %r12
cmpl %r13d, %ecx
jle 0x61c4
leaq (,%r13,2), %rsi
movl %esi, (%r14)
movq %r12, %rdi
callq 0x22f0
movq %rax, %r12
movq %rax, (%r15)
leaq (%rax,%r13), %rdi
movslq (%r14), %rdx
subq %r13, %rdx
xorl %esi, %esi
callq 0x20f0
movl (%rbx), %eax
movslq %eax, %rdi
addq %r12, %rdi
movl 0x10(%rbp), %ecx
leaq 0x10c9(%rip), %rsi      # 0x729d
movl 0xc(%rsp), %edx
xorl %eax, %eax
callq 0x2050
addl %eax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/crcx[P]retroforth/tools/retro-unu.c
// Function: unu
void unu(char *fname, int tests_enabled, Handler handler) {
  int inBlock = 0;
  char buffer[4096];
  FILE *fp;
  fp = fopen(fname, "r");
  if (fp == NULL) {
    printf("Unable to load file\n");
    exit(2);
  }
  while (!feof(fp)) {
    read_line(fp, buffer);
    if (fence_boundary(buffer, tests_enabled) == -1) {
      if (inBlock == 0) {
        inBlock = 1;
      } else {
        inBlock = 0;
      }
    } else {
      if (inBlock == 1) {
        handler(buffer);
      }
    }
  }
  fclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdx, %rbx
movl %esi, %ebp
leaq 0xd8d(%rip), %rsi       # 0x2004
callq 0x1080
testq %rax, %rax
je 0x1318
movq %rax, %r14
movq %rax, %rdi
callq 0x1070
testl %eax, %eax
jne 0x12fe
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x10a0
cmpl $-0x1, %eax
je 0x12b8
cmpl $0xa, %eax
je 0x12b8
movb %al, (%rsp,%r13)
incq %r13
jmp 0x129d
movl %r13d, %eax
movb $0x0, (%rsp,%rax)
movq %r15, %rdi
movl %ebp, %esi
callq 0x11e2
cmpl $-0x1, %eax
je 0x12e7
cmpl $0x1, %r12d
movl $0x0, %r12d
jne 0x12f2
movq %r15, %rdi
callq *%rbx
movl $0x1, %r12d
jmp 0x12f2
xorl %eax, %eax
testl %r12d, %r12d
sete %al
movl %eax, %r12d
movq %r14, %rdi
callq 0x1070
testl %eax, %eax
je 0x129a
movq %r14, %rdi
callq 0x1050
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd37(%rip), %rdi       # 0x2056
callq 0x1040
movl $0x2, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/bytesequence.c
// Function: SH_ByteSequence__init
SH_ByteSequence*
SH_ByteSequence__init(sh_byte_t* value, size_t n, int* err) {
	SH_ByteSequence* obj;

	__cascade(err, (SH_ByteSequence*)0);

	if (n > SH_BYTESEQUENCE_LENGTH_MAX) {
		__raise(err, SH_E_BYTESEQUENCE_TOO_LONG);
		return (SH_ByteSequence*)0;
	}

	obj = (SH_ByteSequence*)malloc(sizeof(SH_ByteSequence));
	if ((SH_ByteSequence*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_ByteSequence*)0;
	}

	obj->value = (sh_byte_t*)malloc(sizeof(sh_byte_t) * n);
	if ((sh_byte_t*)0 == obj->value) {
		free(obj);
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_ByteSequence*)0;
	}

	memcpy((void*)obj->value, (const void*)value, n);
	obj->length = n;

	__clear(err);
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rdx, %rdx
je 0x1157
cmpl $0x0, (%rbx)
jne 0x116f
cmpq $0x4000, %r15           # imm = 0x4000
jbe 0x1174
movl $0x150001, %eax         # imm = 0x150001
jmp 0x11c8
cmpq $0x4000, %r15           # imm = 0x4000
ja 0x116f
movl $0x10, %edi
callq 0x1050
testq %rax, %rax
jne 0x1183
xorl %r14d, %r14d
jmp 0x11cd
movl $0x10, %edi
callq 0x1050
testq %rax, %rax
je 0x11c3
movq %rax, %r14
movq %r15, %rdi
callq 0x1050
movq %rax, (%r14)
testq %rax, %rax
je 0x11ac
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1040
xorl %eax, %eax
movq %r15, 0x8(%r14)
jmp 0x11bc
movq %r14, %rdi
callq 0x1030
xorl %r14d, %r14d
movl $0x80000001, %eax       # imm = 0x80000001
testq %rbx, %rbx
jne 0x11cb
jmp 0x11cd
movl $0x80000001, %eax       # imm = 0x80000001
xorl %r14d, %r14d
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/bytesequence.c
// Function: SH_ByteSequence__destroy
void
SH_ByteSequence__destroy(SH_ByteSequence* obj, int* err) {
	__cascade(err,);
	if ((sh_byte_t*)0 != obj->value) {
		free(obj->value);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x11f0
cmpl $0x0, (%rbx)
jne 0x1210
movq (%r14), %rdi
testq %rdi, %rdi
je 0x11fd
callq 0x1030
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x1210
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/bytesequence.c
// Function: SH_ByteSequence__to_s
sh_char_t*
SH_ByteSequence__to_s(SH_ByteSequence* obj, int* err) {
	size_t size;
	size_t i;

	uint8_t b1;
	uint8_t b2;
	uint8_t b3;
	uint8_t b4;

	sh_char_t* str;
	sh_char_t* ptr;

	__cascade(err, (sh_char_t*)0);

	size = (obj->length * 4 + 2) / 3; /* 3in -> 4out */
	str = (sh_char_t*)malloc(sizeof(sh_char_t) * (size + 3));
	if ((sh_char_t*)0 == str) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (sh_char_t*)0;
	}

	ptr = str;
	*ptr = SH_CHAR_C('*'); ptr ++;

	for (i = 0; i < obj->length; i += 3) {
		b1 = (obj->value[i] & 0xFC) >> 2;        /* xxxxxx__ -> __xxxxxx */
		b2 = (obj->value[i] & 0x03) << 4;        /* ______xx -> __xx____ */
		b3 = 0;
		b4 = 0;

		*ptr = _b64[b1]; ptr++;

		if ((i + 1) < obj->length) {
			b2 |= (obj->value[i+1] & 0xF0) >> 4; /* xxxx____ -> ____xxxx */
			b3  = (obj->value[i+1] & 0x0F) << 2; /* ____xxxx -> __xxxx__ */

			*ptr = _b64[b2]; ptr++;

			if ((i + 2) < obj->length) {
				b3 |= (obj->value[i+2] & 0xC0) >> 6; /* xx______ -> ______xx */
				b4  = (obj->value[i+2] & 0x3F);      /* __xxxxxx */

				*ptr = _b64[b3]; ptr++;
				*ptr = _b64[b4]; ptr++;
			} else {
				*ptr = _b64[b3]; ptr++;
				*ptr = SH_CHAR_C('='); ptr++;
			}
		} else {
			*ptr = _b64[b2]; ptr++;
			*ptr = SH_CHAR_C('='); ptr++;
			*ptr = SH_CHAR_C('='); ptr++;
		}
	}

	*ptr = SH_CHAR_C('*'); ptr ++;
	*ptr = SH_CHAR_C(0);

	__clear(err);
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1246
cmpl $0x0, (%rbx)
je 0x1246
xorl %eax, %eax
jmp 0x134e
movq 0x8(%r14), %r15
leaq 0x2(,%r15,4), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq %rdx
leaq 0x3(%rdx), %rdi
callq 0x1050
testq %rax, %rax
je 0x1340
movb $0x2a, (%rax)
movq %rax, %rcx
incq %rcx
testq %r15, %r15
je 0x1337
movq (%r14), %rdx
movl $0x2, %edi
movq 0x2d43(%rip), %rsi      # 0x3fd8
movzbl -0x2(%rdx,%rdi), %r9d
movl %r9d, %r8d
shrl $0x2, %r8d
shll $0x4, %r9d
andl $0x30, %r9d
movb (%rsi,%r8), %r8b
movb %r8b, (%rcx)
leaq -0x1(%rdi), %r8
cmpq %r15, %r8
jae 0x1304
movzbl -0x1(%rdx,%rdi), %r8d
movl %r8d, %r10d
shrl $0x4, %r10d
orq %r9, %r10
shll $0x2, %r8d
andl $0x3c, %r8d
movb (%rsi,%r10), %r9b
movb %r9b, 0x1(%rcx)
cmpq %r15, %rdi
jae 0x1314
movzbl (%rdx,%rdi), %r9d
movl %r9d, %r10d
shrl $0x6, %r10d
orq %r8, %r10
andl $0x3f, %r9d
movb (%rsi,%r10), %r8b
movb %r8b, 0x2(%rcx)
movb (%rsi,%r9), %r8b
movb %r8b, 0x3(%rcx)
jmp 0x1320
movb (%rsi,%r9), %r8b
movb %r8b, 0x1(%rcx)
movw $0x3d3d, 0x2(%rcx)      # imm = 0x3D3D
jmp 0x1320
movb (%rsi,%r8), %r8b
movb %r8b, 0x2(%rcx)
movb $0x3d, 0x3(%rcx)
addq $0x4, %rcx
leaq 0x3(%rdi), %r8
incq %rdi
cmpq %r15, %rdi
movq %r8, %rdi
jb 0x1295
xorl %edx, %edx
movw $0x2a, (%rcx)
jmp 0x1347
movl $0x80000001, %edx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x134e
movl %edx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/carlitosmarin[P]Sistema-Ficheros-SOII/mi_chmod.c
// Function: main
int main (int argc, char **argv) {
	if (argc != 4) {
		printf("Número de parametros incorrectos\n");
		return -1;
	}
	//Montamos el disco
	bmount(argv[1]);

	unsigned int permisos = atoi(argv[2]);
	if(permisos < 0 || permisos > 7) {
		puts("Permisos introducidos invalidos\n");
		bumount();
		return -1;
	}

	if(mi_chmod (argv[3],permisos) == 0) printf("Permisos del fichero %s actualizados correctamente\n", argv[3]);
	else printf("Error: No se ha podido llevar a cabo mi_chmod\n");

	bumount();
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x4, %edi
jne 0x3d41
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x128c
movq 0x10(%rbx), %rdi
callq 0x1150
cmpl $0x8, %eax
jb 0x3d54
leaq 0x7f5(%rip), %rdi       # 0x4528
callq 0x1060
xorl %eax, %eax
callq 0x12ca
jmp 0x3d4d
leaq 0x863(%rip), %rdi       # 0x45ab
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3d8d
movq 0x18(%rbx), %rdi
movzbl %al, %esi
callq 0x3909
testl %eax, %eax
je 0x3d72
leaq 0x812(%rip), %rdi       # 0x457d
callq 0x1060
jmp 0x3d84
movq 0x18(%rbx), %rsi
leaq 0x7cc(%rip), %rdi       # 0x4549
xorl %eax, %eax
callq 0x1090
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x12ca
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]gpss/datgen.c
// Function: pt_quicksort
static void pt_quicksort(int *a, int n)
{
	int i, j, t;
	int kx, ky;
	if (n < 2)
		return;
	if (n < 100) {
		pt_insertion(a, n);
		return;
	}
	kx = pt_sx[a[n / 2]];
	ky = pt_sy[a[n / 2]];
	for (i = 0, j = n - 1; ; i++, j--) {
		while (DEGCMP(pt_sx[a[i]], pt_sy[a[i]], kx, ky) < 0)
			i++;
		while (DEGCMP(pt_sx[a[j]], pt_sy[a[j]], kx, ky) > 0)
			j--;
		if (i >= j)
			break;
		t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	if (i > 1)
		pt_quicksort(a, i);
	if (i + 1 < n)
		pt_quicksort(a + i, n - i);
}

// Assembly:
cmpl $0x2, %esi
jl 0x1804
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xb940b5(%rip), %r14    # 0xb95750
leaq 0xb9dcee(%rip), %r15    # 0xb9f390
cmpl $0x63, %esi
jbe 0x1790
movl %esi, %eax
shrl %eax
movslq (%rbx,%rax,4), %rcx
movslq (%r14,%rcx,4), %rax
movslq (%r15,%rcx,4), %rcx
movl %esi, 0x4(%rsp)
movl %esi, %edx
xorl %esi, %esi
movq %rsi, 0x10(%rsp)
movslq %esi, %rsi
leaq (%rbx,%rsi,4), %rdi
movl $0x4, %ebp
xorl %r13d, %r13d
movslq (%rdi,%r13,4), %r8
movslq (%r14,%r8,4), %r9
negq %r9
imulq %rcx, %r9
movslq (%r15,%r8,4), %r10
imulq %rax, %r10
incq %r13
addq $-0x4, %rbp
addq %r9, %r10
js 0x16d7
movslq %edx, %rdx
leaq (%rsi,%r13), %r10
decq %r10
movslq -0x4(%rbx,%rdx,4), %r9
decq %rdx
movslq (%r14,%r9,4), %r11
negq %r11
imulq %rcx, %r11
movslq (%r15,%r9,4), %r12
imulq %rax, %r12
addq %r11, %r12
jg 0x1704
cmpq %rdx, %r10
jge 0x1737
movl %r9d, -0x4(%rdi,%r13,4)
movl %r8d, (%rbx,%rdx,4)
addq %r13, %rsi
jmp 0x16c3
movq 0x10(%rsp), %r12
movslq %r12d, %rcx
leaq (%rcx,%r13), %rax
decq %rax
cmpq $0x2, %rax
jl 0x1766
leal -0x1(%r12), %esi
addq %r13, %rsi
movq %rbx, %rdi
movq %rcx, 0x8(%rsp)
callq 0x167a
movq 0x8(%rsp), %rcx
leal (%r12,%r13), %eax
movl 0x4(%rsp), %esi
cmpl %esi, %eax
jge 0x17f6
leaq (%rbx,%rcx,4), %rbx
subq %rbp, %rbx
subl %r12d, %esi
subl %r13d, %esi
incl %esi
cmpl $0x1, %esi
jg 0x16a2
jmp 0x17f6
movl %esi, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
testq %rcx, %rcx
je 0x17e9
movslq %edx, %rdi
movslq (%r14,%rdi,4), %rsi
negq %rsi
movslq (%r15,%rdi,4), %r8
movq %rcx, %rdi
leaq -0x1(%rdi), %r9
movl %r9d, %r10d
movslq (%rbx,%r10,4), %r10
movslq (%r15,%r10,4), %r11
imulq %rsi, %r11
movslq (%r14,%r10,4), %r12
imulq %r8, %r12
addq %r11, %r12
jns 0x17e0
movl %r10d, (%rbx,%rdi,4)
leaq 0x1(%r9), %r10
movq %r9, %rdi
cmpq $0x1, %r10
jg 0x17ad
xorl %edi, %edi
movslq %edi, %rsi
shlq $0x2, %rsi
jmp 0x17eb
xorl %esi, %esi
movl %edx, (%rbx,%rsi)
incq %rcx
cmpq %rax, %rcx
jne 0x1794
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: split
void split(const char *in_fname, const char *out_even_fname, const char *out_odd_fname, int bytes)
{
	int c;
	FILE *fin, *fout_odd, *fout_even;
	fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_fname);
		return;
	}
	fout_odd = fopen(out_odd_fname, "wb");
	if (!fout_odd)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_odd_fname);
		fclose(fin);
		return;
	}
	fout_even = fopen(out_even_fname, "wb");
	if (!fout_even)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_even_fname);
		fclose(fin);
		fclose(fout_odd);
		return;
	}

	do
	{
		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin);
			if (feof(fin))
			{
				goto done;
			}
			fputc(c, fout_even);
		}
		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin);
			if (feof(fin))
			{
				goto done;
			}
			fputc(c, fout_odd);
		}
	}
	while (c != EOF);
done:
	fclose(fin);
	fclose(fout_odd);
	fclose(fout_even);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xe2b(%rip), %rsi       # 0x2004
callq 0x10a0
testq %rax, %rax
je 0x12a8
movq %rax, %rbx
leaq 0xe29(%rip), %rsi       # 0x201a
movq %r15, %rdi
callq 0x10a0
testq %rax, %rax
je 0x12d1
movq %rax, %r14
leaq 0xe0e(%rip), %rsi       # 0x201a
movq %r12, %rdi
callq 0x10a0
testq %rax, %rax
je 0x12f1
movq %rax, %r15
movl %ebp, %r13d
testl %ebp, %ebp
jle 0x127c
movq %rbx, %rdi
callq 0x1060
movl %eax, %r12d
movq %rbx, %rdi
callq 0x1090
testl %eax, %eax
jne 0x1282
movl %r12d, %edi
movq %r15, %rsi
callq 0x1070
decl %r13d
jne 0x1227
movl %ebp, %r13d
testl %ebp, %ebp
jle 0x127c
movq %rbx, %rdi
callq 0x1060
movl %eax, %r12d
movq %rbx, %rdi
callq 0x1090
testl %eax, %eax
jne 0x1282
movl %r12d, %edi
movq %r14, %rsi
callq 0x1070
decl %r13d
jne 0x1255
cmpl $-0x1, %r12d
jne 0x1220
movq %rbx, %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
movq 0x2d49(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd4e(%rip), %rsi       # 0x2007
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
movq 0x2d20(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd25(%rip), %rsi       # 0x2007
movq %r15, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
jmp 0x1295
movq 0x2d00(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd05(%rip), %rsi       # 0x2007
movq %r12, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
callq 0x1040
movq %r14, %rdi
jmp 0x1295