LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::impl(unsigned long, unsigned long, memorypool::recycle_method_e, std::function<void (DummyClass&)>)
impl(size_t enlarge_size, size_t max_size, recycle_method_e method, recycle_function recycle)
        {
            // assert(enlarge_size > 0); // NOTE: enlarge_size can be zero to create a limited-size memory pool

            // configurations
            m_recycle_method = method;
            m_recycle_fn = recycle;
            m_enlarge_step = enlarge_size;
            m_max_size = max_size;

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

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

#if BOOST_INTRUSIVE_POOL_DEBUG_THREAD_ACCESS
            m_allowed_thread = 0;
#endif
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
leaq 0x6d40(%rip), %rax      # 0xac40
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %ecx, 0xc(%rdi)
movq %r14, %rdi
movq %r8, %rsi
callq 0x405e
movq %r12, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movq $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x49(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x69(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x3f6c
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x39cc
// File: /workspace/github_cpp_makefile_star2_O3/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyClass>::impl::enlarge(unsigned long)
bool enlarge(size_t arena_size)
        {
#if BOOST_INTRUSIVE_POOL_DEBUG_THREAD_ACCESS
            assert(m_allowed_thread == 0 || m_allowed_thread == pthread_self());
#endif
            // If the current arena is full, create a new one.
            boost_intrusive_pool_arena<Item>* new_arena = new boost_intrusive_pool_arena<Item>(arena_size, this);
            if (!new_arena)
                return false; // malloc failed... memory finished... very likely this is a game over

            // Link the new arena to the last one.
            if (m_last_arena)
                m_last_arena->set_next_arena(new_arena);
            if (m_first_arena == nullptr)
                m_first_arena = new_arena; // apparently we are initializing the memory pool for the very first time

            // Seek pointer to last arena
            m_last_arena = new_arena;

            // Update the free_list with the storage of the just created arena.
            if (m_first_free_item == nullptr)
                m_first_free_item = m_last_arena->get_first_item();

            m_free_count += arena_size;
            m_total_count += arena_size;

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %r15
testq %r15, %r15
je 0x3fa2
callq 0x20d0
cmpq %rax, %r15
jne 0x401d
movl $0x18, %edi
callq 0x235c
movq %rax, %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
incl 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x449a
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x3fd9
decl 0x8(%rdi)
jne 0x3fd9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x3fea
movq %r15, %rsi
callq 0x467e
cmpq $0x0, 0x40(%r14)
jne 0x3ff5
movq %r15, 0x40(%r14)
movq %r15, 0x48(%r14)
cmpq $0x0, 0x50(%r14)
jne 0x4008
movq 0x10(%r15), %rax
movq %rax, 0x50(%r14)
addq %rbx, 0x60(%r14)
addq %rbx, 0x70(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c85(%rip), %rdi      # 0x6ca9
leaq 0x2678(%rip), %rsi      # 0x66a3
leaq 0x2cb3(%rip), %rcx      # 0x6ce5
movl $0x288, %edx            # imm = 0x288
callq 0x2080
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x404d
callq 0x21d2
movq %r15, %rdi
callq 0x242d
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x43bd
movq (%r14), %r15
movq %r14, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x242d
movq %r15, %r14
testq %r15, %r15
jne 0x43a0
jmp 0x43c4
cmpq $0x0, 0x48(%rbx)
jne 0x43e9
leaq 0x40(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2656(%rip), %rdi      # 0x6a46
leaq 0x22ac(%rip), %rsi      # 0x66a3
leaq 0x2660(%rip), %rcx      # 0x6a5e
movl $0x2f3, %edx            # imm = 0x2F3
callq 0x2080
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0x1, 0x78(%rdi)
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x4715
leaq -0x18(%rbp), %rbx
movq $0x0, -0x18(%rbp)
leaq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x4466
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x470c
decl 0x8(%rdi)
jne 0x470c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x46e4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x472f
callq 0x21f6
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
leaq 0x78(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
cmpl $0x1, %edi
jne 0x243f
movq 0x6bd8(%rip), %r14      # 0x8fd8
leaq 0x3c39(%rip), %rsi      # 0x6040
movl $0x1e, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x6ba6(%rip), %rdi      # 0x8fd8
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2596
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5126
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x25d4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2498
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x48(%rsp), %rdi
callq 0x2caa
leaq 0x48(%rsp), %rdi
callq 0x2dcc
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24c7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x24e4
movq 0xd8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x2501
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x251e
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x80(%rsp), %rdi
callq 0x506a
leaq 0x48(%rsp), %rdi
callq 0x50b2
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2568
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x2568
jmp 0x2560
movq %rax, %rbx
jmp 0x2583
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2583
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x48(%rsp), %rdi
callq 0x2ed6
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O3/kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: ck_cdcl_solver::Solver::solve()
void solve(){
            
            int decision_level = 1;
            
            std::unordered_set<int> implied;
            if(!unitPropagate(implied, decision_level)){
                unsat = 1;
                return;
            }
                
            int i = 0;
            while(i < variableNumber && val_decisionLevel[sor[i]] != 0)
                i++;
            if(i == variableNumber)
                return;
            
            
            decisionVar[2] = sor[i];
            val_decisionLevel[sor[i]] = -2;
            if(recursion(i+1,2))
                return ;
            
            decisionVar[2] = -sor[i];
            val_decisionLevel[sor[i]] = 2;
            if(recursion(i+1,2))
                return ;
            unsat = 1;
            return;
            
            
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x4868
testb %al, %al
je 0x2d97
movslq 0x98(%rbx), %rax
testq %rax, %rax
jle 0x2d21
movq 0x50(%rbx), %rcx
movq 0x80(%rbx), %rdx
xorl %r14d, %r14d
movslq (%rdx,%r14,4), %rsi
cmpl $0x0, (%rcx,%rsi,4)
je 0x2d24
incq %r14
cmpq %r14, %rax
jne 0x2d0a
jmp 0x2da1
xorl %r14d, %r14d
cmpl %eax, %r14d
je 0x2da1
movl %r14d, %r15d
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
movslq (%rcx,%r15,4), %rcx
movl %ecx, 0x8(%rax)
movq 0x50(%rbx), %rax
movl $0xfffffffe, (%rax,%rcx,4) # imm = 0xFFFFFFFE
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl $0x2, %edx
callq 0x4c9e
testb %al, %al
jne 0x2da1
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
xorl %edx, %edx
subl (%rcx,%r15,4), %edx
movl %edx, 0x8(%rax)
movslq (%rcx,%r15,4), %rax
movq 0x50(%rbx), %rcx
movl $0x2, (%rcx,%rax,4)
movq %rbx, %rdi
movl %r14d, %esi
movl $0x2, %edx
callq 0x4c9e
testb %al, %al
jne 0x2da1
movl $0x1, 0x9c(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x3d9a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2db7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d9a
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1, 0x9c(%rdi)
jne 0x2dfa
movq 0x61f4(%rip), %rdi      # 0x8fd8
leaq 0x32f5(%rip), %rsi      # 0x60e0
movl $0x5, %edx
callq 0x2180
jmp 0x2e9f
movq %rdi, %rbx
movq 0x61d4(%rip), %r14      # 0x8fd8
leaq 0x32d7(%rip), %rsi      # 0x60e2
movl $0x3, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
cmpl $0x0, 0x98(%rbx)
jle 0x2e9f
movl $0x1, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x617e(%rip), %r14      # 0x8fd8
leaq 0x3285(%rip), %r15      # 0x60e6
movq 0x50(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
movl %ebp, %esi
js 0x2e71
movl %r12d, %esi
movq %r14, %rdi
callq 0x2200
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
leaq 0x1(%r12), %rax
movslq 0x98(%rbx), %rcx
decl %ebp
cmpq %rcx, %r12
movq %rax, %r12
jl 0x2e61
movq 0x6132(%rip), %rbx      # 0x8fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
incl %edi
movl 0x16dc1(%rip), %ecx     # 0x1a140
cmpl %ecx, %edi
jge 0x33d4
movq 0x16dbe(%rip), %rax     # 0x1a148
movabsq $0xe4904003a0001, %rsi  # imm = 0xE4904003A0001
leal 0x1(%rdi), %edx
movslq %edi, %r8
movq (%rax,%r8,8), %r8
cmpb $0x2d, (%r8)
jne 0x33cc
cmpb $0x61, 0x1(%r8)
jne 0x33b2
cmpb $0x0, 0x2(%r8)
je 0x33df
movzbl 0x1(%r8), %r8d
addl $-0x41, %r8d
cmpl $0x33, %r8d
ja 0x33cc
btq %r8, %rsi
jae 0x33cc
addl $0x2, %edi
movl %edi, %edx
movl %edx, %edi
cmpl %ecx, %edx
jl 0x3394
jmp 0x33d6
movl %edi, %edx
xorl %eax, %eax
cmpl %ecx, %edx
cmovll %edx, %eax
popq %rcx
retq
cmpl %ecx, %edx
jl 0x33d6
leaq 0xfba3(%rip), %rdi      # 0x12f8d
leaq 0xf87e(%rip), %rsi      # 0x12c6f
leaq 0xfba1(%rip), %rcx      # 0x12f99
movl $0x11e, %edx            # imm = 0x11E
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0xf6c4(%rip), %rsi      # 0x12ae5
movq %r14, %rdi
callq 0x332a
movl %eax, %ebp
testl %eax, %eax
je 0x3473
movq %r14, %rdi
callq 0x1090
leaq 0xf(%rax), %rdi
callq 0x1160
movq %rax, %r12
leaq 0xfb68(%rip), %rsi      # 0x12fb2
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11e0
leaq 0xf361(%rip), %rsi      # 0x127bf
movq %r12, %rdi
callq 0x1190
movq %rax, %r13
movq %r12, %rdi
callq 0x1050
jmp 0x3485
leaq 0xf345(%rip), %rsi      # 0x127bf
movq %r14, %rdi
callq 0x11a0
movq %rax, %r13
testq %r13, %r13
je 0x34e5
cmpl $0x0, 0x16cd7(%rip)     # 0x1a168
je 0x34c3
testl %ebp, %ebp
movq 0x16cc4(%rip), %rdi     # 0x1a160
leaq 0x107c5(%rip), %rax     # 0x13c68
leaq 0xfb32(%rip), %rdx      # 0x12fdc
cmoveq %rax, %rdx
leaq 0xfb0d(%rip), %rsi      # 0x12fc2
movq (%rsp), %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x1140
movq %r15, %rdi
movq %r13, %rsi
callq *%rbx
movq %r13, %rdi
addq $0x8, %rsp
testl %ebp, %ebp
je 0x350b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
movq 0x16c74(%rip), %rdi     # 0x1a160
leaq 0xf43f(%rip), %rsi      # 0x12932
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa7c5
testl %eax, %eax
jle 0x357f
movl %eax, %r15d
negl %r15d
movl $0x1, %r13d
leaq 0xf75a(%rip), %r12      # 0x12ca1
xorl %ebp, %ebp
movq %r14, %rdi
movl %r13d, %esi
callq 0x8d5a
testl %eax, %eax
je 0x356a
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x1140
incl %ebp
leal (%r15,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x3549
jmp 0x3581
xorl %ebp, %ebp
cmpl $0x0, 0x16be0(%rip)     # 0x1a168
je 0x35af
movq 0x16bcf(%rip), %rdi     # 0x1a160
leaq 0xfa4d(%rip), %rsi      # 0x12fe5
movl %ebp, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0xa7c5
movl %eax, %r14d
xorl %ebp, %ebp
xorl %r13d, %r13d
movl %r13d, %edi
callq 0x3376
testl %eax, %eax
je 0x3627
movl %eax, %r13d
movq 0x16b56(%rip), %rax     # 0x1a148
movslq %r13d, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11d0
movl %eax, %r12d
movq %rbx, %rdi
movl %eax, %esi
callq 0x8e73
testl %eax, %eax
je 0x35dc
movq %r15, %rdi
leaq 0xf688(%rip), %rsi      # 0x12ca1
movl %r12d, %edx
xorl %eax, %eax
callq 0x1140
incl %ebp
jmp 0x35dc
cmpl $0x0, 0x16b3a(%rip)     # 0x1a168
je 0x3647
movq 0x16b29(%rip), %rdi     # 0x1a160
leaq 0xf9cc(%rip), %rsi      # 0x1300a
movl %ebp, %edx
xorl %eax, %eax
callq 0x1140
testl %r14d, %r14d
jle 0x3679
negl %r14d
movl $0x1, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8e73
cmpl $0x1, %eax
adcl $-0x1, %ebp
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x3655
testl %ebp, %ebp
jne 0x368c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf9a0(%rip), %rdi      # 0x13033
leaq 0xf5d5(%rip), %rsi      # 0x12c6f
leaq 0xf999(%rip), %rcx      # 0x1303a
movl $0x142, %edx            # imm = 0x142
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq 0x16ad5(%rip), %rsi     # 0x1a188
movl $0x2, %edi
callq 0x1130
movq 0x16acc(%rip), %rsi     # 0x1a190
movl $0xb, %edi
callq 0x1130
movq 0x16ac3(%rip), %rsi     # 0x1a198
movl $0x6, %edi
callq 0x1130
movq 0x16aba(%rip), %rsi     # 0x1a1a0
movl $0xf, %edi
callq 0x1130
movq 0x16ab1(%rip), %rsi     # 0x1a1a8
movl $0x9, %edi
callq 0x1130
movq 0x16aa8(%rip), %rsi     # 0x1a1b0
movl $0x18, %edi
callq 0x1130
movq 0x16a9f(%rip), %rsi     # 0x1a1b8
movl $0x19, %edi
popq %rax
jmp 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl %edi, %ebx
cmpb $0x0, 0x16a92(%rip)     # 0x1a1c0
jne 0x3751
movl %ebx, %edi
callq 0x375e
movb $0x1, 0x16a82(%rip)     # 0x1a1c0
movq 0x16a2b(%rip), %rdi     # 0x1a170
callq 0xa7e4
movl %ebx, %edi
callq 0x375e
callq 0x36ab
movl %ebx, %edi
popq %rbx
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
cmpl $0xe, %edi
jne 0x37e4
cmpl $0x0, 0x169b1(%rip)     # 0x1a178
je 0x3803
cmpb $0x1, 0x16a00(%rip)     # 0x1a1d0
je 0x3822
movb $0x1, 0x169f7(%rip)     # 0x1a1d0
cmpb $0x1, 0x169f4(%rip)     # 0x1a1d4
je 0x3841
popq %rax
retq
leaq 0xf653(%rip), %rdi      # 0x12e3e
leaq 0xf47d(%rip), %rsi      # 0x12c6f
leaq 0xf654(%rip), %rcx      # 0x12e4d
movl $0x191, %edx            # imm = 0x191
callq 0x10b0
leaq 0xf65d(%rip), %rdi      # 0x12e67
leaq 0xf45e(%rip), %rsi      # 0x12c6f
leaq 0xf635(%rip), %rcx      # 0x12e4d
movl $0x192, %edx            # imm = 0x192
callq 0x10b0
leaq 0xf654(%rip), %rdi      # 0x12e7d
leaq 0xf43f(%rip), %rsi      # 0x12c6f
leaq 0xf616(%rip), %rcx      # 0x12e4d
movl $0x193, %edx            # imm = 0x193
callq 0x10b0
leaq 0xf64e(%rip), %rdi      # 0x12e96
leaq 0xf420(%rip), %rsi      # 0x12c6f
leaq 0xf5f7(%rip), %rcx      # 0x12e4d
movl $0x195, %edx            # imm = 0x195
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x1, 0x16963(%rip)     # 0x1a1d0
jne 0x38e0
movl $0x1, %ebx
cmpb $0x0, 0x16959(%rip)     # 0x1a1d4
jne 0x38e0
cmpl $0x0, 0x168e4(%rip)     # 0x1a168
je 0x38d9
movq 0x168e3(%rip), %rdi     # 0x1a170
leaq 0x103d4(%rip), %r14     # 0x13c68
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xaf6e
movq 0x168c6(%rip), %rdi     # 0x1a170
movl 0x168c8(%rip), %ecx     # 0x1a178
leaq 0xf5f3(%rip), %rdx      # 0x12eaa
movl $0x1, %esi
xorl %eax, %eax
callq 0xaf6e
movq 0x168a6(%rip), %rdi     # 0x1a170
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xaf6e
movb $0x1, 0x168f4(%rip)     # 0x1a1d4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %ebx
leaq 0x168e4(%rip), %r15     # 0x1a1e0
leaq 0x168de(%rip), %r12     # 0x1a1e1
leaq 0xf78d(%rip), %r14      # 0x13097
leaq 0x1691f(%rip), %r13     # 0x1a230
movq 0x16810(%rip), %rdi     # 0x1a128
cmpq %r15, %rdi
jne 0x392e
movq %r12, 0x16804(%rip)     # 0x1a128
movb $0x76, 0x168b5(%rip)    # 0x1a1e0
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x11e0
cltq
addq 0x167e5(%rip), %rax     # 0x1a128
cmpq %r13, %rax
jb 0x394f
callq 0x3960
jmp 0x3911
movq %rax, 0x167d2(%rip)     # 0x1a128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq 0x167c0(%rip), %rax     # 0x1a128
movb $0x0, (%rax)
movq 0x167ee(%rip), %rsi     # 0x1a160
leaq 0x16867(%rip), %rbx     # 0x1a1e0
movq %rbx, %rdi
callq 0x10c0
movq 0x167d8(%rip), %rsi     # 0x1a160
movl $0xa, %edi
callq 0x10f0
movq %rbx, 0x1678f(%rip)     # 0x1a128
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1e0(%rdi), %r15
movq 0x1e8(%rdi), %rax
cmpq %rax, %r15
jne 0x39c4
movq 0x1f8(%rbx), %r15
cmpq 0x200(%rbx), %r15
je 0x3b17
leaq 0x102f8(%rip), %r14     # 0x13cd0
movq (%r15), %r12
testq %r12, %r12
je 0x3afa
movl (%r12), %r13d
testq %r13, %r13
je 0x3ad7
leaq 0x18(,%r13,8), %rax
cmpq $0x20, %rax
jne 0x3a27
movl 0x18(%r12), %eax
subl 0x38(%rbx), %eax
movq 0x10(%rbx), %rdi
movl %eax, %ecx
shrl %ecx
movl %ecx, %edx
negl %edx
testb $0x1, %al
cmovel %ecx, %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
jmp 0x3ad7
cmpl $0x1, %r13d
je 0x3b26
movl 0x38(%rbx), %eax
movl 0x18(%r12), %ecx
movl 0x20(%r12), %edx
subl %eax, %ecx
shrl %ecx
subl %eax, %edx
shrl %edx
xorl %ebp, %ebp
xorl %esi, %esi
cmpl %edx, %ecx
setbe %bpl
seta %sil
movq 0x10(%rbx), %rdi
movl 0x18(%r12,%rsi,8), %ecx
subl %eax, %ecx
movl %ecx, %eax
shrl %eax
movl %eax, %edx
negl %edx
testb $0x1, %cl
cmovel %eax, %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
movl 0x18(%r12,%rbp,8), %eax
subl 0x38(%rbx), %eax
movq 0x10(%rbx), %rdi
movl %eax, %ecx
shrl %ecx
movl %ecx, %edx
negl %edx
testb $0x1, %al
cmovel %ecx, %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
cmpl $0x3, %r13d
jb 0x3ad7
leaq (%r12,%r13,8), %r13
addq $0x18, %r13
addq $0x28, %r12
movl (%r12), %eax
subl 0x38(%rbx), %eax
movq 0x10(%rbx), %rdi
movl %eax, %ecx
shrl %ecx
movl %ecx, %edx
negl %edx
testb $0x1, %al
cmovel %ecx, %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
addq $0x8, %r12
cmpq %r13, %r12
jb 0x3aac
movq 0x10(%rbx), %rsi
movl $0x30, %edi
callq 0x10f0
movq 0x10(%rbx), %rsi
movl $0xa, %edi
callq 0x10f0
movq 0x1e8(%rbx), %rax
addq $0x8, %r15
cmpq %rax, %r15
jne 0x3b0a
movq 0x1f8(%rbx), %r15
cmpq 0x200(%rbx), %r15
jne 0x39d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x103cf(%rip), %rdi     # 0x13efc
leaq 0xf748(%rip), %rsi      # 0x1327c
leaq 0x103ce(%rip), %rcx     # 0x13f09
movl $0x435, %edx            # imm = 0x435
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
testq %rsi, %rsi
je 0x3e3d
testq %rdx, %rdx
je 0x3e42
testq %rcx, %rcx
je 0x3e47
popq %rax
jmp 0x3b57
callq 0x1294
callq 0x1278
callq 0x125c
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
negl %r14d
cmovsl %esi, %r14d
cmpl 0x2c(%rdi), %r14d
jle 0x3e73
movq 0x118(%rbx), %rax
cmpq 0x120(%rbx), %rax
jne 0x3eac
movq %rbx, %rdi
callq 0x3eb1
cmpl %r14d, 0x30(%rbx)
ja 0x3e97
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x3edd
jmp 0x3e97
movq %rbx, %rdi
callq 0x4184
cmpl %r14d, 0x2c(%rbx)
jb 0x3e8f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4375
callq 0x12b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl 0x358(%rdi), %eax
testl %eax, %eax
je 0x43c0
movq %rdi, %rbx
decl %eax
movl %eax, 0x358(%rdi)
jne 0x43be
callq 0xac39
movapd %xmm0, %xmm1
subsd 0x350(%rbx), %xmm1
xorpd %xmm2, %xmm2
maxsd %xmm1, %xmm2
addsd 0x340(%rbx), %xmm2
movsd %xmm2, 0x340(%rbx)
movsd %xmm0, 0x350(%rbx)
popq %rbx
retq
leaq 0xfd1e(%rip), %rdi      # 0x140e5
leaq 0xeeae(%rip), %rsi      # 0x1327c
leaq 0xfd1d(%rip), %rcx      # 0x140f2
movl $0x1962, %edx           # imm = 0x1962
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x35c(%rdi)
je 0x43f6
movq %rbx, %rdi
callq 0x3eb1
jmp 0x43fe
movq %rbx, %rdi
callq 0x441c
movq %rbx, %rdi
callq 0x4184
cmpl $0x0, 0x35c(%rbx)
je 0x4417
movq %rbx, %rdi
callq 0x4375
movl 0x2c(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_push
int
picosat_push (PS * ps)
{
  int res;
  Lit *lit;
  Var * v;

  if (ps->measurealltimeinlib)
    enter (ps);
  else
    check_ready (ps);

  if (ps->state != READY)
    reset_incremental_usage (ps);

  if (ps->rils != ps->rilshead)
    {
      res = *--ps->rilshead;
      assert (ps->vars[res].internal);
    }
  else
    {
      inc_max_var (ps);
      res = ps->max_var;
      v = ps->vars + res;
      assert (!v->internal);
      v->internal = 1;
      ps->internals++;
      LOG ( fprintf (ps->out, "%snew internal variable index %d\n", ps->prefix, res));
    }

  lit = int2lit (ps, res);

  if (ps->clshead == ps->eocls)
    ENLARGE (ps->CLS, ps->clshead, ps->eocls);
  *ps->clshead++ = lit;

  ps->contexts++;

  LOG ( fprintf (ps->out, "%snew context %d at depth %ld after push\n",
                 ps->prefix, res, (long)(ps->clshead - ps->CLS)));

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

  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x35c(%rdi)
je 0x4474
movq %rbx, %rdi
callq 0x3eb1
jmp 0x447c
movq %rbx, %rdi
callq 0x441c
cmpl $0x1, (%rbx)
je 0x4489
movq %rbx, %rdi
callq 0x4601
movq 0x138(%rbx), %rax
cmpq %rax, 0x130(%rbx)
je 0x44d8
leaq -0x4(%rax), %rcx
movq %rcx, 0x138(%rbx)
movslq -0x4(%rax), %r14
movq 0x40(%rbx), %rax
movq %r14, %rcx
shlq $0x4, %rcx
testb $0x40, (%rax,%rcx)
jne 0x450b
leaq 0xeda5(%rip), %rdi      # 0x13265
leaq 0xedb5(%rip), %rsi      # 0x1327c
leaq 0xedb8(%rip), %rcx      # 0x13286
movl $0x1a0b, %edx           # imm = 0x1A0B
callq 0x10b0
movq %rbx, %rdi
callq 0x4184
movslq 0x2c(%rbx), %r14
movq 0x40(%rbx), %rax
movq %r14, %rdx
shlq $0x4, %rdx
movzwl (%rax,%rdx), %ecx
testb $0x40, %cl
jne 0x45c3
addq %rdx, %rax
orl $0x40, %ecx
movw %cx, (%rax)
incl 0x424(%rbx)
leal (%r14,%r14), %eax
movl $0x1, %r12d
subl %eax, %r12d
testl %r14d, %r14d
cmovnsl %eax, %r12d
addq 0x38(%rbx), %r12
movq 0x120(%rbx), %rax
cmpq 0x128(%rbx), %rax
jne 0x4591
movq 0x118(%rbx), %rsi
cmpq %rax, %rsi
ja 0x45e2
subq %rsi, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,8), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x473a
movq %rax, 0x118(%rbx)
addq %rax, %r15
leaq (%rax,%r13,8), %rax
movq %rax, 0x128(%rbx)
movq %r15, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x120(%rbx)
movq %r12, (%rax)
incl 0x420(%rbx)
cmpl $0x0, 0x35c(%rbx)
je 0x45b6
movq %rbx, %rdi
callq 0x4375
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xecd3(%rip), %rdi      # 0x1329d
leaq 0xecab(%rip), %rsi      # 0x1327c
leaq 0xecae(%rip), %rcx      # 0x13286
movl $0x1a12, %edx           # imm = 0x1A12
callq 0x10b0
leaq 0xecc1(%rip), %rdi      # 0x132aa
leaq 0xec8c(%rip), %rsi      # 0x1327c
leaq 0xec8f(%rip), %rcx      # 0x13286
movl $0x1a1b, %edx           # imm = 0x1A1B
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xa742
cmpl $0x0, 0x28(%rbx)
je 0x461c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc6ac
movq $0x0, 0x1b8(%rbx)
cmpl $0x0, 0x1c0(%rbx)
je 0x4664
movq 0xf8(%rbx), %rax
cmpq 0x100(%rbx), %rax
jae 0x465a
movq 0x40(%rbx), %rcx
movl (%rax), %edx
subl 0x38(%rbx), %edx
shrl %edx
shlq $0x4, %rdx
andw $-0x21, (%rcx,%rdx)
addq $0x8, %rax
jmp 0x4637
movl $0x0, 0x1c0(%rbx)
movq 0xf8(%rbx), %rcx
movq 0x250(%rbx), %rax
movq %rcx, 0x100(%rbx)
movq %rcx, 0x108(%rbx)
movl $0x0, 0xf0(%rbx)
testq %rax, %rax
je 0x46b9
leaq 0x98(%rbx), %rcx
cmpq %rcx, %rax
jne 0x46ae
cmpl $0x0, 0xc4(%rbx)
je 0x471b
movl $0x0, 0xc4(%rbx)
movq $0x0, 0x250(%rbx)
cmpl $0x0, 0x22c(%rbx)
movl 0x2c(%rbx), %eax
je 0x46f5
testl %eax, %eax
je 0x46e9
movl $0x1, %ecx
movq 0x40(%rbx), %rax
movl %ecx, %edx
shlq $0x4, %rdx
andw $0xdfff, (%rax,%rdx)    # imm = 0xDFFF
incl %ecx
movl 0x2c(%rbx), %eax
cmpl %eax, %ecx
jbe 0x46ce
jmp 0x46eb
xorl %eax, %eax
movl $0x0, 0x22c(%rbx)
movq 0x468(%rbx), %rcx
movq %rcx, 0x490(%rbx)
movl $0xffffffff, 0x49c(%rbx) # imm = 0xFFFFFFFF
movl %eax, 0x498(%rbx)
movl $0x1, (%rbx)
popq %rbx
retq
leaq 0x104dd(%rip), %rdi     # 0x14bff
leaq 0xeb53(%rip), %rsi      # 0x1327c
leaq 0xfa90(%rip), %rcx      # 0x141c0
movl $0x6ab, %edx            # imm = 0x6AB
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: resize
static void *
resize (PS * ps, void *void_ptr, size_t old_size, size_t new_size)
{
  size_t old_bytes, new_bytes;
  Blk *b;

  b = PTR2BLK (void_ptr);

  assert (old_size <= ps->current_bytes);
  ps->current_bytes -= old_size;

  if ((old_bytes = old_size))
    {
      assert (old_size && b && b->header.size == old_size);
      old_bytes += SIZE_OF_BLK;
    }
  else
    assert (!b);

  if ((new_bytes = new_size))
    new_bytes += SIZE_OF_BLK;

  if (ps->eresize)
    b = ps->eresize (ps->emgr, b, old_bytes, new_bytes);
  else
    b = realloc (b, new_bytes);

  if (!new_size)
    {
      assert (!b);
      return 0;
    }

  ABORTIF (!b, "out of memory in 'resize'");
#ifndef NDEBUG
  b->header.size = new_size;
#endif

  ps->current_bytes += new_size;
  if (ps->current_bytes > ps->max_bytes)
    ps->max_bytes = ps->current_bytes;

  return b->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq -0x10(%rsi), %rcx
testq %rsi, %rsi
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x328(%rdi), %rdi
subq %rdx, %rdi
jb 0x481c
movq %rdi, 0x328(%r14)
testq %rdx, %rdx
je 0x4785
testq %rax, %rax
je 0x47fd
cmpq %rdx, (%rcx)
jne 0x47fd
addq $0x10, %rdx
jmp 0x4790
testq %rax, %rax
jne 0x4840
xorl %edx, %edx
leaq 0x10(%rbx), %rcx
testq %rbx, %rbx
cmoveq %rbx, %rcx
movq 0x4b0(%r14), %rax
testq %rax, %rax
je 0x47b2
movq 0x4a0(%r14), %rdi
callq *%rax
jmp 0x47bd
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x1180
testq %rbx, %rbx
je 0x47ee
testq %rax, %rax
je 0x483b
movq %rbx, (%rax)
addq 0x328(%r14), %rbx
movq %rbx, 0x328(%r14)
cmpq 0x330(%r14), %rbx
jbe 0x47e8
movq %rbx, 0x330(%r14)
addq $0x10, %rax
jmp 0x47f5
testq %rax, %rax
jne 0x485f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfa1b(%rip), %rdi      # 0x1421f
leaq 0xea71(%rip), %rsi      # 0x1327c
leaq 0xf9e2(%rip), %rcx      # 0x141f4
movl $0x3f1, %edx            # imm = 0x3F1
callq 0x10b0
leaq 0xf9b3(%rip), %rdi      # 0x141d6
leaq 0xea52(%rip), %rsi      # 0x1327c
leaq 0xf9c3(%rip), %rcx      # 0x141f4
movl $0x3ec, %edx            # imm = 0x3EC
callq 0x10b0
callq 0x12e8
leaq 0xfa04(%rip), %rdi      # 0x1424b
leaq 0xea2e(%rip), %rsi      # 0x1327c
leaq 0xf99f(%rip), %rcx      # 0x141f4
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x10b0
leaq 0xf9e5(%rip), %rdi      # 0x1424b
leaq 0xea0f(%rip), %rsi      # 0x1327c
leaq 0xf980(%rip), %rcx      # 0x141f4
movl $0x401, %edx            # imm = 0x401
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x441c
cmpl $0x0, 0x238(%r14)
jne 0x67ed
movq %r15, 0x230(%r14)
movl %ebp, 0x23c(%r14)
movl %ebx, 0x240(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcb71(%rip), %rdi      # 0x13365
leaq 0xca81(%rip), %rsi      # 0x1327c
leaq 0xcb73(%rip), %rcx      # 0x13375
movl $0x1a75, %edx           # imm = 0x1A75
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1083e
testq %rbx, %rbx
je 0x6898
movq %rbx, %rdi
callq 0x1090
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x9cfe
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
leaq 0xe758(%rip), %rdi      # 0x14ff7
leaq 0xc9d6(%rip), %rsi      # 0x1327c
leaq 0xe74e(%rip), %rcx      # 0x14ffb
movl $0x47e, %edx            # imm = 0x47E
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
negl %ebp
jo 0x7576
movl %esi, %r14d
movq %rdi, %rbx
cmovsl %esi, %ebp
cmpl 0x2c(%rdi), %ebp
jle 0x7538
movq 0x118(%rbx), %rax
cmpq 0x120(%rbx), %rax
jne 0x757b
movq %rbx, %rdi
callq 0x4184
cmpl 0x2c(%rbx), %ebp
jg 0x7514
leal (%r14,%r14), %ecx
movl $0x1, %eax
subl %ecx, %eax
testl %r14d, %r14d
cmovnsl %ecx, %eax
addq 0x38(%rbx), %rax
jmp 0x7571
leal (%r14,%r14), %eax
movl $0x1, %ecx
subl %eax, %ecx
testl %r14d, %r14d
cmovnsl %eax, %ecx
movq 0x38(%rbx), %rax
addq %rcx, %rax
movq 0x40(%rbx), %rsi
shrl %ecx
shlq $0x4, %rcx
movzwl (%rsi,%rcx), %ecx
testl %edx, %edx
je 0x756c
testb $0x40, %cl
je 0x7571
callq 0x1374
testb $0x40, %cl
je 0x7580
popq %rbx
popq %r14
popq %rbp
retq
callq 0x13c8
callq 0x13ac
callq 0x1390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7624
movq %rsi, %rbx
movq %rdi, %r14
movq 0x260(%rdi), %rax
cmpq 0x268(%rdi), %rax
jne 0x760a
movq 0x258(%r14), %rsi
cmpq %rax, %rsi
ja 0x7643
subq %rsi, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
movl $0x1, %r12d
cmovneq %rax, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x473a
movq %rax, 0x258(%r14)
addq %rax, %r15
leaq (%rax,%r12,8), %rax
movq %rax, 0x268(%r14)
movq %r15, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x260(%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xd531(%rip), %rdi      # 0x14b5c
leaq 0xbc4a(%rip), %rsi      # 0x1327c
leaq 0xdb36(%rip), %rcx      # 0x1516f
movl $0x715, %edx            # imm = 0x715
callq 0x10b0
leaq 0xdb3f(%rip), %rdi      # 0x15189
leaq 0xbc2b(%rip), %rsi      # 0x1327c
leaq 0xdb17(%rip), %rcx      # 0x1516f
movl $0x718, %edx            # imm = 0x718
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x76c1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x76fa
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x7708
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %esi
testl %esi, %esi
je 0x7718
movq %rbx, %rdi
callq 0x6e0a
jmp 0x76e1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6e0a
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_add_lits
int
picosat_add_lits (PS * ps, int * lits)
{
  const int * p;
  int lit;
  for (p = lits; (lit = *p); p++)
    (void) picosat_add (ps, lit);
  return picosat_add (ps, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
testl %esi, %esi
je 0x7752
addq $0x4, %r14
movq %rbx, %rdi
callq 0x6e0a
movl (%r14), %esi
addq $0x4, %r14
testl %esi, %esi
jne 0x773f
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6e0a
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_assume
void
picosat_assume (PS * ps, int int_lit)
{
  Lit *lit;

  if (ps->measurealltimeinlib)
    enter (ps);
  else
    check_ready (ps);

  if (ps->state != READY)
    reset_incremental_usage (ps);

  assume_contexts (ps);
  lit = import_lit (ps, int_lit, 1);
  assume (ps, lit);

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x0, 0x35c(%rdi)
je 0x779a
movq %rbx, %rdi
callq 0x3eb1
jmp 0x77a2
movq %rbx, %rdi
callq 0x441c
cmpl $0x1, (%rbx)
je 0x77af
movq %rbx, %rdi
callq 0x4601
movq %rbx, %rdi
callq 0x77ef
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74e8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7830
cmpl $0x0, 0x35c(%rbx)
je 0x77e8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4375
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assume_contexts
static void
assume_contexts (PS * ps)
{
  Lit ** p;
  if (ps->als != ps->alshead)
    return;
  for (p = ps->CLS; p != ps->clshead; p++)
    assume (ps, *p);
}

// Assembly:
movq 0xf8(%rdi), %rax
cmpq 0x100(%rdi), %rax
je 0x7800
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %r14
cmpq 0x120(%rbx), %r14
je 0x7828
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7830
addq $0x8, %r14
jmp 0x780e
addq $0x8, %rsp
popq %rbx
popq %r14
retq