LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfece
leaq 0x9dd9(%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_O3/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 0xffb5
leaq 0x9d67(%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_O3/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 0x100d4
leaq 0x9c4f(%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_O3/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 0x849b
testq %rax, %rax
je 0x1013a
movq %rax, %r14
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x1013a
leaq 0x9b87(%rip), %rsi      # 0x19c98
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, 0x40(%rax)
leaq 0x1d(%rip), %rcx        # 0x10144
movq %rcx, 0x38(%rax)
xorl %ecx, %ecx
cmpb $0x6b, (%rbx)
sete %cl
incl %ecx
movl %ecx, 0x60(%rax)
jmp 0x1013c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x68, %edi
callq 0x2250
testq %rax, %rax
je 0x10175
leaq 0x9bfe(%rip), %rsi      # 0x19d68
movl $0xd, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x102ef
movq %rbx, %rdi
callq 0x10326
movl (%rbx), %ecx
movl 0x4(%rbx), %eax
subl %ecx, %eax
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0x10324
shrl $0x18, %ecx
movq %rbx, %rdi
movl %ecx, %esi
callq 0x10512
movl (%rbx), %ecx
movl 0x4(%rbx), %eax
shll $0x8, %ecx
movl %ecx, (%rbx)
shll $0x8, %eax
leal 0xff(%rax), %edx
movl %edx, 0x4(%rbx)
subl %ecx, %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x102f8
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1035b
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
cmpl $0x0, 0x14(%rbx)
jle 0x10354
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq *0x10(%rdi)
incl %ebp
cmpl 0x14(%rbx), %ebp
jl 0x10344
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x31d2(%rip), %rdi      # 0x13534
leaq 0x2148(%rip), %rsi      # 0x124b1
leaq 0x31d9(%rip), %rcx      # 0x13549
movl $0x2b4f, %edx           # imm = 0x2B4F
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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), %ecx
movl %ecx, 0x4(%rbx)
jae 0x103aa
movq %rbx, %rdi
callq 0x10326
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
subl %eax, %ecx
cmpl $0xffffff, %ecx         # imm = 0xFFFFFF
ja 0x103e1
shrl $0x18, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x10512
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
shll $0x8, %eax
movl %eax, (%rbx)
shll $0x8, %ecx
leal 0xff(%rcx), %edx
movl %edx, 0x4(%rbx)
subl %eax, %ecx
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x103b4
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10446
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
callq *(%rdi)
testl %eax, %eax
jg 0x1042f
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 0x10423
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x104a9
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
callq *(%rdi)
testl %eax, %eax
jg 0x10492
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 0x10486
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10512
movzwl 0x2(%rbx), %esi
movq %rbx, %rdi
callq 0x10512
movl (%rbx), %esi
shrl $0x8, %esi
movq %rbx, %rdi
callq 0x10512
movl (%rbx), %esi
movq %rbx, %rdi
callq 0x10512
cmpl $0x0, 0x14(%rbx)
js 0x10507
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
cmpl $0x0, 0x14(%rbx)
jle 0x10507
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movl $0xff, %esi
callq *0x10(%rdi)
incl %ebp
cmpl 0x14(%rbx), %ebp
jl 0x104f4
movq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10543
cmpl $-0x1, %eax
jne 0x10554
cmpl $0xff, %ebp
jne 0x10563
movq 0x18(%rbx), %rdi
movq 0x10(%rdi), %rax
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
cmpl $0xff, %ebp
jne 0x1056f
movl $0x1, 0x14(%rbx)
jmp 0x105a3
cmpl $0xff, %ebp
jne 0x1057e
incl %eax
movl %eax, 0x14(%rbx)
jmp 0x105a3
movl %ebp, 0x10(%rbx)
movl $0x0, 0x14(%rbx)
jmp 0x105a3
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
movl %ebp, 0x10(%rbx)
jmp 0x105a3
movq 0x18(%rbx), %rdi
movl 0x10(%rbx), %esi
callq *0x10(%rdi)
cmpl $0x0, 0x14(%rbx)
jle 0x105a3
xorl %ebp, %ebp
movq 0x18(%rbx), %rdi
movl $0xff, %esi
callq *0x10(%rdi)
incl %ebp
cmpl 0x14(%rbx), %ebp
jl 0x10590
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movl %edi, %ebx
movslq %edi, %rax
leaq 0xc(,%rax,4), %rdi
callq 0x2250
movq %rax, %rsi
testq %rax, %rax
je 0x10699
movl %ebx, (%rsi)
leal (%rbx,%rbx,2), %eax
movl $0x4, %ecx
movl $0x1, %edx
shll %cl, %edx
cmpl %eax, %edx
jge 0x105f2
incl %ecx
cmpl $0xf, %ecx
jne 0x105db
movl $0xf, %ecx
movl $0x1, %edi
shll %cl, %edi
movl %ecx, 0x4(%rsi)
movl %edi, %eax
cltd
idivl %ebx
testl %eax, %eax
jle 0x106a1
xorl %r9d, %r9d
testl %edx, %edx
jle 0x1064a
cmpl $0xc, %ecx
setae %r9b
leal 0x1(%rax), %r10d
movl %edx, %r11d
xorl %r8d, %r8d
xorl %r14d, %r14d
movw %r8w, 0xc(%rsi,%r14,4)
movw %r9w, 0xe(%rsi,%r14,4)
incq %r14
addl %r10d, %r8d
cmpq %r14, %r11
jne 0x10624
xorl %r10d, %r10d
cmpl $0xc, %ecx
movl %edx, %r9d
cmovbl %r10d, %r9d
jmp 0x1064f
xorl %r8d, %r8d
xorl %edx, %edx
movl %ebx, %ebp
subl %edx, %ebp
jle 0x10684
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpl $0xc, %ecx
setae %r11b
movl %edx, %edx
cmovael %ebp, %r10d
movl %ebx, %ebx
movw %r8w, 0xc(%rsi,%rdx,4)
movw %r11w, 0xe(%rsi,%rdx,4)
addl %eax, %r8d
incq %rdx
cmpq %rdx, %rbx
jne 0x1066a
addl %r10d, %r9d
cmpl %edi, %r8d
jne 0x106c0
movl $0x2, %eax
shll %cl, %eax
addl %edi, %r9d
subl %r9d, %eax
movl %eax, 0x8(%rsi)
movq %rsi, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x281e(%rip), %rdi      # 0x12ec6
leaq 0x1e02(%rip), %rsi      # 0x124b1
leaq 0x2820(%rip), %rcx      # 0x12ed6
movl $0x2be1, %edx           # imm = 0x2BE1
callq 0x2140
leaq 0x283f(%rip), %rdi      # 0x12f06
leaq 0x1de3(%rip), %rsi      # 0x124b1
leaq 0x2801(%rip), %rcx      # 0x12ed6
movl $0x2bf7, %edx           # imm = 0x2BF7
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7a6(%rip), %rdx      # 0x1fea8
testq %rdx, %rdx
je 0x10733
leaq 0xf7a2(%rip), %r14      # 0x1feb0
leaq 0x1ef5(%rip), %rsi      # 0x1260a
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2350
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
je 0x10777
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2220
testl %eax, %eax
je 0x10774
leaq 0xf765(%rip), %r14      # 0x1feb0
leaq 0x27c9(%rip), %rsi      # 0x12f1b
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 0x10777
movq %rbx, %r14
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10e16
movl %edx, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %r12
leaq (%rax,%r12,8), %r15
addq $0x10, %r15
movq (%r15), %rax
testq %rax, %rax
jne 0x10dd7
movl 0x9484(%rip), %ecx      # 0x1a224
movl $0x10, %esi
movq %r14, %rdi
movl $0x2, %edx
callq 0x508a
movaps 0x12d7(%rip), %xmm0     # 0x12090
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, (%r15)
movq 0x18(%r14), %rax
leaq (%rax,%r12,8), %r15
addq $0x10, %r15
movq (%r15), %rax
testq %rax, %rax
je 0x10de6
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0x10de6
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0x10e01
movq %r15, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x56ce
movq 0x18(%r14), %rax
movq 0x10(%rax,%r12,8), %rax
movslq -0x10(%rax), %rcx
movw %bx, -0x2(%rax,%rcx,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x23df(%rip), %rdi      # 0x131fc
leaq 0x168d(%rip), %rsi      # 0x124b1
leaq 0x23dc(%rip), %rcx      # 0x13207
movl $0x2399, %edx           # imm = 0x2399
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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), %r12
leaq (%rax,%r12,8), %r15
addq $0x8, %r15
movq (%r15), %rax
testq %rax, %rax
jne 0x11250
movl 0x900b(%rip), %ecx      # 0x1a224
movl $0x10, %esi
movq %r14, %rdi
movl $0x2, %edx
callq 0x508a
movaps 0xe5e(%rip), %xmm0      # 0x12090
movups %xmm0, (%rax)
addq $0x10, %rax
movq %rax, (%r15)
movq 0x18(%r14), %rax
leaq (%rax,%r12,8), %r15
addq $0x8, %r15
movq (%r15), %rax
testq %rax, %rax
je 0x1125f
movl -0x10(%rax), %ecx
cmpl -0xc(%rax), %ecx
jge 0x1125f
incl %ecx
movl %ecx, -0x10(%rax)
jmp 0x1127a
movq %r15, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x56ce
movq 0x18(%r14), %rax
movq 0x8(%rax,%r12,8), %rax
movslq -0x10(%rax), %rcx
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_O3/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 %esi, %edx
leaq (%rdx,%rdx,2), %rdx
cmpw $0x0, (%rcx,%rdx,8)
je 0x112a5
retq
leaq (%rcx,%rdx,8), %rdx
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x112b8
cmpl $0x0, -0x10(%rsi)
jne 0x112a4
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x112a4
cmpl $0x1, -0x10(%rdx)
jne 0x112a4
movzwl (%rdx), %eax
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rdx
cmpw $0x0, (%rdx)
je 0x112a9
jmp 0x112a4
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeb6e(%rip), %rax      # 0x1fe50
movl %esi, %ecx
leaq (%rax,%rcx), %r8
movq 0xeb51(%rip), %rdx      # 0x1fe40
cmpq %rdx, %r8
ja 0x11326
cmpq %rdi, 0xeb4d(%rip)      # 0x1fe48
jbe 0x11302
incq %rdx
jmp 0x1131d
testl %esi, %esi
je 0x11324
xorl %edx, %edx
movb (%rdi,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x11308
addq %rdx, %rax
movq %rax, %rdx
movq %rdx, 0xeb2c(%rip)      # 0x1fe50
popq %rax
retq
leaq 0x1ff1(%rip), %rdi      # 0x1331e
leaq 0x117d(%rip), %rsi      # 0x124b1
leaq 0x2006(%rip), %rcx      # 0x13341
movl $0x27c3, %edx           # imm = 0x27C3
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeb00(%rip), %rdi      # 0x1fe50
movl %esi, %edx
leaq (%rdi,%rdx), %rbx
movq 0xeae3(%rip), %rcx      # 0x1fe40
cmpq %rcx, %rbx
ja 0x11384
cmpq %rax, 0xeac7(%rip)      # 0x1fe30
jbe 0x11373
incq %rcx
movq %rcx, %rbx
jmp 0x1137b
movq %rax, %rsi
callq 0x2230
movq %rbx, 0xeace(%rip)      # 0x1fe50
popq %rbx
retq
leaq 0x1f93(%rip), %rdi      # 0x1331e
leaq 0x111f(%rip), %rsi      # 0x124b1
leaq 0x1fcf(%rip), %rcx      # 0x13368
movl $0x27cb, %edx           # imm = 0x27CB
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b1c(%rip), %r12      # 0x4021
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x2537
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 0x2505
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x21c0
movq 0x3a7d(%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 0x2575
movq %rax, %rbx
movq 0x3a49(%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_O3/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 0x2677
leaq 0x19ac(%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 0x3930(%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 0x3906(%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_O3/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:
movl (%rdi), %eax
testl %eax, %eax
jle 0x2842
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rcx
movq (%rcx,%r15,8), %rcx
movslq (%rcx), %rsi
movq 0x8(%rbx), %rdx
cmpl $0x0, (%rdx,%rsi,4)
je 0x2833
movb 0x4(%rcx), %bpl
movq %rbx, %rdi
callq 0x2460
cmpb %bpl, %al
je 0x2845
movl (%r14), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x280a
xorl %eax, %eax
jmp 0x2847
xorl %eax, %eax
retq
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %eax
testl %eax, %eax
jle 0x28e2
movq %rsi, %r14
xorl %ebp, %ebp
movslq %ebp, %r15
movq 0x8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movslq (%rcx), %rsi
movq 0x8(%r14), %rdx
cmpl $0x0, (%rdx,%rsi,4)
je 0x28dc
movb 0x4(%rcx), %r12b
movq %r14, %rdi
callq 0x2460
cmpb %r12b, %al
je 0x28da
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
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 0x28c8
leaq (%rax,%r15,8), %rdi
subq %rsi, %rdx
callq 0x21d0
movq 0x10(%rbx), %rdx
addq $-0x8, %rdx
movq %rdx, 0x10(%rbx)
decl %ebp
movl (%rbx), %eax
decl %eax
movl %eax, (%rbx)
jmp 0x28dc
movl (%rbx), %eax
incl %ebp
cmpl %eax, %ebp
jl 0x2868
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2160
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
cmpl $0x0, (%rbx)
jle 0x2956
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r12
movl $0x8, %edi
callq 0x2160
movl (%r12), %ecx
movb 0x4(%r12), %dl
movl %ecx, (%rax)
movb %dl, 0x4(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2768
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x2920
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x21a0
cmpl $0x0, (%r14)
jle 0x29fb
leaq 0x20(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x167a(%rip), %r13      # 0x4021
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
callq 0x2644
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x2180
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2180
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x29f0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
incq %rbx
movslq (%r14), %rax
cmpq %rax, %rbx
jl 0x29a7
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x21c0
movq 0x35b4(%rip), %rsi      # 0x5fc8
leaq 0x30(%rsp), %rdi
callq 0x20c0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a42
movq %rax, %rbx
jmp 0x2a61
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2a61
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x3560(%rip), %rsi      # 0x5fc8
leaq 0x30(%rsp), %rdi
callq 0x20c0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl $0x0, (%rdi)
jle 0x2c1e
movq %rsi, %r14
movq %rdi, %r15
movslq %ebx, %r13
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %rdi
movq %r14, %rsi
callq 0x27f4
movq 0x8(%r15), %rcx
movq (%rcx,%r13,8), %r12
testb %al, %al
je 0x2bfc
testq %r12, %r12
je 0x2bb8
movq %r12, %rdi
callq 0x26dc
movl $0x20, %esi
movq %r12, %rdi
callq 0x2170
movq 0x8(%r15), %rax
movq 0x10(%r15), %rdx
leaq (%rax,%r13,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x2bea
leaq (%rax,%r13,8), %rdi
subq %rsi, %rdx
callq 0x21d0
movq 0x10(%r15), %rdx
addq $-0x8, %rdx
movq %rdx, 0x10(%r15)
movl (%r15), %eax
decl %eax
movl %eax, (%r15)
jmp 0x2c10
movq %r12, %rdi
movq %r14, %rsi
callq 0x2852
testb %al, %al
jne 0x2c1c
movl (%r15), %eax
incl %ebx
cmpl %eax, %ebx
jl 0x2b8c
xorl %ebx, %ebx
jmp 0x2c1e
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2afc
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b72
testb %al, %al
jne 0x2c5f
testb %bpl, %bpl
jne 0x2c34
xorl %eax, %eax
cmpl $0x0, (%rbx)
sete %al
jmp 0x2c64
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x20, %edi
callq 0x2160
movq %rax, %r14
movl 0x4(%rbx), %eax
movl $0x0, (%r14)
movl %eax, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq $0x0, 0x18(%r14)
cmpl $0x0, (%rbx)
jle 0x2d6c
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x28f6
movq %r14, %rdi
movq %rax, %rsi
callq 0x2c72
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x2d49
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x21a0
leaq 0x1277(%rip), %rsi      # 0x4018
movl $0xa, %edx
movq %r15, %rdi
callq 0x2180
movl (%r14), %esi
leaq 0x30(%rsp), %rdi
callq 0x2200
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq %rax, %r15
leaq 0x1234(%rip), %rsi      # 0x4023
movl $0x7, %edx
movq %rax, %rdi
callq 0x2180
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x2200
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq %rbx, 0x8(%rsp)
cmpl $0x0, (%r14)
jle 0x2ebc
leaq 0x20(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
callq 0x2966
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x2180
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2eb1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
incq %rbx
movslq (%r14), %rax
cmpq %rax, %rbx
jl 0x2e4e
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x21c0
movq 0x30f3(%rip), %rsi      # 0x5fc8
leaq 0x30(%rsp), %rdi
callq 0x20c0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f03
movq %rax, %rbx
jmp 0x2f22
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f22
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x309f(%rip), %rsi      # 0x5fc8
leaq 0x30(%rsp), %rdi
callq 0x20c0
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/aaronshim[P]SATurday/./parser.cpp
// Function: Parser::parse(_IO_FILE*)
Formula *Parser::parse(FILE *file) {
  int nClauses, nVars;
  fscanf(file, "p cnf %d %d", &nVars, &nClauses);

  Formula *formula = new Formula(nVars);

  for (int i = 0; i < nClauses; i ++) {
    Clause *clause = new Clause();
    formula->addClause(clause);

    // Get next literal.
    while (1) {
      int literal;
      int nScanned = fscanf(file, "%d", &literal);

      if (nScanned == 0 || literal == 0) break;

      clause->addLiteral(abs(literal) - 1, literal > 0);
    }
  }

  return formula;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10cb(%rip), %rsi      # 0x402b
leaq 0x24(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2220
movl $0x20, %edi
callq 0x2160
movl (%r14), %ecx
movl $0x0, (%rax)
movl %ecx, 0x4(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rax)
cmpl $0x0, (%r15)
jle 0x3071
leaq 0x4(%rsp), %r12
xorl %eax, %eax
movl %eax, 0x8(%rsp)
movl $0x20, %edi
callq 0x2160
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2c72
movq %rbx, %rdi
leaq 0x1050(%rip), %rsi      # 0x4034
movq %r12, %rdx
xorl %eax, %eax
callq 0x2220
testl %eax, %eax
sete %al
movl 0x4(%rsp), %r15d
testl %r15d, %r15d
sete %cl
orb %al, %cl
jne 0x3061
movq %r14, %rbp
addq $0x8, %rbp
movl %r15d, %r13d
negl %r13d
cmovsl %r15d, %r13d
decl %r13d
movl $0x8, %edi
callq 0x2160
testl %r15d, %r15d
movl %r13d, (%rax)
setg 0x4(%rax)
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x3516
incl (%r14)
movq %rbx, %rdi
leaq 0xfeb(%rip), %rsi       # 0x4034
movq %r12, %rdx
xorl %eax, %eax
callq 0x2220
testl %eax, %eax
je 0x3061
movl 0x4(%rsp), %r15d
testl %r15d, %r15d
jne 0x3009
movl 0x8(%rsp), %eax
incl %eax
cmpl 0xc(%rsp), %eax
jl 0x2fb2
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/aaronshim[P]SATurday/./solver.cpp
// Function: Solver::solve(Formula*)
Model *Solver::solve(Formula *formula) {
  Model *model = new Model(formula->getNVars());

  // // This is just testing code.
  // model->setVar(0);
  // model->setVar(1);
  // model->clearVar(2);
  // cout << model->toString() << endl;

  // Setup.
  srand(time(NULL));

  Model *solvedModel;

  // If nodes failed was surpassed, we restart.
  while (nodesFailed >= CUTOFF) {
    nodesFailed = 0;
    CUTOFF += GLOBAL_CUTOFF;
    solvedModel = solveR(formula, model, 0);
  }

  return solvedModel;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2160
movq %rax, %rbx
movslq 0x4(%r14), %rax
leaq (,%rax,4), %r15
testq %rax, %rax
movl %eax, (%rbx)
movq $-0x1, %rdi
cmovnsq %r15, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20d0
xorl %edi, %edi
callq 0x2110
movl %eax, %edi
callq 0x2120
movl 0x303b(%rip), %ecx      # 0x6128
movl $0x0, 0x304d(%rip)      # 0x6144
addl $0xc8, %ecx
movl %ecx, 0x3025(%rip)      # 0x6128
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x313c
movl 0x3012(%rip), %ecx      # 0x6128
cmpl %ecx, 0x3028(%rip)      # 0x6144
jge 0x30ed
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/aaronshim[P]SATurday/./solver.cpp
// Function: Solver::solveR(Formula*, Model*, int)
Model *Solver::solveR(Formula *formula, Model *model, int backtrackDepth) {
  invariant(formula != NULL, 2331);

  // Restart solver if nodes failed is above cutoff.
  if (nodesFailed >= CUTOFF) {
    return NULL;
  }

  int state = formula->simplify(model);
  switch (state) {
    case -1: // If unsat, return null.
      if (DEBUG >= 5)
        cout << "Unsatisfied model: " << model->toString() << endl;
      return NULL;
    case 1: // If sat, return the model.
      model->complete();
      return model->clone();
  }

  int nextIndex = formula->nextVar();
  invariant(!model->isAssigned(nextIndex), 1940);

  // Should we try setting the literal or clearing the literal first?
  int firstSet = rand() % 2;
  //int firstSet = 0;

  if (DEBUG >= 5)
    cout << "firstSet = " << firstSet << endl;

  Model *retModel;

  if (DEBUG >= 5) {
    cout << "Trying a value for " << nextIndex + 1 << " at depth " <<
      backtrackDepth << "..." << endl;
  }
  if (DEBUG >= 2) {
    if (backtrackDepth > maxDepth) {
      maxDepth = backtrackDepth;
    }
    cout << "progress: " << backtrackDepth << "/" << formula->getNVars() <<
            "\tnodes failed: " << nodesFailed << endl;
  }

  if ((retModel = solveRClone(formula, model, nextIndex, firstSet, backtrackDepth))) {
    nodesFailed = 0;
    return retModel;
  }

  if (DEBUG >= 5) {
    cout << "Backtracking... depth=" << backtrackDepth << endl;
  }

  if ((retModel = solveRClone(formula, model, nextIndex, !firstSet, backtrackDepth))) {
    nodesFailed = 0;
    return retModel;
  }

  nodesFailed ++;

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
testq %r14, %r14
setne %dil
movl $0x91b, %esi            # imm = 0x91B
callq 0x238c
movl 0x2fdf(%rip), %eax      # 0x6144
cmpl 0x2fbd(%rip), %eax      # 0x6128
jge 0x3243
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c2a
cmpl $-0x1, %eax
je 0x3243
cmpl $0x1, %eax
jne 0x31c0
movl (%rbx), %eax
testl %eax, %eax
jle 0x31b0
movq 0x8(%rbx), %rcx
xorl %edx, %edx
cmpl $0x0, (%rcx,%rdx,4)
jne 0x31a5
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movl (%rbx), %eax
incq %rdx
movslq %eax, %rsi
cmpq %rsi, %rdx
jl 0x3196
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x259c
movq %r14, %rdi
callq 0x2cb0
movl %eax, %r15d
movq 0x8(%rbx), %rax
movslq %r15d, %rcx
xorl %edi, %edi
cmpl $0x0, (%rax,%rcx,4)
sete %dil
movl $0x794, %esi            # imm = 0x794
callq 0x238c
callq 0x2050
movl %eax, %r12d
shrl $0x1f, %eax
addl %r12d, %eax
andl $-0x2, %eax
subl %eax, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x324e
testq %rax, %rax
jne 0x3231
xorl %ecx, %ecx
testl %r12d, %r12d
sete %cl
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %r8d
callq 0x324e
testq %rax, %rax
je 0x323d
movl $0x0, 0x2f09(%rip)      # 0x6144
jmp 0x3245
incl 0x2f01(%rip)            # 0x6144
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aaronshim[P]SATurday/./solver.cpp
// Function: Solver::solveRClone(Formula*, Model*, int, int, int)
Model *Solver::solveRClone(Formula *formula, Model *model, int index, int setVar, int backtrackDepth) {
  Model *modelClone = model->clone();
  Formula *formulaClone = formula->clone();
  if (setVar) {
    modelClone->setVar(index);
  } else {
    modelClone->clearVar(index);
  }
  Model *retModel = solveR(formulaClone, modelClone, backtrackDepth + 1);
  delete formulaClone;
  delete modelClone;
  return retModel;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %r12
movq %rsi, %rdi
callq 0x259c
movq %rax, %rbx
movq %r12, %rdi
callq 0x2d0e
movq %rax, %r12
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x1, %r14d
sbbl %ecx, %ecx
movslq %r15d, %rdx
orl $0x1, %ecx
movl %ecx, (%rax,%rdx,4)
incl %ebp
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x313c
movq %rax, %r14
movq %r12, %rdi
callq 0x2a88
movl $0x20, %esi
movq %r12, %rdi
callq 0x2170
movq 0x8(%rbx), %rdi
movl $0x4, %esi
callq 0x2170
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2170
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dacunni[P]stlloader/./stlloader.h
// Function: stlloader::parse_ascii_stream(std::istream&, stlloader::Mesh&)
void parse_ascii_stream(std::istream & is, Mesh & mesh)
{
    std::string line, kind;
    while(std::getline(is, line)) {
        std::istringstream ss(line);
        ss >> kind;
        if(kind == "solid") {
            ss.ignore(line.length(), ' ');
            std::getline(ss, mesh.name);
            parse_ascii_solid(is, mesh);
        }
        else { throw; }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x18(%rsi), %r12
leaq 0x8(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x28(%rsp), %rbx
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2e93
movq %rbp, %rdi
movq %r13, %rsi
movl $0x8, %edx
callq 0x22e0
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2220
movq %rbx, %rdi
leaq 0x1239(%rip), %rsi      # 0x405d
callq 0x2070
testl %eax, %eax
jne 0x2edd
movq 0x10(%rsp), %rsi
movq %rbp, %rdi
movl $0x20, %edx
callq 0x2110
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2340
movq %r15, %rdi
movq %r14, %rsi
callq 0x2adb
movq %rbp, %rdi
movq 0x313c(%rip), %rsi      # 0x5fb8
callq 0x2250
leaq 0xc0(%rsp), %rdi
callq 0x2090
jmp 0x2dcb
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2eaf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2ecb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2260
jmp 0x2ee6
jmp 0x2eeb
movq %rax, %rbx
jmp 0x2f0c
movq %rax, %rbx
movq 0x30c3(%rip), %rsi      # 0x5fb8
leaq 0x48(%rsp), %rdi
callq 0x2250
leaq 0xc0(%rsp), %rdi
callq 0x2090
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2f28
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/dacunni[P]stlloader/./stlloader.h
// Function: float stlloader::little_endian_to_native<float>(float)
float little_endian_to_native(float v) {
    uint32_t vntemp;
    std::memcpy(&vntemp, &v, sizeof(vntemp));
    vntemp = little_endian_to_native(vntemp);
    float result;
    std::memcpy(&result, &vntemp, sizeof(vntemp)); 
    return result;
}

// Assembly:
leaq -0x4(%rsp), %rax
movss %xmm0, (%rax)
xorl %ecx, %ecx
xorl %edx, %edx
movzbl (%rax), %esi
shll %cl, %esi
addl %esi, %edx
addq $0x8, %rcx
incq %rax
cmpq $0x20, %rcx
jne 0x2f59
movd %edx, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/dacunni[P]stlloader/./stlloader.h
// Function: unsigned short stlloader::read_binary_value<unsigned short>(std::istream&)
uint16_t read_binary_value(std::istream & is) {
    uint16_t value;
    is.read((char*)&value, 2);
    value = little_endian_to_native(value);
    return value;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xe(%rsp), %rbx
movl $0x2, %edx
movq %rbx, %rsi
callq 0x2210
movzwl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/dacunni[P]stlloader/./stlloader.h
// Function: unsigned int stlloader::read_binary_value<unsigned int>(std::istream&)
uint32_t read_binary_value(std::istream & is) {
    uint32_t value;
    is.read((char*)&value, 4);
    value = little_endian_to_native(value);
    return value;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movl $0x4, %edx
movq %rbx, %rsi
callq 0x2210
movl (%rbx), %eax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rdx), %esi
shll %cl, %esi
addl %esi, %eax
addq $0x8, %rcx
incq %rdx
cmpq $0x20, %rcx
jne 0x2fb6
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/dacunni[P]stlloader/./stlloader.h
// Function: stlloader::Normal stlloader::read_binary_value<stlloader::Normal>(std::istream&)
Normal read_binary_value(std::istream & is) {
    Normal n;
    n.x = read_binary_value<float>(is);
    n.y = read_binary_value<float>(is);
    n.z = read_binary_value<float>(is);
    return n;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2fd0
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x2fd0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2fd0
movaps %xmm0, %xmm1
movaps 0x10(%rsp), %xmm0
unpcklps (%rsp), %xmm0           # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
addq $0x20, %rsp
popq %rbx
retq