LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb5f9
cmpq $0x1, %rsi
jbe 0xb618
movl %edi, %eax
andl $0x3, %eax
movl %eax, %eax
leaq 0x6d22(%rip), %rcx      # 0x12224
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq %rdi, %rsi
sete %al
jmp 0xb5f4
movslq -0x2(%rdi), %rcx
testq %rcx, %rcx
jle 0xb5ee
decq %rcx
xorl %edx, %edx
cmpq %rsi, 0x6(%rdi,%rdx,8)
sete %al
je 0xb5f4
leaq 0x1(%rdx), %r8
cmpq %rdx, %rcx
movq %r8, %rdx
jne 0xb528
jmp 0xb5f4
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 0xb5f2
testq %rax, %rax
je 0xb5ee
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 0xb5f4
testq %r9, %r9
jne 0xb5b7
jmp 0xb5f4
movb $0x1, %al
cmpq %rsi, -0x1(%rdi)
je 0xb5f4
cmpq %rsi, 0x7(%rdi)
je 0xb5f4
cmpq %rsi, 0xf(%rdi)
je 0xb5f4
cmpq %rsi, 0x17(%rdi)
jmp 0xb50e
xorl %eax, %eax
jmp 0xb5f4
movb $0x1, %al
movzbl %al, %eax
popq %rcx
retq
leaq 0x751e(%rip), %rdi      # 0x12b1e
leaq 0x6eaa(%rip), %rsi      # 0x124b1
leaq 0x7533(%rip), %rcx      # 0x12b41
movl $0x1e01, %edx           # imm = 0x1E01
callq 0x2140
leaq 0x7544(%rip), %rdi      # 0x12b63
leaq 0x6e8b(%rip), %rsi      # 0x124b1
leaq 0x7514(%rip), %rcx      # 0x12b41
movl $0x1e02, %edx           # imm = 0x1E02
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6542(%rip), %rcx      # 0x12254
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xbdde
movl $0x8, %edi
callq 0x2250
movq %rax, %r15
movq %r14, (%rax)
movl $0x1, %r13d
jmp 0xbde4
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 0xbde4
movslq 0x5(%r14), %rdi
shlq $0x3, %rdi
callq 0x2250
movq %rax, %r15
movslq -0x3(%r14), %rax
testq %rax, %rax
jle 0xbdd9
xorl %ecx, %ecx
xorl %r13d, %r13d
movq 0x1d(%r14,%rcx,8), %rdx
testl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
je 0xbd9e
movslq %r13d, %rsi
incl %r13d
movq %rdx, (%r15,%rsi,8)
incq %rcx
cmpq %rcx, %rax
jne 0xbd87
jmp 0xbde4
movl $0x20, %edi
callq 0x2250
movq %rax, %r15
xorl %eax, %eax
xorl %r13d, %r13d
movq -0x1(%r14,%rax,8), %rcx
testq %rcx, %rcx
je 0xbdce
movslq %r13d, %rdx
incl %r13d
movq %rcx, (%r15,%rdx,8)
incq %rax
cmpq $0x4, %rax
jne 0xbdba
jmp 0xbde4
xorl %r13d, %r13d
jmp 0xbde4
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_O3/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 0x645e(%rip), %rdx      # 0x12264
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 0xbebe
movq %rcx, (%rsi)
movl $0x1, %eax
jmp 0xbebe
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 0xbebe
xorl %eax, %eax
testl %ebx, %ebx
jle 0xbebe
movslq 0x5(%rcx), %rdx
testq %rdx, %rdx
jle 0xbebe
xorl %edi, %edi
xorl %eax, %eax
movq 0x1d(%rcx,%rdi,8), %r8
testl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
je 0xbe83
movslq %eax, %r9
incl %eax
movq %r8, (%rsi,%r9,8)
cmpl %ebx, %eax
je 0xbe51
incq %rdi
cmpq %rdi, %rdx
jne 0xbe68
jmp 0xbebe
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 0xbeb5
movslq %eax, %r8
incl %eax
movq %rdi, (%rsi,%r8,8)
incq %rdx
cmpq $0x4, %rdx
jne 0xbe91
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6396(%rip), %rcx      # 0x12274
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xbf8b
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 0xbf94
xorl %r15d, %r15d
movq 0x6(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xbf92
incq %r15
movslq -0x2(%r14), %rax
cmpq %rax, %r15
jl 0xbf16
jmp 0xbf94
movl 0x5(%r14), %eax
movl $0x1, %ebp
testl %eax, %eax
jle 0xbf94
xorl %r15d, %r15d
movq 0x1d(%r14,%r15,8), %rdi
testl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
je 0xbf5e
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xbf92
movl 0x5(%r14), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xbf43
jmp 0xbf94
xorl %r15d, %r15d
movq -0x1(%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xbf82
movq %rbx, %rsi
callq *%r12
testl %eax, %eax
je 0xbf92
incq %r15
cmpq $0x4, %r15
jne 0xbf6e
movl $0x1, %ebp
jmp 0xbf94
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6281(%rip), %rdx      # 0x12294
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testq %rax, %rax
je 0xc054
movq %rax, 0x12a18(%rip)     # 0x1ea40
leaq 0x12a11(%rip), %rax     # 0x1ea40
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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl %r14d, %eax
andl $0x3, %eax
leaq 0x622c(%rip), %rcx      # 0x122a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
testq %r14, %r14
je 0xc0ee
movq %r14, 0x129b3(%rip)     # 0x1ea40
movl $0x1, %eax
leaq 0x129a7(%rip), %r14     # 0x1ea40
jmp 0xc0ca
movl $0x6, %ecx
movq $-0x2, %rax
jmp 0xc0b5
movl $0x1d, %ecx
movq $-0x3, %rax
movl (%r14,%rax), %eax
testl %eax, %eax
jle 0xc0ee
addq %rcx, %r14
jmp 0xc0ca
decq %r14
movl $0x4, %eax
movl %eax, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
cmpq $0x2, %rsi
jb 0xc0e6
movq %rbx, %rdi
callq 0xb4df
testl %eax, %eax
je 0xc0f5
incq %r12
cmpq %r12, %r15
jne 0xc0d0
movl $0x1, %eax
jmp 0xc0f7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0xc206
movq 0x1284f(%rip), %rax     # 0x1ea48
movq %rax, (%rsp)
movq %rbx, 0x12844(%rip)     # 0x1ea48
jmp 0xc206
cmpl $0x2, %r12d
jl 0xc27a
leaq -0x1(%r12), %r13
imulq %r14, %r13
addq %r15, %r13
movq %r14, %rbp
negq %rbp
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
imulq $0x7ff8a3ed, 0x12818(%rip), %rax # imm = 0x7FF8A3ED
addq $0x2aa01d31, %rax       # imm = 0x2AA01D31
movq %rax, 0x1280b(%rip)     # 0x1ea48
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 0x32fe
addq %rbp, %r13
leaq -0x1(%r12), %rax
cmpq $0x2, %r12
movq %rax, %r12
ja 0xc225
testq %rbx, %rbx
je 0xc28a
movq (%rsp), %rax
movq %rax, 0x127be(%rip)     # 0x1ea48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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:
xorl %eax, %eax
leaq 0x1274c(%rip), %rcx     # 0x1ea50
imulq $0x7ff8a3ed, %rdi, %rdi # imm = 0x7FF8A3ED
addq $0x2aa01d31, %rdi       # imm = 0x2AA01D31
movq %rdi, %rdx
shrq $0x10, %rdx
movq %rdi, %rsi
shlq $0x10, %rsi
addq %rdx, %rsi
xorq $0x31415926, %rsi       # imm = 0x31415926
movq %rsi, (%rax,%rcx)
addq $0x8, %rax
cmpq $0x1380, %rax           # imm = 0x1380
jne 0xc304
movl $0x1380, 0xdee8(%rip)   # imm = 0x1380
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x38, %edi
callq 0x2250
movq %rax, %rbx
movl $0x4, 0xc(%rax)
movl $0x10, %eax
cmpl $0x101, %ebp            # imm = 0x101
jl 0xc615
movl $0x4, %ecx
incl %ecx
addl %eax, %eax
movl %eax, %edx
imull %eax, %edx
cmpl %ebp, %edx
jl 0xc605
movl %ecx, 0xc(%rbx)
movq %r12, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movl %eax, 0x8(%rbx)
movl %eax, %r14d
leaq (,%r14,8), %rdi
callq 0x2250
movq %rax, (%rbx)
cmpq $0x1, %r14
adcq %r15, %r14
shlq $0x3, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2160
movq %r15, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc6a2
movl -0x10(%rax), %edx
cmpl -0xc(%rax), %edx
jge 0xc6a2
incl %edx
movl %edx, -0x10(%rax)
jmp 0xc6bc
leaq (%rcx,%r15,8), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x56ce
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_O3/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 0xc6f1
movslq -0x10(%rdi), %rax
jmp 0xc6f3
xorl %eax, %eax
cmpq %rax, %r12
jge 0xc710
cmpq $0x0, (%rdi,%r15)
je 0xc707
addq %r15, %rdi
callq 0x55ba
incq %r12
addq $0x8, %r15
jmp 0xc6e3
movq %r14, %rdi
callq 0x55ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcceb
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 0xcce2
movl %r8d, (%rdi,%rdx,4)
movl $0x1, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0xccc9
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xce03
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 0x536a(%rip), %xmm1     # 0x120a0
movdqa 0x5372(%rip), %xmm2     # 0x120b0
xorl %edx, %edx
movdqa 0x5318(%rip), %xmm3     # 0x12060
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x5368(%rip), %xmm5     # 0x120c0
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 0xcd90
movl %ecx, (%rax,%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xcda3
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 0xcddf
movl %ecx, 0x8(%rax,%rdx)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xcdee
movl %ecx, 0xc(%rax,%rdx)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rbx
jne 0xcd58
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xce7b
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %eax, %eax
movq %rsp, %r15
movl %ebp, %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%r14,%rcx,4), %ecx
btl %ebp, %ecx
jae 0xce73
testq %rax, %rax
je 0xce4c
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xce4c
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xce62
movq %r15, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x56ce
movq (%rsp), %rax
testq %rax, %rax
je 0xce6d
movslq -0x10(%rax), %rcx
jmp 0xce6f
xorl %ecx, %ecx
movl %ebp, -0x4(%rax,%rcx,4)
incl %ebp
cmpl %ebp, %ebx
jne 0xce27
jmp 0xce7d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xce88
movl %eax, %r14d
movq %rsp, %r15
movq $0x0, (%r15)
leal (%r14,%r14), %ecx
movq %r15, %rdi
movl $0x4, %esi
movl %ecx, %edx
callq 0x55f6
movq (%r15), %r15
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xce88
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd4c6
testl %edx, %edx
jle 0xd4f3
movl %edx, %r12d
xorl %r13d, %r13d
movsbq (%r14,%r13), %rbp
cmpq $0x3f, %rbp
jne 0xd4a7
cmpb $0x0, (%r15,%r13)
jne 0xd4bc
jmp 0xd4f1
callq 0x23a0
movq (%rax), %rax
movl (%rax,%rbp,4), %ecx
movsbq (%r15,%r13), %rdx
cmpl (%rax,%rdx,4), %ecx
jne 0xd4f1
incq %r13
cmpq %r13, %r12
jne 0xd493
jmp 0xd4f3
testl %edx, %edx
jle 0xd4f3
movl %edx, %eax
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb (%r15,%rcx), %sil
cmpb $0x3f, %dl
jne 0xd4e2
testb %sil, %sil
jne 0xd4e7
jmp 0xd4f1
cmpb %sil, %dl
jne 0xd4f1
incq %rcx
cmpq %rcx, %rax
jne 0xd4ce
jmp 0xd4f3
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_O3/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
testq %rax, %rax
je 0xd5c2
movq %rax, %r12
movq %r14, 0x8(%rsp)
movq %r12, %rax
subq %r13, %rax
cmpq $0xff, %rax
jg 0xd586
incl %eax
movslq %eax, %r15
movl %ebp, %r14d
movl %ebx, %ebp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2060
movb $0x0, 0xf(%rsp,%r15)
movq %rbx, %rdi
movl %ebp, %ebx
movl %r14d, %ebp
movq 0x8(%rsp), %r14
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xd176
jmp 0xd59f
movb $0x0, (%r12)
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xd176
movb $0x3b, (%r12)
testl %eax, %eax
jns 0xd5d1
movq %r12, %r13
incq %r13
movq %r13, %rdi
movl $0x3b, %esi
callq 0x2110
movq %rax, %r12
testq %rax, %rax
jne 0xd53a
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xd176
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_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 0xd68e
movq %rax, %rbx
cmpb $0x5e, (%r14)
jne 0xd647
movl $0x1, 0x14(%rbx)
incq %r14
movzwl (%rbx), %esi
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd778
testq %rax, %rax
je 0xd664
cmpb $0x0, (%rax)
je 0xd670
movq %rbx, %rdi
callq 0x4de4
xorl %ebx, %ebx
jmp 0xd683
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_O3/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 0xcb8f(%rip), %ecx      # 0x1a224
movl $0x48, %esi
xorl %edi, %edi
movl $0x2, %edx
callq 0x508a
movq %rax, %rbx
movw $0x0, (%rax)
movl 0xcb70(%rip), %ecx      # 0x1a224
movl $0x10, %esi
movq %rax, %rdi
movl $0x2, %edx
callq 0x508a
movaps 0x49c3(%rip), %xmm0     # 0x12090
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 0xcb31(%rip), %ecx      # 0x1a224
movl $0x10, %esi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x508a
movaps 0x4984(%rip), %xmm0     # 0x12090
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x28(%rbx)
movl 0xcb07(%rip), %ecx      # 0x1a224
movl $0x10, %esi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x508a
movaps 0x495a(%rip), %xmm0     # 0x12090
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x30(%rbx)
movl 0xcadd(%rip), %ecx      # 0x1a224
movl $0x10, %esi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x508a
movaps 0x4930(%rip), %xmm0     # 0x12090
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
callq 0x10ceb
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10ceb
movl %eax, %r13d
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x10d6a
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x10e35
testq %rax, %rax
je 0xd841
movq %rax, %r14
movzbl (%rax), %eax
cmpl $0x29, %eax
je 0xd7d6
testl %eax, %eax
jne 0xd7e7
movzwl 0xe(%rsp), %r12d
movq 0x10(%rsp), %rax
movw %r12w, (%rax)
jmp 0xd844
movq %r15, %rdi
callq 0x10ceb
movl %eax, %r12d
leaq 0xe(%rsp), %r13
movzwl 0xe(%rsp), %esi
movq %r15, %rdi
movl %r12d, %edx
callq 0x10d6a
movzbl (%r14), %eax
cmpl $0x7c, %eax
jne 0xd856
movq %r15, %rdi
callq 0x10ceb
movl %eax, %ebx
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x10d6a
incq %r14
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x10e35
movq %rax, %r14
testq %rax, %rax
jne 0xd7f7
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 0xd7dc
cmpl $0x29, %eax
je 0xd7dc
leaq 0x5941(%rip), %rdi      # 0x131ab
leaq 0x4c40(%rip), %rsi      # 0x124b1
leaq 0x5941(%rip), %rcx      # 0x131b9
movl $0x245a, %edx           # imm = 0x245A
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd778
testq %rax, %rax
je 0xd8d3
movq %r14, %rdi
callq 0xd8dd
movq 0x18(%r14), %rax
movzwl 0x6(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
movw %bx, (%rax,%rcx,8)
movl $0x1, %eax
jmp 0xd8d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__lex_reset
static void stb__lex_reset(stb_matcher *matcher)
{
   // flush cached dfa data
   stb_arr_setlen(matcher->dfa, 0);
   stb_arr_setlen(matcher->dfa_mapping, 0);
   stb_arr_setlen(matcher->dfa_result, 0);
   matcher->dfa_start = STB__DFA_UNDEF;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xd8f9
cmpl $0x0, -0xc(%rax)
js 0xd8f9
movl $0x0, -0x10(%rax)
jmp 0xd90b
leaq 0x28(%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x55f6
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xd923
cmpl $0x0, -0xc(%rax)
js 0xd923
movl $0x0, -0x10(%rax)
jmp 0xd935
leaq 0x30(%rbx), %rdi
movl $0x4, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x55f6
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xd94d
cmpl $0x0, -0xc(%rax)
js 0xd94d
movl $0x0, -0x10(%rax)
jmp 0xd95f
leaq 0x38(%rbx), %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x55f6
movw $0xffff, 0x2(%rbx)      # imm = 0xFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lex_item_wild
int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result)
{
   char *z;
   stb_uint16 end;

   z = stb__wild_parse(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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movzwl (%rdi), %ebx
callq 0x10ceb
movl %eax, %r15d
movzwl %r15w, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x10d6a
movl %r15d, %ebp
movzbl (%r12), %ebx
movq %r14, %rdi
callq 0x10ceb
movl %eax, %r15d
cmpl $0x2a, %ebx
je 0xda00
cmpl $0x3f, %ebx
je 0xd9f0
testl %ebx, %ebx
je 0xda66
callq 0x2030
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movsbq (%r12), %rbx
movl (%rax,%rbx,4), %r13d
callq 0x23a0
movq (%rax), %rax
movl (%rax,%rbx,4), %ecx
cmpl %ecx, %r13d
jne 0xda31
movzwl %bp, %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebx, %ecx
jmp 0xda59
movzwl %bp, %esi
movq %r14, %rdi
movl %r15d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0xda59
movzwl %bp, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x111ea
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x10d6a
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x10d6a
jmp 0xda5e
movzwl %bp, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x111ea
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbq (%r12), %rcx
movl (%rax,%rcx,4), %ecx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x111ea
incq %r12
jmp 0xd998
movl $0xffff, %ebx           # imm = 0xFFFF
andl %ebx, %ebp
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x111ea
movq %r14, %rdi
callq 0xd8dd
movq 0x18(%r14), %rax
andl %ebx, %r15d
leaq (%r15,%r15,2), %rcx
movl 0xc(%rsp), %edx
movw %dx, (%rax,%rcx,8)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_if_inactive
static stb_uint16 * stb__add_if_inactive(stb_matcher *m, stb_uint16 *list, int n)
{
   if (!m->nodes[n].active) {
      stb_arr_push(list, n);
      m->nodes[n].active = 1;
   }
   return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x18(%rdi), %rcx
movl %edx, %edx
leaq (%rdx,%rdx,2), %r12
cmpb $0x0, 0x2(%rcx,%r12,8)
jne 0xde79
movq %rdi, %r14
testq %rax, %rax
je 0xde4e
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xde4e
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xde66
movq %rsp, %r15
movq %r15, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x56ce
movq (%r15), %rax
movslq -0x10(%rax), %rcx
movw %bx, -0x2(%rax,%rcx,2)
movq 0x18(%r14), %rcx
movb $0x1, 0x2(%rcx,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__eps_closure
static stb_uint16 * stb__eps_closure(stb_matcher *m, stb_uint16 *list)
{
   int i,n = stb_arr_len(list);

   for(i=0; i < n; ++i) {
      stb_uint16 *e = m->nodes[(int) list[i]].eps;
      if (e) {
         int j,k = stb_arr_len(e);
         for (j=0; j < k; ++j)
            list = stb__add_if_inactive(m, list, e[j]);
         n = stb_arr_len(list);
      }
   }

   return list;
}

// Assembly:
testq %rsi, %rsi
je 0xdf01
movq %rsi, %rax
movl -0x10(%rsi), %ecx
testl %ecx, %ecx
jle 0xdf03
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x18(%rbx), %rdx
movzwl (%rax,%r14,2), %esi
leaq (%rsi,%rsi,2), %rsi
movq 0x10(%rdx,%rsi,8), %r15
testq %r15, %r15
je 0xdeec
movslq -0x10(%r15), %r12
testq %r12, %r12
jle 0xdee3
xorl %r13d, %r13d
movzwl (%r15,%r13,2), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde14
incq %r13
cmpq %r13, %r12
jne 0xdec6
testq %rax, %rax
je 0xdee8
movl -0x10(%rax), %ecx
jmp 0xdeec
xorl %ecx, %ecx
xorl %eax, %eax
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0xdea3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_decompress_fromfile
char *stb_decompress_fromfile(char *filename, unsigned int *len)
{
   unsigned int n;
   char *q;
   unsigned char *p;
   FILE *f = fopen(filename, "rb");   if (f == NULL) return NULL;
   fseek(f, 0, SEEK_END);
   n = ftell(f);
   fseek(f, 0, SEEK_SET);
   p = (unsigned char * ) malloc(n); if (p == NULL) return NULL;
   fread(p, 1, n, f);
   fclose(f);
   if (p == NULL) return NULL;
   if (p[0] != 0x57 || p[1] != 0xBc || p[2] || p[3]) { free(p); return NULL; }
   q = (char *) malloc(stb_decompress_length(p)+1);
   if (!q) { free(p); return NULL; }
   *len = stb_decompress((unsigned char *) q, p, n);
   if (*len) q[*len] = 0;
   free(p);
   return q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x39f4(%rip), %rsi      # 0x127fc
callq 0x22f0
testq %rax, %rax
je 0xee90
movq %rax, %r13
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22a0
movq %r13, %rdi
callq 0x2200
movq %rax, %r12
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22a0
movl %r12d, %ebp
movq %rbp, %rdi
callq 0x2250
testq %rax, %rax
je 0xee93
movq %rax, %rbx
movl $0x1, %esi
movq %rax, %rdi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x20b0
movq %r13, %rdi
callq 0x20d0
cmpb $0x57, (%rbx)
jne 0xee83
cmpb $-0x44, 0x1(%rbx)
jne 0xee83
cmpb $0x0, 0x2(%rbx)
jne 0xee83
cmpb $0x0, 0x3(%rbx)
je 0xeea5
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x23c0
jmp 0xee93
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %edi
bswapl %edi
incl %edi
callq 0x2250
testq %rax, %rax
je 0xee83
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0xeaff
movl %eax, (%r14)
testl %eax, %eax
je 0xee86
movl %eax, %eax
movb $0x0, (%r15,%rax)
jmp 0xee86
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress
stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
{
   stb__out = out;
   stb__outfile = NULL;

   stb_compress_inner(input, length);

   return stb__out - out;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rdi, 0x10f40(%rip)     # 0x1fe58
movq $0x0, 0x10f3d(%rip) # 0x1fe60
movq %rsi, %rdi
movl %edx, %esi
callq 0xef37
movl 0x10f25(%rip), %eax     # 0x1fe58
subl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_inner
static int stb_compress_inner(stb_uchar *input, stb_uint length)
{
   int literals = 0;
   stb_uint len,i;

   stb_uchar **chash;
   chash = (stb_uchar**) malloc(stb__hashsize * sizeof(stb_uchar*));
   if (chash == NULL) return 0; // failure
   for (i=0; i < stb__hashsize; ++i)
      chash[i] = NULL;

   // stream signature
   stb_out(0x57); stb_out(0xbc);
   stb_out2(0);

   stb_out4(0);       // 64-bit length requires 32-bit leading 0
   stb_out4(length);
   stb_out4(stb__window);

   stb__running_adler = 1;

   len = stb_compress_chunk(input, input, input+length, length, &literals, chash, stb__hashsize-1);
   assert(len == length);

   outliterals(input+length - literals, literals);

   free(chash);

   stb_out2(0x05fa); // end opcode

   stb_out4(stb__running_adler);

   return 1; // success
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
movl 0xb2dd(%rip), %r12d     # 0x1a234
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x2250
testq %rax, %rax
je 0xef95
movq %rax, %rbx
testl %r12d, %r12d
je 0xef81
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2160
movq 0x10ed0(%rip), %rax     # 0x1fe58
testq %rax, %rax
je 0xef9c
movb $0x57, (%rax)
incq %rax
jmp 0xefc3
xorl %eax, %eax
jmp 0xf056
movq 0x10ebd(%rip), %rsi     # 0x1fe60
movl $0x57, %edi
callq 0x21b0
incl 0x10eb5(%rip)           # 0x1fe68
movq 0x10e9e(%rip), %rax     # 0x1fe58
testq %rax, %rax
je 0xf063
leaq 0x1(%rax), %rcx
movq %rcx, 0x10e8a(%rip)     # 0x1fe58
movb $-0x44, (%rax)
xorl %edi, %edi
callq 0x113a3
xorl %edi, %edi
callq 0x11405
movl %ebp, %edi
callq 0x11405
movl 0xb244(%rip), %edi      # 0x1a230
callq 0x11405
movl $0x1, 0x113d5(%rip)     # 0x203d0
movl %ebp, %r15d
addq %r14, %r15
movl 0xb22c(%rip), %r9d      # 0x1a234
decl %r9d
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %r8
callq 0xf372
cmpl %ebp, %eax
jne 0xf07f
movslq 0xc(%rsp), %rsi
subq %rsi, %r15
movq %r15, %rdi
callq 0xfaf5
movq %rbx, %rdi
callq 0x23c0
movl $0x5fa, %edi            # imm = 0x5FA
callq 0x113a3
movl 0x11384(%rip), %edi     # 0x203d0
callq 0x11405
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10df6(%rip), %rsi     # 0x1fe60
movl $0xbc, %edi
callq 0x21b0
incl 0x10dee(%rip)           # 0x1fe68
jmp 0xefd1
leaq 0x4307(%rip), %rdi      # 0x1338d
leaq 0x3424(%rip), %rsi      # 0x124b1
leaq 0x4307(%rip), %rcx      # 0x1339b
movl $0x2935, %edx           # imm = 0x2935
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_tofile
int stb_compress_tofile(char *filename, char *input, unsigned int length)
{
   //int maxlen = length + 512 + (length >> 2); // total guess
   //char *buffer = (char *) malloc(maxlen);
   //int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
   
   stb__out = NULL;
   stb__outfile = fopen(filename, "wb");
   if (!stb__outfile) return 0;

   stb__outbytes = 0;

   if (!stb_compress_inner((stb_uchar*)input, length))
      return 0;

   fclose(stb__outfile);

   return stb__outbytes;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq $0x0, 0x10da6(%rip) # 0x1fe58
leaq 0x3746(%rip), %rsi      # 0x127ff
callq 0x22f0
movq %rax, 0x10d9b(%rip)     # 0x1fe60
xorl %ebx, %ebx
testq %rax, %rax
je 0xf0f6
movl $0x0, 0x10d92(%rip)     # 0x1fe68
movq %r14, %rdi
movl %ebp, %esi
callq 0xef37
testl %eax, %eax
je 0xf0f6
movq 0x10d75(%rip), %rdi     # 0x1fe60
callq 0x20d0
movl 0x10d72(%rip), %ebx     # 0x1fe68
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_intofile
int stb_compress_intofile(FILE *f, char *input, unsigned int length)
{
   //int maxlen = length + 512 + (length >> 2); // total guess
   //char *buffer = (char*)malloc(maxlen);
   //int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
   
   stb__out = NULL;
   stb__outfile = f;
   if (!stb__outfile) return 0;

   stb__outbytes = 0;

   if (!stb_compress_inner((stb_uchar*)input, length))
      return 0;

   return stb__outbytes;
}

// Assembly:
movq $0x0, 0x10d50(%rip) # 0x1fe58
movq %rdi, 0x10d51(%rip)     # 0x1fe60
testq %rdi, %rdi
je 0xf139
pushq %rax
movl $0x0, 0x10d49(%rip)     # 0x1fe68
movq %rsi, %rdi
movl %edx, %esi
callq 0xef37
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0xf138
movl 0x10d30(%rip), %eax     # 0x1fe68
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: outliterals
static void outliterals(stb_uchar *in, int numlit)
{
   while (numlit > 65536) {
      outliterals(in,65536);
      in     += 65536;
      numlit -= 65536;
   }

   if      (numlit ==     0)    ;
   else if (numlit <=    32)    stb_out (0x000020 + numlit-1);
   else if (numlit <=  2048)    stb_out2(0x000800 + numlit-1);
   else /*  numlit <= 65536) */ stb_out3(0x070000 + numlit-1);

   if (stb__out) {
      memcpy(stb__out,in,numlit);
      stb__out += numlit;
   } else
      fwrite(in, 1, numlit, stb__outfile);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x10001, %esi          # imm = 0x10001
jl 0xfb31
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0xfaf5
addq $0x10000, %rbx          # imm = 0x10000
leal -0x10000(%r14), %r15d
cmpl $0x20000, %r14d         # imm = 0x20000
movl %r15d, %r14d
ja 0xfb08
jmp 0xfb39
testl %r14d, %r14d
je 0xfb7c
movl %r14d, %r15d
cmpl $0x20, %r15d
jg 0xfb57
movq 0x10312(%rip), %r14     # 0x1fe58
leal 0x1f(%r15), %eax
testq %r14, %r14
je 0xfb81
movb %al, (%r14)
incq %r14
jmp 0xfba2
cmpl $0x800, %r15d           # imm = 0x800
ja 0xfb6e
leal 0x7ff(%r15), %edi
callq 0x113a3
jmp 0xfb96
leal 0x6ffff(%r15), %edi
callq 0x114b9
jmp 0xfb96
xorl %r15d, %r15d
jmp 0xfb96
movzbl %al, %edi
movq 0x102d5(%rip), %rsi     # 0x1fe60
callq 0x21b0
incl 0x102d2(%rip)           # 0x1fe68
movq 0x102bb(%rip), %r14     # 0x1fe58
testq %r14, %r14
je 0xfbc3
movslq %r15d, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2230
addq %r15, %r14
movq %r14, 0x1029b(%rip)     # 0x1fe58
popq %rbx
popq %r14
popq %r15
retq
movslq %r15d, %rdx
movq 0x10293(%rip), %rcx     # 0x1fe60
movl $0x1, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_stream_start
int stb_compress_stream_start(FILE *f)
{
   stb__out = NULL;
   stb__outfile = f;

   if (f == NULL)
      return 0;

   if (!stb_compress_streaming_start())
      return 0;

   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq $0x0, 0x10266(%rip) # 0x1fe58
movq %rdi, 0x10267(%rip)     # 0x1fe60
xorl %ebp, %ebp
testq %rdi, %rdi
je 0xfd3c
movq %rdi, %rbx
movslq 0xa622(%rip), %r15      # 0x1a230
leaq (%r15,%r15,2), %rdi
movl %edi, 0x10260(%rip)     # 0x1fe78
callq 0x2250
movq %rax, 0x1024c(%rip)     # 0x1fe70
testq %rax, %rax
je 0xfd3c
movq %rax, %r14
movl 0xa5fd(%rip), %r12d     # 0x1a234
leaq (,%r12,8), %rdi
callq 0x2250
movq %rax, 0x1024d(%rip)     # 0x1fe98
testq %rax, %rax
je 0xfcce
testq %r12, %r12
je 0xfc6e
xorl %eax, %eax
movq 0x1023a(%rip), %rcx     # 0x1fe98
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xfc57
decl %r12d
movl %r12d, 0x10228(%rip)    # 0x1fea0
movq $0x0, 0x101f9(%rip) # 0x1fe7c
movl %r15d, 0x101fa(%rip)    # 0x1fe84
movl %r15d, 0x101f7(%rip)    # 0x1fe88
xorl %eax, %eax
movl %eax, 0x101f3(%rip)     # 0x1fe8c
movl %eax, 0x101f5(%rip)     # 0x1fe94
movl $0x57, %edi
movq %rbx, %rsi
callq 0x21b0
incl 0x101b6(%rip)           # 0x1fe68
movq 0x1019f(%rip), %rax     # 0x1fe58
testq %rax, %rax
je 0xfcd8
leaq 0x1(%rax), %rcx
movq %rcx, 0x1018f(%rip)     # 0x1fe58
movb $-0x44, (%rax)
jmp 0xfcef
movq %r14, %rdi
callq 0x23c0
jmp 0xfd3c
movq 0x10181(%rip), %rsi     # 0x1fe60
movl $0xbc, %edi
callq 0x21b0
incl 0x10179(%rip)           # 0x1fe68
xorl %edi, %edi
callq 0x113a3
xorl %edi, %edi
callq 0x11405
movq 0x10154(%rip), %rax     # 0x1fe58
testq %rax, %rax
jne 0xfd15
movq 0x10150(%rip), %rdi     # 0x1fe60
callq 0x2200
movl %eax, 0x10175(%rip)     # 0x1fe90
xorl %edi, %edi
callq 0x11405
movl 0xa508(%rip), %edi      # 0x1a230
callq 0x11405
movl $0x1, 0x10699(%rip)     # 0x203d0
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq