LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
leaq -0x18(%r12), %r14
pushq $-0x1
popq %r13
testq %r12, %r12
je 0x9b88
movslq -0x10(%r12), %rax
jmp 0x9b8a
xorl %eax, %eax
incq %r13
cmpq %rax, %r13
jge 0x9bcd
movq 0x18(%r14), %rdi
addq $0x18, %r14
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
jne 0x9b7c
movslq -0x10(%r12), %rax
imulq $0x18, %rax, %rax
leaq (%r12,%rax), %rsi
addq $-0x18, %rsi
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x3153
movq (%rbx), %rax
decl -0x10(%rax)
pushq $0x1
popq %rax
jmp 0x9bcf
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__hashfind
static int stb__hashfind(void *p)
{
   stb_uint32 h = stb_hashptr(p);
   int s,n = h & stb__alloc_mask;
   if (stb__allocations[n].p == p)
      return n;
   s = stb_rehash(h)|1;
   for(;;) {
      if (stb__allocations[n].p == NULL)
         return -1;
      n = (n+s) & stb__alloc_mask;
      if (stb__allocations[n].p == p)
         return n;
   }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5355
movl %eax, %ecx
movl 0x1476a(%rip), %edx     # 0x1e3c8
movl %edx, %eax
andl %ecx, %eax
movq 0x12917(%rip), %rsi     # 0x1c580
movslq %eax, %rdi
imulq $0x18, %rdi, %rdi
movq (%rsi,%rdi), %rdi
cmpq %rbx, %rdi
je 0x9cae
movl %ecx, %r8d
shrl $0x6, %r8d
addl %ecx, %r8d
shrl $0x13, %ecx
addl %r8d, %ecx
orl $0x1, %ecx
pushq $-0x1
popq %r8
testq %rdi, %rdi
je 0x9cab
addl %ecx, %eax
andl %edx, %eax
movslq %eax, %rdi
imulq $0x18, %rdi, %rdi
movq (%rsi,%rdi), %rdi
cmpq %rbx, %rdi
jne 0x9c90
jmp 0x9cae
movl %r8d, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9eed
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x9c4d
testl %eax, %eax
js 0x9ef3
movl %eax, %edi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x9f1a
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x9f77
leaq 0x6844(%rip), %rdi      # 0x10746
leaq 0x6518(%rip), %rsi      # 0x10421
leaq 0x6a6e(%rip), %rcx      # 0x1097e
movl $0x1cd7, %edx           # imm = 0x1CD7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__remove_alloc
static void stb__remove_alloc(int n, char *file, int line)
{
   stb__alloc_history[stb__history_pos] = stb__allocations[n];
   stb__alloc_history[stb__history_pos].file = file;
   stb__alloc_history[stb__history_pos].line = line;
   if (++stb__history_pos == STB_MALLOC_HISTORY_COUNT)
      stb__history_pos = 0;
   stb__allocations[n].p = STB_DEL;
   --stb__alloc_count;
}

// Assembly:
movslq 0x14193(%rip), %rax     # 0x1e0b4
imulq $0x18, %rax, %rcx
leaq 0x12664(%rip), %r8      # 0x1c590
movq 0x1264d(%rip), %r9      # 0x1c580
movslq %edi, %rdi
imulq $0x18, %rdi, %rdi
movups (%r9,%rdi), %xmm0
movups %xmm0, (%rcx,%r8)
movq 0x10(%r9,%rdi), %r10
movq %r10, 0x10(%rcx,%r8)
movq %rsi, 0x8(%rcx,%r8)
movl %edx, 0x10(%rcx,%r8)
incl %eax
xorl %ecx, %ecx
cmpl $0x32, %eax
cmovnel %eax, %ecx
movl %ecx, 0x1414c(%rip)     # 0x1e0b4
movq $0x1, (%r9,%rdi)
decl 0x1413a(%rip)           # 0x1e0b0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq $0x33
popq %rcx
movl 0x14133(%rip), %r9d     # 0x1e0b4
pushq $-0x1
popq %rdx
pushq $0x31
popq %rsi
leaq 0x12602(%rip), %r8      # 0x1c590
decl %ecx
je 0x9fad
leal -0x1(%r9), %eax
testl %r9d, %r9d
cmovlel %esi, %eax
movslq %eax, %r9
imulq $0x18, %r9, %r10
movl %eax, %r9d
cmpq %rdi, (%r10,%r8)
jne 0x9f8e
retq
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9fc2
movq %rdi, %rbx
callq 0x9c4d
testl %eax, %eax
js 0x9fc4
popq %rbx
retq
movl 0x125be(%rip), %edx     # 0x1c588
movq 0x125af(%rip), %rax     # 0x1c580
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
imulq $0x18, %rdx, %rdx
addq $0x18, %rdx
leaq 0x18(%rcx), %rsi
cmpq %rsi, %rdx
je 0xa003
cmpq %rbx, (%rax,%rcx)
movq %rsi, %rcx
jne 0x9fe0
leaq 0x69b0(%rip), %rdi      # 0x109a9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2e7e
movq %rbx, %rdi
callq 0x9f77
testl %eax, %eax
js 0xa03b
movl %eax, %eax
imulq $0x18, %rax, %rax
leaq 0x12574(%rip), %rdx     # 0x1c590
movl 0x14(%rax,%rdx), %esi
movq 0x8(%rax,%rdx), %rcx
movl 0x10(%rax,%rdx), %r8d
leaq 0x69b9(%rip), %rdi      # 0x109ea
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e7e
leaq 0x69e5(%rip), %rdi      # 0x10a27
xorl %eax, %eax
callq 0x2e7e
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa09b
testq %r15, %r15
je 0xa0d3
movq %rdi, %r12
callq 0x9c4d
cmpl $-0x1, %eax
je 0xa0dc
cmpq %r12, %r15
je 0xa0b2
movl %eax, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9f1a
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9cb6
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9cb0
movq 0x124c7(%rip), %rcx     # 0x1c580
cltq
imulq $0x18, %rax, %rax
movl %ebp, 0x14(%rcx,%rax)
movq %r14, 0x8(%rcx,%rax)
movq 0x124b1(%rip), %rcx     # 0x1c580
movl %ebx, 0x10(%rcx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x9f77
leaq 0x665b(%rip), %rdi      # 0x10746
leaq 0x632f(%rip), %rsi      # 0x10421
leaq 0x6947(%rip), %rcx      # 0x10a40
movl $0x1d04, %edx           # imm = 0x1D04
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x14
popq %r14
movl 0x12473(%rip), %eax     # 0x1c588
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0xa151
movq 0x12459(%rip), %rcx     # 0x1c580
movq -0x14(%rcx,%r14), %rdi
cmpq $0x2, %rdi
jb 0xa148
movl (%rcx,%r14), %esi
movq -0xc(%rcx,%r14), %rdx
movl -0x4(%rcx,%r14), %ecx
callq *%rbx
movl 0x12440(%rip), %eax     # 0x1c588
incq %r15
addq $0x18, %r14
jmp 0xa118
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6915(%rip), %rsi      # 0x10a7b
callq 0x22f0
testq %rax, %rax
je 0xa1cb
movq %rax, %rbx
pushq $0x14
popq %r15
movl 0x1240b(%rip), %eax     # 0x1c588
leaq 0x68f9(%rip), %r14      # 0x10a7d
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0xa1cb
movq 0x123ea(%rip), %rsi     # 0x1c580
movq -0x14(%rsi,%r15), %rdx
cmpq $0x2, %rdx
jb 0xa1c2
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
movl 0x123c6(%rip), %eax     # 0x1c588
incq %r12
addq $0x18, %r15
jmp 0xa187
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 %rbx
movq %rdi, %rbx
movl %ebx, %eax
andl $0x3, %eax
leaq 0x5f74(%rip), %rcx      # 0x10184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x20
popq %rdi
callq 0x2250
movups -0x1(%rbx), %xmm0
movups 0xf(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
incq %rax
jmp 0xa261
pushq $0x78
popq %rdi
callq 0x2250
movl -0x2(%rbx), %ecx
movl %ecx, (%rax)
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0xa25d
movq 0x6(%rbx,%rdx,8), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
incq %rdx
jmp 0xa249
addq $0x2, %rax
movq %rax, %rbx
jmp 0xa27e
movl -0x3(%rbx), %edi
addq $0x1d, %rbx
movl %edi, %esi
movq %rbx, %rdx
callq 0xa283
movq %rax, %rbx
addq $0x3, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %edi, %r12d
leal -0x1(%r12), %ebp
movslq %ebp, %rax
leaq 0x28(,%rax,8), %rdi
callq 0x2250
testl %ebp, %r12d
jne 0xa346
movq %rax, %r15
cvtsi2ss %r12d, %xmm0
movl %r12d, (%rax)
movl %ebp, 0x4(%rax)
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1      # xmm1 = xmm1[0,0],xmm0[0,0]
mulps 0x5ddf(%rip), %xmm1     # 0x100b0
cvttps2dq %xmm1, %xmm1
movlps %xmm1, 0x10(%rax)
mulss 0x5d7b(%rip), %xmm0     # 0x1005c
cvttss2si %xmm0, %eax
movl %eax, 0x18(%r15)
andq $0x0, 0x8(%r15)
andl $0x0, 0x1c(%r15)
leaq 0x20(%r15), %rdi
movslq %r12d, %rdx
shlq $0x3, %rdx
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x2160
movq %r15, %r12
addq $0x3, %r12
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r13, %r14
je 0xa334
movq (%rbx,%r13,8), %rsi
testl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
je 0xa32f
movq %r12, %rdi
callq 0xa47a
incq %r13
jmp 0xa316
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d8c(%rip), %rdi      # 0x110d9
leaq 0x60cd(%rip), %rsi      # 0x10421
leaq 0x6d90(%rip), %rcx      # 0x110eb
movl $0x1dc7, %edx           # imm = 0x1DC7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testb $0x3, %bl
jne 0xa43c
cmpq $0x1, %rbx
jbe 0xa45b
movq %rdi, %r14
movl %r14d, %eax
andl $0x3, %eax
movl %eax, %eax
leaq 0x5e03(%rip), %rcx      # 0x10194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq %r14, %rbx
sete %cl
jmp 0xa431
movl -0x2(%r14), %eax
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
setne %cl
je 0xa431
leaq 0x1(%rdx), %rsi
cmpq %rbx, 0x6(%r14,%rdx,8)
movq %rsi, %rdx
jne 0xa3b0
jmp 0xa431
movq %rbx, %rdi
callq 0x5355
movl 0x1(%r14), %edx
movl %edx, %esi
andl %eax, %esi
movq 0x1d(%r14,%rsi,8), %rcx
cmpq %rbx, %rcx
je 0xa42b
testq %rcx, %rcx
je 0xa42f
movl %eax, %ecx
shrl $0x6, %ecx
addl %eax, %ecx
shrl $0x13, %eax
addl %ecx, %eax
orl $0x1, %eax
addl %eax, %esi
andl %edx, %esi
movq 0x1d(%r14,%rsi,8), %rdi
cmpq %rbx, %rdi
sete %cl
je 0xa431
testq %rdi, %rdi
jne 0xa3f6
jmp 0xa431
movb $0x1, %cl
cmpq %rbx, -0x1(%r14)
je 0xa431
cmpq %rbx, 0x7(%r14)
je 0xa431
cmpq %rbx, 0xf(%r14)
je 0xa431
cmpq %rbx, 0x17(%r14)
jmp 0xa39d
movb $0x1, %cl
jmp 0xa431
xorl %ecx, %ecx
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x664b(%rip), %rdi      # 0x10a8e
leaq 0x5fd7(%rip), %rsi      # 0x10421
leaq 0x6660(%rip), %rcx      # 0x10ab1
movl $0x1e01, %edx           # imm = 0x1E01
callq 0x2140
leaq 0x6671(%rip), %rdi      # 0x10ad3
leaq 0x5fb8(%rip), %rsi      # 0x10421
leaq 0x6641(%rip), %rcx      # 0x10ab1
movl $0x1e02, %edx           # imm = 0x1E02
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5708(%rip), %rcx      # 0x101d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xab8d
pushq $0x8
popq %rdi
callq 0x2250
movq %rax, %r15
movq %r14, (%rax)
pushq $0x1
popq %r13
jmp 0xab93
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 0xab93
movslq 0x5(%r14), %rdi
shlq $0x3, %rdi
callq 0x2250
movq %rax, %r15
movl -0x3(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %r13d, %r13d
cmpq %rcx, %rax
je 0xab93
movq 0x1d(%r14,%rcx,8), %rdx
testl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
je 0xab59
movslq %r13d, %rsi
incl %r13d
movq %rdx, (%r15,%rsi,8)
incq %rcx
jmp 0xab3d
pushq $0x20
popq %rdi
callq 0x2250
movq %rax, %r15
xorl %eax, %eax
xorl %r13d, %r13d
cmpq $0x4, %rax
je 0xab93
movq -0x1(%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0xab88
movslq %r13d, %rdx
incl %r13d
movq %rcx, (%r15,%rdx,8)
incq %rax
jmp 0xab6e
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_O2/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 0x562f(%rip), %rdx      # 0x101e4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testq %rcx, %rcx
sete %al
testl %ebx, %ebx
setle %dl
orb %al, %dl
jne 0xac66
movq %rcx, (%rsi)
pushq $0x1
popq %rax
jmp 0xac68
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 0xac68
testl %ebx, %ebx
jle 0xac66
movl 0x5(%rcx), %edx
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
xorl %eax, %eax
cmpq %rdi, %rdx
je 0xac68
movq 0x1d(%rcx,%rdi,8), %r8
testl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
je 0xac2e
movslq %eax, %r9
incl %eax
movq %r8, (%rsi,%r9,8)
cmpl %ebx, %eax
je 0xabfa
incq %rdi
jmp 0xac0e
xorl %edx, %edx
xorl %eax, %eax
cmpq $0x4, %rdx
je 0xac68
movq -0x1(%rcx,%rdx,8), %rdi
testq %rdi, %rdi
setne %r8b
cmpl %ebx, %eax
setl %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0xac61
movslq %eax, %r8
incl %eax
movq %rdi, (%rsi,%r8,8)
incq %rdx
jmp 0xac37
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x556c(%rip), %rcx      # 0x101f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xad22
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movslq -0x2(%r14), %rax
cmpq %rax, %r15
jge 0xad25
movq 0x6(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq *%r12
incq %r15
testl %eax, %eax
jne 0xacb3
xorl %ebp, %ebp
jmp 0xad25
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movslq 0x5(%r14), %rax
cmpq %rax, %r15
jge 0xad25
movq 0x1d(%r14,%r15,8), %rdi
testl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
je 0xacf8
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xacce
incq %r15
jmp 0xacd8
xorl %r15d, %r15d
pushq $0x1
popq %rbp
cmpq $0x4, %r15
je 0xad25
movq -0x1(%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xad1d
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xacce
incq %r15
jmp 0xad03
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0x5470(%rip), %rdx      # 0x10214
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testq %rax, %rax
je 0xade5
movq %rax, 0x11c87(%rip)     # 0x1ca40
leaq 0x11c80(%rip), %rax     # 0x1ca40
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
andl $0x0, (%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0xad95
movq %rax, %r14
movslq (%r15), %r15
xorl %r12d, %r12d
pushq $0x1
popq %rbp
cmpq %r15, %r12
jge 0xae38
movq (%r14,%r12,8), %rsi
cmpq $0x2, %rsi
jb 0xae31
movq %rbx, %rdi
callq 0xa365
testl %eax, %eax
je 0xae36
incq %r12
jmp 0xae16
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 %rdi, %r15
testq %rcx, %rcx
je 0xaf22
movq 0x11b33(%rip), %rax     # 0x1ca48
movq %rax, (%rsp)
movq %rbx, 0x11b28(%rip)     # 0x1ca48
jmp 0xaf22
leaq -0x1(%rsi), %r12
imulq %r14, %r12
addq %r15, %r12
movq %r14, %rbp
negq %rbp
movl %esi, %r13d
cmpl $0x2, %r13d
jl 0xaf61
callq 0xae97
xorl %edx, %edx
divq %r13
imulq %r14, %rdx
leaq (%rdx,%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x3153
addq %rbp, %r12
decq %r13
jmp 0xaf36
testq %rbx, %rbx
je 0xaf71
movq (%rsp), %rax
movq %rax, 0x11ad7(%rip)     # 0x1ca48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_srand
void stb_srand(unsigned long seed)
{
   int i;
   unsigned long old = stb_srandLCG(seed);
   for (i = 0; i < STB__MT_LEN; i++)
      stb__mt_buffer[i] = stb_randLCG();
   stb_srandLCG(old);
   stb__mt_index = STB__MT_LEN*sizeof(unsigned long);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x11a6f(%rip), %rbx     # 0x1ca48
movq %rdi, 0x11a68(%rip)     # 0x1ca48
xorl %r14d, %r14d
leaq 0x11a66(%rip), %r15     # 0x1ca50
cmpq $0x1380, %r14           # imm = 0x1380
je 0xb002
callq 0xae97
movq %rax, (%r14,%r15)
addq $0x8, %r14
jmp 0xafea
movq %rbx, 0x11a3f(%rip)     # 0x1ca48
movl $0x1380, 0xd219(%rip)   # imm = 0x1380
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_rand
unsigned long stb_rand()
{
   unsigned long * b = stb__mt_buffer;
   int idx = stb__mt_index;
   unsigned long s,r;
   int i;
	
   if (idx >= STB__MT_LEN*sizeof(unsigned long)) {
      if (idx > STB__MT_LEN*sizeof(unsigned long))
         stb_srand(0);
      idx = 0;
      i = 0;
      for (; i < STB__MT_IB; i++) {
         s = STB__TWIST(b, i, i+1);
         b[i] = b[i + STB__MT_IA] ^ (s >> 1) ^ STB__MAGIC(s);
      }
      for (; i < STB__MT_LEN-1; i++) {
         s = STB__TWIST(b, i, i+1);
         b[i] = b[i - STB__MT_IB] ^ (s >> 1) ^ STB__MAGIC(s);
      }
      
      s = STB__TWIST(b, STB__MT_LEN-1, 0);
      b[STB__MT_LEN-1] = b[STB__MT_IA-1] ^ (s >> 1) ^ STB__MAGIC(s);
   }
   stb__mt_index = idx + sizeof(unsigned long);
   
   r = *(unsigned long *)((unsigned char *)b + idx);
   
   r ^= (r >> 11);
   r ^= (r << 7) & 0x9D2C5680;
   r ^= (r << 15) & 0xEFC60000;
   r ^= (r >> 18);
   
   return r;
}

// Assembly:
movl 0xd20d(%rip), %eax      # 0x1822c
cmpq $0x137f, %rax           # imm = 0x137F
jbe 0xb090
cmpl $0x1380, %eax           # imm = 0x1380
je 0xb03a
pushq %rax
xorl %edi, %edi
callq 0xafcd
addq $0x8, %rsp
movl $0x9908b0df, %eax       # imm = 0x9908B0DF
xorl %edx, %edx
leaq 0x11a08(%rip), %rcx     # 0x1ca50
movl $0x80000000, %esi       # imm = 0x80000000
cmpq $0xe3, %rdx
je 0xb0a3
movq 0x8(%rcx,%rdx,8), %rdi
movl $0x9908b0df, %r8d       # imm = 0x9908B0DF
testb $0x1, %dil
jne 0xb06a
xorl %r8d, %r8d
movl (%rcx,%rdx,8), %r9d
andl %esi, %r9d
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
orl %r9d, %edi
shrl %edi
xorq 0xc68(%rcx,%rdx,8), %r8
xorq %rdi, %r8
movq %r8, (%rcx,%rdx,8)
incq %rdx
jmp 0xb04d
leaq 0x119b9(%rip), %rcx     # 0x1ca50
movq (%rax,%rcx), %rcx
addl $0x8, %eax
jmp 0xb12f
xorl %edx, %edx
movl $0x80000000, %esi       # imm = 0x80000000
cmpq $0x18c, %rdx            # imm = 0x18C
je 0xb0f4
movq 0x720(%rcx,%rdx,8), %rdi
movl $0x9908b0df, %r8d       # imm = 0x9908B0DF
testb $0x1, %dil
jne 0xb0ca
xorl %r8d, %r8d
movl 0x718(%rcx,%rdx,8), %r9d
andl %esi, %r9d
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
orl %r9d, %edi
xorq (%rcx,%rdx,8), %r8
shrl %edi
xorq %rdi, %r8
movq %r8, 0x718(%rcx,%rdx,8)
incq %rdx
jmp 0xb0aa
movl $0x80000000, %edx       # imm = 0x80000000
andl 0x12cc9(%rip), %edx     # 0x1ddc8
movq 0x1194a(%rip), %rcx     # 0x1ca50
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orl %edx, %esi
shrl %esi
xorl %edx, %edx
testb $0x1, %cl
cmovneq %rax, %rdx
xorq 0x1258e(%rip), %rdx     # 0x1d6b0
xorq %rsi, %rdx
movq %rdx, 0x12c9c(%rip)     # 0x1ddc8
pushq $0x8
popq %rax
movl %eax, 0xd0f7(%rip)      # 0x1822c
movq %rcx, %rax
shrq $0xb, %rax
xorq %rcx, %rax
movl %eax, %ecx
shll $0x7, %ecx
andl $0x9d2c5680, %ecx       # imm = 0x9D2C5680
xorq %rax, %rcx
movl %ecx, %edx
shll $0xf, %edx
andl $0xefc60000, %edx       # imm = 0xEFC60000
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x12, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
pushq $0x38
popq %rdi
callq 0x2250
movq %rax, %rbx
movl $0x4, 0xc(%rax)
pushq $0x10
popq %rax
pushq $0x5
popq %rcx
movl %eax, %edx
imull %eax, %edx
cmpl %ebp, %edx
jge 0xb279
movl %ecx, 0xc(%rbx)
addl %eax, %eax
incl %ecx
jmp 0xb267
movq %r12, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
andq $0x0, 0x10(%rbx)
movl %eax, 0x8(%rbx)
movl %eax, %r14d
leaq (,%r14,8), %rdi
callq 0x2250
movq %rax, (%rbx)
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0xb2b1
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0xb2a2
andq $0x0, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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), %rcx
movq (%rcx,%r15,8), %rax
testq %rax, %rax
je 0xb2fe
movl -0x10(%rax), %edx
cmpl -0xc(%rax), %edx
jge 0xb2fe
incl %edx
movl %edx, -0x10(%rax)
jmp 0xb314
leaq (%rcx,%r15,8), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x521e
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movslq -0x10(%rax), %rcx
movq %r14, -0x8(%rax,%rcx,8)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb349
movslq -0x10(%rdi), %rax
jmp 0xb34b
xorl %eax, %eax
cmpq %rax, %r12
jge 0xb368
cmpq $0x0, (%rdi,%r15)
je 0xb35f
addq %r15, %rdi
callq 0x510d
incq %r12
addq $0x8, %r15
jmp 0xb33b
movq %r14, %rdi
callq 0x510d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_eq
int stb_bitset_eq(stb_bitset *p0, stb_bitset *p1, int len)
{
   int i;
   for (i=0; i < len; ++i)
      if (p0[i] != p1[i]) return 0;
   return 1;
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
pushq $0x1
popq %rax
cmpq %rcx, %rdx
je 0xb788
movl (%rdi,%rcx,4), %r8d
leaq 0x1(%rcx), %r9
cmpl (%rsi,%rcx,4), %r8d
movq %r9, %rcx
je 0xb770
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_disjoint_0
int stb_bitset_disjoint_0(stb_bitset *p0, stb_bitset *p1, int len)
{
   int i;
   for (i=0; i < len; ++i)
      if ((p0[i] | p1[i]) != 0xffffffff) return 0;
   return 1;
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
pushq $0x1
popq %rax
cmpq %rcx, %rdx
je 0xb7ce
movl (%rsi,%rcx,4), %r8d
orl (%rdi,%rcx,4), %r8d
incq %rcx
cmpl $-0x1, %r8d
je 0xb7b6
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_subset
int stb_bitset_subset(stb_bitset *bigger, stb_bitset *smaller, int len)
{
   int i;
   for (i=0; i < len; ++i)
      if ((bigger[i] & smaller[i]) != smaller[i]) return 0;
   return 1;
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
pushq $0x1
popq %rax
cmpq %rcx, %rdx
je 0xb7f4
movl (%rdi,%rcx,4), %r8d
notl %r8d
leaq 0x1(%rcx), %r9
testl %r8d, (%rsi,%rcx,4)
movq %r9, %rcx
je 0xb7d9
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
pushq $0x1
popq %r8
xorl %eax, %eax
cmpq %rcx, %rdx
je 0xb861
movl (%rdi,%rcx,4), %r10d
movl (%rsi,%rcx,4), %r9d
orl %r10d, %r9d
cmpl %r10d, %r9d
je 0xb85c
movl %r9d, (%rdi,%rcx,4)
movl %r8d, %eax
incq %rcx
jmp 0xb840
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %esi, %r14
leaq (,%r14,4), %rdi
callq 0x2250
xorl %ecx, %ecx
negl %ebx
movl $0x0, %edx
sbbl %edx, %edx
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %rcx, %r14
je 0xb897
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0xb88a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rsp, %r14
andq $0x0, (%r14)
movq %rdi, %r15
xorl %eax, %eax
pushq $0x4
popq %r12
pushq $0x1
popq %r13
cmpl %ebx, %ebp
jge 0xb912
movl %ebp, %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%r15,%rcx,4), %ecx
btl %ebp, %ecx
jae 0xb90e
testq %rax, %rax
je 0xb8eb
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xb8eb
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xb8fd
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x521e
movq (%rsp), %rax
testq %rax, %rax
je 0xb908
movslq -0x10(%rax), %rcx
jmp 0xb90a
xorl %ecx, %ecx
movl %ebp, -0x4(%rax,%rcx,4)
incl %ebp
jmp 0xb8c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0xb921
movl %eax, %r14d
movq %rsp, %r15
andq $0x0, (%r15)
leal (%r14,%r14), %edx
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x5206
movq (%r15), %r15
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xb921
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__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
xorl %r12d, %r12d
testl %edx, %edx
cmovgl %edx, %r12d
testl %ecx, %ecx
je 0xbee3
xorl %r13d, %r13d
pushq $0x1
popq %rbx
cmpq %r13, %r12
je 0xbf0b
movsbq (%r14,%r13), %rbp
cmpq $0x3f, %rbp
jne 0xbec9
cmpb $0x0, (%r15,%r13)
jne 0xbede
jmp 0xbf09
callq 0x23a0
movq (%rax), %rax
movl (%rax,%rbp,4), %ecx
movsbq (%r15,%r13), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0xbf09
incq %r13
jmp 0xbeb0
xorl %eax, %eax
pushq $0x1
popq %rbx
cmpq %rax, %r12
je 0xbf0b
movb (%r14,%rax), %cl
movb (%r15,%rax), %dl
cmpb $0x3f, %cl
jne 0xbf00
testb %dl, %dl
jne 0xbf04
jmp 0xbf09
cmpb %dl, %cl
jne 0xbf09
incq %rax
jmp 0xbee8
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_O2/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 $0x108, %rsp            # imm = 0x108
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
pushq $0x3b
popq %rsi
callq 0x2110
movq %rax, %r15
movq %rsp, %r12
testq %r15, %r15
je 0xbfa8
movq %r15, %rdx
subq %r13, %rdx
cmpq $0xff, %rdx
jg 0xbf77
incl %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3c14
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xbbc9
jmp 0xbf8e
movb $0x0, (%r15)
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xbbc9
movb $0x3b, (%r15)
testl %eax, %eax
jns 0xbfb7
movq %r15, %r13
incq %r13
movq %r13, %rdi
pushq $0x3b
popq %rsi
callq 0x2110
movq %rax, %r15
jmp 0xbf45
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xbbc9
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0xc06a
movq %rax, %rbx
cmpb $0x5e, (%r14)
jne 0xc024
movl $0x1, 0x14(%rbx)
incq %r14
movzwl (%rbx), %esi
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc0c7
testq %rax, %rax
je 0xc041
cmpb $0x0, (%rax)
je 0xc04d
movq %rbx, %rdi
callq 0x4992
xorl %ebx, %ebx
jmp 0xc05f
movq 0x18(%rbx), %rax
movzwl 0x6(%rsp), %ecx
imulq $0x18, %rcx, %rcx
orw $-0x1, (%rax,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x48
popq %rsi
xorl %edi, %edi
callq 0x4dcf
movq %rax, %rbx
andw $0x0, (%rax)
leaq 0x18(%rax), %rdi
movq %rax, %rsi
callq 0x5064
andq $0x0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
orw $-0x1, 0x2(%rbx)
leaq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x5064
leaq 0x30(%rbx), %rdi
movq %rbx, %rsi
callq 0x5064
leaq 0x38(%rbx), %rdi
movq %rbx, %rsi
callq 0x5064
movq %rbx, %rdi
callq 0xf1db
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__reg_parse_alt
static char *stb__reg_parse_alt(stb_matcher *matcher, int start, char *regex, stb_uint16 *end)
{
   stb_uint16 last_end = start;
   stb_uint16 main_end;

   int head, tail;

   head = stb__add_node(matcher);
   stb__add_epsilon(matcher, start, head);

   regex = stb__reg_parse(matcher, head, regex, &last_end);
   if (regex == NULL) return NULL;
   if (*regex == 0 || *regex == ')') {
      *end = last_end;
      return regex;
   }

   main_end = last_end;
   tail = stb__add_node(matcher);

   stb__add_epsilon(matcher, last_end, tail);

   // start alternatives from the same starting node; use epsilon
   // transitions to combine their endings
   while(*regex && *regex != ')') {
      assert(*regex == '|');
      head = stb__add_node(matcher);
      stb__add_epsilon(matcher, start, head);
      regex = stb__reg_parse(matcher, head, regex+1, &last_end);
      if (regex == NULL)
         return NULL;
      stb__add_epsilon(matcher, last_end, tail);
   }

   *end = tail;
   return regex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0xe(%rsp), %r12
movw %bp, (%r12)
callq 0xf1db
movl %eax, %r13d
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xf253
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0xf2e9
testq %rax, %rax
je 0xc190
movq %rax, %r14
movzbl (%rax), %eax
cmpl $0x29, %eax
je 0xc125
testl %eax, %eax
jne 0xc136
movzwl 0xe(%rsp), %r12d
movq 0x10(%rsp), %rax
movw %r12w, (%rax)
jmp 0xc193
movq %r15, %rdi
callq 0xf1db
movl %eax, %r12d
leaq 0xe(%rsp), %r13
movzwl 0xe(%rsp), %esi
movq %r15, %rdi
movl %r12d, %edx
callq 0xf253
movzbl (%r14), %eax
cmpl $0x7c, %eax
jne 0xc1a5
movq %r15, %rdi
callq 0xf1db
movl %eax, %ebx
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xf253
incq %r14
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0xf2e9
movq %rax, %r14
testq %rax, %rax
jne 0xc146
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0xc12b
cmpl $0x29, %eax
je 0xc12b
leaq 0x4f62(%rip), %rdi      # 0x1111b
leaq 0x4261(%rip), %rsi      # 0x10421
leaq 0x4f62(%rip), %rcx      # 0x11129
movl $0x245a, %edx           # imm = 0x245A
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lex_matcher
stb_matcher *stb_lex_matcher(void)
{
   stb_matcher *matcher = stb__alloc_matcher();

   matcher->match_start = 1;
   matcher->does_lex    = 1;

   return matcher;
}

// Assembly:
pushq %rax
callq 0xc06a
pushq $0x1
popq %rcx
movl %ecx, 0x14(%rax)
movl %ecx, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lex_item
int stb_lex_item(stb_matcher *matcher, char *regex, int result)
{
   char *z;
   stb_uint16 end;

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

   if (z == NULL)
      return 0;

   stb__lex_reset(matcher);

   matcher->nodes[(int) end].goal = result;
   return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %r14
movzwl (%rdi), %esi
leaq 0x6(%rsp), %rcx
callq 0xc0c7
testq %rax, %rax
je 0xc21e
movq %r14, %rdi
callq 0xc228
movq 0x18(%r14), %rax
movzwl 0x6(%rsp), %ecx
imulq $0x18, %rcx, %rcx
movw %bx, (%rax,%rcx)
pushq $0x1
popq %rax
jmp 0xc220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq