LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sdict_copy
stb_sdict* stb_sdict_copy(stb_sdict *old)
{
   stb_sdict *n;
   void *old_arena = old->arena;
   void *new_arena = old_arena ? stb_malloc_global(1) : NULL;
   old->arena = new_arena;
   n = stb_sdictinternal_copy(old);
   old->arena = old_arena;
   if (n)
      n->arena = new_arena;
   else if (new_arena)
      stb_free(new_arena);
   return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x8319
movl 0x11f31(%rip), %ecx     # 0x1a234
movl $0x1, %esi
xorl %edi, %edi
movl $0x2, %edx
callq 0x5184
movq %rax, %r14
jmp 0x831c
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rdi
callq 0x81b1
movq %rax, %r15
movq %r12, (%rbx)
testq %rax, %rax
je 0x8337
movq %r14, (%r15)
jmp 0x8344
testq %r14, %r14
je 0x8344
movq %r14, %rdi
callq 0x4ecf
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_filelen
size_t  stb_filelen(FILE *f)
{
   size_t len, pos;
   pos = ftell(f);
   fseek(f, 0, SEEK_END);
   len = ftell(f);
   fseek(f, pos, SEEK_SET);
   return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2200
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22a0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x22a0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_file
void *stb_file(char *filename, size_t *length)
{
   FILE *f = stb__fopen(filename, "rb");
   char *buffer;
   size_t len, len2;
   if (!f) return NULL;
   len = stb_filelen(f);
   buffer = (char *) malloc(len+2); // nul + extra
   len2 = fread(buffer, 1, len, f);
   if (len2 == len) {
      if (length) *length = len;
      buffer[len] = 0;
   } else {
      free(buffer);
      buffer = NULL;
   }
   fclose(f);
   return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0xa3d5(%rip), %rsi      # 0x1284c
callq 0x22f0
testq %rax, %rax
je 0x84c2
movq %rax, %rbx
movq %rax, %rdi
callq 0x8425
movq %rax, %r12
leaq 0x2(%rax), %rdi
callq 0x2250
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x20b0
cmpq %r12, %rax
jne 0x84c7
testq %r14, %r14
je 0x84bb
movq %r12, (%r14)
movb $0x0, (%r15,%r12)
jmp 0x84d2
xorl %r15d, %r15d
jmp 0x84da
movq %r15, %rdi
callq 0x23d0
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_filewrite
int stb_filewrite(char *filename, void *data, size_t length)
{
   FILE *f = stb_fopen(filename, "wb");
   if (f) {
      unsigned char *data_ptr = (unsigned char *) data;
      size_t remaining = length;
      while (remaining > 0) {
         size_t len2 = remaining > 65536 ? 65536 : remaining;
         size_t len3 = fwrite(data_ptr, 1, len2, f);
         if (len2 != len3) {
            fprintf(stderr, "Failed while writing %s\n", filename);
            break;
         }
         remaining -= len2;
         data_ptr += len2;
      }
      stb_fclose(f, stb_keep_if_different);
   }
   return f != NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
leaq 0xa34e(%rip), %rsi      # 0x1284f
movq %rdi, (%rsp)
callq 0x8593
movq %rax, %r14
testq %rax, %rax
je 0x857c
movl $0x10000, %r12d         # imm = 0x10000
testq %rbx, %rbx
je 0x856f
cmpq %r12, %rbx
movl $0x10000, %ebp          # imm = 0x10000
cmovbq %rbx, %rbp
movl $0x1, %esi
movq %r15, %rdi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x2370
movq %rax, %r13
cmpq %rax, %rbp
jne 0x8551
subq %rbp, %rbx
addq %rbp, %r15
cmpq %r13, %rbp
je 0x8518
jmp 0x856f
movq 0x11aa0(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xa2f0(%rip), %rsi      # 0x12852
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x21f0
jmp 0x854a
movq %r14, %rdi
movl $0x2, %esi
callq 0x8763
xorl %eax, %eax
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fclose
int     stb_fclose(FILE *f, int keep)
{
   stb__file_data *d;

   int ok = STB_FALSE;
   if (f == NULL) return 0;

   if (ferror(f))
      keep = stb_keep_no;

   fclose(f);

   if (stb__files && stb_ptrmap_remove(stb__files, f, (void **) &d)) {
      if (stb__files->count == 0) {
         stb_ptrmap_destroy(stb__files);
         stb__files = NULL;
      }
   } else
      return STB_TRUE; // not special

   if (keep == stb_keep_if_different) {
      // check if the files are identical
      if (stb_feq(d->name, d->temp_name)) {
         keep = stb_keep_no;
         ok = STB_TRUE;  // report success if no change
      }
   }

   if (keep != stb_keep_no) {
      if (stb_fexists(d->name) && remove(d->name)) {
         // failed to delete old, so don't keep new
         keep = stb_keep_no;
      } else {
         if (!stb_rename(d->temp_name, d->name))
            ok = STB_TRUE;
         else
            keep=stb_keep_no;
      }
   }

   if (keep == stb_keep_no)
      remove(d->temp_name);

   free(d->temp_name);
   free(d->name);
   free(d);

   return ok;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
testq %rdi, %rdi
je 0x883a
movl %esi, %ebx
movq %rdi, %r14
callq 0x2090
xorl %ebp, %ebp
testl %eax, %eax
cmovel %ebx, %ebp
movq %r14, %rdi
callq 0x20d0
movq 0x157e9(%rip), %rdi     # 0x1df80
movl $0x1, %ebx
testq %rdi, %rdi
je 0x8887
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x6b60
testl %eax, %eax
je 0x8887
movq 0x157bf(%rip), %rdi     # 0x1df80
cmpl $0x0, 0xc(%rdi)
jne 0x87d7
callq 0x6791
movq $0x0, 0x157a9(%rip) # 0x1df80
xorl %ebx, %ebx
cmpl $0x2, %ebp
jne 0x87fb
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0x8df6
movl %eax, %ebx
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
addl %ebp, %ebp
movb $0x1, %r14b
testl %ebp, %ebp
je 0x8850
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2220
testl %eax, %eax
je 0x883e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x2310
testl %eax, %eax
setne %r14b
movl $0x1, %eax
cmovel %eax, %ebx
jmp 0x8850
xorl %ebx, %ebx
jmp 0x8887
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2070
testl %eax, %eax
je 0x8819
testb %r14b, %r14b
je 0x8862
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2070
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23d0
movq 0x8(%rsp), %rdi
callq 0x23d0
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_file_max
void *  stb_file_max(char *filename, size_t *length)
{
   FILE *f = stb__fopen(filename, "rb");
   char *buffer;
   size_t len, maxlen;
   if (!f) return NULL;
   maxlen = *length;
   buffer = (char *) malloc(maxlen+1);
   len = fread(buffer, 1, maxlen, f);
   buffer[len] = 0;
   fclose(f);
   *length = len;
   return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x9f7e(%rip), %rsi      # 0x1284c
callq 0x22f0
testq %rax, %rax
je 0x8913
movq %rax, %r14
movq (%rbx), %r12
leaq 0x1(%r12), %rdi
callq 0x2250
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x20b0
movq %rax, %r12
movb $0x0, (%r15,%rax)
movq %r14, %rdi
callq 0x20d0
movq %r12, (%rbx)
jmp 0x8916
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_stringfile
char ** stb_stringfile(char *filename, int *plen)
{
   FILE *f = stb__fopen(filename, "rb");
   char *buffer, **list=NULL, *s;
   size_t len, count, i;

   if (!f) return NULL;
   len = stb_filelen(f);
   buffer = (char *) malloc(len+1);
   len = fread(buffer, 1, len, f);
   buffer[len] = 0;
   fclose(f);

   // two passes through: first time count lines, second time set them
   for (i=0; i < 2; ++i) {
      s = buffer;
      if (i == 1)
         list[0] = s;
      count = 1;
      while (*s) {
         if (*s == '\n' || *s == '\r') {
            // detect if both cr & lf are together
            int crlf = (s[0] + s[1]) == ('\n' + '\r');
            if (i == 1) *s = 0;
            if (crlf) ++s;
            if (s[1]) {  // it's not over yet
               if (i == 1) list[count] = s+1;
               ++count;
            }
         }
         ++s;
      }
      if (i == 0) {
         list = (char **) malloc(sizeof(*list) * (count+1) + len+1);
         if (!list) return NULL;
         list[count] = 0;
         // recopy the file so there's just a single allocation to free
         memcpy(&list[count+1], buffer, len+1);
         free(buffer);
         buffer = (char *) &list[count+1];
         if (plen) *plen = count;
      }
   }
   return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x9f12(%rip), %rsi      # 0x1284c
callq 0x22f0
testq %rax, %rax
je 0x8a50
movq %rax, %r15
movq %rbx, (%rsp)
movq %rax, %rdi
callq 0x8425
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x2250
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x20b0
movq %rax, %r14
movb $0x0, (%r12,%rax)
movq %r15, %rdi
callq 0x20d0
incq %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpq $0x1, %rbp
jne 0x899a
movq %r12, (%r15)
movl $0x1, %ebx
movq %r12, %rax
movzbl (%rax), %ecx
cmpl $0xa, %ecx
je 0x89b5
cmpl $0xd, %ecx
je 0x89b5
testl %ecx, %ecx
jne 0x89e6
jmp 0x89eb
cmpq $0x1, %rbp
jne 0x89be
movb $0x0, (%rax)
movsbl %cl, %ecx
movsbl 0x1(%rax), %edx
addl %ecx, %edx
cmpl $0x17, %edx
jne 0x89cf
incq %rax
cmpb $0x0, 0x1(%rax)
je 0x89e6
cmpq $0x1, %rbp
jne 0x89e3
leaq 0x1(%rax), %rcx
movq %rcx, (%r15,%rbx,8)
incq %rbx
incq %rax
jmp 0x89a2
testq %rbp, %rbp
je 0x89f5
movq %r12, %r13
jmp 0x8a3b
leaq (%r14,%rbx,8), %rdi
addq $0x8, %rdi
callq 0x2250
testq %rax, %rax
je 0x8a50
movq %rax, %r15
leaq 0x1(%rbx), %rax
movq $0x0, (%r15,%rbx,8)
leaq (%r15,%rax,8), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2230
movq %r12, %rdi
callq 0x23d0
movq (%rsp), %rax
testq %rax, %rax
je 0x8a3b
movl %ebx, (%rax)
leaq 0x1(%rbp), %rax
movq %r13, %r12
testq %rbp, %rbp
movq %rax, %rbp
je 0x8991
jmp 0x8a53
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_stringfile_trimmed
char ** stb_stringfile_trimmed(char *name, int *len, char comment)
{
   int i,n,o=0;
   char **s = stb_stringfile(name, &n);
   if (s == NULL) return NULL;
   for (i=0; i < n; ++i) {
      char *p = stb_skipwhite(s[i]);
      if (*p && *p != comment)
         s[o++] = p;
   }
   s[o] = NULL;
   if (len) *len = o;
   return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
leaq 0xc(%rsp), %rsi
callq 0x8925
xorl %ecx, %ecx
testq %rax, %rax
je 0x8aef
movq %rax, %rbx
movslq 0xc(%rsp), %r15
testq %r15, %r15
jle 0x8ada
xorl %r12d, %r12d
callq 0x23c0
xorl %ecx, %ecx
movq (%rbx,%r12,8), %rdx
movq (%rax), %rsi
decq %rdx
movzbl 0x1(%rdx), %edi
incq %rdx
testb $0x20, 0x1(%rsi,%rdi,2)
jne 0x8aa8
testb %dil, %dil
sete %sil
cmpb %bpl, %dil
sete %dil
orb %sil, %dil
jne 0x8ad2
movslq %ecx, %rsi
incl %ecx
movq %rdx, (%rbx,%rsi,8)
incq %r12
cmpq %r15, %r12
jne 0x8a9e
movslq %ecx, %rax
movq $0x0, (%rbx,%rax,8)
testq %r14, %r14
je 0x8af1
movl %ecx, (%r14)
jmp 0x8af1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fgets
char * stb_fgets(char *buffer, int buflen, FILE *f)
{
   char *p;
   buffer[0] = 0;
   p = fgets(buffer, buflen, f);
   if (p) {
      int n = strlen(p)-1;
      if (n >= 0)
         if (p[n] == '\n')
            p[n] = 0;
   }
   return p;
}

// Assembly:
pushq %rbx
movb $0x0, (%rdi)
callq 0x21d0
movq %rax, %rbx
testq %rax, %rax
je 0x8b2a
movq %rbx, %rdi
callq 0x2100
decl %eax
js 0x8b2a
movl %eax, %eax
cmpb $0xa, (%rbx,%rax)
jne 0x8b2a
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fgets_malloc
char * stb_fgets_malloc(FILE *f)
{
   // avoid reallocing for small strings
   char quick_buffer[800];
   quick_buffer[sizeof(quick_buffer)-2] = 0;
   if (!fgets(quick_buffer, sizeof(quick_buffer), f))
      return NULL;

   if (quick_buffer[sizeof(quick_buffer)-2] == 0) {
      int n = strlen(quick_buffer);
      if (n > 0 && quick_buffer[n-1] == '\n')
         quick_buffer[n-1] = 0;
      return strdup(quick_buffer);
   } else {
      char *p;
      char *a = strdup(quick_buffer);
      int len = sizeof(quick_buffer)-1;

      while (!feof(f)) {
         if (a[len-1] == '\n') break;
         a = (char *) realloc(a, len*2);
         p = &a[len];
         p[len-2] = 0;
         if (!fgets(p, len, f))
            break;
         if (p[len-2] == 0) {
            len += strlen(p);
            break;
         }
         len = len + (len-1);
      }
      if (a[len-1] == '\n')
         a[len-1] = 0;
      return a;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x320, %rsp            # imm = 0x320
movq %rdi, %r14
movq %rsp, %rdi
movb $0x0, 0x31e(%rdi)
movl $0x320, %esi            # imm = 0x320
movq %r14, %rdx
callq 0x21d0
testq %rax, %rax
je 0x8bf5
cmpb $0x0, 0x31e(%rsp)
je 0x8bf9
movq %rsp, %rdi
callq 0x2390
movq %rax, %rbx
movq %r14, %rdi
callq 0x2210
movl $0x31f, %r15d           # imm = 0x31F
testl %eax, %eax
jne 0x8c2b
movl $0x31f, %ebp            # imm = 0x31F
movslq %ebp, %r15
cmpb $0xa, -0x1(%rbx,%r15)
je 0x8c28
leal (%r15,%r15), %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x22b0
movq %rax, %rbx
movq %rax, %r12
addq %r15, %r12
movb $0x0, -0x2(%r15,%r12)
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x21d0
testq %rax, %rax
je 0x8c28
cmpb $0x0, -0x2(%r12,%r15)
je 0x8c1e
leaq -0x1(%r15), %rax
addl %eax, %r15d
movq %r14, %rdi
callq 0x2210
movl %r15d, %ebp
testl %eax, %eax
je 0x8b95
jmp 0x8c2b
xorl %ebx, %ebx
jmp 0x8c3a
movq %rsp, %rdi
callq 0x2100
testl %eax, %eax
jle 0x8c11
decl %eax
cmpb $0xa, (%rsp,%rax)
jne 0x8c11
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
callq 0x2390
movq %rax, %rbx
jmp 0x8c3a
movq %r12, %rdi
callq 0x2100
addl %eax, %ebp
movl %ebp, %r15d
movslq %r15d, %rax
cmpb $0xa, -0x1(%rax,%rbx)
jne 0x8c3a
movb $0x0, -0x1(%rbx,%rax)
movq %rbx, %rax
addq $0x320, %rsp            # imm = 0x320
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fullpath
int stb_fullpath(char *abs, int abs_size, char *rel)
{
   #ifdef _MSC_VER
   return _fullpath(abs, rel, abs_size) != NULL;
   #else
   if (rel[0] == '/' || rel[0] == '~') {
      if ((int) strlen(rel) >= abs_size)
         return 0;
      strcpy(abs,rel);
      return STB_TRUE;
   } else {
      int n;
      getcwd(abs, abs_size);
      n = strlen(abs);
      if (n+(int) strlen(rel)+2 <= abs_size) {
         abs[n] = '/';
         strcpy(abs+n+1, rel);
         return STB_TRUE;
      } else {
         return STB_FALSE;
      }
   }
   #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movzbl (%rdx), %eax
cmpl $0x7e, %eax
je 0x8c69
cmpl $0x2f, %eax
jne 0x8c77
movq %rbx, %rdi
callq 0x2100
cmpl %ebp, %eax
jge 0x8c9f
jmp 0x8cb1
movslq %ebp, %rsi
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2100
movq %rax, %r15
movq %rbx, %rdi
callq 0x2100
addl %r15d, %eax
addl $0x2, %eax
cmpl %ebp, %eax
jle 0x8ca3
xorl %eax, %eax
jmp 0x8cc1
movslq %r15d, %rax
addq %rax, %r14
incq %r14
movb $0x2f, -0x1(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2080
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fcmp
int stb_fcmp(char *s1, char *s2)
{
   FILE *f = stb__fopen(s1, "rb");
   FILE *g = stb__fopen(s2, "rb");

   if (f == NULL || g == NULL) {
      if (f) fclose(f);
      if (g) {
         fclose(g);
         return STB_TRUE;
      }
      return f != NULL;
   }

   return stb_fcmp_core(f,g);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0x9b71(%rip), %r15      # 0x1284c
movq %r15, %rsi
callq 0x22f0
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f0
movq %rax, %r14
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
testb %cl, %al
jne 0x8d25
testq %rbx, %rbx
je 0x8d11
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x8d32
movq %r14, %rdi
callq 0x20d0
movl $0x1, %eax
jmp 0x8d3a
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x8d40
xorl %eax, %eax
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fcmp_core
static int stb_fcmp_core(FILE *f, FILE *g)
{
   char buf1[1024],buf2[1024];
   int n1,n2, res=0;

   while (1) {
      n1 = fread(buf1, 1, sizeof(buf1), f);
      n2 = fread(buf2, 1, sizeof(buf2), g);
      res = memcmp(buf1,buf2,stb_min(n1,n2));
      if (res)
         break;
      if (n1 != n2) {
         res = n1 < n2 ? -1 : 1;
         break;
      }
      if (n1 == 0)
         break;
   }

   fclose(f);
   fclose(g);
   return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x410(%rsp), %r15
leaq 0x10(%rsp), %r12
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r14, %rcx
callq 0x20b0
movq %rax, %r13
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
movq 0x8(%rsp), %rcx
callq 0x20b0
movq %rax, %rbx
cmpl %ebx, %r13d
cmovll %r13d, %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
testl %eax, %eax
jne 0x8dbf
cmpl %ebx, %r13d
jne 0x8dc3
testl %r13d, %r13d
jne 0x8d66
xorl %ebp, %ebp
jmp 0x8dd0
movl %eax, %ebp
jmp 0x8dd0
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %ebp
movq %r14, %rdi
callq 0x20d0
movq 0x8(%rsp), %rdi
callq 0x20d0
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_feq
int stb_feq(char *s1, char *s2)
{
   FILE *f = stb__fopen(s1, "rb");
   FILE *g = stb__fopen(s2, "rb");

   if (f == NULL || g == NULL) {
      if (f) fclose(f);
      if (g) fclose(g);
      return f == g;
   }

   // feq is faster because it shortcuts if they're different length
   if (stb_filelen(f) != stb_filelen(g)) {
      fclose(f);
      fclose(g);
      return 0;
   }

   return !stb_fcmp_core(f,g);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0x9a47(%rip), %r15      # 0x1284c
movq %r15, %rsi
callq 0x22f0
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f0
movq %rax, %r14
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
testb %cl, %al
jne 0x8e4d
testq %rbx, %rbx
je 0x8e3b
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x8e48
movq %r14, %rdi
callq 0x20d0
cmpq %r14, %rbx
jmp 0x8e72
movq %rbx, %rdi
callq 0x8425
movq %rax, %r15
movq %r14, %rdi
callq 0x8425
movq %rbx, %rdi
cmpq %rax, %r15
jne 0x8e77
movq %r14, %rsi
callq 0x8d40
testl %eax, %eax
sete %al
jmp 0x8e86
callq 0x20d0
movq %r14, %rdi
callq 0x20d0
xorl %eax, %eax
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_copyfile
int stb_copyfile(char *src, char *dest)
{
   char raw_buffer[1024];
   char *buffer;
   int buf_size = 65536;

   FILE *f, *g;

   // if file already exists at destination, do nothing
   if (stb_feq(src, dest)) return STB_TRUE;

   // open file
   f = stb__fopen(src, "rb");
   if (f == NULL) return STB_FALSE;

   // open file for writing
   g = stb__fopen(dest, "wb");
   if (g == NULL) {
      fclose(f);
      return STB_FALSE;
   }

   buffer = (char *) malloc(buf_size);
   if (buffer == NULL) {
      buffer = raw_buffer;
      buf_size = sizeof(raw_buffer);
   }

   while (!feof(f)) {
      int n = fread(buffer, 1, buf_size, f);
      if (n != 0)
         fwrite(buffer, 1, n, g);
   }

   fclose(f);
   if (buffer != raw_buffer)
      free(buffer);

   fclose(g);
   return STB_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8df6
movl $0x1, %ebp
testl %eax, %eax
jne 0x8f7a
leaq 0x998d(%rip), %rsi      # 0x1284c
movq %rbx, %rdi
callq 0x22f0
testq %rax, %rax
je 0x8f6c
movq %rax, %rbx
leaq 0x9975(%rip), %rsi      # 0x1284f
movq %r14, %rdi
callq 0x22f0
testq %rax, %rax
je 0x8f70
movq %rax, %r14
movl $0x10000, %r12d         # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x2250
movq %rax, %r15
testq %rax, %rax
movl $0x400, %r13d           # imm = 0x400
cmovneq %r12, %r13
movq %rsp, %r12
cmovneq %rax, %r12
movq %rbx, %rdi
callq 0x2210
testl %eax, %eax
jne 0x8f4d
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x20b0
testl %eax, %eax
je 0x8f15
movslq %eax, %rdx
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rcx
callq 0x2370
jmp 0x8f15
movq %rbx, %rdi
callq 0x20d0
movl $0x1, %ebp
testq %r15, %r15
je 0x8f67
movq %r12, %rdi
callq 0x23d0
movq %r14, %rbx
jmp 0x8f72
xorl %ebp, %ebp
jmp 0x8f7a
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x20d0
movl %ebp, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_varlenu
int stb_size_varlenu(unsigned int v)
{
   if (v < 0x00000080) return 1;
   if (v < 0x00004000) return 2;
   if (v < 0x00200000) return 3;
   if (v < 0x10000000) return 4;
   return 5;
}

// Assembly:
movl $0x1, %eax
cmpl $0x80, %edi
jb 0x9007
movl $0x2, %eax
cmpl $0x4000, %edi           # imm = 0x4000
jb 0x9007
movl $0x3, %eax
cmpl $0x200000, %edi         # imm = 0x200000
jb 0x9007
cmpl $0x10000000, %edi       # imm = 0x10000000
movl $0x5, %eax
sbbl $0x0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fput_varlenu
void    stb_fput_varlenu(FILE *f, unsigned int z)
{
   if (z >= 0x10000000) fputc(0xF0,f);
   if (z >= 0x00200000) fputc((z < 0x10000000 ? 0xE0 : 0)+(z>>24),f);
   if (z >= 0x00004000) fputc((z < 0x00200000 ? 0xC0 : 0)+(z>>16),f);
   if (z >= 0x00000080) fputc((z < 0x00004000 ? 0x80 : 0)+(z>> 8),f);
   fputc(z,f);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x10000000, %esi       # imm = 0x10000000
jb 0x9038
movl $0xf0, %edi
movq %rbx, %rsi
callq 0x21b0
cmpl $0x200000, %ebp         # imm = 0x200000
jb 0x905c
movl %ebp, %eax
shrl $0x18, %eax
leal 0xe0(%rax), %edi
cmpl $0x10000000, %ebp       # imm = 0x10000000
cmovael %eax, %edi
movq %rbx, %rsi
callq 0x21b0
cmpl $0x4000, %ebp           # imm = 0x4000
jb 0x9080
movl %ebp, %eax
shrl $0x10, %eax
leal 0xc0(%rax), %edi
cmpl $0x200000, %ebp         # imm = 0x200000
cmovael %eax, %edi
movq %rbx, %rsi
callq 0x21b0
cmpl $0x80, %ebp
jb 0x90a5
xorl %eax, %eax
cmpl $0x4000, %ebp           # imm = 0x4000
setb %al
shll $0x7, %eax
movl %ebp, %edi
shrl $0x8, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
movl %ebp, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_varlenu
unsigned int stb_fget_varlenu(FILE *f)
{
   unsigned int z;
   unsigned char d;
   d = stb_fgetc(f);

   if (d >= 0x80) {
      if (d >= 0xc0) {
         if (d >= 0xe0) {
            if (d == 0xf0) z = stb_fgetc(f) << 24;
            else           z = (d - 0xe0) << 24;
            z += stb_fgetc(f) << 16;
         }
         else
            z = (d - 0xc0) << 16;
         z += stb_fgetc(f) << 8;
      } else
         z = (d - 0x80) <<  8;
      z += stb_fgetc(f);
   } else
      z = d;
   return z;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2180
movl %eax, %r14d
movzbl %r14b, %ebp
cmpl $0x80, %ebp
jb 0x9161
cmpl $0xc0, %ebp
jb 0x910c
cmpl $0xe0, %ebp
jb 0x911a
cmpl $0xf0, %ebp
jne 0x9125
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shll $0x18, %r14d
jmp 0x9130
shll $0x8, %ebp
addl $0xffff8000, %ebp       # imm = 0xFFFF8000
movl %ebp, %r14d
jmp 0x9153
shll $0x10, %ebp
addl $0xff400000, %ebp       # imm = 0xFF400000
jmp 0x9141
shll $0x18, %r14d
addl $0x20000000, %r14d      # imm = 0x20000000
movq %rbx, %rdi
callq 0x2180
movzbl %al, %ebp
shll $0x10, %ebp
addl %r14d, %ebp
movq %rbx, %rdi
callq 0x2180
shll $0x8, %eax
movzwl %ax, %r14d
addl %ebp, %r14d
movq %rbx, %rdi
callq 0x2180
movzbl %al, %ebp
addl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_varlen64
stb_uint64   stb_fget_varlen64(FILE *f)
{
   stb_uint64 z;
   unsigned char d;
   d = stb_fgetc(f);

   if (d >= 0x80) {
      if (d >= 0xc0) {
         if (d >= 0xe0) {
            if (d >= 0xf0) {
               if (d >= 0xf8) {
                  if (d >= 0xfc) {
                     if (d >= 0xfe) {
                        if (d >= 0xff)
                           z = (stb_uint64) stb_fgetc(f) << 56;
                        else
                           z = (stb_uint64) (d - 0xfe) << 56;
                        z |= (stb_uint64) stb_fgetc(f) << 48;
                     } else z = (stb_uint64) (d - 0xfc) << 48;
                     z |= (stb_uint64) stb_fgetc(f) << 40;
                  } else z = (stb_uint64) (d - 0xf8) << 40;
                  z |= (stb_uint64) stb_fgetc(f) << 32;
               } else z = (stb_uint64) (d - 0xf0) << 32;
               z |= (stb_uint) stb_fgetc(f) << 24;
            } else z = (stb_uint) (d - 0xe0) << 24;
            z |= (stb_uint) stb_fgetc(f) << 16;
         } else z = (stb_uint) (d - 0xc0) << 16;
         z |= (stb_uint) stb_fgetc(f) << 8;
      } else z = (stb_uint) (d - 0x80) << 8;
      z |= stb_fgetc(f);
   } else
      z = d;

   return (z & 1) ? ~(z >> 1) : (z >> 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2180
movl %eax, %r14d
movzbl %r14b, %r15d
cmpl $0x80, %r15d
jb 0x91d5
cmpl $0xc0, %r15d
jb 0x91dd
cmpl $0xe0, %r15d
jb 0x91f0
cmpl $0xf0, %r15d
jb 0x9200
cmpl $0xf8, %r15d
jb 0x920d
cmpl $0xfc, %r15d
jb 0x921a
cmpl $0xfe, %r15d
jb 0x922a
cmpl $0xff, %r15d
jne 0x9237
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shlq $0x38, %r14
jmp 0x923a
movl %r15d, %eax
jmp 0x92b8
shll $0x8, %r15d
addl $0xffff8000, %r15d      # imm = 0xFFFF8000
movq %r15, %r14
jmp 0x92aa
shll $0x10, %r15d
addl $0xff400000, %r15d      # imm = 0xFF400000
jmp 0x9298
shll $0x18, %r14d
addl $0x20000000, %r14d      # imm = 0x20000000
jmp 0x9285
addl $0xffffff10, %r15d      # imm = 0xFFFFFF10
shlq $0x20, %r15
jmp 0x9273
addl $0xffff08, %r15d        # imm = 0xFFFF08
shlq $0x28, %r15
movq %r15, %r14
jmp 0x9260
addl $0xff04, %r15d          # imm = 0xFF04
shlq $0x30, %r15
jmp 0x924d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r15d
shlq $0x30, %r15
orq %r14, %r15
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r14d
shlq $0x28, %r14
orq %r15, %r14
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r15d
shlq $0x20, %r15
orq %r14, %r15
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shll $0x18, %r14d
orq %r15, %r14
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r15d
shll $0x10, %r15d
orq %r14, %r15
movq %rbx, %rdi
callq 0x2180
shll $0x8, %eax
movzwl %ax, %r14d
orq %r15, %r14
movq %rbx, %rdi
callq 0x2180
movzbl %al, %eax
orq %r14, %rax
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
negq %rax
xorq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_varlen64
int stb_size_varlen64(stb_uint64 v)
{
   if (v < 0x00000080) return 1;
   if (v < 0x00004000) return 2;
   if (v < 0x00200000) return 3;
   if (v < 0x10000000) return 4;
   if (v < STB_IMM_UINT64(0x0000000800000000)) return 5;
   if (v < STB_IMM_UINT64(0x0000040000000000)) return 6;
   if (v < STB_IMM_UINT64(0x0002000000000000)) return 7;
   if (v < STB_IMM_UINT64(0x0100000000000000)) return 8; 
   return 9;
}

// Assembly:
movl $0x1, %eax
cmpq $0x80, %rdi
jb 0x933f
movl $0x2, %eax
cmpq $0x4000, %rdi           # imm = 0x4000
jb 0x933f
movl $0x3, %eax
cmpq $0x200000, %rdi         # imm = 0x200000
jb 0x933f
movl $0x4, %eax
cmpq $0x10000000, %rdi       # imm = 0x10000000
jb 0x933f
movq %rdi, %rax
shrq $0x23, %rax
movl $0x5, %eax
je 0x933f
movq %rdi, %rax
shrq $0x2a, %rax
movl $0x6, %eax
je 0x933f
movq %rdi, %rax
shrq $0x31, %rax
movl $0x7, %eax
je 0x933f
shrq $0x38, %rdi
cmpq $0x1, %rdi
movl $0x9, %eax
sbbl $0x0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fput_varlen64
void    stb_fput_varlen64(FILE *f, stb_uint64 v)
{
   stb_uint64 z = stb__varlen_xform(v);
   int first=1;
   if (z >= STB_IMM_UINT64(0x100000000000000)) {
      fputc(0xff,f);
      first=0;
   }
   if (z >= STB_IMM_UINT64(0x02000000000000)) fputc((first ? 0xFE : 0)+(char)(z>>56),f), first=0;
   if (z >= STB_IMM_UINT64(0x00040000000000)) fputc((first ? 0xFC : 0)+(char)(z>>48),f), first=0;
   if (z >= STB_IMM_UINT64(0x00000800000000)) fputc((first ? 0xF8 : 0)+(char)(z>>40),f), first=0;
   if (z >= STB_IMM_UINT64(0x00000010000000)) fputc((first ? 0xF0 : 0)+(char)(z>>32),f), first=0;
   if (z >= STB_IMM_UINT64(0x00000000200000)) fputc((first ? 0xE0 : 0)+(char)(z>>24),f), first=0;
   if (z >= STB_IMM_UINT64(0x00000000004000)) fputc((first ? 0xC0 : 0)+(char)(z>>16),f), first=0;
   if (z >= STB_IMM_UINT64(0x00000000000080)) fputc((first ? 0x80 : 0)+(char)(z>> 8),f), first=0; 
   fputc((char)z,f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq %rsi, %r14
movq %r14, %r15
shrq $0x38, %r15
movl $0x1, %eax
je 0x936b
movl $0xff, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rcx
shrq $0x31, %rcx
je 0x9391
movq %r14, %rax
sarq $0x38, %rax
leal 0xfe(%rax), %edi
testq %r15, %r15
cmovnel %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rcx
shrq $0x2a, %rcx
je 0x93ba
testl %eax, %eax
movl $0xfc, %ecx
cmovel %eax, %ecx
movq %r14, %rdi
shrq $0x18, %rdi
sarl $0x18, %edi
addl %ecx, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rcx
shrq $0x23, %rcx
je 0x93e3
testl %eax, %eax
movl $0xf8, %ecx
cmovel %eax, %ecx
movq %r14, %rdi
shrq $0x10, %rdi
sarl $0x18, %edi
addl %ecx, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
cmpq $0x10000000, %r14       # imm = 0x10000000
jb 0x940c
testl %eax, %eax
movl $0xf0, %ecx
cmovel %eax, %ecx
movq %r14, %rdi
shrq $0x8, %rdi
sarl $0x18, %edi
addl %ecx, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
cmpq $0x200000, %r14         # imm = 0x200000
jb 0x9431
testl %eax, %eax
movl $0xe0, %ecx
cmovel %eax, %ecx
movl %r14d, %edi
sarl $0x18, %edi
addl %ecx, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
cmpq $0x4000, %r14           # imm = 0x4000
jb 0x9459
testl %eax, %eax
movl $0xc0, %ecx
cmovel %eax, %ecx
movl %r14d, %eax
shrl $0x10, %eax
movsbl %al, %edi
addl %ecx, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
cmpq $0x80, %r14
jb 0x9478
shll $0x7, %eax
movl %r14d, %ecx
shrl $0x8, %ecx
movsbl %cl, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
movsbl %r14b, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fput_ranged
void    stb_fput_ranged(FILE *f, int v, int b, stb_uint n)
{
   v -= b;
   if (n <= (1 << 31))
      assert((stb_uint) v < n);
   if (n > (1 << 24)) fputc(v >> 24, f);
   if (n > (1 << 16)) fputc(v >> 16, f);
   if (n > (1 <<  8)) fputc(v >>  8, f);
   fputc(v,f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
subl %edx, %ebx
cmpl $0x80000001, %ecx       # imm = 0x80000001
setae %al
cmpl %ecx, %ebx
setb %cl
orb %al, %cl
je 0x94f5
movq %rdi, %r14
cmpl $0x1000001, %ebp        # imm = 0x1000001
jb 0x94bd
movl %ebx, %edi
sarl $0x18, %edi
movq %r14, %rsi
callq 0x21b0
cmpl $0x10001, %ebp          # imm = 0x10001
jb 0x94d2
movl %ebx, %edi
sarl $0x10, %edi
movq %r14, %rsi
callq 0x21b0
cmpl $0x101, %ebp            # imm = 0x101
jb 0x94e7
movl %ebx, %edi
sarl $0x8, %edi
movq %r14, %rsi
callq 0x21b0
movl %ebx, %edi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
leaq 0x939a(%rip), %rdi      # 0x12896
leaq 0x8ffe(%rip), %rsi      # 0x12501
leaq 0x939d(%rip), %rcx      # 0x128a7
movl $0x166d, %edx           # imm = 0x166D
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_ranged
int     stb_fget_ranged(FILE *f, int b, stb_uint n)
{
   unsigned int v=0;
   if (n > (1 << 24)) v += stb_fgetc(f) << 24;
   if (n > (1 << 16)) v += stb_fgetc(f) << 16;
   if (n > (1 <<  8)) v += stb_fgetc(f) <<  8;
   v += stb_fgetc(f);
   return b+v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
cmpl $0x1000001, %edx        # imm = 0x1000001
jb 0x953a
movq %r14, %rdi
callq 0x2180
movl %eax, %ebp
shll $0x18, %ebp
cmpl $0x10001, %r15d         # imm = 0x10001
jb 0x9553
movq %r14, %rdi
callq 0x2180
movzbl %al, %eax
shll $0x10, %eax
orl %eax, %ebp
cmpl $0x101, %r15d           # imm = 0x101
jb 0x956c
movq %r14, %rdi
callq 0x2180
shll $0x8, %eax
movzwl %ax, %eax
addl %eax, %ebp
movq %r14, %rdi
callq 0x2180
movzbl %al, %eax
addl %ebx, %ebp
addl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_string
char *stb_fget_string(FILE *f, void *p)
{
   char *s;
   int len = stb_fget_varlenu(f);
   if (len > 4096) return NULL;
   s = p ? stb_malloc_string(p, len+1) : (char *) malloc(len+1);
   fread(s, 1, len, f);
   s[len] = 0;
   return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x90c8
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x9606
xorl %r15d, %r15d
jmp 0x964f
movl %eax, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rsi
testq %r15, %r15
je 0x9629
movq %r15, %rdi
movl $0x4, %edx
movl $0x1, %ecx
callq 0x5184
jmp 0x9631
movq %rsi, %rdi
callq 0x2250
movq %rax, %r15
movslq %r14d, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x20b0
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strdup
char *stb_strdup(char *str, void *pool)
{
   int len = strlen(str);
   char *p = stb_malloc_string(pool, len+1);
   strcpy(p, str);
   return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2100
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl $0x4, %edx
movl $0x1, %ecx
callq 0x5184
movq %rax, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2080
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strip_final_slash
char *stb_strip_final_slash(char *t)
{
   if (t[0]) {
      char *z = t + strlen(t) - 1;
      // *z is the last character
      if (*z == '\\' || *z == '/')
         if (z != t+2 || t[1] != ':') // but don't strip it if it's e.g. "c:/"
            *z = 0;
      if (*z == '\\')
         *z = '/'; // canonicalize to make sure it matches db
   }
   return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x96cd
movq %rbx, %rdi
callq 0x2100
movzbl -0x1(%rbx,%rax), %ecx
decq %rax
cmpl $0x5c, %ecx
je 0x96b3
cmpl $0x2f, %ecx
jne 0x96c3
cmpq $0x2, %rax
jne 0x96bf
cmpb $0x3a, 0x1(%rbx)
je 0x96c3
movb $0x0, (%rbx,%rax)
cmpb $0x5c, (%rbx,%rax)
jne 0x96cd
movb $0x2f, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strip_final_slash_regardless
char *stb_strip_final_slash_regardless(char *t)
{
   if (t[0]) {
      char *z = t + strlen(t) - 1;
      // *z is the last character
      if (*z == '\\' || *z == '/')
         *z = 0;
      if (*z == '\\')
         *z = '/'; // canonicalize to make sure it matches db
   }
   return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x9703
movq %rbx, %rdi
callq 0x2100
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0x5c, %ecx
je 0x96f2
cmpl $0x2f, %ecx
jne 0x96f7
movb $0x0, -0x1(%rbx,%rax)
cmpb $0x5c, -0x1(%rbx,%rax)
jne 0x9703
movb $0x2f, -0x1(%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_getopt_free
void   stb_getopt_free(char **opts)
{
   int i;
   char ** o2 = opts;
   for (i=0; i < stb_arr_len(o2); ++i)
      free(o2[i]);
   stb_arr_free(o2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x9721
movslq -0x10(%rbx), %rax
jmp 0x9723
xorl %eax, %eax
cmpq %rax, %r14
jge 0x9736
movq (%rbx,%r14,8), %rdi
callq 0x23d0
incq %r14
jmp 0x9716
movq %rsp, %rdi
callq 0x56c1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_readdir_free
void stb_readdir_free(char **files)
{
   char **f2 = files;
   int i;
   for (i=0; i < stb_arr_len(f2); ++i)
      free(f2[i]);
   stb_arr_free(f2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, (%rsp)
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x99f1
movslq -0x10(%rbx), %rax
jmp 0x99f3
xorl %eax, %eax
cmpq %rax, %r14
jge 0x9a06
movq (%rbx,%r14,8), %rdi
callq 0x23d0
incq %r14
jmp 0x99e6
movq %rsp, %rdi
callq 0x56c1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_readdir_rec
static char **stb_readdir_rec(char **sofar, char *dir, char *filespec)
{
   char **files;
   char ** dirs;
   char **p;

   if (stb_arr_len(sofar) >= stb__rec_max) return sofar;

   files = stb_readdir_files_mask(dir, filespec);
   stb_arr_for(p, files) {
      stb_arr_push(sofar, strdup(*p));
      if (stb_arr_len(sofar) >= stb__rec_max) break;
   }
   stb_readdir_free(files);
   if (stb_arr_len(sofar) >= stb__rec_max) return sofar;

   dirs = stb_readdir_subdirs(dir);
   stb_arr_for(p, dirs)
      sofar = stb_readdir_rec(sofar, *p, filespec);
   stb_readdir_free(dirs);
   return sofar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x9cba
movl -0x10(%rdi), %eax
jmp 0x9cbc
xorl %eax, %eax
cmpl 0x10576(%rip), %eax     # 0x1a238
jge 0x9dd4
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x9a1c
movq %rax, %r15
movq %rsp, %r12
movq %rax, %rbp
testq %r15, %r15
je 0x9ce9
movslq -0x10(%r15), %rax
jmp 0x9ceb
xorl %eax, %eax
leaq (%r15,%rax,8), %rax
cmpq %rax, %rbp
jae 0x9d65
movq (%rbp), %rdi
callq 0x2390
movq %rax, %r13
movq (%rsp), %rax
testq %rax, %rax
je 0x9d10
movl -0x10(%rax), %ecx
incl %ecx
jmp 0x9d15
movl $0x1, %ecx
testq %rax, %rax
je 0x9d1f
movl -0xc(%rax), %edx
jmp 0x9d21
xorl %edx, %edx
cmpl %edx, %ecx
jle 0x9d39
movq %r12, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0x9d3c
incl -0x10(%rax)
movq (%rsp), %rax
testq %rax, %rax
je 0x9d4f
movslq -0x10(%rax), %rcx
leaq (%rax,%rcx,8), %rax
jmp 0x9d51
xorl %ecx, %ecx
movq %r13, -0x8(%rax)
addq $0x8, %rbp
cmpl 0x104d9(%rip), %ecx     # 0x1a238
jl 0x9cde
movq %r15, %rdi
callq 0x99d8
movq (%rsp), %rax
testq %rax, %rax
je 0x9d7b
movl -0x10(%rax), %eax
jmp 0x9d7d
xorl %eax, %eax
cmpl 0x104b5(%rip), %eax     # 0x1a238
jge 0x9dd4
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x9a1c
movq %rax, %r14
movq (%rsp), %rax
movq %r14, %r15
testq %r14, %r14
je 0x9da9
movslq -0x10(%r14), %rcx
jmp 0x9dab
xorl %ecx, %ecx
leaq (%r14,%rcx,8), %rcx
cmpq %rcx, %r15
jae 0x9dc8
movq (%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x9c9b
addq $0x8, %r15
jmp 0x9d9e
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x99d8
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_delete_directory_recursive
void stb_delete_directory_recursive(char *dir)
{
   char **list = stb_readdir_subdirs(dir);
   int i;
   for (i=0; i < stb_arr_len(list); ++i)
      stb_delete_directory_recursive(list[i]);
   stb_arr_free(list);
   list = stb_readdir_files(dir);
   for (i=0; i < stb_arr_len(list); ++i)
      if (!remove(list[i])) {
         // on windows, try again after making it writeable; don't ALWAYS
         // do this first since that would be slow in the normal case
         #ifdef _MSC_VER
         _chmod(list[i], _S_IWRITE);
         remove(list[i]);
         #endif
      }
   stb_arr_free(list);
   stb__windows(_rmdir,rmdir)(dir);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x9a1c
movq %rax, %r14
movq %rax, (%rsp)
testq %r14, %r14
je 0x9e13
movslq -0x10(%r14), %rax
jmp 0x9e15
xorl %eax, %eax
cmpq %rax, %r15
jge 0x9e28
movq (%r14,%r15,8), %rdi
callq 0x9de7
incq %r15
jmp 0x9e08
movq %rsp, %r15
movq %r15, %rdi
callq 0x56c1
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9a1c
movq %rax, %r14
movq %rax, (%r15)
testq %r14, %r14
je 0x9e53
movslq -0x10(%r14), %rax
jmp 0x9e55
xorl %eax, %eax
cmpq %rax, %r12
jge 0x9e68
movq (%r14,%r12,8), %rdi
callq 0x2070
incq %r12
jmp 0x9e48
movq %rsp, %rdi
callq 0x56c1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_crc32_block
stb_uint stb_crc32_block(stb_uint crc, unsigned char *buffer, stb_uint len)
{
   static stb_uint crc_table[256];
   stb_uint i,j,s;
   crc = ~crc;

   if (crc_table[1] == 0)
      for(i=0; i < 256; i++) {
         for (s=i, j=0; j < 8; ++j)
            s = (s >> 1) ^ (s & 1 ? 0xedb88320 : 0);
         crc_table[i] = s;
      }
   for (i=0; i < len; ++i)
      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
   return ~crc;
}

// Assembly:
movl %edi, %eax
cmpl $0x0, 0x13cfd(%rip)     # 0x1df94
leaq 0x13cf2(%rip), %rcx     # 0x1df90
jne 0xa2d7
xorl %edi, %edi
movl $0x8, %r8d
movl %edi, %r9d
movl %r9d, %r10d
shrl %r10d
andl $0x1, %r9d
negl %r9d
andl $0xedb88320, %r9d       # imm = 0xEDB88320
xorl %r10d, %r9d
decl %r8d
jne 0xa2ab
movl %r9d, (%rcx,%rdi,4)
incq %rdi
cmpq $0x100, %rdi            # imm = 0x100
jne 0xa2a2
testl %edx, %edx
je 0xa2fe
notl %eax
movl %edx, %edx
xorl %edi, %edi
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rsi,%rdi), %r9d
xorl %r9d, %r8d
xorl (%rcx,%r8,4), %eax
incq %rdi
cmpq %rdi, %rdx
jne 0xa2e1
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_adler32
stb_uint stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen)
{
   const unsigned long ADLER_MOD = 65521;
   unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
   unsigned long blocklen, i;

   blocklen = buflen % 5552;
   while (buflen) {
      for (i=0; i + 7 < blocklen; i += 8) {
         s1 += buffer[0], s2 += s1;
         s1 += buffer[1], s2 += s1;
         s1 += buffer[2], s2 += s1;
         s1 += buffer[3], s2 += s1;
         s1 += buffer[4], s2 += s1;
         s1 += buffer[5], s2 += s1;
         s1 += buffer[6], s2 += s1;
         s1 += buffer[7], s2 += s1;

         buffer += 8;
      }

      for (; i < blocklen; ++i)
         s1 += *buffer++, s2 += s1;

      s1 %= ADLER_MOD, s2 %= ADLER_MOD;
      buflen -= blocklen;
      blocklen = 5552;
   }
   return (s2 << 16) + s1;
}

// Assembly:
movzwl %di, %r8d
shrl $0x10, %edi
testl %edx, %edx
je 0xa424
movl %edx, %ecx
movl %edx, %eax
imulq $0x5e6ea9af, %rax, %rax # imm = 0x5E6EA9AF
shrq $0x2b, %rax
imull $0x15b0, %eax, %eax     # imm = 0x15B0
movl %edx, %r9d
subl %eax, %r9d
movabsq $0xf00e10d2fc5cd, %r10  # imm = 0xF00E10D2FC5CD
xorl %edx, %edx
cmpq $0x8, %r9
jb 0xa3b5
movq %rdx, %rax
movzbl (%rsi,%rdx), %edx
addq %r8, %rdx
addq %rdx, %rdi
movzbl 0x1(%rsi,%rax), %r8d
addq %rdx, %r8
addq %r8, %rdi
movzbl 0x2(%rsi,%rax), %edx
addq %r8, %rdx
addq %rdx, %rdi
movzbl 0x3(%rsi,%rax), %r8d
addq %rdx, %r8
addq %r8, %rdi
movzbl 0x4(%rsi,%rax), %edx
addq %r8, %rdx
addq %rdx, %rdi
movzbl 0x5(%rsi,%rax), %r8d
addq %rdx, %r8
addq %r8, %rdi
movzbl 0x6(%rsi,%rax), %edx
addq %r8, %rdx
addq %rdx, %rdi
movzbl 0x7(%rsi,%rax), %r8d
addq %rdx, %r8
addq %r8, %rdi
leaq 0x8(%rax), %rdx
addq $0xf, %rax
cmpq %r9, %rax
jb 0xa347
addq %rdx, %rsi
movq %r9, %rax
subq %rdx, %rax
jbe 0xa3d5
xorl %edx, %edx
movzbl (%rsi,%rdx), %r11d
addq %r11, %r8
addq %r8, %rdi
incq %rdx
cmpq %rdx, %rax
jne 0xa3bf
addq %rax, %rsi
movq %r8, %rax
mulq %r10
movq %r8, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0xf, %rax
imulq $0xfff1, %rax, %rax     # imm = 0xFFF1
subq %rax, %r8
movq %rdi, %rax
mulq %r10
movq %rdi, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0xf, %rax
imulq $0xfff1, %rax, %rax     # imm = 0xFFF1
subq %rax, %rdi
subl %r9d, %ecx
movl $0x15b0, %r9d           # imm = 0x15B0
jne 0xa33f
shll $0x10, %edi
addl %edi, %r8d
movl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sha1_readable
void stb_sha1_readable(char display[27], unsigned char sha[20])
{
   char encoding[65] = "0123456789abcdefghijklmnopqrstuv"
                       "wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ%$";
   int num_bits = 0, acc=0;
   int i=0,o=0;
   while (o < 26) {
      int v;
      // expand the accumulator
      if (num_bits < 6) {
         assert(i != 20);
         acc += sha[i++] << num_bits;
         num_bits += 8;
      }
      v = acc & ((1 << 6) - 1);
      display[o++] = encoding[v];
      acc >>= 6;
      num_bits -= 6;
   }
   assert(num_bits == 20*8 - 26*6);
   display[o++] = encoding[acc];   
}

// Assembly:
pushq %rax
xorl %edx, %edx
leaq 0x8e02(%rip), %rax      # 0x135d0
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpl $0x5, %ecx
jg 0xa7f5
cmpl $0x14, %r9d
je 0xa824
movslq %r9d, %r10
movzbl (%rsi,%r10), %r10d
shll %cl, %r10d
incl %r9d
addl %r10d, %r8d
addl $0x8, %ecx
movl %r8d, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r10b
movb %r10b, (%rdi,%rdx)
incq %rdx
sarl $0x6, %r8d
addl $-0x6, %ecx
cmpq $0x1a, %rdx
jne 0xa7d6
cmpl $0x4, %ecx
jne 0xa843
movslq %r8d, %rcx
movb (%rcx,%rax), %al
movb %al, 0x1a(%rdi)
popq %rax
retq
leaq 0x818c(%rip), %rdi      # 0x129b7
leaq 0x7ccf(%rip), %rsi      # 0x12501
leaq 0x8186(%rip), %rcx      # 0x129bf
movl $0x1943, %edx           # imm = 0x1943
callq 0x2140
leaq 0x81a5(%rip), %rdi      # 0x129ef
leaq 0x7cb0(%rip), %rsi      # 0x12501
leaq 0x8167(%rip), %rcx      # 0x129bf
movl $0x194c, %edx           # imm = 0x194C
callq 0x2140