LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kc885[P]SAT-Solver-with-CDCL/cdcl.cpp
// Function: ck_cdcl_solver::Solver::recursion(int, int)
bool recursion(int index, int level){
            std::unordered_set<int> implied;
            if(!unitPropagate(implied,level)){
                for(auto iter = implied.begin();iter != implied.end(); iter++)
                    val_decisionLevel[*iter] = 0;
                return false;
            }
                
            int i = index;
            while(i < variableNumber && val_decisionLevel[sor[i]] != 0)
                i++;
            if(i == variableNumber)
                return true;
            
            
            decisionVar[level+1] = sor[i];
            val_decisionLevel[sor[i]] = -level-1;
            if(recursion(i+1,level+1))
                return true;
            
            decisionVar[level+1] = -sor[i];
            val_decisionLevel[sor[i]] = level+1;
            if(recursion(i+1,level+1))
                return true;
            
            val_decisionLevel[sor[i]] = 0;
            for(auto iter = implied.begin();iter != implied.end(); iter++)
                val_decisionLevel[*iter] = 0;
            return false;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%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 0x10(%rsp), %rsi
callq 0x47aa
testb %al, %al
je 0x4bc4
leaq 0x20(%rsp), %r13
movslq 0x98(%rbx), %rdx
movq 0x50(%rbx), %rax
movq 0x80(%rbx), %rcx
movslq %ebp, %rsi
cmpl %esi, %edx
movl %esi, %r15d
cmovgl %edx, %r15d
cmpq %rdx, %rsi
jge 0x4be6
movslq (%rcx,%rsi,4), %rdi
cmpl $0x0, (%rax,%rdi,4)
je 0x4be3
incq %rsi
jmp 0x4bb0
movq 0x20(%rsp), %rax
movq 0x50(%rbx), %rcx
testq %rax, %rax
je 0x4c8a
movslq 0x8(%rax), %rdx
andl $0x0, (%rcx,%rdx,4)
movq (%rax), %rax
jmp 0x4bcd
movl %esi, %r15d
movb $0x1, %bpl
cmpl %edx, %r15d
je 0x4c8c
movslq %r15d, %r12
movslq (%rcx,%r12,4), %rcx
movslq %r14d, %rdi
leal 0x1(%r14), %esi
movq 0x68(%rbx), %rdx
movq %rdi, 0x8(%rsp)
movl %ecx, 0x4(%rdx,%rdi,4)
notl %r14d
movl %r14d, (%rax,%rcx,4)
movl %esi, %r14d
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x4b46
testb %al, %al
jne 0x4c8c
movq 0x8(%rsp), %rsi
incq %rsi
movq 0x68(%rbx), %rax
movq 0x80(%rbx), %rcx
xorl %edx, %edx
subl (%rcx,%r12,4), %edx
movl %edx, (%rax,%rsi,4)
movslq (%rcx,%r12,4), %rax
movq 0x50(%rbx), %rcx
movl %r14d, (%rcx,%rax,4)
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x4b46
testb %al, %al
jne 0x4c8c
shlq $0x2, %r12
addq 0x80(%rbx), %r12
movq 0x50(%rbx), %rax
movslq (%r12), %rcx
andl $0x0, (%rax,%rcx,4)
movq (%r13), %r13
leaq 0x8(%r13), %r12
testq %r13, %r13
jne 0x4c75
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x3bec
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ca9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3bec
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15593(%rip), %ecx     # 0x18140
movq 0x15594(%rip), %rax     # 0x18148
movabsq $0xe4904003a0001, %rdx  # imm = 0xE4904003A0001
movl %edi, %esi
cmpl %ecx, %edi
jge 0x2bfe
leal 0x1(%rsi), %edi
movslq %esi, %r8
movq (%rax,%r8,8), %r8
cmpb $0x2d, (%r8)
jne 0x2bbe
cmpb $0x61, 0x1(%r8)
jne 0x2be2
cmpb $0x0, 0x2(%r8)
je 0x2c09
movzbl 0x1(%r8), %r8d
addl $-0x41, %r8d
cmpl $0x33, %r8d
ja 0x2bbe
btq %r8, %rdx
jae 0x2bbe
addl $0x2, %esi
movl %esi, %edi
jmp 0x2bbe
movl %esi, %edi
xorl %eax, %eax
cmpl %ecx, %edi
cmovll %edi, %eax
popq %rcx
retq
cmpl %ecx, %edi
jl 0x2c00
leaq 0xe379(%rip), %rdi      # 0x10f8d
leaq 0xe054(%rip), %rsi      # 0x10c6f
leaq 0xe377(%rip), %rcx      # 0x10f99
movl $0x11e, %edx            # imm = 0x11E
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xde9a(%rip), %rsi      # 0x10ae5
movq %r14, %rdi
callq 0x2b58
movl %eax, %ebp
testl %eax, %eax
je 0x2c9d
movq %r14, %rdi
callq 0x1090
leaq 0xf(%rax), %rdi
callq 0x1160
movq %rax, %r12
leaq 0xe33e(%rip), %rsi      # 0x10fb2
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11e0
leaq 0xdb37(%rip), %rsi      # 0x107bf
movq %r12, %rdi
callq 0x1190
movq %rax, %r13
movq %r12, %rdi
callq 0x1050
jmp 0x2caf
leaq 0xdb1b(%rip), %rsi      # 0x107bf
movq %r14, %rdi
callq 0x11a0
movq %rax, %r13
testq %r13, %r13
je 0x2d0f
cmpl $0x0, 0x154ad(%rip)     # 0x18168
je 0x2ced
testl %ebp, %ebp
movq 0x1549a(%rip), %rdi     # 0x18160
leaq 0xef93(%rip), %rax      # 0x11c60
leaq 0xe308(%rip), %rdx      # 0x10fdc
cmoveq %rax, %rdx
leaq 0xe2e3(%rip), %rsi      # 0x10fc2
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 0x2d35
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
movq 0x1544a(%rip), %rdi     # 0x18160
leaq 0xdc15(%rip), %rsi      # 0x10932
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_O2/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 0x9a0f
movl %eax, %r15d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
negl %r15d
pushq $0x1
popq %r12
leaq 0xdf2d(%rip), %r13      # 0x10ca1
xorl %ebp, %ebp
leal (%r15,%r12), %eax
cmpl $0x1, %eax
je 0x2da5
movq %r14, %rdi
movl %r12d, %esi
callq 0x80c0
testl %eax, %eax
je 0x2da0
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1140
incl %ebp
incl %r12d
jmp 0x2d76
cmpl $0x0, 0x153bc(%rip)     # 0x18168
je 0x2dd3
movq 0x153ab(%rip), %rdi     # 0x18160
leaq 0xe229(%rip), %rsi      # 0x10fe5
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_O2/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 0x9a0f
movl %eax, %r14d
xorl %ebp, %ebp
xorl %r13d, %r13d
movl %r13d, %edi
callq 0x2ba4
testl %eax, %eax
je 0x2e4b
movl %eax, %r13d
movq 0x15332(%rip), %rax     # 0x18148
movslq %r13d, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11d0
movl %eax, %r12d
movq %rbx, %rdi
movl %eax, %esi
callq 0x81f1
testl %eax, %eax
je 0x2e00
movq %r15, %rdi
leaq 0xde64(%rip), %rsi      # 0x10ca1
movl %r12d, %edx
xorl %eax, %eax
callq 0x1140
incl %ebp
jmp 0x2e00
cmpl $0x0, 0x15316(%rip)     # 0x18168
je 0x2e6b
movq 0x15305(%rip), %rdi     # 0x18160
leaq 0xe1a8(%rip), %rsi      # 0x1100a
movl %ebp, %edx
xorl %eax, %eax
callq 0x1140
xorl %r15d, %r15d
testl %r14d, %r14d
cmovgl %r14d, %r15d
negl %r15d
pushq $0x1
popq %r14
leal (%r15,%r14), %eax
cmpl $0x1, %eax
je 0x2e9b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x81f1
cmpl $0x1, %eax
adcl $-0x1, %ebp
incl %r14d
jmp 0x2e7c
testl %ebp, %ebp
jne 0x2eae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe17e(%rip), %rdi      # 0x11033
leaq 0xddb3(%rip), %rsi      # 0x10c6f
leaq 0xe177(%rip), %rcx      # 0x1103a
movl $0x142, %edx            # imm = 0x142
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x152b3(%rip), %rsi     # 0x18188
pushq $0x2
popq %rdi
callq 0x1130
movq 0x152ac(%rip), %rsi     # 0x18190
pushq $0xb
popq %rdi
callq 0x1130
movq 0x152a5(%rip), %rsi     # 0x18198
pushq $0x6
popq %rdi
callq 0x1130
movq 0x1529e(%rip), %rsi     # 0x181a0
pushq $0xf
popq %rdi
callq 0x1130
movq 0x15297(%rip), %rsi     # 0x181a8
pushq $0x9
popq %rdi
callq 0x1130
movq 0x15290(%rip), %rsi     # 0x181b0
pushq $0x18
popq %rdi
callq 0x1130
movq 0x15289(%rip), %rsi     # 0x181b8
pushq $0x19
popq %rdi
popq %rax
jmp 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x1527e(%rip)     # 0x181c0
jne 0x2f65
movl %ebx, %edi
callq 0x2f72
movb $0x1, 0x1526e(%rip)     # 0x181c0
movq 0x15217(%rip), %rdi     # 0x18170
callq 0x9a2e
movl %ebx, %edi
callq 0x2f72
callq 0x2ecd
movl %ebx, %edi
popq %rbx
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2fef
cmpl $0x0, 0x151a6(%rip)     # 0x18178
je 0x300e
cmpb $0x1, 0x151f5(%rip)     # 0x181d0
je 0x302d
movb $0x1, 0x151ec(%rip)     # 0x181d0
cmpb $0x1, 0x151e9(%rip)     # 0x181d4
je 0x304c
popq %rax
retq
leaq 0xde48(%rip), %rdi      # 0x10e3e
leaq 0xdc72(%rip), %rsi      # 0x10c6f
leaq 0xde49(%rip), %rcx      # 0x10e4d
movl $0x191, %edx            # imm = 0x191
callq 0x10b0
leaq 0xde52(%rip), %rdi      # 0x10e67
leaq 0xdc53(%rip), %rsi      # 0x10c6f
leaq 0xde2a(%rip), %rcx      # 0x10e4d
movl $0x192, %edx            # imm = 0x192
callq 0x10b0
leaq 0xde49(%rip), %rdi      # 0x10e7d
leaq 0xdc34(%rip), %rsi      # 0x10c6f
leaq 0xde0b(%rip), %rcx      # 0x10e4d
movl $0x193, %edx            # imm = 0x193
callq 0x10b0
leaq 0xde43(%rip), %rdi      # 0x10e96
leaq 0xdc15(%rip), %rsi      # 0x10c6f
leaq 0xddec(%rip), %rcx      # 0x10e4d
movl $0x195, %edx            # imm = 0x195
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpb $0x1, 0x15158(%rip)     # 0x181d0
jne 0x30e3
pushq $0x1
popq %rbx
cmpb $0x0, 0x15150(%rip)     # 0x181d4
jne 0x30e3
cmpl $0x0, 0x150db(%rip)     # 0x18168
je 0x30dc
movq 0x150da(%rip), %rdi     # 0x18170
leaq 0xebc3(%rip), %r14      # 0x11c60
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa184
movq 0x150bd(%rip), %rdi     # 0x18170
movl 0x150bf(%rip), %ecx     # 0x18178
leaq 0xddea(%rip), %rdx      # 0x10eaa
movl %ebp, %esi
xorl %eax, %eax
callq 0xa184
movq 0x150a0(%rip), %rdi     # 0x18170
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa184
movb $0x1, 0x150f1(%rip)     # 0x181d4
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x15066(%rip), %rdi     # 0x18158
callq 0x1200
cmpl $0xa, %eax
jne 0x3102
incl 0x1507a(%rip)           # 0x1817c
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x150ca(%rip), %r15     # 0x181e0
leaq 0x150c4(%rip), %r12     # 0x181e1
leaq 0xdf73(%rip), %r14      # 0x11097
leaq 0x15105(%rip), %r13     # 0x18230
movq 0x14ff6(%rip), %rdi     # 0x18128
cmpq %r15, %rdi
jne 0x3148
movq %r12, 0x14fea(%rip)     # 0x18128
movb $0x76, 0x1509b(%rip)    # 0x181e0
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x11e0
cltq
addq 0x14fcb(%rip), %rax     # 0x18128
cmpq %r13, %rax
jb 0x3169
callq 0x317a
jmp 0x312b
movq %rax, 0x14fb8(%rip)     # 0x18128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14fa6(%rip), %rax     # 0x18128
movb $0x0, (%rax)
movq 0x14fd4(%rip), %rsi     # 0x18160
leaq 0x1504d(%rip), %rbx     # 0x181e0
movq %rbx, %rdi
callq 0x10c0
movq 0x14fbe(%rip), %rsi     # 0x18160
pushq $0xa
popq %rdi
callq 0x10f0
movq %rbx, 0x14f77(%rip)     # 0x18128
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movq 0x1e8(%rdi), %rax
cmpq %rax, %r12
jne 0x31dc
movq 0x1f8(%rbx), %r12
leaq 0xeae5(%rip), %r15      # 0x11cc8
cmpq 0x200(%rbx), %r12
je 0x3316
movq (%r12), %r14
testq %r14, %r14
je 0x3250
movl (%r14), %eax
testq %rax, %rax
je 0x3231
leaq 0x18(,%rax,8), %rcx
cmpq $0x20, %rcx
jne 0x3262
movl 0x18(%r14), %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 %r15, %rsi
xorl %eax, %eax
callq 0x1140
movq 0x10(%rbx), %rsi
pushq $0x30
popq %rdi
callq 0x10f0
movq 0x10(%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x10f0
movq 0x1e8(%rbx), %rax
addq $0x8, %r12
cmpq %rax, %r12
jne 0x31e3
movq 0x1f8(%rbx), %r12
jmp 0x31e3
cmpl $0x1, %eax
je 0x3325
leaq (%r14,%rax,8), %r13
addq $0x18, %r13
leaq 0x28(%r14), %rbp
movl 0x38(%rbx), %eax
movl 0x18(%r14), %ecx
movl 0x20(%r14), %edx
subl %eax, %ecx
shrl %ecx
subl %eax, %edx
shrl %edx
xorl %edi, %edi
xorl %esi, %esi
cmpl %edx, %ecx
setbe %dil
movq %rdi, (%rsp)
seta %sil
movq 0x10(%rbx), %rdi
movl 0x18(%r14,%rsi,8), %ecx
subl %eax, %ecx
movl %ecx, %eax
shrl %eax
movl %eax, %edx
negl %edx
testb $0x1, %cl
cmovel %eax, %edx
movq %r15, %rsi
xorl %eax, %eax
callq 0x1140
movq (%rsp), %rax
movl 0x18(%r14,%rax,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 %r15, %rsi
xorl %eax, %eax
callq 0x1140
cmpq %r13, %rbp
jae 0x3231
movl (%rbp), %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 %r15, %rsi
xorl %eax, %eax
callq 0x1140
addq $0x8, %rbp
jmp 0x32e6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xebc8(%rip), %rdi      # 0x11ef4
leaq 0xdf41(%rip), %rsi      # 0x11274
leaq 0xebc7(%rip), %rcx      # 0x11f01
movl $0x435, %edx            # imm = 0x435
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3647
testq %rdx, %rdx
je 0x365a
testq %rcx, %rcx
je 0x366d
popq %rax
jmp 0x3356
movq 0x149aa(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xdb17(%rip), %rdi      # 0x1116f
jmp 0x367e
movq 0x14997(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xdb3c(%rip), %rdi      # 0x111a7
jmp 0x367e
movq 0x14984(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xdb62(%rip), %rdi      # 0x111e0
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36af
movq 0x118(%rbx), %rax
cmpq 0x120(%rbx), %rax
jne 0x36e8
movq %rbx, %rdi
callq 0x3703
cmpl %r14d, 0x30(%rbx)
ja 0x36d3
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x372f
jmp 0x36d3
movq %rbx, %rdi
callq 0x39cf
cmpl %r14d, 0x2c(%rbx)
jb 0x36cb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ade
movq 0x14909(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xdb1d(%rip), %rdi      # 0x11216
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: inc_max_var
inline static void
inc_max_var (PS * ps)
{
  Lit *lit;
  Rnk *r;
  Var *v;

  assert (ps->max_var < ps->size_vars);

  if (ps->max_var + 1 == ps->size_vars)
    enlarge (ps, ps->size_vars + 2*(ps->size_vars + 3) / 4); /* +25% */

  ps->max_var++;			/* new index of variable */
  assert (ps->max_var);			/* no unsigned overflow */

  assert (ps->max_var < ps->size_vars);

  lit = ps->lits + 2 * ps->max_var;
  lit[0].val = lit[1].val = UNDEF;

  memset (ps->htps + 2 * ps->max_var, 0, 2 * sizeof *ps->htps);
#ifndef NDSC
  memset (ps->dhtps + 2 * ps->max_var, 0, 2 * sizeof *ps->dhtps);
#endif
  memset (ps->impls + 2 * ps->max_var, 0, 2 * sizeof *ps->impls);
  memset (ps->jwh + 2 * ps->max_var, 0, 2 * sizeof *ps->jwh);

  v = ps->vars + ps->max_var;		/* initialize variable components */
  CLR (v);

  r = ps->rnks + ps->max_var;		/* initialize rank */
  CLR (r);

  hpush (ps, r);
}

// Assembly:
pushq %rbx
movl 0x2c(%rdi), %eax
movl 0x30(%rdi), %ecx
cmpl %ecx, %eax
jae 0x3a81
movq %rdi, %rbx
leal 0x1(%rax), %edx
cmpl %ecx, %edx
jne 0x39ff
leal 0x6(,%rcx,2), %esi
shrl $0x2, %esi
addl %ecx, %esi
movq %rbx, %rdi
callq 0x372f
movl 0x2c(%rbx), %eax
incl %eax
movl %eax, 0x2c(%rbx)
je 0x3aa0
cmpl 0x30(%rbx), %eax
jae 0x3abf
movq 0x38(%rbx), %rcx
addl %eax, %eax
andw $0x0, (%rcx,%rax)
movq 0x58(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rcx,%rax,8)
movq 0x60(%rbx), %rax
movl 0x2c(%rbx), %ecx
addl %ecx, %ecx
movups %xmm0, (%rax,%rcx,8)
movq 0x68(%rbx), %rax
movl 0x2c(%rbx), %ecx
addl %ecx, %ecx
shlq $0x4, %rcx
movups %xmm0, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq 0x50(%rbx), %rax
movl 0x2c(%rbx), %ecx
addl %ecx, %ecx
andq $0x0, (%rax,%rcx,4)
movq 0x40(%rbx), %rax
movl 0x2c(%rbx), %ecx
shlq $0x4, %rcx
movups %xmm0, (%rax,%rcx)
movq 0x48(%rbx), %rax
movl 0x2c(%rbx), %ecx
leaq (%rax,%rcx,8), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
popq %rbx
jmp 0xa357
leaq 0xe622(%rip), %rdi      # 0x120aa
leaq 0xd7e5(%rip), %rsi      # 0x11274
leaq 0xe630(%rip), %rcx      # 0x120c6
movl $0x1167, %edx           # imm = 0x1167
callq 0x10b0
leaq 0xfb6b(%rip), %rdi      # 0x13612
leaq 0xd7c6(%rip), %rsi      # 0x11274
leaq 0xe611(%rip), %rcx      # 0x120c6
movl $0x116d, %edx           # imm = 0x116D
callq 0x10b0
leaq 0xe5e4(%rip), %rdi      # 0x120aa
leaq 0xd7a7(%rip), %rsi      # 0x11274
leaq 0xe5f2(%rip), %rcx      # 0x120c6
movl $0x116f, %edx           # imm = 0x116F
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b2e
movq %rbx, %rdi
callq 0x3703
jmp 0x3b36
movq %rbx, %rdi
callq 0x3b54
movq %rbx, %rdi
callq 0x39cf
cmpl $0x0, 0x35c(%rbx)
je 0x3b4f
movq %rbx, %rdi
callq 0x3ade
movl 0x2c(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bc2
movq %rbx, %rdi
callq 0x3703
jmp 0x3bca
movq %rbx, %rdi
callq 0x3b54
cmpl $0x1, (%rbx)
je 0x3bd7
movq %rbx, %rdi
callq 0x3d4b
movq 0x138(%rbx), %rax
cmpq %rax, 0x130(%rbx)
je 0x3c26
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 0x3c59
leaq 0xd64f(%rip), %rdi      # 0x1125d
leaq 0xd65f(%rip), %rsi      # 0x11274
leaq 0xd662(%rip), %rcx      # 0x1127e
movl $0x1a0b, %edx           # imm = 0x1A0B
callq 0x10b0
movq %rbx, %rdi
callq 0x39cf
movslq 0x2c(%rbx), %r14
movq 0x40(%rbx), %rax
movq %r14, %rdx
shlq $0x4, %rdx
movzwl (%rax,%rdx), %ecx
testb $0x40, %cl
jne 0x3d0d
addq %rdx, %rax
orl $0x40, %ecx
movw %cx, (%rax)
incl 0x424(%rbx)
leal (%r14,%r14), %eax
pushq $0x1
popq %r12
subl %eax, %r12d
testl %r14d, %r14d
cmovnsl %eax, %r12d
addq 0x38(%rbx), %r12
movq 0x120(%rbx), %rax
cmpq 0x128(%rbx), %rax
jne 0x3cdb
movq 0x118(%rbx), %rsi
cmpq %rax, %rsi
ja 0x3d2c
subq %rsi, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
pushq $0x1
popq %r13
cmovneq %rax, %r13
leaq (,%r13,8), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3e40
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 0x3d00
movq %rbx, %rdi
callq 0x3ade
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xd581(%rip), %rdi      # 0x11295
leaq 0xd559(%rip), %rsi      # 0x11274
leaq 0xd55c(%rip), %rcx      # 0x1127e
movl $0x1a12, %edx           # imm = 0x1A12
callq 0x10b0
leaq 0xd56f(%rip), %rdi      # 0x112a2
leaq 0xd53a(%rip), %rsi      # 0x11274
leaq 0xd53d(%rip), %rcx      # 0x1127e
movl $0x1a1b, %edx           # imm = 0x1A1B
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x9973
cmpl $0x0, 0x28(%rbx)
je 0x3d64
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb7ab
andq $0x0, 0x1b8(%rbx)
cmpl $0x0, 0x1c0(%rbx)
je 0x3da6
movq 0xf8(%rbx), %rax
cmpq 0x100(%rbx), %rax
jae 0x3d9f
movq 0x40(%rbx), %rcx
movl (%rax), %edx
subl 0x38(%rbx), %edx
shrl %edx
shlq $0x4, %rdx
andw $-0x21, (%rcx,%rdx)
addq $0x8, %rax
jmp 0x3d7c
andl $0x0, 0x1c0(%rbx)
movq 0xf8(%rbx), %rcx
movq 0x250(%rbx), %rax
movq %rcx, 0x100(%rbx)
movq %rcx, 0x108(%rbx)
andl $0x0, 0xf0(%rbx)
testq %rax, %rax
je 0x3dea
leaq 0x98(%rbx), %rcx
cmpq %rcx, %rax
jne 0x3de2
movq %rbx, %rdi
callq 0xb880
andq $0x0, 0x250(%rbx)
cmpl $0x0, 0x22c(%rbx)
je 0x3e1a
pushq $0x1
popq %rax
movl 0x2c(%rbx), %ecx
cmpl %ecx, %eax
ja 0x3e11
movq 0x40(%rbx), %rcx
movl %eax, %edx
shlq $0x4, %rdx
andw $0xdfff, (%rcx,%rdx)    # imm = 0xDFFF
incl %eax
jmp 0x3df6
andl $0x0, 0x22c(%rbx)
jmp 0x3e1d
movl 0x2c(%rbx), %ecx
movq 0x468(%rbx), %rax
movq %rax, 0x490(%rbx)
orl $-0x1, 0x49c(%rbx)
movl %ecx, 0x498(%rbx)
movl $0x1, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f2a
movq %rdi, 0x328(%r14)
testq %rdx, %rdx
je 0x3e8f
testq %rax, %rax
je 0x3f0b
cmpq %rdx, (%rcx)
jne 0x3f0b
addq $0x10, %rdx
jmp 0x3e9a
testq %rax, %rax
jne 0x3f64
xorl %edx, %edx
leaq 0x10(%rbx), %rcx
testq %rbx, %rbx
cmoveq %rbx, %rcx
movq 0x4b0(%r14), %rax
testq %rax, %rax
je 0x3ebc
movq 0x4a0(%r14), %rdi
callq *%rax
jmp 0x3ec7
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x1180
testq %rbx, %rbx
je 0x3ef8
testq %rax, %rax
je 0x3f49
movq %rbx, (%rax)
addq 0x328(%r14), %rbx
movq %rbx, 0x328(%r14)
cmpq 0x330(%r14), %rbx
jbe 0x3ef2
movq %rbx, 0x330(%r14)
addq $0x10, %rax
jmp 0x3f03
testq %rax, %rax
jne 0x3f83
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xe305(%rip), %rdi      # 0x12217
leaq 0xd35b(%rip), %rsi      # 0x11274
leaq 0xe2cc(%rip), %rcx      # 0x121ec
movl $0x3f1, %edx            # imm = 0x3F1
callq 0x10b0
leaq 0xe29d(%rip), %rdi      # 0x121ce
leaq 0xd33c(%rip), %rsi      # 0x11274
leaq 0xe2ad(%rip), %rcx      # 0x121ec
movl $0x3ec, %edx            # imm = 0x3EC
callq 0x10b0
movq 0x140a8(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xe2ec(%rip), %rdi      # 0x12246
callq 0x10c0
callq 0x1060
leaq 0xe2d8(%rip), %rdi      # 0x12243
leaq 0xd302(%rip), %rsi      # 0x11274
leaq 0xe273(%rip), %rcx      # 0x121ec
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x10b0
leaq 0xe2b9(%rip), %rdi      # 0x12243
leaq 0xd2e3(%rip), %rsi      # 0x11274
leaq 0xe254(%rip), %rcx      # 0x121ec
movl $0x401, %edx            # imm = 0x401
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
cmpl $0x0, 0x238(%r14)
jne 0x5d1d
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 0xb639(%rip), %rdi      # 0x1135d
leaq 0xb549(%rip), %rsi      # 0x11274
leaq 0xb63b(%rip), %rcx      # 0x1136d
movl $0x1a75, %edx           # imm = 0x1A75
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xef2c
testq %rbx, %rbx
je 0x5dc8
movq %rbx, %rdi
callq 0x1090
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x8f50
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
leaq 0xd220(%rip), %rdi      # 0x12fef
leaq 0xb49e(%rip), %rsi      # 0x11274
leaq 0xd216(%rip), %rcx      # 0x12ff3
movl $0x47e, %edx            # imm = 0x47E
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a92
movl %esi, %r14d
movq %rdi, %rbx
cmovsl %esi, %ebp
movl 0x2c(%rdi), %eax
cmpl %eax, %ebp
jle 0x6a48
movq 0x118(%rbx), %rcx
cmpq 0x120(%rbx), %rcx
je 0x6a2f
movq 0x115e0(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xc690(%rip), %rdi      # 0x130b2
jmp 0x6aa3
movq %rbx, %rdi
callq 0x39cf
movl 0x2c(%rbx), %eax
cmpl %eax, %ebp
jg 0x6a24
leal (%r14,%r14), %ecx
pushq $0x1
popq %rax
subl %ecx, %eax
testl %r14d, %r14d
cmovnsl %ecx, %eax
addq 0x38(%rbx), %rax
jmp 0x6a8d
leal (%r14,%r14), %eax
pushq $0x1
popq %rcx
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 0x6a88
testb $0x40, %cl
je 0x6a8d
movq 0x1157c(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xc66d(%rip), %rdi      # 0x130f3
jmp 0x6aa3
testb $0x40, %cl
je 0x6aad
popq %rbx
popq %r14
popq %rbp
retq
movq 0x1155f(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xc5e6(%rip), %rdi      # 0x13089
callq 0x10c0
callq 0x1060
movq 0x11544(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0xc66f(%rip), %rdi      # 0x1312d
jmp 0x6aa3
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6b5d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x260(%rdi), %rax
cmpq 0x268(%rdi), %rax
jne 0x6b43
movq 0x258(%r14), %rsi
cmpq %rax, %rsi
ja 0x6b7c
subq %rsi, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
pushq $0x1
popq %r12
cmovneq %rax, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x3e40
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 0xbff0(%rip), %rdi      # 0x12b54
leaq 0xa709(%rip), %rsi      # 0x11274
leaq 0xc5f5(%rip), %rcx      # 0x13167
movl $0x715, %edx            # imm = 0x715
callq 0x10b0
leaq 0xc5fe(%rip), %rdi      # 0x13181
leaq 0xa6ea(%rip), %rsi      # 0x11274
leaq 0xc5d6(%rip), %rcx      # 0x13167
movl $0x718, %edx            # imm = 0x718
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6bfa
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 0x6c33
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x6c41
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %esi
testl %esi, %esi
je 0x6c51
movq %rbx, %rdi
callq 0x633b
jmp 0x6c1a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x633b
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 (%r14), %esi
testl %esi, %esi
je 0x6c83
movq %rbx, %rdi
callq 0x633b
addq $0x4, %r14
jmp 0x6c6e
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x633b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6ccb
movq %rbx, %rdi
callq 0x3703
jmp 0x6cd3
movq %rbx, %rdi
callq 0x3b54
cmpl $0x1, (%rbx)
je 0x6ce0
movq %rbx, %rdi
callq 0x3d4b
movq %rbx, %rdi
callq 0x6d1e
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x69e3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6d5f
cmpl $0x0, 0x35c(%rbx)
je 0x6d17
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ade
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6d2f
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %r14
cmpq 0x120(%rbx), %r14
je 0x6d57
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x6d5f
addq $0x8, %r14
jmp 0x6d3d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assume
static void
assume (PS * ps, Lit * lit)
{
  if (ps->alshead == ps->eoals)
    {
      assert (ps->alstail == ps->als);
      ENLARGE (ps->als, ps->alshead, ps->eoals);
      ps->alstail = ps->als;
    }

  *ps->alshead++ = lit;
  LOG ( fprintf (ps->out, "%sassumption %d\n", ps->prefix, LIT2INT (lit)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x100(%rdi), %rax
cmpq 0x110(%rdi), %rax
jne 0x6dec
movq 0xf8(%r14), %rsi
movq 0x108(%r14), %rcx
cmpq %rsi, %rcx
jne 0x6e06
cmpq %rax, %rcx
ja 0x6e25
subq %rcx, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
pushq $0x1
popq %r12
cmovneq %rax, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x3e40
movq %rax, 0xf8(%r14)
addq %rax, %r15
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x110(%r14)
movq %rax, 0x108(%r14)
movq %r15, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x100(%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xc3fc(%rip), %rdi      # 0x13209
leaq 0xa460(%rip), %rsi      # 0x11274
leaq 0xc405(%rip), %rcx      # 0x13220
movl $0x1b08, %edx           # imm = 0x1B08
callq 0x10b0
leaq 0xc40d(%rip), %rdi      # 0x13239
leaq 0xa441(%rip), %rsi      # 0x11274
leaq 0xc3e6(%rip), %rcx      # 0x13220
movl $0x1b09, %edx           # imm = 0x1B09
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rheader
static void
rheader (PS * ps)
{
  assert (ps->lastrheader <= ps->reports);

  if (ps->lastrheader == ps->reports)
    return;

  ps->lastrheader = ps->reports;

   fprintf (ps->out, "%s\n", ps->prefix);
   fprintf (ps->out, "%s %s\n", ps->prefix, ps->rline[0]);
   fprintf (ps->out, "%s %s\n", ps->prefix, ps->rline[1]);
   fprintf (ps->out, "%s\n", ps->prefix);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x384(%rdi), %eax
cmpl %eax, 0x388(%rdi)
jg 0x7f16
jne 0x7ea4
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl %eax, 0x388(%rdi)
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
leaq 0xb3d1(%rip), %r14      # 0x1328d
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq 0x360(%rbx), %rcx
leaq 0xb6e3(%rip), %r15      # 0x135bf
movq %r15, %rsi
xorl %eax, %eax
callq 0x1140
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq 0x368(%rbx), %rcx
movq %r15, %rsi
xorl %eax, %eax
callq 0x1140
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1140
leaq 0xb670(%rip), %rdi      # 0x1358d
leaq 0x9350(%rip), %rsi      # 0x11274
leaq 0xb681(%rip), %rcx      # 0x135ac
movl $0xc55, %edx            # imm = 0xC55
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_deref
int
picosat_deref (PS * ps, int int_lit)
{
  Lit *lit;

  check_ready (ps);
  check_sat_state (ps);
  ABORTIF (!int_lit, "API usage: can not deref zero literal");
  ABORTIF (ps->mtcls, "API usage: deref after empty clause generated");

#ifdef STATS
  ps->derefs++;
#endif

  if (abs (int_lit) > (int) ps->max_var)
    return 0;

  lit = int2lit (ps, int_lit);

  if (lit->val == TRUE)
    return 1;

  if (lit->val == FALSE)
    return -1;

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3b54
movq %r14, %rdi
callq 0x7fc8
testl %ebx, %ebx
je 0x7f9a
cmpq $0x0, 0x248(%r14)
jne 0x7fad
movl %ebx, %ecx
negl %ecx
cmovsl %ebx, %ecx
xorl %eax, %eax
cmpl 0x2c(%r14), %ecx
jg 0x7f92
movq 0x38(%r14), %rax
leal (%rbx,%rbx), %ecx
pushq $0x1
popq %rdx
movl %edx, %esi
subl %ecx, %esi
testl %ebx, %ebx
cmovnsl %ecx, %esi
movb (%rax,%rsi), %cl
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
negl %eax
cmpb $0x1, %cl
cmovel %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10057(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0x94f1(%rip), %rdi      # 0x1149c
jmp 0x7fbe
movq 0x10044(%rip), %rax     # 0x17ff8
movq (%rax), %rsi
leaq 0x9512(%rip), %rdi      # 0x114d0
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_deref_toplevel
int
picosat_deref_toplevel (PS * ps, int int_lit)
{
  check_ready (ps);
  ABORTIF (!int_lit, "API usage: can not deref zero literal");

#ifdef STATS
  ps->derefs++;
#endif
  if (abs (int_lit) > (int) ps->max_var)
    return 0;

  return tderef (ps, int_lit);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3b54
testl %ebx, %ebx
je 0x8021
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
cmpl 0x2c(%r14), %eax
jle 0x8013
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x803c
movq 0xffd0(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x946a(%rip), %rdi      # 0x1149c
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: tderef
static int
tderef (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;

  assert (abs (int_lit) <= (int) ps->max_var);

  lit = int2lit (ps, int_lit);

  v = LIT2VAR (lit);
  if (v->level > 0)
    return 0;

  if (lit->val == TRUE)
    return 1;

  if (lit->val == FALSE)
    return -1;

  return 0;
}

// Assembly:
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
cmpl 0x2c(%rdi), %eax
jg 0x8088
leal (%rsi,%rsi), %eax
pushq $0x1
popq %rcx
movl %ecx, %edx
subl %eax, %edx
testl %esi, %esi
cmovnsl %eax, %edx
movq 0x40(%rdi), %rsi
movl %edx, %r8d
shrl %r8d
shlq $0x4, %r8
xorl %eax, %eax
cmpl $0x0, 0x4(%rsi,%r8)
je 0x8070
retq
movq 0x38(%rdi), %rax
movb (%rax,%rdx), %dl
xorl %eax, %eax
cmpb $-0x1, %dl
sete %al
negl %eax
cmpb $0x1, %dl
cmovel %ecx, %eax
retq
pushq %rax
leaq 0xb56b(%rip), %rdi      # 0x135fb
leaq 0x91dd(%rip), %rsi      # 0x11274
leaq 0xb580(%rip), %rcx      # 0x1361e
movl $0x1b29, %edx           # imm = 0x1B29
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_corelit
int
picosat_corelit (PS * ps, int int_lit)
{
  check_ready (ps);
  check_unsat_state (ps);
  ABORTIF (!int_lit, "API usage: zero literal can not be in core");

  assert (ps->mtcls || ps->failed_assumption);

#ifdef TRACE
  {
    int res = 0;
    ABORTIF (!ps->trace, "tracing disabled");
    if (ps->measurealltimeinlib)
      enter (ps);
    core (ps);
    if (abs (int_lit) <= (int) ps->max_var)
      res = ps->vars[abs (int_lit)].core;
    assert (!res || ps->failed_assumption || ps->vars[abs (int_lit)].used);
    if (ps->measurealltimeinlib)
      leave (ps);
    return res;
  }
#else
  ABORT ("compiled without trace support");
  return 0;
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3b54
movq %rbx, %rdi
callq 0x813a
testl %ebp, %ebp
jne 0x80ec
movq 0xff18(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x9422(%rip), %rdi      # 0x1150c
jmp 0x8130
cmpq $0x0, 0x248(%rbx)
jne 0x811f
cmpq $0x0, 0x1b8(%rbx)
jne 0x811f
leaq 0x943e(%rip), %rdi      # 0x11545
leaq 0x9166(%rip), %rsi      # 0x11274
leaq 0x9453(%rip), %rcx      # 0x11568
movl $0x1c31, %edx           # imm = 0x1C31
callq 0x10b0
movq 0xfed2(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x9457(%rip), %rdi      # 0x11587
callq 0x10c0
callq 0x1060