LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa6c2
movl %eax, %r14d
xorl %ebp, %ebp
xorl %r13d, %r13d
movl %r13d, %edi
callq 0x3283
testl %eax, %eax
je 0x3562
movl %eax, %r13d
movq 0x15c1b(%rip), %rax     # 0x19148
movslq %r13d, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11c0
movl %eax, %r12d
movq %rbx, %rdi
movl %eax, %esi
callq 0x8d81
testl %eax, %eax
je 0x3517
movq %r15, %rdi
leaq 0xe786(%rip), %rsi      # 0x11cda
movl %r12d, %edx
xorl %eax, %eax
callq 0x1130
incl %ebp
jmp 0x3517
cmpl $0x0, 0x15bff(%rip)     # 0x19168
je 0x3582
movq 0x15bee(%rip), %rdi     # 0x19160
leaq 0xeaca(%rip), %rsi      # 0x12043
movl %ebp, %edx
xorl %eax, %eax
callq 0x1130
testl %r14d, %r14d
jle 0x35b4
negl %r14d
movl $0x1, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8d81
cmpl $0x1, %eax
adcl $-0x1, %ebp
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x3590
testl %ebp, %ebp
jne 0x35c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xea9e(%rip), %rdi      # 0x1206c
leaq 0xe6d3(%rip), %rsi      # 0x11ca8
leaq 0xea97(%rip), %rcx      # 0x12073
movl $0x142, %edx            # imm = 0x142
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15b9a(%rip), %rsi     # 0x19188
movl $0x2, %edi
callq 0x1120
movq 0x15b91(%rip), %rsi     # 0x19190
movl $0xb, %edi
callq 0x1120
movq 0x15b88(%rip), %rsi     # 0x19198
movl $0x6, %edi
callq 0x1120
movq 0x15b7f(%rip), %rsi     # 0x191a0
movl $0xf, %edi
callq 0x1120
movq 0x15b76(%rip), %rsi     # 0x191a8
movl $0x9, %edi
callq 0x1120
movq 0x15b6d(%rip), %rsi     # 0x191b0
movl $0x18, %edi
callq 0x1120
movq 0x15b64(%rip), %rsi     # 0x191b8
movl $0x19, %edi
popq %rax
jmp 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x15b57(%rip)     # 0x191c0
jne 0x368c
movl %ebx, %edi
callq 0x3699
movb $0x1, 0x15b47(%rip)     # 0x191c0
movq 0x15af0(%rip), %rdi     # 0x19170
callq 0xa6e1
movl %ebx, %edi
callq 0x3699
callq 0x35e6
movl %ebx, %edi
popq %rbx
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/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 0x371f
cmpl $0x0, 0x15a76(%rip)     # 0x19178
je 0x373e
cmpb $0x1, 0x15ac5(%rip)     # 0x191d0
je 0x375d
movb $0x1, 0x15abc(%rip)     # 0x191d0
cmpb $0x1, 0x15ab9(%rip)     # 0x191d4
je 0x377c
popq %rax
retq
leaq 0xe751(%rip), %rdi      # 0x11e77
leaq 0xe57b(%rip), %rsi      # 0x11ca8
leaq 0xe752(%rip), %rcx      # 0x11e86
movl $0x191, %edx            # imm = 0x191
callq 0x10b0
leaq 0xe75b(%rip), %rdi      # 0x11ea0
leaq 0xe55c(%rip), %rsi      # 0x11ca8
leaq 0xe733(%rip), %rcx      # 0x11e86
movl $0x192, %edx            # imm = 0x192
callq 0x10b0
leaq 0xe752(%rip), %rdi      # 0x11eb6
leaq 0xe53d(%rip), %rsi      # 0x11ca8
leaq 0xe714(%rip), %rcx      # 0x11e86
movl $0x193, %edx            # imm = 0x193
callq 0x10b0
leaq 0xe74c(%rip), %rdi      # 0x11ecf
leaq 0xe51e(%rip), %rsi      # 0x11ca8
leaq 0xe6f5(%rip), %rcx      # 0x11e86
movl $0x195, %edx            # imm = 0x195
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x15a28(%rip)     # 0x191d0
jne 0x381b
movl $0x1, %ebx
cmpb $0x0, 0x15a1e(%rip)     # 0x191d4
jne 0x381b
cmpl $0x0, 0x159a9(%rip)     # 0x19168
je 0x3814
movq 0x159a8(%rip), %rdi     # 0x19170
leaq 0xf4c9(%rip), %r14      # 0x12c98
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xae65
movq 0x1598b(%rip), %rdi     # 0x19170
movl 0x1598d(%rip), %ecx     # 0x19178
leaq 0xe6f1(%rip), %rdx      # 0x11ee3
movl $0x1, %esi
xorl %eax, %eax
callq 0xae65
movq 0x1596b(%rip), %rdi     # 0x19170
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xae65
movb $0x1, 0x159b9(%rip)     # 0x191d4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x159a9(%rip), %r15     # 0x191e0
leaq 0x159a3(%rip), %r12     # 0x191e1
leaq 0xe88b(%rip), %r14      # 0x120d0
leaq 0x159e4(%rip), %r13     # 0x19230
cmpq %r15, 0x158cd(%rip)     # 0x19120
jne 0x3863
movq %r12, 0x158c4(%rip)     # 0x19120
movb $0x76, 0x1597d(%rip)    # 0x191e0
movq 0x158b6(%rip), %rdi     # 0x19120
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x11d0
cltq
addq 0x158a1(%rip), %rax     # 0x19120
cmpq %r13, %rax
jb 0x388b
callq 0x389c
jmp 0x384c
movq %rax, 0x1588e(%rip)     # 0x19120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1587c(%rip), %rax     # 0x19120
movb $0x0, (%rax)
movq 0x158b2(%rip), %rsi     # 0x19160
leaq 0x1592b(%rip), %rbx     # 0x191e0
movq %rbx, %rdi
callq 0x10c0
movq 0x1589c(%rip), %rsi     # 0x19160
movl $0xa, %edi
callq 0x10f0
movq %rbx, 0x1584b(%rip)     # 0x19120
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq 0x1e8(%rdi), %r15
jne 0x38fd
movq 0x1f8(%rbx), %r15
cmpq 0x200(%rbx), %r15
je 0x3a4d
leaq 0xf3ef(%rip), %r14      # 0x12d00
movq (%r15), %r12
testq %r12, %r12
je 0x3a2c
movl (%r12), %r13d
testq %r13, %r13
je 0x3a10
leaq 0x18(,%r13,8), %rax
cmpq $0x20, %rax
jne 0x3960
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 0x1130
jmp 0x3a10
cmpl $0x1, %r13d
je 0x3a5c
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 0x1130
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 0x1130
cmpl $0x3, %r13d
jb 0x3a10
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 0x1130
addq $0x8, %r12
cmpq %r13, %r12
jb 0x39e5
movq 0x10(%rbx), %rsi
movl $0x30, %edi
callq 0x10f0
movq 0x10(%rbx), %rsi
movl $0xa, %edi
callq 0x10f0
addq $0x8, %r15
cmpq 0x1e8(%rbx), %r15
jne 0x3a40
movq 0x1f8(%rbx), %r15
cmpq 0x200(%rbx), %r15
jne 0x3911
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf4c9(%rip), %rdi      # 0x12f2c
leaq 0xe842(%rip), %rsi      # 0x122ac
leaq 0xf4c8(%rip), %rcx      # 0x12f39
movl $0x435, %edx            # imm = 0x435
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d72
testq %rdx, %rdx
je 0x3d77
testq %rcx, %rcx
je 0x3d7c
popq %rax
jmp 0x3a8d
callq 0x1284
callq 0x1268
callq 0x124c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3da8
movq 0x118(%rbx), %rax
cmpq 0x120(%rbx), %rax
jne 0x3de1
movq %rbx, %rdi
callq 0x3de6
cmpl %r14d, 0x30(%rbx)
ja 0x3dcc
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x3e12
jmp 0x3dcc
movq %rbx, %rdi
callq 0x40ae
cmpl %r14d, 0x2c(%rbx)
jb 0x3dc4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41bd
callq 0x12a0
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
movl 0x30(%rdi), %eax
cmpl %eax, %ecx
jae 0x4160
movq %rdi, %rbx
incl %ecx
cmpl %eax, %ecx
jne 0x40da
leal 0x6(,%rax,2), %esi
shrl $0x2, %esi
addl %eax, %esi
movq %rbx, %rdi
callq 0x3e12
movl 0x2c(%rbx), %eax
incl %eax
movl %eax, 0x2c(%rbx)
je 0x417f
cmpl 0x30(%rbx), %eax
jae 0x419e
movq 0x38(%rbx), %rcx
addl %eax, %eax
movw $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
xorl %edx, %edx
movq %rdx, (%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
movq %rdx, (%rsi)
movq %rbx, %rdi
popq %rbx
jmp 0xb043
leaq 0xef89(%rip), %rdi      # 0x130f0
leaq 0xe13e(%rip), %rsi      # 0x122ac
leaq 0xef97(%rip), %rcx      # 0x1310c
movl $0x1167, %edx           # imm = 0x1167
callq 0x10b0
leaq 0x10512(%rip), %rdi     # 0x14698
leaq 0xe11f(%rip), %rsi      # 0x122ac
leaq 0xef78(%rip), %rcx      # 0x1310c
movl $0x116d, %edx           # imm = 0x116D
callq 0x10b0
leaq 0xef4b(%rip), %rdi      # 0x130f0
leaq 0xe100(%rip), %rsi      # 0x122ac
leaq 0xef59(%rip), %rcx      # 0x1310c
movl $0x116f, %edx           # imm = 0x116F
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4208
movq %rdi, %rbx
decl %eax
movl %eax, 0x358(%rdi)
jne 0x4206
callq 0xab36
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 0xef14(%rip), %rdi      # 0x13123
leaq 0xe096(%rip), %rsi      # 0x122ac
leaq 0xef13(%rip), %rcx      # 0x13130
movl $0x1962, %edx           # imm = 0x1962
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x423e
movq %rbx, %rdi
callq 0x3de6
jmp 0x4246
movq %rbx, %rdi
callq 0x4264
movq %rbx, %rdi
callq 0x40ae
cmpl $0x0, 0x35c(%rbx)
je 0x425f
movq %rbx, %rdi
callq 0x41bd
movl 0x2c(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x35c(%rdi)
je 0x42be
movq %rbx, %rdi
callq 0x3de6
jmp 0x42c6
movq %rbx, %rdi
callq 0x4264
cmpl $0x1, (%rbx)
je 0x42d3
movq %rbx, %rdi
callq 0x4460
movq 0x138(%rbx), %rax
cmpq %rax, 0x130(%rbx)
je 0x4322
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 0x4355
leaq 0xdf8b(%rip), %rdi      # 0x12295
leaq 0xdf9b(%rip), %rsi      # 0x122ac
leaq 0xdf9e(%rip), %rcx      # 0x122b6
movl $0x1a0b, %edx           # imm = 0x1A0B
callq 0x10b0
movq %rbx, %rdi
callq 0x40ae
movslq 0x2c(%rbx), %r14
movq 0x40(%rbx), %rax
movq %r14, %rdx
shlq $0x4, %rdx
movzwl (%rax,%rdx), %ecx
testb $0x40, %cl
jne 0x4422
addq %rdx, %rax
orl $0x40, %ecx
movw %cx, (%rax)
incl 0x424(%rbx)
leal (%r14,%r14), %eax
movl $0x1, %r15d
subl %eax, %r15d
testl %r14d, %r14d
cmovnsl %eax, %r15d
addq 0x38(%rbx), %r15
movq 0x120(%rbx), %r12
movq 0x128(%rbx), %rdx
cmpq %rdx, %r12
jne 0x43e4
movq 0x118(%rbx), %rsi
cmpq %rdx, %rsi
ja 0x4441
subq %rsi, %r12
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %r13      # imm = 0x7FFFFFFF8
andq %r13, %rdx
movl %eax, %eax
movl $0x1, %ebp
cmovneq %rax, %rbp
leaq (,%rbp,8), %rcx
movq %rbx, %rdi
callq 0x4593
movq %rax, 0x118(%rbx)
andq %r13, %r12
addq %rax, %r12
movq %r12, 0x120(%rbx)
leaq (%rax,%rbp,8), %rax
movq %rax, 0x128(%rbx)
movq 0x120(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x120(%rbx)
movq %r15, (%rax)
incl 0x420(%rbx)
cmpl $0x0, 0x35c(%rbx)
je 0x4410
movq %rbx, %rdi
callq 0x41bd
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdea4(%rip), %rdi      # 0x122cd
leaq 0xde7c(%rip), %rsi      # 0x122ac
leaq 0xde7f(%rip), %rcx      # 0x122b6
movl $0x1a12, %edx           # imm = 0x1A12
callq 0x10b0
leaq 0xde92(%rip), %rdi      # 0x122da
leaq 0xde5d(%rip), %rsi      # 0x122ac
leaq 0xde60(%rip), %rcx      # 0x122b6
movl $0x1a1b, %edx           # imm = 0x1A1B
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa63c
cmpl $0x0, 0x28(%rbx)
je 0x4479
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc632
movq $0x0, 0x1b8(%rbx)
cmpl $0x0, 0x1c0(%rbx)
je 0x44c1
movq 0xf8(%rbx), %rax
cmpq 0x100(%rbx), %rax
jae 0x44b7
movq 0x40(%rbx), %rcx
movl (%rax), %edx
subl 0x38(%rbx), %edx
shrl %edx
shlq $0x4, %rdx
andw $-0x21, (%rcx,%rdx)
addq $0x8, %rax
jmp 0x4494
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 0x4516
leaq 0x98(%rbx), %rcx
cmpq %rcx, %rax
jne 0x450b
cmpl $0x0, 0xc4(%rbx)
je 0x4574
movl $0x0, 0xc4(%rbx)
movq $0x0, 0x250(%rbx)
cmpl $0x0, 0x22c(%rbx)
je 0x454b
cmpl $0x0, 0x2c(%rbx)
je 0x4541
movl $0x1, %eax
movq 0x40(%rbx), %rcx
movl %eax, %edx
shlq $0x4, %rdx
andw $0xdfff, (%rcx,%rdx)    # imm = 0xDFFF
incl %eax
cmpl 0x2c(%rbx), %eax
jbe 0x452a
movl $0x0, 0x22c(%rbx)
movq 0x468(%rbx), %rax
movq %rax, 0x490(%rbx)
movl $0xffffffff, 0x49c(%rbx) # imm = 0xFFFFFFFF
movl 0x2c(%rbx), %eax
movl %eax, 0x498(%rbx)
movl $0x1, (%rbx)
popq %rbx
retq
leaq 0xf6c2(%rip), %rdi      # 0x13c3d
leaq 0xdd2a(%rip), %rsi      # 0x122ac
leaq 0xec75(%rip), %rcx      # 0x131fe
movl $0x6ab, %edx            # imm = 0x6AB
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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
addq $-0x10, %rsi
testq %rax, %rax
cmoveq %rax, %rsi
movq 0x328(%rdi), %rcx
subq %rdx, %rcx
jb 0x4672
movq %rdi, %r14
movq %rcx, 0x328(%rdi)
testq %rdx, %rdx
je 0x45db
testq %rax, %rax
je 0x4653
cmpq %rdx, (%rsi)
jne 0x4653
addq $0x10, %rdx
jmp 0x45e6
testq %rax, %rax
jne 0x4696
xorl %edx, %edx
leaq 0x10(%rbx), %rcx
testq %rbx, %rbx
cmoveq %rbx, %rcx
movq 0x4b0(%r14), %rax
testq %rax, %rax
je 0x4608
movq 0x4a0(%r14), %rdi
callq *%rax
jmp 0x4613
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x1170
testq %rbx, %rbx
je 0x4644
testq %rax, %rax
je 0x4691
movq %rbx, (%rax)
addq 0x328(%r14), %rbx
movq %rbx, 0x328(%r14)
cmpq 0x330(%r14), %rbx
jbe 0x463e
movq %rbx, 0x330(%r14)
addq $0x10, %rax
jmp 0x464b
testq %rax, %rax
jne 0x46b5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xec03(%rip), %rdi      # 0x1325d
leaq 0xdc4b(%rip), %rsi      # 0x122ac
leaq 0xebca(%rip), %rcx      # 0x13232
movl $0x3f1, %edx            # imm = 0x3F1
callq 0x10b0
leaq 0xeb9b(%rip), %rdi      # 0x13214
leaq 0xdc2c(%rip), %rsi      # 0x122ac
leaq 0xebab(%rip), %rcx      # 0x13232
movl $0x3ec, %edx            # imm = 0x3EC
callq 0x10b0
callq 0x12d8
leaq 0xebec(%rip), %rdi      # 0x13289
leaq 0xdc08(%rip), %rsi      # 0x122ac
leaq 0xeb87(%rip), %rcx      # 0x13232
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x10b0
leaq 0xebcd(%rip), %rdi      # 0x13289
leaq 0xdbe9(%rip), %rsi      # 0x122ac
leaq 0xeb68(%rip), %rcx      # 0x13232
movl $0x401, %edx            # imm = 0x401
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
cmpl $0x0, 0x238(%r14)
jne 0x6744
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 0xbc4a(%rip), %rdi      # 0x12395
leaq 0xbb5a(%rip), %rsi      # 0x122ac
leaq 0xbc4c(%rip), %rcx      # 0x123a5
movl $0x1a75, %edx           # imm = 0x1A75
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x107a7
testq %rbx, %rbx
je 0x67ef
movq %rbx, %rdi
callq 0x1090
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0x9bf6
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1070
leaq 0xd865(%rip), %rdi      # 0x1405b
leaq 0xbaaf(%rip), %rsi      # 0x122ac
leaq 0xd85b(%rip), %rcx      # 0x1405f
movl $0x47e, %edx            # imm = 0x47E
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7565
movl %esi, %r14d
movq %rdi, %rbx
cmovsl %esi, %ebp
movl 0x2c(%rdi), %eax
cmpl %eax, %ebp
jle 0x7503
movq 0x118(%rbx), %rcx
cmpq 0x120(%rbx), %rcx
jne 0x756a
cmpl %eax, %ebp
jg 0x753f
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 0x755b
testb $0x40, %cl
je 0x7560
callq 0x1380
movq %rbx, %rdi
callq 0x40ae
cmpl 0x2c(%rbx), %ebp
jg 0x7537
leal (%r14,%r14), %ecx
movl $0x1, %eax
subl %ecx, %eax
testl %r14d, %r14d
cmovnsl %ecx, %eax
addq 0x38(%rbx), %rax
jmp 0x7560
testb $0x40, %cl
je 0x756f
popq %rbx
popq %r14
popq %rbp
retq
callq 0x13b8
callq 0x1364
callq 0x139c
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x7623
movq %rsi, %rbx
movq %rdi, %r14
movq 0x260(%rdi), %r15
movq 0x268(%rdi), %rdx
cmpq %rdx, %r15
jne 0x7604
movq 0x258(%r14), %rsi
cmpq %rdx, %rsi
ja 0x7642
subq %rsi, %r15
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %r12      # imm = 0x7FFFFFFF8
andq %r12, %rdx
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,8), %rcx
movq %r14, %rdi
callq 0x4593
movq %rax, 0x258(%r14)
andq %r12, %r15
addq %rax, %r15
movq %r15, 0x260(%r14)
leaq (%rax,%r13,8), %rax
movq %rax, 0x268(%r14)
movq 0x260(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x260(%r14)
movq %rbx, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xc570(%rip), %rdi      # 0x13b9a
leaq 0xac7b(%rip), %rsi      # 0x122ac
leaq 0xcb9b(%rip), %rcx      # 0x141d3
movl $0x715, %edx            # imm = 0x715
callq 0x10b0
leaq 0xcba4(%rip), %rdi      # 0x141ed
leaq 0xac5c(%rip), %rsi      # 0x122ac
leaq 0xcb7c(%rip), %rcx      # 0x141d3
movl $0x718, %edx            # imm = 0x718
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x76c0
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 0x76f9
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x7707
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %esi
testl %esi, %esi
je 0x7717
movq %rbx, %rdi
callq 0x6d5b
jmp 0x76e0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d5b
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7751
addq $0x4, %r14
movq %rbx, %rdi
callq 0x6d5b
movl (%r14), %esi
addq $0x4, %r14
testl %esi, %esi
jne 0x773e
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6d5b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7799
movq %rbx, %rdi
callq 0x3de6
jmp 0x77a1
movq %rbx, %rdi
callq 0x4264
cmpl $0x1, (%rbx)
je 0x77ae
movq %rbx, %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x77ee
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74d1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x782f
cmpl $0x0, 0x35c(%rbx)
je 0x77e7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x41bd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x77ff
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %r14
cmpq 0x120(%rbx), %r14
je 0x7827
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x782f
addq $0x8, %r14
jmp 0x780d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x100(%rdi), %r15
movq 0x110(%rdi), %rdx
cmpq %rdx, %r15
jne 0x78ca
movq 0xf8(%r14), %rsi
cmpq %rsi, 0x108(%r14)
jne 0x78e9
cmpq %rdx, %rsi
ja 0x7908
subq %rsi, %r15
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %r12      # imm = 0x7FFFFFFF8
andq %r12, %rdx
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,8), %rcx
movq %r14, %rdi
callq 0x4593
movq %rax, 0xf8(%r14)
andq %r12, %r15
addq %rax, %r15
movq %r15, 0x100(%r14)
leaq (%rax,%r13,8), %rcx
movq %rcx, 0x110(%r14)
movq %rax, 0x108(%r14)
movq 0x100(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x100(%r14)
movq %rbx, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xc985(%rip), %rdi      # 0x14275
leaq 0xa9b5(%rip), %rsi      # 0x122ac
leaq 0xc98e(%rip), %rcx      # 0x1428c
movl $0x1b08, %edx           # imm = 0x1B08
callq 0x10b0
leaq 0xc996(%rip), %rdi      # 0x142a5
leaq 0xa996(%rip), %rsi      # 0x122ac
leaq 0xc96f(%rip), %rcx      # 0x1428c
movl $0x1b09, %edx           # imm = 0x1B09
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8b02
jne 0x8a90
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl %eax, 0x388(%rdi)
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
leaq 0xb851(%rip), %r14      # 0x142f9
movq %r14, %rsi
xorl %eax, %eax
callq 0x1130
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq 0x360(%rbx), %rcx
leaq 0xbb7d(%rip), %r15      # 0x14645
movq %r15, %rsi
xorl %eax, %eax
callq 0x1130
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq 0x368(%rbx), %rcx
movq %r15, %rsi
xorl %eax, %eax
callq 0x1130
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1130
leaq 0xbb0a(%rip), %rdi      # 0x14613
leaq 0x979c(%rip), %rsi      # 0x122ac
leaq 0xbb1b(%rip), %rcx      # 0x14632
movl $0xc55, %edx            # imm = 0xC55
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
movq %r14, %rdi
callq 0x8b95
testl %ebx, %ebx
je 0x8b8b
cmpq $0x0, 0x248(%r14)
jne 0x8b90
movl %ebx, %ecx
negl %ecx
cmovsl %ebx, %ecx
xorl %eax, %eax
cmpl 0x2c(%r14), %ecx
jg 0x8b83
movq 0x38(%r14), %rax
leal (%rbx,%rbx), %ecx
movl $0x1, %edx
movl $0x1, %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
callq 0x140c
callq 0x13f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
testl %ebx, %ebx
je 0x8bd8
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
cmpl 0x2c(%r14), %eax
jle 0x8bca
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 0x8bdd
callq 0x1444
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c2e
leal (%rsi,%rsi), %eax
movl $0x1, %edx
subl %eax, %edx
testl %esi, %esi
cmovnsl %eax, %edx
movl $0x1, %ecx
movq 0x40(%rdi), %rsi
movl %edx, %r8d
shrl %r8d
shlq $0x4, %r8
xorl %eax, %eax
cmpl $0x0, 0x4(%rsi,%r8)
je 0x8c16
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 0xba4b(%rip), %rdi      # 0x14681
leaq 0x966f(%rip), %rsi      # 0x122ac
leaq 0xba60(%rip), %rcx      # 0x146a4
movl $0x1b29, %edx           # imm = 0x1B29
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
movq %rbx, %rdi
callq 0x8ce0
testl %ebp, %ebp
jne 0x8c92
movq 0x10372(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
leaq 0x98b4(%rip), %rdi      # 0x12544
jmp 0x8cd6
cmpq $0x0, 0x248(%rbx)
jne 0x8cc5
cmpq $0x0, 0x1b8(%rbx)
jne 0x8cc5
leaq 0x98d0(%rip), %rdi      # 0x1257d
leaq 0x95f8(%rip), %rsi      # 0x122ac
leaq 0x98e5(%rip), %rcx      # 0x125a0
movl $0x1c31, %edx           # imm = 0x1C31
callq 0x10b0
movq 0x1032c(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
leaq 0x98e9(%rip), %rdi      # 0x125bf
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_coreclause
int
picosat_coreclause (PS * ps, int ocls)
{
  check_ready (ps);
  check_unsat_state (ps);

  ABORTIF (ocls < 0, "API usage: negative original clause index");
  ABORTIF (ocls >= (int)ps->oadded, "API usage: original clause index exceeded");

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

#ifdef TRACE
  {
    Cls ** clsptr, * c;
    int res  = 0;

    ABORTIF (!ps->trace, "tracing disabled");
    if (ps->measurealltimeinlib)
      enter (ps);
    core (ps);
    clsptr = ps->oclauses + ocls;
    assert (clsptr < ps->ohead);
    c = *clsptr;
    if (c) 
      res = c->core;
    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 0x4264
movq %rbx, %rdi
callq 0x8ce0
testl %ebp, %ebp
jns 0x8d18
movq 0x102ec(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
leaq 0x98d6(%rip), %rdi      # 0x125ec
jmp 0x8d77
cmpl %ebp, 0x438(%rbx)
jle 0x8d53
cmpq $0x0, 0x248(%rbx)
jne 0x8d66
cmpq $0x0, 0x1b8(%rbx)
jne 0x8d66
leaq 0x9842(%rip), %rdi      # 0x1257d
leaq 0x956a(%rip), %rsi      # 0x122ac
leaq 0x9913(%rip), %rcx      # 0x1265c
movl $0x1c50, %edx           # imm = 0x1C50
callq 0x10b0
movq 0x1029e(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
leaq 0x98c0(%rip), %rdi      # 0x12624
jmp 0x8d77
movq 0x1028b(%rip), %rax     # 0x18ff8
movq (%rax), %rsi
leaq 0x9848(%rip), %rdi      # 0x125bf
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_failed_assumption
int
picosat_failed_assumption (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  ABORTIF (!int_lit, "API usage: zero literal as assumption");
  check_ready (ps);
  check_unsat_state (ps);
  if (ps->mtcls)
    return 0;
  assert (ps->failed_assumption);
  if (abs (int_lit) > (int) ps->max_var)
    return 0;
  if (!ps->extracted_all_failed_assumptions)
    extract_all_failed_assumptions (ps);
  lit = import_lit (ps, int_lit, 1);
  v = LIT2VAR (lit);
  return v->failed;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x8df9
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4264
movq %rbx, %rdi
callq 0x8ce0
xorl %eax, %eax
cmpq $0x0, 0x248(%rbx)
jne 0x8df2
cmpq $0x0, 0x1b8(%rbx)
je 0x8dfe
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
cmpl 0x2c(%rbx), %ecx
jg 0x8df2
cmpl $0x0, 0x1c0(%rbx)
jne 0x8dcd
movq %rbx, %rdi
callq 0x8e1d
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74d1
movq 0x40(%rbx), %rcx
subl 0x38(%rbx), %eax
shrl %eax
shlq $0x4, %rax
movl (%rcx,%rax), %eax
shrl $0x5, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x147c
leaq 0x9785(%rip), %rdi      # 0x1258a
leaq 0x94a0(%rip), %rsi      # 0x122ac
leaq 0x989f(%rip), %rcx      # 0x126b2
movl $0x1c75, %edx           # imm = 0x1C75
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_failed_context
int
picosat_failed_context (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  ABORTIF (!int_lit, "API usage: zero literal as context");
  ABORTIF (abs (int_lit) > (int) ps->max_var, "API usage: invalid context");
  check_ready (ps);
  check_unsat_state (ps);
  assert (ps->failed_assumption);
  if (!ps->extracted_all_failed_assumptions)
    extract_all_failed_assumptions (ps);
  lit = import_lit (ps, int_lit, 0);
  v = LIT2VAR (lit);
  return v->failed;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x90dd
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
cmpl 0x2c(%rdi), %eax
jg 0x90e2
movq %rbx, %rdi
callq 0x4264
movq %rbx, %rdi
callq 0x8ce0
cmpq $0x0, 0x1b8(%rbx)
je 0x90e7
cmpl $0x0, 0x1c0(%rbx)
jne 0x90b4
movq %rbx, %rdi
callq 0x8e1d
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x74d1
movq 0x40(%rbx), %rcx
subl 0x38(%rbx), %eax
shrl %eax
shlq $0x4, %rax
movl (%rcx,%rax), %eax
shrl $0x5, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x14b4
callq 0x1498
leaq 0x949c(%rip), %rdi      # 0x1258a
leaq 0x91b7(%rip), %rsi      # 0x122ac
leaq 0x9639(%rip), %rcx      # 0x12735
movl $0x1c88, %edx           # imm = 0x1C88
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: delete
static void
delete (PS * ps, void *void_ptr, size_t size)
{
  size_t bytes;
  Blk *b;

  if (!void_ptr)
    {
      assert (!size);
      return;
    }

  assert (size);
  b = PTR2BLK (void_ptr);

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

  assert (b->header.size == size);

  bytes = size + SIZE_OF_BLK;
  if (ps->edelete)
    ps->edelete (ps->emgr, b, bytes);
  else
    free (b);
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x9b6a
testq %rdx, %rdx
je 0x9b7a
movq 0x328(%rdi), %rax
subq %rdx, %rax
jb 0x9b99
addq $-0x10, %rsi
movq %rax, 0x328(%rdi)
cmpq %rdx, (%rsi)
jne 0x9bb8
movq 0x4b8(%rdi), %rax
testq %rax, %rax
je 0x9b71
addq $0x10, %rdx
movq 0x4a0(%rdi), %rdi
popq %rcx
jmpq *%rax
testq %rdx, %rdx
jne 0x9bd7
popq %rax
retq
movq %rsi, %rdi
popq %rax
jmp 0x1050
leaq 0xabd4(%rip), %rdi      # 0x14755
leaq 0x8724(%rip), %rsi      # 0x122ac
leaq 0xab92(%rip), %rcx      # 0x14721
movl $0x3d5, %edx            # imm = 0x3D5
callq 0x10b0
leaq 0x9678(%rip), %rdi      # 0x13218
leaq 0x8705(%rip), %rsi      # 0x122ac
leaq 0xab73(%rip), %rcx      # 0x14721
movl $0x3d8, %edx            # imm = 0x3D8
callq 0x10b0
leaq 0xab84(%rip), %rdi      # 0x14743
leaq 0x86e6(%rip), %rsi      # 0x122ac
leaq 0xab54(%rip), %rcx      # 0x14721
movl $0x3db, %edx            # imm = 0x3DB
callq 0x10b0
leaq 0xab3d(%rip), %rdi      # 0x1471b
leaq 0x86c7(%rip), %rsi      # 0x122ac
leaq 0xab35(%rip), %rcx      # 0x14721
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: new
static void *
new (PS * ps, size_t size)
{
  size_t bytes;
  Blk *b;
  
  if (!size)
    return 0;

  bytes = size + SIZE_OF_BLK;

  if (ps->enew)
    b = ps->enew (ps->emgr, bytes);
  else
    b = malloc (bytes);

  ABORTIF (!b, "out of memory in 'new'");
#ifndef NDEBUG
  b->header.size = size;
#endif
  ps->current_bytes += size;
  if (ps->current_bytes > ps->max_bytes)
    ps->max_bytes = ps->current_bytes;
  return b->data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x9c20
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rsi
movq 0x4a8(%rdi), %rax
testq %rax, %rax
je 0x9c24
movq 0x4a0(%r14), %rdi
callq *%rax
jmp 0x9c2c
xorl %eax, %eax
jmp 0x9c56
movq %rsi, %rdi
callq 0x1150
testq %rax, %rax
je 0x9c5e
movq %rbx, (%rax)
addq 0x328(%r14), %rbx
movq %rbx, 0x328(%r14)
cmpq 0x330(%r14), %rbx
jbe 0x9c52
movq %rbx, 0x330(%r14)
addq $0x10, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x14d0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_maximal_satisfiable_subset_of_assumptions
const int *
picosat_maximal_satisfiable_subset_of_assumptions (PS * ps)
{
  const int * res;
  int i, *a, size;

  ABORTIF (ps->mtcls,
           "API usage: CNF inconsistent (use 'picosat_inconsistent')");

  enter (ps);

  size = ps->alshead - ps->als;
  NEWN (a, size);

  for (i = 0; i < size; i++)
    a[i] = LIT2INT (ps->als[i]);

  res = mss (ps, a, size);
  reassume (ps, a, size);

  DELETEN (a, size);

  leave (ps);

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x248(%rdi)
jne 0x9d4e
movq %rdi, %rbx
callq 0x3de6
movq 0x100(%rbx), %r14
subq 0xf8(%rbx), %r14
movq %r14, %r15
shrq $0x3, %r15
shlq $0x1d, %r14
sarq $0x1e, %r14
andq $-0x4, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9bf6
movq %rax, %r12
testl %r15d, %r15d
jle 0x9cf3
movq 0x38(%rbx), %rax
movq 0xf8(%rbx), %rcx
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movl (%rcx,%rsi,8), %edi
subl %eax, %edi
movl %edi, %r8d
shrl %r8d
movl %r8d, %r9d
negl %r9d
testb $0x1, %dil
cmovel %r8d, %r9d
movl %r9d, (%r12,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x9cce
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x9d53
movq %rax, %r13
testl %r15d, %r15d
jle 0x9d26
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movl (%r12,%rbp,4), %esi
movq %rbx, %rdi
callq 0x777e
incq %rbp
cmpq %rbp, %r15
jne 0x9d12
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x9b29
movq %rbx, %rdi
callq 0x41bd
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x14ec
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_next_maximal_satisfiable_subset_of_assumptions
const int *
picosat_next_maximal_satisfiable_subset_of_assumptions (PS * ps)
{
  const int * res;
  enter (ps);
  res = next_mss (ps, 0);
  leave (ps);
  return  res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3de6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9f65
movq %rax, %r14
movq %rbx, %rdi
callq 0x41bd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq