LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::clear()
void clear()
        {
            if (m_first_arena) {
                size_t init_size = m_first_arena->get_stored_item_count();
                boost_intrusive_pool_arena<Item>* pcurr = m_first_arena;
                while (pcurr) {
                    boost_intrusive_pool_arena<Item>* pnext = pcurr->get_next_arena();
                    delete pcurr;
                    pcurr = pnext;
                }
            } else {
                // this memory pool has just been clear()ed... the last arena pointer should be null as well:
                assert(m_last_arena == nullptr);
            }

            // status
            m_first_free_item = nullptr;
            m_first_arena = nullptr;
            m_last_arena = nullptr;
            m_memory_exhausted = false;

            // stats
            m_free_count = 0;
            m_inuse_count = 0;
            m_total_count = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x40(%rax)
je 0x61ab
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x6220
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61a9
movq -0x18(%rbp), %rdi
callq 0x6240
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x619f
movq -0x30(%rbp), %rdi
callq 0x6260
movq -0x30(%rbp), %rdi
callq 0x2370
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x616b
jmp 0x61d9
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x61b8
jmp 0x61d7
leaq 0x38be(%rip), %rdi      # 0x9a7d
leaq 0x3514(%rip), %rsi      # 0x96da
movl $0x2f3, %edx            # imm = 0x2F3
leaq 0x38c3(%rip), %rcx      # 0x9a95
callq 0x20a0
jmp 0x61d9
movq -0x28(%rbp), %rax
movq $0x0, 0x50(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movb $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool_arena<DummyClass>::~boost_intrusive_pool_arena()
~boost_intrusive_pool_arena()
    {
        // m_storage is automatically cleaned up
        if (m_storage) {
            delete[] m_storage;
            m_storage = nullptr;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x62ed
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x62e1
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
imulq $0x420, -0x8(%rcx), %rdx # imm = 0x420
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x20(%rbp)
je 0x62d8
movq -0x20(%rbp), %rdi
addq $-0x420, %rdi           # imm = 0xFBE0
movq %rdi, -0x30(%rbp)
callq 0x4180
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x20(%rbp)
jne 0x62b3
movq -0x28(%rbp), %rdi
callq 0x2150
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::trigger_self_destruction()
void trigger_self_destruction()
        {
            m_trigger_self_destruction = true;

            // walk over the free list and reduce our own refcount by removing the link between the items and ourselves:
            // this is important because it allows the last item that will return to this pool to trigger the pool
            // dtor: see recycle() implementation
            boost_intrusive_pool_item* pcurr = m_first_free_item;
            while (pcurr) {
                pcurr->_refcounted_item_set_pool(nullptr);
                pcurr = pcurr->_refcounted_item_get_next();
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x78(%rax)
movq 0x50(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x697f
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x1, %edx
callq 0x43b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x63b0
jmp 0x6950
leaq -0x18(%rbp), %rdi
callq 0x4300
movq -0x10(%rbp), %rdi
callq 0x6300
movq %rax, -0x10(%rbp)
jmp 0x691c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4300
jmp 0x6985
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2190
nop
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::get_effective_enlarge_step() const
size_t get_effective_enlarge_step() const
        {
            size_t enlarge_step = m_enlarge_step;
            if (m_enlarge_step > 0 && (m_max_size > 0 && (m_total_count + m_enlarge_step > m_max_size)))
                enlarge_step = m_max_size - m_total_count; // enlarge_step can be zero if we reach the max_size
            return enlarge_step;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x30(%rax)
jbe 0x6c7c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x6c7c
movq -0x18(%rbp), %rcx
movq 0x70(%rcx), %rax
addq 0x30(%rcx), %rax
cmpq 0x38(%rcx), %rax
jbe 0x6c7c
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rax
subq 0x70(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: main
int main(int argc, char **argv){
    ck_cdcl_solver::Solver solver;
    if(argc == 1) {
      std::cout << "Please specify the input file." << std::endl;
    }
    std::string filename = argv[1];
    solver.parse(filename);  // parse input file
    solver.solve();
    solver.printResult();  // print answer
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movl $0x0, 0x124(%rsp)
movl %edi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x25e0
cmpl $0x1, 0x120(%rsp)
jne 0x24d7
movq 0x10b3c(%rip), %rdi     # 0x12fd8
leaq 0xab65(%rip), %rsi      # 0xd008
callq 0x21a0
movq %rax, 0x18(%rsp)
jmp 0x24af
movq 0x18(%rsp), %rdi
movq 0x10b0d(%rip), %rsi     # 0x12fc8
callq 0x21d0
jmp 0x24c2
jmp 0x24d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x25ca
movq 0x118(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x22e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x2640
jmp 0x250d
leaq 0x47(%rsp), %rdi
callq 0x21f0
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20b0
jmp 0x2528
leaq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2700
jmp 0x2539
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0x78(%rsp), %rdi
callq 0x2eb0
jmp 0x254f
leaq 0x78(%rsp), %rdi
callq 0x3140
jmp 0x255b
leaq 0x48(%rsp), %rdi
callq 0x2100
leaq 0x78(%rsp), %rdi
callq 0x3240
movl 0x124(%rsp), %eax
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x21f0
jmp 0x25ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x25c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0x48(%rsp), %rdi
callq 0x2100
leaq 0x78(%rsp), %rdi
callq 0x3240
movq 0x70(%rsp), %rdi
callq 0x22d0
nop
// File: kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: ck_cdcl_solver::Solver::printResult()
void printResult(){
            if(unsat == 1)
                std::cout<< "UNSAT" << std::endl;
            else{
                std::cout << "SAT" << std::endl;
                for (int i = 1;i <= variableNumber; i ++){
                    if(val_decisionLevel[i] < 0)
                        std::cout << -i << " ";
                    else
                        std::cout << i << " ";
                    
                }
                std::cout << std::endl;
            }
            
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x1, 0x9c(%rax)
jne 0x3182
movq 0xfe76(%rip), %rdi      # 0x12fd8
leaq 0x9f15(%rip), %rsi      # 0xd07e
callq 0x21a0
movq %rax, %rdi
movq 0xfe50(%rip), %rsi      # 0x12fc8
callq 0x21d0
jmp 0x3237
movq 0xfe4f(%rip), %rdi      # 0x12fd8
leaq 0x9ef0(%rip), %rsi      # 0xd080
callq 0x21a0
movq %rax, %rdi
movq 0xfe29(%rip), %rsi      # 0x12fc8
callq 0x21d0
movl $0x1, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x98(%rcx), %eax
jg 0x3224
movq (%rsp), %rdi
addq $0x50, %rdi
movslq 0xc(%rsp), %rsi
callq 0xb970
cmpl $0x0, (%rax)
jge 0x31f6
xorl %esi, %esi
subl 0xc(%rsp), %esi
movq 0xfdf8(%rip), %rdi      # 0x12fd8
callq 0x22c0
movq %rax, %rdi
leaq 0x9e95(%rip), %rsi      # 0xd084
callq 0x21a0
jmp 0x3215
movl 0xc(%rsp), %esi
movq 0xfdd7(%rip), %rdi      # 0x12fd8
callq 0x22c0
movq %rax, %rdi
leaq 0x9e74(%rip), %rsi      # 0xd084
callq 0x21a0
jmp 0x3217
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x31ac
movq 0xfdad(%rip), %rdi      # 0x12fd8
movq 0xfd96(%rip), %rsi      # 0x12fc8
callq 0x21d0
addq $0x18, %rsp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: has_suffix
static int
has_suffix (const char *str, const char *suffix)
{
  const char *tmp = strstr (str, suffix);
  if (!tmp)
    return 0;

  return str + strlen (str) - strlen (suffix) == tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2bb1
movl $0x0, -0x4(%rbp)
jmp 0x2bf7
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1090
movq %rax, %rdx
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: setsighandlers
static void
setsighandlers (void)
{
  sig_int_handler = signal (SIGINT, catch);
  sig_segv_handler = signal (SIGSEGV, catch);
  sig_abrt_handler = signal (SIGABRT, catch);
  sig_term_handler = signal (SIGTERM, catch);
#ifndef NALLSIGNALS
  sig_kill_handler = signal (SIGKILL, catch);
  sig_xcpu_handler = signal (SIGXCPU, catch);
  sig_xfsz_handler = signal (SIGXFSZ, catch);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
leaq 0xbd0(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2156c(%rip)     # 0x24188
movl $0xb, %edi
leaq 0xbb8(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2155c(%rip)     # 0x24190
movl $0x6, %edi
leaq 0xba0(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2154c(%rip)     # 0x24198
movl $0xf, %edi
leaq 0xb88(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2153c(%rip)     # 0x241a0
movl $0x9, %edi
leaq 0xb70(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2152c(%rip)     # 0x241a8
movl $0x18, %edi
leaq 0xb58(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2151c(%rip)     # 0x241b0
movl $0x19, %edi
leaq 0xb40(%rip), %rsi       # 0x37e0
callq 0x1120
movq %rax, 0x2150c(%rip)     # 0x241b8
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: next_assumption
static int
next_assumption (int start)
{
  char * arg, c;
  int res;
  res = start + 1;
  while (res < sargc)
  {
    arg = sargv[res++];
    if (!strcmp (arg, "-a"))
      {
	assert (res < sargc);
	break;
      }

    if (arg[0] == '-') {
      c = arg[1];
      if (c == 'l' || c == 'i' || c == 's' || c == 'o' || c == 't' ||
	  c == 'T' || c == 'r' || c == 'R' || c == 'c' || c == 'V' ||
	  c == 'U' || c == 'A') res++;
    }
  }
  if (res >= sargc) res = 0;
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x20fc3(%rip), %eax     # 0x24140
jge 0x327c
movq 0x20fbe(%rip), %rax     # 0x24148
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1955e(%rip), %rsi     # 0x1c709
callq 0x1110
cmpl $0x0, %eax
jne 0x31e6
movl -0x18(%rbp), %eax
cmpl 0x20f82(%rip), %eax     # 0x24140
jge 0x31c2
jmp 0x31e1
leaq 0x19dfd(%rip), %rdi     # 0x1cfc6
leaq 0x19ad8(%rip), %rsi     # 0x1cca8
movl $0x11e, %edx            # imm = 0x11E
leaq 0x19df6(%rip), %rcx     # 0x1cfd2
callq 0x10b0
jmp 0x327c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3277
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x6c, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x69, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x74, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x54, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x72, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x52, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x63, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x56, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x55, %eax
je 0x326c
movsbl -0x11(%rbp), %eax
cmpl $0x41, %eax
jne 0x3275
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3277
jmp 0x3174
movl -0x18(%rbp), %eax
cmpl 0x20ebb(%rip), %eax     # 0x24140
jl 0x328e
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: write_to_file
static void
write_to_file (PicoSAT * picosat, 
               const char *name, 
               const char *type,
	       void (*writer) (PicoSAT *, FILE *))
{
  int pclose_file, zipped = has_suffix (name, ".gz");
  FILE *file;
  char *cmd;

  if (zipped)
    {
      cmd = malloc (strlen (GZIP) + strlen (name));
      sprintf (cmd, GZIP, name);
      file = popen (cmd, "w");
      free (cmd);
      pclose_file = 1;
    }
  else
    {
      file = fopen (name, "w");
      pclose_file = 0;
    }

  if (file)
    {
      if (verbose)
	fprintf (output,
		 "c\nc writing %s%s to '%s'\n",
		 zipped ? "gzipped " : "", type, name);

      writer (picosat, file);

      if (pclose_file)
	pclose (file);
      else
	fclose (file);
    }
  else
    fprintf (output, "*** picosat: can not write to '%s'\n", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1985b(%rip), %rsi     # 0x1cb1e
callq 0x2b80
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x3326
movq -0x10(%rbp), %rdi
callq 0x1090
movq %rax, %rdi
addq $0xf, %rdi
callq 0x1150
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x19cf2(%rip), %rsi     # 0x1cfeb
movb $0x0, %al
callq 0x11d0
movq -0x38(%rbp), %rdi
leaq 0x194d8(%rip), %rsi     # 0x1c7e3
callq 0x1180
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1050
movl $0x1, -0x24(%rbp)
jmp 0x3341
movq -0x10(%rbp), %rdi
leaq 0x194b2(%rip), %rsi     # 0x1c7e3
callq 0x1190
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x33b0
cmpl $0x0, 0x20e19(%rip)     # 0x24168
je 0x3386
movq 0x20e08(%rip), %rdi     # 0x24160
movl -0x28(%rbp), %ecx
leaq 0x1a92e(%rip), %rdx     # 0x1dc90
leaq 0x19cac(%rip), %rax     # 0x1d015
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0x19c7c(%rip), %rsi     # 0x1cffb
movb $0x0, %al
callq 0x1130
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, -0x24(%rbp)
je 0x33a5
movq -0x30(%rbp), %rdi
callq 0x10a0
jmp 0x33ae
movq -0x30(%rbp), %rdi
callq 0x1080
jmp 0x33c9
movq 0x20da9(%rip), %rdi     # 0x24160
movq -0x10(%rbp), %rdx
leaq 0x195a0(%rip), %rsi     # 0x1c962
movb $0x0, %al
callq 0x1130
addq $0x40, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: write_core_variables
static void
write_core_variables (PicoSAT * picosat, FILE * file)
{
  int i, max_idx = picosat_variables (picosat), count = 0;
  for (i = 1; i <= max_idx; i++)
    if (picosat_corelit (picosat, i))
      {
	fprintf (file, "%d\n", i);
	count++;
      }

  if (verbose)
    fprintf (output, "c found and wrote %d core variables\n", count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab90
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x343e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8070
cmpl $0x0, %eax
je 0x3431
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x198b9(%rip), %rsi     # 0x1ccda
movb $0x0, %al
callq 0x1130
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3433
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x33fa
cmpl $0x0, 0x20d23(%rip)     # 0x24168
je 0x345f
movq 0x20d12(%rip), %rdi     # 0x24160
movl -0x1c(%rbp), %edx
leaq 0x19bc6(%rip), %rsi     # 0x1d01e
movb $0x0, %al
callq 0x1130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: write_failed_assumptions
static void
write_failed_assumptions (PicoSAT * picosat, FILE * file)
{
  int i, lit, count = 0;
#ifndef NDEBUG
  int max_idx = picosat_variables (picosat);
#endif
  i = 0;
  while ((i = next_assumption (i))) {
    lit = atoi (sargv[i]);
    if (!picosat_failed_assumption (picosat, lit)) continue;
    fprintf (file, "%d\n", lit);
    count++;
  }
  if (verbose)
    fprintf (output, "c found and wrote %d failed assumptions\n", count);
#ifndef NDEBUG
  for (i = 1; i <= max_idx; i++)
    if (picosat_failed_assumption (picosat, i))
      count--;
#endif
  assert (!count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab90
movl %eax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x3160
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x34f4
movq 0x20c97(%rip), %rax     # 0x24148
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11c0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8220
cmpl $0x0, %eax
jne 0x34d4
jmp 0x349a
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x197f8(%rip), %rsi     # 0x1ccda
movb $0x0, %al
callq 0x1130
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x349a
cmpl $0x0, 0x20c6d(%rip)     # 0x24168
je 0x3515
movq 0x20c5c(%rip), %rdi     # 0x24160
movl -0x1c(%rbp), %edx
leaq 0x19b35(%rip), %rsi     # 0x1d043
movb $0x0, %al
callq 0x1130
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x354b
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8220
cmpl $0x0, %eax
je 0x353e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3540
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x351c
cmpl $0x0, -0x1c(%rbp)
jne 0x3553
jmp 0x3572
leaq 0x19b12(%rip), %rdi     # 0x1d06c
leaq 0x19747(%rip), %rsi     # 0x1cca8
movl $0x142, %edx            # imm = 0x142
leaq 0x19b06(%rip), %rcx     # 0x1d073
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: printa
static void
printa (PicoSAT * picosat, int partial)
{
  int max_idx = picosat_variables (picosat), i, lit, val;

  assert (bhead == buffer);

  for (i = 1; i <= max_idx; i++)
    {
      if (partial)
	{
	  val = picosat_deref_partial (picosat, i);
	  if (!val)
	    continue;
	}
      else
	val = picosat_deref (picosat, i);
      lit = (val > 0) ? i : -i;
      printi (lit);
    }

  printi (0);
  if (bhead > buffer)
    bflush ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab90
movl %eax, -0x10(%rbp)
leaq 0x20c3e(%rip), %rax     # 0x241e0
cmpq %rax, 0x20b6f(%rip)     # 0x24118
jne 0x35ad
jmp 0x35cc
leaq 0x19af0(%rip), %rdi     # 0x1d0a4
leaq 0x196ed(%rip), %rsi     # 0x1cca8
movl $0xd1, %edx
leaq 0x19aed(%rip), %rcx     # 0x1d0b4
callq 0x10b0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x3638
cmpl $0x0, -0xc(%rbp)
je 0x35fa
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xd710
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x35f8
jmp 0x362d
jmp 0x3609
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7dd0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x3617
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x361f
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x3ae0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x35d3
xorl %edi, %edi
callq 0x3ae0
leaq 0x20b9a(%rip), %rax     # 0x241e0
cmpq %rax, 0x20acb(%rip)     # 0x24118
jbe 0x3654
callq 0x3b70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: blocksol
static void
blocksol (PicoSAT * picosat)
{
  int max_idx = picosat_variables (picosat), i;

  if (!sol)
    {
      sol = malloc (max_idx + 1);
      memset (sol, 0, max_idx + 1);
    }

  for (i = 1; i <= max_idx; i++)
    sol[i] = (picosat_deref (picosat, i) > 0) ? 1 : -1;

  for (i = 1; i <= max_idx; i++)
    picosat_add (picosat, (sol[i] < 0) ? i : -i);

  picosat_add (picosat, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab90
movl %eax, -0xc(%rbp)
cmpq $0x0, 0x20b00(%rip)     # 0x24180
jne 0x36ae
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1150
movq %rax, 0x20ae9(%rip)     # 0x24180
movq 0x20ae2(%rip), %rdi     # 0x24180
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x10d0
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x36f6
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x7dd0
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovgl %ecx, %eax
movb %al, %dl
movq 0x20a9c(%rip), %rax     # 0x24180
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x36b5
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x3748
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20a6c(%rip), %rax     # 0x24180
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jge 0x3729
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3731
xorl %eax, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6880
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x36fd
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x6880
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: resetsighandlers
static void
resetsighandlers (void)
{
  (void) signal (SIGINT, sig_int_handler);
  (void) signal (SIGSEGV, sig_segv_handler);
  (void) signal (SIGABRT, sig_abrt_handler);
  (void) signal (SIGTERM, sig_term_handler);
#ifndef NALLSIGNALS
  (void) signal (SIGKILL, sig_kill_handler);
  (void) signal (SIGXCPU, sig_xcpu_handler);
  (void) signal (SIGXFSZ, sig_xfsz_handler);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20a1d(%rip), %rsi     # 0x24188
movl $0x2, %edi
callq 0x1120
movq 0x20a14(%rip), %rsi     # 0x24190
movl $0xb, %edi
callq 0x1120
movq 0x20a0b(%rip), %rsi     # 0x24198
movl $0x6, %edi
callq 0x1120
movq 0x20a02(%rip), %rsi     # 0x241a0
movl $0xf, %edi
callq 0x1120
movq 0x209f9(%rip), %rsi     # 0x241a8
movl $0x9, %edi
callq 0x1120
movq 0x209f0(%rip), %rsi     # 0x241b0
movl $0x18, %edi
callq 0x1120
movq 0x209e7(%rip), %rsi     # 0x241b8
movl $0x19, %edi
callq 0x1120
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: catch
static void
catch (int sig)
{
  if (!catched)
    {
      message (sig);
      catched = 1;
      picosat_stats (picosat);
      message (sig);
    }

  resetsighandlers ();
  raise (sig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x209ce(%rip)     # 0x241c0
jne 0x381a
movl -0x4(%rbp), %edi
callq 0x3830
movl $0x1, 0x209ba(%rip)     # 0x241c0
movq 0x20963(%rip), %rdi     # 0x24170
callq 0xabf0
movl -0x4(%rbp), %edi
callq 0x3830
callq 0x3760
movl -0x4(%rbp), %edi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: setalarm
static void
setalarm ()
{
  assert (time_limit_in_seconds > 0);
  sig_alarm_handler = signal (SIGALRM, alarm_triggered);
  alarm (time_limit_in_seconds);
  assert (picosat);
  picosat_set_interrupt (picosat, 0, interrupt_call_back);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x208cd(%rip)     # 0x24178
jle 0x38af
jmp 0x38ce
leaq 0x1958f(%rip), %rdi     # 0x1ce45
leaq 0x193eb(%rip), %rsi     # 0x1cca8
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x19596(%rip), %rcx     # 0x1ce5f
callq 0x10b0
movl $0xe, %edi
leaq 0x66(%rip), %rsi        # 0x3940
callq 0x1120
movq %rax, 0x208e2(%rip)     # 0x241c8
movl 0x2088c(%rip), %edi     # 0x24178
callq 0x10e0
cmpq $0x0, 0x20877(%rip)     # 0x24170
je 0x38fd
jmp 0x391c
leaq 0x1956b(%rip), %rdi     # 0x1ce6f
leaq 0x1939d(%rip), %rsi     # 0x1cca8
movl $0x1b3, %edx            # imm = 0x1B3
leaq 0x19548(%rip), %rcx     # 0x1ce5f
callq 0x10b0
movq 0x2084d(%rip), %rdi     # 0x24170
xorl %eax, %eax
movl %eax, %esi
leaq 0xd2(%rip), %rdx        # 0x3a00
callq 0xd6e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: alarm_triggered
static void
alarm_triggered (int sig)
{
  (void) sig;
  assert (sig == SIGALRM);
  assert (time_limit_in_seconds);
  assert (!ought_to_be_interrupted);
  ought_to_be_interrupted = 1;
  assert (!interrupt_notified);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0xe, -0x4(%rbp)
jne 0x3953
jmp 0x3972
leaq 0x1951d(%rip), %rdi     # 0x1ce77
leaq 0x19347(%rip), %rsi     # 0x1cca8
movl $0x191, %edx            # imm = 0x191
leaq 0x19519(%rip), %rcx     # 0x1ce86
callq 0x10b0
cmpl $0x0, 0x207ff(%rip)     # 0x24178
je 0x397d
jmp 0x399c
leaq 0x1951c(%rip), %rdi     # 0x1cea0
leaq 0x1931d(%rip), %rsi     # 0x1cca8
movl $0x192, %edx            # imm = 0x192
leaq 0x194ef(%rip), %rcx     # 0x1ce86
callq 0x10b0
cmpl $0x0, 0x2082d(%rip)     # 0x241d0
jne 0x39a7
jmp 0x39c6
leaq 0x19508(%rip), %rdi     # 0x1ceb6
leaq 0x192f3(%rip), %rsi     # 0x1cca8
movl $0x193, %edx            # imm = 0x193
leaq 0x194c5(%rip), %rcx     # 0x1ce86
callq 0x10b0
movl $0x1, 0x20800(%rip)     # 0x241d0
cmpl $0x0, 0x207fd(%rip)     # 0x241d4
jne 0x39db
jmp 0x39fa
leaq 0x194ed(%rip), %rdi     # 0x1cecf
leaq 0x192bf(%rip), %rsi     # 0x1cca8
movl $0x195, %edx            # imm = 0x195
leaq 0x19491(%rip), %rcx     # 0x1ce86
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: interrupt_call_back
static int
interrupt_call_back (void * dummy)
{
  (void) dummy;
  if (!ought_to_be_interrupted)
    return 0;
  if (!interrupt_notified)
    {
      if (verbose)
	{
	  picosat_message (picosat, 1, "");
	  picosat_message (picosat, 1,
	    "*** TIME LIMIT OF %d SECONDS REACHED ***",
	    time_limit_in_seconds);
	  picosat_message (picosat, 1, "");
	}
      interrupt_notified = 1;
    }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x207bd(%rip)     # 0x241d0
jne 0x3a1e
movl $0x0, -0x4(%rbp)
jmp 0x3a95
cmpl $0x0, 0x207af(%rip)     # 0x241d4
jne 0x3a8e
cmpl $0x0, 0x2073a(%rip)     # 0x24168
je 0x3a84
movq 0x20739(%rip), %rdi     # 0x24170
movl $0x1, %esi
leaq 0x1a24d(%rip), %rdx     # 0x1dc90
movb $0x0, %al
callq 0xb9e0
movq 0x2071f(%rip), %rdi     # 0x24170
movl 0x20721(%rip), %ecx     # 0x24178
movl $0x1, %esi
leaq 0x19480(%rip), %rdx     # 0x1cee3
movb $0x0, %al
callq 0xb9e0
movq 0x206ff(%rip), %rdi     # 0x24170
movl $0x1, %esi
leaq 0x1a213(%rip), %rdx     # 0x1dc90
movb $0x0, %al
callq 0xb9e0
movl $0x1, 0x20746(%rip)     # 0x241d4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: next
static int
next (void)
{
  int res = getc (input);
  if (res == '\n')
    lineno++;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x206a9(%rip), %rdi     # 0x24158
callq 0x11e0
movl %eax, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jne 0x3acc
movl 0x206b9(%rip), %eax     # 0x2417c
addl $0x1, %eax
movl %eax, 0x206b0(%rip)     # 0x2417c
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: printi
static void
printi (int i)
{
  char *next;
  int l;

REENTER:
  if (bhead == buffer)
    *bhead++ = 'v';

  l = sprintf (bhead, " %d", i);
  next = bhead + l;

  if (next >= eob)
    {
      bflush ();
      goto REENTER;
    }
  else
    bhead = next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x206ee(%rip), %rax     # 0x241e0
cmpq %rax, 0x2061f(%rip)     # 0x24118
jne 0x3b13
movq 0x20616(%rip), %rax     # 0x24118
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20608(%rip)     # 0x24118
movb $0x76, (%rax)
movq 0x205fe(%rip), %rdi     # 0x24118
movl -0x4(%rbp), %edx
leaq 0x195ac(%rip), %rsi     # 0x1d0d0
movb $0x0, %al
callq 0x11d0
movl %eax, -0x14(%rbp)
movq 0x205e3(%rip), %rax     # 0x24118
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x205d5(%rip), %rax     # 0x24120
jb 0x3b54
callq 0x3b70
jmp 0x3aeb
movq -0x10(%rbp), %rax
movq %rax, 0x205b9(%rip)     # 0x24118
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/app.c
// Function: bflush
static void
bflush (void)
{
  *bhead = 0;
  fputs (buffer, output);
  fputc ('\n', output);
  bhead = buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2059d(%rip), %rax     # 0x24118
movb $0x0, (%rax)
movq 0x205db(%rip), %rsi     # 0x24160
leaq 0x20654(%rip), %rdi     # 0x241e0
callq 0x10c0
movq 0x205c8(%rip), %rsi     # 0x24160
movl $0xa, %edi
callq 0x10f0
leaq 0x20637(%rip), %rax     # 0x241e0
movq %rax, 0x20568(%rip)     # 0x24118
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: dumpcnf
void
dumpcnf (PS * ps)
{
  Cls **p, *c;

  for (p = SOC; p != EOC; p = NXC (p))
    {
      c = *p;

      if (!c)
	continue;

#ifdef TRACE
      if (c->collected)
	continue;
#endif

      dumpclsnl (ps, *p);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jne 0x3c45
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3c54
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x200(%rcx), %rax
je 0x3ccd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3c81
jmp 0x3c91
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3ce0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jne 0x3cb7
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3cc3
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3c5c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_minit
PicoSAT * 
picosat_minit (void * pmgr,
	       picosat_malloc pnew,
	       picosat_realloc presize,
	       picosat_free pfree)
{
  ABORTIF (!pnew, "API usage: zero 'picosat_malloc' argument");
  ABORTIF (!presize, "API usage: zero 'picosat_realloc' argument");
  ABORTIF (!pfree, "API usage: zero 'picosat_free' argument");
  return init (pmgr, pnew, presize, pfree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4251
jmp 0x426e
jmp 0x4253
movq 0x1fd9e(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x18f3b(%rip), %rdi     # 0x1d19f
callq 0x10c0
callq 0x1060
jmp 0x4270
cmpq $0x0, -0x18(%rbp)
je 0x4279
jmp 0x4296
jmp 0x427b
movq 0x1fd76(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x18f4b(%rip), %rdi     # 0x1d1d7
callq 0x10c0
callq 0x1060
jmp 0x4298
cmpq $0x0, -0x20(%rbp)
je 0x42a1
jmp 0x42be
jmp 0x42a3
movq 0x1fd4e(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x18f5c(%rip), %rdi     # 0x1d210
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3d50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_adjust
void
picosat_adjust (PS * ps, int new_max_var)
{
  unsigned new_size_vars;

  ABORTIF (abs (new_max_var) > (int) ps->max_var && ps->CLS != ps->clshead,
           "API usage: adjusting variable index after 'picosat_push'");
  enter (ps);

  new_max_var = abs (new_max_var);
  new_size_vars = new_max_var + 1;

  if (ps->size_vars < new_size_vars)
    enlarge (ps, new_size_vars);

  while (ps->max_var < (unsigned) new_max_var)
    inc_max_var (ps);

  leave (ps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x431a
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x431c
jmp 0x4339
jmp 0x431e
movq 0x1fcd3(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x18f17(%rip), %rdi     # 0x1d246
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x43a0
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x10(%rbp), %eax
jae 0x4370
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x43f0
jmp 0x4372
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0xc(%rbp), %eax
jae 0x4389
movq -0x8(%rbp), %rdi
callq 0x4700
jmp 0x4372
movq -0x8(%rbp), %rdi
callq 0x4910
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: enter
static void
enter (PS * ps)
{
  if (ps->nentered++)
    return;

  check_ready (ps);
  ps->entered = picosat_time_stamp ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl 0x358(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x358(%rcx)
cmpl $0x0, %eax
je 0x43c8
jmp 0x43e2
movq -0x8(%rbp), %rdi
callq 0x49e0
callq 0xb380
movq -0x8(%rbp), %rax
movsd %xmm0, 0x350(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: leave
static void
leave (PS * ps)
{
  assert (ps->nentered);
  if (--ps->nentered)
    return;

  sflush (ps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x358(%rax)
je 0x492b
jmp 0x494a
leaq 0x19830(%rip), %rdi     # 0x1e162
leaq 0x1896b(%rip), %rsi     # 0x1d2a4
movl $0x1962, %edx           # imm = 0x1962
leaq 0x1982a(%rip), %rcx     # 0x1e16f
callq 0x10b0
movq -0x8(%rbp), %rcx
movl 0x358(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x358(%rcx)
cmpl $0x0, %eax
je 0x4964
jmp 0x496d
movq -0x8(%rbp), %rdi
callq 0xb2f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_inc_max_var
int
picosat_inc_max_var (PS * ps)
{
  if (ps->measurealltimeinlib)
    enter (ps);
  else
    check_ready (ps);

  inc_max_var (ps);

  if (ps->measurealltimeinlib)
    leave (ps);

  return ps->max_var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x35c(%rax)
je 0x49a4
movq -0x8(%rbp), %rdi
callq 0x43a0
jmp 0x49ad
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
callq 0x4700
movq -0x8(%rbp), %rax
cmpl $0x0, 0x35c(%rax)
je 0x49cc
movq -0x8(%rbp), %rdi
callq 0x4910
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: reset_incremental_usage
static void
reset_incremental_usage (PS * ps)
{
  unsigned num_non_false;
  Lit * lit, ** q;

  check_sat_or_unsat_or_unknown_state (ps);

  LOG ( fprintf (ps->out, "%sRESET incremental usage\n", ps->prefix));

  if (ps->LEVEL)
    undo (ps, 0);

  reset_assumptions (ps);

  if (ps->conflict)
    { 
      num_non_false = 0;
      for (q = ps->conflict->lits; q < end_of_lits (ps->conflict); q++)
	{
	  lit = *q;
	  if (lit->val != FALSE)
	    num_non_false++;
	}

      // assert (num_non_false >= 2); // TODO: why this assertion?
#ifdef NO_BINARY_CLAUSES
      if (ps->conflict == &ps->cimpl)
	resetcimpl (ps);
#endif
#ifndef NADC
      if (ps->conflict == ps->adoconflict)
	resetadoconflict (ps);
#endif
      ps->conflict = 0;
    }

#ifdef TRACE
  reset_core (ps);
#endif

  reset_partial (ps);

  ps->saved_flips = ps->flips;
  ps->min_flipped = UINT_MAX;
  ps->saved_max_var = ps->max_var;

  ps->state = READY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa940
jmp 0x4dc7
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x4ddc
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xea10
movq -0x8(%rbp), %rdi
callq 0xeba0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
je 0x4e98
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rdi
callq 0xb980
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4e65
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
je 0x4e55
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e57
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x4e11
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x98, %rcx
cmpq %rcx, %rax
jne 0x4e89
movq -0x8(%rbp), %rdi
callq 0xec70
movq -0x8(%rbp), %rax
movq $0x0, 0x250(%rax)
movq -0x8(%rbp), %rdi
callq 0xecc0
movq -0x8(%rbp), %rax
movq 0x468(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x490(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x49c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x498(%rax)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_incremental_rup_file
void
picosat_set_incremental_rup_file (PS * ps, FILE * rup_file, int m, int n)
{
  check_ready (ps);
  assert (!ps->rupstarted);
  ps->rup = rup_file;
  ps->rupvariables = m;
  ps->rupclauses = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x238(%rax)
jne 0x5eae
jmp 0x5ecd
leaq 0x174d8(%rip), %rdi     # 0x1d38d
leaq 0x173e8(%rip), %rsi     # 0x1d2a4
movl $0x1a75, %edx           # imm = 0x1A75
leaq 0x174d5(%rip), %rcx     # 0x1d39d
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x230(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x23c(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x240(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: new_prefix
static void
new_prefix (PS * ps, const char * str)
{
  delete_prefix (ps);
  assert (str);
  ps->prefix = new (ps, strlen (str) + 1);
  strcpy (ps->prefix, str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x183e0
cmpq $0x0, -0x10(%rbp)
je 0x5fb2
jmp 0x5fd1
leaq 0x191d7(%rip), %rdi     # 0x1f190
leaq 0x172e4(%rip), %rsi     # 0x1d2a4
movl $0x47e, %edx            # imm = 0x47E
leaq 0x191c8(%rip), %rcx     # 0x1f194
callq 0x10b0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x9900
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: import_lit
static Lit *
import_lit (PS * ps, int lit, int nointernal)
{
  Lit * res;
  Var * v;

  ABORTIF (lit == INT_MIN, "API usage: INT_MIN literal");
  ABORTIF (abs (lit) > (int) ps->max_var && ps->CLS != ps->clshead,
           "API usage: new variable index after 'picosat_push'");

  if (abs (lit) <= (int) ps->max_var)
    {
      res = int2lit (ps, lit);
      v = LIT2VAR (res);
      if (nointernal && v->internal)
	ABORT ("API usage: trying to import invalid literal");
      else if (!nointernal && !v->internal)
	ABORT ("API usage: trying to import invalid context");
    }
  else
    {
      while (abs (lit) > (int) ps->max_var)
	inc_max_var (ps);
      res = int2lit (ps, lit);
    }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
je 0x6b0d
jmp 0x6b2a
jmp 0x6b0f
movq 0x1d4e2(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x1870a(%rip), %rdi     # 0x1f22a
callq 0x10c0
callq 0x1060
jmp 0x6b2c
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x6b57
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jne 0x6b59
jmp 0x6b76
jmp 0x6b5b
movq 0x1d496(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x186e7(%rip), %rdi     # 0x1f253
callq 0x10c0
callq 0x1060
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jg 0x6c3b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4ef0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x6bfd
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x6bfd
jmp 0x6be2
movq 0x1d40f(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x186a1(%rip), %rdi     # 0x1f294
callq 0x10c0
callq 0x1060
cmpl $0x0, -0x10(%rbp)
jne 0x6c37
movq -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x6c37
jmp 0x6c1c
movq 0x1d3d5(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x186a1(%rip), %rdi     # 0x1f2ce
callq 0x10c0
callq 0x1060
jmp 0x6c39
jmp 0x6c6b
jmp 0x6c3d
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x6c5b
movq -0x8(%rbp), %rdi
callq 0x4700
jmp 0x6c3d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4ef0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: add_lit
static void
add_lit (PS * ps, Lit * lit)
{
  assert (lit);

  if (ps->ahead == ps->eoa)
    ENLARGE (ps->added, ps->ahead, ps->eoa);

  *ps->ahead++ = lit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6c99
jmp 0x6cb8
leaq 0x17f5f(%rip), %rdi     # 0x1ebff
leaq 0x165fd(%rip), %rsi     # 0x1d2a4
movl $0x715, %edx            # imm = 0x715
leaq 0x18655(%rip), %rcx     # 0x1f308
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x268(%rcx), %rax
jne 0x6df8
jmp 0x6cd6
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x258(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6d06
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0x6d10
movl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6d10
movl -0x3c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x260(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x258(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x268(%rcx), %rax
ja 0x6d53
jmp 0x6d72
leaq 0x185c8(%rip), %rdi     # 0x1f322
leaq 0x16543(%rip), %rsi     # 0x1d2a4
movl $0x718, %edx            # imm = 0x718
leaq 0x1859b(%rip), %rcx     # 0x1f308
callq 0x10b0
jmp 0x6d74
movl -0x14(%rbp), %eax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4f30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x258(%rax)
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rcx
movl -0x24(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x260(%rax)
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rcx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x268(%rax)
jmp 0x6df8
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x260(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x260(%rdx)
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_add_arg
int
picosat_add_arg (PS * ps, ...)
{
  int lit;
  va_list ap;
  va_start (ap, ps);
  while ((lit = va_arg (ap, int)))
    (void) picosat_add (ps, lit);
  va_end (ap);
  return picosat_add (ps, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x70c8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x714e
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x716b
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x718a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6880
jmp 0x7113
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x6880
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop