LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_search_binary
int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest)
{
   int r;
   if (maxv < minv) return minv-1;
   s->minval = minv;
   s->maxval = maxv;
   s->mode = find_smallest ? STB_probe_binary_smallest : STB_probe_binary_largest;
   stb_probe_guess(s, &r);
   return r;
}

// Assembly:
movl %esi, %eax
cmpl %esi, %edx
jge 0x3d12
decl %eax
retq
pushq %rbx
subq $0x10, %rsp
movl %eax, (%rdi)
movl %edx, 0x4(%rdi)
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movl %eax, 0xc(%rdi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x3c80
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_search_open
int stb_search_open(stb_search *s, int minv, int find_smallest)
{
   int r;
   s->step   = 4;
   s->minval = minv;
   s->maxval = minv+s->step;
   s->mode = find_smallest ? STB_probe_open_smallest : STB_probe_open_largest;
   stb_probe_guess(s, &r);
   return r;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x4, 0x10(%rdi)
movl %esi, (%rdi)
addl $0x4, %esi
movl %esi, 0x4(%rdi)
xorl %eax, %eax
cmpl $0x1, %edx
adcl $0x2, %eax
movl %eax, 0xc(%rdi)
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x3c80
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strscpy
size_t stb_strscpy(char *d, const char *s, size_t n)
{
   size_t len = strlen(s);
   if (len >= n) {
      if (n) d[0] = 0;
      return 0;
   }
   strcpy(d,s);
   return len + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2100
cmpq %r12, %rax
jae 0x3da0
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2080
incq %rbx
jmp 0x3dab
testq %r12, %r12
je 0x3da9
movb $0x0, (%r14)
xorl %ebx, %ebx
movq %rbx, %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_prefix_count
int stb_prefix_count(char *s, char *t)
{
   int c=0;
   while (*t) {
      if (*s++ != *t++)
         break;
      ++c;
   }
   return c;
}

// Assembly:
movb (%rsi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x3e04
cmpb %cl, (%rdi,%rax)
jne 0x3e04
movb 0x1(%rsi,%rax), %cl
incq %rax
jmp 0x3df2
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_suffix
int stb_suffix(char *s, char *t)
{
   size_t n = strlen(s);
   size_t m = strlen(t);
   if (m <= n)
      return 0 == strcmp(s+n-m, t);
   else
      return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2100
movq %rax, %r15
movq %rbx, %rdi
callq 0x2100
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
ja 0x3e44
addq %r15, %r14
subq %rcx, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_suffixi
int stb_suffixi(char *s, char *t)
{
   size_t n = strlen(s);
   size_t m = strlen(t);
   if (m <= n)
      return 0 == stb_stricmp(s+n-m, t);
   else
      return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2100
movq %rax, %r15
movq %rbx, %rdi
callq 0x2100
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
ja 0x3e89
addq %r15, %r14
subq %rcx, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2040
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_skipnewline
char *stb_skipnewline(char *s)
{
   if (s[0] == '\r' || s[0] == '\n') {
      if (s[0]+s[1] == '\r' + '\n') ++s;
      ++s;
   }
   return s;
}

// Assembly:
movq %rdi, %rax
movzbl (%rdi), %ecx
cmpl $0xd, %ecx
je 0x3ec1
cmpl $0xa, %ecx
jne 0x3edb
movsbl %cl, %ecx
leaq 0x1(%rax), %rdx
movsbl 0x1(%rax), %esi
addl %ecx, %esi
cmpl $0x17, %esi
cmovneq %rax, %rdx
incq %rdx
movq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_trimwhite
char *stb_trimwhite(char *s)
{
   int i,n;
   s = stb_skipwhite(s);
   n = (int) strlen(s);
   for (i=n-1; i >= 0; --i)
      if (!isspace(s[i]))
         break;
   s[i+1] = 0;
   return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x23c0
movq (%rax), %r14
decq %rbx
movzbl 0x1(%rbx), %eax
incq %rbx
testb $0x20, 0x1(%r14,%rax,2)
jne 0x3eee
movq %rbx, %rdi
callq 0x2100
movl %eax, %edx
movl %eax, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
addq %rbx, %rdx
decq %rdx
testl %eax, %eax
jle 0x3f2d
movsbq (%rdx), %rsi
decl %eax
decq %rdx
testb $0x20, 0x1(%r14,%rsi,2)
jne 0x3f14
incl %eax
movl %eax, %ecx
movslq %ecx, %rax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_substr
char *stb_substr(char *t, int n)
{
   char *a;
   int z = (int) strlen(t);
   if (z < n) n = z;
   a = (char *) malloc(n+1);
   strncpy(a,t,n);
   a[n] = 0;
   return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x2100
cmpl %ebx, %eax
cmovll %eax, %ebx
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x2250
movq %rax, %r15
movslq %ebx, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2060
movb $0x0, (%r15,%rbx)
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_duplower
char *stb_duplower(char *s)
{
   char *p = strdup(s), *q = p;
   while (*q) {
      *q = tolower(*q);
      ++q;
   }
   return p;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x2390
movq %rax, %rbx
movb (%rax), %bpl
testb %bpl, %bpl
je 0x3fd9
callq 0x23b0
movq (%rax), %rax
movq %rbx, %rcx
incq %rcx
movsbq %bpl, %rdx
movb (%rax,%rdx,4), %dl
movb %dl, -0x1(%rcx)
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0x3fc4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strrchr2
char *stb_strrchr2(char *s, char x, char y)
{
   char *r = NULL;
   for(; *s; ++s)
      if (*s == x || *s == y)
         r = s;
   return r;
}

// Assembly:
movb (%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x4054
cmpb %dl, %cl
cmoveq %rdi, %rax
cmpb %sil, %cl
cmoveq %rdi, %rax
movb 0x1(%rdi), %cl
incq %rdi
jmp 0x403b
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_stristr
char *stb_stristr(char *s, char *t)
{
   size_t n = strlen(t);
   char *z;
   if (n==0) return s;
   while ((z = stb_strichr(s, *t)) != NULL) {
      if (0==stb_strnicmp(z, t, n))
         return z;
      s = z+1;
   }
   return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
testq %rax, %rax
je 0x411a
movq %rax, %r15
movsbl (%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4055
testq %rax, %rax
je 0x4118
movq %rax, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2260
testl %eax, %eax
je 0x411a
incq %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4055
movq %rax, %rbx
testq %rax, %rax
jne 0x40f1
xorl %ebx, %ebx
movq %rbx, %rax
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_strtok_raw
static char *stb_strtok_raw(char *output, char *src, char *delimit, int keep, int invert)
{
   if (invert) {
      while (*src && strchr(delimit, *src) != NULL) {
         *output++ = *src++;
      }
   } else {
      while (*src && strchr(delimit, *src) == NULL) {
         *output++ = *src++;
      }
   }
   *output = 0;
   if (keep)
      return src;
   else
      return *src ? src+1 : src;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %r12b
testl %r8d, %r8d
je 0x418d
testb %r12b, %r12b
je 0x4192
movsbl %r12b, %esi
movq %r15, %rdi
callq 0x2110
testq %rax, %rax
je 0x4192
movb %r12b, (%r14)
incq %r14
movb 0x1(%rbx), %r12b
incq %rbx
jmp 0x414a
movsbl %r12b, %esi
movq %r15, %rdi
callq 0x2110
testq %rax, %rax
jne 0x4192
movb %r12b, (%r14)
incq %r14
movb 0x1(%rbx), %r12b
incq %rbx
testb %r12b, %r12b
jne 0x416f
movb $0x0, (%r14)
testl %ebp, %ebp
jne 0x41a1
cmpb $0x1, (%rbx)
sbbq $-0x1, %rbx
movq %rbx, %rax
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_dupreplace
char *stb_dupreplace(char *src, char *find, char *replace)
{
   size_t len_find = strlen(find);
   size_t len_replace = strlen(replace);
   int count = 0;

   char *s,*p,*q;

   s = strstr(src, find);
   if (s == NULL) return strdup(src);
   do {
      ++count;
      s = strstr(s + len_find, find);
   } while (s != NULL);

   p = (char *)  malloc(strlen(src) + count * (len_replace - len_find) + 1);
   if (p == NULL) return p;
   q = p;
   s = src;
   for (;;) {
      char *t = strstr(s, find);
      if (t == NULL) {
         strcpy(q,s);
         assert(strlen(p) == strlen(src) + count*(len_replace-len_find));
         return p;
      }
      memcpy(q, s, t-s);
      q += t-s;
      memcpy(q, replace, len_replace);
      q += len_replace;
      s = t + len_find;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2100
movq %rax, %r13
movq %rbx, 0x20(%rsp)
movq %rbx, %rdi
callq 0x2100
movq %rax, %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x23a0
testq %rax, %rax
je 0x48f3
movq %r13, %rbx
subq %rbp, %rbx
movq $-0x1, %r12
addq %rbx, %r12
addq %r13, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x23a0
testq %rax, %rax
jne 0x4820
movq %r14, %rdi
callq 0x2100
subq %r12, %rax
movq %rax, %rdi
callq 0x2250
testq %rax, %rax
je 0x4909
movq %rbp, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r14, 0x8(%rsp)
movq %r14, %rbx
movq %rax, (%rsp)
movq %rax, %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23a0
movq %rax, %r14
testq %rax, %rax
je 0x48bb
movq %r14, %r13
subq %rbx, %r13
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2230
addq %rbp, %r13
movq %r13, %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x2230
addq %rbx, %r13
movq 0x18(%rsp), %rax
leaq (%r14,%rax), %rbx
movq %r13, %rbp
jmp 0x48e8
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2080
movq (%rsp), %rdi
callq 0x2100
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0x2100
subq %rax, %r13
addq %r12, %r13
cmpq $-0x1, %r13
jne 0x4924
testq %r14, %r14
jne 0x486b
jmp 0x4911
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2390
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdc4d(%rip), %rdi      # 0x12578
leaq 0xdbcf(%rip), %rsi      # 0x12501
leaq 0xdc77(%rip), %rcx      # 0x125b0
movl $0x8a7, %edx            # imm = 0x8A7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_replaceinplace
void stb_replaceinplace(char *src, char *find, char *replace)
{
   size_t len_find = strlen(find);
   size_t len_replace = strlen(replace);
   int delta;

   char *s,*p,*q;

   delta = len_replace - len_find;
   assert(delta <= 0);
   if (delta > 0) return;

   p = strstr(src, find);
   if (p == NULL) return;

   s = q = p;
   while (*s) {
      memcpy(q, replace, len_replace);
      p += len_find;
      q += len_replace;
      s = strstr(p, find);
      if (s == NULL) s = p + strlen(p);
      memmove(q, p, s-p);
      q += s-p;
      p = s;
   }
   *q = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movq %rax, %r13
movq %r15, 0x10(%rsp)
movq %r15, %rdi
callq 0x2100
movq %rax, %r12
movq %r13, 0x8(%rsp)
subl %r13d, %eax
testl %eax, %eax
jg 0x4a0d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23a0
testq %rax, %rax
je 0x49fe
movq %rax, %r13
cmpb $0x0, (%rax)
je 0x49f9
movq %r13, %rbp
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x2230
addq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x23a0
movq %rax, %r15
testq %rax, %rax
jne 0x49d6
movq %rbp, %rdi
callq 0x2100
movq %rax, %r15
addq %rbp, %r15
addq %r12, %r13
movq %r15, %rbx
subq %rbp, %rbx
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x22d0
addq %rbx, %r13
cmpb $0x0, (%r15)
movq %r15, %rbp
jne 0x49a0
movb $0x0, (%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdbc9(%rip), %rdi      # 0x125dd
leaq 0xdae6(%rip), %rsi      # 0x12501
leaq 0xdbc6(%rip), %rcx      # 0x125e8
movl $0x8bb, %edx            # imm = 0x8BB
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_section
void stb__add_section(char *buffer, char *data, int curlen, int newlen)
{
   if (newlen < curlen) {
      int z1 = newlen >> 1, z2 = newlen-z1;
      memcpy(buffer, data, z1-1);
      buffer[z1-1] = '.';
      buffer[z1-0] = '.';
      memcpy(buffer+z1+1, data+curlen-z2+1, z2-1);
   } else
      memcpy(buffer, data, curlen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
cmpl %edx, %ecx
jge 0x4a96
movl %ecx, %ebp
movl %ecx, %eax
sarl %eax
subl %eax, %ebp
movslq %eax, %r12
leaq -0x1(%r12), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
leaq (%r15,%r12), %rdi
incq %rdi
movw $0x2e2e, -0x2(%rdi)     # imm = 0x2E2E
movslq %r14d, %rsi
addq %rbx, %rsi
movslq %ebp, %rax
subq %rax, %rsi
incq %rsi
decl %eax
movslq %eax, %rdx
jmp 0x4a9f
movslq %r14d, %rdx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__splitpath_raw
static char *stb__splitpath_raw(char *buffer, char *path, int flag)
{
   int len=0,x,y, n = (int) strlen(path), f1,f2;
   char *s = stb_strrchr2(path, '/', '\\');
   char *t = strrchr(path, '.');
   if (s && t && t < s) t = NULL;
   if (s) ++s;

   if (flag == STB_EXT_NO_PERIOD)
      flag |= STB_EXT;

   if (!(flag & (STB_PATH | STB_FILE | STB_EXT))) return NULL;

   f1 = s == NULL ? 0 : s-path; // start of filename
   f2 = t == NULL ? n : t-path; // just past end of filename

   if (flag & STB_PATH) {
      x = 0; if (f1 == 0 && flag == STB_PATH) len=2;
   } else if (flag & STB_FILE) {
      x = f1;
   } else {
      x = f2;
      if (flag & STB_EXT_NO_PERIOD)
         if (buffer[x] == '.')
            ++x;
   }

   if (flag & STB_EXT)
      y = n;
   else if (flag & STB_FILE)
      y = f2;
   else
      y = f1;

   if (buffer == NULL) {
      buffer = (char *) malloc(y-x + len + 1);
      if (!buffer) return NULL;
   }

   if (len) { strcpy(buffer, "./"); return buffer; }
   strncpy(buffer, path+x, y-x);
   buffer[y-x] = 0;
   return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movb (%r14), %dl
xorl %r13d, %r13d
testb %dl, %dl
je 0x4ce9
movq %r14, %rcx
cmpb $0x5c, %dl
cmoveq %rcx, %r13
cmpb $0x2f, %dl
cmoveq %rcx, %r13
movb 0x1(%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x4cd1
cmpl $0x8, %ebp
movl $0xc, %r12d
cmovnel %ebp, %r12d
xorl %r15d, %r15d
testb $0x7, %r12b
je 0x4df3
movq %rbx, (%rsp)
leal 0x1(%r13), %ebp
testq %r13, %r13
cmovel %r15d, %ebp
subl %r14d, %ebp
testq %r13, %r13
cmovel %r15d, %ebp
movq %r14, %rdi
movq %rax, %rbx
movl $0x2e, %esi
callq 0x2130
movq %rbx, %rsi
cmpq %r13, %rax
cmovaeq %rax, %r15
testq %rax, %rax
cmoveq %rax, %r15
testq %r13, %r13
cmoveq %rax, %r15
movq %r15, %rax
subq %r14, %rax
testq %r15, %r15
cmoveq %rbx, %rax
testb $0x1, %r12b
jne 0x4d71
xorl %ecx, %ecx
movb $0x1, %r15b
testb $0x2, %r12b
movq (%rsp), %rbx
jne 0x4d8d
testb $0x8, %r12b
jne 0x4d92
movl %eax, %r13d
jmp 0x4da3
movl %r12d, %edx
xorl $0x1, %edx
xorl %ecx, %ecx
orl %ebp, %edx
setne %r15b
sete %cl
addl %ecx, %ecx
xorl %r13d, %r13d
movq (%rsp), %rbx
jmp 0x4da3
movl %ebp, %r13d
jmp 0x4da3
movslq %eax, %rdx
xorl %r13d, %r13d
cmpb $0x2e, (%rbx,%rdx)
sete %r13b
addl %eax, %r13d
testb $0x2, %r12b
cmovnel %eax, %ebp
testb $0x4, %r12b
cmovnel %esi, %ebp
testq %rbx, %rbx
jne 0x4dcd
addl %ebp, %ecx
subl %r13d, %ecx
incl %ecx
movslq %ecx, %rdi
callq 0x2250
movq %rax, %rbx
testq %rax, %rax
je 0x4df3
testb %r15b, %r15b
je 0x4df7
movslq %r13d, %rax
addq %rax, %r14
subl %r13d, %ebp
movslq %ebp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2060
movb $0x0, (%rbx,%r15)
jmp 0x4e00
xorl %ebx, %ebx
jmp 0x4e00
movb $0x0, 0x2(%rbx)
movw $0x2f2e, (%rbx)         # imm = 0x2F2E
movq %rbx, %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_replacedir
char *stb_replacedir(char *output, char *src, char *dir)
{
   char buffer[4096];
   stb_splitpath(buffer, src, STB_FILE | STB_EXT);
   if (dir)
      sprintf(output, "%s/%s", dir, buffer);
   else
      strcpy(output, buffer);
   return output;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x6, %edx
callq 0x4ca9
testq %r14, %r14
je 0x4e59
leaq 0xd813(%rip), %rsi      # 0x1265a
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2350
jmp 0x4e64
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_replaceext
char *stb_replaceext(char *output, char *src, char *ext)
{
   char buffer[4096];
   stb_splitpath(buffer, src, STB_PATH | STB_FILE);
   if (ext)
      sprintf(output, "%s.%s", buffer, ext[0] == '.' ? ext+1 : ext);
   else
      strcpy(output, buffer);
   return output;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x3, %edx
callq 0x4ca9
testq %r14, %r14
je 0x4eb6
xorl %ecx, %ecx
cmpb $0x2e, (%r14)
sete %cl
addq %r14, %rcx
leaq 0xd7b9(%rip), %rsi      # 0x12660
movq %rsp, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2350
jmp 0x4ec1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_free
void stb_free(void *p)
{
   if (p == NULL) return;

   // count frees so that unit tests can see what's happening
   ++stb_alloc_count_free;

   switch(stb__identify(p)) {
      case STB__chunked:
         // freeing a chunked-block with children does nothing;
         // they only get freed when the parent does
         // surely this is wrong, and it should free them immediately?
         // otherwise how are they getting put on the right chain?
         return;
      case STB__nochildren: {
         stb__nochildren *s = (stb__nochildren *) p - 1;
         // unlink from sibling chain
         *(s->prevn) = s->next;
         if (s->next)
            *stb__prevn(s->next) = s->prevn;
         free(s);
         return;
      }
      case STB__alloc: {
         stb__alloc *s = (stb__alloc *) p - 1;
         stb__chunk *c, *n;
         void *q;

         // unlink from sibling chain, if any
         *(s->prevn) = s->next;
         if (s->next)
            *stb__prevn(s->next) = s->prevn;

         // first free chunks
         c = (stb__chunk *) stb__chunks(s);
         while (c != NULL) {
            n = c->next;
            stb_alloc_count_free += c->alloc;
            free(c);
            c = n;
         }

         // validating
         stb__setchunks(s,NULL);
         s->prevn = NULL;
         s->next = NULL;

         // now free children
         while ((q = s->child) != NULL) {
            stb_free(q);
         }

         // now free self
         free(s);
         return;
      }
      default:
         assert(0); /* NOTREACHED */
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4f38
movq %rdi, %r14
incl 0x1903e(%rip)           # 0x1df20
movq -0x8(%rdi), %rax
movl %eax, %ecx
andl $0x3, %ecx
leaq 0xd32e(%rip), %rdx      # 0x12220
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq -0x10(%r14), %rbx
movq -0x10(%r14), %rcx
movq %rcx, (%rax)
movq -0x10(%r14), %rax
testq %rax, %rax
je 0x4f2b
movq -0x8(%r14), %rcx
leaq -0x8(%rax), %rdx
movl -0x8(%rax), %esi
andl $0x3, %esi
addq $-0x20, %rax
cmpl $0x2, %esi
cmovneq %rdx, %rax
movq %rcx, (%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x23d0
popq %rbx
popq %r14
popq %r15
retq
leaq -0x20(%r14), %rbx
movq -0x20(%r14), %rax
movq -0x10(%r14), %rcx
movq %rcx, (%rax)
movq -0x10(%r14), %rax
testq %rax, %rax
je 0x4f71
movq (%rbx), %rcx
leaq -0x8(%rax), %rdx
movl -0x8(%rax), %esi
andl $0x3, %esi
addq $-0x20, %rax
cmpl $0x2, %esi
cmovneq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%r14), %rdi
addq $-0x2, %rdi
movq (%rdi), %r15
movl 0xc(%rdi), %eax
addl %eax, 0x18f9b(%rip)     # 0x1df20
callq 0x23d0
movq %r15, %rdi
testq %r15, %r15
jne 0x4f79
movq $0x2, -0x8(%r14)
xorl %eax, %eax
movq %rax, -0x20(%r14)
movq %rax, -0x10(%r14)
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x4f2b
callq 0x4ecf
jmp 0x4fa4
leaq 0xd867(%rip), %rdi      # 0x12826
leaq 0xd53b(%rip), %rsi      # 0x12501
leaq 0xd699(%rip), %rcx      # 0x12666
movl $0xa27, %edx            # imm = 0xA27
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_realloc
void *stb_realloc(void *ptr, size_t newsize)
{
   stb__alloc_type t;

   if (ptr == NULL) return stb_malloc(NULL, newsize);
   if (newsize == 0) { stb_free(ptr); return NULL; }
   
   t = stb__identify(ptr);
   assert(t == STB__alloc || t == STB__nochildren);

   if (t == STB__alloc) {
      stb__alloc *s = (stb__alloc *) ptr - 1;

      s = (stb__alloc *) realloc(s, newsize + sizeof(*s));
      if (s == NULL) return NULL;

      ptr = s+1;

      // update pointers
      (*s->prevn) = ptr;
      if (s->next)
         *stb__prevn(s->next) = &s->next;

      if (s->child)
         *stb__prevn(s->child) = &s->child;

      return ptr;
   } else {
      stb__nochildren *s = (stb__nochildren *) ptr - 1;

      s = (stb__nochildren *) realloc(ptr, newsize + sizeof(s));
      if (s == NULL) return NULL;

      // update pointers
      (*s->prevn) = s+1;
      if (s->next)
         *stb__prevn(s->next) = &s->next;

      return s+1;
   }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x5443
testq %rsi, %rsi
je 0x5456
movl -0x8(%rdi), %eax
andl $0x3, %eax
je 0x545d
cmpl $0x2, %eax
jne 0x549f
addq $-0x20, %rdi
addq $0x20, %rsi
callq 0x22b0
testq %rax, %rax
je 0x549b
movq %rax, %rcx
addq $0x20, %rax
movq (%rcx), %rdx
movq %rax, (%rdx)
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x5434
leaq 0x10(%rcx), %rsi
leaq -0x8(%rdx), %rdi
movl -0x8(%rdx), %r8d
andl $0x3, %r8d
addq $-0x20, %rdx
cmpl $0x2, %r8d
cmovneq %rdi, %rdx
movq %rsi, (%rdx)
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x549d
addq $0x8, %rcx
jmp 0x5481
movl 0x14deb(%rip), %ecx     # 0x1a234
xorl %edi, %edi
movl $0x2, %edx
popq %rax
jmp 0x5184
callq 0x4ecf
jmp 0x549b
addq $0x8, %rsi
callq 0x22b0
testq %rax, %rax
je 0x549b
movq %rax, %rcx
addq $0x10, %rax
movq 0x8(%rcx), %rdx
movq %rax, (%rdx)
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x549d
leaq -0x8(%rdx), %rsi
movl -0x8(%rdx), %edi
andl $0x3, %edi
addq $-0x20, %rdx
cmpl $0x2, %edi
cmovneq %rsi, %rdx
movq %rcx, (%rdx)
jmp 0x549d
xorl %eax, %eax
popq %rcx
retq
leaq 0xd282(%rip), %rdi      # 0x12728
leaq 0xd054(%rip), %rsi      # 0x12501
leaq 0xd29c(%rip), %rcx      # 0x12750
movl $0xb5c, %edx            # imm = 0xB5C
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_realloc_c
void *stb_realloc_c(void *context, void *ptr, size_t newsize)
{
   if (ptr == NULL) return stb_malloc(context, newsize);
   if (newsize == 0) { stb_free(ptr); return NULL; }
   // @TODO: verify you haven't changed contexts
   return stb_realloc(ptr, newsize);
}

// Assembly:
testq %rsi, %rsi
je 0x54d3
testq %rdx, %rdx
je 0x54e6
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x53cd
movl 0x14d5b(%rip), %ecx     # 0x1a234
movq %rdx, %rsi
movl $0x2, %edx
jmp 0x5184
pushq %rax
movq %rsi, %rdi
callq 0x4ecf
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_reassign
void stb_reassign(void *new_context, void *ptr)
{
   stb__alloc *src = stb__get_context(new_context);

   stb__alloc_type t = stb__identify(ptr);
   assert(t == STB__alloc || t == STB__nochildren);

   if (t == STB__alloc) {
      stb__alloc *s = (stb__alloc *) ptr - 1;

      // unlink from old
      *(s->prevn) = s->next;
      if (s->next)
         *stb__prevn(s->next) = s->prevn;

      stb__insert_alloc(src, s);
   } else {
      stb__nochildren *s = (stb__nochildren *) ptr - 1;

      // unlink from old
      *(s->prevn) = s->next;
      if (s->next)
         *stb__prevn(s->next) = s->prevn;

      stb__insert_nochild(src, s);
   }
}

// Assembly:
testq %rdi, %rdi
je 0x550b
movq -0x8(%rdi), %rax
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x1, %ecx
jne 0x5514
decq %rax
jmp 0x551b
leaq 0x14d36(%rip), %rax     # 0x1a248
jmp 0x551b
addq $-0x20, %rdi
movq %rdi, %rax
movq -0x8(%rsi), %rcx
movl %ecx, %edx
andl $0x3, %edx
je 0x556c
cmpl $0x2, %edx
jne 0x55d1
movq -0x20(%rsi), %rcx
movq -0x10(%rsi), %rdx
movq %rdx, (%rcx)
movq -0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x5562
movq -0x20(%rsi), %rdx
leaq -0x8(%rcx), %rdi
movl -0x8(%rcx), %r8d
andl $0x3, %r8d
addq $-0x20, %rcx
cmpl $0x2, %r8d
cmovneq %rdi, %rcx
movq %rdx, (%rcx)
leaq 0x8(%rax), %rcx
movq %rcx, -0x20(%rsi)
jmp 0x55a3
movq -0x10(%rsi), %rdx
movq %rdx, (%rcx)
movq -0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x559b
movq -0x8(%rsi), %rdx
leaq -0x8(%rcx), %rdi
movl -0x8(%rcx), %r8d
andl $0x3, %r8d
addq $-0x20, %rcx
cmpl $0x2, %r8d
cmovneq %rdi, %rcx
movq %rdx, (%rcx)
leaq 0x8(%rax), %rcx
movq %rcx, -0x8(%rsi)
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rsi)
movq %rsi, 0x8(%rax)
testq %rcx, %rcx
je 0x55d0
addq $-0x10, %rsi
leaq -0x8(%rcx), %rax
movl -0x8(%rcx), %edx
andl $0x3, %edx
addq $-0x20, %rcx
cmpl $0x2, %edx
cmovneq %rax, %rcx
movq %rsi, (%rcx)
retq
pushq %rax
leaq 0xd14f(%rip), %rdi      # 0x12728
leaq 0xcf21(%rip), %rsi      # 0x12501
leaq 0xd18b(%rip), %rcx      # 0x12772
movl $0xb8b, %edx            # imm = 0xB8B
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arr_copy_
void * stb__arr_copy_(void *p, int elem_size)
{
   stb__arr *q;
   if (p == NULL) return p;
   q = (stb__arr *) stb__arr_malloc(sizeof(*q) + elem_size * stb_arrhead2(p)->limit);
   stb_arr_check2(p);
   memcpy(q, stb_arrhead2(p), sizeof(*q) + elem_size * stb_arrhead2(p)->len);
   q->stb_malloc = !!stb__arr_context;
   return q+1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5688
movl %esi, %ebp
movq %rdi, %r14
leaq -0x10(%rdi), %r15
movl -0xc(%rdi), %edi
imull %esi, %edi
addl $0x10, %edi
callq 0x5698
movq %rax, %rbx
movslq -0x10(%r14), %rax
movslq %ebp, %rdx
imulq %rax, %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2230
xorl %eax, %eax
cmpq $0x0, 0x188ac(%rip)     # 0x1df28
setne %al
movl %eax, 0x8(%rbx)
addq $0x10, %rbx
jmp 0x568a
xorl %ebx, %ebx
movq %rbx, %rax
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_arr_free_
void stb_arr_free_(void **pp)
{
   void *p = *pp;
   stb_arr_check2(p);
   if (p) {
      stb__arr *q = stb_arrhead2(p);
      if (q->stb_malloc)
         stb_free(q);
      else
         free(q);
   }
   *pp = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x56e3
leaq -0x10(%rax), %rdi
cmpl $0x0, -0x8(%rax)
je 0x56de
callq 0x4ecf
jmp 0x56e3
callq 0x23d0
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arrsize_
static void stb__arrsize_(void **pp, int size, int limit, int len  STB__PARAMS)
{
   void *p = *pp;
   stb__arr *a;
   stb_arr_check2(p);
   if (p == NULL) {
      if (len == 0 && size == 0) return;
      a = (stb__arr *) stb__arr_malloc(sizeof(*a) + size*limit);
      a->limit = limit;
      a->len   = len;
      a->stb_malloc = !!stb__arr_context;
      a->signature = stb_arr_signature;
   } else {
      a = stb_arrhead2(p);
      a->len = len;
      if (a->limit < limit) {
         void *p;
         if (a->limit >= 4 && limit < a->limit * 2)
            limit = a->limit * 2;
         if (a->stb_malloc)
            p = stb_realloc(a, sizeof(*a) + limit*size);
         else
            #ifdef STB_MALLOC_WRAPPER
            p = stb__realloc(a, sizeof(*a) + limit*size, file, line);
            #else
            p = realloc(a, sizeof(*a) + limit*size);
            #endif
         if (p) {
            a = (stb__arr *) p;
            a->limit = limit;
         } else {
            // throw an error!
         }
      }
   }
   a->len   = stb_min(a->len, a->limit);
   *pp = a+1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5750
leaq -0x10(%rax), %r14
movl %r15d, -0x10(%rax)
movl -0xc(%rax), %ecx
cmpl %ebp, %ecx
jge 0x579c
leal (%rcx,%rcx), %r15d
cmpl %ebp, %r15d
cmovlel %ebp, %r15d
cmpl $0x4, %ecx
cmovll %ebp, %r15d
imull %r15d, %esi
movslq %esi, %rsi
addq $0x10, %rsi
cmpl $0x0, -0x8(%rax)
je 0x5788
movq %r14, %rdi
callq 0x53cd
jmp 0x5790
movl %r15d, %eax
orl %esi, %eax
je 0x57b2
imull %ebp, %esi
addl $0x10, %esi
movl %esi, %edi
callq 0x5698
movq %rax, %r14
movl %ebp, 0x4(%rax)
movl %r15d, (%rax)
xorl %eax, %eax
cmpq $0x0, 0x187b1(%rip)     # 0x1df28
setne %al
movl %eax, 0x8(%r14)
movl $0x51bada7b, 0xc(%r14)  # imm = 0x51BADA7B
jmp 0x579c
movq %r14, %rdi
callq 0x22b0
testq %rax, %rax
je 0x579c
movl %r15d, 0x4(%rax)
movq %rax, %r14
movl (%r14), %eax
movl 0x4(%r14), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, (%r14)
addq $0x10, %r14
movq %r14, (%rbx)
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__arr_setlen_
void stb__arr_setlen_(void **pp, int size, int newlen  STB__PARAMS)
{
   void *p = *pp;
   stb_arr_check2(p);
   if (stb_arrcurmax2(p) < newlen || p == NULL) {
      stb__arrsize_(pp, size, newlen, newlen  STB__ARGS);
   } else {
      stb_arrhead2(p)->len = newlen;
   }
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x57ca
movl -0xc(%rax), %ecx
jmp 0x57cc
xorl %ecx, %ecx
testq %rax, %rax
je 0x57d9
cmpl %edx, %ecx
jl 0x57d9
movl %edx, -0x10(%rax)
retq
movl %edx, %ecx
jmp 0x56fd
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arr_insertn_
void stb__arr_insertn_(void **pp, int size, int i, int n  STB__PARAMS)
{
   void *p = *pp;
   if (n) {
      int z;

      if (p == NULL) {
         stb__arr_addlen_(pp, size, n  STB__ARGS);
         return;
      }

      z = stb_arr_len2(p);
      stb__arr_addlen_(&p, size, n  STB__ARGS);
      memmove((char *) p + (i+n)*size, (char *) p + i*size, size * (z-i));
   }
   *pp = p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
movq %r13, (%rsp)
testl %ecx, %ecx
je 0x588a
movl %ecx, %r15d
movl %esi, %ebp
testq %r13, %r13
je 0x5878
movl %edx, %r14d
movl -0x10(%r13), %r12d
movq %rsp, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x57e0
movq %rsp, %rax
movq (%rax), %rax
addl %r14d, %r15d
imull %ebp, %r15d
movslq %r15d, %rdi
addq %rax, %rdi
subl %r14d, %r12d
imull %ebp, %r14d
movslq %r14d, %rsi
addq %rax, %rsi
imull %ebp, %r12d
movslq %r12d, %rdx
callq 0x22d0
jmp 0x5885
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x57e0
testq %r13, %r13
je 0x5891
movq (%rsp), %rax
movq %rax, (%rbx)
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__arr_deleten_
void stb__arr_deleten_(void **pp, int size, int i, int n  STB__PARAMS)
{
   void *p = *pp;
   if (n) {
      memmove((char *) p + i*size, (char *) p + (i+n)*size, size * (stb_arr_len2(p)-(i+n)));
      stb_arrhead2(p)->len -= n;
   }
   *pp = p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r15
testl %ecx, %ecx
je 0x58e8
movl %ecx, %ebx
leal (%rbx,%rdx), %ecx
imull %esi, %edx
movslq %edx, %rdi
addq %r15, %rdi
movl %ecx, %eax
imull %esi, %eax
cltq
addq %r15, %rax
testq %r15, %r15
je 0x58d2
movl -0x10(%r15), %edx
jmp 0x58d4
xorl %edx, %edx
subl %ecx, %edx
imull %esi, %edx
movslq %edx, %rdx
movq %rax, %rsi
callq 0x22d0
subl %ebx, -0x10(%r15)
movq %r15, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash
unsigned int stb_hash(char *str)
{
   unsigned int hash = 0;
   while (*str)
      hash = (hash << 7) + (hash >> 25) + *str++;
   return hash + (hash >> 16);
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x590f
incq %rdi
xorl %ecx, %ecx
roll $0x7, %ecx
movsbl %al, %eax
addl %eax, %ecx
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x58fc
jmp 0x5911
xorl %ecx, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hashlen
unsigned int stb_hashlen(char *str, int len)
{
   unsigned int hash = 0;
   while (len-- > 0 && *str)
      hash = (hash << 7) + (hash >> 25) + *str++;
   return hash + (hash >> 16);
}

// Assembly:
testl %esi, %esi
jle 0x5939
incl %esi
xorl %ecx, %ecx
movsbl (%rdi), %eax
testl %eax, %eax
je 0x593b
roll $0x7, %ecx
incq %rdi
addl %eax, %ecx
decl %esi
cmpl $0x1, %esi
jg 0x5921
jmp 0x593b
xorl %ecx, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__stb__spmatrix_hash
unsigned int stb_hashptr(void *p)
{
   unsigned int x = (unsigned int) p;

   // typically lacking in low bits and high bits
   x = stb_rehash(x);
   x += x << 16;

   // pearson's shuffle
   x ^= x << 3;
   x += x >> 5;
   x ^= x << 2;
   x += x >> 15;
   x ^= x << 10;
   return stb_rehash(x);
}

// Assembly:
movl %edi, %eax
shrl $0x6, %eax
addl %edi, %eax
shrl $0x13, %edi
addl %eax, %edi
movl %edi, %eax
shll $0x10, %eax
addl %edi, %eax
movl %edi, %ecx
shll $0x13, %ecx
leal (%rcx,%rdi,8), %ecx
movl %esi, %edx
shrl $0x6, %edx
addl %esi, %edx
shrl $0x13, %esi
addl %edx, %esi
movl %esi, %edx
shll $0x10, %edx
addl %esi, %edx
movl %esi, %edi
shll $0x13, %edi
leal (%rdi,%rsi,8), %esi
movd %eax, %xmm0
movd %esi, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd %edx, %xmm0
movd %ecx, %xmm2
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
pxor %xmm1, %xmm0
movdqa %xmm0, %xmm1
psrld $0x5, %xmm1
paddd %xmm0, %xmm1
movdqa %xmm1, %xmm0
pslld $0x2, %xmm0
pxor %xmm1, %xmm0
movdqa %xmm0, %xmm1
psrld $0xf, %xmm1
paddd %xmm0, %xmm1
movdqa %xmm1, %xmm0
pslld $0xa, %xmm0
pxor %xmm1, %xmm0
movdqa %xmm0, %xmm1
psrld $0x6, %xmm1
paddd %xmm0, %xmm1
psrld $0x13, %xmm0
paddd %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %ecx
movl %ecx, %edx
shrl $0x6, %edx
movd %xmm0, %eax
addl %ecx, %eax
shrl $0x13, %ecx
addl %edx, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash2
unsigned int stb_hash2(char *str, unsigned int *hash2_ptr)
{
   unsigned int hash1 = 0x3141592c;
   unsigned int hash2 = 0x77f044ed;
   while (*str) {
      hash1 = (hash1 << 7) + (hash1 >> 25) + *str;
      hash2 = (hash2 << 11) + (hash2 >> 21) + *str;
      ++str;
   }
   *hash2_ptr = hash2 + (hash1 >> 16);
   return       hash1 + (hash2 >> 16);
}

// Assembly:
movb (%rdi), %dl
testb %dl, %dl
je 0x59fe
incq %rdi
movl $0x3141592c, %ecx       # imm = 0x3141592C
movl $0x77f044ed, %eax       # imm = 0x77F044ED
roll $0x7, %ecx
movsbl %dl, %edx
addl %edx, %ecx
roll $0xb, %eax
addl %edx, %eax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x59e6
jmp 0x5a08
movl $0x77f044ed, %eax       # imm = 0x77F044ED
movl $0x3141592c, %ecx       # imm = 0x3141592C
movl %ecx, %edx
shrl $0x10, %edx
addl %eax, %edx
movl %edx, (%rsi)
shrl $0x10, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash_number
unsigned int stb_hash_number(unsigned int hash)
{
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;
   return hash;
}

// Assembly:
leal (,%rdi,8), %eax
xorl %edi, %eax
movl %eax, %ecx
shrl $0x5, %ecx
addl %eax, %ecx
movl %ecx, %eax
shll $0x4, %eax
xorl %ecx, %eax
movl %eax, %ecx
shrl $0x11, %ecx
addl %eax, %ecx
movl %ecx, %edx
shll $0x19, %edx
xorl %ecx, %edx
movl %edx, %eax
shrl $0x6, %eax
addl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_perfect_hash
int stb_perfect_hash(stb_perfect *p, unsigned int x)
{
   stb_uint m = x * p->multiplicand;
   stb_uint y = x >> 16;
   stb_uint bv = (m >> 24) + y;
   stb_uint av = (m + y) >> 12;
   if (p->table == NULL) return -1;  // uninitialized table fails
   bv &= p->b_mask;
   av &= p->table_mask;
   if (p->large_bmap)
      av ^= p->large_bmap[bv];
   else
      av ^= p->small_bmap[bv];
   return p->table[av] == x ? av : -1;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x5b93
movl 0x4(%rdi), %edx
imull %esi, %edx
movl %esi, %r8d
shrl $0x10, %r8d
leal (%rdx,%r8), %ecx
shrl $0xc, %ecx
shrl $0x18, %edx
addl %r8d, %edx
andl 0x8(%rdi), %edx
andl 0x28(%rdi), %ecx
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0x5b99
movl %edx, %edx
movzwl (%r8,%rdx,2), %edx
jmp 0x5b9e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movzbl 0xc(%rdi,%rdx), %edx
xorl %ecx, %edx
cmpl %esi, (%rax,%rdx,4)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_perfect_destroy
void stb_perfect_destroy(stb_perfect *p)
{
   if (p->large_bmap) free(p->large_bmap);
   if (p->table     ) free(p->table);
   p->large_bmap = NULL;
   p->table      = NULL;
   p->b_mask     = 0;
   p->table_mask = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x63c3
callq 0x23d0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x63d1
callq 0x23d0
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq %rax, 0x30(%rbx)
movl %eax, 0x8(%rbx)
movl %eax, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ptrmap_delete
void stb_ptrmap_delete(stb_ptrmap *e, void (*free_func)(void *))
{
   int i;
   if (free_func)
      for (i=0; i < e->limit; ++i)
         if (e->table[i].k != STB_EMPTY && e->table[i].k != STB_EDEL) {
            if (free_func == free)
               free(e->table[i].v); // allow STB_MALLOC_WRAPPER to operate
            else
               free_func(e->table[i].v);
         }
   stb_ptrmap_destroy(e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6e2b
cmpl $0x0, 0x10(%rbx)
jle 0x6e2b
movq %rsi, %r14
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x131ca(%rip), %r13     # 0x19fc0
movq (%rbx), %rax
movq -0x8(%rax,%r15), %rcx
orq $0x4, %rcx
cmpq $0x6, %rcx
je 0x6e1b
movq (%rax,%r15), %rdi
cmpq %r13, %r14
je 0x6e16
callq *%r14
jmp 0x6e1b
callq 0x23d0
incq %r12
movslq 0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x6df6
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6791
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_idict_init
stb_define_hash_base(STB_noprefix, stb_idict, short type; short gc; STB_nofields, stb_idict_,stb_idict_,0.85f,
              stb_int32,STB_IEMPTY,STB_IDEL,STB_nocopy,STB_nodelete,STB_nosafe,
              STB_equal,STB_equal,
              return stb_rehash_improved(k);,stb_int32,STB_nonullvalue,0)

stb_idict * stb_idict_new_size(int size)
{
   stb_idict *e = (stb_idict *) malloc(sizeof(*e));
   if (e) {
      if (!stb_is_pow2(size))
         size = 1 << stb_log2_ceil(size);
      stb_idict_init(e, size);
      e->alloced = 1;
   }
   return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0x5, %esi
movl $0x4, %r15d
cmovgel %esi, %r15d
movl %r15d, 0x18(%rdi)
xorl %ebx, %ebx
movl %ebx, 0x14(%rdi)
leal -0x1(%r15), %eax
movl %eax, 0x10(%rdi)
movl %ebx, 0x1c(%rdi)
cvtsi2ss %r15d, %xmm0
movb $0x0, 0x2e(%rdi)
movw $0x0, 0x2c(%rdi)
cvtsi2sd %r15d, %xmm1
mulsd 0xb1a8(%rip), %xmm1     # 0x12028
cvttsd2si %xmm1, %eax
cmpl $0x41, %esi
cmovll %ebx, %eax
movss 0xb1c6(%rip), %xmm1     # 0x12058
mulss %xmm0, %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps 0xb260(%rip), %xmm1     # 0x12100
movl %eax, 0x28(%rdi)
cvttps2dq %xmm1, %xmm0
movq %xmm0, 0x20(%rdi)
leaq (,%r15,8), %rdi
callq 0x2250
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x6fcd
movl %r15d, %ecx
leaq -0x1(%rcx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0x18(,%rcx,8), %rcx
andq $-0x20, %rcx
movdqa 0xb245(%rip), %xmm1     # 0x12130
movdqa 0xb21d(%rip), %xmm2     # 0x12110
xorl %edx, %edx
movdqa 0xb163(%rip), %xmm3     # 0x12060
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0xb233(%rip), %xmm5     # 0x12140
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x6f49
movl $0x1, (%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x6f60
movl $0x1, 0x8(%rax,%rdx)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x6fa0
movl $0x1, 0x10(%rax,%rdx)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x6fb3
movl $0x1, 0x18(%rax,%rdx)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x20, %rdx
cmpq %rdx, %rcx
jne 0x6f0d
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_idict_remove_all
void stb_idict_remove_all(stb_idict *e)
{
   int n;
   for (n=0; n < e->limit; ++n)
      e->table[n].k = STB_IEMPTY;
   e->has_empty = e->has_del = 0;
}

// Assembly:
movslq 0x18(%rdi), %rdx
testq %rdx, %rdx
jle 0x7748
movq 0x8(%rdi), %rax
leal 0x3(%rdx), %ecx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %ecx
shlq $0x5, %rcx
movdqa 0xaac5(%rip), %xmm1     # 0x12130
movdqa 0xaa9d(%rip), %xmm2     # 0x12110
xorl %edx, %edx
movdqa 0xa9e3(%rip), %xmm3     # 0x12060
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0xaab3(%rip), %xmm5     # 0x12140
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x76c9
movl $0x1, (%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x76e0
movl $0x1, 0x8(%rax,%rdx)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x7720
movl $0x1, 0x10(%rax,%rdx)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x7733
movl $0x1, 0x18(%rax,%rdx)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x20, %rdx
cmpq %rdx, %rcx
jne 0x768d
movw $0x0, 0x2d(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sparse_ptr_matrix_new
stb_spmatrix *stb_sparse_ptr_matrix_new(int val_size)
{
   stb_spmatrix *m = stb__spmatrix_create();
   if (m) m->val_size = val_size;
   if (m) m->arena = stb_malloc_global(1);
   return m;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x48, %edi
callq 0x2250
testq %rax, %rax
je 0x7785
movq %rax, %rbx
movq %rax, %rdi
movl $0x10, %esi
callq 0x10c78
testl %eax, %eax
je 0x777d
movb $0x1, 0x34(%rbx)
jmp 0x7787
movq %rbx, %rdi
callq 0x23d0
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x77a9
movl %ebp, (%rbx)
movl 0x12aa0(%rip), %ecx     # 0x1a234
movl $0x1, %esi
xorl %edi, %edi
movl $0x2, %edx
callq 0x5184
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sparse_ptr_matrix_get
void *stb_sparse_ptr_matrix_get(stb_spmatrix *z, void *a, void *b, int create)
{
   stb__ptrpair t = { a,b };
   void *data = stb__spmatrix_get(z, t);
   if (!data && create) {
      data = stb_malloc_raw(z->arena, z->val_size);
      if (!data) return NULL;
      memset(data, 0, z->val_size);
      stb__spmatrix_add(z, t, data);
   }
   return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10d35
movq %r14, %rcx
xorq $0x1, %rcx
movq %rbx, %rdx
xorq $0x1, %rdx
orq %rcx, %rdx
jne 0x7824
cmpb $0x0, 0x35(%r15)
je 0x78b7
leaq 0x38(%r15), %rdi
jmp 0x78b2
movq %r14, %rcx
xorq $0x2, %rcx
movq %rbx, %rdx
xorq $0x2, %rdx
orq %rcx, %rdx
jne 0x7844
cmpb $0x0, 0x36(%r15)
je 0x78b7
leaq 0x40(%r15), %rdi
jmp 0x78b2
movl 0x18(%r15), %ecx
movl %ecx, %edx
andl %eax, %edx
movq 0x10(%r15), %rsi
movl %edx, %edi
leaq (%rdi,%rdi,2), %rdi
leaq (%rsi,%rdi,8), %rdi
movq (%rdi), %r8
cmpq $0x1, %r8
jne 0x786a
cmpq $0x1, 0x8(%rdi)
je 0x78b7
cmpq %r14, %r8
jne 0x7875
cmpq %rbx, 0x8(%rdi)
je 0x78ae
movl %eax, %edi
shrl $0x6, %edi
addl %eax, %edi
shrl $0x13, %eax
addl %edi, %eax
orl $0x1, %eax
xorl %r12d, %r12d
addl %eax, %edx
andl %ecx, %edx
leaq (%rdx,%rdx,2), %rdi
leaq (%rsi,%rdi,8), %rdi
movq (%rdi), %r8
cmpq $0x1, %r8
jne 0x78a3
cmpq $0x1, 0x8(%rdi)
je 0x78ba
cmpq %r14, %r8
jne 0x7887
cmpq %rbx, 0x8(%rdi)
jne 0x7887
addq $0x10, %rdi
movq (%rdi), %r12
jmp 0x78ba
xorl %r12d, %r12d
testl %ebp, %ebp
je 0x790e
testq %r12, %r12
jne 0x790e
movq 0x8(%r15), %rdi
movslq (%r15), %rsi
movl 0x12964(%rip), %ecx     # 0x1a234
movl $0x4, %edx
callq 0x5184
testq %rax, %rax
je 0x790b
movq %rax, %r12
movslq (%r15), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2160
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x10ded
jmp 0x790e
xorl %r12d, %r12d
movq %r12, %rax
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_sdict_new
stb_sdict * stb_sdict_new(int use_arena)
{
   stb_sdict *d = stb_sdict_create();
   if (d == NULL) return NULL;
   d->arena = use_arena ? stb_malloc_global(1) : NULL;
   return d;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x7a5a
testq %rax, %rax
je 0x82d7
movq %rax, %rbx
testl %ebp, %ebp
je 0x82db
movl 0x11f70(%rip), %ecx     # 0x1a234
movl $0x1, %esi
xorl %edi, %edi
movl $0x2, %edx
callq 0x5184
jmp 0x82dd
xorl %ebx, %ebx
jmp 0x82e0
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq