LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__lex_reset
static void stb__lex_reset(stb_matcher *matcher)
{
   // flush cached dfa data
   stb_arr_setlen(matcher->dfa, 0);
   stb_arr_setlen(matcher->dfa_mapping, 0);
   stb_arr_setlen(matcher->dfa_result, 0);
   matcher->dfa_start = STB__DFA_UNDEF;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x5206
leaq 0x30(%rbx), %rdi
pushq $0x4
popq %rsi
xorl %edx, %edx
callq 0x5206
leaq 0x38(%rbx), %rdi
pushq $0x2
popq %rsi
xorl %edx, %edx
callq 0x5206
orw $-0x1, 0x2(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_lex_item_wild
int stb_lex_item_wild(stb_matcher *matcher, char *regex, int result)
{
   char *z;
   stb_uint16 end;

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

   if (z == NULL)
      return 0;

   stb__lex_reset(matcher);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r14
movzwl (%rdi), %ebx
callq 0xf1db
movl %eax, %r15d
movzwl %r15w, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0xf253
pushq $-0x1
popq %rbp
movl %r15d, %r13d
movzbl (%r12), %ebx
movq %r14, %rdi
callq 0xf1db
movl %eax, %r15d
cmpl $0x2a, %ebx
je 0xc2fd
cmpl $0x3f, %ebx
je 0xc2ea
testl %ebx, %ebx
je 0xc365
callq 0x2030
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movsbq (%r12), %rbp
movl (%rax,%rbp,4), %ebx
callq 0x23a0
movq (%rax), %rax
movl (%rax,%rbp,4), %ecx
cmpl %ecx, %ebx
jne 0xc32c
movzwl %r13w, %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
jmp 0xc355
movzwl %r13w, %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xf647
jmp 0xc35d
movzwl %r13w, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xf647
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0xf253
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0xf253
jmp 0xc35d
movzwl %r13w, %ebp
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xf647
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbq (%r12), %rcx
movl (%rax,%rcx,4), %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xf647
pushq $-0x1
popq %rbp
incq %r12
jmp 0xc293
movl $0xffff, %ebx           # imm = 0xFFFF
andl %ebx, %r13d
movq %r14, %rdi
movl %r13d, %esi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0xf647
movq %r14, %rdi
callq 0xc228
movq 0x18(%r14), %rax
andl %ebx, %r15d
imulq $0x18, %r15, %rcx
movl 0xc(%rsp), %edx
movw %dx, (%rax,%rcx)
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_if_inactive
static stb_uint16 * stb__add_if_inactive(stb_matcher *m, stb_uint16 *list, int n)
{
   if (!m->nodes[n].active) {
      stb_arr_push(list, n);
      m->nodes[n].active = 1;
   }
   return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x18(%rdi), %rcx
movl %edx, %edx
imulq $0x18, %rdx, %r12
cmpb $0x0, 0x2(%rcx,%r12)
jne 0xc6ea
movq %rdi, %r14
testq %rax, %rax
je 0xc6c3
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xc6c3
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xc6d7
movq %rsp, %r15
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x521e
movq (%r15), %rax
movslq -0x10(%rax), %rcx
movw %bx, -0x2(%rax,%rcx,2)
movq 0x18(%r14), %rcx
movb $0x1, 0x2(%rcx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x0, %ecx
testq %rsi, %rsi
je 0xc717
movl -0x10(%rax), %ecx
xorl %r15d, %r15d
movslq %ecx, %rdx
cmpq %rdx, %r15
jge 0xc774
movq 0x18(%rbx), %rdx
movzwl (%rax,%r15,2), %esi
imulq $0x18, %rsi, %rsi
movq 0x10(%rdx,%rsi), %r12
testq %r12, %r12
je 0xc76f
movl -0x10(%r12), %r13d
testl %r13d, %r13d
cmovlel %r14d, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0xc761
movzwl (%r12,%rbp,2), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc689
incq %rbp
jmp 0xc747
testq %rax, %rax
je 0xc76b
movl -0x10(%rax), %ecx
jmp 0xc76f
xorl %ecx, %ecx
xorl %eax, %eax
incq %r15
jmp 0xc71a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_decompress_fromfile
char *stb_decompress_fromfile(char *filename, unsigned int *len)
{
   unsigned int n;
   char *q;
   unsigned char *p;
   FILE *f = fopen(filename, "rb");   if (f == NULL) return NULL;
   fseek(f, 0, SEEK_END);
   n = ftell(f);
   fseek(f, 0, SEEK_SET);
   p = (unsigned char * ) malloc(n); if (p == NULL) return NULL;
   fread(p, 1, n, f);
   fclose(f);
   if (p == NULL) return NULL;
   if (p[0] != 0x57 || p[1] != 0xBc || p[2] || p[3]) { free(p); return NULL; }
   q = (char *) malloc(stb_decompress_length(p)+1);
   if (!q) { free(p); return NULL; }
   *len = stb_decompress((unsigned char *) q, p, n);
   if (*len) q[*len] = 0;
   free(p);
   return q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x3151(%rip), %rsi      # 0x1076c
callq 0x22f0
testq %rax, %rax
je 0xd6a3
movq %rax, %r13
xorl %r15d, %r15d
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x22a0
movq %r13, %rdi
callq 0x2200
movq %rax, %r12
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22a0
movl %r12d, %ebp
movq %rbp, %rdi
callq 0x2250
testq %rax, %rax
je 0xd6a6
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x20b0
movq %r13, %rdi
callq 0x20d0
cmpb $0x57, (%r14)
jne 0xd696
cmpb $-0x44, 0x1(%r14)
jne 0xd696
cmpb $0x0, 0x2(%r14)
jne 0xd696
cmpb $0x0, 0x3(%r14)
je 0xd6b8
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x23c0
jmp 0xd6a6
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xd2fc
leal 0x1(%rax), %edi
callq 0x2250
testq %rax, %rax
je 0xd696
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0xd302
movl %eax, (%rbx)
testl %eax, %eax
je 0xd699
movl %eax, %eax
movb $0x0, (%r15,%rax)
jmp 0xd699
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress
stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
{
   stb__out = out;
   stb__outfile = NULL;

   stb_compress_inner(input, length);

   return stb__out - out;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rdi, 0x1072a(%rip)     # 0x1de58
andq $0x0, 0x1072a(%rip)     # 0x1de60
movq %rsi, %rdi
movl %edx, %esi
callq 0xd74a
movl 0x10712(%rip), %eax     # 0x1de58
subl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_inner
static int stb_compress_inner(stb_uchar *input, stb_uint length)
{
   int literals = 0;
   stb_uint len,i;

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

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

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

   stb__running_adler = 1;

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

   outliterals(input+length - literals, literals);

   free(chash);

   stb_out2(0x05fa); // end opcode

   stb_out4(stb__running_adler);

   return 1; // success
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %r14
movl 0xaad2(%rip), %r15d     # 0x18234
leaq (,%r15,8), %rdi
callq 0x2250
testq %rax, %rax
je 0xd79c
movq %rax, %rbx
xorl %eax, %eax
cmpq %rax, %r15
je 0xd788
andq $0x0, (%rbx,%rax,8)
incq %rax
jmp 0xd779
movq 0x106c9(%rip), %rax     # 0x1de58
testq %rax, %rax
je 0xd7a3
movb $0x57, (%rax)
incq %rax
jmp 0xd7bb
xorl %eax, %eax
jmp 0xd84c
pushq $0x57
popq %rdi
callq 0xf804
movq 0x106a6(%rip), %rax     # 0x1de58
testq %rax, %rax
je 0xd857
leaq 0x1(%rax), %rcx
movq %rcx, 0x10692(%rip)     # 0x1de58
movb $-0x44, (%rax)
xorl %edi, %edi
callq 0xf819
xorl %edi, %edi
callq 0xf85d
movl %ebp, %edi
callq 0xf85d
movl 0xaa4c(%rip), %edi      # 0x18230
callq 0xf85d
movl $0x1, 0x10bdd(%rip)     # 0x1e3d0
movl %ebp, %r15d
addq %r14, %r15
movl 0xaa34(%rip), %r9d      # 0x18234
decl %r9d
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %r8
callq 0xdb3d
cmpl %ebp, %eax
jne 0xd866
movslq 0x4(%rsp), %rsi
subq %rsi, %r15
movq %r15, %rdi
callq 0xe1bd
movq %rbx, %rdi
callq 0x23c0
movl $0x5fa, %edi            # imm = 0x5FA
callq 0xf819
movl 0x10b8c(%rip), %edi     # 0x1e3d0
callq 0xf85d
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xbc, %edi
callq 0xf804
jmp 0xd7c9
leaq 0x3a90(%rip), %rdi      # 0x112fd
leaq 0x2bad(%rip), %rsi      # 0x10421
leaq 0x3a90(%rip), %rcx      # 0x1130b
movl $0x2935, %edx           # imm = 0x2935
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_tofile
int stb_compress_tofile(char *filename, char *input, unsigned int length)
{
   //int maxlen = length + 512 + (length >> 2); // total guess
   //char *buffer = (char *) malloc(maxlen);
   //int blen = stb_compress((stb_uchar*)buffer, (stb_uchar*)input, length);
   
   stb__out = NULL;
   stb__outfile = fopen(filename, "wb");
   if (!stb__outfile) return 0;

   stb__outbytes = 0;

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

   fclose(stb__outfile);

   return stb__outbytes;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
andq $0x0, 0x105c2(%rip)     # 0x1de58
leaq 0x2ed2(%rip), %rsi      # 0x1076f
callq 0x22f0
movq %rax, 0x105b7(%rip)     # 0x1de60
xorl %ebx, %ebx
testq %rax, %rax
je 0xd8d7
andl $0x0, 0x105b1(%rip)     # 0x1de68
movq %r14, %rdi
movl %ebp, %esi
callq 0xd74a
testl %eax, %eax
je 0xd8d7
movq 0x10594(%rip), %rdi     # 0x1de60
callq 0x20d0
movl 0x10591(%rip), %ebx     # 0x1de68
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x10572(%rip)     # 0x1de58
movq %rdi, 0x10573(%rip)     # 0x1de60
testq %rdi, %rdi
je 0xd914
pushq %rax
andl $0x0, 0x1056e(%rip)     # 0x1de68
movq %rsi, %rdi
movl %edx, %esi
callq 0xd74a
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0xd913
movl 0x10555(%rip), %eax     # 0x1de68
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: outliterals
static void outliterals(stb_uchar *in, int numlit)
{
   while (numlit > 65536) {
      outliterals(in,65536);
      in     += 65536;
      numlit -= 65536;
   }

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
xorl %r12d, %r12d
movl %esi, %ebp
leaq (%r15,%r12), %r14
cmpl $0x10001, %ebp          # imm = 0x10001
jl 0xe1f7
movq %r14, %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0xe1bd
addl $0xffff0000, %ebp       # imm = 0xFFFF0000
addq $0x10000, %r12          # imm = 0x10000
jmp 0xe1cf
cmpl %r12d, %ebx
jne 0xe228
movq 0xfc55(%rip), %r15      # 0x1de58
testq %r15, %r15
jne 0xe243
movslq %ebx, %rdx
subq %r12, %rdx
movq 0xfc4b(%rip), %rcx      # 0x1de60
pushq $0x1
popq %rsi
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2370
cmpl $0x20, %ebp
jg 0xe26d
movq 0xfc24(%rip), %r15      # 0x1de58
addb $0x1f, %bpl
testq %r15, %r15
je 0xe29a
movb %bpl, (%r15)
incq %r15
movslq %ebx, %rbx
movq %rbx, %rdx
subq %r12, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2230
addq %rbx, %r15
subq %r12, %r15
movq %r15, 0xfbf4(%rip)      # 0x1de58
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
subl %r12d, %edi
cmpl $0x800, %ebp            # imm = 0x800
ja 0xe28a
addl $0x7ff, %edi            # imm = 0x7FF
callq 0xf819
jmp 0xe1fc
addl $0x6ffff, %edi          # imm = 0x6FFFF
callq 0xf92c
jmp 0xe1fc
movzbl %bpl, %edi
callq 0xf804
jmp 0xe1fc
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_compress_stream_start
int stb_compress_stream_start(FILE *f)
{
   stb__out = NULL;
   stb__outfile = f;

   if (f == NULL)
      return 0;

   if (!stb_compress_streaming_start())
      return 0;

   return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
andq $0x0, 0xfba0(%rip)      # 0x1de58
movq %rdi, 0xfba1(%rip)      # 0x1de60
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xe3dc
movslq 0x9f5f(%rip), %r15      # 0x18230
leaq (%r15,%r15,2), %rdi
movl %edi, 0xfb9d(%rip)      # 0x1de78
callq 0x2250
movq %rax, 0xfb89(%rip)      # 0x1de70
testq %rax, %rax
je 0xe3dc
movq %rax, %r14
movl 0x9f3a(%rip), %r12d     # 0x18234
leaq (,%r12,8), %rdi
callq 0x2250
movq %rax, 0xfb8a(%rip)      # 0x1de98
testq %rax, %rax
je 0xe37d
xorl %eax, %eax
cmpq %rax, %r12
je 0xe32b
movq 0xfb77(%rip), %rcx      # 0x1de98
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0xe315
decl %r12d
movl %r12d, 0xfb6b(%rip)     # 0x1dea0
andq $0x0, 0xfb3f(%rip)      # 0x1de7c
movl %r15d, 0xfb40(%rip)     # 0x1de84
movl %r15d, 0xfb3d(%rip)     # 0x1de88
andl $0x0, 0xfb3a(%rip)      # 0x1de8c
andl $0x0, 0xfb3b(%rip)      # 0x1de94
pushq $0x57
popq %rdi
callq 0xf804
movq 0xfaf0(%rip), %rax      # 0x1de58
testq %rax, %rax
je 0xe387
leaq 0x1(%rax), %rcx
movq %rcx, 0xfae0(%rip)      # 0x1de58
movb $-0x44, (%rax)
jmp 0xe391
movq %r14, %rdi
callq 0x23c0
jmp 0xe3dc
movl $0xbc, %edi
callq 0xf804
xorl %edi, %edi
callq 0xf819
xorl %edi, %edi
callq 0xf85d
movq 0xfab2(%rip), %rax      # 0x1de58
testq %rax, %rax
jne 0xe3b7
movq 0xfaae(%rip), %rdi      # 0x1de60
callq 0x2200
movl %eax, 0xfad3(%rip)      # 0x1de90
xorl %edi, %edi
callq 0xf85d
movl 0x9e66(%rip), %edi      # 0x18230
callq 0xf85d
movl $0x1, 0xfff7(%rip)      # 0x1e3d0
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
pushq $0x68
popq %rdi
callq 0x2250
testq %rax, %rax
je 0xe569
leaq 0x973c(%rip), %rsi      # 0x17c98
pushq $0xd
popq %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, 0x40(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x68
popq %rdi
callq 0x2250
testq %rax, %rax
je 0xe644
leaq 0x96d6(%rip), %rsi      # 0x17d00
pushq $0xd
popq %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, 0x48(%rax)
movq %rbx, 0x50(%rax)
movl %ebp, %ecx
addq %rbx, %rcx
movq %rcx, 0x58(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
callq 0xe60e
testq %rax, %rax
je 0xe733
movl $0x1, 0x60(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rsi, %rbx
xorl %esi, %esi
cmpb $0x6b, (%rbx)
sete %sil
addq %rbx, %rsi
callq 0x7716
testq %rax, %rax
je 0xe776
movq %rax, %rdi
callq 0xe544
testq %rax, %rax
je 0xe776
leaq 0x17(%rip), %rcx        # 0xe77a
movq %rcx, 0x38(%rax)
xorl %ecx, %ecx
cmpb $0x6b, (%rbx)
sete %cl
incl %ecx
movl %ecx, 0x60(%rax)
jmp 0xe778
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
pushq $0x68
popq %rdi
callq 0x2250
testq %rax, %rax
je 0xe7a7
leaq 0x95ca(%rip), %rsi      # 0x17d68
pushq $0xd
popq %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_encode
void stb_arith_encode(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq)
{
   unsigned int range = a->range_high - a->range_low;
   unsigned int old = a->range_low;
   range /= totalfreq;
   a->range_low += range * cumfreq;
   a->range_high = a->range_low + range*freq;
   if (a->range_low < old)
      stb__arith_carry(a);
   while (a->range_high - a->range_low < 0x1000000)
      stb__renorm_encoder(a);
}

// Assembly:
pushq %rbx
movl %edx, %r8d
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %eax
subl %edi, %eax
xorl %edx, %edx
divl %esi
imull %eax, %ecx
imull %eax, %r8d
addl %edi, %ecx
movl %ecx, (%rbx)
leal (%rcx,%r8), %eax
movl %eax, 0x4(%rbx)
jae 0xe91a
movq %rbx, %rdi
callq 0xe928
jmp 0xe91a
movq %rbx, %rdi
callq 0xe978
movl 0x4(%rbx), %eax
subl (%rbx), %eax
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
jbe 0xe912
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arith_carry
static void stb__arith_carry(stb_arith *a)
{
   int i;
   assert(a->pending_ffs != -1); // can't carry with no data
   stb_putc(a->output, a->buffered_u8);
   for (i=0; i < a->pending_ffs; ++i)
      stb_putc(a->output, 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $-0x1, 0x14(%rdi)
je 0xe959
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
xorl %ebp, %ebp
cmpl 0x14(%rbx), %ebp
jge 0xe952
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq *0x10(%rdi)
incl %ebp
jmp 0xe940
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2b44(%rip), %rdi      # 0x114a4
leaq 0x1aba(%rip), %rsi      # 0x10421
leaq 0x2b4b(%rip), %rcx      # 0x114b9
movl $0x2b4f, %edx           # imm = 0x2B4F
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_encode_log2
void stb_arith_encode_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq)
{
   unsigned int range = a->range_high - a->range_low;
   unsigned int old = a->range_low;
   range >>= totalfreq2;
   a->range_low += range * cumfreq;
   a->range_high = a->range_low + range*freq;
   if (a->range_low < old)
      stb__arith_carry(a);
   while (a->range_high - a->range_low < 0x1000000)
      stb__renorm_encoder(a);
}

// Assembly:
pushq %rbx
movl %ecx, %eax
movl %esi, %ecx
movq %rdi, %rbx
movl (%rdi), %esi
movl 0x4(%rdi), %edi
subl %esi, %edi
shrl %cl, %edi
imull %edi, %eax
imull %edx, %edi
addl %esi, %eax
movl %eax, (%rbx)
leal (%rax,%rdi), %eax
movl %eax, 0x4(%rbx)
jae 0xe9cd
movq %rbx, %rdi
callq 0xe928
jmp 0xe9cd
movq %rbx, %rdi
callq 0xe978
movl 0x4(%rbx), %eax
subl (%rbx), %eax
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
jbe 0xe9c5
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_decode_advance
void stb_arith_decode_advance(stb_arith *a, unsigned int totalfreq, unsigned int freq, unsigned int cumfreq)
{
   unsigned int freqsize = a->range / totalfreq; // @OPTIMIZE, share with above divide somehow?
   a->code -= freqsize * cumfreq;
   a->range = freqsize * freq;
   while (a->range < 0x1000000)
      stb__renorm_decoder(a);
}

// Assembly:
pushq %rbx
movl %edx, %r8d
movq %rdi, %rbx
movl 0xc(%rdi), %eax
xorl %edx, %edx
divl %esi
imull %eax, %ecx
subl %ecx, 0x8(%rdi)
imull %eax, %r8d
movl %r8d, 0xc(%rdi)
cmpl $0xffffff, %r8d         # imm = 0xFFFFFF
ja 0xea29
movq %rbx, %rdi
callq 0xea2b
movl 0xc(%rbx), %r8d
jmp 0xea12
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_decode_advance_log2
void stb_arith_decode_advance_log2(stb_arith *a, unsigned int totalfreq2, unsigned int freq, unsigned int cumfreq)
{
   unsigned int freqsize = a->range >> totalfreq2;
   a->code -= freqsize * cumfreq;
   a->range = freqsize * freq;
   while (a->range < 0x1000000)
      stb__renorm_decoder(a);
}

// Assembly:
pushq %rbx
movl %ecx, %eax
movl %esi, %ecx
movq %rdi, %rbx
movl 0xc(%rdi), %esi
shrl %cl, %esi
imull %esi, %eax
subl %eax, 0x8(%rdi)
imull %edx, %esi
movl %esi, 0xc(%rdi)
cmpl $0xffffff, %esi         # imm = 0xFFFFFF
ja 0xea93
movq %rbx, %rdi
callq 0xea2b
movl 0xc(%rbx), %esi
jmp 0xea7e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_encode_close
stbfile *stb_arith_encode_close(stb_arith *a)
{
   // put exactly as many bytes as we'll read, so we can turn on/off arithmetic coding in a stream
   stb__arith_putbyte(a, a->range_low >> 24);
   stb__arith_putbyte(a, a->range_low >> 16);
   stb__arith_putbyte(a, a->range_low >>  8);
   stb__arith_putbyte(a, a->range_low >>  0);
   stb__arith_flush(a);
   return a->output;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x3(%rdi), %esi
callq 0xeaf9
movzwl 0x2(%rbx), %esi
movq %rbx, %rdi
callq 0xeaf9
movl (%rbx), %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0xeaf9
movl (%rbx), %esi
movq %rbx, %rdi
callq 0xeaf9
cmpl $0x0, 0x14(%rbx)
js 0xeaee
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
xorl %ebp, %ebp
cmpl 0x14(%rbx), %ebp
jge 0xeaee
movq 0x18(%rbx), %rdi
movl $0xff, %esi
callq *0x10(%rdi)
incl %ebp
jmp 0xead9
movq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arith_putbyte
static void stb__arith_putbyte(stb_arith *a, int byte)
{
   if (a->pending_ffs) {
      if (a->pending_ffs == -1) { // means no buffered data; encoded for fast path efficiency
         if (byte == 0xff)
            stb_putc(a->output, byte); // just write it immediately
         else {
            a->buffered_u8 = byte;
            a->pending_ffs = 0;
         }
      } else if (byte == 0xff) {
         ++a->pending_ffs;
      } else {
         int i;
         stb_putc(a->output, a->buffered_u8);
         for (i=0; i < a->pending_ffs; ++i)
            stb_putc(a->output, 0xff);
      }
   } else if (byte == 0xff) {
      ++a->pending_ffs;
   } else {
      // fast path
      stb_putc(a->output, a->buffered_u8);
      a->buffered_u8 = byte;
   }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x14(%rdi), %eax
testl %eax, %eax
je 0xeb2a
cmpl $-0x1, %eax
jne 0xeb3b
cmpl $0xff, %ebp
jne 0xeb4a
movq 0x18(%rbx), %rdi
movq 0x10(%rdi), %rax
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
cmpl $0xff, %ebp
jne 0xeb53
movl $0x1, 0x14(%rbx)
jmp 0xeb60
cmpl $0xff, %ebp
jne 0xeb67
incl %eax
movl %eax, 0x14(%rbx)
jmp 0xeb60
movl %ebp, 0x10(%rbx)
andl $0x0, 0x14(%rbx)
jmp 0xeb60
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
movl %ebp, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
xorl %ebp, %ebp
cmpl 0x14(%rbx), %ebp
jge 0xeb60
movq 0x18(%rbx), %rdi
movl $0xff, %esi
callq *0x10(%rdi)
incl %ebp
jmp 0xeb73
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb_arith_state_create
stb_arith_symstate *stb_arith_state_create(int num_sym)
{
   stb_arith_symstate *s = (stb_arith_symstate *) malloc(sizeof(*s) + (num_sym-1) * sizeof(s->data[0])); 
   if (s) {
      int i, cf, cf_next, next;
      int start_freq, extra;
      s->num_sym = num_sym;
      s->pow2 = 4;
      while (s->pow2 < 15 && (1 << s->pow2) < 3*num_sym) {
         ++s->pow2;
      }
      start_freq = (1 << s->pow2) / num_sym;
      assert(start_freq >= 1);
      extra = (1 << s->pow2) % num_sym;
      // now set up the initial stats

      if (s->pow2 < POW2_LIMIT)
         next = 0;
      else
         next = 1;

      cf = cf_next = 0;
      for (i=0; i < extra; ++i) {
         s->data[i].cumfreq = cf;
         s->data[i].samples = next;
         cf += start_freq+1;
         cf_next += next;
      }
      for (; i < num_sym; ++i) {
         s->data[i].cumfreq = cf;
         s->data[i].samples = next;
         cf += start_freq;
         cf_next += next;
      }
      assert(cf == (1 << s->pow2));
      // now, how long should we go until we have 2 << s->pow2 samples?
      s->countdown = (2 << s->pow2) - cf - cf_next;
   }
   return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r14
leaq 0xc(,%r14,4), %rdi
callq 0x2250
movq %rax, %rsi
testq %rax, %rax
je 0xec54
movl %ebx, (%rsi)
leal (%rbx,%rbx,2), %eax
pushq $0x3
popq %rcx
pushq $0x1
popq %rdx
incl %ecx
movl %edx, %edi
shll %cl, %edi
cmpl $0xe, %ecx
ja 0xebc9
cmpl %eax, %edi
jl 0xebba
movl %ecx, 0x4(%rsi)
movl %edi, %eax
cltd
idivl %ebx
testl %eax, %eax
jle 0xec5f
xorl %r8d, %r8d
cmpl $0xc, %ecx
setae %r8b
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
movl %eax, %r10d
notl %r10d
leal 0x1(%rax), %r11d
imull %edx, %r10d
addl %edi, %r10d
xorl %ebx, %ebx
cmpq %rbx, %rdx
je 0xec18
movw %r9w, 0xc(%rsi,%rbx,4)
addl %r11d, %r9d
movw %r8w, 0xe(%rsi,%rbx,4)
incq %rbx
jmp 0xebff
xorl %r11d, %r11d
cmpl $0xc, %ecx
cmovael %edx, %r11d
addl %edi, %r11d
cmpq %r14, %rdx
jge 0xec44
movw %r9w, 0xc(%rsi,%rdx,4)
addl %eax, %r9d
movw %r8w, 0xe(%rsi,%rdx,4)
incq %rdx
addl %r8d, %r11d
subl %eax, %r10d
jmp 0xec25
testl %r10d, %r10d
jne 0xec7e
pushq $0x2
popq %rax
shll %cl, %eax
subl %r11d, %eax
movl %eax, 0x8(%rsi)
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x21d0(%rip), %rdi      # 0x10e36
leaq 0x17b4(%rip), %rsi      # 0x10421
leaq 0x21d2(%rip), %rcx      # 0x10e46
movl $0x2be1, %edx           # imm = 0x2BE1
callq 0x2140
leaq 0x21f1(%rip), %rdi      # 0x10e76
leaq 0x1795(%rip), %rsi      # 0x10421
leaq 0x21b3(%rip), %rcx      # 0x10e46
movl $0x2bf7, %edx           # imm = 0x2BF7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__get_sourcefile_path
char *stb__get_sourcefile_path(char *file)
{
   static char filebuf[512];
   if (stb__source_path) {
      sprintf(filebuf, "%s/%s", stb__source_path, file);
      if (stb_fexists(filebuf)) return filebuf;
   }

   if (stb_fexists(file)) return file;

   sprintf(filebuf, "../%s", file);
   if (!stb_fexists(filebuf)) return filebuf;

   return file;      
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf1f0(%rip), %rdx      # 0x1dea8
testq %rdx, %rdx
je 0xece4
leaq 0xf1ec(%rip), %r14      # 0x1deb0
leaq 0x18af(%rip), %rsi      # 0x1057a
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2350
movq %r14, %rdi
callq 0x756b
testl %eax, %eax
jne 0xed1c
movq %rbx, %rdi
callq 0x756b
testl %eax, %eax
jne 0xed19
leaq 0xf1b9(%rip), %r14      # 0x1deb0
leaq 0x218d(%rip), %rsi      # 0x10e8b
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2350
movq %r14, %rdi
callq 0x756b
testl %eax, %eax
cmoveq %r14, %rbx
movq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__sort_chunks
static void stb__sort_chunks(stb__alloc *src)
{
   // of the first two chunks, put the chunk with more data left in it first
   stb__chunk *c = stb__chunks(src), *d;
   if (c == NULL) return;
   d = c->next;
   if (d == NULL) return;
   if (c->data_left > d->data_left) return;

   c->next = d->next;
   d->next = c;
   stb__setchunks(src, d);
}

// Assembly:
movq 0x18(%rdi), %rcx
movq -0x2(%rcx), %rax
testq %rax, %rax
je 0xef0b
movl 0x6(%rcx), %edx
cmpl 0x8(%rax), %edx
jg 0xef0b
addq $-0x2, %rcx
movq (%rax), %rdx
movq %rdx, (%rcx)
movq %rcx, (%rax)
addq $0x2, %rax
movq %rax, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_node
static int stb__add_node(stb_matcher *matcher)
{
   stb_nfa_node z;
   z.active = 0;
   z.eps    = 0;
   z.goal   = 0;
   z.out    = 0;
   stb_arr_push(matcher->nodes, z);
   return stb_arr_len(matcher->nodes)-1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x18, %rbx
testq %rax, %rax
je 0xf1ff
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xf1ff
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xf210
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x521e
movq (%rbx), %rax
movslq -0x10(%rax), %rcx
imulq $0x18, %rcx, %rcx
andw $0x0, -0x18(%rax,%rcx)
movb $0x0, -0x16(%rax,%rcx)
movl 0xb(%rsp), %edx
movl %edx, -0x15(%rax,%rcx)
movb 0xf(%rsp), %dl
movb %dl, -0x11(%rax,%rcx)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%rax,%rcx)
movq (%rbx), %rax
testq %rax, %rax
je 0xf24a
movl -0x10(%rax), %eax
decl %eax
jmp 0xf24d
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_epsilon
static void stb__add_epsilon(stb_matcher *matcher, int from, int to)
{
   assert(from != to);
   if (matcher->nodes[from].eps == NULL)
      stb_arr_malloc((void **) &matcher->nodes[from].eps, matcher);
   stb_arr_push(matcher->nodes[from].eps, to);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl %edx, %esi
je 0xf2ca
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movslq %esi, %rcx
imulq $0x18, %rcx, %r15
leaq (%rax,%r15), %rdi
addq $0x10, %rdi
movq (%rdi), %rax
testq %rax, %rax
jne 0xf298
movq %r14, %rsi
callq 0x5064
movq 0x18(%r14), %rax
leaq (%rax,%r15), %rdi
addq $0x10, %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0xf2a7
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xf2a7
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xf2bb
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x521e
movq 0x18(%r14), %rax
movq 0x10(%rax,%r15), %rax
movslq -0x10(%rax), %rcx
movw %bx, -0x2(%rax,%rcx,2)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e9b(%rip), %rdi      # 0x1116c
leaq 0x1149(%rip), %rsi      # 0x10421
leaq 0x1e98(%rip), %rcx      # 0x11177
movl $0x2399, %edx           # imm = 0x2399
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__add_edge
static void stb__add_edge(stb_matcher *matcher, int from, int to, int type)
{
   stb_nfa_edge z = { type, to };
   if (matcher->nodes[from].out == NULL)
      stb_arr_malloc((void **) &matcher->nodes[from].out, matcher);
   stb_arr_push(matcher->nodes[from].out, z);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movl %esi, %ecx
imulq $0x18, %rcx, %r15
leaq (%rax,%r15), %rdi
addq $0x8, %rdi
movq (%rdi), %rax
testq %rax, %rax
jne 0xf68b
movq %r14, %rsi
callq 0x5064
movq 0x18(%r14), %rax
leaq (%rax,%r15), %rdi
addq $0x8, %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0xf69a
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0xf69a
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0xf6ae
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x521e
movq 0x18(%r14), %rax
movq 0x8(%rax,%r15), %rax
movslq -0x10(%rax), %rcx
movw %bp, -0x4(%rax,%rcx,4)
movw %bx, -0x2(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__clear_goalcheck
static int stb__clear_goalcheck(stb_matcher *m, stb_uint16 *list)
{
   int i, t=0;
   for (i=0; i < stb_arr_len(list); ++i) {
      t += m->nodes[(int) list[i]].goal;
      m->nodes[(int) list[i]].active = 0;
   }
   return t;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
testq %rsi, %rsi
je 0xf6d6
movslq -0x10(%rsi), %rdx
jmp 0xf6d8
xorl %edx, %edx
cmpq %rdx, %rcx
jge 0xf6fd
movq 0x18(%rdi), %rdx
movzwl (%rsi,%rcx,2), %r8d
imulq $0x18, %r8, %r8
movswl (%rdx,%r8), %r9d
addl %r9d, %eax
movb $0x0, 0x2(%rdx,%r8)
incq %rcx
jmp 0xf6cb
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__opt
static int stb__opt(stb_matcher *m, int n)
{
   for(;;) {
      stb_nfa_node *p = &m->nodes[n];
      if (p->goal)                  return n;
      if (stb_arr_len(p->out))      return n;
      if (stb_arr_len(p->eps) != 1) return n;
      n = p->eps[0];
   }
}

// Assembly:
movl %esi, %eax
movq 0x18(%rdi), %rcx
movl %eax, %edx
imulq $0x18, %rdx, %rdx
cmpw $0x0, (%rcx,%rdx)
jne 0xf737
addq %rcx, %rdx
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0xf723
cmpl $0x0, -0x10(%rsi)
jne 0xf737
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0xf737
cmpl $0x1, -0x10(%rdx)
jne 0xf737
movzwl (%rdx), %eax
jmp 0xf704
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__match
static void stb__match(stb_uchar *data, stb_uint length)
{
   // INVERSE of memmove... write each byte before copying the next...
   assert (stb__dout + length <= stb__barrier);
   if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
   if (data < stb__barrier4) { stb__dout = stb__barrier+1; return; }
   while (length--) *stb__dout++ = *data++;
}

// Assembly:
pushq %rax
movq 0xe710(%rip), %rax      # 0x1de50
movl %esi, %ecx
leaq (%rax,%rcx), %rsi
movq 0xe6f3(%rip), %rdx      # 0x1de40
cmpq %rdx, %rsi
ja 0xf787
cmpq %rdi, 0xe6ef(%rip)      # 0x1de48
jbe 0xf767
incq %rdx
movq %rdx, 0xe6eb(%rip)      # 0x1de50
popq %rax
retq
incq %rax
xorl %edx, %edx
cmpl %edx, %ecx
je 0xf765
movb (%rdi,%rdx), %sil
movq %rax, 0xe6d5(%rip)      # 0x1de50
movb %sil, -0x1(%rax)
incq %rax
incq %rdx
jmp 0xf76c
leaq 0x1b00(%rip), %rdi      # 0x1128e
leaq 0xc8c(%rip), %rsi       # 0x10421
leaq 0x1b15(%rip), %rcx      # 0x112b1
movl $0x27c3, %edx           # imm = 0x27C3
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/stb/./stb.h
// Function: stb__lit
static void stb__lit(stb_uchar *data, stb_uint length)
{
   assert (stb__dout + length <= stb__barrier);
   if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
   if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
   memcpy(stb__dout, data, length);
   stb__dout += length;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq 0xe69f(%rip), %rdi      # 0x1de50
movl %esi, %edx
leaq (%rdi,%rdx), %rbx
movq 0xe682(%rip), %rcx      # 0x1de40
cmpq %rcx, %rbx
ja 0xf7e5
cmpq %rax, 0xe666(%rip)      # 0x1de30
jbe 0xf7d4
incq %rcx
movq %rcx, %rbx
jmp 0xf7dc
movq %rax, %rsi
callq 0x2230
movq %rbx, 0xe66d(%rip)      # 0x1de50
popq %rbx
retq
leaq 0x1aa2(%rip), %rdi      # 0x1128e
leaq 0xc2e(%rip), %rsi       # 0x10421
leaq 0x1ade(%rip), %rcx      # 0x112d8
movl $0x27cb, %edx           # imm = 0x27CB
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./model.cpp
// Function: Model::toString[abi:cxx11]()
string Model::toString() {
  ostringstream os;
  for(int i = 0; i < nVars; ++i) {
    int lit = (i + 1)*vars[i];
    os << lit  << " ";
  }
  return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2180
xorl %r13d, %r13d
leaq 0x1b86(%rip), %r12      # 0x4021
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x24c8
movq 0x8(%r14), %rax
leal 0x1(%r13), %esi
imull (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x21d0
incq %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x2130
jmp 0x249b
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x21a0
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x24f5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./literal.cpp
// Function: Literal::toString[abi:cxx11]()
string Literal::toString() {
  ostringstream os;

  if (!isSet) {
    os << "-";
  }
  os << index + 1;

  return os.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2180
cmpb $0x0, 0x4(%r14)
jne 0x259a
leaq 0x1a84(%rip), %rsi      # 0x4016
movq %rsp, %rdi
callq 0x2130
movl (%r14), %esi
incl %esi
movq %rsp, %rdi
callq 0x21d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21a0
movq %rsp, %rdi
callq 0x2040
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./clause.cpp
// Function: Clause::checkSat(Model*)
bool Clause::checkSat(Model *model) {
  // Check each literal for true.
  for (int i = 0; i < nLiterals; i ++) {
    int vari = literals[i]->getIndex();
    bool varPos = literals[i]->getIsSet();

    if (!model->isAssigned(vari)) continue;

    bool varSet = model->checkVar(vari);
    if (varSet == varPos) return true;
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq (%r14), %r12
cmpq %r12, %r15
jge 0x2716
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax), %rsi
movq 0x8(%rbx), %rcx
cmpl $0x0, (%rcx,%rsi,4)
je 0x2711
movb 0x4(%rax), %bpl
movq %rbx, %rdi
callq 0x2400
cmpb %bpl, %al
je 0x2716
incq %r15
jmp 0x26e3
cmpq %r12, %r15
setl %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./clause.cpp
// Function: Clause::deleteOffendingLiterals(Model*)
bool Clause::deleteOffendingLiterals(Model *model) {
  for (int i = 0; i < nLiterals; i ++) {
    int vari = literals[i]->getIndex();
    bool varPos = literals[i]->getIsSet();

    if (!model->isAssigned(vari)) continue;

    if (model->checkVar(vari) != varPos) {
      delete literals[i];
      literals.erase(literals.begin() + i);

      i --;
      nLiterals --;
    }
  }

  return literals.size() == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
xorl %ebp, %ebp
cmpl (%rbx), %ebp
jge 0x2794
movslq %ebp, %r13
movq (%r15), %rax
movq (%rax,%r13,8), %rax
movslq (%rax), %rsi
movq 0x8(%r14), %rcx
cmpl $0x0, (%rcx,%rsi,4)
je 0x2790
movb 0x4(%rax), %r12b
movq %r14, %rdi
callq 0x2400
cmpb %r12b, %al
je 0x2790
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
shlq $0x3, %r13
pushq $0x8
popq %rsi
callq 0x2160
addq 0x8(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x3026
decl %ebp
decl (%rbx)
incl %ebp
jmp 0x273d
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./clause.cpp
// Function: Clause::clone()
Clause *Clause::clone() {
  Clause *newClause = new Clause();

  for (int i = 0; i < nLiterals; i ++) {
    newClause->addLiteral(literals[i]->clone());
  }

  return newClause;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x2150
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x27f3
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2554
movq %r14, %rdi
movq %rax, %rsi
callq 0x265c
incq %r15
jmp 0x27ce
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./clause.cpp
// Function: Clause::toString[abi:cxx11]()
string Clause::toString() {
  ostringstream os;

  for (int i = 0; i < nLiterals; i ++) {
    os << literals[i]->toString() << " ";
  }

  return os.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2180
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x17f5(%rip), %r13      # 0x4021
movslq (%r14), %rax
cmpq %rax, %rbp
jge 0x2867
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rsi
movq %r12, %rdi
callq 0x256c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2130
movq %r12, %rdi
callq 0x2090
incq %rbp
jmp 0x282c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21a0
leaq 0x20(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2895
movq %rax, %rbx
jmp 0x28a5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./formula.cpp
// Function: Formula::unitPropagate(Model*)
bool Formula::unitPropagate(Model *model) {
  bool changed = false;

  // For all singule-literal clauses, decide for that variable.
  for (auto c : clauses) {
    if (c->getNumLiterals() > 1) continue;

    Literal *literal = c->getFirstLiteral();
    int vari = literal->getIndex();
    if (literal->getIsSet()) {
      model->setVar(vari);
    } else {
      model->clearVar(vari);
    }

    changed = true;
  }

  return changed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
xorl %eax, %eax
cmpq %r15, %r14
je 0x294f
movq (%r14), %rdi
cmpl $0x1, (%rdi)
jg 0x2949
callq 0x26ac
movslq (%rax), %rcx
movzbl 0x4(%rax), %eax
movq 0x8(%rbx), %rdx
decl %eax
orl $0x1, %eax
movl %eax, (%rdx,%rcx,4)
movb $0x1, %al
addq $0x8, %r14
jmp 0x2922
andb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./formula.cpp
// Function: Formula::deleteSatisfied(Model*)
bool Formula::deleteSatisfied(Model *model) {
  for (int i = 0; i < nClauses; i ++) {
    if (clauses[i]->checkSat(model)) {
      delete clauses[i];
      clauses.erase(clauses.begin() + i);

      i --;
      nClauses --;
    } else {
      if (clauses[i]->deleteOffendingLiterals(model)) {
        return true;
      }
    }
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x8(%rdi), %r15
xorl %r12d, %r12d
movq (%rsp), %rax
movl (%rax), %ebx
cmpl %ebx, %r12d
jge 0x29e3
movslq %r12d, %r13
movq (%r15), %rax
movq (%rax,%r13,8), %rdi
movq %r14, %rsi
callq 0x26d2
movq (%r15), %rcx
movq (%rcx,%r13,8), %rbp
testb %al, %al
je 0x29cf
testq %rbp, %rbp
je 0x29a6
movq %rbp, %rdi
callq 0x25de
movq %rbp, %rdi
pushq $0x20
popq %rsi
callq 0x2160
shlq $0x3, %r13
movq (%rsp), %rbx
addq 0x8(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x3060
decl %r12d
decl (%rbx)
jmp 0x29de
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2726
testb %al, %al
jne 0x29e3
incl %r12d
jmp 0x2971
cmpl %ebx, %r12d
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./formula.cpp
// Function: Formula::simplify(Model*)
int Formula::simplify(Model *model) {
  bool changed = true;

  while (changed) {
    changed = unitPropagate(model);
    if (deleteSatisfied(model)) return -1;
  }

  if (checkSat(model)) return 1;

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $-0x1
popq %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2910
movl %eax, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x2958
testb %al, %al
jne 0x2a32
testb %bpl, %bpl
jne 0x2a08
xorl %ebx, %ebx
cmpl $0x0, (%r14)
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./formula.cpp
// Function: Formula::clone()
Formula *Formula::clone() {
  Formula *newFormula = new Formula(nVars);

  for (int i = 0; i < nClauses; i ++) {
    newFormula->addClause(clauses[i]->clone());
  }

  return newFormula;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x2150
movq %rax, %r14
movl 0x4(%rbx), %eax
andl $0x0, (%r14)
movl %eax, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
andq $0x0, 0x18(%r14)
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x2b07
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x27ae
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a48
incq %r15
jmp 0x2ae2
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/aaronshim[P]SATurday/./formula.cpp
// Function: Formula::toString[abi:cxx11]()
string Formula::toString() {
  ostringstream os;

  os << "nClauses: " << nClauses << endl
     << "nVars: " << nVars << endl;

  for (int i = 0; i < nClauses; i ++) {
    os << clauses[i]->toString() << endl;
  }

  return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2180
leaq 0x14de(%rip), %rsi      # 0x4018
movq %r15, %rdi
callq 0x2130
movl (%r14), %esi
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20a0
leaq 0x14c7(%rip), %rsi      # 0x4023
movq %rax, %rdi
callq 0x2130
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20a0
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x2bbd
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
callq 0x27fc
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
movq %r15, %rdi
callq 0x2090
incq %r13
jmp 0x2b85
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x21a0
leaq 0x28(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2bea
movq %rax, %rbx
jmp 0x2bfc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21e0