LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_feq
int stb_feq(char *s1, char *s2)
{
   FILE *f = stb__fopen(s1, "rb");
   FILE *g = stb__fopen(s2, "rb");

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

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

   return !stb_fcmp_core(f,g);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0x9afe(%rip), %r15      # 0x127fc
movq %r15, %rsi
callq 0x22f0
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f0
movq %rax, %r14
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
testb %cl, %al
jne 0x8d46
testq %rbx, %rbx
je 0x8d34
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x8d41
movq %r14, %rdi
callq 0x20d0
cmpq %r14, %rbx
jmp 0x8d6b
movq %rbx, %rdi
callq 0x8337
movq %rax, %r15
movq %r14, %rdi
callq 0x8337
movq %rbx, %rdi
cmpq %rax, %r15
jne 0x8d70
movq %r14, %rsi
callq 0x8c39
testl %eax, %eax
sete %al
jmp 0x8d7f
callq 0x20d0
movq %r14, %rdi
callq 0x20d0
xorl %eax, %eax
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_copyfile
int stb_copyfile(char *src, char *dest)
{
   char raw_buffer[1024];
   char *buffer;
   int buf_size = 65536;

   FILE *f, *g;

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

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

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

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

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

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

   fclose(g);
   return STB_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8cef
movl $0x1, %ebp
testl %eax, %eax
jne 0x8e73
leaq 0x9a44(%rip), %rsi      # 0x127fc
movq %rbx, %rdi
callq 0x22f0
testq %rax, %rax
je 0x8e65
movq %rax, %rbx
leaq 0x9a2c(%rip), %rsi      # 0x127ff
movq %r14, %rdi
callq 0x22f0
testq %rax, %rax
je 0x8e69
movq %rax, %r14
movl $0x10000, %r13d         # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x2250
movq %rax, %r15
testq %rax, %rax
movl $0x400, %r12d           # imm = 0x400
cmovneq %r13, %r12
movq %rsp, %r13
cmovneq %rax, %r13
movq %rbx, %rdi
callq 0x2210
testl %eax, %eax
jne 0x8e46
movl $0x1, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x20b0
testl %eax, %eax
je 0x8e0e
movslq %eax, %rdx
movl $0x1, %esi
movq %r13, %rdi
movq %r14, %rcx
callq 0x2370
jmp 0x8e0e
movq %rbx, %rdi
callq 0x20d0
movl $0x1, %ebp
testq %r15, %r15
je 0x8e60
movq %r15, %rdi
callq 0x23c0
movq %r14, %rbx
jmp 0x8e6b
xorl %ebp, %ebp
jmp 0x8e73
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x20d0
movl %ebp, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_varlenu
int stb_size_varlenu(unsigned int v)
{
   if (v < 0x00000080) return 1;
   if (v < 0x00004000) return 2;
   if (v < 0x00200000) return 3;
   if (v < 0x10000000) return 4;
   return 5;
}

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2180
movl %eax, %r14d
movzbl %r14b, %r15d
cmpl $0x80, %r15d
jb 0x90d2
cmpl $0xc0, %r15d
jb 0x90da
cmpl $0xe0, %r15d
jb 0x90ed
cmpl $0xf0, %r15d
jb 0x90fd
cmpl $0xf8, %r15d
jb 0x910a
cmpl $0xfc, %r15d
jb 0x9117
cmpl $0xfe, %r15d
jb 0x9127
cmpl $0xff, %r15d
jne 0x9134
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shlq $0x38, %r14
jmp 0x9137
movl %r15d, %eax
jmp 0x91b5
shll $0x8, %r15d
addl $0xffff8000, %r15d      # imm = 0xFFFF8000
movq %r15, %r14
jmp 0x91a7
shll $0x10, %r15d
addl $0xff400000, %r15d      # imm = 0xFF400000
jmp 0x9195
shll $0x18, %r14d
addl $0x20000000, %r14d      # imm = 0x20000000
jmp 0x9182
addl $0xffffff10, %r15d      # imm = 0xFFFFFF10
shlq $0x20, %r15
jmp 0x9170
addl $0xffff08, %r15d        # imm = 0xFFFF08
shlq $0x28, %r15
movq %r15, %r14
jmp 0x915d
addl $0xff04, %r15d          # imm = 0xFF04
shlq $0x30, %r15
jmp 0x914a
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r15d
shlq $0x30, %r15
orq %r14, %r15
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r14d
shlq $0x28, %r14
orq %r15, %r14
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r15d
shlq $0x20, %r15
orq %r14, %r15
movq %rbx, %rdi
callq 0x2180
movl %eax, %r14d
shll $0x18, %r14d
orq %r15, %r14
movq %rbx, %rdi
callq 0x2180
movzbl %al, %r15d
shll $0x10, %r15d
orq %r14, %r15
movq %rbx, %rdi
callq 0x2180
shll $0x8, %eax
movzwl %ax, %r14d
orq %r15, %r14
movq %rbx, %rdi
callq 0x2180
movzbl %al, %eax
orq %r14, %rax
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
negq %rax
xorq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_varlen64
int stb_size_varlen64(stb_uint64 v)
{
   if (v < 0x00000080) return 1;
   if (v < 0x00004000) return 2;
   if (v < 0x00200000) return 3;
   if (v < 0x10000000) return 4;
   if (v < STB_IMM_UINT64(0x0000000800000000)) return 5;
   if (v < STB_IMM_UINT64(0x0000040000000000)) return 6;
   if (v < STB_IMM_UINT64(0x0002000000000000)) return 7;
   if (v < STB_IMM_UINT64(0x0100000000000000)) return 8; 
   return 9;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq %rsi, %r14
movq %r14, %rax
shrq $0x38, %rax
je 0x9264
movl $0xff, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
jmp 0x9276
movq %r14, %rax
shrq $0x31, %rax
movl $0xfe, %eax
je 0x9318
movq %r14, %rdi
sarq $0x38, %rdi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rdi
shrq $0x18, %rdi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rdi
shrq $0x10, %rdi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movq %r14, %rdi
shrq $0x8, %rdi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movl %r14d, %edi
sarl $0x18, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movl %r14d, %ecx
shrl $0x10, %ecx
movsbl %cl, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
xorl %eax, %eax
movl %r14d, %ecx
shrl $0x8, %ecx
movsbl %cl, %edi
addl %eax, %edi
movq %rbx, %rsi
callq 0x21b0
movsbl %r14b, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
movq %r14, %rax
shrq $0x2a, %rax
movl $0xfc, %eax
jne 0x9289
movq %r14, %rax
shrq $0x23, %rax
movl $0xf8, %eax
jne 0x929f
movl $0xf0, %eax
cmpq $0xfffffff, %r14        # imm = 0xFFFFFFF
ja 0x92b5
movl $0xe0, %eax
cmpq $0x1fffff, %r14         # imm = 0x1FFFFF
ja 0x92cb
cmpq $0x4000, %r14           # imm = 0x4000
jb 0x9373
movl $0xc0, %eax
jmp 0x92dd
movl $0x80, %eax
cmpq $0x7f, %r14
ja 0x92f2
jmp 0x9305
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fput_ranged
void    stb_fput_ranged(FILE *f, int v, int b, stb_uint n)
{
   v -= b;
   if (n <= (1 << 31))
      assert((stb_uint) v < n);
   if (n > (1 << 24)) fputc(v >> 24, f);
   if (n > (1 << 16)) fputc(v >> 16, f);
   if (n > (1 <<  8)) fputc(v >>  8, f);
   fputc(v,f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
subl %edx, %ebx
cmpl $0x80000001, %ecx       # imm = 0x80000001
setae %al
cmpl %ecx, %ebx
setb %dl
orb %al, %dl
je 0x93f5
movq %rdi, %r14
cmpl $0x1000001, %ecx        # imm = 0x1000001
jb 0x93b8
movl %ebx, %edi
sarl $0x18, %edi
movq %r14, %rsi
callq 0x21b0
jmp 0x93c0
cmpl $0x10001, %ecx          # imm = 0x10001
jb 0x93eb
movl %ebx, %edi
sarl $0x10, %edi
movq %r14, %rsi
callq 0x21b0
movl %ebx, %edi
sarl $0x8, %edi
movq %r14, %rsi
callq 0x21b0
movl %ebx, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
cmpl $0x101, %ecx            # imm = 0x101
jae 0x93cd
jmp 0x93da
leaq 0x944a(%rip), %rdi      # 0x12846
leaq 0x90ae(%rip), %rsi      # 0x124b1
leaq 0x944d(%rip), %rcx      # 0x12857
movl $0x166d, %edx           # imm = 0x166D
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_ranged
int     stb_fget_ranged(FILE *f, int b, stb_uint n)
{
   unsigned int v=0;
   if (n > (1 << 24)) v += stb_fgetc(f) << 24;
   if (n > (1 << 16)) v += stb_fgetc(f) << 16;
   if (n > (1 <<  8)) v += stb_fgetc(f) <<  8;
   v += stb_fgetc(f);
   return b+v;
}

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x9b67
movl -0x10(%r14), %eax
jmp 0x9b69
xorl %eax, %eax
cmpl 0x106b9(%rip), %eax     # 0x1a228
jge 0x9c66
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x98e0
movq %rax, %r15
leaq 0x8(%rsp), %r13
movq %rax, %r12
testq %r15, %r15
je 0x9b9d
movslq -0x10(%r15), %rax
jmp 0x9b9f
xorl %eax, %eax
leaq (%r15,%rax,8), %rax
cmpq %rax, %r12
jae 0x9bf7
movq (%r12), %rdi
callq 0x2380
movq %rax, %rbp
testq %r14, %r14
je 0x9bcb
movl -0x10(%r14), %eax
cmpl -0xc(%r14), %eax
jge 0x9bcb
incl %eax
movl %eax, -0x10(%r14)
jmp 0x9be2
movq %r13, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x56ce
movq 0x8(%rsp), %r14
movslq -0x10(%r14), %rax
movq %rbp, -0x8(%r14,%rax,8)
addq $0x8, %r12
cmpl 0x10633(%rip), %eax     # 0x1a228
jl 0x9b92
movq %r15, %rdi
callq 0x989c
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x9c0f
movl -0x10(%r14), %eax
jmp 0x9c11
xorl %eax, %eax
movq 0x10(%rsp), %rdi
cmpl 0x1060c(%rip), %eax     # 0x1a228
jge 0x9c66
movl $0x1, %esi
xorl %edx, %edx
callq 0x98e0
movq %rax, %r15
movq %rax, %r12
testq %r15, %r15
je 0x9c3b
movslq -0x10(%r15), %rax
jmp 0x9c3d
xorl %eax, %eax
leaq (%r15,%rax,8), %rax
cmpq %rax, %r12
jae 0x9c5e
movq (%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x9b43
movq %rax, %r14
addq $0x8, %r12
jmp 0x9c30
movq %r15, %rdi
callq 0x989c
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_delete_directory_recursive
void stb_delete_directory_recursive(char *dir)
{
   char **list = stb_readdir_subdirs(dir);
   int i;
   for (i=0; i < stb_arr_len(list); ++i)
      stb_delete_directory_recursive(list[i]);
   stb_arr_free(list);
   list = stb_readdir_files(dir);
   for (i=0; i < stb_arr_len(list); ++i)
      if (!remove(list[i])) {
         // on windows, try again after making it writeable; don't ALWAYS
         // do this first since that would be slow in the normal case
         #ifdef _MSC_VER
         _chmod(list[i], _S_IWRITE);
         remove(list[i]);
         #endif
      }
   stb_arr_free(list);
   stb__windows(_rmdir,rmdir)(dir);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x98e0
movq %rax, %r14
movq %rax, (%rsp)
testq %r14, %r14
je 0x9ca4
movslq -0x10(%r14), %rax
jmp 0x9ca6
xorl %eax, %eax
cmpq %rax, %r15
jge 0x9cb9
movq (%r14,%r15,8), %rdi
callq 0x9c78
incq %r15
jmp 0x9c99
movq %rsp, %r15
movq %r15, %rdi
callq 0x55ba
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x98e0
movq %rax, %r14
movq %rax, (%r15)
testq %r14, %r14
je 0x9ce4
movslq -0x10(%r14), %rax
jmp 0x9ce6
xorl %eax, %eax
cmpq %rax, %r12
jge 0x9cf9
movq (%r14,%r12,8), %rdi
callq 0x2070
incq %r12
jmp 0x9cd9
movq %rsp, %rdi
callq 0x55ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_crc32_block
stb_uint stb_crc32_block(stb_uint crc, unsigned char *buffer, stb_uint len)
{
   static stb_uint crc_table[256];
   stb_uint i,j,s;
   crc = ~crc;

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

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

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

         buffer += 8;
      }

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

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

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

// Assembly:
pushq %rax
xorl %edx, %edx
leaq 0x8efa(%rip), %rax      # 0x13570
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpl $0x5, %ecx
jg 0xa69d
cmpl $0x14, %r9d
je 0xa6cc
movslq %r9d, %r10
movzbl (%rsi,%r10), %r10d
shll %cl, %r10d
incl %r9d
addl %r10d, %r8d
addl $0x8, %ecx
movl %r8d, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r10b
movb %r10b, (%rdi,%rdx)
incq %rdx
sarl $0x6, %r8d
addl $-0x6, %ecx
cmpq $0x1a, %rdx
jne 0xa67e
cmpl $0x4, %ecx
jne 0xa6eb
movslq %r8d, %rcx
movb (%rcx,%rax), %al
movb %al, 0x1a(%rdi)
popq %rax
retq
leaq 0x8294(%rip), %rdi      # 0x12967
leaq 0x7dd7(%rip), %rsi      # 0x124b1
leaq 0x828e(%rip), %rcx      # 0x1296f
movl $0x1943, %edx           # imm = 0x1943
callq 0x2140
leaq 0x82ad(%rip), %rdi      # 0x1299f
leaq 0x7db8(%rip), %rsi      # 0x124b1
leaq 0x826f(%rip), %rcx      # 0x1296f
movl $0x194c, %edx           # imm = 0x194C
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_close
void stb_cfg_close(stb_cfg *z)
{
   if (z->f) {
      int i;
      // write the file out
      fwrite(stb__cfg_sig, 12, 1, z->f);
      for (i=0; i < stb_arr_len(z->data); ++i) {
         stb_int16 n = strlen(z->data[i].key)+1;
         fwrite(&n, 2, 1, z->f);
         fwrite(z->data[i].key, n, 1, z->f);
         fwrite(&z->data[i].value_len, 4, 1, z->f);
         fwrite(z->data[i].value, z->data[i].value_len, 1, z->f);
      }
      fclose(z->f);
   }
   stb_arr_free(z->data);
   stb_free(z);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xa9a2
leaq 0x7b1f(%rip), %rdi      # 0x12400
movl $0xc, %esi
movl $0x1, %edx
callq 0x2370
movl $0x10, %r15d
xorl %r12d, %r12d
leaq 0x6(%rsp), %r14
movq (%rbx), %rax
testq %rax, %rax
je 0xa90c
movslq -0x10(%rax), %rcx
jmp 0xa90e
xorl %ecx, %ecx
cmpq %rcx, %r12
jge 0xa999
movq -0x10(%rax,%r15), %rdi
callq 0x2100
incl %eax
movw %ax, 0x6(%rsp)
movq 0x10(%rbx), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2370
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq -0x10(%rax,%r15), %rdi
movswq 0x6(%rsp), %rsi
movl $0x1, %edx
callq 0x2370
movq (%rbx), %rdi
addq %r15, %rdi
movq 0x10(%rbx), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2370
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movq -0x8(%rax,%r15), %rdi
movslq (%rax,%r15), %rsi
movl $0x1, %edx
callq 0x2370
incq %r12
addq $0x18, %r15
jmp 0xa8fe
movq 0x10(%rbx), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x55ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4de4
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_read
int stb_cfg_read(stb_cfg *z, char *key, void *value, int len)
{
   int i;
   for (i=0; i < stb_arr_len(z->data); ++i) {
      if (!stb_stricmp(z->data[i].key, key)) {
         int n = stb_min(len, z->data[i].value_len);
         memcpy(value, z->data[i].value, n);
         if (n < len)
            *((char *) value + n) = 0;
         return 1;
      }
   }
   return 0;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xaaa2
movl %r13d, 0xc(%rsp)
movl -0x10(%rbx), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovgl %r13d, %ebp
jle 0xaaae
movq %r12, 0x10(%rsp)
xorl %r12d, %r12d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
je 0xaaa6
incq %r12
addq $0x18, %rbx
cmpq %r12, %rbp
jne 0xaa85
jmp 0xaaa9
xorl %ebp, %ebp
jmp 0xaab8
movl %r12d, %ebp
movq 0x10(%rsp), %r12
cmpl %r13d, %ebp
movl 0xc(%rsp), %r13d
jne 0xab10
movq %r15, %rdi
movq %r14, %rsi
callq 0x955d
movq %rax, %r15
movq (%r14), %rax
testq %rax, %rax
je 0xaadd
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xaadd
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xaaf2
movq %r14, %rdi
movl $0x18, %esi
movl $0x1, %edx
callq 0x56ce
movq (%r14), %rax
movslq -0x10(%rax), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %r15, -0x18(%rax,%rcx,8)
movq $0x0, -0x10(%rax,%rcx,8)
movl $0x0, -0x8(%rax,%rcx,8)
movslq %r13d, %r15
movl 0xf70b(%rip), %ecx      # 0x1a224
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x508a
movq (%r14), %rcx
movl %ebp, %edx
leaq (%rdx,%rdx,2), %rdx
movq %rax, 0x8(%rcx,%rdx,8)
movl %r15d, 0x10(%rcx,%rdx,8)
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_delete
int stb_cfg_delete(stb_cfg *z, char *key)
{
   int i;
   for (i=0; i < stb_arr_len(z->data); ++i)
      if (!stb_stricmp(z->data[i].key, key)) {   
         stb_arr_fastdelete(z->data, i);
         return 1;
      }
   return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq $-0x1, %r13
xorl %r12d, %r12d
testq %r15, %r15
je 0xab86
movslq -0x10(%r15), %rax
jmp 0xab88
xorl %eax, %eax
incq %r13
cmpq %rax, %r13
jge 0xac08
movq (%r15,%r12), %rdi
addq $0x18, %r12
movq %r14, %rsi
callq 0x2040
testl %eax, %eax
jne 0xab7b
movslq -0x10(%r15), %rax
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
cmpq %r12, %rcx
je 0xabfb
leaq (%r15,%rcx), %rax
addq $-0x18, %rax
leaq -0x18(%r15,%r12), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movups (%rcx), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movaps (%rsp), %xmm0
movups %xmm0, (%rax)
movq (%rbx), %r15
movl -0x10(%r15), %eax
decl %eax
movl %eax, -0x10(%r15)
movl $0x1, %eax
jmp 0xac0a
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_free
void stb_wrapper_free(void *p, char *file, int line)
{
   int n;
   
   if (p == NULL) return;

   n = stb__hashfind(p);

   if (n >= 0)
      stb__remove_alloc(n, file, line);
   else {
      // tried to free something we hadn't allocated!
      n = stb__historyfind(p);
      assert(0); /* NOTREACHED */
      if (n >= 0)
         stb_fatal("Attempted to free %d-byte block %p at %s:%d previously freed/realloced at %s:%d",
                       stb__alloc_history[n].size, p,
                       file, line,
                       stb__alloc_history[n].file, stb__alloc_history[n].line);
      else
         stb_fatal("Attempted to free unknown block %p at %s:%d", p, file,line);
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb019
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0xac91
testl %eax, %eax
js 0xb01f
movslq 0x150ec(%rip), %rcx     # 0x200b4
leaq (%rcx,%rcx,2), %rdx
leaq 0x135bd(%rip), %rsi     # 0x1e590
movq 0x135a6(%rip), %rdi     # 0x1e580
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movups (%rdi,%rax,8), %xmm0
movups %xmm0, (%rsi,%rdx,8)
movq 0x10(%rdi,%rax,8), %r8
movq %r8, 0x10(%rsi,%rdx,8)
movq %r14, 0x8(%rsi,%rdx,8)
movl %ebx, 0x10(%rsi,%rdx,8)
incl %ecx
xorl %edx, %edx
cmpl $0x32, %ecx
cmovnel %ecx, %edx
movl %edx, 0x150a9(%rip)     # 0x200b4
movq $0x1, (%rdi,%rax,8)
decl 0x15097(%rip)           # 0x200b0
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0xb046
leaq 0x77a8(%rip), %rdi      # 0x127d6
leaq 0x747c(%rip), %rsi      # 0x124b1
leaq 0x79d2(%rip), %rcx      # 0x12a0e
movl $0x1cd7, %edx           # imm = 0x1CD7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__historyfind
static int stb__historyfind(void *p)
{
   int n = stb__history_pos;
   int i;
   for (i=0; i < STB_MALLOC_HISTORY_COUNT; ++i) {
      if (--n < 0) n = STB_MALLOC_HISTORY_COUNT-1;
      if (stb__alloc_history[n].p == p)
         return n;
   }
   return -1;
}

// Assembly:
movl $0x31, %eax
movl 0x15063(%rip), %edx     # 0x200b4
leaq 0x13538(%rip), %rcx     # 0x1e590
movl $0x31, %esi
testl %edx, %edx
leal -0x1(%rdx), %edx
cmovlel %eax, %edx
movslq %edx, %r8
leaq (%r8,%r8,2), %r9
subl $0x1, %esi
setb %r8b
cmpq %rdi, (%rcx,%r9,8)
je 0xb07e
testb %r8b, %r8b
je 0xb05d
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_check
void stb_wrapper_check(void *p)
{
   int n;
   
   if (p == NULL) return;

   n = stb__hashfind(p);

   if (n >= 0) return;

   for (n=0; n < stb__alloc_size; ++n)
      if (stb__allocations[n].p == p)
         stb_fatal("Internal error: pointer %p was allocated, but hash search failed", p);

   // tried to free something that wasn't allocated!
   n = stb__historyfind(p);
   if (n >= 0)
      stb_fatal("Checked %d-byte block %p previously freed/realloced at %s:%d",
                    stb__alloc_history[n].size, p,
                    stb__alloc_history[n].file, stb__alloc_history[n].line);
   stb_fatal("Checked unknown block %p");
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xb091
movq %rdi, %rbx
callq 0xac91
testl %eax, %eax
js 0xb093
popq %rbx
retq
movslq 0x134ee(%rip), %rcx     # 0x1e588
testq %rcx, %rcx
jle 0xb0bf
movq 0x134da(%rip), %rax     # 0x1e580
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
cmpq %rbx, (%rax,%rdx)
je 0xb128
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0xb0b0
movl $0x32, %edx
movl 0x14fea(%rip), %ecx     # 0x200b4
movl $0x31, %esi
leaq 0x134ba(%rip), %rax     # 0x1e590
testl %ecx, %ecx
leal -0x1(%rcx), %ecx
cmovlel %esi, %ecx
movslq %ecx, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpq %rbx, (%rax,%rdi,8)
je 0xb0f1
decl %edx
jne 0xb0d6
jmp 0xb11a
testl %ecx, %ecx
js 0xb11a
movl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdx
movl 0x14(%rax,%rdx,8), %esi
movq 0x8(%rax,%rdx,8), %rcx
movl 0x10(%rax,%rdx,8), %r8d
leaq 0x796a(%rip), %rdi      # 0x12a7a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3027
leaq 0x7996(%rip), %rdi      # 0x12ab7
xorl %eax, %eax
callq 0x3027
leaq 0x790a(%rip), %rdi      # 0x12a39
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3027
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_realloc
void stb_wrapper_realloc(void *p, void *q, int sz, char *file, int line)
{
   int n;
   if (p == NULL) { stb_wrapper_malloc(q, sz, file, line); return; }
   if (q == NULL) return; // nothing happened

   n = stb__hashfind(p);
   if (n == -1) {
      // tried to free something we hadn't allocated!
      // this is weird, though, because we got past the realloc!
      n = stb__historyfind(p);
      assert(0); /* NOTREACHED */
      if (n >= 0)
         stb_fatal("Attempted to realloc %d-byte block %p at %s:%d previously freed/realloced at %s:%d",
                       stb__alloc_history[n].size, p,
                       file, line,
                       stb__alloc_history[n].file, stb__alloc_history[n].line);
      else
         stb_fatal("Attempted to realloc unknown block %p at %s:%d", p, file,line);
   } else {
      if (q == p) {
         stb__allocations[n].size = sz;
         stb__allocations[n].file = file;
         stb__allocations[n].line = line;
      } else {
         stb__remove_alloc(n, file, line);
         stb__add_alloc(q,sz,file,line);
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %rdi, %rdi
je 0xb1ca
testq %r15, %r15
je 0xb20b
movq %rdi, %r12
callq 0xac91
cmpl $-0x1, %eax
je 0xb214
cmpq %r12, %r15
je 0xb1e6
movslq 0x14f3d(%rip), %rcx     # 0x200b4
leaq (%rcx,%rcx,2), %rdx
leaq 0x1340e(%rip), %rsi     # 0x1e590
movq 0x133f7(%rip), %rdi     # 0x1e580
cltq
leaq (%rax,%rax,2), %rax
movups (%rdi,%rax,8), %xmm0
movups %xmm0, (%rsi,%rdx,8)
movq 0x10(%rdi,%rax,8), %r8
movq %r8, 0x10(%rsi,%rdx,8)
movq %r14, 0x8(%rsi,%rdx,8)
movl %ebx, 0x10(%rsi,%rdx,8)
incl %ecx
xorl %edx, %edx
cmpl $0x32, %ecx
cmovnel %ecx, %edx
movl %edx, 0x14efa(%rip)     # 0x200b4
movq $0x1, (%rdi,%rax,8)
decl 0x14ee8(%rip)           # 0x200b0
jmp 0xb1cf
testq %r15, %r15
je 0xb20b
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xad34
movq 0x13393(%rip), %rcx     # 0x1e580
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movl %ebp, 0x14(%rcx,%rax)
movq %r14, 0x8(%rcx,%rax)
movq 0x13379(%rip), %rcx     # 0x1e580
movl %ebx, 0x10(%rcx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0xb046
leaq 0x75b3(%rip), %rdi      # 0x127d6
leaq 0x7287(%rip), %rsi      # 0x124b1
leaq 0x789f(%rip), %rcx      # 0x12ad0
movl $0x1d04, %edx           # imm = 0x1D04
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_listall
void stb_wrapper_listall(void (*func)(void *ptr, int sz, char *file, int line))
{
   int i;
   for (i=0; i < stb__alloc_size; ++i)
      if (stb__allocations[i].p > STB_DEL)
         func(stb__allocations[i].p   , stb__allocations[i].size,
              stb__allocations[i].file, stb__allocations[i].line);
}

// Assembly:
movl 0x13347(%rip), %eax     # 0x1e588
testl %eax, %eax
jle 0xb299
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x14, %r14d
movq 0x13326(%rip), %rcx     # 0x1e580
xorl %r15d, %r15d
movq -0x14(%rcx,%r14), %rdi
cmpq $0x2, %rdi
jb 0xb285
movl (%rcx,%r14), %esi
movq -0xc(%rcx,%r14), %rdx
movl -0x4(%rcx,%r14), %ecx
callq *%rbx
movq 0x13301(%rip), %rcx     # 0x1e580
movl 0x13303(%rip), %eax     # 0x1e588
incq %r15
movslq %eax, %rdx
addq $0x18, %r14
cmpq %rdx, %r15
jl 0xb25d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_dump
void stb_wrapper_dump(char *filename)
{
   int i;
   FILE *f = fopen(filename, "w");
   if (!f) return;
   for (i=0; i < stb__alloc_size; ++i)
      if (stb__allocations[i].p > STB_DEL)
         fprintf(f, "%p %7d - %4d %s\n",
            stb__allocations[i].p   , stb__allocations[i].size,
            stb__allocations[i].line, stb__allocations[i].file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7862(%rip), %rsi      # 0x12b0b
callq 0x22f0
movq %rax, %rbx
testq %rax, %rax
setne %cl
movl 0x132cb(%rip), %eax     # 0x1e588
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xb322
movl $0x14, %r15d
movq 0x132aa(%rip), %rsi     # 0x1e580
leaq 0x7830(%rip), %r14      # 0x12b0d
xorl %r12d, %r12d
movq -0x14(%rsi,%r15), %rdx
cmpq $0x2, %rdx
jb 0xb313
movl (%rsi,%r15), %ecx
movl -0x4(%rsi,%r15), %r8d
movq -0xc(%rsi,%r15), %r9
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x21f0
movq 0x13273(%rip), %rsi     # 0x1e580
movl 0x13275(%rip), %eax     # 0x1e588
incq %r12
movslq %eax, %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0xb2e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_copy
stb_ps *stb_ps_copy(stb_ps *ps)
{
   int i;
   // not a switch: order based on expected performance/power-law distribution
   switch (3 & (int) ps) {
      case STB_ps_direct: return ps;
      case STB_ps_bucket: {
         stb_ps_bucket *n = (stb_ps_bucket *) malloc(sizeof(*n));
         *n = *GetBucket(ps);
         return EncodeBucket(n);
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         stb_ps_array *n = (stb_ps_array *) malloc(sizeof(*n) + stb_ps_array_max * sizeof(n->p[0]));
         n->count = a->count;
         for (i=0; i < a->count; ++i)
            n->p[i] = a->p[i];
         return EncodeArray(n);
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         stb_ps_hash *n = stb_ps_makehash(h->size, h->size, h->table);
         return EncodeHash(n);
      }
   }
   assert(0); /* NOTREACHED */
   return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
leaq 0x6e9c(%rip), %rcx      # 0x12214
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x20, %edi
callq 0x2250
movups -0x1(%rbx), %xmm0
movups 0xf(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
incq %rax
movq %rax, %rbx
jmp 0xb3ef
movl $0x78, %edi
callq 0x2250
movq %rax, %r14
movslq -0x2(%rbx), %rdx
movl %edx, (%rax)
testq %rdx, %rdx
jle 0xb3ce
addq $0x6, %rbx
leaq 0x8(%r14), %rdi
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x2230
addq $0x2, %r14
movq %r14, %rbx
jmp 0xb3ef
movl -0x3(%rbx), %edi
addq $0x1d, %rbx
movl %edi, %esi
movq %rbx, %rdx
callq 0xb3fa
movq %rax, %rbx
addq $0x3, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_makehash
static stb_ps_hash *stb_ps_makehash(int size, int old_size, void **old_data)
{
   int i;
   stb_ps_hash *h = (stb_ps_hash *) malloc(sizeof(*h) + (size-1) * sizeof(h->table[0]));
   assert(stb_is_pow2(size));
   h->size = size;
   h->mask = size-1;
   h->shrink_threshhold = (int) (0.3f * size);
   h->  grow_threshhold = (int) (0.8f * size);
   h->rehash_threshhold = (int) (0.9f * size);
   h->count = 0;
   h->count_deletes = 0;
   h->any_offset = 0;
   memset(h->table, 0, size * sizeof(h->table[0]));
   for (i=0; i < old_size; ++i)
      if (!stb_ps_empty(old_data[i]))
         stb_ps_add(EncodeHash(h), old_data[i]);
   return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r15d
leal -0x1(%r15), %r12d
movslq %r12d, %rax
leaq 0x28(,%rax,8), %rdi
callq 0x2250
testl %r12d, %r15d
jne 0xb4c0
movq %rax, %r14
movl %r15d, (%rax)
movl %r12d, 0x4(%rax)
cvtsi2ss %r15d, %xmm0
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1      # xmm1 = xmm1[0,0],xmm0[0,0]
mulps 0x6cb9(%rip), %xmm1     # 0x12100
cvttps2dq %xmm1, %xmm1
movlps %xmm1, 0x10(%rax)
mulss 0x6c05(%rip), %xmm0     # 0x1205c
cvttss2si %xmm0, %eax
movl %eax, 0x18(%r14)
movq $0x0, 0x8(%r14)
movl $0x0, 0x1c(%r14)
leaq 0x20(%r14), %rdi
movslq %r15d, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2160
testl %ebp, %ebp
jle 0xb4ae
movq %r14, %r15
addq $0x3, %r15
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
testl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
je 0xb4a6
movq %r15, %rdi
callq 0xb637
incq %r13
cmpq %r13, %r12
jne 0xb492
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7ca2(%rip), %rdi      # 0x13169
leaq 0x6fe3(%rip), %rsi      # 0x124b1
leaq 0x7ca6(%rip), %rcx      # 0x1317b
movl $0x1dc7, %edx           # imm = 0x1DC7
callq 0x2140