LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0xe(%rsp), %r12
movw %bp, (%r12)
callq 0x11027
movl %eax, %r13d
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x110a9
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x1118f
testq %rax, %rax
je 0xdab1
movq %rax, %r14
movzbl (%rax), %eax
cmpl $0x29, %eax
je 0xda46
testl %eax, %eax
jne 0xda57
movzwl 0xe(%rsp), %r12d
movq 0x10(%rsp), %rax
movw %r12w, (%rax)
jmp 0xdab4
movq %r15, %rdi
callq 0x11027
movl %eax, %r12d
leaq 0xe(%rsp), %r13
movzwl 0xe(%rsp), %esi
movq %r15, %rdi
movl %r12d, %edx
callq 0x110a9
movzbl (%r14), %eax
cmpl $0x7c, %eax
jne 0xdac6
movq %r15, %rdi
callq 0x11027
movl %eax, %ebx
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x110a9
incq %r14
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x1118f
movq %rax, %r14
testq %rax, %rax
jne 0xda67
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
je 0xda4c
cmpl $0x29, %eax
je 0xda4c
leaq 0x572b(%rip), %rdi      # 0x13205
leaq 0x4a20(%rip), %rsi      # 0x12501
leaq 0x572b(%rip), %rcx      # 0x13213
movl $0x245a, %edx           # imm = 0x245A
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %r14
movzwl (%rdi), %esi
leaq 0x6(%rsp), %rcx
callq 0xd9e8
testq %rax, %rax
je 0xdb43
movq %r14, %rdi
callq 0xdb4d
movq 0x18(%r14), %rax
movzwl 0x6(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
movw %bx, (%rax,%rcx,8)
movl $0x1, %eax
jmp 0xdb45
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xdb62
movl -0xc(%rax), %ecx
shrl $0x1f, %ecx
jmp 0xdb64
xorl %ecx, %ecx
testq %rax, %rax
je 0xdb76
testb %cl, %cl
jne 0xdb76
movl $0x0, -0x10(%rax)
jmp 0xdb88
leaq 0x28(%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x56fd
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0xdb99
movl -0xc(%rax), %ecx
shrl $0x1f, %ecx
jmp 0xdb9b
xorl %ecx, %ecx
testq %rax, %rax
je 0xdbad
testb %cl, %cl
jne 0xdbad
movl $0x0, -0x10(%rax)
jmp 0xdbbf
leaq 0x30(%rbx), %rdi
movl $0x4, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x56fd
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xdbd0
movl -0xc(%rax), %ecx
shrl $0x1f, %ecx
jmp 0xdbd2
xorl %ecx, %ecx
testq %rax, %rax
je 0xdbe4
testb %cl, %cl
jne 0xdbe4
movl $0x0, -0x10(%rax)
jmp 0xdbf6
leaq 0x38(%rbx), %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x56fd
movw $0xffff, 0x2(%rbx)      # imm = 0xFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11027
movl %eax, %r15d
movzwl %r15w, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x110a9
movl %r15d, %ebp
movzbl (%r12), %ebx
movq %r14, %rdi
callq 0x11027
movl %eax, %r15d
cmpl $0x2a, %ebx
je 0xdc97
cmpl $0x3f, %ebx
je 0xdc87
testl %ebx, %ebx
je 0xdcfd
callq 0x2030
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movsbq (%r12), %rbx
movl (%rax,%rbx,4), %r13d
callq 0x23b0
movq (%rax), %rax
movl (%rax,%rbx,4), %ecx
cmpl %ecx, %r13d
jne 0xdcc8
movzwl %bp, %esi
movq %r14, %rdi
movl %r15d, %edx
movl %ebx, %ecx
jmp 0xdcf0
movzwl %bp, %esi
movq %r14, %rdi
movl %r15d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0xdcf0
movzwl %bp, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x11534
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x110a9
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x110a9
jmp 0xdcf5
movzwl %bp, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x11534
movq 0x10(%rsp), %rax
movq (%rax), %rax
movsbq (%r12), %rcx
movl (%rax,%rcx,4), %ecx
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x11534
incq %r12
jmp 0xdc2f
movl $0xffff, %ebx           # imm = 0xFFFF
andl %ebx, %ebp
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x11534
movq %r14, %rdi
callq 0xdb4d
movq 0x18(%r14), %rax
andl %ebx, %r15d
leaq (%r15,%r15,2), %rcx
movl 0xc(%rsp), %edx
movw %dx, (%rax,%rcx,8)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movq 0x18(%rdi), %rax
movl %edx, %ecx
leaq (%rcx,%rcx,2), %r15
cmpb $0x0, 0x2(%rax,%r15,8)
jne 0xe12d
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
je 0xe0de
movl -0x10(%rsi), %eax
incl %eax
jmp 0xe0e3
movl $0x1, %eax
testq %rsi, %rsi
je 0xe0ed
movl -0xc(%rsi), %ecx
jmp 0xe0ef
xorl %ecx, %ecx
cmpl %ecx, %eax
jle 0xe109
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0xe10c
incl -0x10(%rsi)
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xe11c
movslq -0x10(%rax), %rcx
jmp 0xe11e
xorl %ecx, %ecx
movw %bx, -0x2(%rax,%rcx,2)
movq 0x18(%r14), %rax
movb $0x1, 0x2(%rax,%r15,8)
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xe155
movl -0x10(%rax), %ecx
jmp 0xe157
xorl %ecx, %ecx
testl %ecx, %ecx
jle 0xe1b0
xorl %r14d, %r14d
movq 0x18(%rbx), %rdx
movzwl (%rax,%r14,2), %esi
leaq (%rsi,%rsi,2), %rsi
movq 0x10(%rdx,%rsi,8), %r15
testq %r15, %r15
je 0xe1a5
movslq -0x10(%r15), %r12
testq %r12, %r12
jle 0xe199
xorl %r13d, %r13d
movzwl (%r15,%r13,2), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe0ad
incq %r13
cmpq %r13, %r12
jne 0xe181
testq %rax, %rax
je 0xe1a3
movl -0x10(%rax), %ecx
jmp 0xe1a5
xorl %ecx, %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0xe15e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
leaq 0x3710(%rip), %rsi      # 0x1284c
callq 0x22f0
testq %rax, %rax
je 0xf1c4
movq %rax, %r13
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
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 0xf1c7
movq %rax, %rbx
movl $0x1, %esi
movq %rax, %rdi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x20b0
movq %r13, %rdi
callq 0x20d0
cmpb $0x57, (%rbx)
jne 0xf1b7
cmpb $-0x44, 0x1(%rbx)
jne 0xf1b7
cmpb $0x0, 0x2(%rbx)
jne 0xf1b7
cmpb $0x0, 0x3(%rbx)
je 0xf1d9
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x23d0
jmp 0xf1c7
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rbx), %edi
bswapl %edi
incl %edi
callq 0x2250
testq %rax, %rax
je 0xf1b7
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0xee1e
movl %eax, (%r14)
testl %eax, %eax
je 0xf1ba
movl %eax, %eax
movb $0x0, (%r15,%rax)
jmp 0xf1ba
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10c1c(%rip)     # 0x1fe68
movq $0x0, 0x10c19(%rip) # 0x1fe70
movq %rsi, %rdi
movl %edx, %esi
callq 0xf26b
movl 0x10c01(%rip), %eax     # 0x1fe68
subl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
movl 0xafb9(%rip), %r12d     # 0x1a244
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x2250
testq %rax, %rax
je 0xf2d1
movq %rax, %rbx
testq %r12, %r12
je 0xf2b5
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2160
movq 0x10bac(%rip), %rax     # 0x1fe68
testq %rax, %rax
je 0xf2d8
leaq 0x1(%rax), %rcx
movq %rcx, 0x10b9c(%rip)     # 0x1fe68
movb $0x57, (%rax)
jmp 0xf2ef
xorl %eax, %eax
jmp 0xf3a7
movq 0x10b91(%rip), %rsi     # 0x1fe70
movl $0x57, %edi
callq 0x21b0
incl 0x10b89(%rip)           # 0x1fe78
movq 0x10b72(%rip), %rax     # 0x1fe68
testq %rax, %rax
je 0xf30b
leaq 0x1(%rax), %rcx
movq %rcx, 0x10b62(%rip)     # 0x1fe68
movb $-0x44, (%rax)
jmp 0xf322
movq 0x10b5e(%rip), %rsi     # 0x1fe70
movl $0xbc, %edi
callq 0x21b0
incl 0x10b56(%rip)           # 0x1fe78
xorl %edi, %edi
callq 0x11707
xorl %edi, %edi
callq 0x11771
movl %ebp, %edi
callq 0x11771
movl 0xaf03(%rip), %edi      # 0x1a240
callq 0x11771
movl $0x1, 0x11094(%rip)     # 0x203e0
movl %ebp, %r15d
addq %r14, %r15
movl 0xaeeb(%rip), %r9d      # 0x1a244
decl %r9d
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %r8
callq 0xf697
cmpl %ebp, %eax
jne 0xf3b4
movslq 0xc(%rsp), %rsi
subq %rsi, %r15
movq %r15, %rdi
callq 0xfdaa
movq %rbx, %rdi
callq 0x23d0
movl $0x5fa, %edi            # imm = 0x5FA
callq 0x11707
movl 0x11043(%rip), %edi     # 0x203e0
callq 0x11771
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x402c(%rip), %rdi      # 0x133e7
leaq 0x313f(%rip), %rsi      # 0x12501
leaq 0x402c(%rip), %rcx      # 0x133f5
movl $0x2935, %edx           # imm = 0x2935
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, 0x10a81(%rip) # 0x1fe68
leaq 0x3461(%rip), %rsi      # 0x1284f
callq 0x22f0
movq %rax, 0x10a76(%rip)     # 0x1fe70
xorl %ebx, %ebx
testq %rax, %rax
je 0xf42b
movl $0x0, 0x10a6d(%rip)     # 0x1fe78
movq %r14, %rdi
movl %ebp, %esi
callq 0xf26b
testl %eax, %eax
je 0xf42b
movq 0x10a50(%rip), %rdi     # 0x1fe70
callq 0x20d0
movl 0x10a4d(%rip), %ebx     # 0x1fe78
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq $0x0, 0x10a2b(%rip) # 0x1fe68
movq %rdi, 0x10a2c(%rip)     # 0x1fe70
testq %rdi, %rdi
je 0xf46e
pushq %rax
movl $0x0, 0x10a24(%rip)     # 0x1fe78
movq %rsi, %rdi
movl %edx, %esi
callq 0xf26b
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0xf46d
movl 0x10a0b(%rip), %eax     # 0x1fe78
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x10001, %esi          # imm = 0x10001
jl 0xfde9
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0xfdaa
addq $0x10000, %rbx          # imm = 0x10000
leal -0x10000(%r14), %r12d
cmpl $0x20000, %r14d         # imm = 0x20000
movl %r12d, %r14d
jg 0xfdc0
jmp 0xfdec
movl %r14d, %r12d
testl %r12d, %r12d
je 0xfe58
cmpl $0x20, %r12d
jg 0xfe17
movq 0x1006a(%rip), %rax     # 0x1fe68
testq %rax, %rax
je 0xfe3e
leal 0x1f(%r12), %ecx
leaq 0x1(%rax), %rdx
movq %rdx, 0x10055(%rip)     # 0x1fe68
movb %cl, (%rax)
jmp 0xfe58
cmpl $0x800, %r12d           # imm = 0x800
jg 0xfe2f
leal 0x7ff(%r12), %edi
callq 0x11707
jmp 0xfe58
leal 0x6ffff(%r12), %edi
callq 0x11841
jmp 0xfe58
leal 0x1f(%r12), %eax
movzbl %al, %edi
movq 0x10023(%rip), %rsi     # 0x1fe70
callq 0x21b0
incl 0x10020(%rip)           # 0x1fe78
movq 0x10009(%rip), %r15     # 0x1fe68
movslq %r12d, %r14
testq %r15, %r15
je 0xfe8b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2230
addq %r14, %r15
movq %r15, 0xffe9(%rip)      # 0x1fe68
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xffde(%rip), %rcx      # 0x1fe70
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq $0x0, 0xffa8(%rip) # 0x1fe68
movq %rdi, 0xffa9(%rip)      # 0x1fe70
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x1000a
movq %rdi, %rbx
movslq 0xa364(%rip), %r15      # 0x1a240
leaq (%r15,%r15,2), %rdi
movl %edi, 0xffa2(%rip)      # 0x1fe88
callq 0x2250
movq %rax, 0xff8e(%rip)      # 0x1fe80
testq %rax, %rax
je 0x1000a
movq %rax, %r14
movl 0xa33f(%rip), %r12d     # 0x1a244
leaq (,%r12,8), %rdi
callq 0x2250
movq %rax, 0xff8f(%rip)      # 0x1fea8
testq %rax, %rax
je 0xff9c
testq %r12, %r12
je 0xff3c
xorl %eax, %eax
movq 0xff7c(%rip), %rcx      # 0x1fea8
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0xff25
decl %r12d
movl %r12d, 0xff6a(%rip)     # 0x1feb0
movq $0x0, 0xff3b(%rip) # 0x1fe8c
movl %r15d, 0xff3c(%rip)     # 0x1fe94
movl %r15d, 0xff39(%rip)     # 0x1fe98
xorl %eax, %eax
movl %eax, 0xff35(%rip)      # 0x1fe9c
movl %eax, 0xff37(%rip)      # 0x1fea4
movl $0x57, %edi
movq %rbx, %rsi
callq 0x21b0
incl 0xfef8(%rip)            # 0x1fe78
movq 0xfee1(%rip), %rax      # 0x1fe68
testq %rax, %rax
je 0xffa6
leaq 0x1(%rax), %rcx
movq %rcx, 0xfed1(%rip)      # 0x1fe68
movb $-0x44, (%rax)
jmp 0xffbd
movq %r14, %rdi
callq 0x23d0
jmp 0x1000a
movq 0xfec3(%rip), %rsi      # 0x1fe70
movl $0xbc, %edi
callq 0x21b0
incl 0xfebb(%rip)            # 0x1fe78
xorl %edi, %edi
callq 0x11707
xorl %edi, %edi
callq 0x11771
movq 0xfe96(%rip), %rax      # 0x1fe68
testq %rax, %rax
jne 0xffe3
movq 0xfe92(%rip), %rdi      # 0x1fe70
callq 0x2200
movl %eax, 0xfeb7(%rip)      # 0x1fea0
xorl %edi, %edi
callq 0x11771
movl 0xa24a(%rip), %edi      # 0x1a240
callq 0x11771
movl $0x1, 0x103db(%rip)     # 0x203e0
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x1019c
leaq 0x9b0b(%rip), %rsi      # 0x19c98
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, 0x40(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x10283
leaq 0x9a99(%rip), %rsi      # 0x19d00
movl $0xd, %ecx
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_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movl %edx, %ecx
movq 0x50(%rdi), %rsi
movq 0x58(%rdi), %rdi
addq %rsi, %rcx
movl %edi, %r14d
subl %esi, %r14d
cmpq %rdi, %rcx
cmovbel %edx, %r14d
movq %rax, %rdi
movq %r14, %rdx
callq 0x2230
addq %r14, 0x50(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x103a2
leaq 0x9981(%rip), %rsi      # 0x19d00
movl $0xd, %ecx
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)
movl $0x1, 0x60(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %esi, %esi
cmpb $0x6b, (%rbx)
sete %sil
addq %rbx, %rsi
callq 0x8593
testq %rax, %rax
je 0x10408
movq %rax, %r14
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x1040a
leaq 0x98b9(%rip), %rsi      # 0x19c98
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, 0x40(%rax)
leaq 0x1d(%rip), %rcx        # 0x10412
movq %rcx, 0x38(%rax)
xorl %ecx, %ecx
cmpb $0x6b, (%rbx)
sete %cl
incl %ecx
movl %ecx, 0x60(%rax)
jmp 0x1040a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x1044a
movq %rbx, 0x60(%rax)
leaq 0x9929(%rip), %rsi      # 0x19d68
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x105e0
movq %rbx, %rdi
callq 0x1061a
movl (%rbx), %esi
movl 0x4(%rbx), %eax
subl %esi, %eax
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0x10618
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x10802
movl (%rbx), %esi
movl 0x4(%rbx), %eax
shll $0x8, %esi
movl %esi, (%rbx)
shll $0x8, %eax
leal 0xff(%rax), %ecx
movl %ecx, 0x4(%rbx)
subl %esi, %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x105ee
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1064f
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
cmpl $0x0, 0x14(%rbx)
jle 0x10648
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq *0x10(%rdi)
incl %ebp
cmpl 0x14(%rbx), %ebp
jl 0x10638
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2f38(%rip), %rdi      # 0x1358e
leaq 0x1ea4(%rip), %rsi      # 0x12501
leaq 0x2f3f(%rip), %rcx      # 0x135a3
movl $0x2b4f, %edx           # imm = 0x2B4F
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10699
movq %rbx, %rdi
callq 0x1061a
movl (%rbx), %esi
movl 0x4(%rbx), %eax
subl %esi, %eax
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0x106d1
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x10802
movl (%rbx), %esi
movl 0x4(%rbx), %eax
shll $0x8, %esi
movl %esi, (%rbx)
shll $0x8, %eax
leal 0xff(%rax), %ecx
movl %ecx, 0x4(%rbx)
subl %esi, %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x106a7
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edx, %r8d
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 0x10736
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
callq *(%rdi)
testl %eax, %eax
jg 0x1071f
xorl %eax, %eax
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
shll $0x8, %ecx
addl %eax, %ecx
movl %ecx, 0x8(%rbx)
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x10713
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %ecx, %eax
movl %esi, %ecx
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 0x10799
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
callq *(%rdi)
testl %eax, %eax
jg 0x10782
xorl %eax, %eax
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
shll $0x8, %ecx
addl %eax, %ecx
movl %ecx, 0x8(%rbx)
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x10776
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10802
movzwl 0x2(%rbx), %esi
movq %rbx, %rdi
callq 0x10802
movl (%rbx), %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x10802
movl (%rbx), %esi
movq %rbx, %rdi
callq 0x10802
cmpl $0x0, 0x14(%rbx)
js 0x107f7
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
cmpl $0x0, 0x14(%rbx)
jle 0x107f7
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movl $0xff, %esi
callq *0x10(%rdi)
incl %ebp
cmpl 0x14(%rbx), %ebp
jl 0x107e4
movq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10833
cmpl $-0x1, %eax
jne 0x10844
cmpl $0xff, %ebp
jne 0x10853
movq 0x18(%rbx), %rdi
movq 0x10(%rdi), %rax
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
cmpl $0xff, %ebp
jne 0x1085f
movl $0x1, 0x14(%rbx)
jmp 0x10893
cmpl $0xff, %ebp
jne 0x1086e
incl %eax
movl %eax, 0x14(%rbx)
jmp 0x10893
movl %ebp, 0x10(%rbx)
movl $0x0, 0x14(%rbx)
jmp 0x10893
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
movl %ebp, 0x10(%rbx)
jmp 0x10893
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
cmpl $0x0, 0x14(%rbx)
jle 0x10893
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movl $0xff, %esi
callq *0x10(%rdi)
incl %ebp
cmpl 0x14(%rbx), %ebp
jl 0x10880
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %rax
leaq 0xc(,%rax,4), %rdi
callq 0x2250
movq %rax, %rsi
testq %rax, %rax
je 0x10986
movl %ebx, (%rsi)
leal (%rbx,%rbx,2), %eax
movl $0x4, %ecx
movl $0x1, %edx
shll %cl, %edx
cmpl %eax, %edx
jge 0x108e1
incl %ecx
cmpl $0xf, %ecx
jne 0x108ca
movl $0xf, %ecx
movl $0x1, %edi
shll %cl, %edi
movl %ecx, 0x4(%rsi)
movl %edi, %eax
cltd
idivl %ebx
testl %eax, %eax
jle 0x10990
testl %edx, %edx
jle 0x10933
xorl %r10d, %r10d
cmpl $0xc, %ecx
setae %r10b
leal 0x1(%rax), %r11d
xorl %r8d, %r8d
xorl %r9d, %r9d
movw %r8w, 0xc(%rsi,%r9,4)
movw %r10w, 0xe(%rsi,%r9,4)
incq %r9
addl %r11d, %r8d
cmpq %r9, %rdx
jne 0x10910
xorl %r10d, %r10d
cmpl $0xc, %ecx
cmovbl %r10d, %edx
jmp 0x1093b
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %ebx, %ebp
subl %r9d, %ebp
jle 0x10972
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpl $0xc, %ecx
setae %r11b
movl %r9d, %r9d
cmovael %ebp, %r10d
movl %ebx, %ebx
movw %r8w, 0xc(%rsi,%r9,4)
movw %r11w, 0xe(%rsi,%r9,4)
addl %eax, %r8d
incq %r9
cmpq %r9, %rbx
jne 0x10958
addl %r10d, %edx
cmpl %edi, %r8d
jne 0x109af
movl $0x2, %eax
shll %cl, %eax
addl %r8d, %edx
subl %edx, %eax
movl %eax, 0x8(%rsi)
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2589(%rip), %rdi      # 0x12f20
leaq 0x1b63(%rip), %rsi      # 0x12501
leaq 0x258b(%rip), %rcx      # 0x12f30
movl $0x2be1, %edx           # imm = 0x2BE1
callq 0x2140
leaq 0x25aa(%rip), %rdi      # 0x12f60
leaq 0x1b44(%rip), %rsi      # 0x12501
leaq 0x256c(%rip), %rcx      # 0x12f30
movl $0x2bf7, %edx           # imm = 0x2BF7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x98, %rsp
movq %rdi, %rbx
movq 0xf4c7(%rip), %rdx      # 0x1feb8
testq %rdx, %rdx
je 0x10a22
leaq 0xf4c3(%rip), %r14      # 0x1fec0
leaq 0x1c56(%rip), %rsi      # 0x1265a
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2350
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
je 0x10a66
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2220
testl %eax, %eax
je 0x10a63
leaq 0xf486(%rip), %r14      # 0x1fec0
leaq 0x2534(%rip), %rsi      # 0x12f75
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
cmoveq %rbx, %r14
jmp 0x10a66
movq %rbx, %r14
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1103b
movl -0x10(%rax), %ecx
incl %ecx
jmp 0x11040
movl $0x1, %ecx
testq %rax, %rax
je 0x1104a
movl -0xc(%rax), %edx
jmp 0x1104c
xorl %edx, %edx
addq $0x18, %rbx
cmpl %edx, %ecx
jle 0x11068
movq %rbx, %rdi
movl $0x18, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0x1106b
incl -0x10(%rax)
movq (%rbx), %rax
testq %rax, %rax
je 0x11079
movslq -0x10(%rax), %rcx
jmp 0x1107b
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rcx
movw $0x0, -0x18(%rax,%rcx,8)
movb $0x0, -0x16(%rax,%rcx,8)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%rax,%rcx,8)
movq (%rbx), %rax
testq %rax, %rax
je 0x110a2
movl -0x10(%rax), %eax
decl %eax
jmp 0x110a7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
cmpl %edx, %esi
je 0x11170
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %r15
cmpq $0x0, 0x10(%rax,%r15,8)
jne 0x11103
leaq (%rax,%r15,8), %r12
addq $0x10, %r12
movl 0x9155(%rip), %ecx      # 0x1a234
movl $0x10, %esi
movq %r14, %rdi
movl $0x2, %edx
callq 0x5184
movaps 0xff8(%rip), %xmm0      # 0x120f0
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, (%r12)
movq 0x18(%r14), %rax
movq 0x10(%rax,%r15,8), %rcx
testq %rcx, %rcx
je 0x11118
movl -0x10(%rcx), %edx
incl %edx
jmp 0x1111d
movl $0x1, %edx
testq %rcx, %rcx
je 0x11127
movl -0xc(%rcx), %esi
jmp 0x11129
xorl %esi, %esi
cmpl %esi, %edx
jle 0x11146
leaq (%rax,%r15,8), %rdi
addq $0x10, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0x11149
incl -0x10(%rcx)
movq 0x18(%r14), %rax
movq 0x10(%rax,%r15,8), %rax
testq %rax, %rax
je 0x1115d
movslq -0x10(%rax), %rcx
jmp 0x1115f
xorl %ecx, %ecx
movw %bx, -0x2(%rax,%rcx,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20df(%rip), %rdi      # 0x13256
leaq 0x1383(%rip), %rsi      # 0x12501
leaq 0x20dc(%rip), %rcx      # 0x13261
movl $0x2399, %edx           # imm = 0x2399
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movl %esi, %ecx
leaq (%rcx,%rcx,2), %r15
cmpq $0x0, 0x8(%rax,%r15,8)
jne 0x11587
leaq (%rax,%r15,8), %r12
addq $0x8, %r12
movl 0x8cd1(%rip), %ecx      # 0x1a234
movl $0x10, %esi
movq %r14, %rdi
movl $0x2, %edx
callq 0x5184
movaps 0xb74(%rip), %xmm0      # 0x120f0
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, (%r12)
movq 0x18(%r14), %rax
movq 0x8(%rax,%r15,8), %rcx
testq %rcx, %rcx
je 0x1159c
movl -0x10(%rcx), %edx
incl %edx
jmp 0x115a1
movl $0x1, %edx
testq %rcx, %rcx
je 0x115ab
movl -0xc(%rcx), %esi
jmp 0x115ad
xorl %esi, %esi
cmpl %esi, %edx
jle 0x115ca
leaq (%rax,%r15,8), %rdi
addq $0x8, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x57e0
jmp 0x115cd
incl -0x10(%rcx)
movq 0x18(%r14), %rax
movq 0x8(%rax,%r15,8), %rax
testq %rax, %rax
je 0x115e1
movslq -0x10(%rax), %rcx
jmp 0x115e3
xorl %ecx, %ecx
movw %bp, -0x4(%rax,%rcx,4)
movw %bx, -0x2(%rax,%rcx,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x18(%rdi), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
cmpw $0x0, (%rcx,%rdx,8)
je 0x11611
xorl %edx, %edx
movl %esi, %eax
testb %dl, %dl
jne 0x115fa
jmp 0x1163a
leaq (%rcx,%rdx,8), %rdx
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0x11624
cmpl $0x0, -0x10(%rdi)
jne 0x11607
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x11607
cmpl $0x1, -0x10(%rdx)
jne 0x11607
movzwl (%rdx), %esi
movb $0x1, %dl
jmp 0x1160b
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %ecx
movq 0xe81b(%rip), %rdx      # 0x1fe60
addq %rcx, %rdx
movq 0xe801(%rip), %rax      # 0x1fe50
cmpq %rax, %rdx
ja 0x1168a
cmpq %rdi, 0xe7fd(%rip)      # 0x1fe58
jbe 0x11662
incq %rax
jmp 0x11681
testl %esi, %esi
je 0x11688
movq 0xe7f3(%rip), %rax      # 0x1fe60
xorl %edx, %edx
movb (%rdi,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x1166f
addq %rdx, %rax
movq %rax, 0xe7d8(%rip)      # 0x1fe60
popq %rax
retq
leaq 0x1ce7(%rip), %rdi      # 0x13378
leaq 0xe69(%rip), %rsi       # 0x12501
leaq 0x1cfc(%rip), %rcx      # 0x1339b
movl $0x27c3, %edx           # imm = 0x27C3
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe7ac(%rip), %rdi      # 0x1fe60
movl %esi, %edx
leaq (%rdi,%rdx), %rbx
movq 0xe78f(%rip), %rcx      # 0x1fe50
cmpq %rcx, %rbx
ja 0x116e8
cmpq %rax, 0xe773(%rip)      # 0x1fe40
jbe 0x116d7
incq %rcx
movq %rcx, %rbx
jmp 0x116df
movq %rax, %rsi
callq 0x2230
movq %rbx, 0xe77a(%rip)      # 0x1fe60
popq %rbx
retq
leaq 0x1c89(%rip), %rdi      # 0x13378
leaq 0xe0b(%rip), %rsi       # 0x12501
leaq 0x1cc5(%rip), %rcx      # 0x133c2
movl $0x27cb, %edx           # imm = 0x27CB
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21a0
xorl %r13d, %r13d
leaq 0x1b18(%rip), %r12      # 0x4021
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x253b
movq 0x8(%r14), %rax
leal 0x1(%r13), %esi
imull (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2200
incq %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
jmp 0x2509
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x21c0
movq 0x3a79(%rip), %rsi      # 0x5fc8
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x78(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2579
movq %rax, %rbx
movq 0x3a45(%rip), %rsi      # 0x5fc8
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x78(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21a0
cmpb $0x0, 0x4(%r14)
jne 0x267b
leaq 0x19a8(%rip), %rsi      # 0x4016
movq %rsp, %rdi
movl $0x1, %edx
callq 0x2180
movl (%r14), %esi
incl %esi
movq %rsp, %rdi
callq 0x2200
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21c0
movq 0x392c(%rip), %rsi      # 0x5fc8
movq %rsp, %rdi
callq 0x20c0
leaq 0x70(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x3902(%rip), %rsi      # 0x5fc8
movq %rsp, %rdi
callq 0x20c0
leaq 0x70(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, (%rdi)
setg %bpl
jle 0x2855
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax), %rsi
movq 0x8(%rbx), %rcx
cmpl $0x0, (%rcx,%rsi,4)
je 0x283d
movb 0x4(%rax), %r12b
movq %rbx, %rdi
callq 0x2466
xorb %r12b, %al
xorb $0x1, %al
movzbl %al, %eax
jmp 0x2842
movl $0x4, %eax
testb $0x3, %al
jne 0x2855
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
setl %bpl
jl 0x2812
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x28e9
movq %rsi, %r14
xorl %ebp, %ebp
movslq %ebp, %r15
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movslq (%rax), %rsi
movq 0x8(%r14), %rcx
cmpl $0x0, (%rcx,%rsi,4)
je 0x28e3
movb 0x4(%rax), %r12b
movq %r14, %rdi
callq 0x2466
cmpb %r12b, %al
je 0x28e3
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x28b9
movl $0x8, %esi
callq 0x2170
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
leaq (%rax,%r15,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x28da
leaq (%rax,%r15,8), %rdi
subq %rsi, %rdx
callq 0x21d0
addq $-0x8, 0x10(%rbx)
decl %ebp
decl (%rbx)
incl %ebp
cmpl (%rbx), %ebp
jl 0x2879
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop