LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_eq
int stb_bitset_eq(stb_bitset *p0, stb_bitset *p1, int len)
{
   int i;
   for (i=0; i < len; ++i)
      if (p0[i] != p1[i]) return 0;
   return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x15ce5
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x15cd6
movl $0x0, -0x4(%rsp)
jmp 0x15ced
jmp 0x15cd8
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15ca6
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_disjoint_0
int stb_bitset_disjoint_0(stb_bitset *p0, stb_bitset *p1, int len)
{
   int i;
   for (i=0; i < len; ++i)
      if ((p0[i] | p1[i]) != 0xffffffff) return 0;
   return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x15dc8
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
orl (%rcx,%rdx,4), %eax
cmpl $-0x1, %eax
je 0x15db9
movl $0x0, -0x4(%rsp)
jmp 0x15dd0
jmp 0x15dbb
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15d86
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_subset
int stb_bitset_subset(stb_bitset *bigger, stb_bitset *smaller, int len)
{
   int i;
   for (i=0; i < len; ++i)
      if ((bigger[i] & smaller[i]) != smaller[i]) return 0;
   return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x15e42
movq -0x10(%rsp), %rax
movslq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
andl (%rcx,%rdx,4), %eax
movq -0x18(%rsp), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x15e33
movl $0x0, -0x4(%rsp)
jmp 0x15e4a
jmp 0x15e35
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15df6
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_unioneq_changed
int stb_bitset_unioneq_changed(stb_bitset *p0, stb_bitset *p1, int len)
{
   int i, changed=0;
   for (i=0; i < len; ++i) {
      stb_bitset d = p0[i] | p1[i];
      if (d != p0[i]) {
         p0[i] = d;
         changed = 1;
      }
   }
   return changed;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x15f51
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movslq -0x18(%rsp), %rdx
orl (%rcx,%rdx,4), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movq -0x8(%rsp), %rcx
movslq -0x18(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x15f42
movl -0x20(%rsp), %edx
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x1c(%rsp)
jmp 0x15f44
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x15eee
movl -0x1c(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_new
stb_bitset *stb_bitset_new(int value, int len)
{
   int i;
   stb_bitset *d = (stb_bitset *) malloc(sizeof(*d) * len);
   if (value) value = 0xffffffff;
   for (i=0; i < len; ++i) d[i] = value;
   return d;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movslq 0x10(%rsp), %rdi
shlq $0x2, %rdi
callq 0x2260
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x15f8d
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x15fbc
movl 0x14(%rsp), %edx
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15f95
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_bitset_getlist
int *stb_bitset_getlist(stb_bitset *out, int start, int end)
{
   int *list = NULL;
   int i;
   for (i=start; i < end; ++i)
      if (stb_bitset_testbit(out, i))
         stb_arr_push(list, i);
   return list;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x160fa
movq 0x40(%rsp), %rax
movl 0x2c(%rsp), %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl 0x2c(%rsp), %ecx
andl $0x1f, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x160e8
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1604b
movq 0x30(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x16053
xorl %eax, %eax
movl %eax, 0x24(%rsp)
jmp 0x16053
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x16074
movq 0x30(%rsp), %rax
movl -0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1607c
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1607c
movl 0x20(%rsp), %eax
movl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jle 0x1609e
leaq 0x30(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x160ac
movq 0x30(%rsp), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x160cc
movq 0x30(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x160d4
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x160d4
movq 0x10(%rsp), %rax
movl 0x28(%rsp), %edx
movl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movl %edx, -0x4(%rax,%rcx,4)
jmp 0x160ea
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15ff2
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_wordwrapalloc
int *stb_wordwrapalloc(int count, char *str)
{
   int n = stb_wordwrap(NULL,0,count,str);
   int *z = NULL;
   stb_arr_setlen(z, n*2);
   stb_wordwrap(z, n, count, str);
   return z;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x16110
movl %eax, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movl 0x14(%rsp), %edx
shll %edx
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x7fb0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0x16110
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__match_qstring
static int stb__match_qstring(char *candidate, char *qstring, int qlen, int insensitive)
{
   int i;
   if (insensitive) {
      for (i=0; i < qlen; ++i)
         if (qstring[i] == '?') {
            if (!candidate[i]) return 0;
         } else
            if (tolower(qstring[i]) != tolower(candidate[i]))
               return 0;
   } else {
      for (i=0; i < qlen; ++i)
         if (qstring[i] == '?') {
            if (!candidate[i]) return 0;
         } else
            if (qstring[i] != candidate[i])
               return 0;
   }
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x16bde
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x16bdc
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3f, %eax
jne 0x16b89
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x16b87
movl $0x0, 0x24(%rsp)
jmp 0x16c64
jmp 0x16bca
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2250
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2250
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
je 0x16bc8
movl $0x0, 0x24(%rsp)
jmp 0x16c64
jmp 0x16bca
jmp 0x16bcc
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x16b49
jmp 0x16c5c
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x16c5a
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3f, %eax
jne 0x16c1f
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x16c1d
movl $0x0, 0x24(%rsp)
jmp 0x16c64
jmp 0x16c4b
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x16c49
movl $0x0, 0x24(%rsp)
jmp 0x16c64
jmp 0x16c4b
jmp 0x16c4d
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x16be6
jmp 0x16c5c
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__find_qstring
static int stb__find_qstring(char *candidate, char *qstring, int qlen, int insensitive)
{
   char c;

   int offset=0;
   while (*qstring == '?') {
      ++qstring;
      --qlen;
      ++candidate;
      if (qlen == 0) return 0;
      if (*candidate == 0) return -1;
   }

   c = *qstring++;
   --qlen;
   if (insensitive) c = tolower(c);

   while (candidate[offset]) {
      if (c == (insensitive ? tolower(candidate[offset]) : candidate[offset]))
         if (stb__match_qstring(candidate+offset+1, qstring, qlen, insensitive))
            return offset;
      ++offset;
   }

   return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x16cf2
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x16cd6
movl $0x0, 0x34(%rsp)
jmp 0x16dd2
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x16cf0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x16dd2
jmp 0x16c8e
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %al
movb %al, 0x17(%rsp)
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x16d29
movsbl 0x17(%rsp), %edi
callq 0x2250
movb %al, 0x17(%rsp)
jmp 0x16d2b
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x16dca
movsbl 0x17(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x16d68
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2250
movl %eax, 0x8(%rsp)
jmp 0x16d7a
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
cmpl %ecx, %eax
jne 0x16dba
movq 0x28(%rsp), %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x16b20
cmpl $0x0, %eax
je 0x16db8
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x16dd2
jmp 0x16dba
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x16d2b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__wildmatch_raw
int stb__wildmatch_raw(char *expr, char *candidate, int search, int insensitive)
{
   char buffer[256];
   // handle multiple search strings
   char *s = strchr(expr, ';');
   char *last = expr;
   while (s) {
      int z;
      // need to allow for non-writeable strings... assume they're small
      if (s - last < 256) {
         stb_strncpy(buffer, last, s-last+1);
         z = stb__wildmatch_raw2(buffer, candidate, search, insensitive);
      } else {
         *s = 0;
         z = stb__wildmatch_raw2(last, candidate, search, insensitive);
         *s = ';';
      }
      if (z >= 0) return z;
      last = s+1;
      s = strchr(last, ';');
   }
   return stb__wildmatch_raw2(last, candidate, search, insensitive);
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movl %edx, 0x12c(%rsp)
movl %ecx, 0x128(%rsp)
movq 0x138(%rsp), %rdi
movl $0x3b, %esi
callq 0x2110
movq %rax, 0x18(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x16f01
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0x16e92
leaq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, %edx
callq 0x52c0
leaq 0x20(%rsp), %rdi
movq 0x130(%rsp), %rsi
movl 0x12c(%rsp), %edx
movl 0x128(%rsp), %ecx
callq 0x166e0
movl %eax, 0xc(%rsp)
jmp 0x16ec6
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rdi
movq 0x130(%rsp), %rsi
movl 0x12c(%rsp), %edx
movl 0x128(%rsp), %ecx
callq 0x166e0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movb $0x3b, (%rax)
cmpl $0x0, 0xc(%rsp)
jl 0x16eda
movl 0xc(%rsp), %eax
movl %eax, 0x144(%rsp)
jmp 0x16f28
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3b, %esi
callq 0x2110
movq %rax, 0x18(%rsp)
jmp 0x16e29
movq 0x10(%rsp), %rdi
movq 0x130(%rsp), %rsi
movl 0x12c(%rsp), %edx
movl 0x128(%rsp), %ecx
callq 0x166e0
movl %eax, 0x144(%rsp)
movl 0x144(%rsp), %eax
addq $0x148, %rsp            # imm = 0x148
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_regex_matcher
stb_matcher *stb_regex_matcher(char *regex)
{
   char *z;
   stb_uint16 end;
   stb_matcher *matcher = stb__alloc_matcher();
   if (*regex == '^') {
      matcher->match_start = 1;
      ++regex;
   }

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

   if (!z || *z) {
      stb_free(matcher);
      return NULL;
   }

   ((matcher->nodes)[(int) end]).goal = STB__NFA_STOP_GOAL;

   return matcher;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
callq 0x170e0
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5e, %eax
jne 0x17068
movq (%rsp), %rax
movl $0x1, 0x14(%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
movq (%rsp), %rax
movzwl (%rax), %esi
movq 0x18(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x17180
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1709c
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x170b0
movq (%rsp), %rdi
callq 0x6e60
movq $0x0, 0x20(%rsp)
jmp 0x170d5
movq (%rsp), %rax
movq 0x18(%rax), %rax
movzwl 0xe(%rsp), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__alloc_matcher
static stb_matcher *stb__alloc_matcher(void)
{
   stb_matcher *matcher = (stb_matcher *) stb_malloc(0,sizeof(*matcher));

   matcher->start_node  = 0;
   stb_arr_malloc((void **) &matcher->nodes, matcher);
   matcher->num_charset = 0;
   matcher->match_start = 0;
   matcher->does_lex    = 0;

   matcher->dfa_start   = STB__DFA_UNDEF;
   stb_arr_malloc((void **) &matcher->dfa, matcher);
   stb_arr_malloc((void **) &matcher->dfa_mapping, matcher);
   stb_arr_malloc((void **) &matcher->dfa_result, matcher);

   stb__add_node(matcher);

   return matcher;
}

// Assembly:
pushq %rax
xorl %eax, %eax
movl %eax, %edi
movl $0x48, %esi
callq 0x75b0
movq %rax, (%rsp)
movq (%rsp), %rax
movw $0x0, (%rax)
movq (%rsp), %rdi
addq $0x18, %rdi
movq (%rsp), %rsi
callq 0x7bc0
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq (%rsp), %rax
movw $0xffff, 0x2(%rax)      # imm = 0xFFFF
movq (%rsp), %rdi
addq $0x28, %rdi
movq (%rsp), %rsi
callq 0x7bc0
movq (%rsp), %rdi
addq $0x30, %rdi
movq (%rsp), %rsi
callq 0x7bc0
movq (%rsp), %rdi
addq $0x38, %rdi
movq (%rsp), %rsi
callq 0x7bc0
movq (%rsp), %rdi
callq 0x1d950
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__reg_parse_alt
static char *stb__reg_parse_alt(stb_matcher *matcher, int start, char *regex, stb_uint16 *end)
{
   stb_uint16 last_end = start;
   stb_uint16 main_end;

   int head, tail;

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

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

   main_end = last_end;
   tail = stb__add_node(matcher);

   stb__add_epsilon(matcher, last_end, tail);

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

   *end = tail;
   return regex;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x24(%rsp), %eax
movw %ax, 0xe(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1d950
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x1daa0
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x1dca0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x171f3
movq $0x0, 0x30(%rsp)
jmp 0x17339
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1720d
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x17229
movw 0xe(%rsp), %cx
movq 0x10(%rsp), %rax
movw %cx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x17339
movw 0xe(%rsp), %ax
movw %ax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1d950
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movzwl 0xe(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x1daa0
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x3(%rsp)
je 0x17279
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x17286
jmp 0x17320
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x17295
jmp 0x172b4
leaq 0x8e20(%rip), %rdi      # 0x200bc
leaq 0x80e6(%rip), %rsi      # 0x1f389
movl $0x245a, %edx           # imm = 0x245A
leaq 0x8e1b(%rip), %rcx      # 0x200ca
callq 0x2140
movq 0x28(%rsp), %rdi
callq 0x1d950
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x1daa0
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
leaq 0xe(%rsp), %rcx
callq 0x1dca0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x17308
movq $0x0, 0x30(%rsp)
jmp 0x17339
movq 0x28(%rsp), %rdi
movzwl 0xe(%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x1daa0
jmp 0x17254
movl 0x4(%rsp), %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, (%rax)
movq 0x18(%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_lex_matcher
stb_matcher *stb_lex_matcher(void)
{
   stb_matcher *matcher = stb__alloc_matcher();

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

   return matcher;
}

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

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

   if (z == NULL)
      return 0;

   stb__lex_reset(matcher);

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movzwl (%rax), %esi
movq 0x20(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x17180
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x173c5
movl $0x0, 0x34(%rsp)
jmp 0x173f9
movq 0x28(%rsp), %rdi
callq 0x17410
movl 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movzwl 0xe(%rsp), %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__lex_reset
static void stb__lex_reset(stb_matcher *matcher)
{
   // flush cached dfa data
   stb_arr_setlen(matcher->dfa, 0);
   stb_arr_setlen(matcher->dfa_mapping, 0);
   stb_arr_setlen(matcher->dfa_result, 0);
   matcher->dfa_start = STB__DFA_UNDEF;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x28, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x7fb0
movq (%rsp), %rdi
addq $0x30, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x7fb0
movq (%rsp), %rdi
addq $0x38, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x7fb0
movq (%rsp), %rax
movw $0xffff, 0x2(%rax)      # imm = 0xFFFF
popq %rax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lex_item_wild
int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result)
{
   char *z;
   stb_uint16 end;

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

   if (z == NULL)
      return 0;

   stb__lex_reset(matcher);

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movzwl (%rax), %esi
movq 0x20(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x174f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x174a5
movl $0x0, 0x34(%rsp)
jmp 0x174d9
movq 0x28(%rsp), %rdi
callq 0x17410
movl 0x1c(%rsp), %eax
movw %ax, %cx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movzwl 0xe(%rsp), %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_if_inactive
static stb_uint16 * stb__add_if_inactive(stb_matcher *m, stb_uint16 *list, int n)
{
   if (!m->nodes[n].active) {
      stb_arr_push(list, n);
      m->nodes[n].active = 1;
   }
   return list;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpb $0x0, 0x2(%rax)
jne 0x17da8
movl 0x24(%rsp), %eax
movw %ax, 0x22(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x17cf0
movq 0x28(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x17cf8
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x17cf8
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x17d19
movq 0x28(%rsp), %rax
movl -0xc(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x17d21
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x17d21
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jle 0x17d43
leaq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x17d51
movq 0x28(%rsp), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x17d71
movq 0x28(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x17d79
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x17d79
movq 0x8(%rsp), %rax
movw 0x22(%rsp), %dx
movl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movw %dx, -0x2(%rax,%rcx,2)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x2(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__eps_closure
static stb_uint16 * stb__eps_closure(stb_matcher *m, stb_uint16 *list)
{
   int i,n = stb_arr_len(list);

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

   return list;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x17de4
movq 0x28(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x17dec
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x17dec
movl 0xc(%rsp), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x17edf
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x24(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x17ecd
cmpq $0x0, 0x18(%rsp)
je 0x17e56
movq 0x18(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x17e5e
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x17e5e
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x17ea7
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzwl (%rax,%rcx,2), %edx
callq 0x17ca0
movq %rax, 0x28(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x17e6e
cmpq $0x0, 0x28(%rsp)
je 0x17ebd
movq 0x28(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x17ec5
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x17ec5
movl 0x4(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x17ecf
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x17dfc
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_decompress_fromfile
char *stb_decompress_fromfile(char *filename, unsigned int *len)
{
   unsigned int n;
   char *q;
   unsigned char *p;
   FILE *f = fopen(filename, "rb");   if (f == NULL) return NULL;
   fseek(f, 0, SEEK_END);
   n = ftell(f);
   fseek(f, 0, SEEK_SET);
   p = (unsigned char * ) malloc(n); if (p == NULL) return NULL;
   fread(p, 1, n, f);
   fclose(f);
   if (p == NULL) return NULL;
   if (p[0] != 0x57 || p[1] != 0xBc || p[2] || p[3]) { free(p); return NULL; }
   q = (char *) malloc(stb_decompress_length(p)+1);
   if (!q) { free(p); return NULL; }
   *len = stb_decompress((unsigned char *) q, p, n);
   if (*len) q[*len] = 0;
   free(p);
   return q;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x58fa(%rip), %rsi      # 0x1f6d4
callq 0x22f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x19df8
movq $0x0, 0x30(%rsp)
jmp 0x19f57
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x22a0
movq (%rsp), %rdi
callq 0x2200
movl %eax, 0x1c(%rsp)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22a0
movl 0x1c(%rsp), %eax
movl %eax, %edi
callq 0x2260
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x19e4c
movq $0x0, 0x30(%rsp)
jmp 0x19f57
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %edx
movq (%rsp), %rcx
movl $0x1, %esi
callq 0x20b0
movq (%rsp), %rdi
callq 0x20d0
cmpq $0x0, 0x8(%rsp)
jne 0x19e84
movq $0x0, 0x30(%rsp)
jmp 0x19f57
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x57, %eax
jne 0x19ebd
movq 0x8(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xbc, %eax
jne 0x19ebd
movq 0x8(%rsp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x19ebd
movq 0x8(%rsp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
je 0x19ed5
movq 0x8(%rsp), %rdi
callq 0x23c0
movq $0x0, 0x30(%rsp)
jmp 0x19f57
movq 0x8(%rsp), %rdi
callq 0x19750
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2260
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x19f0d
movq 0x8(%rsp), %rdi
callq 0x23c0
movq $0x0, 0x30(%rsp)
jmp 0x19f57
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x19790
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x19f43
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rdi
callq 0x23c0
movq 0x10(%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_compress
stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
{
   stb__out = out;
   stb__outfile = NULL;

   stb_compress_inner(input, length);

   return stb__out - out;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x11fca(%rip)     # 0x2bfc8
movq $0x0, 0x11fc7(%rip) # 0x2bfd0
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x1a030
movq 0x11faa(%rip), %rax     # 0x2bfc8
movq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_inner
static int stb_compress_inner(stb_uchar *input, stb_uint length)
{
   int literals = 0;
   stb_uint len,i;

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

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

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

   stb__running_adler = 1;

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

   outliterals(input+length - literals, literals);

   free(chash);

   stb_out2(0x05fa); // end opcode

   stb_out4(stb__running_adler);

   return 1; // success
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0xc341(%rip), %eax      # 0x2638c
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2260
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1a070
movl $0x0, 0x34(%rsp)
jmp 0x1a1d7
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0xc30a(%rip), %eax      # 0x2638c
jae 0x1a0a2
movq 0x10(%rsp), %rax
movl 0x18(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1a078
cmpq $0x0, 0x11f1e(%rip)     # 0x2bfc8
je 0x1a0c6
movq 0x11f15(%rip), %rax     # 0x2bfc8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x11f07(%rip)     # 0x2bfc8
movb $0x57, (%rax)
jmp 0x1a0d0
movl $0x57, %edi
callq 0x1eb30
cmpq $0x0, 0x11ef0(%rip)     # 0x2bfc8
je 0x1a0f4
movq 0x11ee7(%rip), %rax     # 0x2bfc8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x11ed9(%rip)     # 0x2bfc8
movb $-0x44, (%rax)
jmp 0x1a0fe
movl $0xbc, %edi
callq 0x1eb30
xorl %edi, %edi
callq 0x1eb60
xorl %edi, %edi
callq 0x1ebe0
movl 0x24(%rsp), %edi
callq 0x1ebe0
movl 0xc26d(%rip), %edi      # 0x26388
callq 0x1ebe0
movl $0x1, 0x12416(%rip)     # 0x2c540
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %eax
addq %rax, %rdx
movl 0x24(%rsp), %ecx
movq 0x10(%rsp), %r9
movl 0xc23d(%rip), %eax      # 0x2638c
subl $0x1, %eax
leaq 0x20(%rsp), %r8
movl %eax, (%rsp)
callq 0x1a620
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jne 0x1a16f
jmp 0x1a18e
leaq 0x612c(%rip), %rdi      # 0x202a2
leaq 0x520c(%rip), %rsi      # 0x1f389
movl $0x2935, %edx           # imm = 0x2935
leaq 0x6127(%rip), %rcx      # 0x202b0
callq 0x2140
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
addq %rax, %rdi
movslq 0x20(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl 0x20(%rsp), %esi
callq 0x1b010
movq 0x10(%rsp), %rdi
callq 0x23c0
movl $0x5fa, %edi            # imm = 0x5FA
callq 0x1eb60
movl 0x12376(%rip), %edi     # 0x2c540
callq 0x1ebe0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_tofile
int stb_compress_tofile(char *filename, char *input, unsigned int length)
{
   //int maxlen = length + 512 + (length >> 2); // total guess
   //char *buffer = (char *) malloc(maxlen);
   //int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
   
   stb__out = NULL;
   stb__outfile = fopen(filename, "wb");
   if (!stb__outfile) return 0;

   stb__outbytes = 0;

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

   fclose(stb__outfile);

   return stb__outbytes;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq $0x0, 0x11dcb(%rip) # 0x2bfc8
movq 0x18(%rsp), %rdi
leaq 0x54ce(%rip), %rsi      # 0x1f6d7
callq 0x22f0
movq %rax, 0x11dbb(%rip)     # 0x2bfd0
cmpq $0x0, 0x11db3(%rip)     # 0x2bfd0
jne 0x1a229
movl $0x0, 0x24(%rsp)
jmp 0x1a266
movl $0x0, 0x11da5(%rip)     # 0x2bfd8
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1a030
cmpl $0x0, %eax
jne 0x1a250
movl $0x0, 0x24(%rsp)
jmp 0x1a266
movq 0x11d79(%rip), %rdi     # 0x2bfd0
callq 0x20d0
movl 0x11d76(%rip), %eax     # 0x2bfd8
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_intofile
int stb_compress_intofile(FILE *f, char *input, unsigned int length)
{
   //int maxlen = length + 512 + (length >> 2); // total guess
   //char *buffer = (char*)malloc(maxlen);
   //int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
   
   stb__out = NULL;
   stb__outfile = f;
   if (!stb__outfile) return 0;

   stb__outbytes = 0;

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

   return stb__outbytes;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq $0x0, 0x11d3b(%rip) # 0x2bfc8
movq 0x18(%rsp), %rax
movq %rax, 0x11d37(%rip)     # 0x2bfd0
cmpq $0x0, 0x11d2f(%rip)     # 0x2bfd0
jne 0x1a2ad
movl $0x0, 0x24(%rsp)
jmp 0x1a2de
movl $0x0, 0x11d21(%rip)     # 0x2bfd8
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1a030
cmpl $0x0, %eax
jne 0x1a2d4
movl $0x0, 0x24(%rsp)
jmp 0x1a2de
movl 0x11cfe(%rip), %eax     # 0x2bfd8
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: outliterals
static void outliterals(stb_uchar *in, int numlit)
{
   while (numlit > 65536) {
      outliterals(in,65536);
      in     += 65536;
      numlit -= 65536;
   }

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

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x10000, 0xc(%rsp)     # imm = 0x10000
jle 0x1b055
movq 0x10(%rsp), %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x1b010
movq 0x10(%rsp), %rax
addq $0x10000, %rax          # imm = 0x10000
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, 0xc(%rsp)
jmp 0x1b01d
cmpl $0x0, 0xc(%rsp)
jne 0x1b05e
jmp 0x1b0dc
cmpl $0x20, 0xc(%rsp)
jg 0x1b0a8
cmpq $0x0, 0x10f5b(%rip)     # 0x2bfc8
je 0x1b094
movl 0xc(%rsp), %eax
addl $0x20, %eax
subl $0x1, %eax
movb %al, %cl
movq 0x10f46(%rip), %rax     # 0x2bfc8
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10f38(%rip)     # 0x2bfc8
movb %cl, (%rax)
jmp 0x1b0a6
movl 0xc(%rsp), %eax
addl $0x20, %eax
subl $0x1, %eax
movzbl %al, %edi
callq 0x1eb30
jmp 0x1b0da
cmpl $0x800, 0xc(%rsp)       # imm = 0x800
jg 0x1b0c6
movl 0xc(%rsp), %edi
addl $0x800, %edi            # imm = 0x800
subl $0x1, %edi
callq 0x1eb60
jmp 0x1b0d8
movl 0xc(%rsp), %edi
addl $0x70000, %edi          # imm = 0x70000
subl $0x1, %edi
callq 0x1edb0
jmp 0x1b0da
jmp 0x1b0dc
cmpq $0x0, 0x10ee4(%rip)     # 0x2bfc8
je 0x1b116
movq 0x10edb(%rip), %rdi     # 0x2bfc8
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x2230
movl 0xc(%rsp), %ecx
movq 0x10ec1(%rip), %rax     # 0x2bfc8
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10eb4(%rip)     # 0x2bfc8
jmp 0x1b131
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rdx
movq 0x10ea9(%rip), %rcx     # 0x2bfd0
movl $0x1, %esi
callq 0x2370
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_stream_start
int stb_compress_stream_start(FILE *f)
{
   stb__out = NULL;
   stb__outfile = f;

   if (f == NULL)
      return 0;

   if (!stb_compress_streaming_start())
      return 0;

   return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10e74(%rip) # 0x2bfc8
movq 0x8(%rsp), %rax
movq %rax, 0x10e70(%rip)     # 0x2bfd0
cmpq $0x0, 0x8(%rsp)
jne 0x1b172
movl $0x0, 0x14(%rsp)
jmp 0x1b18e
callq 0x1b1a0
cmpl $0x0, %eax
jne 0x1b186
movl $0x0, 0x14(%rsp)
jmp 0x1b18e
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_streaming_start
static int stb_compress_streaming_start(void)
{
   stb_uint i;
   xtb.size = stb__window * 3;
   xtb.buffer = (stb_uchar*)malloc(xtb.size);
   if (!xtb.buffer) return 0;

   xtb.chash = (stb_uchar**)malloc(sizeof(*xtb.chash) * stb__hashsize);
   if (!xtb.chash) {
      free(xtb.buffer);
      return 0;
   }

   for (i=0; i < stb__hashsize; ++i)
      xtb.chash[i] = NULL;

   xtb.hashmask = stb__hashsize-1;

   xtb.valid        = 0;
   xtb.start        = 0;
   xtb.window       = stb__window;
   xtb.fsize        = stb__window;
   xtb.pending_literals = 0;
   xtb.total_bytes  = 0;

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

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

   xtb.length_id = stb_out_backpatch_id();
   stb_out4(0);       // we don't know the output length yet

   stb_out4(stb__window);

   stb__running_adler = 1;

   return 1;
}

// Assembly:
pushq %rax
imull $0x3, 0xb1e0(%rip), %eax # 0x26388
movl %eax, 0x10e3a(%rip)     # 0x2bfe8
movslq 0x10e33(%rip), %rdi     # 0x2bfe8
callq 0x2260
movq %rax, 0x10e1f(%rip)     # 0x2bfe0
cmpq $0x0, 0x10e17(%rip)     # 0x2bfe0
jne 0x1b1d8
movl $0x0, 0x4(%rsp)
jmp 0x1b32a
movl 0xb1ae(%rip), %eax      # 0x2638c
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2260
movq %rax, 0x10e18(%rip)     # 0x2c008
cmpq $0x0, 0x10e10(%rip)     # 0x2c008
jne 0x1b213
movq 0x10ddf(%rip), %rdi     # 0x2bfe0
callq 0x23c0
movl $0x0, 0x4(%rsp)
jmp 0x1b32a
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0xb169(%rip), %eax      # 0x2638c
jae 0x1b242
movq 0x10ddc(%rip), %rax     # 0x2c008
movl (%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1b21a
movl 0xb144(%rip), %eax      # 0x2638c
subl $0x1, %eax
movl %eax, 0x10dbf(%rip)     # 0x2c010
movl $0x0, 0x10d91(%rip)     # 0x2bfec
movl $0x0, 0x10d8b(%rip)     # 0x2bff0
movl 0xb11d(%rip), %eax      # 0x26388
movl %eax, 0x10d83(%rip)     # 0x2bff4
movl 0xb111(%rip), %eax      # 0x26388
movl %eax, 0x10d7b(%rip)     # 0x2bff8
movl $0x0, 0x10d75(%rip)     # 0x2bffc
movl $0x0, 0x10d73(%rip)     # 0x2c004
cmpq $0x0, 0x10d2f(%rip)     # 0x2bfc8
je 0x1b2b5
movq 0x10d26(%rip), %rax     # 0x2bfc8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10d18(%rip)     # 0x2bfc8
movb $0x57, (%rax)
jmp 0x1b2bf
movl $0x57, %edi
callq 0x1eb30
cmpq $0x0, 0x10d01(%rip)     # 0x2bfc8
je 0x1b2e3
movq 0x10cf8(%rip), %rax     # 0x2bfc8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10cea(%rip)     # 0x2bfc8
movb $-0x44, (%rax)
jmp 0x1b2ed
movl $0xbc, %edi
callq 0x1eb30
xorl %edi, %edi
callq 0x1eb60
xorl %edi, %edi
callq 0x1ebe0
callq 0x1ee70
movl %eax, 0x10cfa(%rip)     # 0x2c000
xorl %edi, %edi
callq 0x1ebe0
movl 0xb075(%rip), %edi      # 0x26388
callq 0x1ebe0
movl $0x1, 0x1121e(%rip)     # 0x2c540
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_streaming_end
static int stb_compress_streaming_end(void)
{
   // flush out any remaining data
   stb_compress_chunk(xtb.buffer, xtb.buffer+xtb.start, xtb.buffer+xtb.valid,
                      xtb.valid-xtb.start, &xtb.pending_literals, xtb.chash, xtb.hashmask);

   // write out pending literals
   outliterals(xtb.buffer + xtb.valid - xtb.pending_literals, xtb.pending_literals);

   stb_out2(0x05fa); // end opcode
   stb_out4(stb__running_adler);

   stb_out_backpatch(xtb.length_id, xtb.total_bytes);

   free(xtb.buffer);
   free(xtb.chash);
   return 1;
}

// Assembly:
pushq %rax
movq 0x10c78(%rip), %rdi     # 0x2bfe0
movq 0x10c71(%rip), %rsi     # 0x2bfe0
movslq 0x10c7a(%rip), %rax     # 0x2bff0
addq %rax, %rsi
movq 0x10c60(%rip), %rdx     # 0x2bfe0
movslq 0x10c65(%rip), %rax     # 0x2bfec
addq %rax, %rdx
movl 0x10c5c(%rip), %ecx     # 0x2bfec
subl 0x10c5a(%rip), %ecx     # 0x2bff0
movq 0x10c6b(%rip), %r9      # 0x2c008
movl 0x10c6d(%rip), %eax     # 0x2c010
leaq 0x10c36(%rip), %r8      # 0x2bfe0
addq $0x1c, %r8
movl %eax, (%rsp)
callq 0x1a620
movq 0x10c23(%rip), %rdi     # 0x2bfe0
movslq 0x10c28(%rip), %rax     # 0x2bfec
addq %rax, %rdi
movslq 0x10c2e(%rip), %rcx     # 0x2bffc
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl 0x10c20(%rip), %esi     # 0x2bffc
callq 0x1b010
movl $0x5fa, %edi            # imm = 0x5FA
callq 0x1eb60
movl 0x1114f(%rip), %edi     # 0x2c540
callq 0x1ebe0
movslq 0x10c03(%rip), %rdi     # 0x2c000
movl 0x10c01(%rip), %esi     # 0x2c004
callq 0x1eea0
movq 0x10bd1(%rip), %rdi     # 0x2bfe0
callq 0x23c0
movq 0x10bed(%rip), %rdi     # 0x2c008
callq 0x23c0
movl $0x1, %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_openf
stbfile *stb_openf(FILE *f)
{
   stbfile m = { stb__fgetbyte, stb__fgetdata,
                 stb__fputbyte, stb__fputdata,
                 stb__fsize, stb__ftell, stb__fbackpatch, stb__fclose,
                 0,0,0, };
   stbfile *z = (stbfile *) malloc(sizeof(*z));
   if (z) {
      *z = m;
      z->f = f;
   }
   return z;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0xa703(%rip), %rsi      # 0x25c98
movl $0x68, %edx
callq 0x2230
movl $0x68, %edi
callq 0x2260
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1b5d4
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x68, %edx
callq 0x2230
movq 0x70(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_open_inbuffer
stbfile *stb_open_inbuffer(void *buffer, unsigned int len)
{
   stbfile m = { stb__bgetbyte, stb__bgetdata,
                 stb__noputbyte, stb__noputdata,
                 stb__bsize, stb__btell, stb__nobackpatch, stb__bclose };
   stbfile *z = (stbfile *) malloc(sizeof(*z));
   if (z) {
      *z = m;
      z->buffer = (unsigned char *) buffer;
      z->indata = z->buffer;
      z->inend = z->indata + len;
   }
   return z;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xa561(%rip), %rsi      # 0x25d00
movl $0x68, %edx
callq 0x2230
movl $0x68, %edi
callq 0x2260
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1b810
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x68, %edx
callq 0x2230
movq 0x80(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rcx
movl 0x7c(%rsp), %eax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__bgetdata
static unsigned int stb__bgetdata(stbfile *s, void *buffer, unsigned int len)
{
   if (s->indata + len > s->inend)
      len = s->inend - s->indata;
   memcpy(buffer, s->indata, len);
   s->indata += len;
   return len;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x4(%rsp), %ecx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jbe 0x1b8b6
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x50(%rcx), %rcx
subq %rcx, %rax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rsi
movl 0x4(%rsp), %eax
movl %eax, %edx
callq 0x2230
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x50(%rax)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_open_inbuffer_free
stbfile *stb_open_inbuffer_free(void *buffer, unsigned int len)
{
   stbfile *z = stb_open_inbuffer(buffer, len);
   if (z)
      z->various = 1; // free
   return z;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1b780
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1ba31
movq (%rsp), %rax
movl $0x1, 0x60(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_open
stbfile *stb_open(char *filename, char *mode)
{
   FILE *f = stb_fopen(filename, mode[0] == 'k' ? mode+1 : mode);
   stbfile *s;
   if (f == NULL) return NULL;
   s = stb_openf(f);
   if (s) {
      s->close = stb__fclose2;
      s->various = mode[0] == 'k' ? stb_keep_if_different : stb_keep_yes;
   }
   return s;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x6b, %eax
jne 0x1ba74
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1ba7d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xd350
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1baa3
movq $0x0, 0x30(%rsp)
jmp 0x1baf4
movq 0x18(%rsp), %rdi
callq 0x1b580
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1baea
movq 0x10(%rsp), %rax
leaq 0x3a(%rip), %rcx        # 0x1bb00
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
movsbl (%rax), %edx
movl $0x1, %ecx
movl $0x2, %eax
cmpl $0x6b, %edx
cmovel %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_open_outbuffer
stbfile *stb_open_outbuffer(unsigned char **update_on_close)
{
   stbfile m = { stb__nogetbyte, stb__nogetdata,
                 stb__aputbyte, stb__aputdata,
                 stb__asize, stb__asize, stb__abackpatch, stb__aclose };
   stbfile *z = (stbfile *) malloc(sizeof(*z));
   if (z) {
      z->ptr = update_on_close;
      *z = m;
   }
   return z;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0xa233(%rip), %rsi      # 0x25d68
movl $0x68, %edx
callq 0x2230
movl $0x68, %edi
callq 0x2260
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1bb74
movq 0x70(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x60(%rax)
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x68, %edx
callq 0x2230
movq (%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_init_encode
void stb_arith_init_encode(stb_arith *a, stbfile *out)
{
   a->range_low = 0;
   a->range_high = 0xffffffff;
   a->pending_ffs = -1; // means no buffered character currently, to speed up normal case
   a->output = out;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopl (%rax)