LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xab10
leaq 0x7a01(%rip), %rdi      # 0x12450
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 0xaa7a
movslq -0x10(%rax), %rcx
jmp 0xaa7c
xorl %ecx, %ecx
cmpq %rcx, %r12
jge 0xab07
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 0xaa6c
movq 0x10(%rbx), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x56c1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4ecf
// File: /workspace/github_cpp_makefile_star2_O1/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 0xab57
movslq -0x10(%r12), %rax
jmp 0xab59
xorl %eax, %eax
incq %r13
cmpq %rax, %r13
jge 0xaba4
movq (%r15), %rdi
addq $0x18, %r15
movq %r14, %rsi
callq 0x2040
testl %eax, %eax
jne 0xab4b
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 0xaba6
movb $0x0, (%rbx,%r14)
jmp 0xaba6
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_O1/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
pushq %rax
movl %ecx, %ebp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %rbx, %rbx
je 0xabe0
movslq -0x10(%rbx), %rax
jmp 0xabe2
xorl %eax, %eax
cmpq %rax, %r13
jge 0xac00
movq (%rbx,%r12), %rdi
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
je 0xac00
incq %r13
addq $0x18, %r12
jmp 0xabd5
testq %rbx, %rbx
je 0xac0a
movl -0x10(%rbx), %eax
jmp 0xac0c
xorl %eax, %eax
cmpl %r13d, %eax
jne 0xac84
movq %r15, %rdi
movq %r14, %rsi
callq 0x9658
movq %rax, %r15
movq (%r14), %rax
testq %rax, %rax
je 0xac2e
movl -0x10(%rax), %ecx
incl %ecx
jmp 0xac33
movl $0x1, %ecx
testq %rax, %rax
je 0xac3d
movl -0xc(%rax), %edx
jmp 0xac3f
xorl %edx, %edx
cmpl %edx, %ecx
jle 0xac57
movq %r14, %rdi
movl $0x18, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0xac5a
incl -0x10(%rax)
movq (%r14), %rax
testq %rax, %rax
je 0xac68
movslq -0x10(%rax), %rcx
jmp 0xac6a
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movq %r15, -0x18(%rax,%rcx,8)
movq $0x0, -0x10(%rax,%rcx,8)
movl $0x0, -0x8(%rax,%rcx,8)
movslq %ebp, %r15
movl 0xf5a7(%rip), %ecx      # 0x1a234
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x5184
movq (%r14), %rcx
movq %rax, 0x8(%rcx,%r12)
movl %r15d, 0x10(%rcx,%r12)
movq %rax, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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 0xacf5
movslq -0x10(%r15), %rax
jmp 0xacf7
xorl %eax, %eax
incq %r13
cmpq %rax, %r13
jge 0xad6b
movq (%r15,%r12), %rdi
addq $0x18, %r12
movq %r14, %rsi
callq 0x2040
testl %eax, %eax
jne 0xacea
movslq -0x10(%r15), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
cmpq %r12, %rax
je 0xad5e
addq %r15, %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), %rax
decl -0x10(%rax)
movl $0x1, %eax
jmp 0xad6d
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_O1/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 0xb193
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0xadf4
testl %eax, %eax
js 0xb199
movslq 0x14f82(%rip), %rcx     # 0x200c4
leaq (%rcx,%rcx,2), %rdx
leaq 0x13453(%rip), %rsi     # 0x1e5a0
movq 0x1343c(%rip), %rdi     # 0x1e590
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, 0x14f3f(%rip)     # 0x200c4
movq $0x1, (%rdi,%rax,8)
decl 0x14f2d(%rip)           # 0x200c0
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0xb1c0
leaq 0x767e(%rip), %rdi      # 0x12826
leaq 0x7352(%rip), %rsi      # 0x12501
leaq 0x78a8(%rip), %rcx      # 0x12a5e
movl $0x1cd7, %edx           # imm = 0x1CD7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14ef9(%rip), %edx     # 0x200c4
leaq 0x133ce(%rip), %rcx     # 0x1e5a0
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 0xb1f8
testb %r8b, %r8b
je 0xb1d7
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb20b
movq %rdi, %rbx
callq 0xadf4
testl %eax, %eax
js 0xb20d
popq %rbx
retq
movslq 0x13384(%rip), %rcx     # 0x1e598
testq %rcx, %rcx
jle 0xb239
movq 0x13370(%rip), %rax     # 0x1e590
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
cmpq %rbx, (%rax,%rdx)
je 0xb2a5
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0xb22a
movl $0x32, %edx
movl 0x14e80(%rip), %ecx     # 0x200c4
movl $0x31, %esi
leaq 0x13350(%rip), %rax     # 0x1e5a0
testl %ecx, %ecx
leal -0x1(%rcx), %ecx
cmovlel %esi, %ecx
movslq %ecx, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpq %rbx, (%rax,%rdi,8)
je 0xb26e
decl %edx
jne 0xb250
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0xb297
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 0x783d(%rip), %rdi      # 0x12aca
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3048
leaq 0x7869(%rip), %rdi      # 0x12b07
xorl %eax, %eax
callq 0x3048
leaq 0x77dd(%rip), %rdi      # 0x12a89
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3048
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb347
testq %r15, %r15
je 0xb388
movq %rdi, %r12
callq 0xadf4
cmpl $-0x1, %eax
je 0xb391
cmpq %r12, %r15
je 0xb363
movslq 0x14dd0(%rip), %rcx     # 0x200c4
leaq (%rcx,%rcx,2), %rdx
leaq 0x132a1(%rip), %rsi     # 0x1e5a0
movq 0x1328a(%rip), %rdi     # 0x1e590
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, 0x14d8d(%rip)     # 0x200c4
movq $0x1, (%rdi,%rax,8)
decl 0x14d7b(%rip)           # 0x200c0
jmp 0xb34c
testq %r15, %r15
je 0xb388
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xae9a
movq 0x13226(%rip), %rcx     # 0x1e590
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movl %ebp, 0x14(%rcx,%rax)
movq %r14, 0x8(%rcx,%rax)
movq 0x1320c(%rip), %rcx     # 0x1e590
movl %ebx, 0x10(%rcx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0xb1c0
leaq 0x7486(%rip), %rdi      # 0x12826
leaq 0x715a(%rip), %rsi      # 0x12501
leaq 0x7772(%rip), %rcx      # 0x12b20
movl $0x1d04, %edx           # imm = 0x1D04
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x131d9(%rip)     # 0x1e598
jle 0xb40c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x14, %r14d
xorl %r15d, %r15d
movq 0x131b7(%rip), %rax     # 0x1e590
movq -0x14(%rax,%r14), %rdi
cmpq $0x2, %rdi
jb 0xb3f4
movl (%rax,%r14), %esi
movq -0xc(%rax,%r14), %rdx
movl -0x4(%rax,%r14), %ecx
callq *%rbx
incq %r15
movslq 0x1319a(%rip), %rax     # 0x1e598
addq $0x18, %r14
cmpq %rax, %r15
jl 0xb3d2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x773f(%rip), %rsi      # 0x12b5b
callq 0x22f0
testq %rax, %rax
je 0xb482
cmpl $0x0, 0x1316b(%rip)     # 0x1e598
jle 0xb482
movq %rax, %rbx
movl $0x14, %r15d
leaq 0x771e(%rip), %r14      # 0x12b5d
xorl %r12d, %r12d
movq 0x13147(%rip), %rax     # 0x1e590
movq -0x14(%rax,%r15), %rdx
cmpq $0x2, %rdx
jb 0xb46f
movl (%rax,%r15), %ecx
movl -0x4(%rax,%r15), %r8d
movq -0xc(%rax,%r15), %r9
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x21f0
incq %r12
movslq 0x1311f(%rip), %rax     # 0x1e598
addq $0x18, %r15
cmpq %rax, %r12
jl 0xb442
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0x6d8c(%rip), %rcx      # 0x12264
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 0xb54f
movl $0x78, %edi
callq 0x2250
movq %rax, %r14
movslq -0x2(%rbx), %rdx
movl %edx, (%rax)
testq %rdx, %rdx
jle 0xb52e
addq $0x6, %rbx
leaq 0x8(%r14), %rdi
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x2230
addq $0x2, %r14
movq %r14, %rbx
jmp 0xb54f
movl -0x3(%rbx), %edi
addq $0x1d, %rbx
movl %edi, %esi
movq %rbx, %rdx
callq 0xb55a
movq %rax, %rbx
addq $0x3, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0xb620
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 0x6bb9(%rip), %xmm1     # 0x12160
cvttps2dq %xmm1, %xmm1
movlps %xmm1, 0x10(%rax)
mulss 0x6aa5(%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 0xb60e
movq %r14, %r15
addq $0x3, %r15
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
testl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
je 0xb606
movq %r15, %rdi
callq 0xb797
incq %r13
cmpq %r13, %r12
jne 0xb5f2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7b9c(%rip), %rdi      # 0x131c3
leaq 0x6ed3(%rip), %rsi      # 0x12501
leaq 0x7ba0(%rip), %rcx      # 0x131d5
movl $0x1dc7, %edx           # imm = 0x1DC7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_find
int stb_ps_find(stb_ps *ps, void *value)
{
   int i, code = 3 & (int) ps;
    assert((3 & (int) value) == STB_ps_direct);
   assert(stb_ps_fastlist_valid(value));
   // not a switch: order based on expected performance/power-law distribution
   if (code == STB_ps_direct)
      return value == ps;
   if (code == STB_ps_bucket) {
      stb_ps_bucket *b = GetBucket(ps);
      assert(STB_BUCKET_SIZE == 4);
      if (b->p[0] == value || b->p[1] == value ||
          b->p[2] == value || b->p[3] == value)
          return STB_TRUE;
      return STB_FALSE;
   }
   if (code == STB_ps_array) {
      stb_ps_array *a = GetArray(ps);
      for (i=0; i < a->count; ++i)
         if (a->p[i] == value)
            return STB_TRUE;
      return STB_FALSE;
   } else {
      stb_ps_hash *h = GetHash(ps);
      stb_uint32 hash = stb_hashptr(value);
      stb_uint32 s, n = hash & h->mask;
      void **t = h->table;
      if (t[n] == value) return STB_TRUE;
      if (t[n] == NULL) return STB_FALSE;
      s = stb_rehash(hash) | 1;
      do {
         n = (n + s) & h->mask;
         if (t[n] == value) return STB_TRUE;
      } while (t[n] != NULL);
      return STB_FALSE;
   }
}

// Assembly:
pushq %rax
testb $0x3, %sil
jne 0xb759
cmpq $0x1, %rsi
jbe 0xb778
movl %edi, %eax
andl $0x3, %eax
movl %eax, %eax
leaq 0x6c12(%rip), %rcx      # 0x12274
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq %rdi, %rsi
sete %al
jmp 0xb754
movslq -0x2(%rdi), %rcx
testq %rcx, %rcx
jle 0xb74e
decq %rcx
xorl %edx, %edx
cmpq %rsi, 0x6(%rdi,%rdx,8)
sete %al
je 0xb754
leaq 0x1(%rdx), %r8
cmpq %rdx, %rcx
movq %r8, %rdx
jne 0xb688
jmp 0xb754
movl %esi, %eax
shrl $0x6, %eax
addl %esi, %eax
movl %esi, %ecx
shrl $0x13, %ecx
addl %eax, %ecx
movl %ecx, %eax
shll $0x10, %eax
addl %ecx, %eax
movl %ecx, %edx
shll $0x13, %edx
leal (%rdx,%rcx,8), %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x5, %eax
addl %ecx, %eax
leal (,%rax,4), %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0xf, %eax
addl %ecx, %eax
movl %eax, %ecx
shll $0xa, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x6, %eax
addl %ecx, %eax
shrl $0x13, %ecx
addl %eax, %ecx
movl 0x1(%rdi), %edx
movl %edx, %r8d
andl %ecx, %r8d
movq 0x1d(%rdi,%r8,8), %rax
cmpq %rsi, %rax
je 0xb752
testq %rax, %rax
je 0xb74e
movl %ecx, %eax
shrl $0x6, %eax
addl %ecx, %eax
shrl $0x13, %ecx
addl %eax, %ecx
orl $0x1, %ecx
addl %ecx, %r8d
andl %edx, %r8d
movq 0x1d(%rdi,%r8,8), %r9
cmpq %rsi, %r9
sete %al
je 0xb754
testq %r9, %r9
jne 0xb717
jmp 0xb754
movb $0x1, %al
cmpq %rsi, -0x1(%rdi)
je 0xb754
cmpq %rsi, 0x7(%rdi)
je 0xb754
cmpq %rsi, 0xf(%rdi)
je 0xb754
cmpq %rsi, 0x17(%rdi)
jmp 0xb66e
xorl %eax, %eax
jmp 0xb754
movb $0x1, %al
movzbl %al, %eax
popq %rcx
retq
leaq 0x740e(%rip), %rdi      # 0x12b6e
leaq 0x6d9a(%rip), %rsi      # 0x12501
leaq 0x7423(%rip), %rcx      # 0x12b91
movl $0x1e01, %edx           # imm = 0x1E01
callq 0x2140
leaq 0x7434(%rip), %rdi      # 0x12bb3
leaq 0x6d7b(%rip), %rsi      # 0x12501
leaq 0x7404(%rip), %rcx      # 0x12b91
movl $0x1e02, %edx           # imm = 0x1E02
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_getlist
void ** stb_ps_getlist(stb_ps *ps, int *count)
{
   int i,n=0;
   void **p = NULL;
   switch (3 & (int) ps) {
      case STB_ps_direct:
         if (ps == NULL) { *count = 0; return NULL; }
         p = (void **) malloc(sizeof(*p) * 1);
         p[0] = ps;
         *count = 1;
         return p;
      case STB_ps_bucket: {
         stb_ps_bucket *b = GetBucket(ps);
         p = (void **) malloc(sizeof(*p) * STB_BUCKET_SIZE);
         for (i=0; i < STB_BUCKET_SIZE; ++i)
            if (b->p[i] != NULL)
               p[n++] = b->p[i];
         break;
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         p = (void **) malloc(sizeof(*p) * a->count);
         memcpy(p, a->p, sizeof(*p) * a->count);
         *count = a->count;
         return p;
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         p = (void **) malloc(sizeof(*p) * h->count);
         for (i=0; i < h->size; ++i)
            if (!stb_ps_empty(h->table[i]))
               p[n++] = h->table[i];
         break;
      }
   }
   *count = n;
   return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %r14d, %eax
andl $0x3, %eax
leaq 0x641c(%rip), %rcx      # 0x122a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xbf54
movl $0x8, %edi
callq 0x2250
movq %rax, %r15
movq %r14, (%rax)
movl $0x1, %r13d
jmp 0xbf5a
movslq -0x2(%r14), %r13
movq %r13, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x2250
movq %rax, %r15
addq $0x6, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2230
jmp 0xbf5a
movslq 0x5(%r14), %rdi
shlq $0x3, %rdi
callq 0x2250
movq %rax, %r15
movslq -0x3(%r14), %rax
testq %rax, %rax
jle 0xbf4f
xorl %ecx, %ecx
xorl %r13d, %r13d
movq 0x1d(%r14,%rcx,8), %rdx
testl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
je 0xbf14
movslq %r13d, %rsi
incl %r13d
movq %rdx, (%r15,%rsi,8)
incq %rcx
cmpq %rcx, %rax
jne 0xbefd
jmp 0xbf5a
movl $0x20, %edi
callq 0x2250
movq %rax, %r15
xorl %eax, %eax
xorl %r13d, %r13d
movq -0x1(%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0xbf44
movslq %r13d, %rdx
incl %r13d
movq %rcx, (%r15,%rdx,8)
incq %rax
cmpq $0x4, %rax
jne 0xbf30
jmp 0xbf5a
xorl %r13d, %r13d
jmp 0xbf5a
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r13d, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_writelist
int stb_ps_writelist(stb_ps *ps, void **list, int size )
{
   int i,n=0;
   switch (3 & (int) ps) {
      case STB_ps_direct:
         if (ps == NULL || size <= 0) return 0;
         list[0] = ps;
         return 1;
      case STB_ps_bucket: {
         stb_ps_bucket *b = GetBucket(ps);
         for (i=0; i < STB_BUCKET_SIZE; ++i)
            if (b->p[i] != NULL && n < size)
               list[n++] = b->p[i];
         return n;
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         n = stb_min(size, a->count);
         memcpy(list, a->p, sizeof(*list) * n);
         return n;
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         if (size <= 0) return 0;
         for (i=0; i < h->count; ++i) {
            if (!stb_ps_empty(h->table[i])) {
               list[n++] = h->table[i];
               if (n == size) break;
            }
         }
         return n;
      }
   }
   return 0; /* NOTREACHED */
}

// Assembly:
pushq %rbx
movl %edx, %ebx
movq %rdi, %rcx
movl %ecx, %eax
andl $0x3, %eax
leaq 0x6338(%rip), %rdx      # 0x122b4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testq %rcx, %rcx
sete %dl
testl %ebx, %ebx
setle %dil
xorl %eax, %eax
orb %dl, %dil
jne 0xc034
movq %rcx, (%rsi)
movl $0x1, %eax
jmp 0xc034
movl -0x2(%rcx), %eax
cmpl %ebx, %eax
cmovll %eax, %ebx
addq $0x6, %rcx
movslq %ebx, %rdx
shlq $0x3, %rdx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x2230
movl %ebx, %eax
jmp 0xc034
xorl %eax, %eax
testl %ebx, %ebx
jle 0xc034
movslq 0x5(%rcx), %rdx
testq %rdx, %rdx
jle 0xc034
xorl %edi, %edi
xorl %eax, %eax
movq 0x1d(%rcx,%rdi,8), %r8
testl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
je 0xbff9
movslq %eax, %r9
incl %eax
movq %r8, (%rsi,%r9,8)
cmpl %ebx, %eax
je 0xc034
incq %rdi
cmpq %rdi, %rdx
jne 0xbfde
jmp 0xc034
xorl %edx, %edx
xorl %eax, %eax
movq -0x1(%rcx,%rdx,8), %rdi
testq %rdi, %rdi
setne %r8b
cmpl %ebx, %eax
setl %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0xc02b
movslq %eax, %r8
incl %eax
movq %rdi, (%rsi,%r8,8)
incq %rdx
cmpq $0x4, %rdx
jne 0xc007
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_enum
int stb_ps_enum(stb_ps *ps, void *data, int (*func)(void *value, void *data))
{
   int i;
   switch (3 & (int) ps) {
      case STB_ps_direct:
         if (ps == NULL) return STB_TRUE;
         return func(ps, data);
      case STB_ps_bucket: {
         stb_ps_bucket *b = GetBucket(ps);
         for (i=0; i < STB_BUCKET_SIZE; ++i)
            if (b->p[i] != NULL)
               if (!func(b->p[i], data))
                  return STB_FALSE;
         return STB_TRUE;
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         for (i=0; i < a->count; ++i)
            if (!func(a->p[i], data))
               return STB_FALSE;
         return STB_TRUE;
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         for (i=0; i < h->count; ++i)
            if (!stb_ps_empty(h->table[i]))
               if (!func(h->table[i], data))
                  return STB_FALSE;
         return STB_TRUE;
      }
   }
   return STB_TRUE; /* NOTREACHED */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl %r14d, %eax
andl $0x3, %eax
leaq 0x6270(%rip), %rcx      # 0x122c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xc0f9
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0x1, %ebp
cmpl $0x0, -0x2(%r14)
jle 0xc102
xorl %r15d, %r15d
movq 0x6(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xc100
incq %r15
movslq -0x2(%r14), %rax
cmpq %rax, %r15
jl 0xc088
jmp 0xc102
movl $0x1, %ebp
cmpl $0x0, 0x5(%r14)
jle 0xc102
xorl %r15d, %r15d
movq 0x1d(%r14,%r15,8), %rdi
testl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
je 0xc0cb
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xc100
incq %r15
movslq 0x5(%r14), %rax
cmpq %rax, %r15
jl 0xc0b4
jmp 0xc102
xorl %r15d, %r15d
movq -0x1(%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xc0f0
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xc100
incq %r15
cmpq $0x4, %r15
jne 0xc0dc
movl $0x1, %ebp
jmp 0xc102
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_count
int stb_ps_count (stb_ps *ps)
{
   switch (3 & (int) ps) {
      case STB_ps_direct:
         return ps != NULL;
      case STB_ps_bucket: {
         stb_ps_bucket *b = GetBucket(ps);
         return (b->p[0] != NULL) + (b->p[1] != NULL) +
                (b->p[2] != NULL) + (b->p[3] != NULL);
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         return a->count;
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         return h->count;
      }
   }
   return 0;
}

// Assembly:
movl %edi, %eax
andl $0x3, %eax
leaq 0x61bb(%rip), %rcx      # 0x122d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
testq %rdi, %rdi
setne %al
retq
movl -0x2(%rdi), %eax
retq
movl 0x5(%rdi), %eax
retq
movdqu -0x1(%rdi), %xmm0
movdqu 0xf(%rdi), %xmm1
pxor %xmm2, %xmm2
pcmpeqd %xmm2, %xmm1
pcmpeqd %xmm2, %xmm0
movdqa %xmm0, %xmm2
shufps $0xdd, %xmm1, %xmm2     # xmm2 = xmm2[1,3],xmm1[1,3]
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
andps %xmm2, %xmm0
movmskps %xmm0, %ecx
xorl $0xf, %ecx
shll $0x2, %ecx
movabsq $0x4332322132212110, %rax # imm = 0x4332322132212110
shrq %cl, %rax
andl $0x7, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_fastlist
void ** stb_ps_fastlist(stb_ps *ps, int *count)
{
   static void *storage;

   switch (3 & (int) ps) {
      case STB_ps_direct:
         if (ps == NULL) { *count = 0; return NULL; }
         storage = ps;
         *count = 1;
         return &storage;
      case STB_ps_bucket: {
         stb_ps_bucket *b = GetBucket(ps);
         *count = STB_BUCKET_SIZE;
         return b->p;
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         *count = a->count;
         return a->p;
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         *count = h->size;
         return h->table;
      }
   }
   return NULL; /* NOTREACHED */
}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
andl $0x3, %ecx
leaq 0x6163(%rip), %rdx      # 0x122e4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testq %rax, %rax
je 0xc1c2
movq %rax, 0x128ba(%rip)     # 0x1ea50
leaq 0x128b3(%rip), %rax     # 0x1ea50
movl $0x1, (%rsi)
retq
movl -0x2(%rax), %ecx
movl %ecx, (%rsi)
addq $0x6, %rax
retq
movl -0x3(%rax), %ecx
movl %ecx, (%rsi)
addq $0x1d, %rax
retq
decq %rax
movl $0x4, (%rsi)
retq
movl $0x0, (%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_subset
int stb_ps_subset(stb_ps *bigger, stb_ps *smaller)
{
   int i, listlen;
   void **list = stb_ps_fastlist(smaller, &listlen);
   for(i=0; i < listlen; ++i)
      if (stb_ps_fastlist_valid(list[i]))
         if (!stb_ps_find(bigger, list[i]))
            return 0;
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl %r14d, %eax
andl $0x3, %eax
leaq 0x610e(%rip), %rcx      # 0x122f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xc227
movq %r14, 0x12855(%rip)     # 0x1ea50
leaq 0x1284e(%rip), %r14     # 0x1ea50
movl $0x1, %eax
jmp 0xc22c
movl -0x2(%r14), %eax
addq $0x6, %r14
jmp 0xc22c
movl -0x3(%r14), %eax
addq $0x1d, %r14
jmp 0xc22c
decq %r14
movl $0x4, %eax
jmp 0xc22c
xorl %eax, %eax
xorl %r14d, %r14d
movl $0x1, %ebp
testl %eax, %eax
jle 0xc25d
movl %eax, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
cmpq $0x2, %rsi
jb 0xc251
movq %rbx, %rdi
callq 0xb63f
testl %eax, %eax
je 0xc25b
incq %r12
cmpq %r12, %r15
jne 0xc23b
jmp 0xc25d
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_shuffle
void stb_shuffle(void *p, size_t n, size_t sz, unsigned long seed)
{
   char *a;
   unsigned long old_seed;
   int i;
   if (seed)
      old_seed = stb_srandLCG(seed);
   a = (char *) p + (n-1) * sz;

   for (i=n; i > 1; --i) {
      int j = stb_randLCG() % i;
      stb_swap(a, (char *) p + j * sz, sz);
      a -= sz;
   }
   if (seed)
      stb_srandLCG(old_seed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rcx, %rcx
je 0xc36b
movq 0x126fa(%rip), %rax     # 0x1ea58
movq %rax, (%rsp)
movq %rbx, 0x126ef(%rip)     # 0x1ea58
jmp 0xc36b
cmpl $0x2, %r12d
jl 0xc3df
leaq -0x1(%r12), %r13
imulq %r14, %r13
addq %r15, %r13
movq %r14, %rbp
negq %rbp
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
imulq $0x7ff8a3ed, 0x126c3(%rip), %rax # imm = 0x7FF8A3ED
addq $0x2aa01d31, %rax       # imm = 0x2AA01D31
movq %rax, 0x126b6(%rip)     # 0x1ea58
movq %rax, %rcx
shrq $0x10, %rcx
shlq $0x10, %rax
addq %rcx, %rax
xorq $0x31415926, %rax       # imm = 0x31415926
xorl %edx, %edx
divq %r12
imulq %r14, %rdx
leaq (%rdx,%r15), %rsi
movq %r13, %rdi
movq %r14, %rdx
callq 0x331f
addq %rbp, %r13
leaq -0x1(%r12), %rax
cmpq $0x2, %r12
movq %rax, %r12
jg 0xc38a
testq %rbx, %rbx
je 0xc3ef
movq (%rsp), %rax
movq %rax, 0x12669(%rip)     # 0x1ea58
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_dupe_create
stb_dupe *stb_dupe_create(stb_hash_func hash, stb_compare_func eq, int size,
                                              stb_compare_func ineq)
{
   int i, hsize;
   stb_dupe *sd = (stb_dupe *) malloc(sizeof(*sd));

   sd->size_log2 = 4;
   hsize = 1 << sd->size_log2;
   while (hsize * hsize < size) {
      ++sd->size_log2;
      hsize *= 2;
   }

   sd->hash = hash;
   sd->eq   = eq;
   sd->ineq = ineq;
   sd->hash_shift = 0;

   sd->population = 0;
   sd->hash_size = hsize;
   sd->hash_table = (void ***) malloc(sizeof(*sd->hash_table) * hsize);
   for (i=0; i < hsize; ++i)
      sd->hash_table[i] = NULL;

   sd->dupes = NULL;

   return sd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
movl $0x38, %edi
callq 0x2250
movq %rax, %rbx
movl $0x4, 0xc(%rax)
movl $0x10, %r14d
cmpl $0x101, %ebp            # imm = 0x101
jl 0xc7a7
movl 0xc(%rbx), %eax
movl $0x10, %r14d
incl %eax
addl %r14d, %r14d
movl %r14d, %ecx
imull %r14d, %ecx
cmpl %ebp, %ecx
jl 0xc794
movl %eax, 0xc(%rbx)
movq %r13, 0x18(%rbx)
movq %r12, 0x20(%rbx)
movq %r15, 0x28(%rbx)
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movl %r14d, 0x8(%rbx)
movl %r14d, %edi
shlq $0x3, %rdi
callq 0x2250
movq %rax, (%rbx)
cmpl $0x1, %r14d
adcl $0x0, %r14d
shlq $0x3, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2160
movq %r15, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_dupe_add
void stb_dupe_add(stb_dupe *sd, void *item)
{
   stb_uint32 hash = sd->hash(item, sd->hash_shift);
   int z = hash & (sd->hash_size-1);
   stb_arr_push(sd->hash_table[z], item);
   ++sd->population;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %esi
movq %r14, %rdi
callq *0x18(%rbx)
movslq 0x8(%rbx), %rcx
decq %rcx
movslq %eax, %r15
andq %rcx, %r15
movq (%rbx), %rax
movq (%rax,%r15,8), %rcx
testq %rcx, %rcx
je 0xc830
movl -0x10(%rcx), %edx
incl %edx
jmp 0xc835
movl $0x1, %edx
testq %rcx, %rcx
je 0xc83f
movl -0xc(%rcx), %esi
jmp 0xc841
xorl %esi, %esi
cmpl %esi, %edx
jle 0xc85a
leaq (%rax,%r15,8), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0xc85d
incl -0x10(%rcx)
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0xc86f
movslq -0x10(%rax), %rcx
jmp 0xc871
xorl %ecx, %ecx
movq %r14, -0x8(%rax,%rcx,8)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_dupe_free
void stb_dupe_free(stb_dupe *sd)
{
   int i;
   for (i=0; i < stb_arr_len(sd->dupes); ++i)
      if (sd->dupes[i])
         stb_arr_free(sd->dupes[i]);
   stb_arr_free(sd->dupes);
   free(sd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xc89c
movslq -0x10(%rdi), %rax
jmp 0xc89e
xorl %eax, %eax
cmpq %rax, %r15
jge 0xc8bb
cmpq $0x0, (%rdi,%r14)
je 0xc8b2
addq %r14, %rdi
callq 0x56c1
incq %r15
addq $0x8, %r14
jmp 0xc88d
leaq 0x30(%rbx), %rdi
callq 0x56c1
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_unioneq_changed
int stb_bitset_unioneq_changed(stb_bitset *p0, stb_bitset *p1, int len)
{
   int i, changed=0;
   for (i=0; i < len; ++i) {
      stb_bitset d = p0[i] | p1[i];
      if (d != p0[i]) {
         p0[i] = d;
         changed = 1;
      }
   }
   return changed;
}

// Assembly:
testl %edx, %edx
jle 0xce98
movl %edx, %ecx
xorl %edx, %edx
xorl %eax, %eax
movl (%rdi,%rdx,4), %r9d
movl (%rsi,%rdx,4), %r8d
orl %r9d, %r8d
cmpl %r9d, %r8d
je 0xce8f
movl %r8d, (%rdi,%rdx,4)
movl $0x1, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0xce76
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_new
stb_bitset *stb_bitset_new(int value, int len)
{
   int i;
   stb_bitset *d = (stb_bitset *) malloc(sizeof(*d) * len);
   if (value) value = 0xffffffff;
   for (i=0; i < len; ++i) d[i] = value;
   return d;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movslq %esi, %r14
leaq (,%r14,4), %rdi
callq 0x2250
xorl %ecx, %ecx
negl %ebp
sbbl %ecx, %ecx
testl %r14d, %r14d
jle 0xcfb0
movl %ebx, %edx
addl $0x3, %ebx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %ebx
shlq $0x4, %rbx
movdqa 0x524d(%rip), %xmm1     # 0x12130
movdqa 0x5225(%rip), %xmm2     # 0x12110
xorl %edx, %edx
movdqa 0x516b(%rip), %xmm3     # 0x12060
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x523b(%rip), %xmm5     # 0x12140
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0xcf3d
movl %ecx, (%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xcf50
movl %ecx, 0x4(%rax,%rdx)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0xcf8c
movl %ecx, 0x8(%rax,%rdx)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xcf9b
movl %ecx, 0xc(%rax,%rdx)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rbx
jne 0xcf05
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_getlist
int *stb_bitset_getlist(stb_bitset *out, int start, int end)
{
   int *list = NULL;
   int i;
   for (i=start; i < end; ++i)
      if (stb_bitset_testbit(out, i))
         stb_arr_push(list, i);
   return list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
cmpl %edx, %esi
jge 0xd039
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r15
movl %ebp, %eax
sarl $0x5, %eax
cltq
movl (%r14,%rax,4), %eax
btl %ebp, %eax
jae 0xd033
movq (%rsp), %rax
testq %rax, %rax
je 0xcff2
movl -0x10(%rax), %ecx
incl %ecx
jmp 0xcff7
movl $0x1, %ecx
testq %rax, %rax
je 0xd001
movl -0xc(%rax), %edx
jmp 0xd003
xorl %edx, %edx
cmpl %edx, %ecx
jle 0xd01b
movq %r15, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0xd01e
incl -0x10(%rax)
movq (%rsp), %rax
testq %rax, %rax
je 0xd02d
movslq -0x10(%rax), %rcx
jmp 0xd02f
xorl %ecx, %ecx
movl %ebp, -0x4(%rax,%rcx,4)
incl %ebp
cmpl %ebp, %ebx
jne 0xcfd2
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wordwrapalloc
int *stb_wordwrapalloc(int count, char *str)
{
   int n = stb_wordwrap(NULL,0,count,str);
   int *z = NULL;
   stb_arr_setlen(z, n*2);
   stb_wordwrap(z, n, count, str);
   return z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xd048
movl %eax, %r14d
movq %rsp, %r15
movq $0x0, (%r15)
leal (%r14,%r14), %ecx
movq %r15, %rdi
movl $0x4, %esi
movl %ecx, %edx
callq 0x56fd
movq (%r15), %r15
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xd048
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__match_qstring
static int stb__match_qstring(char *candidate, char *qstring, int qlen, int insensitive)
{
   int i;
   if (insensitive) {
      for (i=0; i < qlen; ++i)
         if (qstring[i] == '?') {
            if (!candidate[i]) return 0;
         } else
            if (tolower(qstring[i]) != tolower(candidate[i]))
               return 0;
   } else {
      for (i=0; i < qlen; ++i)
         if (qstring[i] == '?') {
            if (!candidate[i]) return 0;
         } else
            if (qstring[i] != candidate[i])
               return 0;
   }
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebx
testl %ecx, %ecx
je 0xd720
testl %edx, %edx
jle 0xd74d
movl %edx, %r12d
xorl %r13d, %r13d
movsbq (%r14,%r13), %rbp
cmpq $0x3f, %rbp
jne 0xd701
cmpb $0x0, (%r15,%r13)
jne 0xd716
jmp 0xd74b
callq 0x23b0
movq (%rax), %rax
movl (%rax,%rbp,4), %ecx
movsbq (%r15,%r13), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0xd74b
incq %r13
cmpq %r13, %r12
jne 0xd6ed
jmp 0xd74d
testl %edx, %edx
jle 0xd74d
movl %edx, %eax
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb (%r15,%rcx), %sil
cmpb $0x3f, %dl
jne 0xd73c
testb %sil, %sil
jne 0xd741
jmp 0xd74b
cmpb %sil, %dl
jne 0xd74b
incq %rcx
cmpq %rcx, %rax
jne 0xd728
jmp 0xd74d
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__wildmatch_raw
int stb__wildmatch_raw(char *expr, char *candidate, int search, int insensitive)
{
   char buffer[256];
   // handle multiple search strings
   char *s = strchr(expr, ';');
   char *last = expr;
   while (s) {
      int z;
      // need to allow for non-writeable strings... assume they're small
      if (s - last < 256) {
         stb_strncpy(buffer, last, s-last+1);
         z = stb__wildmatch_raw2(buffer, candidate, search, insensitive);
      } else {
         *s = 0;
         z = stb__wildmatch_raw2(last, candidate, search, insensitive);
         *s = ';';
      }
      if (z >= 0) return z;
      last = s+1;
      s = strchr(last, ';');
   }
   return stb__wildmatch_raw2(last, candidate, search, insensitive);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
movl $0x3b, %esi
callq 0x2110
movq %rax, %r15
movq %r14, 0x8(%rsp)
testq %r15, %r15
je 0xd82a
movq %r15, %rax
subq %r13, %rax
cmpq $0xff, %rax
jg 0xd7e3
incl %eax
movslq %eax, %r12
movl %ebp, %r14d
movl %ebx, %ebp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2060
movb $0x0, 0xf(%rsp,%r12)
movq %rbx, %rdi
movl %ebp, %ebx
movl %r14d, %ebp
movq 0x8(%rsp), %r14
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xd396
movl %eax, %r12d
jmp 0xd7fd
movb $0x0, (%r15)
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xd396
movl %eax, %r12d
movb $0x3b, (%r15)
testl %r12d, %r12d
js 0xd809
movl %r12d, 0x4(%rsp)
jmp 0xd81f
movq %r15, %r13
incq %r13
movq %r13, %rdi
movl $0x3b, %esi
callq 0x2110
movq %rax, %r15
testl %r12d, %r12d
js 0xd78b
jmp 0xd83d
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xd396
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_regex_matcher
stb_matcher *stb_regex_matcher(char *regex)
{
   char *z;
   stb_uint16 end;
   stb_matcher *matcher = stb__alloc_matcher();
   if (*regex == '^') {
      matcher->match_start = 1;
      ++regex;
   }

   z = stb__reg_parse_alt(matcher, matcher->start_node, regex, &end);

   if (!z || *z) {
      stb_free(matcher);
      return NULL;
   }

   ((matcher->nodes)[(int) end]).goal = STB__NFA_STOP_GOAL;

   return matcher;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xd8fe
movq %rax, %rbx
cmpb $0x5e, (%r14)
jne 0xd8b7
movl $0x1, 0x14(%rbx)
incq %r14
movzwl (%rbx), %esi
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd9e8
testq %rax, %rax
je 0xd8d4
cmpb $0x0, (%rax)
je 0xd8e0
movq %rbx, %rdi
callq 0x4ecf
xorl %ebx, %ebx
jmp 0xd8f3
movq 0x18(%rbx), %rax
movzwl 0x6(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
movw $0xffff, (%rax,%rcx,8)  # imm = 0xFFFF
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__alloc_matcher
static stb_matcher *stb__alloc_matcher(void)
{
   stb_matcher *matcher = (stb_matcher *) stb_malloc(0,sizeof(*matcher));

   matcher->start_node  = 0;
   stb_arr_malloc((void **) &matcher->nodes, matcher);
   matcher->num_charset = 0;
   matcher->match_start = 0;
   matcher->does_lex    = 0;

   matcher->dfa_start   = STB__DFA_UNDEF;
   stb_arr_malloc((void **) &matcher->dfa, matcher);
   stb_arr_malloc((void **) &matcher->dfa_mapping, matcher);
   stb_arr_malloc((void **) &matcher->dfa_result, matcher);

   stb__add_node(matcher);

   return matcher;
}

// Assembly:
pushq %rbx
movl 0xc92f(%rip), %ecx      # 0x1a234
movl $0x48, %esi
xorl %edi, %edi
movl $0x2, %edx
callq 0x5184
movq %rax, %rbx
movw $0x0, (%rax)
movl 0xc910(%rip), %ecx      # 0x1a234
movl $0x10, %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x5184
movaps 0x47b3(%rip), %xmm0     # 0x120f0
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x18(%rbx)
movq $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movw $0xffff, 0x2(%rbx)      # imm = 0xFFFF
movl 0xc8d1(%rip), %ecx      # 0x1a234
movl $0x10, %esi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x5184
movaps 0x4774(%rip), %xmm0     # 0x120f0
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x28(%rbx)
movl 0xc8a7(%rip), %ecx      # 0x1a234
movl $0x10, %esi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x5184
movaps 0x474a(%rip), %xmm0     # 0x120f0
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x30(%rbx)
movl 0xc87d(%rip), %ecx      # 0x1a234
movl $0x10, %esi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x5184
movaps 0x4720(%rip), %xmm0     # 0x120f0
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
callq 0x11027
movq %rbx, %rax
popq %rbx
retq