LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: ge_new_gif
ge_GIF *ge_new_gif(
    const char *fname, uint16_t width, uint16_t height, uint8_t *palette, int depth, int loop) {
    ge_GIF *gif = calloc(1, sizeof(*gif) + 2 * width * height);
    if (!gif)
        goto no_gif;
    gif->w = width;
    gif->h = height;
    gif->depth = depth > 1 ? depth : 2;
    gif->frame = (uint8_t *) &gif[1];
    gif->back = &gif->frame[width * height];
    gif->fd = creat(fname, 0666);
    if (gif->fd == -1)
        goto no_fd;
    write(gif->fd, "GIF89a", 6);
    write_num(gif->fd, width);
    write_num(gif->fd, height);
    write(gif->fd, (uint8_t[]) { 0xF0 | (depth - 1), 0x00, 0x00 }, 3);
    write(gif->fd, palette, 3 << depth);
    if (loop >= 0 && loop <= 0xFFFF)
        put_loop(gif, (uint16_t) loop);
    return gif;
no_fd:
    free(gif);
no_gif:
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r15d
movq %rcx, 0x20(%rsp)
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbp
movl %esi, %r14d
imull %edx, %r14d
leal 0x130(,%r14,2), %esi
movl $0x1, %edi
callq 0x20f0
testq %rax, %rax
je 0x254e
movq %rax, %rbx
movw %r13w, (%rax)
movw %r12w, 0x2(%rax)
cmpl $0x3, %r15d
movl $0x2, %eax
cmovgel %r15d, %eax
movl %eax, 0x4(%rbx)
leaq 0x130(%rbx), %rax
movq %rax, 0x18(%rbx)
leaq (%rbx,%r14), %rax
addq $0x130, %rax            # imm = 0x130
movq %rax, 0x20(%rbx)
movq %rbp, %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x2100
movl %eax, 0x8(%rbx)
cmpl $-0x1, %eax
je 0x2546
leaq 0x1bad(%rip), %rsi      # 0x4004
movl $0x6, %edx
movl %eax, %edi
callq 0x2080
movl 0x8(%rbx), %edi
leaq 0x14(%rsp), %rsi
movw %r13w, (%rsi)
movl $0x2, %edx
callq 0x2080
movl 0x8(%rbx), %edi
leaq 0x12(%rsp), %rsi
movw %r12w, (%rsi)
movl $0x2, %edx
callq 0x2080
movl 0x8(%rbx), %edi
leal -0x1(%r15), %eax
orb $-0x10, %al
leaq 0x1a(%rsp), %rsi
movb %al, (%rsi)
movw $0x0, 0x1(%rsi)
movl $0x3, %edx
callq 0x2080
movl 0x8(%rbx), %edi
movl $0x3, %eax
movl %r15d, %ecx
shll %cl, %eax
movslq %eax, %rdx
movq 0x20(%rsp), %rsi
callq 0x2080
movl 0xc(%rsp), %ebp
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x2550
movl 0x8(%rbx), %edi
leaq 0x1d(%rsp), %rsi
movw $0xff21, (%rsi)         # imm = 0xFF21
movb $0xb, 0x2(%rsi)
movl $0x3, %edx
callq 0x2080
movl 0x8(%rbx), %edi
leaq 0x1b13(%rip), %rsi      # 0x400d
movl $0xb, %edx
callq 0x2080
movl 0x8(%rbx), %edi
leaq 0x18(%rsp), %rsi
movw $0x103, (%rsi)          # imm = 0x103
movl $0x2, %edx
callq 0x2080
movl 0x8(%rbx), %edi
leaq 0x16(%rsp), %rsi
movw %bp, (%rsi)
movl $0x2, %edx
callq 0x2080
movl 0x8(%rbx), %edi
leaq 0x1ae3(%rip), %rsi      # 0x401d
movl $0x1, %edx
callq 0x2080
jmp 0x2550
movq %rbx, %rdi
callq 0x21c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rax
leaq 0x8(,%rax,8), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x20f0
movq %rax, %r14
testq %rax, %rax
je 0x2903
movw $0x0, (%r14)
testl %ebp, %ebp
jle 0x2936
movl %ebp, %r13d
xorl %r12d, %r12d
movl $0x1, %edi
movq %r15, %rsi
callq 0x20f0
testq %rax, %rax
je 0x2923
movw %r12w, (%rax)
movq %rax, 0x8(%r14,%r12,8)
incq %r12
cmpq %r12, %r13
jne 0x290d
addl $0x2, %r12d
jmp 0x293c
movl $0x2, %r12d
movl %r12d, (%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_O1/yahya-tamur[P]Visualising-Complex-Functions/gifenc.c
// Function: del_trie
static void del_trie(Node *root, int degree) {
    if (!root)
        return;
    for (int i = 0; i < degree; i++)
        del_trie(root->children[i], degree);
    free(root);
}

// Assembly:
testq %rdi, %rdi
je 0x2a48
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jle 0x2a36
movl %ebp, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx,%r15,8), %rdi
movl %ebp, %esi
callq 0x2a07
incq %r15
cmpq %r15, %r14
jne 0x2a22
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
fldz
fld %st(0)
fstpt (%rdi)
fld %st(0)
fstpt 0x10(%rdi)
fldt 0xe0(%rsp)
fchs
fstpt 0x68(%rsp)
fldt 0xf0(%rsp)
fchs
fstpt 0x5c(%rsp)
movl $0x64, %ebp
fld %st(0)
fld %st(1)
fld %st(1)
fstpt 0x44(%rsp)
fxch %st(2)
fstpt 0x50(%rsp)
fxch %st(1)
fstpt 0x74(%rsp)
fstpt 0xa0(%rsp)
fldz
fstpt 0xb0(%rsp)
fldt 0x68(%rsp)
fstpt 0x80(%rsp)
fldt 0x5c(%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 0x74(%rsp)
faddp %st, %st(1)
fldt 0x50(%rsp)
faddp %st, %st(2)
fxch %st(1)
fstpt 0x50(%rsp)
fldt 0x50(%rsp)
fld1
fldt 0x44(%rsp)
faddp %st, %st(1)
fstpt 0x44(%rsp)
fldt 0x44(%rsp)
decl %ebp
fxch %st(1)
fxch %st(2)
jne 0x35be
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_O1/openshmem-org[P]openshmem-examples/c/bcast4.c
// Function: main
int
main(void)
{
    int i;
    long *target;
    static long source[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int nlong = 8;
    int me;

    shmem_init();
    me = shmem_my_pe();

    target = (long *) shmem_malloc(8 * sizeof(*target));

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }
    shmem_barrier_all();

    /* Number of PEs in the active set must be set properly, this test is
       expected to run with 4 PEs */
    if ((me % 2) == 0) {
        shmem_broadcast64(target, source, nlong, 0, 0, 1, 2, pSync);
    }

    shmem_barrier_all();

    for (i = 0; i < 8; i++) {
        printf("%d: target[%d] = %ld\n", me, i, target[i]);
    }

    shmem_free(target);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x1080
callq 0x1050
movl %eax, %ebx
movl $0x40, %edi
callq 0x1060
movq %rax, %r14
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x2ee7(%rip)     # 0x40c0
callq 0x1070
testb $0x1, %bl
jne 0x1210
leaq 0x2ed6(%rip), %rax      # 0x40c0
leaq 0x2e7f(%rip), %rsi      # 0x4070
movl $0x8, %edx
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq %rax
pushq $0x2
callq 0x10a0
addq $0x10, %rsp
callq 0x1070
leaq 0xde8(%rip), %r15       # 0x2004
xorl %r12d, %r12d
movq (%r14,%r12,8), %rcx
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1030
incq %r12
cmpq $0x8, %r12
jne 0x121f
movq %r14, %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xe598(%rip)      # 0x111a8
testq %rax, %rax
je 0x2c9d
testq %rbx, %rbx
je 0x2c6e
xorl %r15d, %r15d
movabsq $0x5858585858582e, %r12 # imm = 0x5858585858582E
movq %rbx, %r13
movq 0xe573(%rip), %rax      # 0x111a8
leaq (%rax,%r15), %r14
movups 0x686(%rip), %xmm0      # 0x32c6
movups %xmm0, (%rax,%r15)
movq %r12, 0x10(%rax,%r15)
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
js 0x2c7e
movl %eax, %edi
callq 0x2140
movq %r14, %rdi
callq 0x2080
addq $0x18, %r15
decq %r13
jne 0x2c2e
movl %ebx, 0xe53c(%rip)      # 0x111b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x659(%rip), %rdi       # 0x32de
leaq 0x605(%rip), %rsi       # 0x3291
leaq 0x60e(%rip), %rcx       # 0x32a1
movl $0x1b, %edx
callq 0x2120
leaq 0x5e4(%rip), %rdi       # 0x3288
leaq 0x5e6(%rip), %rsi       # 0x3291
leaq 0x5ef(%rip), %rcx       # 0x32a1
movl $0x14, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/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 0xe4d6(%rip), %r14      # 0x111a8
movq %r14, %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x2210
testl %eax, %eax
js 0x2cfe
movl %eax, %edi
callq 0x2140
movq %r14, %rdi
callq 0x2080
incq (%rbx)
jmp 0x2cd2
leaq 0x5d9(%rip), %rdi       # 0x32de
leaq 0x585(%rip), %rsi       # 0x3291
leaq 0x5d3(%rip), %rcx       # 0x32e6
movl $0x2a, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/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, 0xe48c(%rip)      # 0x111b0
jle 0x2d58
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0xe472(%rip), %rdi      # 0x111a8
addq %rbx, %rdi
callq 0x2080
incq %r14
movslq 0xe468(%rip), %rax      # 0x111b0
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x2d2f
addq $0x8, %rsp
popq %rbx
popq %r14
movq 0xe449(%rip), %rdi      # 0x111a8
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/aspone[P]OrderBook/./FHErrorTracker.h
// Function: OrderBook::FHErrorTracker::printStatistics()
void printStatistics() {
      fprintf(stderr, "\n[Feed Handler Statistics]\n");
      fprintf(stderr, "   %-30s %10u\n", "Corrupt Messages", corrupt_messages_);
      fprintf(stderr, "   %-30s %10u\n", "Good Messages:", good_messages_);
      fprintf(stderr, "   %-30s %10u\n", "Duplicate Adds:", duplicate_add_);
      fprintf(stderr, "   %-30s %10u\n", "Trades Missing Orders:", trade_missing_orders_);
      fprintf(stderr, "   %-30s %10u\n", "Cancels for Missing ID's:", bad_cancels_);
      fprintf(stderr, "   %-30s %10u\n", "Modifies for Missing ID's:", bad_modifies_);
      fprintf(stderr, "   %-30s %10u\n", "Crossed Book:", crossed_book_);
      fprintf(stderr, "   %-30s %10u\n", "Invalid Quantities:", invalid_qtys_);
      fprintf(stderr, "   %-30s %10u\n", "Invalid Prices:", invalid_prices_);
      fprintf(stderr, "   %-30s %10u\n", "Invalid IDs:", invalid_ids_);
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8c79(%rip), %r15      # 0xafd8
movq (%r15), %rcx
leaq 0x4d63(%rip), %rdi      # 0x70cc
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
movq (%r15), %rdi
movl 0x14(%rbx), %ecx
leaq 0x4d67(%rip), %r14      # 0x70e8
leaq 0x4d6f(%rip), %rdx      # 0x70f7
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x24(%rbx), %ecx
leaq 0x4d69(%rip), %rdx      # 0x7108
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl (%rbx), %ecx
leaq 0x4d62(%rip), %rdx      # 0x7117
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x4(%rbx), %ecx
leaq 0x4d5b(%rip), %rdx      # 0x7127
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x8(%rbx), %ecx
leaq 0x4d5b(%rip), %rdx      # 0x713e
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0xc(%rbx), %ecx
leaq 0x4d5e(%rip), %rdx      # 0x7158
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x10(%rbx), %ecx
leaq 0x4d62(%rip), %rdx      # 0x7173
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x18(%rbx), %ecx
leaq 0x4d59(%rip), %rdx      # 0x7181
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x1c(%rbx), %ecx
leaq 0x4d56(%rip), %rdx      # 0x7195
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq (%r15), %rdi
movl 0x20(%rbx), %ecx
leaq 0x4d4f(%rip), %rdx      # 0x71a5
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2270
// File: /workspace/github_c_makefile_star2_O1/aspone[P]OrderBook/./Utilities.h
// Function: growBuffer(char*&, int&)
void growBuffer(char *&buf, int &max_buffer) {
   int old_max = max_buffer;
   max_buffer *= 2;
   buf = (char *)realloc(buf, max_buffer * sizeof(char));

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rsi), %r15
leaq (%r15,%r15), %rsi
movl %esi, (%rbx)
movq (%rdi), %rdi
callq 0x22f0
movq %rax, (%r14)
leaq (%rax,%r15), %rdi
movslq (%rbx), %rdx
subq %r15, %rdx
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/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, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x20a0
movq %rax, %r15
testl %r15d, %r15d
je 0x2837
movl (%rbx), %eax
leal (%rax,%r15), %ecx
movl (%r13), %ebp
cmpl %ebp, %ecx
jl 0x2822
leal (,%rbp,2), %eax
movl %eax, (%r13)
movq (%r12), %rdi
movslq %eax, %rsi
callq 0x22f0
movq %rax, (%r12)
movslq %ebp, %rcx
leaq (%rax,%rcx), %rdi
movl (%r13), %ebp
movl %ebp, %eax
subl %ecx, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x20f0
movl (%rbx), %eax
leal (%rax,%r15), %ecx
jmp 0x27e2
movslq %eax, %rdi
addq (%r12), %rdi
movslq %r15d, %rdx
movq %r14, %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_O1/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 0x2d5c
leaq 0x28(%r14), %rdi
callq 0x3168
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %r15, %rax
jne 0x2d43
movq 0x120(%rbx), %r14
leaq 0x110(%rbx), %r15
cmpq %r15, %r14
je 0x2d88
leaq 0x28(%r14), %rdi
callq 0x3168
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %r15, %rax
jne 0x2d6f
leaq 0xd8(%rbx), %r14
leaq 0x108(%rbx), %r15
movq %r14, %rdi
callq 0x3264
movq %r15, %rdi
callq 0x3264
leaq 0x138(%rbx), %r12
cmpq $0x0, 0x150(%rbx)
je 0x2dd9
movq 0x148(%rbx), %r13
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x2dcc
callq 0x21c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x32c8
jmp 0x2dad
movq %r12, %rdi
callq 0x3384
movq %r15, %rdi
callq 0x33e6
movq %r14, %rdi
callq 0x33e6
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31ae
jmp 0x2e06
jmp 0x2e06
movq %rax, %rdi
callq 0x2aba
// File: /workspace/github_c_makefile_star2_O1/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 0x3195
movl 0x10(%r14), %eax
subl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3206
movq 0x20(%r14), %r14
cmpq 0x10(%rbx), %r14
jne 0x3179
movl 0x10(%r14), %eax
subl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3206
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x8(%rdi)
je 0x31e2
movb $0x1, %al
xchgb %al, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x2300
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x31da
cmpq $0x0, (%rdi)
jne 0x31f8
callq 0x21c0
movq $0x0, 0x8(%rbx)
leaq 0x60(%rbx), %rdi
callq 0x3014
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3014
callq 0x2060
movq %rax, %rdi
callq 0x2aba
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3225
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x3225
movq %rcx, 0x18(%rax)
movq 0x18(%rsi), %rcx
movq %rax, 0x20(%rcx)
retq
cmpq %rsi, 0x10(%rdi)
je 0x324d
leaq 0x8(%rdi), %rcx
testq %rax, %rax
je 0x3246
cmpq %rsi, 0x8(%rdi)
jne 0x3246
movq %rax, (%rcx)
movq $0x0, 0x18(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
retq
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x322b
movq %rcx, 0x10(%rdi)
movq $0x0, 0x20(%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x54d8
leaq 0x138(%r15), %r14
movl (%rbx), %ecx
movq %rcx, %rax
xorl %edx, %edx
divq 0x140(%r15)
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x553e
testq %rax, %rax
je 0x3eb6
cmpq $0x0, (%rax)
je 0x3eb6
leaq 0x7345(%rip), %r14      # 0xb1c0
cmpq $0x0, (%r14)
jne 0x3ea0
movl $0x28, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%r14)
movq (%r14), %rax
incl (%rax)
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x21c0
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 0x6e72(%rip), %rax      # 0xad58
movq %rax, 0x8(%rsi)
movl $0x0, 0x20(%rsi)
movq %r15, %rdi
callq 0x5b96
movl 0x10(%rbx), %ecx
addl %ecx, 0x40(%rax)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x3f16
addq $0x30, %rax
movq %rbx, 0x18(%rcx)
movq %rcx, 0x20(%rbx)
jmp 0x3f1e
movq %rbx, 0x30(%rax)
addq $0x38, %rax
movq %rbx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d04
movq %rbx, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x54d8
leaq 0x138(%r14), %r15
movl (%rbx), %ecx
xorl %r12d, %r12d
movq %rcx, %rax
xorl %edx, %edx
divq 0x140(%r14)
movq %r15, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x553e
testq %rax, %rax
je 0x4206
movq (%rax), %r12
testq %r12, %r12
je 0x42bf
movq 0x10(%r12), %rsi
leaq 0x108(%r14), %rax
addq $0xd8, %r14
cmpl $0x1, 0x14(%rsi)
cmovneq %rax, %r14
leaq 0x8(%rsi), %rdi
movq 0x10(%r14), %rdx
leaq 0x8(%r14), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x425d
movq (%rdi), %r8
movq %rax, %rcx
xorl %r9d, %r9d
cmpq %r8, 0x20(%rdx)
setb %r9b
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%r9,8), %rdx
testq %rdx, %rdx
jne 0x4244
movq %rax, %r13
cmpq %rax, %rcx
je 0x4273
movq (%rdi), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %rax, %rcx
movq %rcx, %r13
cmpq %rax, %r13
je 0x4316
leaq 0x28(%r13), %rdi
movl 0x10(%rsi), %eax
subl %eax, 0x40(%r13)
callq 0x3206
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x429b
callq 0x21c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x32c8
movq %rbx, %rdi
callq 0x21c0
cmpl $0x0, 0x40(%r13)
je 0x4302
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6efa(%rip), %r14      # 0xb1c0
cmpq $0x0, (%r14)
jne 0x42eb
movl $0x28, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%r14)
movq (%r14), %rax
incl 0x8(%rax)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21c0
movq %r14, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5584
movq %rbx, %rsi
callq 0x249f
jmp 0x42b5
// File: /workspace/github_c_makefile_star2_O1/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 0x43d7
cmpq $0x0, 0x100(%rbx)
je 0x43d7
movq 0x120(%rbx), %rax
movq 0x20(%rax), %r14
leaq 0xe0(%rbx), %rdi
callq 0x2200
addq 0x20(%rax), %r14
movq %r14, %xmm1
punpckldq 0x2cc0(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2cc8(%rip), %xmm1     # 0x7040
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd 0x2c94(%rip), %xmm0     # 0x7020
leaq 0x2ea6(%rip), %rsi      # 0x7239
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 0x33fa
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5472
movq (%rsp), %rdi
jmp 0x440b
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ee7(%rip), %rsi      # 0x72ce
leaq 0x2ee4(%rip), %rdx      # 0x72d2
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x33fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5472
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x4415
callq 0x21c0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x4435
movq %rax, %rbx
jmp 0x443f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x443f
callq 0x21c0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x548c
movq %rbx, %rdi
callq 0x55bc
leaq 0xb0(%rbx), %r14
movq %r14, %rdi
callq 0x2290
testl %eax, %eax
jne 0x54bd
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x588e
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_O1/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 0x562f
movq %rbx, %rdi
callq 0x56cc
movq %rbx, %rdi
callq 0x5776
movb (%rbx), %al
testb $0x1, %al
je 0x5618
movq %rbx, %rdi
callq 0x56cc
movq %rbx, %rdi
popq %rbx
jmp 0x5776
// File: /workspace/github_c_makefile_star2_O1/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 0x575b
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 0x5742
movq %r12, %rdi
callq 0x588e
movq %r15, %rdi
callq 0x57e0
jmp 0x56f2
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_O1/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
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq 0x10(%rdi), %r13
movsbl %sil, %eax
movl %eax, 0x4(%rsp)
cmpq 0x8(%rdi), %r13
je 0x6393
movq %rdi, %r12
movl (%rbx), %eax
addl $0x32, %eax
movslq (%r15), %rbp
cmpl %ebp, %eax
jle 0x636a
leaq (,%rbp,2), %rsi
movl %esi, (%r15)
movq (%r14), %rdi
callq 0x22f0
movq %rax, (%r14)
leaq (%rax,%rbp), %rdi
movslq (%r15), %rdx
subq %rbp, %rdx
xorl %esi, %esi
callq 0x20f0
movslq (%rbx), %rdi
addq (%r14), %rdi
movl 0x10(%r13), %ecx
leaq 0xf5e(%rip), %rsi       # 0x72d9
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x2050
addl %eax, (%rbx)
movq 0x18(%r13), %r13
cmpq 0x8(%r12), %r13
jne 0x6337
movl (%rbx), %eax
addl $0x32, %eax
movslq (%r15), %r12
cmpl %r12d, %eax
jle 0x63c3
leaq (%r12,%r12), %rsi
movl %esi, (%r15)
movq (%r14), %rdi
callq 0x22f0
movq %rax, (%r14)
leaq (%rax,%r12), %rdi
movslq (%r15), %rdx
subq %r12, %rdx
xorl %esi, %esi
callq 0x20f0
movslq (%rbx), %rdi
addq (%r14), %rdi
movl 0x10(%r13), %ecx
leaq 0xf05(%rip), %rsi       # 0x72d9
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x2050
addl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/crcx[P]retroforth/tools/retro-unu.c
// Function: read_line
void read_line(FILE *file, char *line_buffer) {
  int ch = getc(file);
  int count = 0;
  while ((ch != '\n') && (ch != EOF)) {
    line_buffer[count] = ch;
    count++;
    ch = getc(file);
  }
  line_buffer[count] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x10a0
cmpl $-0x1, %eax
je 0x11d5
cmpl $0xa, %eax
je 0x11d5
movb %al, (%rbx,%r15)
incq %r15
jmp 0x11ba
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/crcx[P]retroforth/tools/retro-unu.c
// Function: fence_boundary
int fence_boundary(char *buffer, int tests_enabled) {
  int flag = 1;
  if (strcmp(buffer, code_start) == 0) { flag = -1; }
  if (strcmp(buffer, code_end) == 0)   { flag = -1; }
  if (tests_enabled == 0) { return flag; }
  if (strcmp(buffer, test_start) == 0) { flag = -1; }
  if (strcmp(buffer, test_end) == 0)   { flag = -1; }
  return flag;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x2e8e(%rip), %rsi      # 0x4080
callq 0x1060
testl %eax, %eax
sete %bl
leaq 0x2ead(%rip), %rsi      # 0x40b0
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
sete %al
orb %bl, %al
movzbl %al, %ebx
negl %ebx
orl $0x1, %ebx
testl %ebp, %ebp
je 0x1253
leaq 0x2ebb(%rip), %rsi      # 0x40e0
movq %r14, %rdi
callq 0x1060
movl %eax, %ebp
leaq 0x2eda(%rip), %rsi      # 0x4110
movq %r14, %rdi
callq 0x1060
xorl %ecx, %ecx
cmpl $0x1, %ebp
movl $0x0, %edx
sbbl %edx, %edx
cmpl $0x1, %eax
sbbl %ecx, %ecx
orl %edx, %ecx
orl %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %rbx
movl %esi, %ebp
leaq 0xd8f(%rip), %rsi       # 0x2004
callq 0x1080
testq %rax, %rax
je 0x12f6
movq %rax, %r14
movq %rax, %rdi
callq 0x1070
testl %eax, %eax
jne 0x12de
xorl %r12d, %r12d
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x11ac
movq %r15, %rdi
movl %ebp, %esi
callq 0x11e2
cmpl $-0x1, %eax
je 0x12c7
cmpl $0x1, %r12d
movl $0x0, %r12d
jne 0x12d2
movq %r15, %rdi
callq *%rbx
movl $0x1, %r12d
jmp 0x12d2
xorl %eax, %eax
testl %r12d, %r12d
sete %al
movl %eax, %r12d
movq %r14, %rdi
callq 0x1070
testl %eax, %eax
je 0x1294
movq %r14, %rdi
callq 0x1050
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd5c(%rip), %rdi       # 0x2059
callq 0x1040
movl $0x2, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 0x114c
cmpl $0x0, (%rbx)
je 0x114c
xorl %r14d, %r14d
jmp 0x11a3
cmpq $0x4001, %r15           # imm = 0x4001
jb 0x115c
movl $0x150001, %eax         # imm = 0x150001
jmp 0x1199
movl $0x10, %edi
callq 0x1050
testq %rax, %rax
je 0x1194
movq %rax, %r14
movq %r15, %rdi
callq 0x1050
movq %rax, (%r14)
testq %rax, %rax
je 0x11b2
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1040
xorl %eax, %eax
movq %r15, 0x8(%r14)
jmp 0x119c
movl $0x80000001, %eax       # imm = 0x80000001
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x11a3
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1030
xorl %r14d, %r14d
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x119c
// File: /workspace/github_c_makefile_star2_O1/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 0x11d8
cmpl $0x0, (%rbx)
jne 0x11f8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x11e5
callq 0x1030
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x11f8
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1234
cmpl $0x0, (%rbx)
je 0x1234
xorl %eax, %eax
jmp 0x133c
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 0x132e
movb $0x2a, (%rax)
movq %rax, %rcx
incq %rcx
testq %r15, %r15
je 0x1325
movq (%r14), %rdx
movl $0x2, %edi
movq 0x2d55(%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 0x12f2
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 0x1302
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 0x130e
movb (%rsi,%r9), %r8b
movb %r8b, 0x1(%rcx)
movw $0x3d3d, 0x2(%rcx)      # imm = 0x3D3D
jmp 0x130e
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 0x1283
xorl %edx, %edx
movw $0x2a, (%rcx)
jmp 0x1335
movl $0x80000001, %edx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x133c
movl %edx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e55
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x128c
movq 0x10(%rbx), %rdi
callq 0x1150
cmpl $0x8, %eax
jb 0x3e68
leaq 0x6e3(%rip), %rdi       # 0x452a
callq 0x1060
xorl %eax, %eax
callq 0x12ca
jmp 0x3e61
leaq 0x751(%rip), %rdi       # 0x45ad
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3ea1
movq 0x18(%rbx), %rdi
movzbl %al, %esi
callq 0x3a0b
testl %eax, %eax
je 0x3e86
leaq 0x700(%rip), %rdi       # 0x457f
callq 0x1060
jmp 0x3e98
movq 0x18(%rbx), %rsi
leaq 0x6ba(%rip), %rdi       # 0x454b
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_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xb9413e(%rip), %r14    # 0xb95750
leaq 0xb9dd77(%rip), %r15    # 0xb9f390
cmpl $0x2, %esi
jl 0x1767
cmpl $0x63, %esi
jle 0x1706
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 0x1657
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 0x1684
cmpq %rdx, %r10
jge 0x16b7
movl %r9d, -0x4(%rdi,%r13,4)
movl %r8d, (%rbx,%rdx,4)
addq %r13, %rsi
jmp 0x1643
movq 0x10(%rsp), %r12
movslq %r12d, %rcx
leaq (%rcx,%r13), %rax
decq %rax
cmpq $0x2, %rax
jl 0x16e6
leal -0x1(%r12), %esi
addq %r13, %rsi
movq %rbx, %rdi
movq %rcx, 0x8(%rsp)
callq 0x15fa
movq 0x8(%rsp), %rcx
leal (%r12,%r13), %eax
movl 0x4(%rsp), %esi
cmpl %esi, %eax
jge 0x1767
leaq (%rbx,%rcx,4), %rbx
subq %rbp, %rbx
subl %r12d, %esi
subl %r13d, %esi
incl %esi
jmp 0x1619
movl %esi, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
movq %rcx, %rsi
testq %rcx, %rcx
je 0x1759
movslq %edx, %rsi
movslq (%r14,%rsi,4), %rdi
negq %rdi
movslq (%r15,%rsi,4), %r8
movq %rcx, %rsi
leaq -0x1(%rsi), %r9
movl %r9d, %r10d
movslq (%rbx,%r10,4), %r10
movslq (%r15,%r10,4), %r11
imulq %rdi, %r11
movslq (%r14,%r10,4), %r12
imulq %r8, %r12
addq %r11, %r12
jns 0x1759
movl %r10d, (%rbx,%rsi,4)
leaq 0x1(%r9), %r10
movq %r9, %rsi
cmpq $0x1, %r10
jg 0x1726
xorl %esi, %esi
movslq %esi, %rsi
movl %edx, (%rbx,%rsi,4)
incq %rcx
cmpq %rax, %rcx
jne 0x170a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: combine
void combine(const char *in_even_fname, const char *in_odd_fname, const char *out_fname, int bytes)
{
	int c;
	FILE *fin_odd, *fin_even, *fout;
	fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_fname);
		return;
	}
	fin_even = fopen(in_even_fname, "rb");
	if (!fin_even)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_even_fname);
		fclose(fout);
		return;
	}
	fin_odd = fopen(in_odd_fname, "rb");
	if (!fin_odd)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_odd_fname);
		fclose(fin_even);
		fclose(fout);
		return;
	}

	do
	{
		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin_even);
			if (c != EOF)
			{
				fputc(c, fout);
			}
		}

		for (int i = 0; i < bytes; i++)
		{
			c = fgetc(fin_odd);
			if (c != EOF)
			{
				fputc(c, fout);
			}
		}
	} while (c != EOF);

	fclose(fout);
	fclose(fin_even);
	fclose(fin_odd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0xc67(%rip), %rsi       # 0x201a
movq %rdx, %rdi
callq 0x10a0
testq %rax, %rax
je 0x1477
movq %rax, %rbx
leaq 0xc36(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x10a0
testq %rax, %rax
je 0x14a0
movq %rax, %r14
leaq 0xc1b(%rip), %rsi       # 0x2004
movq %r12, %rdi
callq 0x10a0
testq %rax, %rax
je 0x14bd
movq %rax, %r15
movl %ebp, %r13d
testl %ebp, %ebp
jle 0x1424
movq %r14, %rdi
callq 0x1060
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x141f
movl %r12d, %edi
movq %rbx, %rsi
callq 0x1070
decl %r13d
jne 0x1404
movl %ebp, %r13d
testl %ebp, %ebp
jle 0x144b
movq %r15, %rdi
callq 0x1060
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x1446
movl %r12d, %edi
movq %rbx, %rsi
callq 0x1070
decl %r13d
jne 0x142b
cmpl $-0x1, %r12d
jne 0x13fd
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 0x2b7a(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb7f(%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 0x2b51(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb56(%rip), %rsi       # 0x2007
movq %r15, %rdx
xorl %eax, %eax
callq 0x1080
jmp 0x14e0
movq 0x2b34(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb39(%rip), %rsi       # 0x2007
movq %r12, %rdx
xorl %eax, %eax
callq 0x1080
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
jmp 0x1464
// File: /workspace/github_c_makefile_star2_O1/Mikejmoffitt[P]romtools/bsplit/bsplit.c
// Function: exchange
void exchange(const char *in_fname, const char *out_fname)
{
	int c;
	uint8_t byte[2];
	FILE *fin, *fout;
	fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Couldn't open %s.\n", out_fname);
		return;
	}
	fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Couldn't open %s.\n", in_fname);
		fclose(fout);
		return;
	}

	do
	{
		c = fgetc(fin);
		if (c == EOF)
		{
			break;
		}
		byte[0] = c;
		c = fgetc(fin);
		if (c == EOF)
		{
			break;
		}
		byte[1] = c;

		fputc(byte[1], fout);
		fputc(byte[0], fout);
	} while (c != EOF);

	fclose(fout);
	fclose(fin);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0xb1e(%rip), %rsi       # 0x201a
movq %r14, %rdi
callq 0x10a0
testq %rax, %rax
je 0x1590
movq %rax, %rbx
leaq 0xaed(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x10a0
testq %rax, %rax
je 0x15b5
movq %rax, %r14
movq %rax, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x1576
movl %eax, %ebp
movl $0xff, %r15d
movq %r14, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x1576
andl %r15d, %eax
movl %eax, %edi
movq %rbx, %rsi
callq 0x1070
andl %r15d, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1070
movq %r14, %rdi
callq 0x1060
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x1540
movq %rbx, %rdi
callq 0x1040
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1040
movq 0x2a61(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa66(%rip), %rsi       # 0x2007
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1080
movq 0x2a3c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xa41(%rip), %rsi       # 0x2007
movq %r15, %rdx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
jmp 0x1581