LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movl 0x10(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
imull 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movl 0x10(%rsp), %eax
imull 0x18(%rsp), %eax
addl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jae 0x1bf56
movq 0x20(%rsp), %rdi
callq 0x1bf80
jmp 0x1bf58
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jae 0x1bf7a
movq 0x20(%rsp), %rdi
callq 0x1c010
jmp 0x1bf58
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x14(%rax)
je 0x1bf96
jmp 0x1bfb5
leaq 0x44ac(%rip), %rdi      # 0x20449
leaq 0x33e5(%rip), %rsi      # 0x1f389
movl $0x2b4f, %edx           # imm = 0x2B4F
leaq 0x44ae(%rip), %rcx      # 0x2045e
callq 0x2140
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x1b450
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1bffe
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
callq 0x1b450
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1bfd3
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movl 0x10(%rsp), %eax
shrl %cl, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
imull 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
movl 0x10(%rsp), %eax
imull 0x18(%rsp), %eax
addl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jae 0x1c0d4
movq 0x20(%rsp), %rdi
callq 0x1bf80
jmp 0x1c0d6
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jae 0x1c0f8
movq 0x20(%rsp), %rdi
callq 0x1c010
jmp 0x1c0d6
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
xorl %edx, %edx
divl 0xc(%rsp)
movl %eax, (%rsp)
movl (%rsp), %edx
imull 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movl (%rsp), %ecx
imull 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
cmpl $0x1000000, 0xc(%rax)   # imm = 0x1000000
jae 0x1c1c5
movq 0x10(%rsp), %rdi
callq 0x1c1d0
jmp 0x1c1ab
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
movl 0xc(%rsp), %ecx
shrl %cl, %eax
movl %eax, (%rsp)
movl (%rsp), %edx
imull 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movl (%rsp), %ecx
imull 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
cmpl $0x1000000, 0xc(%rax)   # imm = 0x1000000
jae 0x1c305
movq 0x10(%rsp), %rdi
callq 0x1c1d0
jmp 0x1c2eb
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %esi
shrl $0x18, %esi
callq 0x1c370
movq (%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %esi
shrl $0x10, %esi
callq 0x1c370
movq (%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %esi
shrl $0x8, %esi
callq 0x1c370
movq (%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %esi
shrl $0x0, %esi
callq 0x1c370
movq (%rsp), %rdi
callq 0x1c480
movq (%rsp), %rax
movq 0x18(%rax), %rax
popq %rcx
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x14(%rax)
je 0x1c43b
movq 0x10(%rsp), %rax
cmpl $-0x1, 0x14(%rax)
jne 0x1c3cf
cmpl $0xff, 0xc(%rsp)
jne 0x1c3b5
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x1b450
jmp 0x1c3cd
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x14(%rax)
jmp 0x1c439
cmpl $0xff, 0xc(%rsp)
jne 0x1c3e9
movq 0x10(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x1c437
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x1b450
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1c435
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movl $0xff, %esi
callq 0x1b450
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1c407
jmp 0x1c437
jmp 0x1c439
jmp 0x1c479
cmpl $0xff, 0xc(%rsp)
jne 0x1c455
movq 0x10(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x1c477
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x1b450
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x1c479
addq $0x18, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__arith_flush
static void stb__arith_flush(stb_arith *a)
{
   if (a->pending_ffs >= 0) {
      int i;
      stb_putc(a->output, a->buffered_u8);
      for (i=0; i < a->pending_ffs; ++i)
         stb_putc(a->output, 0xff);
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jl 0x1c4e2
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x1b450
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1c4e0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movl $0xff, %esi
callq 0x1b450
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c4b2
jmp 0x1c4e2
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0xf887(%rip)      # 0x2c018
je 0x1c7d5
movq 0xf87e(%rip), %rdx      # 0x2c018
movq 0x8(%rsp), %rcx
leaq 0xf87a(%rip), %rdi      # 0x2c020
leaq 0x2d35(%rip), %rsi      # 0x1f4e2
movb $0x0, %al
callq 0x2350
leaq 0xf865(%rip), %rdi      # 0x2c020
callq 0xd060
cmpl $0x0, %eax
je 0x1c7d3
leaq 0xf854(%rip), %rax      # 0x2c020
movq %rax, 0x10(%rsp)
jmp 0x1c833
jmp 0x1c7d5
movq 0x8(%rsp), %rdi
callq 0xd060
cmpl $0x0, %eax
je 0x1c7f0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1c833
movq 0x8(%rsp), %rdx
leaq 0xf824(%rip), %rdi      # 0x2c020
leaq 0x3629(%rip), %rsi      # 0x1fe2c
movb $0x0, %al
callq 0x2350
leaq 0xf80f(%rip), %rdi      # 0x2c020
callq 0xd060
cmpl $0x0, %eax
jne 0x1c829
leaq 0xf7fe(%rip), %rax      # 0x2c020
movq %rax, 0x10(%rsp)
jmp 0x1c833
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__try_chunk
static void * stb__try_chunk(stb__chunk *c, int size, int align, int pre_align)
{
   char *memblock = (char *) (c+1), *q;
   stb_inta iq;
   int start_offset;

   // we going to allocate at the end of the chunk, not the start. confusing,
   // but it means we don't need both a 'limit' and a 'cur', just a 'cur'.
   // the block ends at: p + c->data_left
   //   then we move back by size
   start_offset = c->data_left - size;

   // now we need to check the alignment of that
   q = memblock + start_offset;
   iq = (stb_inta) q;
   assert(sizeof(q) == sizeof(iq));

   // suppose align = 2
   // then we need to retreat iq far enough that (iq & (2-1)) == 0
   // to get (iq & (align-1)) = 0 requires subtracting (iq & (align-1))

   start_offset -= iq & (align-1);
   assert(((stb_uinta) (memblock+start_offset) & (align-1)) == 0);

   // now, if that + pre_align works, go for it!
   start_offset -= pre_align;

   if (start_offset >= 0) {
      c->data_left = start_offset;
      return memblock + start_offset;
   }

   return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
subl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movl 0x30(%rsp), %eax
subl $0x1, %eax
cltq
andq %rax, %rcx
movslq 0xc(%rsp), %rax
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
movl 0x30(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x1cade
jmp 0x1cafd
leaq 0x344c(%rip), %rdi      # 0x1ff31
leaq 0x289d(%rip), %rsi      # 0x1f389
movl $0xa68, %edx            # imm = 0xA68
leaq 0x3470(%rip), %rcx      # 0x1ff68
callq 0x2140
movl 0x2c(%rsp), %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x1cb32
movl 0xc(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
jmp 0x1cb3b
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__sort_chunks
static void stb__sort_chunks(stb__alloc *src)
{
   // of the first two chunks, put the chunk with more data left in it first
   stb__chunk *c = stb__chunks(src), *d;
   if (c == NULL) return;
   d = c->next;
   if (d == NULL) return;
   if (c->data_left > d->data_left) return;

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

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
addq $-0x2, %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x1cb71
jmp 0x1cbcb
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x1cb88
jmp 0x1cbcb
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x1cb9c
jmp 0x1cbcb
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
addq $0x2, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movb $0x0, 0x2a(%rsp)
movq $0x0, 0x38(%rsp)
movw $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1d995
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x1d99d
xorl %eax, %eax
movl %eax, 0x24(%rsp)
jmp 0x1d99d
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1d9c6
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1d9ce
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1d9ce
movl 0x20(%rsp), %eax
movl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jle 0x1d9f4
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl $0x18, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x1da06
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1da32
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x1da3a
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1da3a
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rsp), %rcx
movq %rcx, -0x18(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, -0x8(%rax)
movq 0x40(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1da86
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x1da8e
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x1da8e
movl 0x8(%rsp), %eax
subl $0x1, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0x1dabd
jmp 0x1dadc
leaq 0x2649(%rip), %rdi      # 0x2010d
leaq 0x18be(%rip), %rsi      # 0x1f389
movl $0x2399, %edx           # imm = 0x2399
leaq 0x2641(%rip), %rcx      # 0x20118
callq 0x2140
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0x1db1b
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x2c(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq 0x30(%rsp), %rsi
callq 0x7bc0
movl 0x28(%rsp), %eax
movw %ax, 0x26(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x1db62
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x20(%rsp)
jmp 0x1db6a
xorl %eax, %eax
movl %eax, 0x20(%rsp)
jmp 0x1db6a
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x1dbb3
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0xc(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x1dbbb
xorl %eax, %eax
movl %eax, 0x18(%rsp)
jmp 0x1dbbb
movl 0x1c(%rsp), %eax
movl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jle 0x1dbf1
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x2c(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x1dc13
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x1dc6f
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x1dc77
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1dc77
movq 0x10(%rsp), %rax
movw 0x26(%rsp), %dx
movl 0xc(%rsp), %ecx
movslq %ecx, %rcx
movw %dx, -0x2(%rax,%rcx,2)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl 0x24(%rsp), %eax
movw %ax, 0x20(%rsp)
movl 0x28(%rsp), %eax
movw %ax, 0x22(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0x1e4e6
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x2c(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0x7bc0
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x1e524
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1e52c
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1e52c
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x1e575
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0xc(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x1e57d
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x1e57d
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jle 0x1e5b3
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x2c(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x8, %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x8030
jmp 0x1e5d5
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x1e631
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x1e639
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x1e639
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movslq %ecx, %rcx
movl 0x20(%rsp), %edx
movl %edx, -0x4(%rax,%rcx,4)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__optimize
static void stb__optimize(stb_matcher *m)
{
   // if the target of any edge is a node with exactly
   // one out-epsilon, shorten it
   int i,j;
   for (i=0; i < stb_arr_len(m->nodes); ++i) {
      stb_nfa_node *p = &m->nodes[i];
      for (j=0; j < stb_arr_len(p->out); ++j)
         p->out[j].node = stb__opt(m,p->out[j].node);
      for (j=0; j < stb_arr_len(p->eps); ++j)
         p->eps[j]      = stb__opt(m,p->eps[j]     );
   }
   m->start_node = stb__opt(m,m->start_node);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e697
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x1e69f
xorl %eax, %eax
movl %eax, 0x18(%rsp)
jmp 0x1e69f
movl 0x1c(%rsp), %eax
movl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1e7dd
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1e6f7
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x1e6ff
xorl %eax, %eax
movl %eax, 0x10(%rsp)
jmp 0x1e6ff
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1e74b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x28(%rsp), %rcx
movzwl 0x2(%rax,%rcx,4), %esi
callq 0x1e8c0
movw %ax, %dx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x28(%rsp), %rcx
movw %dx, 0x2(%rax,%rcx,4)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1e6d1
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e779
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x1e781
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x1e781
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1e7cb
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x28(%rsp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0x1e8c0
movw %ax, %dx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x28(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1e753
jmp 0x1e7cd
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1e671
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movzwl (%rax), %esi
callq 0x1e8c0
movw %ax, %cx
movq 0x30(%rsp), %rax
movw %cx, (%rax)
addq $0x38, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb__clear_goalcheck
static int stb__clear_goalcheck(stb_matcher *m, stb_uint16 *list)
{
   int i, t=0;
   for (i=0; i < stb_arr_len(list); ++i) {
      t += m->nodes[(int) list[i]].goal;
      m->nodes[(int) list[i]].active = 0;
   }
   return t;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x1c(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x1e838
movq -0x10(%rsp), %rax
movl -0x10(%rax), %eax
movl %eax, -0x20(%rsp)
jmp 0x1e840
xorl %eax, %eax
movl %eax, -0x20(%rsp)
jmp 0x1e840
movl -0x1c(%rsp), %eax
movl -0x20(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1e8ad
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movswl (%rax), %eax
addl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq -0x14(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x2(%rax)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1e81a
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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 %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpw $0x0, (%rax)
je 0x1e8f8
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x1e975
movq -0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1e915
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, -0x10(%rax)
jne 0x1e91d
jmp 0x1e927
xorl %eax, %eax
testb $0x1, %al
jne 0x1e91d
jmp 0x1e927
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x1e975
movq -0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e945
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rax), %eax
movl %eax, -0x24(%rsp)
jmp 0x1e94d
xorl %eax, %eax
movl %eax, -0x24(%rsp)
jmp 0x1e94d
movl -0x24(%rsp), %eax
cmpl $0x1, %eax
je 0x1e960
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x1e975
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x1e8c9
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0xd62c(%rip), %rax      # 0x2bfc0
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0xd60e(%rip), %rax      # 0x2bfb0
ja 0x1e9a6
jmp 0x1e9c5
leaq 0x1886(%rip), %rdi      # 0x20233
leaq 0x9d5(%rip), %rsi       # 0x1f389
movl $0x27c3, %edx           # imm = 0x27C3
leaq 0x1896(%rip), %rcx      # 0x20256
callq 0x2140
movq 0xd5f4(%rip), %rax      # 0x2bfc0
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0xd5d6(%rip), %rax      # 0x2bfb0
jbe 0x1e9f5
movl 0xc(%rsp), %ecx
movq 0xd5d9(%rip), %rax      # 0x2bfc0
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xd5cd(%rip)      # 0x2bfc0
jmp 0x1ea57
movq 0x10(%rsp), %rax
cmpq 0xd5b7(%rip), %rax      # 0x2bfb8
jae 0x1ea17
movq 0xd5a6(%rip), %rax      # 0x2bfb0
addq $0x1, %rax
movq %rax, 0xd5ab(%rip)      # 0x2bfc0
jmp 0x1ea57
jmp 0x1ea19
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x0, %eax
je 0x1ea57
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0xd57b(%rip), %rax      # 0x2bfc0
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xd56d(%rip)      # 0x2bfc0
movb %cl, (%rax)
jmp 0x1ea19
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0xd54c(%rip), %rax      # 0x2bfc0
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0xd52e(%rip), %rax      # 0x2bfb0
ja 0x1ea86
jmp 0x1eaa5
leaq 0x17a6(%rip), %rdi      # 0x20233
leaq 0x8f5(%rip), %rsi       # 0x1f389
movl $0x27cb, %edx           # imm = 0x27CB
leaq 0x17dd(%rip), %rcx      # 0x2027d
callq 0x2140
movq 0xd514(%rip), %rax      # 0x2bfc0
movl 0xc(%rsp), %ecx
addq %rcx, %rax
cmpq 0xd4f6(%rip), %rax      # 0x2bfb0
jbe 0x1ead5
movl 0xc(%rsp), %ecx
movq 0xd4f9(%rip), %rax      # 0x2bfc0
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xd4ed(%rip)      # 0x2bfc0
jmp 0x1eb25
movq 0x10(%rsp), %rax
cmpq 0xd4bf(%rip), %rax      # 0x2bfa0
jae 0x1eaf7
movq 0xd4c6(%rip), %rax      # 0x2bfb0
addq $0x1, %rax
movq %rax, 0xd4cb(%rip)      # 0x2bfc0
jmp 0x1eb25
movq 0xd4c2(%rip), %rdi      # 0x2bfc0
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x2230
movl 0xc(%rsp), %ecx
movq 0xd4a7(%rip), %rax      # 0x2bfc0
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xd49b(%rip)      # 0x2bfc0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_matchlen
static unsigned int stb_matchlen(stb_uchar *m1, stb_uchar *m2, stb_uint maxlen)
{
   stb_uint i;
   for (i=0; i < maxlen; ++i)
      if (m1[i] != m2[i]) return i;
   return i;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jae 0x1ed27
movq -0x10(%rsp), %rax
movl -0x20(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movl -0x20(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1ed18
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x1ed2f
jmp 0x1ed1a
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x1ece6
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_out_backpatch
static void stb_out_backpatch(size_t id, stb_uint value)
{
   stb_uchar data[4] = { value >> 24, value >> 16, value >> 8, value };
   if (stb__out) {
      memcpy((void *) id, data, 4);
   } else {
      stb_uint where = ftell(stb__outfile);
      fseek(stb__outfile, id, SEEK_SET);
      fwrite(data, 4, 1, stb__outfile);
      fseek(stb__outfile, where, SEEK_SET);
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
shrl $0x18, %eax
movb %al, 0x8(%rsp)
movl 0xc(%rsp), %eax
shrl $0x10, %eax
movb %al, 0x9(%rsp)
movl 0xc(%rsp), %eax
shrl $0x8, %eax
movb %al, 0xa(%rsp)
movl 0xc(%rsp), %eax
movb %al, 0xb(%rsp)
cmpq $0x0, 0xd0ea(%rip)      # 0x2bfc8
je 0x1eeed
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x1ef3f
movq 0xd0dc(%rip), %rdi      # 0x2bfd0
callq 0x2200
movl %eax, 0x4(%rsp)
movq 0xd0cc(%rip), %rdi      # 0x2bfd0
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x22a0
leaq 0x8(%rsp), %rdi
movq 0xd0b4(%rip), %rcx      # 0x2bfd0
movl $0x4, %esi
movl $0x1, %edx
callq 0x2370
movq 0xd09e(%rip), %rdi      # 0x2bfd0
movl 0x4(%rsp), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22a0
addq $0x18, %rsp
retq
// File: aaronshim[P]SATurday/./model.cpp
// Function: Model::checkVar(int)
bool Model::checkVar(int i) {
  if (vars[i] == 1) {
    return true;
  }

  if (vars[i] == -1) {
    return false;
  }

  throw 1337; // value was not originally set
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x253b
movb $0x1, -0x1(%rbp)
jmp 0x2576
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x2553
movb $0x0, -0x1(%rbp)
jmp 0x2576
movl $0x4, %edi
callq 0x2090
movq %rax, %rdi
movl $0x539, (%rdi)          # imm = 0x539
movq 0x8a43(%rip), %rsi      # 0xafb0
xorl %eax, %eax
movl %eax, %edx
callq 0x21c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2190
movl $0x0, -0x18c(%rbp)
movq -0x1a8(%rbp), %rcx
movl -0x18c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x26ff
movq -0x1a8(%rbp), %rcx
movslq -0x18c(%rbp), %rdx
movl %edx, %eax
incl %eax
movq 0x8(%rcx), %rcx
movl (%rcx,%rdx,4), %ecx
imull %ecx, %eax
movl %eax, -0x190(%rbp)
movl -0x190(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x21d0
movq %rax, -0x1c0(%rbp)
jmp 0x26b7
movq -0x1c0(%rbp), %rdi
leaq 0x495c(%rip), %rsi      # 0x7021
callq 0x2120
jmp 0x26cc
jmp 0x26ce
movl -0x18c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18c(%rbp)
jmp 0x2665
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2040
jmp 0x2730
movq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2160
jmp 0x2714
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2190
movq -0x1a0(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0x28af
leaq 0x4797(%rip), %rsi      # 0x7016
leaq -0x188(%rbp), %rdi
callq 0x2120
jmp 0x288d
jmp 0x28af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2040
jmp 0x28f9
movq -0x1a0(%rbp), %rax
movl (%rax), %esi
incl %esi
leaq -0x188(%rbp), %rdi
callq 0x21d0
jmp 0x28c8
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2160
jmp 0x28dd
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x1a8(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2c06
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3f30
movq (%rax), %rdi
callq 0x3f50
movq -0x30(%rbp), %rdi
movl %eax, -0x20(%rbp)
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3f30
movq (%rax), %rdi
callq 0x3f60
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x2590
testb $0x1, %al
jne 0x2bca
jmp 0x2bf8
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x2510
andb $0x1, %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2bf6
movb $0x1, -0x1(%rbp)
jmp 0x2c0a
jmp 0x2bf8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2b6f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x48(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2d5d
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3f30
movq (%rax), %rdi
callq 0x3f50
movq -0x48(%rbp), %rdi
movl %eax, -0x18(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3f30
movq (%rax), %rdi
callq 0x3f60
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2590
testb $0x1, %al
jne 0x2c9d
jmp 0x2d4f
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2510
andb $0x1, %al
movzbl %al, %eax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x2d4d
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3f30
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x2ceb
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x2150
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x3d30
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3ff0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4030
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3f80
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x2d4f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c3f
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x3f10
cmpq $0x0, %rax
sete %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x20b0
movq -0x20(%rbp), %rdi
callq 0x4070
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2e0c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3f30
movq (%rax), %rdi
callq 0x27c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2a50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2dc9
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2190
movl $0x0, -0x18c(%rbp)
movq -0x1c8(%rbp), %rcx
movl -0x18c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x2f27
movq -0x1c8(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18c(%rbp), %rsi
callq 0x3f30
movq (%rax), %rsi
leaq -0x1b0(%rbp), %rdi
callq 0x2830
jmp 0x2ea2
leaq -0x188(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x20f0
movq %rax, -0x1e0(%rbp)
jmp 0x2ebe
movq -0x1e0(%rbp), %rdi
leaq 0x4155(%rip), %rsi      # 0x7021
callq 0x2120
jmp 0x2ed3
leaq -0x1b0(%rbp), %rdi
callq 0x20c0
movl -0x18c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18c(%rbp)
jmp 0x2e65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x2f58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x20c0
jmp 0x2f58
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2160
jmp 0x2f3c
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x1b8(%rbp), %rdi
callq 0x21e0
// File: aaronshim[P]SATurday/./formula.cpp
// Function: Formula::unitPropagate(Model*)
bool Formula::unitPropagate(Model *model) {
  bool changed = false;

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

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

    changed = true;
  }

  return changed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x11(%rbp)
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4100
testb $0x1, %al
jne 0x307d
jmp 0x30f1
leaq -0x28(%rbp), %rdi
callq 0x4140
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2a90
cmpl $0x1, %eax
jle 0x309d
jmp 0x30e3
movq -0x38(%rbp), %rdi
callq 0x2b00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3f50
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3f60
testb $0x1, %al
jne 0x30c5
jmp 0x30d3
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x24d0
jmp 0x30df
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x24f0
movb $0x1, -0x11(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4160
jmp 0x306a
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: aaronshim[P]SATurday/./formula.cpp
// Function: Formula::deleteSatisfied(Model*)
bool Formula::deleteSatisfied(Model *model) {
  for (int i = 0; i < nClauses; i ++) {
    if (clauses[i]->checkSat(model)) {
      delete clauses[i];
      clauses.erase(clauses.begin() + i);

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

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3228
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x41e0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2b50
testb $0x1, %al
jne 0x3154
jmp 0x31ed
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x41e0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x3189
movq -0x50(%rbp), %rdi
callq 0x2910
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x2150
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x40a0
movq %rax, -0x38(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4270
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x42b0
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4200
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x3218
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x41e0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c20
testb $0x1, %al
jne 0x3210
jmp 0x3216
movb $0x1, -0x1(%rbp)
jmp 0x322c
jmp 0x3218
jmp 0x321a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x311f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x3292
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3030
movq -0x28(%rbp), %rdi
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3100
testb $0x1, %al
jne 0x3287
jmp 0x3290
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32b5
jmp 0x325c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32c0
testb $0x1, %al
jne 0x32a5
jmp 0x32ae
movl $0x1, -0x4(%rbp)
jmp 0x32b5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: aaronshim[P]SATurday/./formula.cpp
// Function: Formula::nextVar()
int Formula::nextVar() {
  // Find the clause with lowest number of undecided literals.
  Clause *minClause = NULL;
  for (auto c : clauses) {
    if (!minClause || c->getNumLiterals() < minClause->getNumLiterals()) {
      minClause = c;
    }
  }
  invariant(minClause, 4939);

  // Use first literal?
  int vari = minClause->getFirstLiteralIndex();

  return vari;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x10(%rbp)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4100
testb $0x1, %al
jne 0x338d
jmp 0x33d7
leaq -0x20(%rbp), %rdi
callq 0x4140
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x33c2
movq -0x30(%rbp), %rdi
callq 0x2a90
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a90
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jge 0x33ca
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x33cc
leaq -0x20(%rbp), %rdi
callq 0x4160
jmp 0x337a
cmpq $0x0, -0x10(%rbp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x134b, %esi           # imm = 0x134B
callq 0x2360
movq -0x10(%rbp), %rdi
callq 0x2aa0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)