LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2390
testq %rax, %rax
je 0x44cd
movq %r13, %rbx
subq %rbp, %rbx
pushq $-0x1
popq %r12
addq %rbx, %r12
addq %r13, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x2390
testq %rax, %rax
jne 0x43e1
movq %r14, %rdi
callq 0x2100
subq %r12, %rax
movq %rax, %rdi
callq 0x2250
testq %rax, %rax
je 0x44e3
movq %rbp, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r14, 0x8(%rsp)
movq %r14, %r13
movq %rax, (%rsp)
movq %rax, %rbp
movq %r13, %rdi
movq %r15, %rsi
callq 0x2390
testq %rax, %rax
je 0x447b
movq %rax, %r14
movq %rax, %rbx
subq %r13, %rbx
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2230
addq %rbp, %rbx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %r13
movq %r13, %rdx
callq 0x2230
addq %r13, %rbx
addq 0x18(%rsp), %r14
movq %r14, %r13
movq %rbx, %rbp
jmp 0x442c
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2080
movq (%rsp), %r14
movq %r14, %rdi
callq 0x2100
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2100
subq %rax, %rbx
movq %r14, %rax
addq %r12, %rbx
cmpq $-0x1, %rbx
je 0x44e5
leaq 0xbfe3(%rip), %rdi      # 0x10498
leaq 0xbf65(%rip), %rsi      # 0x10421
leaq 0xc00d(%rip), %rcx      # 0x104d0
movl $0x8a7, %edx            # imm = 0x8A7
callq 0x2140
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2380
xorl %eax, %eax
addq $0x28, %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_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, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movq %rax, %r15
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x2100
movq %rax, %r12
movq %r15, 0x8(%rsp)
subl %r15d, %eax
testl %eax, %eax
jg 0x45bf
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2390
testq %rax, %rax
je 0x45b0
movq %rax, %rbx
movq %rax, %r14
cmpb $0x0, (%rbx)
je 0x45ac
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x2230
addq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %r15
movq %r13, %rsi
callq 0x2390
movq %rax, %rbp
testq %rax, %rax
jne 0x458a
movq %rbx, %rdi
callq 0x2100
movq %rax, %rbp
addq %rbx, %rbp
addq %r12, %r14
movq %rbp, %r13
subq %rbx, %r13
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x22d0
addq %r13, %r14
movq %rbp, %rbx
movq %r15, %r13
jmp 0x454c
movb $0x0, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbf37(%rip), %rdi      # 0x104fd
leaq 0xbe54(%rip), %rsi      # 0x10421
leaq 0xbf34(%rip), %rcx      # 0x10508
movl $0x8bb, %edx            # imm = 0x8BB
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_shorten_path_readable
char * stb_shorten_path_readable(char *path, int len)
{
   static char buffer[1024];
   int n = strlen(path),n1,n2,r1,r2;
   char *s;
   if (n <= len) return path;
   if (len > 1024) return path;
   s = stb_strrchr2(path, '/', '\\');
   if (s) {
      n1 = s - path + 1;
      n2 = n - n1;
      ++s;
   } else {
      n1 = 0;
      n2 = n;
      s = path;
   }
   // now we need to reduce r1 and r2 so that they fit in len
   if (n1 < len>>1) {
      r1 = n1;
      r2 = len - r1;
   } else if (n2 < len >> 1) {
      r2 = n2;
      r1 = len - r2;
   } else {
      r1 = n1 * len / n;
      r2 = n2 * len / n;
      if (r1 < len>>2) r1 = len>>2, r2 = len-r1;
      if (r2 < len>>2) r2 = len>>2, r1 = len-r2;
   }
   assert(r1 <= n1 && r2 <= n2);
   if (n1)
      stb__add_section(buffer, path, n1, r1);
   stb__add_section(buffer+r1, s, n2, r2);
   buffer[len] = 0;
   return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x2100
movq %rax, %r13
cmpl %ebx, %r13d
setle %al
cmpl $0x401, %ebx            # imm = 0x401
setge %cl
orb %al, %cl
jne 0x4754
pushq $0x2f
popq %rsi
pushq $0x5c
popq %rdx
movq %r14, %rdi
callq 0x3cf3
movl %eax, %edx
subl %r14d, %edx
incl %edx
xorl %ecx, %ecx
testq %rax, %rax
cmovnel %edx, %ecx
leaq 0x1(%rax), %r15
cmoveq %r14, %r15
movl %r13d, %ebp
subl %ecx, %ebp
movl %ebx, %eax
sarl %eax
cmpl %eax, %ecx
jge 0x46ca
movl %ebx, %r13d
subl %ecx, %r13d
movl %ecx, %r12d
jmp 0x4710
cmpl %eax, %ebp
jge 0x46d9
movl %ebx, %r12d
subl %ebp, %r12d
movl %ebp, %r13d
jmp 0x4710
movl %ecx, %eax
imull %ebx, %eax
cltd
idivl %r13d
movl %eax, %r12d
movl %ebp, %eax
imull %ebx, %eax
cltd
idivl %r13d
movl %eax, %r13d
movl %ebx, %eax
sarl $0x2, %eax
movl %ebx, %edx
subl %eax, %edx
cmpl %eax, %r12d
cmovlel %eax, %r12d
cmovll %edx, %r13d
cmpl %eax, %r13d
cmovll %edx, %r12d
cmovlel %eax, %r13d
cmpl %ecx, %r12d
jg 0x4766
cmpl %ebp, %r13d
jg 0x4766
testl %ecx, %ecx
je 0x4732
leaq 0x173eb(%rip), %rdi     # 0x1bb10
movq %r14, %rsi
movl %ecx, %edx
movl %r12d, %ecx
callq 0x45f5
movslq %r12d, %rdi
leaq 0x173d4(%rip), %r14     # 0x1bb10
addq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0x45f5
movslq %ebx, %rax
movb $0x0, (%rax,%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbdcb(%rip), %rdi      # 0x10538
leaq 0xbcad(%rip), %rsi      # 0x10421
leaq 0xbdd2(%rip), %rcx      # 0x1054d
movl $0x900, %edx            # imm = 0x900
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rsp)
movq %rsi, %rdi
callq 0x2100
movq %rax, %rbx
pushq $0x2f
popq %rsi
pushq $0x5c
popq %rdx
movq %r14, %rdi
callq 0x3cf3
cmpl $0x8, %ebp
pushq $0xc
popq %r13
cmovnel %ebp, %r13d
xorl %r15d, %r15d
testb $0x7, %r13b
je 0x48ba
movq %rax, %r12
leal 0x1(%rax), %ebp
testq %rax, %rax
cmovel %r15d, %ebp
subl %r14d, %ebp
testq %rax, %rax
cmovel %r15d, %ebp
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x2130
cmpq %r12, %rax
cmovaeq %rax, %r15
testq %rax, %rax
cmoveq %rax, %r15
testq %r12, %r12
cmoveq %rax, %r15
movq %r15, %rcx
subq %r14, %rcx
testq %r15, %r15
cmoveq %rbx, %rcx
testb $0x1, %r13b
jne 0x482e
xorl %eax, %eax
movb $0x1, %r15b
testb $0x2, %r13b
jne 0x484f
testb $0x8, %r13b
jne 0x4854
movl %ebp, %r12d
movl %ecx, %ebp
jmp 0x486c
movl %r13d, %edx
xorl $0x1, %edx
xorl %eax, %eax
orl %ebp, %edx
setne %r15b
sete %al
addl %eax, %eax
testb $0x2, %r13b
cmovnel %ecx, %ebp
movl %ebp, %r12d
xorl %ebp, %ebp
jmp 0x486c
movl %ecx, %r12d
jmp 0x486c
movslq %ecx, %rdx
xorl %esi, %esi
movq (%rsp), %rdi
cmpb $0x2e, (%rdi,%rdx)
movl %ebp, %r12d
sete %sil
addl %ecx, %esi
movl %esi, %ebp
testb $0x4, %r13b
cmovnel %ebx, %r12d
movq (%rsp), %rbx
testq %rbx, %rbx
jne 0x4894
addl %r12d, %eax
subl %ebp, %eax
incl %eax
movslq %eax, %rdi
callq 0x2250
movq %rax, %rbx
testq %rax, %rax
je 0x48ba
testb %r15b, %r15b
je 0x48be
movslq %ebp, %rax
addq %rax, %r14
subl %ebp, %r12d
movslq %r12d, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2060
movb $0x0, (%rbx,%r15)
jmp 0x48c7
xorl %ebx, %ebx
jmp 0x48c7
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_O2/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
pushq $0x6
popq %rdx
callq 0x4787
testq %r14, %r14
je 0x491e
leaq 0xbc6e(%rip), %rsi      # 0x1057a
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2350
jmp 0x4929
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_O2/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
pushq $0x3
popq %rdx
callq 0x4787
testq %r14, %r14
je 0x4979
xorl %ecx, %ecx
cmpb $0x2e, (%r14)
sete %cl
addq %r14, %rcx
leaq 0xbc16(%rip), %rsi      # 0x10580
movq %rsp, %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2350
jmp 0x4984
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_O2/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 0x49f7
movq %rdi, %r14
incl 0x1756b(%rip)           # 0x1bf10
movq -0x8(%rdi), %rcx
movl %ecx, %eax
andl $0x3, %eax
leaq 0xb77b(%rip), %rdx      # 0x10130
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq -0x10(%r14), %rbx
movq -0x10(%r14), %rax
movq %rax, (%rcx)
testq %rax, %rax
je 0x49ea
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 0x23c0
popq %rbx
popq %r14
popq %r15
retq
leaq -0x20(%r14), %rbx
movq -0x20(%r14), %rcx
movq -0x10(%r14), %rax
movq %rax, (%rcx)
testq %rax, %rax
je 0x4a2c
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
testq %rdi, %rdi
je 0x4a4f
movq (%rdi), %r15
movl 0xc(%rdi), %eax
addl %eax, 0x174cb(%rip)     # 0x1bf10
callq 0x23c0
movq %r15, %rdi
jmp 0x4a34
movq $0x2, -0x8(%r14)
andq $0x0, -0x20(%r14)
andq $0x0, -0x10(%r14)
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x49ea
callq 0x4992
jmp 0x4a61
leaq 0xbcce(%rip), %rdi      # 0x10746
leaq 0xb9a2(%rip), %rsi      # 0x10421
leaq 0xbb00(%rip), %rcx      # 0x10586
movl $0xa27, %edx            # imm = 0xA27
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_malloc_validate
void stb_malloc_validate(void *p, void *parent)
{
   if (p == NULL) return;

   switch(stb__identify(p)) {
      case STB__chunked:
         return;
      case STB__nochildren: {
         stb__nochildren *n = (stb__nochildren *) p - 1;
         if (n->prevn)
            assert(*n->prevn == p);
         if (n->next) {
            assert(*stb__prevn(n->next) == &n->next);
            stb_malloc_validate(n, parent);
         }
         return;
      }
      case STB__alloc: {
         stb__alloc *s = (stb__alloc *) p - 1;

         if (s->prevn)
            assert(*s->prevn == p);

         if (s->child) {
            assert(*stb__prevn(s->child) == &s->child);
            stb_malloc_validate(s->child, p);
         }

         if (s->next) {
            assert(*stb__prevn(s->next) == &s->next);
            stb_malloc_validate(s->next, parent);
         }
         return;
      }
      default:
         assert(0); /* NOTREACHED */
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb6a2(%rip), %r14      # 0x10140
testq %rbx, %rbx
je 0x4b85
movq -0x8(%rbx), %rax
movl %eax, %ecx
andl $0x3, %ecx
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
testq %rax, %rax
je 0x4ac7
cmpq %rbx, (%rax)
jne 0x4c09
addq $-0x10, %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x4b85
leaq -0x8(%rax), %rcx
movl -0x8(%rax), %edx
andl $0x3, %edx
addq $-0x20, %rax
cmpl $0x2, %edx
cmovneq %rcx, %rax
cmpq %rbx, (%rax)
je 0x4a9e
jmp 0x4bac
movq -0x20(%rbx), %rax
testq %rax, %rax
je 0x4b08
cmpq %rbx, (%rax)
jne 0x4bcb
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4b38
leaq -0x18(%rbx), %rax
leaq -0x8(%rdi), %rcx
movl -0x8(%rdi), %edx
andl $0x3, %edx
leaq -0x20(%rdi), %rsi
cmpl $0x2, %edx
cmovneq %rcx, %rsi
cmpq %rax, (%rsi)
jne 0x4bea
callq 0x4a90
movq -0x10(%rbx), %rax
testq %rax, %rax
je 0x4b85
addq $-0x10, %rbx
leaq -0x8(%rax), %rcx
movl -0x8(%rax), %edx
andl $0x3, %edx
leaq -0x20(%rax), %rsi
cmpl $0x2, %edx
cmovneq %rcx, %rsi
cmpq %rbx, (%rsi)
movq %rax, %rbx
je 0x4a9e
leaq 0xbaba(%rip), %rdi      # 0x10627
leaq 0xb8ad(%rip), %rsi      # 0x10421
leaq 0xba30(%rip), %rcx      # 0x105ab
movl $0xa48, %edx            # imm = 0xA48
callq 0x2140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xbbb2(%rip), %rdi      # 0x10746
leaq 0xb886(%rip), %rsi      # 0x10421
leaq 0xba09(%rip), %rcx      # 0x105ab
movl $0xa4e, %edx            # imm = 0xA4E
callq 0x2140
leaq 0xba21(%rip), %rdi      # 0x105d4
leaq 0xb867(%rip), %rsi      # 0x10421
leaq 0xb9ea(%rip), %rcx      # 0x105ab
movl $0xa37, %edx            # imm = 0xA37
callq 0x2140
leaq 0xba23(%rip), %rdi      # 0x105f5
leaq 0xb848(%rip), %rsi      # 0x10421
leaq 0xb9cb(%rip), %rcx      # 0x105ab
movl $0xa40, %edx            # imm = 0xA40
callq 0x2140
leaq 0xba13(%rip), %rdi      # 0x10604
leaq 0xb829(%rip), %rsi      # 0x10421
leaq 0xb9ac(%rip), %rcx      # 0x105ab
movl $0xa43, %edx            # imm = 0xA43
callq 0x2140
leaq 0xb98c(%rip), %rdi      # 0x1059c
leaq 0xb80a(%rip), %rsi      # 0x10421
leaq 0xb98d(%rip), %rcx      # 0x105ab
movl $0xa35, %edx            # imm = 0xA35
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4e87
testq %rsi, %rsi
je 0x4e8f
movl -0x8(%rdi), %eax
andl $0x3, %eax
je 0x4e96
cmpl $0x2, %eax
jne 0x4ed8
addq $-0x20, %rdi
addq $0x20, %rsi
callq 0x22b0
testq %rax, %rax
je 0x4ed4
movq %rax, %rcx
addq $0x20, %rax
movq (%rcx), %rdx
movq %rax, (%rdx)
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x4e78
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 0x4ed6
addq $0x8, %rcx
jmp 0x4eba
xorl %edi, %edi
popq %rax
jmp 0x4dcf
callq 0x4992
jmp 0x4ed4
addq $0x8, %rsi
callq 0x22b0
testq %rax, %rax
je 0x4ed4
movq %rax, %rcx
addq $0x10, %rax
movq 0x8(%rcx), %rdx
movq %rax, (%rdx)
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x4ed6
leaq -0x8(%rdx), %rsi
movl -0x8(%rdx), %edi
andl $0x3, %edi
addq $-0x20, %rdx
cmpl $0x2, %edi
cmovneq %rsi, %rdx
movq %rcx, (%rdx)
jmp 0x4ed6
xorl %eax, %eax
popq %rcx
retq
leaq 0xb769(%rip), %rdi      # 0x10648
leaq 0xb53b(%rip), %rsi      # 0x10421
leaq 0xb783(%rip), %rcx      # 0x10670
movl $0xb5c, %edx            # imm = 0xB5C
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f0c
testq %rdx, %rdx
je 0x4f14
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x4e11
movq %rdx, %rsi
jmp 0x4dcf
pushq %rax
movq %rsi, %rdi
callq 0x4992
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4f3c
movq %rdi, %rax
movq -0x8(%rdi), %rdi
movl %edi, %ecx
andl $0x3, %ecx
cmpl $0x1, %ecx
jne 0x4f45
decq %rdi
jmp 0x4f4c
leaq 0x132f5(%rip), %rdi     # 0x18238
jmp 0x4f4c
addq $-0x20, %rax
movq %rax, %rdi
movq -0x8(%rsi), %rdx
movl %edx, %eax
andl $0x3, %eax
je 0x4f93
cmpl $0x2, %eax
jne 0x4fc7
leaq -0x20(%rsi), %rax
movq -0x20(%rsi), %rdx
movq -0x10(%rsi), %rcx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x4f8e
movq (%rax), %rdx
leaq -0x8(%rcx), %rsi
movl -0x8(%rcx), %r8d
andl $0x3, %r8d
addq $-0x20, %rcx
cmpl $0x2, %r8d
cmovneq %rsi, %rcx
movq %rdx, (%rcx)
movq %rax, %rsi
jmp 0x4fe7
leaq -0x10(%rsi), %rax
movq -0x10(%rsi), %rcx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x4fc2
movq -0x8(%rsi), %rdx
leaq -0x8(%rcx), %rsi
movl -0x8(%rcx), %r8d
andl $0x3, %r8d
addq $-0x20, %rcx
cmpl $0x2, %r8d
cmovneq %rsi, %rcx
movq %rdx, (%rcx)
movq %rax, %rsi
jmp 0x5020
pushq %rax
leaq 0xb679(%rip), %rdi      # 0x10648
leaq 0xb44b(%rip), %rsi      # 0x10421
leaq 0xb6b5(%rip), %rcx      # 0x10692
movl $0xb8b, %edx            # imm = 0xB8B
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__insert_alloc
static void stb__insert_alloc(stb__alloc *src, stb__alloc *s)
{
   s->prevn = &src->child;
   s->next  = src->child;
   src->child = s+1;
   if (s->next)
      *stb__prevn(s->next) = &s->next;
}

// Assembly:
leaq 0x8(%rdi), %rax
movq %rax, (%rsi)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsi)
leaq 0x20(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rax, %rax
je 0x501f
addq $0x10, %rsi
leaq -0x8(%rax), %rcx
movl -0x8(%rax), %edx
andl $0x3, %edx
addq $-0x20, %rax
cmpl $0x2, %edx
cmovneq %rcx, %rax
movq %rsi, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__insert_nochild
static void stb__insert_nochild(stb__alloc *src, stb__nochildren *s)
{
   s->prevn = &src->child;
   s->next  = src->child;
   src->child = s+1;
   if (s->next)
      *stb__prevn(s->next) = &s->next;
}

// Assembly:
leaq 0x8(%rdi), %rax
movq %rax, 0x8(%rsi)
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
leaq 0x10(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rax, %rax
je 0x5054
leaq -0x8(%rax), %rcx
movl -0x8(%rax), %edx
andl $0x3, %edx
addq $-0x20, %rax
cmpl $0x2, %edx
cmovneq %rcx, %rax
movq %rsi, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x50df
movl %esi, %ebp
movq %rdi, %r14
leaq -0x10(%rdi), %r15
movl -0xc(%rdi), %edi
imull %esi, %edi
addl $0x10, %edi
callq 0x50ef
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, 0x16e45(%rip)     # 0x1bf18
setne %al
movl %eax, 0x8(%rbx)
addq $0x10, %rbx
jmp 0x50e1
xorl %ebx, %ebx
movq %rbx, %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_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 0x512f
leaq -0x10(%rax), %rdi
cmpl $0x0, -0x8(%rax)
je 0x512a
callq 0x4992
jmp 0x512f
callq 0x23c0
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5199
leaq -0x10(%rax), %r14
movl %r15d, -0x10(%rax)
movl -0xc(%rax), %ecx
cmpl %ebp, %ecx
jge 0x51e5
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 0x51d1
movq %r14, %rdi
callq 0x4e11
jmp 0x51d9
movl %r15d, %eax
orl %esi, %eax
je 0x51fb
imull %ebp, %esi
addl $0x10, %esi
movl %esi, %edi
callq 0x50ef
movq %rax, %r14
movl %ebp, 0x4(%rax)
movl %r15d, (%rax)
xorl %eax, %eax
cmpq $0x0, 0x16d58(%rip)     # 0x1bf18
setne %al
movl %eax, 0x8(%r14)
movl $0x51bada7b, 0xc(%r14)  # imm = 0x51BADA7B
jmp 0x51e5
movq %r14, %rdi
callq 0x22b0
testq %rax, %rax
je 0x51e5
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_O2/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 0x5213
cmpl %edx, -0xc(%rax)
jge 0x521a
movl %edx, %ecx
jmp 0x5146
movl %edx, -0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movq %r12, (%rsp)
testl %ecx, %ecx
je 0x529b
movl %ecx, %r15d
movl %esi, %ebp
testq %r12, %r12
je 0x52ad
movl %edx, %r14d
movl -0x10(%r12), %r13d
movq %rsp, %r12
movq %r12, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x521e
movq (%r12), %r12
addl %r14d, %r15d
imull %ebp, %r15d
movslq %r15d, %rdi
addq %r12, %rdi
subl %r14d, %r13d
imull %ebp, %r14d
movslq %r14d, %rsi
addq %r12, %rsi
imull %ebp, %r13d
movslq %r13d, %rdx
callq 0x22d0
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x521e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5310
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 0x52fa
movl -0x10(%r15), %edx
jmp 0x52fc
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_O2/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:
xorl %ecx, %ecx
movsbl (%rdi), %eax
testl %eax, %eax
je 0x532c
roll $0x7, %ecx
incq %rdi
addl %eax, %ecx
jmp 0x531b
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %esi, %esi
jle 0x534d
movsbl (%rdi), %eax
testl %eax, %eax
je 0x534d
roll $0x7, %ecx
incq %rdi
addl %eax, %ecx
decl %esi
jmp 0x5336
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hashptr
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
imull $0x10001, %edi, %eax    # imm = 0x10001
imull $0x80008, %edi, %ecx    # imm = 0x80008
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x5, %eax
addl %ecx, %eax
leal (,%rax,4), %ecx
xorl %eax, %ecx
movl %ecx, %edx
shrl $0xf, %edx
addl %ecx, %edx
movl %edx, %eax
shll $0xa, %eax
xorl %edx, %eax
movl %eax, %ecx
shrl $0x6, %ecx
addl %eax, %ecx
shrl $0x13, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl $0x77f044ed, %eax       # imm = 0x77F044ED
movl $0x3141592c, %ecx       # imm = 0x3141592C
movsbl (%rdi), %edx
testl %edx, %edx
je 0x53c1
roll $0x7, %ecx
addl %edx, %ecx
roll $0xb, %eax
addl %edx, %eax
incq %rdi
jmp 0x53ab
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_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash_fast
unsigned int stb_hash_fast(void *p, int len)
{
   unsigned char *q = (unsigned char *) p;
   unsigned int hash = len;

   if (len <= 0 || q == NULL) return 0;

   /* Main loop */
   if (((int) q & 1) == 0) {
      for (;len > 3; len -= 4) {
         unsigned int val;
         hash +=  stb__get16(q);
         val   = (stb__get16(q+2) << 11);
         hash  = (hash << 16) ^ hash ^ val;
         q    += 4;
         hash += hash >> 11;
      }
   } else {
      for (;len > 3; len -= 4) {
         unsigned int val;
         hash +=  stb__get16_slow(q);
         val   = (stb__get16_slow(q+2) << 11);
         hash  = (hash << 16) ^ hash ^ val;
         q    += 4;
         hash += hash >> 11;
      }
   }

   /* Handle end cases */
   switch (len) {
      case 3: hash += stb__get16_slow(q);
              hash ^= hash << 16;
              hash ^= q[2] << 18;
              hash += hash >> 11;
              break;
      case 2: hash += stb__get16_slow(q);
              hash ^= hash << 11;
              hash += hash >> 17;
              break;
      case 1: hash += q[0];
              hash ^= hash << 10;
              hash += hash >> 1;
              break;
      case 0: break;
   }

   /* Force "avalanching" of final 127 bits */
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;

   return hash;
}

// Assembly:
testl %esi, %esi
setle %cl
testq %rdi, %rdi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x54e0
movq %rdi, %rcx
movl %esi, %eax
movl %esi, %edx
testb $0x1, %dil
je 0x544d
cmpl $0x4, %edx
jb 0x5452
movzwl (%rcx), %r8d
addl %r8d, %eax
movzwl 0x2(%rcx), %r8d
shll $0xb, %r8d
xorl %eax, %r8d
shll $0x10, %eax
xorl %r8d, %eax
addq $0x4, %rcx
movl %eax, %r8d
shrl $0xb, %r8d
addl %r8d, %eax
addl $-0x4, %edx
jmp 0x53f2
movzwl (%rcx), %r8d
addl %r8d, %eax
movzwl 0x2(%rcx), %r8d
shll $0xb, %r8d
xorl %eax, %r8d
shll $0x10, %eax
xorl %r8d, %eax
addq $0x4, %rcx
movl %eax, %r8d
shrl $0xb, %r8d
addl %r8d, %eax
addl $-0x4, %edx
cmpl $0x4, %edx
jae 0x5423
movl %esi, %ecx
andl $0x3, %ecx
andl $0x7ffffffc, %esi       # imm = 0x7FFFFFFC
leaq 0xad00(%rip), %rdx      # 0x10164
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movzbl (%rdi,%rsi), %ecx
addl %ecx, %eax
movl %eax, %ecx
shll $0xa, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl %eax
jmp 0x5492
movzwl (%rdi,%rsi), %ecx
addl %ecx, %eax
movl %eax, %ecx
shll $0xb, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x11, %eax
addl %ecx, %eax
jmp 0x54b4
movzwl (%rdi,%rsi), %ecx
addl %ecx, %eax
movzbl 0x2(%rdi,%rsi), %ecx
shll $0x12, %ecx
xorl %eax, %ecx
shll $0x10, %eax
xorl %ecx, %eax
movl %eax, %ecx
shrl $0xb, %ecx
addl %eax, %ecx
movl %ecx, %eax
leal (,%rax,8), %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x5, %eax
addl %ecx, %eax
movl %eax, %ecx
shll $0x4, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x11, %eax
addl %ecx, %eax
movl %eax, %ecx
shll $0x19, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x6, %eax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5549
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 0x554d
movl %edx, %edx
movzwl (%r8,%rdx,2), %edx
jmp 0x5552
pushq $-0x1
popq %rax
retq
movzbl 0xc(%rdi,%rdx), %edx
xorl %ecx, %edx
cmpl %esi, (%rax,%rdx,4)
pushq $-0x1
popq %rax
cmovel %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x23c0
movq 0x30(%rbx), %rdi
callq 0x23c0
andq $0x0, 0x20(%rbx)
andq $0x0, 0x30(%rbx)
andl $0x0, 0x8(%rbx)
andl $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x64ce
movq %rsi, %r14
pushq $0x8
popq %r15
xorl %r12d, %r12d
movq 0x11b29(%rip), %r13     # 0x17fc0
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x64ce
movq (%rbx), %rax
movq -0x8(%rax,%r15), %rcx
orq $0x4, %rcx
cmpq $0x6, %rcx
je 0x64c5
movq (%rax,%r15), %rdi
cmpq %r13, %r14
je 0x64c0
callq *%r14
jmp 0x64c5
callq 0x23c0
incq %r12
addq $0x10, %r15
jmp 0x6497
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5f78
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__stb_idict_addset
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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r12d
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %edi
callq 0x5355
cmpl $0x3, %r15d
je 0x6739
cmpl $0x1, %r15d
jne 0x674d
cmpb $0x0, 0x2d(%rbx)
sete %r15b
je 0x6785
testl %r12d, %r12d
jne 0x678e
jmp 0x6827
cmpb $0x0, 0x2e(%rbx)
sete %r15b
je 0x679a
testl %r12d, %r12d
jne 0x67a3
jmp 0x6827
movl 0x10(%rbx), %esi
movl %esi, %edx
andl %eax, %edx
movq 0x8(%rbx), %rcx
movl %edx, %r8d
movl (%rcx,%r8,8), %r9d
cmpl $0x1, %r9d
je 0x67af
movl %edx, %edi
cmpl $0x3, %r9d
je 0x67b9
cmpl %r15d, %r9d
jne 0x67b6
testl %r12d, %r12d
je 0x6835
movl %ebp, 0x4(%rcx,%r8,8)
jmp 0x6835
testl %r14d, %r14d
je 0x6827
movl %ebp, 0x30(%rbx)
movb $0x1, 0x2d(%rbx)
jmp 0x683c
testl %r14d, %r14d
je 0x6827
movl %ebp, 0x34(%rbx)
movb $0x1, 0x2e(%rbx)
jmp 0x683c
testl %r14d, %r14d
jne 0x67fc
jmp 0x6827
pushq $-0x1
popq %rdi
movl %eax, %r8d
shrl $0x6, %r8d
addl %eax, %r8d
shrl $0x13, %eax
addl %r8d, %eax
orl $0x1, %eax
addl %eax, %edx
andl %esi, %edx
movl (%rcx,%rdx,8), %r8d
cmpl $0x1, %r8d
je 0x67ee
cmpl $0x3, %r8d
je 0x67e7
cmpl %r15d, %r8d
jne 0x67cc
jmp 0x682c
testl %edi, %edi
cmovsl %edx, %edi
jmp 0x67cc
testl %r14d, %r14d
je 0x6827
testl %edi, %edi
js 0x67fc
decl 0x1c(%rbx)
movl %edi, %edx
movslq %edx, %rax
movl %r15d, (%rcx,%rax,8)
movl %ebp, 0x4(%rcx,%rax,8)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
movb $0x1, %r15b
cmpl 0x24(%rbx), %eax
jl 0x683c
movl 0x18(%rbx), %esi
addl %esi, %esi
movq %rbx, %rdi
callq 0x695a
jmp 0x683c
xorl %r15d, %r15d
jmp 0x683c
testl %r12d, %r12d
je 0x6835
movl %ebp, 0x4(%rcx,%rdx,8)
testl %r14d, %r14d
sete %r15b
movzbl %r15b, %eax
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_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), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x6abd
movq 0x8(%rdi), %rdx
movl $0x1, (%rdx,%rcx,8)
incq %rcx
jmp 0x6aa8
andw $0x0, 0x2d(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x2250
testq %rax, %rax
je 0x6b03
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %rax, %rdi
callq 0xef0c
testl %eax, %eax
je 0x6afb
movb $0x1, 0x34(%rbx)
movl %ebp, (%rbx)
pushq $0x1
popq %rdi
callq 0x4c28
movq %rax, 0x8(%rbx)
jmp 0x6b05
movq %rbx, %rdi
callq 0x23c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xefb3
movq %r14, %rcx
xorq $0x1, %rcx
movq %rbx, %rdx
xorq $0x1, %rdx
orq %rcx, %rdx
jne 0x6b7b
cmpb $0x0, 0x35(%r15)
je 0x6c1f
pushq $0x38
jmp 0x6b9b
movq %r14, %rcx
xorq $0x2, %rcx
movq %rbx, %rdx
xorq $0x2, %rdx
orq %rcx, %rdx
jne 0x6ba1
cmpb $0x0, 0x36(%r15)
je 0x6c1f
pushq $0x40
popq %rax
addq %r15, %rax
jmp 0x6c1a
movl 0x18(%r15), %edx
movl %edx, %edi
andl %eax, %edi
movq 0x10(%r15), %rcx
movl %edi, %esi
imulq $0x18, %rsi, %r9
leaq (%rcx,%r9), %r8
movq (%rcx,%r9), %r9
cmpq $0x1, %r9
jne 0x6bc8
cmpq $0x1, 0x8(%r8)
je 0x6c1f
cmpq %r14, %r9
jne 0x6bd3
cmpq %rbx, 0x8(%r8)
je 0x6c0f
movl %eax, %esi
shrl $0x6, %esi
addl %eax, %esi
shrl $0x13, %eax
addl %esi, %eax
orl $0x1, %eax
xorl %r12d, %r12d
movl %edi, %esi
addl %eax, %esi
andl %edx, %esi
imulq $0x18, %rsi, %r8
leaq (%rcx,%r8), %rdi
movq (%rcx,%r8), %r8
cmpq $0x1, %r8
jne 0x6c04
cmpq $0x1, 0x8(%rdi)
je 0x6c22
cmpq %r14, %r8
jne 0x6be7
cmpq %rbx, 0x8(%rdi)
jne 0x6be7
imulq $0x18, %rsi, %rax
addq %rcx, %rax
addq $0x10, %rax
movq (%rax), %r12
jmp 0x6c22
xorl %r12d, %r12d
testl %ebp, %ebp
je 0x6c65
testq %r12, %r12
jne 0x6c65
movq 0x8(%r15), %rdi
movslq (%r15), %rsi
callq 0x4df8
testq %rax, %rax
je 0x6c62
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
callq 0xefe0
jmp 0x6c65
xorl %r12d, %r12d
movq %r12, %rax
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_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 0x6d13
movq %rax, %rbx
testq %rax, %rax
je 0x749f
testl %ebp, %ebp
je 0x749a
pushq $0x1
popq %rdi
callq 0x4c28
jmp 0x749c
xorl %eax, %eax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sdict_copy
stb_sdict* stb_sdict_copy(stb_sdict *old)
{
   stb_sdict *n;
   void *old_arena = old->arena;
   void *new_arena = old_arena ? stb_malloc_global(1) : NULL;
   old->arena = new_arena;
   n = stb_sdictinternal_copy(old);
   old->arena = old_arena;
   if (n)
      n->arena = new_arena;
   else if (new_arena)
      stb_free(new_arena);
   return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x74c9
pushq $0x1
popq %rdi
callq 0x4c28
movq %rax, %r14
jmp 0x74cc
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rdi
callq 0x7387
movq %rax, %r15
movq %r12, (%rbx)
testq %rax, %rax
je 0x74e7
movq %r14, (%r15)
jmp 0x74f4
testq %r14, %r14
je 0x74f4
movq %r14, %rdi
callq 0x4992
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_filelen
size_t  stb_filelen(FILE *f)
{
   size_t len, pos;
   pos = ftell(f);
   fseek(f, 0, SEEK_END);
   len = ftell(f);
   fseek(f, pos, SEEK_SET);
   return len;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x9169(%rip), %rsi      # 0x1076c
callq 0x22f0
testq %rax, %rax
je 0x764c
movq %rax, %rbx
movq %rax, %rdi
callq 0x75b3
movq %rax, %r12
leaq 0x2(%rax), %rdi
callq 0x2250
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x20b0
cmpq %r12, %rax
jne 0x7651
testq %r14, %r14
je 0x7645
movq %r12, (%r14)
movb $0x0, (%r15,%r12)
jmp 0x765c
xorl %r15d, %r15d
jmp 0x7664
movq %r15, %rdi
callq 0x23c0
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq