LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lowbit8
int stb_lowbit8(unsigned int n)
{
   static signed char lowbit4[16] = { -1,0,1,0, 2,0,1,0, 3,0,1,0, 2,0,1,0 };
   int k = lowbit4[n & 15];
   if (k >= 0) return k;
   k = lowbit4[(n >> 4) & 15];
   if (k >= 0) return k+4;
   return k;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21b1a(%rip), %rax     # 0x26350
movsbl (%rax,%rcx), %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jl 0x484f
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x4888
movl -0x8(%rsp), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21aec(%rip), %rax     # 0x26350
movsbl (%rax,%rcx), %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jl 0x4880
movl -0xc(%rsp), %eax
addl $0x4, %eax
movl %eax, -0x4(%rsp)
jmp 0x4888
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_probe
int stb_probe(stb_search *s, int compare, int *result)
{
   switch(s->mode) {
      case STB_probe_open_smallest:
      case STB_probe_open_largest: {
         if (compare <= 0) {
            // then it lies within minval & maxval
            if (s->mode == STB_probe_open_smallest)
               s->mode = STB_probe_binary_smallest;
            else
               s->mode = STB_probe_binary_largest;
         } else {
            // otherwise, we need to probe larger
            s->minval  = s->maxval + 1;
            s->maxval  = s->minval + s->step;
            s->step   += s->step;
         }
         break;
      }
      case STB_probe_binary_smallest: {
         // if compare < 0, then s->minval <= a <  p
         // if compare = 0, then s->minval <= a <= p
         // if compare > 0, then         p <  a <= s->maxval
         if (compare <= 0)
            s->maxval = s->guess;
         else
            s->minval = s->guess+1;
         break;
      }
      case STB_probe_binary_largest: {
         // if compare < 0, then s->minval <= a < p
         // if compare = 0, then         p <= a <= s->maxval
         // if compare > 0, then         p <  a <= s->maxval
         if (compare < 0)
            s->maxval = s->guess-1;
         else
            s->minval = s->guess;
         break;
      }
   }
   return stb_probe_guess(s, result);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x4c55
jmp 0x4bc8
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x4c82
jmp 0x4bd7
movl 0xc(%rsp), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0x4caf
jmp 0x4be9
cmpl $0x0, 0x1c(%rsp)
jg 0x4c17
movq 0x20(%rsp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x4c09
movq 0x20(%rsp), %rax
movl $0x0, 0xc(%rax)
jmp 0x4c15
movq 0x20(%rsp), %rax
movl $0x1, 0xc(%rax)
jmp 0x4c53
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
addl 0x10(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x20(%rsp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x4caf
cmpl $0x0, 0x1c(%rsp)
jg 0x4c6e
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x4c80
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4caf
cmpl $0x0, 0x1c(%rsp)
jge 0x4c9e
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x4cad
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4caf
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4cd0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_probe_guess
static int stb_probe_guess(stb_search *s, int *result)
{
   switch(s->mode) {
      case STB_probe_binary_largest:
         if (s->minval == s->maxval) {
            *result = s->minval;
            return 0;
         }
         assert(s->minval < s->maxval);
         // if a < b, then a < p <= b
         s->guess = s->minval + (((unsigned) s->maxval - s->minval + 1) >> 1);
         break;

      case STB_probe_binary_smallest:
         if (s->minval == s->maxval) {
            *result = s->minval;
            return 0;
         }
         assert(s->minval < s->maxval);
         // if a < b, then a <= p < b
         s->guess = s->minval + (((unsigned) s->maxval - s->minval) >> 1);
         break;
      case STB_probe_open_smallest:
      case STB_probe_open_largest:
         s->guess = s->maxval;  // guess the current maxval
         break;
   }
   *result = s->guess;
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x4d9c
jmp 0x4cf4
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x4d14
jmp 0x4cff
movl 0xc(%rsp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x4e1b
jmp 0x4e2b
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x4d40
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x4e42
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x4d53
jmp 0x4d72
leaq 0x1b0f9(%rip), %rdi     # 0x1fe53
leaq 0x1a628(%rip), %rsi     # 0x1f389
movl $0x682, %edx            # imm = 0x682
leaq 0x1b0fc(%rip), %rcx     # 0x1fe69
callq 0x2140
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x18(%rsp), %rdx
subl (%rdx), %eax
addl $0x1, %eax
shrl %eax
addl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x4e2b
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x4dc5
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x4e42
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x4dd8
jmp 0x4df7
leaq 0x1b074(%rip), %rdi     # 0x1fe53
leaq 0x1a5a3(%rip), %rsi     # 0x1f389
movl $0x68c, %edx            # imm = 0x68C
leaq 0x1b077(%rip), %rcx     # 0x1fe69
callq 0x2140
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x18(%rsp), %rdx
subl (%rdx), %eax
shrl %eax
addl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x4e2b
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_search_binary
int stb_search_binary(stb_search *s, int minv, int maxv, int find_smallest)
{
   int r;
   if (maxv < minv) return minv-1;
   s->minval = minv;
   s->maxval = maxv;
   s->mode = find_smallest ? STB_probe_binary_smallest : STB_probe_binary_largest;
   stb_probe_guess(s, &r);
   return r;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x4e7c
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4ec3
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0xc(%rsp), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4cd0
movl 0x8(%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_search_open
int stb_search_open(stb_search *s, int minv, int find_smallest)
{
   int r;
   s->step   = 4;
   s->minval = minv;
   s->maxval = minv+s->step;
   s->mode = find_smallest ? STB_probe_open_smallest : STB_probe_open_largest;
   stb_probe_guess(s, &r);
   return r;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl $0x4, 0x10(%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
addl 0x10(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x8(%rsp), %edx
movl $0x3, %ecx
movl $0x2, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x4cd0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strscpy
size_t stb_strscpy(char *d, const char *s, size_t n)
{
   size_t len = strlen(s);
   if (len >= n) {
      if (n) d[0] = 0;
      return 0;
   }
   strcpy(d,s);
   return len + 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x4f87
cmpq $0x0, 0x8(%rsp)
je 0x4f7c
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq $0x0, 0x20(%rsp)
jmp 0x4fa3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2070
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_prefix
int stb_prefix(char *s, char *t)
{
   while (*t)
      if (*s++ != *t++)
         return STB_FALSE;
   return STB_TRUE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x501c
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movsbl (%rax), %eax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x501a
movl $0x0, -0x4(%rsp)
jmp 0x5024
jmp 0x4fda
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_prefix_count
int stb_prefix_count(char *s, char *t)
{
   int c=0;
   while (*t) {
      if (*s++ != *t++)
         break;
      ++c;
   }
   return c;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x5087
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movsbl (%rax), %eax
movq -0x10(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x507a
jmp 0x5087
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x5042
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_suffix
int stb_suffix(char *s, char *t)
{
   size_t n = strlen(s);
   size_t m = strlen(t);
   if (m <= n)
      return 0 == strcmp(s+n-m, t);
   else
      return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2100
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0x50f7
movq 0x18(%rsp), %rdi
addq 0x8(%rsp), %rdi
xorl %eax, %eax
subq (%rsp), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x21e0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x50ff
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_suffixi
int stb_suffixi(char *s, char *t)
{
   size_t n = strlen(s);
   size_t m = strlen(t);
   if (m <= n)
      return 0 == stb_stricmp(s+n-m, t);
   else
      return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2100
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0x5177
movq 0x18(%rsp), %rdi
addq 0x8(%rsp), %rdi
xorl %eax, %eax
subq (%rsp), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2030
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x517f
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_skipnewline
char *stb_skipnewline(char *s)
{
   if (s[0] == '\r' || s[0] == '\n') {
      if (s[0]+s[1] == '\r' + '\n') ++s;
      ++s;
   }
   return s;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x51ef
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x5223
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
movq -0x8(%rsp), %rcx
movsbl 0x1(%rcx), %ecx
addl %ecx, %eax
cmpl $0x17, %eax
jne 0x5215
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_trimwhite
char *stb_trimwhite(char *s)
{
   int i,n;
   s = stb_skipwhite(s);
   n = (int) strlen(s);
   for (i=n-1; i >= 0; --i)
      if (!isspace(s[i]))
         break;
   s[i+1] = 0;
   return s;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5190
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x52a0
callq 0x23b0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x5291
jmp 0x52a0
jmp 0x5293
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5261
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_substr
char *stb_substr(char *t, int n)
{
   char *a;
   int z = (int) strlen(t);
   if (z < n) n = z;
   a = (char *) malloc(n+1);
   strncpy(a,t,n);
   a[n] = 0;
   return a;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2100
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x533d
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2260
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
callq 0x2050
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_duplower
char *stb_duplower(char *s)
{
   char *p = strdup(s), *q = p;
   while (*q) {
      *q = tolower(*q);
      ++q;
   }
   return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2390
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpb $0x0, (%rax)
je 0x53cc
movq (%rsp), %rax
movsbl (%rax), %edi
callq 0x2250
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x53a1
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strchr2
char *stb_strchr2(char *s, char x, char y)
{
   for(; *s; ++s)
      if (*s == x || *s == y)
         return s;
   return NULL;
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rsp)
movb %cl, -0x11(%rsp)
movb %al, -0x12(%rsp)
movq -0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x547c
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rsp), %ecx
cmpl %ecx, %eax
je 0x545e
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movsbl -0x12(%rsp), %ecx
cmpl %ecx, %eax
jne 0x546a
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x5485
jmp 0x546c
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x5432
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strrchr2
char *stb_strrchr2(char *s, char x, char y)
{
   char *r = NULL;
   for(; *s; ++s)
      if (*s == x || *s == y)
         r = s;
   return r;
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rsp)
movb %cl, -0x9(%rsp)
movb %al, -0xa(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x54f3
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rsp), %ecx
cmpl %ecx, %eax
je 0x54d7
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
movsbl -0xa(%rsp), %ecx
cmpl %ecx, %eax
jne 0x54e1
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x54e3
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x54ab
movq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_stristr
char *stb_stristr(char *s, char *t)
{
   size_t n = strlen(t);
   char *z;
   if (n==0) return s;
   while ((z = stb_strichr(s, *t)) != NULL) {
      if (0==stb_strnicmp(z, t, n))
         return z;
      s = z+1;
   }
   return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x55c1
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x561d
jmp 0x55c3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movsbl (%rax), %esi
callq 0x5500
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x5614
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2270
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5605
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x561d
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x55c3
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_strtok_raw
static char *stb_strtok_raw(char *output, char *src, char *delimit, int keep, int invert)
{
   if (invert) {
      while (*src && strchr(delimit, *src) != NULL) {
         *output++ = *src++;
      }
   } else {
      while (*src && strchr(delimit, *src) == NULL) {
         *output++ = *src++;
      }
   }
   *output = 0;
   if (keep)
      return src;
   else
      return *src ? src+1 : src;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x56e9
jmp 0x5685
movq 0x20(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x56b5
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movsbl (%rax), %esi
callq 0x2110
cmpq $0x0, %rax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x56bf
jmp 0x56e7
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %cl
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rsp)
movb %cl, (%rax)
jmp 0x5685
jmp 0x574f
jmp 0x56eb
movq 0x20(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xe(%rsp)
je 0x571b
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movsbl (%rax), %esi
callq 0x2110
cmpq $0x0, %rax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x5725
jmp 0x574d
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %cl
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rsp)
movb %cl, (%rax)
jmp 0x56eb
jmp 0x574f
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
cmpl $0x0, 0x14(%rsp)
je 0x576a
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x5798
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5786
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x578f
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_dupreplace
char *stb_dupreplace(char *src, char *find, char *replace)
{
   size_t len_find = strlen(find);
   size_t len_replace = strlen(replace);
   int count = 0;

   char *s,*p,*q;

   s = strstr(src, find);
   if (s == NULL) return strdup(src);
   do {
      ++count;
      s = strstr(s + len_find, find);
   } while (s != NULL);

   p = (char *)  malloc(strlen(src) + count * (len_replace - len_find) + 1);
   if (p == NULL) return p;
   q = p;
   s = src;
   for (;;) {
      char *t = strstr(s, find);
      if (t == NULL) {
         strcpy(q,s);
         assert(strlen(p) == strlen(src) + count*(len_replace-len_find));
         return p;
      }
      memcpy(q, s, t-s);
      q += t-s;
      memcpy(q, replace, len_replace);
      q += len_replace;
      s = t + len_find;
   }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2100
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2100
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x23a0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x63d9
movq 0x58(%rsp), %rdi
callq 0x2390
movq %rax, 0x60(%rsp)
jmp 0x6561
jmp 0x63db
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x28(%rsp), %rdi
addq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x23a0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x63db
movq 0x58(%rsp), %rdi
callq 0x2100
movq %rax, %rdi
movslq 0x34(%rsp), %rax
movq 0x38(%rsp), %rcx
subq 0x40(%rsp), %rcx
imulq %rcx, %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x2260
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x644f
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x6561
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x23a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x64f7
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2070
movq 0x20(%rsp), %rdi
callq 0x2100
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movq 0x8(%rsp), %rax
movslq 0x34(%rsp), %rdx
movq 0x38(%rsp), %rsi
subq 0x40(%rsp), %rsi
imulq %rsi, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x64cc
jmp 0x64eb
leaq 0x18f2d(%rip), %rdi     # 0x1f400
leaq 0x18eaf(%rip), %rsi     # 0x1f389
movl $0x8a7, %edx            # imm = 0x8A7
leaq 0x18f52(%rip), %rcx     # 0x1f438
callq 0x2140
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x6561
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rax
subq %rax, %rdx
callq 0x2230
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x2230
movq 0x38(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x6463
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_replaceinplace
void stb_replaceinplace(char *src, char *find, char *replace)
{
   size_t len_find = strlen(find);
   size_t len_replace = strlen(replace);
   int delta;

   char *s,*p,*q;

   delta = len_replace - len_find;
   assert(delta <= 0);
   if (delta > 0) return;

   p = strstr(src, find);
   if (p == NULL) return;

   s = q = p;
   while (*s) {
      memcpy(q, replace, len_replace);
      p += len_find;
      q += len_replace;
      s = strstr(p, find);
      if (s == NULL) s = p + strlen(p);
      memmove(q, p, s-p);
      q += s-p;
      p = s;
   }
   *q = 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2100
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2100
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
subq 0x38(%rsp), %rax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jg 0x65b8
jmp 0x65d7
leaq 0x18ea6(%rip), %rdi     # 0x1f465
leaq 0x18dc3(%rip), %rsi     # 0x1f389
movl $0x8bb, %edx            # imm = 0x8BB
leaq 0x18e9e(%rip), %rcx     # 0x1f470
callq 0x2140
cmpl $0x0, 0x2c(%rsp)
jle 0x65e3
jmp 0x66dd
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x23a0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x6604
jmp 0x66dd
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
je 0x66d5
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x2230
movq 0x38(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x23a0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x6693
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rax
subq %rax, %rdx
callq 0x22d0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x6613
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_section
void stb__add_section(char *buffer, char *data, int curlen, int newlen)
{
   if (newlen < curlen) {
      int z1 = newlen >> 1, z2 = newlen-z1;
      memcpy(buffer, data, z1-1);
      buffer[z1-1] = '.';
      buffer[z1-0] = '.';
      memcpy(buffer+z1+1, data+curlen-z2+1, z2-1);
   } else
      memcpy(buffer, data, curlen);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x67e9
movl 0x10(%rsp), %eax
sarl %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
subl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x2230
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x2e, (%rax,%rcx)
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x0, %ecx
movslq %ecx, %rcx
movb $0x2e, (%rax,%rcx)
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rax
addq %rax, %rsi
movslq 0x8(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
addq $0x1, %rsi
movl 0x8(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x2230
jmp 0x67fd
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x2230
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_replacedir
char *stb_replacedir(char *output, char *src, char *dir)
{
   char buffer[4096];
   stb_splitpath(buffer, src, STB_FILE | STB_EXT);
   if (dir)
      sprintf(output, "%s/%s", dir, buffer);
   else
      strcpy(output, buffer);
   return output;
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, 0x1010(%rsp)
movq %rsi, 0x1008(%rsp)
movq %rdx, 0x1000(%rsp)
movq %rsp, %rdi
movq 0x1008(%rsp), %rsi
movl $0x6, %edx
callq 0x6a30
cmpq $0x0, 0x1000(%rsp)
je 0x6d62
movq 0x1010(%rsp), %rdi
movq 0x1000(%rsp), %rdx
movq %rsp, %rcx
leaq 0x18789(%rip), %rsi     # 0x1f4e2
movb $0x0, %al
callq 0x2350
jmp 0x6d72
movq 0x1010(%rsp), %rdi
movq %rsp, %rsi
callq 0x2070
movq 0x1010(%rsp), %rax
addq $0x1018, %rsp           # imm = 0x1018
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_replaceext
char *stb_replaceext(char *output, char *src, char *ext)
{
   char buffer[4096];
   stb_splitpath(buffer, src, STB_PATH | STB_FILE);
   if (ext)
      sprintf(output, "%s.%s", buffer, ext[0] == '.' ? ext+1 : ext);
   else
      strcpy(output, buffer);
   return output;
}

// Assembly:
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, 0x1030(%rsp)
movq %rsi, 0x1028(%rsp)
movq %rdx, 0x1020(%rsp)
leaq 0x20(%rsp), %rdi
movq 0x1028(%rsp), %rsi
movl $0x3, %edx
callq 0x6a30
cmpq $0x0, 0x1020(%rsp)
je 0x6e37
movq 0x1030(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x1020(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x6e0b
movq 0x1020(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x6e18
movq 0x1020(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
leaq 0x186ba(%rip), %rsi     # 0x1f4e8
movb $0x0, %al
callq 0x2350
jmp 0x6e49
movq 0x1030(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2070
movq 0x1030(%rsp), %rax
addq $0x1038, %rsp           # imm = 0x1038
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__prevn
static void *** stb__prevn(void *p)
{
   if (stb__identify(p) == STB__alloc) {
      stb__alloc      *s = (stb__alloc *) p - 1;
      return &s->prevn;
   } else {
      stb__nochildren *s = (stb__nochildren *) p - 1;
      return &s->prevn;
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7030
cmpl $0x2, %eax
jne 0x7082
movq 0x18(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x709e
movq 0x18(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_realloc
void *stb_realloc(void *ptr, size_t newsize)
{
   stb__alloc_type t;

   if (ptr == NULL) return stb_malloc(NULL, newsize);
   if (newsize == 0) { stb_free(ptr); return NULL; }
   
   t = stb__identify(ptr);
   assert(t == STB__alloc || t == STB__nochildren);

   if (t == STB__alloc) {
      stb__alloc *s = (stb__alloc *) ptr - 1;

      s = (stb__alloc *) realloc(s, newsize + sizeof(*s));
      if (s == NULL) return NULL;

      ptr = s+1;

      // update pointers
      (*s->prevn) = ptr;
      if (s->next)
         *stb__prevn(s->next) = &s->next;

      if (s->child)
         *stb__prevn(s->child) = &s->child;

      return ptr;
   } else {
      stb__nochildren *s = (stb__nochildren *) ptr - 1;

      s = (stb__nochildren *) realloc(ptr, newsize + sizeof(s));
      if (s == NULL) return NULL;

      // update pointers
      (*s->prevn) = s+1;
      if (s->next)
         *stb__prevn(s->next) = &s->next;

      return s+1;
   }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x76ce
movq 0x30(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x75b0
movq %rax, 0x40(%rsp)
jmp 0x7883
cmpq $0x0, 0x30(%rsp)
jne 0x76ee
movq 0x38(%rsp), %rdi
callq 0x6e60
movq $0x0, 0x40(%rsp)
jmp 0x7883
movq 0x38(%rsp), %rdi
callq 0x7030
movl %eax, 0x2c(%rsp)
cmpl $0x2, 0x2c(%rsp)
je 0x770a
cmpl $0x0, 0x2c(%rsp)
jne 0x770c
jmp 0x772b
leaq 0x17e9d(%rip), %rdi     # 0x1f5b0
leaq 0x17c6f(%rip), %rsi     # 0x1f389
movl $0xb5c, %edx            # imm = 0xB5C
leaq 0x17eb2(%rip), %rcx     # 0x1f5d8
callq 0x2140
cmpl $0x2, 0x2c(%rsp)
jne 0x77ff
movq 0x38(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
callq 0x22b0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x7772
movq $0x0, 0x40(%rsp)
jmp 0x7883
movq 0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x77c0
movq 0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7050
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x77f0
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x7050
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x7883
movq 0x38(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x8, %rsi
callq 0x22b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7838
movq $0x0, 0x40(%rsp)
jmp 0x7883
movq 0x18(%rsp), %rcx
addq $0x10, %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7875
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x7050
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_reassign
void stb_reassign(void *new_context, void *ptr)
{
   stb__alloc *src = stb__get_context(new_context);

   stb__alloc_type t = stb__identify(ptr);
   assert(t == STB__alloc || t == STB__nochildren);

   if (t == STB__alloc) {
      stb__alloc *s = (stb__alloc *) ptr - 1;

      // unlink from old
      *(s->prevn) = s->next;
      if (s->next)
         *stb__prevn(s->next) = s->prevn;

      stb__insert_alloc(src, s);
   } else {
      stb__nochildren *s = (stb__nochildren *) ptr - 1;

      // unlink from old
      *(s->prevn) = s->next;
      if (s->next)
         *stb__prevn(s->next) = s->prevn;

      stb__insert_nochild(src, s);
   }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x7a30
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x7030
movl %eax, 0x2c(%rsp)
cmpl $0x2, 0x2c(%rsp)
je 0x7939
cmpl $0x0, 0x2c(%rsp)
jne 0x793b
jmp 0x795a
leaq 0x17c6e(%rip), %rdi     # 0x1f5b0
leaq 0x17a40(%rip), %rsi     # 0x1f389
movl $0xb8b, %edx            # imm = 0xB8B
leaq 0x17ca5(%rip), %rcx     # 0x1f5fa
callq 0x2140
cmpl $0x2, 0x2c(%rsp)
jne 0x79c3
movq 0x38(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x79b2
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7050
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7aa0
jmp 0x7a22
movq 0x38(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7a13
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x7050
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7b20
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__get_context
static stb__alloc * stb__get_context(void *context)
{
   if (context == NULL) {
      return &stb__alloc_global;
   } else {
      int u = stb__identify(context);
      // if context is chunked, grab parent
      if (u == STB__chunked) {
         stb__chunked *s = (stb__chunked *) context - 1;
         return stb__parent(s);
      } else {
         return (stb__alloc *) context - 1;
      }
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7a4f
leaq 0x1e948(%rip), %rax     # 0x26390
movq %rax, 0x20(%rsp)
jmp 0x7a93
movq 0x18(%rsp), %rdi
callq 0x7030
movl %eax, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x7a85
movq 0x18(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x7a93
movq 0x18(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__insert_alloc
static void stb__insert_alloc(stb__alloc *src, stb__alloc *s)
{
   s->prevn = &src->child;
   s->next  = src->child;
   src->child = s+1;
   if (s->next)
      *stb__prevn(s->next) = &s->next;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
addq $0x20, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7b11
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7050
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__insert_nochild
static void stb__insert_nochild(stb__alloc *src, stb__nochildren *s)
{
   s->prevn = &src->child;
   s->next  = src->child;
   src->child = s+1;
   if (s->next)
      *stb__prevn(s->next) = &s->next;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
addq $0x10, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7b8b
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x7050
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arr_malloc
void stb_arr_malloc(void **target, void *context)
{
   stb__arr *q = (stb__arr *) stb_malloc(context, sizeof(*q));
   q->len = q->limit = 0;
   q->stb_malloc = 1;
   q->signature = stb_arr_signature;
   *target = (void *) (q+1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x75b0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movl $0x1, 0x8(%rax)
movq (%rsp), %rax
movl $0x51bada7b, 0xc(%rax)  # imm = 0x51BADA7B
movq (%rsp), %rcx
addq $0x10, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arr_copy_
void * stb__arr_copy_(void *p, int elem_size)
{
   stb__arr *q;
   if (p == NULL) return p;
   q = (stb__arr *) stb__arr_malloc(sizeof(*q) + elem_size * stb_arrhead2(p)->limit);
   stb_arr_check2(p);
   memcpy(q, stb_arrhead2(p), sizeof(*q) + elem_size * stb_arrhead2(p)->len);
   q->stb_malloc = !!stb__arr_context;
   return q+1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x7c51
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7cc1
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
imull -0xc(%rcx), %eax
cltq
addq $0x10, %rax
movl %eax, %edi
callq 0x7cd0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $-0x10, %rsi
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
imull -0x10(%rcx), %eax
movslq %eax, %rdx
addq $0x10, %rdx
callq 0x2230
cmpq $0x0, 0x223e9(%rip)     # 0x2a088
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arr_free_
void stb_arr_free_(void **pp)
{
   void *p = *pp;
   stb_arr_check2(p);
   if (p) {
      stb__arr *q = stb_arrhead2(p);
      if (q->stb_malloc)
         stb_free(q);
      else
         free(q);
   }
   *pp = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x7d6b
movq 0x8(%rsp), %rax
addq $-0x10, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x7d60
movq (%rsp), %rdi
callq 0x6e60
jmp 0x7d69
movq (%rsp), %rdi
callq 0x23c0
jmp 0x7d6b
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arr_setlen_
void stb__arr_setlen_(void **pp, int size, int newlen  STB__PARAMS)
{
   void *p = *pp;
   stb_arr_check2(p);
   if (stb_arrcurmax2(p) < newlen || p == NULL) {
      stb__arrsize_(pp, size, newlen, newlen  STB__ARGS);
   } else {
      stb_arrhead2(p)->len = newlen;
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7fe4
movq 0x10(%rsp), %rax
movl -0xc(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x7fec
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x7fec
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jl 0x7ffe
cmpq $0x0, 0x10(%rsp)
jne 0x8016
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x7e00
jmp 0x8022
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, -0x10(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arr_insertn_
void stb__arr_insertn_(void **pp, int size, int i, int n  STB__PARAMS)
{
   void *p = *pp;
   if (n) {
      int z;

      if (p == NULL) {
         stb__arr_addlen_(pp, size, n  STB__ARGS);
         return;
      }

      z = stb_arr_len2(p);
      stb__arr_addlen_(&p, size, n  STB__ARGS);
      memmove((char *) p + (i+n)*size, (char *) p + i*size, size * (z-i));
   }
   *pp = p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x8162
cmpq $0x0, 0x8(%rsp)
jne 0x80ec
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x8030
jmp 0x816f
cmpq $0x0, 0x8(%rsp)
je 0x8101
movq 0x8(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, (%rsp)
jmp 0x8108
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x8108
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
leaq 0x8(%rsp), %rdi
callq 0x8030
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
addl 0x14(%rsp), %eax
imull 0x1c(%rsp), %eax
cltq
addq %rax, %rdi
movq 0x8(%rsp), %rsi
movl 0x18(%rsp), %eax
imull 0x1c(%rsp), %eax
cltq
addq %rax, %rsi
movl 0x1c(%rsp), %eax
movl 0x4(%rsp), %ecx
subl 0x18(%rsp), %ecx
imull %ecx, %eax
movslq %eax, %rdx
callq 0x22d0
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arr_deleten_
void stb__arr_deleten_(void **pp, int size, int i, int n  STB__PARAMS)
{
   void *p = *pp;
   if (n) {
      memmove((char *) p + i*size, (char *) p + (i+n)*size, size * (stb_arr_len2(p)-(i+n)));
      stb_arrhead2(p)->len -= n;
   }
   *pp = p;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x8241
movq 0x28(%rsp), %rax
movl 0x38(%rsp), %ecx
imull 0x3c(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x38(%rsp), %ecx
addl 0x34(%rsp), %ecx
imull 0x3c(%rsp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x8201
movq 0x28(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x8209
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x8209
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl 0xc(%rsp), %ecx
movl 0x38(%rsp), %edx
addl 0x34(%rsp), %edx
subl %edx, %ecx
imull %ecx, %eax
movslq %eax, %rdx
callq 0x22d0
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rax
movl -0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, -0x10(%rax)
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash
unsigned int stb_hash(char *str)
{
   unsigned int hash = 0;
   while (*str)
      hash = (hash << 7) + (hash >> 25) + *str++;
   return hash + (hash >> 16);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x82a3
movl -0xc(%rsp), %eax
shll $0x7, %eax
movl -0xc(%rsp), %ecx
shrl $0x19, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rsp)
jmp 0x826d
movl -0xc(%rsp), %eax
movl -0xc(%rsp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hashlen
unsigned int stb_hashlen(char *str, int len)
{
   unsigned int hash = 0;
   while (len-- > 0 && *str)
      hash = (hash << 7) + (hash >> 25) + *str++;
   return hash + (hash >> 16);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl -0xc(%rsp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rsp)
jle 0x82fb
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
testb $0x1, %al
jne 0x8305
jmp 0x8331
movl -0x10(%rsp), %eax
shll $0x7, %eax
movl -0x10(%rsp), %ecx
shrl $0x19, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rsp)
jmp 0x82d1
movl -0x10(%rsp), %eax
movl -0x10(%rsp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hashptr
unsigned int stb_hashptr(void *p)
{
   unsigned int x = (unsigned int) p;

   // typically lacking in low bits and high bits
   x = stb_rehash(x);
   x += x << 16;

   // pearson's shuffle
   x ^= x << 3;
   x += x >> 5;
   x ^= x << 2;
   x += x >> 15;
   x ^= x << 10;
   return stb_rehash(x);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl -0xc(%rsp), %ecx
shrl $0x6, %ecx
addl %ecx, %eax
movl -0xc(%rsp), %ecx
shrl $0x13, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0x10, %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0x3, %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shrl $0x5, %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0x2, %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shrl $0xf, %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0xa, %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl -0xc(%rsp), %ecx
shrl $0x6, %ecx
addl %ecx, %eax
movl -0xc(%rsp), %ecx
shrl $0x13, %ecx
addl %ecx, %eax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash2
unsigned int stb_hash2(char *str, unsigned int *hash2_ptr)
{
   unsigned int hash1 = 0x3141592c;
   unsigned int hash2 = 0x77f044ed;
   while (*str) {
      hash1 = (hash1 << 7) + (hash1 >> 25) + *str;
      hash2 = (hash2 << 11) + (hash2 >> 21) + *str;
      ++str;
   }
   *hash2_ptr = hash2 + (hash1 >> 16);
   return       hash1 + (hash2 >> 16);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x3141592c, -0x14(%rsp) # imm = 0x3141592C
movl $0x77f044ed, -0x18(%rsp) # imm = 0x77F044ED
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x8470
movl -0x14(%rsp), %eax
shll $0x7, %eax
movl -0x14(%rsp), %ecx
shrl $0x19, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
shll $0xb, %eax
movl -0x18(%rsp), %ecx
shrl $0x15, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x841a
movl -0x18(%rsp), %ecx
movl -0x14(%rsp), %eax
shrl $0x10, %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x14(%rsp), %eax
movl -0x18(%rsp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_hash_number
unsigned int stb_hash_number(unsigned int hash)
{
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;
   return hash;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x3, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x5, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x4, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x11, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x19, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x6, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)