LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_perfect_hash
int stb_perfect_hash(stb_perfect *p, unsigned int x)
{
   stb_uint m = x * p->multiplicand;
   stb_uint y = x >> 16;
   stb_uint bv = (m >> 24) + y;
   stb_uint av = (m + y) >> 12;
   if (p->table == NULL) return -1;  // uninitialized table fails
   bv &= p->b_mask;
   av &= p->table_mask;
   if (p->large_bmap)
      av ^= p->large_bmap[bv];
   else
      av ^= p->small_bmap[bv];
   return p->table[av] == x ? av : -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x10(%rsp), %rcx
imull 0x4(%rcx), %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x1c(%rsp)
movl -0x18(%rsp), %eax
shrl $0x18, %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x18(%rsp), %eax
addl -0x1c(%rsp), %eax
shrl $0xc, %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x881c
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x88ac
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movl 0x28(%rax), %eax
andl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8863
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x8879
movq -0x10(%rsp), %rax
movl -0x20(%rsp), %ecx
movzbl 0xc(%rax,%rcx), %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movl -0x24(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rsp), %eax
jne 0x8899
movl -0x24(%rsp), %eax
movl %eax, -0x28(%rsp)
jmp 0x88a4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x28(%rsp)
jmp 0x88a4
movl -0x28(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__perfect_prehash
static void stb__perfect_prehash(stb_perfect *p, stb_uint x, stb_uint16 *a, stb_uint16 *b)
{
   stb_uint m = x * p->multiplicand;
   stb_uint y = x >> 16;
   stb_uint bv = (m >> 24) + y;
   stb_uint av = (m + y) >> 12;
   bv &= p->b_mask;
   av &= p->table_mask;
   *b = bv;
   *a = av;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
imull 0x4(%rcx), %eax
movl %eax, -0x24(%rsp)
movl -0xc(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x28(%rsp)
movl -0x24(%rsp), %eax
shrl $0x18, %eax
addl -0x28(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x24(%rsp), %eax
addl -0x28(%rsp), %eax
shrl $0xc, %eax
movl %eax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl -0x2c(%rsp), %eax
movl %eax, -0x2c(%rsp)
movq -0x8(%rsp), %rax
movl 0x28(%rax), %eax
andl -0x30(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x2c(%rsp), %eax
movw %ax, %cx
movq -0x20(%rsp), %rax
movw %cx, (%rax)
movl -0x30(%rsp), %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, (%rax)
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_perfect_destroy
void stb_perfect_destroy(stb_perfect *p)
{
   if (p->large_bmap) free(p->large_bmap);
   if (p->table     ) free(p->table);
   p->large_bmap = NULL;
   p->table      = NULL;
   p->b_mask     = 0;
   p->table_mask = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x968d
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x23c0
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x96a5
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x23c0
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x28(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ptrmap_delete
void stb_ptrmap_delete(stb_ptrmap *e, void (*free_func)(void *))
{
   int i;
   if (free_func)
      for (i=0; i < e->limit; ++i)
         if (e->table[i].k != STB_EMPTY && e->table[i].k != STB_EDEL) {
            if (free_func == free)
               free(e->table[i].v); // allow STB_MALLOC_WRAPPER to operate
            else
               free_func(e->table[i].v);
         }
   stb_ptrmap_destroy(e);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xab12
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xab10
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x2, %ecx
cmpq %rcx, (%rax)
je 0xaafe
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x6, %ecx
cmpq %rcx, (%rax)
je 0xaafe
movq 0x1b509(%rip), %rax     # 0x25fc0
cmpq %rax, 0x8(%rsp)
jne 0xaadd
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x23c0
jmp 0xaafc
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x4(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdi
callq *%rax
jmp 0xaafe
jmp 0xab00
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xaa62
jmp 0xab12
movq 0x10(%rsp), %rdi
callq 0x9c60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_idict_remove_all
void stb_idict_remove_all(stb_idict *e)
{
   int n;
   for (n=0; n < e->limit; ++n)
      e->table[n].k = STB_IEMPTY;
   e->has_empty = e->has_del = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xb99d
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rsp), %rcx
movl $0x1, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xb96d
movq -0x8(%rsp), %rax
movb $0x0, 0x2e(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x2d(%rax)
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sparse_ptr_matrix_new
stb_spmatrix *stb_sparse_ptr_matrix_new(int val_size)
{
   stb_spmatrix *m = stb__spmatrix_create();
   if (m) m->val_size = val_size;
   if (m) m->arena = stb_malloc_global(1);
   return m;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
callq 0xba00
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xb9d5
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0xb9f3
movl $0x1, %edi
callq 0x72e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sparse_ptr_matrix_get
void *stb_sparse_ptr_matrix_get(stb_spmatrix *z, void *a, void *b, int create)
{
   stb__ptrpair t = { a,b };
   void *data = stb__spmatrix_get(z, t);
   if (!data && create) {
      data = stb_malloc_raw(z->arena, z->val_size);
      if (!data) return NULL;
      memset(data, 0, z->val_size);
      stb__spmatrix_add(z, t, data);
   }
   return data;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xbc40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xbc1e
cmpl $0x0, 0x24(%rsp)
je 0xbc1e
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rax
movslq (%rax), %rsi
callq 0x7640
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xbbf1
movq $0x0, 0x40(%rsp)
jmp 0xbc28
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq (%rax), %rdx
xorl %esi, %esi
callq 0x2160
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xbc90
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sdict_new
stb_sdict * stb_sdict_new(int use_arena)
{
   stb_sdict *d = stb_sdict_create();
   if (d == NULL) return NULL;
   d->arena = use_arena ? stb_malloc_global(1) : NULL;
   return d;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
callq 0xbe60
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xcec5
movq $0x0, 0x20(%rsp)
jmp 0xcefd
cmpl $0x0, 0x1c(%rsp)
je 0xcedd
movl $0x1, %edi
callq 0x72e0
movq %rax, 0x8(%rsp)
jmp 0xcee6
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xcee6
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sdict_copy
stb_sdict* stb_sdict_copy(stb_sdict *old)
{
   stb_sdict *n;
   void *old_arena = old->arena;
   void *new_arena = old_arena ? stb_malloc_global(1) : NULL;
   old->arena = new_arena;
   n = stb_sdictinternal_copy(old);
   old->arena = old_arena;
   if (n)
      n->arena = new_arena;
   else if (new_arena)
      stb_free(new_arena);
   return n;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xcf3e
movl $0x1, %edi
callq 0x72e0
movq %rax, (%rsp)
jmp 0xcf46
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xcf46
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0xcc60
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0xcf8f
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0xcfa3
cmpq $0x0, 0x8(%rsp)
je 0xcfa1
movq 0x8(%rsp), %rdi
callq 0x6e60
jmp 0xcfa3
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ftimestamp
time_t stb_ftimestamp(char *filename)
{
   struct stb__stat buf;
   if (stb__windows(
             _wstat((const wchar_t *)stb__from_utf8(filename), &buf),
               stat(filename,&buf)
          ) == 0)
   {
      return buf.st_mtime;
   } else {
      return 0;
   }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2220
cmpl $0x0, %eax
jne 0xd0d5
movq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0xd0e1
movq $0x0, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_filelen
size_t  stb_filelen(FILE *f)
{
   size_t len, pos;
   pos = ftell(f);
   fseek(f, 0, SEEK_END);
   len = ftell(f);
   fseek(f, pos, SEEK_SET);
   return len;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2200
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x22a0
movq 0x10(%rsp), %rdi
callq 0x2200
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x22a0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_file
void *stb_file(char *filename, size_t *length)
{
   FILE *f = stb__fopen(filename, "rb");
   char *buffer;
   size_t len, len2;
   if (!f) return NULL;
   len = stb_filelen(f);
   buffer = (char *) malloc(len+2); // nul + extra
   len2 = fread(buffer, 1, len, f);
   if (len2 == len) {
      if (length) *length = len;
      buffer[len] = 0;
   } else {
      free(buffer);
      buffer = NULL;
   }
   fclose(f);
   return buffer;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x1255a(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xd19a
movq $0x0, 0x30(%rsp)
jmp 0xd230
movq 0x18(%rsp), %rdi
callq 0xd100
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x2, %rdi
callq 0x2260
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x20b0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0xd209
cmpq $0x0, 0x20(%rsp)
je 0xd1f9
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xd21c
movq 0x10(%rsp), %rdi
callq 0x23c0
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20d0
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_filewrite
int stb_filewrite(char *filename, void *data, size_t length)
{
   FILE *f = stb_fopen(filename, "wb");
   if (f) {
      unsigned char *data_ptr = (unsigned char *) data;
      size_t remaining = length;
      while (remaining > 0) {
         size_t len2 = remaining > 65536 ? 65536 : remaining;
         size_t len3 = fwrite(data_ptr, 1, len2, f);
         if (len2 != len3) {
            fprintf(stderr, "Failed while writing %s\n", filename);
            break;
         }
         remaining -= len2;
         data_ptr += len2;
      }
      stb_fclose(f, stb_keep_if_different);
   }
   return f != NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x12478(%rip), %rsi     # 0x1f6d7
callq 0xd350
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xd33b
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0xd32c
cmpq $0x10000, 0x18(%rsp)    # imm = 0x10000
jbe 0xd2ab
movl $0x10000, %eax          # imm = 0x10000
movq %rax, (%rsp)
jmp 0xd2b4
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
movl $0x1, %esi
callq 0x2370
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0xd306
movq 0x18d0a(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
leaq 0x123dd(%rip), %rsi     # 0x1f6da
movb $0x0, %al
callq 0x21f0
jmp 0xd32c
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xd289
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0xd610
cmpq $0x0, 0x28(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x48, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fclose
int     stb_fclose(FILE *f, int keep)
{
   stb__file_data *d;

   int ok = STB_FALSE;
   if (f == NULL) return 0;

   if (ferror(f))
      keep = stb_keep_no;

   fclose(f);

   if (stb__files && stb_ptrmap_remove(stb__files, f, (void **) &d)) {
      if (stb__files->count == 0) {
         stb_ptrmap_destroy(stb__files);
         stb__files = NULL;
      }
   } else
      return STB_TRUE; // not special

   if (keep == stb_keep_if_different) {
      // check if the files are identical
      if (stb_feq(d->name, d->temp_name)) {
         keep = stb_keep_no;
         ok = STB_TRUE;  // report success if no change
      }
   }

   if (keep != stb_keep_no) {
      if (stb_fexists(d->name) && remove(d->name)) {
         // failed to delete old, so don't keep new
         keep = stb_keep_no;
      } else {
         if (!stb_rename(d->temp_name, d->name))
            ok = STB_TRUE;
         else
            keep=stb_keep_no;
      }
   }

   if (keep == stb_keep_no)
      remove(d->temp_name);

   free(d->temp_name);
   free(d->name);
   free(d);

   return ok;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xd63a
movl $0x0, 0x24(%rsp)
jmp 0xd790
movq 0x18(%rsp), %rdi
callq 0x2090
cmpl $0x0, %eax
je 0xd651
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20d0
cmpq $0x0, 0x1ca7d(%rip)     # 0x2a0e0
je 0xd6a6
movq 0x1ca74(%rip), %rdi     # 0x2a0e0
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xa4f0
cmpl $0x0, %eax
je 0xd6a6
movq 0x1ca59(%rip), %rax     # 0x2a0e0
cmpl $0x0, 0xc(%rax)
jne 0xd6a4
movq 0x1ca4c(%rip), %rdi     # 0x2a0e0
callq 0x9c60
movq $0x0, 0x1ca3c(%rip) # 0x2a0e0
jmp 0xd6b3
movl $0x1, 0x24(%rsp)
jmp 0xd790
cmpl $0x2, 0x14(%rsp)
jne 0xd6e7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xe140
cmpl $0x0, %eax
je 0xd6e5
movl $0x0, 0x14(%rsp)
movl $0x1, 0x4(%rsp)
jmp 0xd6e7
cmpl $0x0, 0x14(%rsp)
je 0xd74f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xd060
cmpl $0x0, %eax
je 0xd71e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2060
cmpl $0x0, %eax
je 0xd71e
movl $0x0, 0x14(%rsp)
jmp 0xd74d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2310
cmpl $0x0, %eax
jne 0xd743
movl $0x1, 0x4(%rsp)
jmp 0xd74b
movl $0x0, 0x14(%rsp)
jmp 0xd74d
jmp 0xd74f
cmpl $0x0, 0x14(%rsp)
jne 0xd763
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2060
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23c0
movq 0x8(%rsp), %rdi
callq 0x23c0
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_file_max
void *  stb_file_max(char *filename, size_t *length)
{
   FILE *f = stb__fopen(filename, "rb");
   char *buffer;
   size_t len, maxlen;
   if (!f) return NULL;
   maxlen = *length;
   buffer = (char *) malloc(maxlen+1);
   len = fread(buffer, 1, maxlen, f);
   buffer[len] = 0;
   fclose(f);
   *length = len;
   return buffer;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x11eca(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xd827
movq $0x0, 0x30(%rsp)
jmp 0xd891
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x2260
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x20b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rdi
callq 0x20d0
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_stringfile_trimmed
char ** stb_stringfile_trimmed(char *name, int *len, char comment)
{
   int i,n,o=0;
   char **s = stb_stringfile(name, &n);
   if (s == NULL) return NULL;
   for (i=0; i < n; ++i) {
      char *p = stb_skipwhite(s[i]);
      if (*p && *p != comment)
         s[o++] = p;
   }
   s[o] = NULL;
   if (len) *len = o;
   return s;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0xd8a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xdb66
movq $0x0, 0x30(%rsp)
jmp 0xdc06
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xdbd7
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5190
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xdbc8
movq (%rsp), %rax
movsbl (%rax), %eax
movsbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
je 0xdbc8
movq (%rsp), %rdx
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rsp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xdbca
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xdb6e
movq 0x8(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, 0x20(%rsp)
je 0xdbfc
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fgets
char * stb_fgets(char *buffer, int buflen, FILE *f)
{
   char *p;
   buffer[0] = 0;
   p = fgets(buffer, buflen, f);
   if (p) {
      int n = strlen(p)-1;
      if (n >= 0)
         if (p[n] == '\n')
            p[n] = 0;
   }
   return p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x21d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdc88
movq 0x8(%rsp), %rdi
callq 0x2100
subq $0x1, %rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0xdc86
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xdc84
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xdc86
jmp 0xdc88
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fgets_malloc
char * stb_fgets_malloc(FILE *f)
{
   // avoid reallocing for small strings
   char quick_buffer[800];
   quick_buffer[sizeof(quick_buffer)-2] = 0;
   if (!fgets(quick_buffer, sizeof(quick_buffer), f))
      return NULL;

   if (quick_buffer[sizeof(quick_buffer)-2] == 0) {
      int n = strlen(quick_buffer);
      if (n > 0 && quick_buffer[n-1] == '\n')
         quick_buffer[n-1] = 0;
      return strdup(quick_buffer);
   } else {
      char *p;
      char *a = strdup(quick_buffer);
      int len = sizeof(quick_buffer)-1;

      while (!feof(f)) {
         if (a[len-1] == '\n') break;
         a = (char *) realloc(a, len*2);
         p = &a[len];
         p[len-2] = 0;
         if (!fgets(p, len, f))
            break;
         if (p[len-2] == 0) {
            len += strlen(p);
            break;
         }
         len = len + (len-1);
      }
      if (a[len-1] == '\n')
         a[len-1] = 0;
      return a;
   }
}

// Assembly:
subq $0x358, %rsp            # imm = 0x358
movq %rdi, 0x348(%rsp)
movb $0x0, 0x33e(%rsp)
leaq 0x20(%rsp), %rdi
movq 0x348(%rsp), %rdx
movl $0x320, %esi            # imm = 0x320
callq 0x21d0
cmpq $0x0, %rax
jne 0xdce5
movq $0x0, 0x350(%rsp)
jmp 0xde6d
movsbl 0x33e(%rsp), %eax
cmpl $0x0, %eax
jne 0xdd3f
leaq 0x20(%rsp), %rdi
callq 0x2100
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0xdd28
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
movsbl 0x20(%rsp,%rax), %eax
cmpl $0xa, %eax
jne 0xdd28
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
movb $0x0, 0x20(%rsp,%rax)
leaq 0x20(%rsp), %rdi
callq 0x2390
movq %rax, 0x350(%rsp)
jmp 0xde6d
leaq 0x20(%rsp), %rdi
callq 0x2390
movq %rax, 0x8(%rsp)
movl $0x31f, 0x4(%rsp)       # imm = 0x31F
movq 0x348(%rsp), %rdi
callq 0x2210
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdd74
jmp 0xde35
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xdd91
jmp 0xde35
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %eax
shll %eax
movslq %eax, %rsi
callq 0x22b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x348(%rsp), %rdx
callq 0x21d0
cmpq $0x0, %rax
jne 0xddec
jmp 0xde35
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xde1f
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movslq 0x4(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x4(%rsp)
jmp 0xde35
movl 0x4(%rsp), %eax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
addl %ecx, %eax
movl %eax, 0x4(%rsp)
jmp 0xdd56
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xde60
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x350(%rsp)
movq 0x350(%rsp), %rax
addq $0x358, %rsp            # imm = 0x358
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fullpath
int stb_fullpath(char *abs, int abs_size, char *rel)
{
   #ifdef _MSC_VER
   return _fullpath(abs, rel, abs_size) != NULL;
   #else
   if (rel[0] == '/' || rel[0] == '~') {
      if ((int) strlen(rel) >= abs_size)
         return 0;
      strcpy(abs,rel);
      return STB_TRUE;
   } else {
      int n;
      getcwd(abs, abs_size);
      n = strlen(abs);
      if (n+(int) strlen(rel)+2 <= abs_size) {
         abs[n] = '/';
         strcpy(abs+n+1, rel);
         return STB_TRUE;
      } else {
         return STB_FALSE;
      }
   }
   #endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xdeac
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0xdee2
movq 0x8(%rsp), %rdi
callq 0x2100
cmpl 0x14(%rsp), %eax
jl 0xdec9
movl $0x0, 0x24(%rsp)
jmp 0xdf5c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2070
movl $0x1, 0x24(%rsp)
jmp 0xdf5c
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x2170
movq 0x18(%rsp), %rdi
callq 0x2100
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movl (%rsp), %eax
addl %ecx, %eax
addl $0x2, %eax
cmpl 0x14(%rsp), %eax
jg 0xdf54
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x2f, (%rax,%rcx)
movq 0x18(%rsp), %rdi
movslq 0x4(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
callq 0x2070
movl $0x1, 0x24(%rsp)
jmp 0xdf5c
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fcmp
int stb_fcmp(char *s1, char *s2)
{
   FILE *f = stb__fopen(s1, "rb");
   FILE *g = stb__fopen(s2, "rb");

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

   return stb_fcmp_core(f,g);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x1174a(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x11734(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdfb8
cmpq $0x0, (%rsp)
jne 0xdff8
cmpq $0x0, 0x8(%rsp)
je 0xdfca
movq 0x8(%rsp), %rdi
callq 0x20d0
cmpq $0x0, (%rsp)
je 0xdfe4
movq (%rsp), %rdi
callq 0x20d0
movl $0x1, 0x24(%rsp)
jmp 0xe00a
cmpq $0x0, 0x8(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xe00a
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xe020
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fcmp_core
static int stb_fcmp_core(FILE *f, FILE *g)
{
   char buf1[1024],buf2[1024];
   int n1,n2, res=0;

   while (1) {
      n1 = fread(buf1, 1, sizeof(buf1), f);
      n2 = fread(buf2, 1, sizeof(buf2), g);
      res = memcmp(buf1,buf2,stb_min(n1,n2));
      if (res)
         break;
      if (n1 != n2) {
         res = n1 < n2 ? -1 : 1;
         break;
      }
      if (n1 == 0)
         break;
   }

   fclose(f);
   fclose(g);
   return res;
}

// Assembly:
subq $0x848, %rsp            # imm = 0x848
movq %rdi, 0x840(%rsp)
movq %rsi, 0x838(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x430(%rsp), %rdi
movq 0x840(%rsp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x20b0
movl %eax, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
movq 0x838(%rsp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x20b0
movl %eax, 0x28(%rsp)
leaq 0x430(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0xe0ad
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xe0b5
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movslq %eax, %rdx
callq 0x21c0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0xe0d8
jmp 0xe10d
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0xe0ff
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, 0x24(%rsp)
jmp 0xe10d
cmpl $0x0, 0x2c(%rsp)
jne 0xe108
jmp 0xe10d
jmp 0xe03f
movq 0x840(%rsp), %rdi
callq 0x20d0
movq 0x838(%rsp), %rdi
callq 0x20d0
movl 0x24(%rsp), %eax
addq $0x848, %rsp            # imm = 0x848
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_feq
int stb_feq(char *s1, char *s2)
{
   FILE *f = stb__fopen(s1, "rb");
   FILE *g = stb__fopen(s2, "rb");

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

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

   return !stb_fcmp_core(f,g);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x1157a(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x11564(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xe18a
cmpq $0x0, 0x10(%rsp)
jne 0xe1c6
cmpq $0x0, 0x18(%rsp)
je 0xe19c
movq 0x18(%rsp), %rdi
callq 0x20d0
cmpq $0x0, 0x10(%rsp)
je 0xe1ae
movq 0x10(%rsp), %rdi
callq 0x20d0
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xe22a
movq 0x18(%rsp), %rdi
callq 0xd100
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd100
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xe20a
movq 0x18(%rsp), %rdi
callq 0x20d0
movq 0x10(%rsp), %rdi
callq 0x20d0
movl $0x0, 0x34(%rsp)
jmp 0xe22a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe020
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_copyfile
int stb_copyfile(char *src, char *dest)
{
   char raw_buffer[1024];
   char *buffer;
   int buf_size = 65536;

   FILE *f, *g;

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

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

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

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

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

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

   fclose(g);
   return STB_TRUE;
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rdi, 0x438(%rsp)
movq %rsi, 0x430(%rsp)
movl $0x10000, 0x24(%rsp)    # imm = 0x10000
movq 0x438(%rsp), %rdi
movq 0x430(%rsp), %rsi
callq 0xe140
cmpl $0x0, %eax
je 0xe289
movl $0x1, 0x444(%rsp)
jmp 0xe3af
movq 0x438(%rsp), %rdi
leaq 0x1143c(%rip), %rsi     # 0x1f6d4
callq 0x22f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xe2ba
movl $0x0, 0x444(%rsp)
jmp 0xe3af
movq 0x430(%rsp), %rdi
leaq 0x1140e(%rip), %rsi     # 0x1f6d7
callq 0x22f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xe2f5
movq 0x18(%rsp), %rdi
callq 0x20d0
movl $0x0, 0x444(%rsp)
jmp 0xe3af
movslq 0x24(%rsp), %rdi
callq 0x2260
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xe31e
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x400, 0x24(%rsp)      # imm = 0x400
jmp 0xe320
movq 0x18(%rsp), %rdi
callq 0x2210
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe338
jmp 0xe377
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x20b0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xe375
movq 0x28(%rsp), %rdi
movslq 0xc(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x2370
jmp 0xe320
movq 0x18(%rsp), %rdi
callq 0x20d0
movq 0x28(%rsp), %rax
leaq 0x30(%rsp), %rcx
cmpq %rcx, %rax
je 0xe39a
movq 0x28(%rsp), %rdi
callq 0x23c0
movq 0x10(%rsp), %rdi
callq 0x20d0
movl $0x1, 0x444(%rsp)
movl 0x444(%rsp), %eax
addq $0x448, %rsp            # imm = 0x448
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_varlenu
int stb_size_varlenu(unsigned int v)
{
   if (v < 0x00000080) return 1;
   if (v < 0x00004000) return 2;
   if (v < 0x00200000) return 3;
   if (v < 0x10000000) return 4;
   return 5;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x80, -0x8(%rsp)
jae 0xe408
movl $0x1, -0x4(%rsp)
jmp 0xe44c
cmpl $0x4000, -0x8(%rsp)     # imm = 0x4000
jae 0xe41c
movl $0x2, -0x4(%rsp)
jmp 0xe44c
cmpl $0x200000, -0x8(%rsp)   # imm = 0x200000
jae 0xe430
movl $0x3, -0x4(%rsp)
jmp 0xe44c
cmpl $0x10000000, -0x8(%rsp) # imm = 0x10000000
jae 0xe444
movl $0x4, -0x4(%rsp)
jmp 0xe44c
movl $0x5, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fput_varlenu
void    stb_fput_varlenu(FILE *f, unsigned int z)
{
   if (z >= 0x10000000) fputc(0xF0,f);
   if (z >= 0x00200000) fputc((z < 0x10000000 ? 0xE0 : 0)+(z>>24),f);
   if (z >= 0x00004000) fputc((z < 0x00200000 ? 0xC0 : 0)+(z>>16),f);
   if (z >= 0x00000080) fputc((z < 0x00004000 ? 0x80 : 0)+(z>> 8),f);
   fputc(z,f);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x10000000, 0xc(%rsp)  # imm = 0x10000000
jb 0xe4d6
movq 0x10(%rsp), %rsi
movl $0xf0, %edi
callq 0x21b0
cmpl $0x200000, 0xc(%rsp)    # imm = 0x200000
jb 0xe507
movl 0xc(%rsp), %ecx
xorl %edi, %edi
movl $0xe0, %eax
cmpl $0x10000000, %ecx       # imm = 0x10000000
cmovbl %eax, %edi
movl 0xc(%rsp), %eax
shrl $0x18, %eax
addl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
cmpl $0x4000, 0xc(%rsp)      # imm = 0x4000
jb 0xe538
movl 0xc(%rsp), %ecx
xorl %edi, %edi
movl $0xc0, %eax
cmpl $0x200000, %ecx         # imm = 0x200000
cmovbl %eax, %edi
movl 0xc(%rsp), %eax
shrl $0x10, %eax
addl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
cmpl $0x80, 0xc(%rsp)
jb 0xe569
movl 0xc(%rsp), %ecx
xorl %edi, %edi
movl $0x80, %eax
cmpl $0x4000, %ecx           # imm = 0x4000
cmovbl %eax, %edi
movl 0xc(%rsp), %eax
shrl $0x8, %eax
addl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_varlenu
unsigned int stb_fget_varlenu(FILE *f)
{
   unsigned int z;
   unsigned char d;
   d = stb_fgetc(f);

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movb %al, 0xb(%rsp)
movzbl 0xb(%rsp), %eax
cmpl $0x80, %eax
jl 0xe6b3
movzbl 0xb(%rsp), %eax
cmpl $0xc0, %eax
jl 0xe68b
movzbl 0xb(%rsp), %eax
cmpl $0xe0, %eax
jl 0xe660
movzbl 0xb(%rsp), %eax
cmpl $0xf0, %eax
jne 0xe635
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
shll $0x18, %eax
movl %eax, 0xc(%rsp)
jmp 0xe646
movzbl 0xb(%rsp), %eax
subl $0xe0, %eax
shll $0x18, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
shll $0x10, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xe671
movzbl 0xb(%rsp), %eax
subl $0xc0, %eax
shll $0x10, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
shll $0x8, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xe69c
movzbl 0xb(%rsp), %eax
subl $0x80, %eax
shll $0x8, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xe6bc
movzbl 0xb(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_varlen64
int stb_size_varlen64(stb_uint64 v)
{
   if (v < 0x00000080) return 1;
   if (v < 0x00004000) return 2;
   if (v < 0x00200000) return 3;
   if (v < 0x10000000) return 4;
   if (v < STB_IMM_UINT64(0x0000000800000000)) return 5;
   if (v < STB_IMM_UINT64(0x0000040000000000)) return 6;
   if (v < STB_IMM_UINT64(0x0002000000000000)) return 7;
   if (v < STB_IMM_UINT64(0x0100000000000000)) return 8; 
   return 9;
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x80, -0x10(%rsp)
jae 0xe93d
movl $0x1, -0x4(%rsp)
jmp 0xe9f6
cmpq $0x4000, -0x10(%rsp)    # imm = 0x4000
jae 0xe955
movl $0x2, -0x4(%rsp)
jmp 0xe9f6
cmpq $0x200000, -0x10(%rsp)  # imm = 0x200000
jae 0xe96d
movl $0x3, -0x4(%rsp)
jmp 0xe9f6
cmpq $0x10000000, -0x10(%rsp) # imm = 0x10000000
jae 0xe982
movl $0x4, -0x4(%rsp)
jmp 0xe9f6
movabsq $0x800000000, %rax      # imm = 0x800000000
cmpq %rax, -0x10(%rsp)
jae 0xe99d
movl $0x5, -0x4(%rsp)
jmp 0xe9f6
movabsq $0x40000000000, %rax    # imm = 0x40000000000
cmpq %rax, -0x10(%rsp)
jae 0xe9b8
movl $0x6, -0x4(%rsp)
jmp 0xe9f6
movabsq $0x2000000000000, %rax  # imm = 0x2000000000000
cmpq %rax, -0x10(%rsp)
jae 0xe9d3
movl $0x7, -0x4(%rsp)
jmp 0xe9f6
movabsq $0x100000000000000, %rax # imm = 0x100000000000000
cmpq %rax, -0x10(%rsp)
jae 0xe9ee
movl $0x8, -0x4(%rsp)
jmp 0xe9f6
movl $0x9, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fput_ranged
void    stb_fput_ranged(FILE *f, int v, int b, stb_uint n)
{
   v -= b;
   if (n <= (1 << 31))
      assert((stb_uint) v < n);
   if (n > (1 << 24)) fputc(v >> 24, f);
   if (n > (1 << 16)) fputc(v >> 16, f);
   if (n > (1 <<  8)) fputc(v >>  8, f);
   fputc(v,f);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
cmpl $0x80000000, 0x4(%rsp)  # imm = 0x80000000
ja 0xec9a
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0xec79
jmp 0xec98
leaq 0x10a9e(%rip), %rdi     # 0x1f71e
leaq 0x10702(%rip), %rsi     # 0x1f389
movl $0x166d, %edx           # imm = 0x166D
leaq 0x10a9c(%rip), %rcx     # 0x1f72f
callq 0x2140
jmp 0xec9a
cmpl $0x1000000, 0x4(%rsp)   # imm = 0x1000000
jbe 0xecb5
movl 0xc(%rsp), %edi
sarl $0x18, %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
cmpl $0x10000, 0x4(%rsp)     # imm = 0x10000
jbe 0xecd0
movl 0xc(%rsp), %edi
sarl $0x10, %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
cmpl $0x100, 0x4(%rsp)       # imm = 0x100
jbe 0xeceb
movl 0xc(%rsp), %edi
sarl $0x8, %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x21b0
addq $0x18, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_ranged
int     stb_fget_ranged(FILE *f, int b, stb_uint n)
{
   unsigned int v=0;
   if (n > (1 << 24)) v += stb_fgetc(f) << 24;
   if (n > (1 << 16)) v += stb_fgetc(f) << 16;
   if (n > (1 <<  8)) v += stb_fgetc(f) <<  8;
   v += stb_fgetc(f);
   return b+v;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x1000000, 0x8(%rsp)   # imm = 0x1000000
jbe 0xed3b
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
shll $0x18, %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x10000, 0x8(%rsp)     # imm = 0x10000
jbe 0xed5d
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
shll $0x10, %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
cmpl $0x100, 0x8(%rsp)       # imm = 0x100
jbe 0xed7f
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
shll $0x8, %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movzbl %al, %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
addl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_size_ranged
int     stb_size_ranged(int b, stb_uint n)
{
   if (n > (1 << 24)) return 4;
   if (n > (1 << 16)) return 3;
   if (n > (1 <<  8)) return 2;
   return 1;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
cmpl $0x1000000, -0xc(%rsp)  # imm = 0x1000000
jbe 0xedcc
movl $0x4, -0x4(%rsp)
jmp 0xedfc
cmpl $0x10000, -0xc(%rsp)    # imm = 0x10000
jbe 0xede0
movl $0x3, -0x4(%rsp)
jmp 0xedfc
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jbe 0xedf4
movl $0x2, -0x4(%rsp)
jmp 0xedfc
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fget_string
char *stb_fget_string(FILE *f, void *p)
{
   char *s;
   int len = stb_fget_varlenu(f);
   if (len > 4096) return NULL;
   s = p ? stb_malloc_string(p, len+1) : (char *) malloc(len+1);
   fread(s, 1, len, f);
   s[len] = 0;
   return s;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe5d0
movl %eax, 0x14(%rsp)
cmpl $0x1000, 0x14(%rsp)     # imm = 0x1000
jle 0xee91
movq $0x0, 0x30(%rsp)
jmp 0xef03
cmpq $0x0, 0x20(%rsp)
je 0xeeb4
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x7670
movq %rax, 0x8(%rsp)
jmp 0xeec8
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2260
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x28(%rsp), %rcx
movl $0x1, %esi
callq 0x20b0
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strdup
char *stb_strdup(char *str, void *pool)
{
   int len = strlen(str);
   char *p = stb_malloc_string(pool, len+1);
   strcpy(p, str);
   return p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2100
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x7670
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2070
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strip_final_slash
char *stb_strip_final_slash(char *t)
{
   if (t[0]) {
      char *z = t + strlen(t) - 1;
      // *z is the last character
      if (*z == '\\' || *z == '/')
         if (z != t+2 || t[1] != ':') // but don't strip it if it's e.g. "c:/"
            *z = 0;
      if (*z == '\\')
         *z = '/'; // canonicalize to make sure it matches db
   }
   return t;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xeff9
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0xefb7
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xefe2
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0xefd8
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
je 0xefe0
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0xefe2
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xeff7
movq 0x8(%rsp), %rax
movb $0x2f, (%rax)
jmp 0xeff9
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strip_final_slash_regardless
char *stb_strip_final_slash_regardless(char *t)
{
   if (t[0]) {
      char *z = t + strlen(t) - 1;
      // *z is the last character
      if (*z == '\\' || *z == '/')
         *z = 0;
      if (*z == '\\')
         *z = '/'; // canonicalize to make sure it matches db
   }
   return t;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf082
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0xf063
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xf06b
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xf080
movq 0x8(%rsp), %rax
movb $0x2f, (%rax)
jmp 0xf082
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_getopt_free
void   stb_getopt_free(char **opts)
{
   int i;
   char ** o2 = opts;
   for (i=0; i < stb_arr_len(o2); ++i)
      free(o2[i]);
   stb_arr_free(o2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xf0c9
movq 0x10(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0xf0d1
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0xf0d1
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
cmpl %ecx, %eax
jge 0xf0fd
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23c0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xf0ab
leaq 0x10(%rsp), %rdi
callq 0x7d20
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_readdir_free
void stb_readdir_free(char **files)
{
   char **f2 = files;
   int i;
   for (i=0; i < stb_arr_len(f2); ++i)
      free(f2[i]);
   stb_arr_free(f2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xf5f9
movq 0x18(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0xf601
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0xf601
movl 0x10(%rsp), %eax
movl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0xf62d
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23c0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xf5db
leaq 0x18(%rsp), %rdi
callq 0x7d20
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_delete_directory_recursive
void stb_delete_directory_recursive(char *dir)
{
   char **list = stb_readdir_subdirs(dir);
   int i;
   for (i=0; i < stb_arr_len(list); ++i)
      stb_delete_directory_recursive(list[i]);
   stb_arr_free(list);
   list = stb_readdir_files(dir);
   for (i=0; i < stb_arr_len(list); ++i)
      if (!remove(list[i])) {
         // on windows, try again after making it writeable; don't ALWAYS
         // do this first since that would be slow in the normal case
         #ifdef _MSC_VER
         _chmod(list[i], _S_IWRITE);
         remove(list[i]);
         #endif
      }
   stb_arr_free(list);
   stb__windows(_rmdir,rmdir)(dir);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xfa60
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xfe8e
movq 0x18(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0xfe96
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0xfe96
movl 0x10(%rsp), %eax
movl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0xfec2
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xfe50
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xfe70
leaq 0x18(%rsp), %rdi
callq 0x7d20
movq 0x20(%rsp), %rdi
callq 0xf640
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xff01
movq 0x18(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0xff09
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0xff09
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
cmpl %ecx, %eax
jge 0xff3e
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2060
cmpl $0x0, %eax
jne 0xff2f
jmp 0xff2f
jmp 0xff31
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xfee3
leaq 0x18(%rsp), %rdi
callq 0x7d20
movq 0x20(%rsp), %rdi
callq 0x20f0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_dir_is_prefix
int stb_dir_is_prefix(char *dir, int dirlen, char *file)
{
   if (dirlen == 0) return STB_TRUE;
   if (stb_strnicmp(dir, file, dirlen)) return STB_FALSE;
   if (file[dirlen] == '/' || file[dirlen] == '\\') return STB_TRUE;
   return STB_FALSE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xff83
movl $0x1, 0x24(%rsp)
jmp 0xffde
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x2270
cmpl $0x0, %eax
je 0xffa6
movl $0x0, 0x24(%rsp)
jmp 0xffde
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0xffcc
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xffd6
movl $0x1, 0x24(%rsp)
jmp 0xffde
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)