LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_crc32_block
stb_uint stb_crc32_block(stb_uint crc, unsigned char *buffer, stb_uint len)
{
   static stb_uint crc_table[256];
   stb_uint i,j,s;
   crc = ~crc;

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

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x4(%rsp), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rsp)
cmpl $0x0, 0x197d5(%rip)     # 0x2a0f4
jne 0x1099a
movl $0x0, -0x18(%rsp)
cmpl $0x100, -0x18(%rsp)     # imm = 0x100
jae 0x10998
movl -0x18(%rsp), %eax
movl %eax, -0x20(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x8, -0x1c(%rsp)
jae 0x10977
movl -0x20(%rsp), %eax
shrl %eax
movl -0x20(%rsp), %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0xedb88320, %edx       # imm = 0xEDB88320
cmpl $0x0, %esi
cmovnel %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x10943
movl -0x20(%rsp), %edx
movl -0x18(%rsp), %eax
movl %eax, %ecx
leaq 0x19768(%rip), %rax     # 0x2a0f0
movl %edx, (%rax,%rcx,4)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x10929
jmp 0x1099a
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jae 0x109eb
movl -0x4(%rsp), %eax
shrl $0x8, %eax
movq -0x10(%rsp), %rcx
movl -0x18(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
movl -0x4(%rsp), %edx
andl $0xff, %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x19719(%rip), %rcx     # 0x2a0f0
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x4(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x109a2
movl -0x4(%rsp), %eax
xorl $-0x1, %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_sha1_readable
void stb_sha1_readable(char display[27], unsigned char sha[20])
{
   char encoding[65] = "0123456789abcdefghijklmnopqrstuv"
                       "wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ%$";
   int num_bits = 0, acc=0;
   int i=0,o=0;
   while (o < 26) {
      int v;
      // expand the accumulator
      if (num_bits < 6) {
         assert(i != 20);
         acc += sha[i++] << num_bits;
         num_bits += 8;
      }
      v = acc & ((1 << 6) - 1);
      display[o++] = encoding[v];
      acc >>= 6;
      num_bits -= 6;
   }
   assert(num_bits == 20*8 - 26*6);
   display[o++] = encoding[acc];   
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0xef36(%rip), %rsi      # 0x20490
movl $0x41, %edx
callq 0x2230
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x1a, 0x10(%rsp)
jge 0x11637
cmpl $0x6, 0x1c(%rsp)
jge 0x115f0
cmpl $0x14, 0x14(%rsp)
je 0x1159f
jmp 0x115be
leaq 0xe299(%rip), %rdi      # 0x1f83f
leaq 0xdddc(%rip), %rsi      # 0x1f389
movl $0x1943, %edx           # imm = 0x1943
leaq 0xe28e(%rip), %rcx      # 0x1f847
callq 0x2140
movq 0x68(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x14(%rsp)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl 0x1c(%rsp), %ecx
shll %cl, %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
andl $0x3f, %eax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movb 0x20(%rsp,%rax), %dl
movq 0x70(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x18(%rsp), %eax
sarl $0x6, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
subl $0x6, %eax
movl %eax, 0x1c(%rsp)
jmp 0x11584
cmpl $0x4, 0x1c(%rsp)
jne 0x11640
jmp 0x1165f
leaq 0xe230(%rip), %rdi      # 0x1f877
leaq 0xdd3b(%rip), %rsi      # 0x1f389
movl $0x194c, %edx           # imm = 0x194C
leaq 0xe1ed(%rip), %rcx      # 0x1f847
callq 0x2140
movslq 0x18(%rsp), %rax
movb 0x20(%rsp,%rax), %dl
movq 0x70(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_close
void stb_cfg_close(stb_cfg *z)
{
   if (z->f) {
      int i;
      // write the file out
      fwrite(stb__cfg_sig, 12, 1, z->f);
      for (i=0; i < stb_arr_len(z->data); ++i) {
         stb_int16 n = strlen(z->data[i].key)+1;
         fwrite(&n, 2, 1, z->f);
         fwrite(z->data[i].key, n, 1, z->f);
         fwrite(&z->data[i].value_len, 4, 1, z->f);
         fwrite(z->data[i].value, z->data[i].value_len, 1, z->f);
      }
      fclose(z->f);
   }
   stb_arr_free(z->data);
   stb_free(z);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x11b8c
movq 0x14948(%rip), %rdi     # 0x26378
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0xc, %esi
movl $0x1, %edx
callq 0x2370
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x11a73
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl -0x10(%rax), %eax
movl %eax, (%rsp)
jmp 0x11a7a
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x11a7a
movl 0x4(%rsp), %eax
movl (%rsp), %ecx
cmpl %ecx, %eax
jge 0x11b7e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2100
addq $0x1, %rax
movw %ax, 0xa(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0xa(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x2370
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movswq 0xa(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edx
callq 0x2370
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2370
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edx
callq 0x2370
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11a50
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x20d0
movq 0x10(%rsp), %rdi
callq 0x7d20
movq 0x10(%rsp), %rdi
callq 0x6e60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_read
int stb_cfg_read(stb_cfg *z, char *key, void *value, int len)
{
   int i;
   for (i=0; i < stb_arr_len(z->data); ++i) {
      if (!stb_stricmp(z->data[i].key, key)) {
         int n = stb_min(len, z->data[i].value_len);
         memcpy(value, z->data[i].value, n);
         if (n < len)
            *((char *) value + n) = 0;
         return 1;
      }
   }
   return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x11bf3
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x11bfb
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x11bfb
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x11cd7
movq 0x28(%rsp), %rax
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x11cc5
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x10(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jge 0x11c5b
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
jmp 0x11c75
movq 0x28(%rsp), %rax
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movslq 0xc(%rsp), %rdx
callq 0x2230
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x11cbb
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, 0x34(%rsp)
jmp 0x11cdf
jmp 0x11cc7
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11bcf
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_cfg_delete
int stb_cfg_delete(stb_cfg *z, char *key)
{
   int i;
   for (i=0; i < stb_arr_len(z->data); ++i)
      if (!stb_stricmp(z->data[i].key, key)) {   
         stb_arr_fastdelete(z->data, i);
         return 1;
      }
   return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x11f7a
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x11f82
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x11f82
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x12022
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x12010
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl -0x10(%rax), %eax
subl $0x1, %eax
cltq
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl $0x18, %edx
callq 0x39c0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl -0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rax)
movl $0x1, 0x24(%rsp)
jmp 0x1202a
jmp 0x12012
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11f56
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__hashfind
static int stb__hashfind(void *p)
{
   stb_uint32 h = stb_hashptr(p);
   int s,n = h & stb__alloc_mask;
   if (stb__allocations[n].p == p)
      return n;
   s = stb_rehash(h)|1;
   for(;;) {
      if (stb__allocations[n].p == NULL)
         return -1;
      n = (n+s) & stb__alloc_mask;
      if (stb__allocations[n].p == p)
         return n;
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8340
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
andl 0x1a3b7(%rip), %eax     # 0x2c538
movl %eax, 0xc(%rsp)
movq 0x18564(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x121ac
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x12227
movl 0x14(%rsp), %eax
movl 0x14(%rsp), %ecx
shrl $0x6, %ecx
addl %ecx, %eax
movl 0x14(%rsp), %ecx
shrl $0x13, %ecx
addl %ecx, %eax
orl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x18520(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x121ec
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x12227
movl 0xc(%rsp), %eax
addl 0x10(%rsp), %eax
andl 0x1a33e(%rip), %eax     # 0x2c538
movl %eax, 0xc(%rsp)
movq 0x184eb(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x12225
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x12227
jmp 0x121c9
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_alloc
static void stb__add_alloc(void *p, int sz, char *file, int line)
{
   stb_uint32 h;
   int n;
   if (stb__alloc_count >= stb__alloc_limit)
      stb__grow_alloc();
   h = stb_hashptr(p);
   n = h & stb__alloc_mask;
   if (stb__allocations[n].p > STB_DEL) {
      int s = stb_rehash(h)|1;
      do {
         n = (n+s) & stb__alloc_mask;
      } while (stb__allocations[n].p > STB_DEL);
   }
   assert(stb__allocations[n].p == NULL || stb__allocations[n].p == STB_DEL);
   stb__allocations[n].p = p;
   stb__allocations[n].size = sz;
   stb__allocations[n].line = line;
   stb__allocations[n].file = file;
   ++stb__alloc_count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0x19f94(%rip), %eax     # 0x2c220
cmpl 0x1a2aa(%rip), %eax     # 0x2c53c
jl 0x12299
callq 0x1d6d0
movq 0x20(%rsp), %rdi
callq 0x8340
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
andl 0x1a287(%rip), %eax     # 0x2c538
movl %eax, 0x4(%rsp)
movq 0x18434(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, %ecx
cmpq %rcx, (%rax)
jbe 0x1231e
movl 0x8(%rsp), %eax
movl 0x8(%rsp), %ecx
shrl $0x6, %ecx
addl %ecx, %eax
movl 0x8(%rsp), %ecx
shrl $0x13, %ecx
addl %ecx, %eax
orl $0x1, %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
addl (%rsp), %eax
andl 0x1a23d(%rip), %eax     # 0x2c538
movl %eax, 0x4(%rsp)
movq 0x183ea(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, %ecx
cmpq %rcx, (%rax)
ja 0x122ee
jmp 0x1231e
movq 0x183cb(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x12354
movq 0x183b2(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, %ecx
cmpq %rcx, (%rax)
jne 0x12356
jmp 0x12375
leaq 0xdc42(%rip), %rdi      # 0x1ff9f
leaq 0xd025(%rip), %rsi      # 0x1f389
movl $0x1cb1, %edx           # imm = 0x1CB1
leaq 0xdc71(%rip), %rcx      # 0x1ffe1
callq 0x2140
movq 0x20(%rsp), %rcx
movq 0x1836f(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x18355(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl 0xc(%rsp), %ecx
movq 0x1833b(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x18320(%rip), %rax     # 0x2a6f0
movslq 0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x19e3a(%rip), %eax     # 0x2c220
addl $0x1, %eax
movl %eax, 0x19e31(%rip)     # 0x2c220
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_free
void stb_wrapper_free(void *p, char *file, int line)
{
   int n;
   
   if (p == NULL) return;

   n = stb__hashfind(p);

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1241c
jmp 0x1246e
movq 0x10(%rsp), %rdi
callq 0x12160
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jl 0x12442
movl (%rsp), %edi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x12480
jmp 0x1246e
movq 0x10(%rsp), %rdi
callq 0x12550
movl %eax, (%rsp)
leaq 0xd258(%rip), %rdi      # 0x1f6ae
leaq 0xcf2c(%rip), %rsi      # 0x1f389
movl $0x1cd7, %edx           # imm = 0x1CD7
leaq 0xd47d(%rip), %rcx      # 0x1f8e6
callq 0x2140
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__remove_alloc
static void stb__remove_alloc(int n, char *file, int line)
{
   stb__alloc_history[stb__history_pos] = stb__allocations[n];
   stb__alloc_history[stb__history_pos].file = file;
   stb__alloc_history[stb__history_pos].line = line;
   if (++stb__history_pos == STB_MALLOC_HISTORY_COUNT)
      stb__history_pos = 0;
   stb__allocations[n].p = STB_DEL;
   --stb__alloc_count;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movslq 0x19d90(%rip), %rcx     # 0x2c224
leaq 0x18265(%rip), %rax     # 0x2a700
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x18247(%rip), %rcx     # 0x2a6f0
movslq -0x4(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movslq 0x19d4d(%rip), %rdx     # 0x2c224
leaq 0x18222(%rip), %rax     # 0x2a700
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rsp), %ecx
movslq 0x19d30(%rip), %rdx     # 0x2c224
leaq 0x18205(%rip), %rax     # 0x2a700
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movl 0x19d19(%rip), %eax     # 0x2c224
addl $0x1, %eax
movl %eax, 0x19d10(%rip)     # 0x2c224
cmpl $0x32, %eax
jne 0x12523
movl $0x0, 0x19d01(%rip)     # 0x2c224
movq 0x181c6(%rip), %rax     # 0x2a6f0
movslq -0x4(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, %ecx
movq %rcx, (%rax)
movl 0x19cdc(%rip), %eax     # 0x2c220
addl $-0x1, %eax
movl %eax, 0x19cd3(%rip)     # 0x2c220
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__historyfind
static int stb__historyfind(void *p)
{
   int n = stb__history_pos;
   int i;
   for (i=0; i < STB_MALLOC_HISTORY_COUNT; ++i) {
      if (--n < 0) n = STB_MALLOC_HISTORY_COUNT-1;
      if (stb__alloc_history[n].p == p)
         return n;
   }
   return -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl 0x19cc9(%rip), %eax     # 0x2c224
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
cmpl $0x32, -0x18(%rsp)
jge 0x125bc
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, %eax
jge 0x12586
movl $0x31, -0x14(%rsp)
movslq -0x14(%rsp), %rcx
leaq 0x1816e(%rip), %rax     # 0x2a700
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0x125ad
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x125c4
jmp 0x125af
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x12567
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_check
void stb_wrapper_check(void *p)
{
   int n;
   
   if (p == NULL) return;

   n = stb__hashfind(p);

   if (n >= 0) return;

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

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x125e6
jmp 0x126cd
movq 0x10(%rsp), %rdi
callq 0x12160
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x12600
jmp 0x126cd
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x180e6(%rip), %eax     # 0x2a6f8
jge 0x12653
movq 0x180d5(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x12644
movq 0x10(%rsp), %rsi
leaq 0xd2d4(%rip), %rdi      # 0x1f911
movb $0x0, %al
callq 0x3610
jmp 0x12646
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12608
movq 0x10(%rsp), %rdi
callq 0x12550
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x126bf
movslq 0xc(%rsp), %rcx
leaq 0x1808c(%rip), %rax     # 0x2a700
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %esi
movq 0x10(%rsp), %rdx
movslq 0xc(%rsp), %rcx
leaq 0x18071(%rip), %rax     # 0x2a700
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movslq 0xc(%rsp), %rdi
leaq 0x1805a(%rip), %rax     # 0x2a700
imulq $0x18, %rdi, %rdi
addq %rdi, %rax
movl 0x10(%rax), %r8d
leaq 0xd29a(%rip), %rdi      # 0x1f952
movb $0x0, %al
callq 0x3610
leaq 0xd2c9(%rip), %rdi      # 0x1f98f
movb $0x0, %al
callq 0x3610
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_realloc
void stb_wrapper_realloc(void *p, void *q, int sz, char *file, int line)
{
   int n;
   if (p == NULL) { stb_wrapper_malloc(q, sz, file, line); return; }
   if (q == NULL) return; // nothing happened

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x12720
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x12230
jmp 0x127f1
cmpq $0x0, 0x18(%rsp)
jne 0x1272d
jmp 0x127f1
movq 0x20(%rsp), %rdi
callq 0x12160
movl %eax, (%rsp)
cmpl $-0x1, (%rsp)
jne 0x1276c
movq 0x20(%rsp), %rdi
callq 0x12550
movl %eax, (%rsp)
leaq 0xcf5a(%rip), %rdi      # 0x1f6ae
leaq 0xcc2e(%rip), %rsi      # 0x1f389
movl $0x1d04, %edx           # imm = 0x1D04
leaq 0xd241(%rip), %rcx      # 0x1f9a8
callq 0x2140
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x127c7
movl 0x14(%rsp), %ecx
movq 0x17f6d(%rip), %rax     # 0x2a6f0
movslq (%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movq 0x8(%rsp), %rcx
movq 0x17f53(%rip), %rax     # 0x2a6f0
movslq (%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x4(%rsp), %ecx
movq 0x17f39(%rip), %rax     # 0x2a6f0
movslq (%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
jmp 0x127ef
movl (%rsp), %edi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x12480
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x12270
jmp 0x127f1
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_listall
void stb_wrapper_listall(void (*func)(void *ptr, int sz, char *file, int line))
{
   int i;
   for (i=0; i < stb__alloc_size; ++i)
      if (stb__allocations[i].p > STB_DEL)
         func(stb__allocations[i].p   , stb__allocations[i].size,
              stb__allocations[i].file, stb__allocations[i].line);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x17edd(%rip), %eax     # 0x2a6f8
jge 0x128b0
movq 0x17ec8(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, %ecx
cmpq %rcx, (%rax)
jbe 0x1289e
movq 0x10(%rsp), %rax
movq 0x17ea6(%rip), %rcx     # 0x2a6f0
movslq 0xc(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdi
movq 0x17e90(%rip), %rcx     # 0x2a6f0
movslq 0xc(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0x14(%rcx), %esi
movq 0x17e7a(%rip), %rcx     # 0x2a6f0
movslq 0xc(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movq 0x17e63(%rip), %rcx     # 0x2a6f0
movslq 0xc(%rsp), %r8
imulq $0x18, %r8, %r8
addq %r8, %rcx
movl 0x10(%rcx), %ecx
callq *%rax
jmp 0x128a0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x12811
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wrapper_dump
void stb_wrapper_dump(char *filename)
{
   int i;
   FILE *f = fopen(filename, "w");
   if (!f) return;
   for (i=0; i < stb__alloc_size; ++i)
      if (stb__allocations[i].p > STB_DEL)
         fprintf(f, "%p %7d - %4d %s\n",
            stb__allocations[i].p   , stb__allocations[i].size,
            stb__allocations[i].line, stb__allocations[i].file);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xd10e(%rip), %rsi      # 0x1f9e3
callq 0x22f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x128ea
jmp 0x1299d
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x17dfc(%rip), %eax     # 0x2a6f8
jge 0x1299d
movq 0x17de7(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x1, %ecx
cmpq %rcx, (%rax)
jbe 0x1298b
movq (%rsp), %rdi
movq 0x17dc6(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x17db0(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq 0x17d9a(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rax
movl 0x10(%rax), %r8d
movq 0x17d83(%rip), %rax     # 0x2a6f0
movslq 0xc(%rsp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rax
movq 0x8(%rax), %r9
leaq 0xd061(%rip), %rsi      # 0x1f9e5
movb $0x0, %al
callq 0x21f0
jmp 0x1298d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x128f2
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_delete
void stb_ps_delete(stb_ps *ps)
{
   switch (3 & (int) ps) {
      case STB_ps_direct: break;
      case STB_ps_bucket: stb_bucket_free(GetBucket(ps)); break;
      case STB_ps_array : free(GetArray(ps)); break;
      case STB_ps_hash  : free(GetHash(ps)); break;
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl 0x10(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0x12a11
movq 0x8(%rsp), %rax
leaq 0xc6fc(%rip), %rcx      # 0x1f0d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x12a11
movq 0x10(%rsp), %rdi
addq $-0x1, %rdi
callq 0x12a20
jmp 0x12a11
movq 0x10(%rsp), %rdi
addq $-0x2, %rdi
callq 0x23c0
jmp 0x12a11
movq 0x10(%rsp), %rdi
addq $-0x3, %rdi
callq 0x23c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_copy
stb_ps *stb_ps_copy(stb_ps *ps)
{
   int i;
   // not a switch: order based on expected performance/power-law distribution
   switch (3 & (int) ps) {
      case STB_ps_direct: return ps;
      case STB_ps_bucket: {
         stb_ps_bucket *n = (stb_ps_bucket *) malloc(sizeof(*n));
         *n = *GetBucket(ps);
         return EncodeBucket(n);
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         stb_ps_array *n = (stb_ps_array *) malloc(sizeof(*n) + stb_ps_array_max * sizeof(n->p[0]));
         n->count = a->count;
         for (i=0; i < a->count; ++i)
            n->p[i] = a->p[i];
         return EncodeArray(n);
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         stb_ps_hash *n = stb_ps_makehash(h->size, h->size, h->table);
         return EncodeHash(n);
      }
   }
   assert(0); /* NOTREACHED */
   return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl 0x38(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0x12b81
movq (%rsp), %rax
leaq 0xc68a(%rip), %rcx      # 0x1f0e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x12ba0
movl $0x20, %edi
callq 0x2260
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
movq -0x1(%rcx), %rdx
movq %rdx, (%rax)
movq 0x7(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0xf(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x17(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x12ba0
movq 0x38(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x20(%rsp)
movslq 0x138ae(%rip), %rdi     # 0x26380
shlq $0x3, %rdi
addq $0x10, %rdi
callq 0x2260
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x12b32
movq 0x20(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x12afa
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x40(%rsp)
jmp 0x12ba0
movq 0x38(%rsp), %rax
addq $-0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x10(%rsp), %rax
movl (%rax), %esi
movq 0x10(%rsp), %rdx
addq $0x20, %rdx
callq 0x12bb0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x40(%rsp)
jmp 0x12ba0
leaq 0xcb26(%rip), %rdi      # 0x1f6ae
leaq 0xc7fa(%rip), %rsi      # 0x1f389
movl $0x1dfa, %edx           # imm = 0x1DFA
leaq 0xce5b(%rip), %rcx      # 0x1f9f6
callq 0x2140
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_makehash
static stb_ps_hash *stb_ps_makehash(int size, int old_size, void **old_data)
{
   int i;
   stb_ps_hash *h = (stb_ps_hash *) malloc(sizeof(*h) + (size-1) * sizeof(h->table[0]));
   assert(stb_is_pow2(size));
   h->size = size;
   h->mask = size-1;
   h->shrink_threshhold = (int) (0.3f * size);
   h->  grow_threshhold = (int) (0.8f * size);
   h->rehash_threshhold = (int) (0.9f * size);
   h->count = 0;
   h->count_deletes = 0;
   h->any_offset = 0;
   memset(h->table, 0, size * sizeof(h->table[0]));
   for (i=0; i < old_size; ++i)
      if (!stb_ps_empty(old_data[i]))
         stb_ps_add(EncodeHash(h), old_data[i]);
   return h;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
addq $0x28, %rdi
callq 0x2260
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edi
callq 0x4680
cmpl $0x0, %eax
je 0x12bed
jmp 0x12c0c
leaq 0xd486(%rip), %rdi      # 0x2007a
leaq 0xc78e(%rip), %rsi      # 0x1f389
movl $0x1dc7, %edx           # imm = 0x1DC7
leaq 0xd485(%rip), %rcx      # 0x2008c
callq 0x2140
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
cvtsi2ssl 0x24(%rsp), %xmm1
movss 0xc444(%rip), %xmm0     # 0x1f078
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rax)
cvtsi2ssl 0x24(%rsp), %xmm1
movss 0xc422(%rip), %xmm0     # 0x1f074
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
cvtsi2ssl 0x24(%rsp), %xmm1
movss 0xc400(%rip), %xmm0     # 0x1f070
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movslq 0x24(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2160
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x12d0d
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jbe 0x12cfe
movq 0x8(%rsp), %rdi
addq $0x3, %rdi
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x12f80
jmp 0x12d00
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x12cc5
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bucket_create2
static stb_ps_bucket *stb_bucket_create2(void *v0, void *v1)
{
   stb_ps_bucket *b = (stb_ps_bucket*) malloc(sizeof(*b));
   b->p[0] = v0;
   b->p[1] = v1;
   b->p[2] = NULL;
   b->p[3] = NULL;
   return b;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x20, %edi
callq 0x2260
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bucket_create3
static stb_ps_bucket * stb_bucket_create3(void **v)
{
   stb_ps_bucket *b = (stb_ps_bucket*) malloc(sizeof(*b));
   b->p[0] = v[0];
   b->p[1] = v[1];
   b->p[2] = v[2];
   b->p[3] = NULL;
   return b;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x20, %edi
callq 0x2260
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl 0x38(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0x1443d
movq (%rsp), %rax
leaq 0xaea0(%rip), %rcx      # 0x1f144
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x38(%rsp)
jne 0x142c2
movl $0x1, 0x44(%rsp)
jmp 0x14445
movq 0x28(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq *%rax
movl %eax, 0x44(%rsp)
jmp 0x14445
movq 0x38(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
cmpl $0x4, 0x24(%rsp)
jge 0x14347
movq 0x18(%rsp), %rax
movslq 0x24(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14338
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x30(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x14336
movl $0x0, 0x44(%rsp)
jmp 0x14445
jmp 0x14338
jmp 0x1433a
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x142f2
movl $0x1, 0x44(%rsp)
jmp 0x14445
movq 0x38(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x143b3
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movq 0x8(%rcx,%rdx,8), %rdi
movq 0x30(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x143a4
movl $0x0, 0x44(%rsp)
jmp 0x14445
jmp 0x143a6
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1436a
movl $0x1, 0x44(%rsp)
jmp 0x14445
movq 0x38(%rsp), %rax
addq $-0x3, %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x14433
movq 0x8(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq 0x20(%rax,%rcx,8), %rax
cmpl $0x1, %eax
jbe 0x14424
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movq 0x20(%rcx,%rdx,8), %rdi
movq 0x30(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x14422
movl $0x0, 0x44(%rsp)
jmp 0x14445
jmp 0x14424
jmp 0x14426
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x143d6
movl $0x1, 0x44(%rsp)
jmp 0x14445
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_ps_count
int stb_ps_count (stb_ps *ps)
{
   switch (3 & (int) ps) {
      case STB_ps_direct:
         return ps != NULL;
      case STB_ps_bucket: {
         stb_ps_bucket *b = GetBucket(ps);
         return (b->p[0] != NULL) + (b->p[1] != NULL) +
                (b->p[2] != NULL) + (b->p[3] != NULL);
      }
      case STB_ps_array: {
         stb_ps_array *a = GetArray(ps);
         return a->count;
      }
      case STB_ps_hash: {
         stb_ps_hash *h = GetHash(ps);
         return h->count;
      }
   }
   return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl -0x10(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rsp)
subl $0x3, %eax
ja 0x14533
movq -0x30(%rsp), %rax
leaq 0xacdc(%rip), %rcx      # 0x1f154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, -0x10(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0x1453b
movq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rsp), %rcx
cmpq $0x0, 0x8(%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movq -0x18(%rsp), %rcx
cmpq $0x0, 0x10(%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movq -0x18(%rsp), %rcx
cmpq $0x0, 0x18(%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rsp)
jmp 0x1453b
movq -0x10(%rsp), %rax
addq $-0x2, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x1453b
movq -0x10(%rsp), %rax
addq $-0x3, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x1453b
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: 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, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl -0x10(%rsp), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rsp)
subl $0x3, %eax
ja 0x1463c
movq -0x38(%rsp), %rax
leaq 0xabf7(%rip), %rcx      # 0x1f164
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, -0x10(%rsp)
jne 0x14597
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rsp)
jmp 0x14645
movq -0x10(%rsp), %rax
movq %rax, 0x1660d(%rip)     # 0x2abb0
movq -0x18(%rsp), %rax
movl $0x1, (%rax)
leaq 0x165fb(%rip), %rax     # 0x2abb0
movq %rax, -0x8(%rsp)
jmp 0x14645
movq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl $0x4, (%rax)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x14645
movq -0x10(%rsp), %rax
addq $-0x2, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rsp)
jmp 0x14645
movq -0x10(%rsp), %rax
addq $-0x3, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x30(%rsp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rsp)
jmp 0x14645
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x14540
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x146cd
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x1, %rax
jbe 0x146be
movq 0x18(%rsp), %rdi
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x12d20
cmpl $0x0, %eax
jne 0x146bc
movl $0x0, 0x24(%rsp)
jmp 0x146d5
jmp 0x146be
jmp 0x146c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x14679
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1483f
movq 0x18(%rsp), %rdi
callq 0x14760
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
imulq 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jle 0x148c4
callq 0x14790
movslq 0x4(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movslq (%rsp), %rax
imulq 0x20(%rsp), %rax
addq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x39c0
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x14864
cmpq $0x0, 0x18(%rsp)
je 0x148d6
movq 0x8(%rsp), %rdi
callq 0x14760
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x14760
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x270, 0xc(%rsp)       # imm = 0x270
jge 0x149ae
callq 0x14790
movq %rax, %rdx
movslq 0xc(%rsp), %rcx
leaq 0x16223(%rip), %rax     # 0x2abc0
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1497f
movq (%rsp), %rdi
callq 0x14760
movl $0x1380, 0x119c3(%rip)  # imm = 0x1380
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x38, %edi
callq 0x2260
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x4, 0xc(%rax)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
imull 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x14e5e
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl 0x10(%rsp), %eax
shll %eax
movl %eax, 0x10(%rsp)
jmp 0x14e35
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movslq 0x10(%rsp), %rdi
shlq $0x3, %rdi
callq 0x2260
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x14ef9
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14ecd
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rcx
movl 0x14(%rcx), %esi
callq *%rax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq 0x40(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14f87
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x10(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x14f8f
xorl %eax, %eax
movl %eax, 0x24(%rsp)
jmp 0x14f8f
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14fc8
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x14fd0
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x14fd0
movl 0x20(%rsp), %eax
movl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jle 0x15001
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movslq 0x30(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x1501b
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1505f
movq 0x40(%rsp), %rax
movq (%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x15067
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x15067
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdx
movl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movq %rdx, -0x8(%rax,%rcx,8)
movq 0x40(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x48, %rsp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x150c7
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x150cf
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x150cf
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x15119
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1510a
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movslq 0xc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x7d20
jmp 0x1510c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x150a1
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x7d20
movq 0x10(%rsp), %rdi
callq 0x23c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)