LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x90e1(%rip), %rsi      # 0x1076f
callq 0x7716
movq %rax, %rbx
testq %rax, %rax
je 0x76ff
movq %r14, (%rsp)
movl $0x10000, %r14d         # imm = 0x10000
pushq $0x1
popq %r13
testq %r15, %r15
je 0x76f4
cmpq %r14, %r15
movl $0x10000, %ebp          # imm = 0x10000
cmovbq %r15, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x2370
cmpq %rax, %rbp
jne 0x76d8
subq %rbp, %r15
addq %rbp, %r12
jmp 0x76a9
movq 0x10919(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
leaq 0x9089(%rip), %rsi      # 0x10772
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x21f0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x78c6
xorl %eax, %eax
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
testq %rdi, %rdi
je 0x795a
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2090
xorl %r14d, %r14d
testl %eax, %eax
cmovel %ebp, %r14d
movq %rbx, %rdi
callq 0x20d0
movq 0x14677(%rip), %rdi     # 0x1bf70
pushq $0x1
popq %rbp
testq %rdi, %rdi
je 0x79cf
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x624a
testl %eax, %eax
je 0x79cf
movq 0x1464f(%rip), %rdi     # 0x1bf70
cmpl $0x0, 0xc(%rdi)
jne 0x7934
callq 0x5f78
andq $0x0, 0x1463c(%rip)     # 0x1bf70
testl %r14d, %r14d
je 0x799a
cmpl $0x2, %r14d
jne 0x795e
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0x7f1c
testl %eax, %eax
je 0x795e
pushq $0x1
popq %r14
jmp 0x799a
xorl %ebp, %ebp
jmp 0x79cf
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x756b
testl %eax, %eax
je 0x7982
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2070
testl %eax, %eax
jne 0x7997
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x2310
testl %eax, %eax
je 0x79da
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2070
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23c0
movq 0x8(%rsp), %rdi
callq 0x23c0
movl %r14d, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %r14
jmp 0x79a7
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8d53(%rip), %rsi      # 0x1076c
callq 0x22f0
testq %rax, %rax
je 0x7a5c
movq %rax, %r14
movq (%rbx), %r12
leaq 0x1(%r12), %rdi
callq 0x2250
movq %rax, %r15
pushq $0x1
popq %rsi
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 0x7a5f
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ce9(%rip), %rsi      # 0x1076c
callq 0x22f0
testq %rax, %rax
je 0x7ba6
movq %rax, %r12
movq %rbx, (%rsp)
movq %rax, %rdi
callq 0x75b3
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x2250
movq %rax, %r13
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x20b0
movq %rax, %r15
movb $0x0, (%r13,%rax)
movq %r12, %rdi
callq 0x20d0
incq %r15
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x7ba9
cmpq $0x1, %r14
jne 0x7aee
movq %r13, (%r12)
movq %r13, %rcx
pushq $0x1
popq %rbx
movzbl (%rcx), %edx
cmpl $0xa, %edx
je 0x7b0a
cmpl $0xd, %edx
je 0x7b0a
testl %edx, %edx
je 0x7b4e
movq %rcx, %rax
jmp 0x7b46
leaq 0x1(%rcx), %rax
movsbl 0x1(%rcx), %esi
addl %edx, %esi
cmpq $0x1, %r14
jne 0x7b35
movb $0x0, (%rcx)
cmpl $0x17, %esi
je 0x7b25
movq %rcx, %rax
cmpb $0x0, 0x1(%rax)
je 0x7b46
leaq 0x1(%rax), %rcx
movq %rcx, (%r12,%rbx,8)
jmp 0x7b43
cmpl $0x17, %esi
je 0x7b3d
movq %rcx, %rax
cmpb $0x0, 0x1(%rax)
je 0x7b46
incq %rbx
incq %rax
movq %rax, %rcx
jmp 0x7af4
testq %r14, %r14
je 0x7b58
movq %r13, %rbp
jmp 0x7b9b
leaq (%r15,%rbx,8), %rdi
addq $0x8, %rdi
callq 0x2250
testq %rax, %rax
je 0x7ba6
movq %rax, %r12
leaq 0x1(%rbx), %rax
andq $0x0, (%r12,%rbx,8)
leaq (%r12,%rax,8), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2230
movq %r13, %rdi
callq 0x23c0
movq (%rsp), %rax
testq %rax, %rax
je 0x7b9b
movl %ebx, (%rax)
incq %r14
movq %rbp, %r13
jmp 0x7ada
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
leaq 0xc(%rsp), %rsi
callq 0x7a6e
movq %rax, %r14
testq %rax, %rax
je 0x7c38
movq %rbx, 0x10(%rsp)
movl 0xc(%rsp), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
xorl %r13d, %r13d
movslq %r13d, %rbx
cmpq %r12, %r15
je 0x7c26
movq (%r14,%r12,8), %rdi
callq 0x3b64
movb (%rax), %cl
testb %cl, %cl
sete %dl
cmpb %bpl, %cl
sete %cl
orb %dl, %cl
jne 0x7c21
leal 0x1(%rbx), %r13d
movq %rax, (%r14,%rbx,8)
incq %r12
jmp 0x7bf7
andq $0x0, (%r14,%rbx,8)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7c38
movl %r13d, (%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7c73
movq %rbx, %rdi
callq 0x2100
decl %eax
js 0x7c73
movl %eax, %eax
cmpb $0xa, (%rbx,%rax)
jne 0x7c73
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d3c
cmpb $0x0, 0x31e(%rsp)
je 0x7d40
movq %rsp, %rdi
callq 0x2380
movq %rax, %rbx
movl $0x31f, %eax            # imm = 0x31F
movl %eax, %ebp
movq %r14, %rdi
callq 0x2210
testl %eax, %eax
jne 0x7d2b
movslq %ebp, %r15
cmpb $0xa, -0x1(%rbx,%r15)
je 0x7d2b
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 0x7d2b
leaq -0x1(%r15), %rax
addl %r15d, %eax
cmpb $0x0, -0x2(%r12,%r15)
jne 0x7cc8
movq %r12, %rdi
callq 0x2100
addl %eax, %ebp
movslq %ebp, %rax
cmpb $0xa, -0x1(%rax,%rbx)
jne 0x7d63
movb $0x0, -0x1(%rbx,%rax)
jmp 0x7d63
xorl %ebx, %ebx
jmp 0x7d63
movq %rsp, %rdi
callq 0x2100
testl %eax, %eax
jle 0x7d58
decl %eax
cmpb $0xa, (%rsp,%rax)
jne 0x7d58
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
callq 0x2380
movq %rax, %rbx
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_O2/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 0x7d92
cmpl $0x2f, %eax
jne 0x7da0
movq %rbx, %rdi
callq 0x2100
cmpl %ebp, %eax
jge 0x7dc8
jmp 0x7dda
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 0x7dcc
xorl %eax, %eax
jmp 0x7de8
movslq %r15d, %rax
addq %rax, %r14
incq %r14
movb $0x2f, -0x1(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2080
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x896a(%rip), %r15      # 0x1076c
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 0x7e4a
testq %rbx, %rbx
je 0x7e38
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x7e57
movq %r14, %rdi
callq 0x20d0
pushq $0x1
popq %rax
jmp 0x7e5f
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7e65
xorl %eax, %eax
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rsp)
leaq 0x410(%rsp), %r15
pushq $0x1
popq %r12
leaq 0x10(%rsp), %r13
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r12, %rsi
movq (%rsp), %rcx
callq 0x20b0
movq %rax, %rbp
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rcx
callq 0x20b0
movq %rax, %r14
cmpl %r14d, %ebp
cmovll %ebp, %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x21c0
testl %eax, %eax
jne 0x7ee4
cmpl %r14d, %ebp
jne 0x7ee8
testl %ebp, %ebp
jne 0x7e90
xorl %ebx, %ebx
jmp 0x7ef5
movl %eax, %ebx
jmp 0x7ef5
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %ebx
movq (%rsp), %rdi
callq 0x20d0
movq 0x8(%rsp), %rdi
callq 0x20d0
movl %ebx, %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_O2/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 0x8841(%rip), %r15      # 0x1076c
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 0x7f73
testq %rbx, %rbx
je 0x7f61
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x7f6e
movq %r14, %rdi
callq 0x20d0
cmpq %r14, %rbx
jmp 0x7f98
movq %rbx, %rdi
callq 0x75b3
movq %rax, %r15
movq %r14, %rdi
callq 0x75b3
movq %rbx, %rdi
cmpq %rax, %r15
jne 0x7f9d
movq %r14, %rsi
callq 0x7e65
testl %eax, %eax
sete %al
jmp 0x7fac
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_O2/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 0x7f1c
testl %eax, %eax
je 0x7fdd
pushq $0x1
popq %rbp
jmp 0x8093
leaq 0x8788(%rip), %rsi      # 0x1076c
movq %rbx, %rdi
callq 0x22f0
testq %rax, %rax
je 0x8085
movq %rax, %rbx
leaq 0x8770(%rip), %rsi      # 0x1076f
movq %r14, %rdi
callq 0x22f0
testq %rax, %rax
je 0x8089
movq %rax, %r14
movl $0x10000, %r13d         # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x2250
movq %rax, %r15
testq %rax, %rax
movl $0x400, %r12d           # imm = 0x400
cmovneq %r13, %r12
movq %rsp, %r13
cmovneq %rax, %r13
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0x2210
testl %eax, %eax
jne 0x806d
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x20b0
testl %eax, %eax
je 0x8039
movslq %eax, %rdx
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rcx
callq 0x2370
jmp 0x8039
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x23c0
pushq $0x1
popq %rbp
movq %r14, %rbx
jmp 0x808b
xorl %ebp, %ebp
jmp 0x8093
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_O2/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:
cmpl $0x80, %edi
jae 0x80c6
pushq $0x1
jmp 0x80dc
cmpl $0x4000, %edi           # imm = 0x4000
jae 0x80d2
pushq $0x2
jmp 0x80dc
cmpl $0x200000, %edi         # imm = 0x200000
jae 0x80de
pushq $0x3
popq %rax
retq
cmpl $0x10000000, %edi       # imm = 0x10000000
pushq $0x5
popq %rax
sbbl $0x0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x811d
movl $0xf0, %edi
movq %rbx, %rsi
callq 0x21b0
jmp 0x8125
cmpl $0x200000, %ebp         # imm = 0x200000
jb 0x818a
movl %ebp, %eax
shrl $0x18, %eax
leal 0xe0(%rax), %edi
cmpl $0x10000000, %ebp       # imm = 0x10000000
cmovael %eax, %edi
movq %rbx, %rsi
callq 0x21b0
movl %ebp, %eax
shrl $0x10, %eax
leal 0xc0(%rax), %edi
cmpl $0x200000, %ebp         # imm = 0x200000
cmovael %eax, %edi
movq %rbx, %rsi
callq 0x21b0
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
cmpl $0x4000, %ebp           # imm = 0x4000
jae 0x8141
cmpl $0x80, %ebp
jae 0x815d
jmp 0x817a
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8248
cmpl $0xc0, %ebp
jb 0x81f3
cmpl $0xe0, %ebp
jb 0x8201
cmpl $0xf0, %ebp
jne 0x820c
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shll $0x18, %r14d
jmp 0x8217
shll $0x8, %ebp
addl $0xffff8000, %ebp       # imm = 0xFFFF8000
movl %ebp, %r14d
jmp 0x823a
shll $0x10, %ebp
addl $0xff400000, %ebp       # imm = 0xFF400000
jmp 0x8228
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_O2/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 0x82bc
cmpl $0xc0, %r15d
jb 0x82c4
cmpl $0xe0, %r15d
jb 0x82d7
cmpl $0xf0, %r15d
jb 0x82e7
cmpl $0xf8, %r15d
jb 0x82f4
cmpl $0xfc, %r15d
jb 0x8301
cmpl $0xfe, %r15d
jb 0x8311
cmpl $0xff, %r15d
jne 0x831e
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shlq $0x38, %r14
jmp 0x8321
movl %r15d, %eax
jmp 0x839f
shll $0x8, %r15d
addl $0xffff8000, %r15d      # imm = 0xFFFF8000
movq %r15, %r14
jmp 0x8391
shll $0x10, %r15d
addl $0xff400000, %r15d      # imm = 0xFF400000
jmp 0x837f
shll $0x18, %r14d
addl $0x20000000, %r14d      # imm = 0x20000000
jmp 0x836c
addl $0xffffff10, %r15d      # imm = 0xFFFFFF10
shlq $0x20, %r15
jmp 0x835a
addl $0xffff08, %r15d        # imm = 0xFFFF08
shlq $0x28, %r15
movq %r15, %r14
jmp 0x8347
addl $0xff04, %r15d          # imm = 0xFF04
shlq $0x30, %r15
jmp 0x8334
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_O2/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:
cmpq $0x80, %rdi
jae 0x83c1
pushq $0x1
jmp 0x840d
cmpq $0x4000, %rdi           # imm = 0x4000
jae 0x83ce
pushq $0x2
jmp 0x840d
cmpq $0x200000, %rdi         # imm = 0x200000
jae 0x83db
pushq $0x3
jmp 0x840d
cmpq $0x10000000, %rdi       # imm = 0x10000000
jae 0x83e8
pushq $0x4
jmp 0x840d
movq %rdi, %rax
shrq $0x23, %rax
jne 0x83f5
pushq $0x5
jmp 0x840d
movq %rdi, %rax
shrq $0x2a, %rax
jne 0x8402
pushq $0x6
jmp 0x840d
movq %rdi, %rax
shrq $0x31, %rax
jne 0x840f
pushq $0x7
popq %rax
retq
shrq $0x38, %rdi
cmpq $0x1, %rdi
pushq $0x9
popq %rax
sbbl $0x0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq %rsi, %r14
movq %r14, %rax
shrq $0x38, %rax
je 0x8445
movl $0xff, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
jmp 0x8457
movq %r14, %rax
shrq $0x31, %rax
movl $0xfe, %eax
je 0x84f9
movq %r14, %rdi
sarq $0x38, %rdi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rdi
shrq $0x18, %rdi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rdi
shrq $0x10, %rdi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rdi
shrq $0x8, %rdi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movl %r14d, %edi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movl %r14d, %ecx
shrl $0x10, %ecx
movsbl %cl, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movl %r14d, %ecx
shrl $0x8, %ecx
movsbl %cl, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
movsbl %r14b, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
movq %r14, %rax
shrq $0x2a, %rax
movl $0xfc, %eax
jne 0x846a
movq %r14, %rax
shrq $0x23, %rax
movl $0xf8, %eax
jne 0x8480
movl $0xf0, %eax
cmpq $0xfffffff, %r14        # imm = 0xFFFFFFF
ja 0x8496
movl $0xe0, %eax
cmpq $0x1fffff, %r14         # imm = 0x1FFFFF
ja 0x84ac
cmpq $0x4000, %r14           # imm = 0x4000
jb 0x8554
movl $0xc0, %eax
jmp 0x84be
movl $0x80, %eax
cmpq $0x7f, %r14
ja 0x84d3
jmp 0x84e6
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
subl %edx, %ebx
cmpl $0x80000001, %ecx       # imm = 0x80000001
setae %al
cmpl %ecx, %ebx
setb %dl
orb %al, %dl
je 0x85d6
movq %rdi, %r14
cmpl $0x1000001, %ecx        # imm = 0x1000001
jb 0x8599
movl %ebx, %edi
sarl $0x18, %edi
movq %r14, %rsi
callq 0x21b0
jmp 0x85a1
cmpl $0x10001, %ecx          # imm = 0x10001
jb 0x85cc
movl %ebx, %edi
sarl $0x10, %edi
movq %r14, %rsi
callq 0x21b0
movl %ebx, %edi
sarl $0x8, %edi
movq %r14, %rsi
callq 0x21b0
movl %ebx, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
cmpl $0x101, %ecx            # imm = 0x101
jae 0x85ae
jmp 0x85bb
leaq 0x81d9(%rip), %rdi      # 0x107b6
leaq 0x7e3d(%rip), %rsi      # 0x10421
leaq 0x81dc(%rip), %rcx      # 0x107c7
movl $0x166d, %edx           # imm = 0x166D
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 %esi, %ebx
movq %rdi, %r14
cmpl $0x1000001, %edx        # imm = 0x1000001
jb 0x861a
movq %r14, %rdi
callq 0x2180
movl %eax, %r15d
shll $0x18, %r15d
jmp 0x8625
xorl %r15d, %r15d
cmpl $0x10001, %edx          # imm = 0x10001
jb 0x8662
movq %r14, %rdi
callq 0x2180
movzbl %al, %ebp
shll $0x10, %ebp
orl %r15d, %ebp
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
xorl %ebp, %ebp
cmpl $0x101, %edx            # imm = 0x101
jae 0x8636
jmp 0x8646
// File: /workspace/github_cpp_makefile_star2_O2/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 0x81af
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x86e6
xorl %r15d, %r15d
jmp 0x8723
movl %eax, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rsi
testq %r15, %r15
je 0x86ff
movq %r15, %rdi
callq 0x4e06
jmp 0x8707
movq %rsi, %rdi
callq 0x2250
movq %rax, %r15
movslq %r14d, %r14
pushq $0x1
popq %rsi
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_O2/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 0x8797
movq %rbx, %rdi
callq 0x2100
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0x5c, %ecx
je 0x877a
cmpl $0x2f, %ecx
jne 0x8797
decq %rax
cmpq $0x2, %rax
jne 0x8792
cmpb $0x3a, 0x1(%rbx)
jne 0x8792
movb $0x2f, %dl
cmpb $0x5c, %cl
je 0x8794
jmp 0x8797
xorl %edx, %edx
movb %dl, (%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x87c1
movq %rbx, %rdi
callq 0x2100
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0x5c, %ecx
je 0x87bc
cmpl $0x2f, %ecx
jne 0x87c1
movb $0x0, -0x1(%rbx,%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x87df
movslq -0x10(%rbx), %rax
jmp 0x87e1
xorl %eax, %eax
cmpq %rax, %r14
jge 0x87f4
movq (%rbx,%r14,8), %rdi
callq 0x23c0
incq %r14
jmp 0x87d4
movq %rsp, %rdi
callq 0x510d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8a58
movslq -0x10(%rbx), %rax
jmp 0x8a5a
xorl %eax, %eax
cmpq %rax, %r14
jge 0x8a6d
movq (%rbx,%r14,8), %rdi
callq 0x23c0
incq %r14
jmp 0x8a4d
movq %rsp, %rdi
callq 0x510d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x8cec
movl -0x10(%r14), %eax
jmp 0x8cee
xorl %eax, %eax
cmpl 0xf534(%rip), %eax      # 0x18228
jge 0x8de6
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x8ca9
movq %rax, %rbp
pushq $0x1
popq %r15
movq %rax, %r12
testq %rbp, %rbp
je 0x8d1f
movslq -0x10(%rbp), %rax
jmp 0x8d21
xorl %eax, %eax
leaq (,%rax,8), %rax
addq %rbp, %rax
cmpq %rax, %r12
jae 0x8d7e
movq (%r12), %rdi
callq 0x2380
movq %rax, %r13
testq %r14, %r14
je 0x8d54
movl -0x10(%r14), %eax
cmpl -0xc(%r14), %eax
jge 0x8d54
incl %eax
movl %eax, -0x10(%r14)
jmp 0x8d69
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
movl %r15d, %edx
callq 0x521e
movq 0x8(%rsp), %r14
movslq -0x10(%r14), %rax
movq %r13, -0x8(%r14,%rax,8)
addq $0x8, %r12
cmpl 0xf4ac(%rip), %eax      # 0x18228
jl 0x8d14
movq %rbp, %rdi
callq 0x8a3f
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x8d96
movl -0x10(%r14), %eax
jmp 0x8d98
xorl %eax, %eax
movq 0x10(%rsp), %rdi
cmpl 0xf485(%rip), %eax      # 0x18228
jge 0x8de6
callq 0x8c9f
movq %rax, %r15
movq %rax, %r12
testq %r15, %r15
je 0x8dbb
movslq -0x10(%r15), %rax
jmp 0x8dbd
xorl %eax, %eax
leaq (%r15,%rax,8), %rax
cmpq %rax, %r12
jae 0x8dde
movq (%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8cc8
movq %rax, %r14
addq $0x8, %r12
jmp 0x8db0
movq %r15, %rdi
callq 0x8a3f
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x8c9f
movq %rax, %r14
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
testq %r14, %r14
je 0x8e1f
movslq -0x10(%r14), %rax
jmp 0x8e21
xorl %eax, %eax
cmpq %rax, %r15
jge 0x8e34
movq (%r14,%r15,8), %rdi
callq 0x8df8
incq %r15
jmp 0x8e14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x510d
movq %rbx, %rdi
callq 0x8a7d
movq %rax, %r14
movq %rax, (%r15)
xorl %r15d, %r15d
testq %r14, %r14
je 0x8e5d
movslq -0x10(%r14), %rax
jmp 0x8e5f
xorl %eax, %eax
cmpq %rax, %r15
jge 0x8e72
movq (%r14,%r15,8), %rdi
callq 0x2070
incq %r15
jmp 0x8e52
leaq 0x8(%rsp), %rdi
callq 0x510d
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x12dbe(%rip)     # 0x1bf84
leaq 0x12db3(%rip), %rcx     # 0x1bf80
je 0x91f5
notl %eax
movl %edx, %edx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x91f2
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rsi,%rdi), %r9d
xorl %r9d, %r8d
xorl (%rcx,%r8,4), %eax
incq %rdi
jmp 0x91d5
notl %eax
retq
xorl %edi, %edi
pushq $0x8
popq %r8
cmpq $0x100, %rdi            # imm = 0x100
je 0x91cf
movl %r8d, %r10d
movl %edi, %r9d
subl $0x1, %r10d
jb 0x9229
movl %r9d, %r11d
shrl %r11d
andl $0x1, %r9d
negl %r9d
andl $0xedb88320, %r9d       # imm = 0xEDB88320
xorl %r11d, %r9d
jmp 0x920a
movl %r9d, (%rcx,%rdi,4)
incq %rdi
jmp 0x91fb
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edx, %ecx
movzwl %di, %r9d
shrl $0x10, %edi
movl $0x15b0, %r8d           # imm = 0x15B0
movl %edx, %eax
xorl %edx, %edx
divl %r8d
movl %edx, %r8d
movl $0xfff1, %r10d          # imm = 0xFFF1
testl %ecx, %ecx
je 0x9310
xorl %r11d, %r11d
leaq 0x7(%r11), %rax
cmpq %r8, %rax
jae 0x92e4
movzbl (%rsi,%r11), %eax
addq %rax, %r9
addq %r9, %rdi
movzbl 0x1(%rsi,%r11), %eax
addq %r9, %rax
addq %rax, %rdi
movzbl 0x2(%rsi,%r11), %edx
addq %rax, %rdx
addq %rdx, %rdi
movzbl 0x3(%rsi,%r11), %eax
addq %rdx, %rax
addq %rax, %rdi
movzbl 0x4(%rsi,%r11), %edx
addq %rax, %rdx
addq %rdx, %rdi
movzbl 0x5(%rsi,%r11), %eax
addq %rdx, %rax
addq %rax, %rdi
movzbl 0x6(%rsi,%r11), %edx
addq %rax, %rdx
addq %rdx, %rdi
movzbl 0x7(%rsi,%r11), %r9d
addq %rdx, %r9
addq %r9, %rdi
addq $0x8, %r11
jmp 0x9268
movzbl (%rsi,%r11), %eax
addq %rax, %r9
addq %r9, %rdi
incq %r11
cmpq %r8, %r11
jb 0x92d6
movq %r9, %rax
xorl %edx, %edx
divq %r10
movq %rdx, %r9
movq %rdi, %rax
xorl %edx, %edx
divq %r10
subl %r8d, %ecx
addq %r11, %rsi
movl $0x15b0, %r8d           # imm = 0x15B0
movq %rdx, %rdi
jmp 0x925d
shll $0x10, %edi
addl %edi, %r9d
movl %r9d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r8d, %r8d
leaq 0x7e1c(%rip), %rax      # 0x114e0
xorl %edx, %edx
xorl %r9d, %r9d
xorl %ecx, %ecx
cmpq $0x1a, %r8
je 0x970a
cmpl $0x5, %ecx
jg 0x96f0
cmpl $0x14, %r9d
je 0x971a
movslq %r9d, %r10
movzbl (%rsi,%r10), %r10d
shll %cl, %r10d
incl %r9d
addl %r10d, %edx
addl $0x8, %ecx
movl %edx, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r10b
movb %r10b, (%rdi,%r8)
incq %r8
sarl $0x6, %edx
addl $-0x6, %ecx
jmp 0x96cb
cmpl $0x4, %ecx
jne 0x9739
movslq %edx, %rcx
movb (%rcx,%rax), %al
movb %al, 0x1a(%rdi)
popq %rax
retq
leaq 0x71b6(%rip), %rdi      # 0x108d7
leaq 0x6cf9(%rip), %rsi      # 0x10421
leaq 0x71b0(%rip), %rcx      # 0x108df
movl $0x1943, %edx           # imm = 0x1943
callq 0x2140
leaq 0x71cf(%rip), %rdi      # 0x1090f
leaq 0x6cda(%rip), %rsi      # 0x10421
leaq 0x7191(%rip), %rcx      # 0x108df
movl $0x194c, %edx           # imm = 0x194C
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_close
void stb_cfg_close(stb_cfg *z)
{
   if (z->f) {
      int i;
      // write the file out
      fwrite(stb__cfg_sig, 12, 1, z->f);
      for (i=0; i < stb_arr_len(z->data); ++i) {
         stb_int16 n = strlen(z->data[i].key)+1;
         fwrite(&n, 2, 1, z->f);
         fwrite(z->data[i].key, n, 1, z->f);
         fwrite(&z->data[i].value_len, 4, 1, z->f);
         fwrite(z->data[i].value, z->data[i].value_len, 1, z->f);
      }
      fclose(z->f);
   }
   stb_arr_free(z->data);
   stb_free(z);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x99d7
leaq 0x6a4c(%rip), %rdi      # 0x10370
pushq $0xc
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x2370
pushq $0x10
popq %rbp
xorl %r15d, %r15d
pushq $0x2
popq %r12
pushq $0x4
popq %r13
movq (%rbx), %rax
testq %rax, %rax
je 0x994f
movslq -0x10(%rax), %rcx
jmp 0x9951
xorl %ecx, %ecx
cmpq %rcx, %r15
jge 0x99ce
movq -0x10(%rax,%rbp), %rdi
callq 0x2100
incl %eax
movw %ax, 0x6(%rsp)
movq 0x10(%rbx), %rcx
leaq 0x6(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2370
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq -0x10(%rax,%rbp), %rdi
movswq 0x6(%rsp), %rsi
movq %r14, %rdx
callq 0x2370
movq (%rbx), %rdi
addq %rbp, %rdi
movq 0x10(%rbx), %rcx
movq %r13, %rsi
movq %r14, %rdx
callq 0x2370
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq -0x8(%rax,%rbp), %rdi
movslq (%rax,%rbp), %rsi
movq %r14, %rdx
callq 0x2370
incq %r15
addq $0x18, %rbp
jmp 0x9941
movq 0x10(%rbx), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x510d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4992
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_read
int stb_cfg_read(stb_cfg *z, char *key, void *value, int len)
{
   int i;
   for (i=0; i < stb_arr_len(z->data); ++i) {
      if (!stb_stricmp(z->data[i].key, key)) {
         int n = stb_min(len, z->data[i].value_len);
         memcpy(value, z->data[i].value, n);
         if (n < len)
            *((char *) value + n) = 0;
         return 1;
      }
   }
   return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r12
pushq $-0x1
popq %r13
movq %r12, %r15
testq %r12, %r12
je 0x9a1e
movslq -0x10(%r12), %rax
jmp 0x9a20
xorl %eax, %eax
incq %r13
cmpq %rax, %r13
jge 0x9a69
movq (%r15), %rdi
addq $0x18, %r15
movq %r14, %rsi
callq 0x2040
testl %eax, %eax
jne 0x9a12
movl -0x8(%r15), %r12d
cmpl %ebp, %r12d
movl %ebp, %eax
cmovll %r12d, %eax
movq -0x10(%r15), %rsi
movslq %eax, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2230
pushq $0x1
popq %rax
cmpl %ebp, %r12d
jge 0x9a6b
movb $0x0, (%rbx,%r14)
jmp 0x9a6b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_write
void stb_cfg_write(stb_cfg *z, char *key, void *value, int len)
{
   int i;
   for (i=0; i < stb_arr_len(z->data); ++i)
      if (!stb_stricmp(z->data[i].key, key))
         break;
   if (i == stb_arr_len(z->data)) {
      stb__cfg_item p;
      p.key = stb_strdup(key, z);
      p.value = NULL;
      p.value_len = 0;
      stb_arr_push(z->data, p);
   }
   z->data[i].value = stb_malloc(z, len);
   z->data[i].value_len = len;
   memcpy(z->data[i].value, value, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
xorl %r12d, %r12d
movq %rbx, %r13
testq %rbx, %rbx
je 0x9ace
movslq -0x10(%rbx), %rbp
cmpq %rbp, %r12
jge 0x9ac7
movq (%r13), %rdi
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
je 0x9ac7
incq %r12
addq $0x18, %r13
jmp 0x9aa0
cmpl %ebp, %r12d
je 0x9ad1
jmp 0x9b1f
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x872c
movq %rax, %r15
movq (%r14), %rax
testq %rax, %rax
je 0x9af6
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0x9af6
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0x9b07
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x521e
movq (%r14), %rax
movslq -0x10(%rax), %rcx
imulq $0x18, %rcx, %rcx
movq %r15, -0x18(%rax,%rcx)
andq $0x0, -0x10(%rax,%rcx)
andl $0x0, -0x8(%rax,%rcx)
movslq 0xc(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4dcf
movq (%r14), %rcx
movl %r12d, %edx
imulq $0x18, %rdx, %rdx
movq %rax, 0x8(%rcx,%rdx)
movl %r15d, 0x10(%rcx,%rdx)
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230