LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x78bf
movq 0xf8(%r14), %rsi
movq 0x108(%r14), %rcx
cmpq %rsi, %rcx
jne 0x78d9
cmpq %rax, %rcx
ja 0x78f8
subq %rcx, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
movl $0x1, %r12d
cmovneq %rax, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x473a
movq %rax, 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 0xd931(%rip), %rdi      # 0x15211
leaq 0xb995(%rip), %rsi      # 0x1327c
leaq 0xd93a(%rip), %rcx      # 0x15228
movl $0x1b08, %edx           # imm = 0x1B08
callq 0x10b0
leaq 0xd942(%rip), %rdi      # 0x15241
leaq 0xb976(%rip), %rsi      # 0x1327c
leaq 0xd91b(%rip), %rcx      # 0x15228
movl $0x1b09, %edx           # imm = 0x1B09
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8bf6
jne 0x8b84
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl %eax, 0x388(%rdi)
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
leaq 0xc6f9(%rip), %r14      # 0x15295
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movq 0x360(%rbx), %rcx
leaq 0xca25(%rip), %r15      # 0x155e1
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 0xc9b2(%rip), %rdi      # 0x155af
leaq 0xa678(%rip), %rsi      # 0x1327c
leaq 0xc9c3(%rip), %rcx      # 0x155ce
movl $0xc55, %edx            # imm = 0xC55
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x441c
movl (%r14), %edi
callq 0x8c89
testl %ebx, %ebx
je 0x8c7f
cmpq $0x0, 0x248(%r14)
jne 0x8c84
movl %ebx, %ecx
negl %ecx
cmovsl %ebx, %ecx
xorl %eax, %eax
cmpl 0x2c(%r14), %ecx
jg 0x8c77
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 0x141c
callq 0x1400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x441c
testl %ebx, %ebx
je 0x8ccc
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
cmpl 0x2c(%r14), %eax
jle 0x8cbe
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 0x8cd1
callq 0x1454
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d22
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 0x8d0a
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 0xc8f3(%rip), %rdi      # 0x1561d
leaq 0xa54b(%rip), %rsi      # 0x1327c
leaq 0xc908(%rip), %rcx      # 0x15640
movl $0x1b29, %edx           # imm = 0x1B29
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x441c
movl (%rbx), %edi
callq 0x8dd3
testl %ebp, %ebp
jne 0x8d85
movq 0x1127f(%rip), %rax     # 0x19ff8
movq (%rax), %rsi
leaq 0xa791(%rip), %rdi      # 0x13514
jmp 0x8dc9
cmpq $0x0, 0x248(%rbx)
jne 0x8db8
cmpq $0x0, 0x1b8(%rbx)
jne 0x8db8
leaq 0xa7ad(%rip), %rdi      # 0x1354d
leaq 0xa4d5(%rip), %rsi      # 0x1327c
leaq 0xa7c2(%rip), %rcx      # 0x13570
movl $0x1c31, %edx           # imm = 0x1C31
callq 0x10b0
movq 0x11239(%rip), %rax     # 0x19ff8
movq (%rax), %rsi
leaq 0xa7c6(%rip), %rdi      # 0x1358f
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/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 0x441c
movl (%rbx), %edi
callq 0x8dd3
testl %ebp, %ebp
jns 0x8e0a
movq 0x111fa(%rip), %rax     # 0x19ff8
movq (%rax), %rsi
leaq 0xa7b4(%rip), %rdi      # 0x135bc
jmp 0x8e69
cmpl %ebp, 0x438(%rbx)
jle 0x8e45
cmpq $0x0, 0x248(%rbx)
jne 0x8e58
cmpq $0x0, 0x1b8(%rbx)
jne 0x8e58
leaq 0xa720(%rip), %rdi      # 0x1354d
leaq 0xa448(%rip), %rsi      # 0x1327c
leaq 0xa7f1(%rip), %rcx      # 0x1362c
movl $0x1c50, %edx           # imm = 0x1C50
callq 0x10b0
movq 0x111ac(%rip), %rax     # 0x19ff8
movq (%rax), %rsi
leaq 0xa79e(%rip), %rdi      # 0x135f4
jmp 0x8e69
movq 0x11199(%rip), %rax     # 0x19ff8
movq (%rax), %rsi
leaq 0xa726(%rip), %rdi      # 0x1358f
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8eea
movl %esi, %ebp
movq %rdi, %rbx
callq 0x441c
movl (%rbx), %edi
callq 0x8dd3
xorl %eax, %eax
cmpq $0x0, 0x248(%rbx)
jne 0x8ee3
cmpq $0x0, 0x1b8(%rbx)
je 0x8eef
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
cmpl 0x2c(%rbx), %ecx
jg 0x8ee3
cmpl $0x0, 0x1c0(%rbx)
jne 0x8ebe
movq %rbx, %rdi
callq 0x8f0e
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74e8
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 0x148c
leaq 0xa664(%rip), %rdi      # 0x1355a
leaq 0xa37f(%rip), %rsi      # 0x1327c
leaq 0xa77e(%rip), %rcx      # 0x13682
movl $0x1c75, %edx           # imm = 0x1C75
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x91cc
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
cmpl 0x2c(%rdi), %eax
jg 0x91d1
movq %rbx, %rdi
callq 0x441c
movl (%rbx), %edi
callq 0x8dd3
cmpq $0x0, 0x1b8(%rbx)
je 0x91d6
cmpl $0x0, 0x1c0(%rbx)
jne 0x91a3
movq %rbx, %rdi
callq 0x8f0e
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x74e8
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 0x14c4
callq 0x14a8
leaq 0xa37d(%rip), %rdi      # 0x1355a
leaq 0xa098(%rip), %rsi      # 0x1327c
leaq 0xa51a(%rip), %rcx      # 0x13705
movl $0x1c88, %edx           # imm = 0x1C88
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_failed_assumptions
const int *
picosat_failed_assumptions (PS * ps)
{
  Lit ** p, * lit;
  Var * v;
  int ilit;

  ps->falshead = ps->fals;
  check_ready (ps);
  check_unsat_state (ps);
  if (!ps->mtcls) 
    {
      assert (ps->failed_assumption);
      if (!ps->extracted_all_failed_assumptions)
	extract_all_failed_assumptions (ps);

      for (p = ps->als; p < ps->alshead; p++)
	{
	  lit = *p;
	  v = LIT2VAR (*p);
	  if (!v->failed)
	    continue;
	  ilit = LIT2INT (lit);
	  if (ps->falshead == ps->eofals)
	    ENLARGE (ps->fals, ps->falshead, ps->eofals);
	  *ps->falshead++ = ilit;
	}
    }
  if (ps->falshead == ps->eofals)
    ENLARGE (ps->fals, ps->falshead, ps->eofals);
  *ps->falshead++ = 0;
  return ps->fals;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x160(%rdi), %rax
movq %rax, 0x168(%rdi)
callq 0x441c
movl (%rbx), %edi
callq 0x8dd3
cmpq $0x0, 0x248(%rbx)
jne 0x9317
cmpq $0x0, 0x1b8(%rbx)
je 0x93c6
cmpl $0x0, 0x1c0(%rbx)
jne 0x924a
movq %rbx, %rdi
callq 0x8f0e
movq 0xf8(%rbx), %r15
movq 0x100(%rbx), %rax
cmpq %rax, %r15
jae 0x9317
movl $0x1, %r13d
movl (%r15), %ecx
movq 0x40(%rbx), %rsi
subl 0x38(%rbx), %ecx
movl %ecx, %edx
shrl %edx
movq %rdx, %rdi
shlq $0x4, %rdi
testb $0x20, (%rsi,%rdi)
je 0x930a
movl %edx, %ebp
negl %ebp
testb $0x1, %cl
cmovel %edx, %ebp
movq 0x168(%rbx), %r14
cmpq 0x170(%rbx), %r14
jne 0x92fc
movq 0x160(%rbx), %rsi
cmpq %r14, %rsi
ja 0x93a7
subq %rsi, %r14
movq %r14, %rax
shrq %rax
movabsq $0x3fffffffc, %rcx      # imm = 0x3FFFFFFFC
andq %rcx, %r14
movl %eax, %r12d
cmoveq %r13, %r12
leaq (,%r12,4), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x473a
movq %rax, 0x160(%rbx)
addq %rax, %r14
leaq (%rax,%r12,4), %rax
movq %rax, 0x170(%rbx)
movq 0x100(%rbx), %rax
leaq 0x4(%r14), %rcx
movq %rcx, 0x168(%rbx)
movl %ebp, (%r14)
addq $0x8, %r15
cmpq %rax, %r15
jb 0x9267
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rcx
cmpq 0x170(%rbx), %rcx
jne 0x9387
cmpq %rcx, %rax
ja 0x93e5
subq %rax, %rcx
movq %rcx, %rdx
shrq %rdx
movl %edx, %edx
movabsq $0x3fffffffc, %r14      # imm = 0x3FFFFFFFC
andq %rcx, %r14
movl $0x1, %r15d
cmovneq %rdx, %r15
leaq (,%r15,4), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x473a
movq %rax, 0x160(%rbx)
addq %rax, %r14
leaq (%rax,%r15,4), %rcx
movq %rcx, 0x170(%rbx)
movq %r14, %rcx
leaq 0x4(%rcx), %rdx
movq %rdx, 0x168(%rbx)
movl $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa3a9(%rip), %rdi      # 0x13757
leaq 0x9ec7(%rip), %rsi      # 0x1327c
leaq 0xa36f(%rip), %rcx      # 0x1372b
movl $0x1ca8, %edx           # imm = 0x1CA8
callq 0x10b0
leaq 0xa18d(%rip), %rdi      # 0x1355a
leaq 0x9ea8(%rip), %rsi      # 0x1327c
leaq 0xa350(%rip), %rcx      # 0x1372b
movl $0x1c9c, %edx           # imm = 0x1C9C
callq 0x10b0
leaq 0xa36b(%rip), %rdi      # 0x13757
leaq 0x9e89(%rip), %rsi      # 0x1327c
leaq 0xa331(%rip), %rcx      # 0x1372b
movl $0x1cad, %edx           # imm = 0x1CAD
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9c72
testq %rdx, %rdx
je 0x9c82
movq 0x328(%rdi), %rax
subq %rdx, %rax
jb 0x9ca1
addq $-0x10, %rsi
movq %rax, 0x328(%rdi)
cmpq %rdx, (%rsi)
jne 0x9cc0
movq 0x4b8(%rdi), %rax
testq %rax, %rax
je 0x9c79
addq $0x10, %rdx
movq 0x4a0(%rdi), %rdi
popq %rcx
jmpq *%rax
testq %rdx, %rdx
jne 0x9cdf
popq %rax
retq
movq %rsi, %rdi
popq %rax
jmp 0x1050
leaq 0xba68(%rip), %rdi      # 0x156f1
leaq 0x95ec(%rip), %rsi      # 0x1327c
leaq 0xba26(%rip), %rcx      # 0x156bd
movl $0x3d5, %edx            # imm = 0x3D5
callq 0x10b0
leaq 0xa532(%rip), %rdi      # 0x141da
leaq 0x95cd(%rip), %rsi      # 0x1327c
leaq 0xba07(%rip), %rcx      # 0x156bd
movl $0x3d8, %edx            # imm = 0x3D8
callq 0x10b0
leaq 0xba18(%rip), %rdi      # 0x156df
leaq 0x95ae(%rip), %rsi      # 0x1327c
leaq 0xb9e8(%rip), %rcx      # 0x156bd
movl $0x3db, %edx            # imm = 0x3DB
callq 0x10b0
leaq 0xb9d1(%rip), %rdi      # 0x156b7
leaq 0x958f(%rip), %rsi      # 0x1327c
leaq 0xb9c9(%rip), %rcx      # 0x156bd
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9d28
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rsi
movq 0x4a8(%rdi), %rax
testq %rax, %rax
je 0x9d2c
movq 0x4a0(%r14), %rdi
callq *%rax
jmp 0x9d34
xorl %eax, %eax
jmp 0x9d5e
movq %rsi, %rdi
callq 0x1160
testq %rax, %rax
je 0x9d66
movq %rbx, (%rax)
addq 0x328(%r14), %rbx
movq %rbx, 0x328(%r14)
cmpq 0x330(%r14), %rbx
jbe 0x9d5a
movq %rbx, 0x330(%r14)
addq $0x10, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x14e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9e69
movq %rdi, %rbx
callq 0x3eb1
movq 0x100(%rbx), %r14
subq 0xf8(%rbx), %r14
movq %r14, %r12
shrq $0x3, %r12
shlq $0x1d, %r14
sarq $0x1e, %r14
andq $-0x4, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9cfe
movq %rax, %r15
testl %r12d, %r12d
jle 0x9e30
movq 0x38(%rbx), %rax
movq 0xf8(%rbx), %rcx
movl %r12d, %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, (%r15,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x9dd6
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x9e6e
movq %rax, %r13
testl %r12d, %r12d
jle 0x9e41
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
movl (%r15,%rbp,4), %esi
movq %rbx, %rdi
callq 0x777f
incq %rbp
cmpq %rbp, %r12
jne 0x9e1a
jmp 0x9e41
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x9e6e
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9c31
movq %rbx, %rdi
callq 0x4375
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x14fc
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3eb1
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa069
movq %rax, %r14
movq %rbx, %rdi
callq 0x4375
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_next_minimal_correcting_subset_of_assumptions
const int *
picosat_next_minimal_correcting_subset_of_assumptions (PS * ps)
{
  const int * res, * tmp;
  enter (ps);
  tmp = next_mss (ps, 1);
  res = tmp ? ps->mcsass : 0;
  leave (ps);
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3eb1
movq %rbx, %rdi
movl $0x1, %esi
callq 0xa069
testq %rax, %rax
je 0xa3c3
movq 0x198(%rbx), %r14
jmp 0xa3c6
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x4375
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_usedlit
int
picosat_usedlit (PS * ps, int int_lit)
{
  int res;
  check_ready (ps);
  check_sat_or_unsat_or_unknown_state (ps);
  ABORTIF (!int_lit, "API usage: zero literal can not be used");
  int_lit = abs (int_lit);
  res = (int_lit <= (int) ps->max_var) ? ps->vars[int_lit].used : 0;
  return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x441c
movl (%rbx), %edi
callq 0xa742
testl %ebp, %ebp
je 0xa73d
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
xorl %eax, %eax
cmpl 0x2c(%rbx), %ecx
jg 0xa736
movq 0x40(%rbx), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
movl (%rax,%rcx), %eax
shrl $0x4, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1518
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_time_stamp
double
picosat_time_stamp (void)
{
  double res = -1;
#ifndef NGETRUSAGE
  struct rusage u;
  res = 0;
  if (!getrusage (RUSAGE_SELF, &u))
    {
      res += u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
      res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
    }
#endif
  return res;
}

// Assembly:
subq $0x98, %rsp
leaq 0x8(%rsp), %rsi
xorl %edi, %edi
callq 0x11b0
xorpd %xmm0, %xmm0
testl %eax, %eax
jne 0xac9a
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rsp), %xmm0
cvtsi2sdq 0x10(%rsp), %xmm1
movsd 0x84ab(%rip), %xmm2     # 0x13118
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
cvtsi2sdq 0x18(%rsp), %xmm4
xorps %xmm0, %xmm0
cvtsi2sdq 0x20(%rsp), %xmm0
addsd %xmm1, %xmm3
mulsd %xmm2, %xmm0
addsd %xmm4, %xmm0
addsd %xmm3, %xmm0
addq $0x98, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_message
void
picosat_message (PS * ps, int vlevel, const char * fmt, ...)
{
  va_list ap;

  if (vlevel > ps->verbosity)
    return;

  fputs (ps->prefix, ps->out);
  va_start (ap, fmt);
  vfprintf (ps->out, fmt, ap);
  va_end (ap);
  fputc ('\n', ps->out);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xafc2
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)
cmpl %esi, 0x20(%rdi)
jl 0xb019
movq %rdx, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdi
callq 0x10c0
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rdx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x11c0
movq 0x10(%rbx), %rsi
movl $0xa, %edi
callq 0x10f0
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_changed
int
picosat_changed (PS * ps)
{
  int res;

  check_ready (ps);
  check_sat_state (ps);

  res = (ps->min_flipped <= ps->saved_max_var);
  assert (!res || ps->saved_flips != ps->flips);

  return res;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x441c
movl (%rbx), %edi
callq 0x8c89
movl 0x498(%rbx), %ecx
movl 0x49c(%rbx), %edx
cmpl %ecx, %edx
ja 0xb054
movq 0x490(%rbx), %rax
cmpq 0x468(%rbx), %rax
je 0xb05d
xorl %eax, %eax
cmpl %ecx, %edx
setbe %al
popq %rbx
retq
leaq 0x8c79(%rip), %rdi      # 0x13cdd
leaq 0x8211(%rip), %rsi      # 0x1327c
leaq 0x8c90(%rip), %rcx      # 0x13d02
movl $0x2047, %edx           # imm = 0x2047
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_reset_scores
void
picosat_reset_scores (PS * ps)
{
  Rnk * r;
  ps->hhead = ps->heap + 1;
  for (r = ps->rnks + 1; r <= ps->rnks + ps->max_var; r++)
    {
      CLR (r);
      hpush (ps, r);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x1c8(%rdi), %rax
addq $0x8, %rax
movq %rax, 0x1d0(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0xb227
movq %rdi, %rbx
movq 0x48(%rdi), %r14
addq $0x8, %r14
movl $0xc0000000, %ebp       # imm = 0xC0000000
movabsq $0x1fffffff8, %r12      # imm = 0x1FFFFFFF8
movq $0x0, (%r14)
testl $0x3fffffff, 0x4(%r14)  # imm = 0x3FFFFFFF
jne 0xb236
movq 0x1c8(%rbx), %rax
movq 0x1d0(%rbx), %rcx
cmpq 0x1d8(%rbx), %rcx
jne 0xb1d0
cmpq %rcx, %rax
ja 0xb255
subq %rax, %rcx
movq %rcx, %r15
movabsq $0x7fffffff8, %rdx      # imm = 0x7FFFFFFF8
andq %rdx, %r15
shrq $0x2, %rcx
testq %r15, %r15
movl %ecx, %r13d
movl $0x1, %ecx
cmoveq %rcx, %r13
leaq (,%r13,8), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x473a
movq %rax, 0x1c8(%rbx)
addq %rax, %r15
leaq (%rax,%r13,8), %rcx
movq %rcx, 0x1d8(%rbx)
movq %r15, %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x1d0(%rbx)
subq %rax, %rcx
movq %rcx, %rax
shrq $0x3, %rax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl 0x4(%r14), %edx
andl %ebp, %edx
orl %eax, %edx
movl %edx, 0x4(%r14)
movq 0x1c8(%rbx), %rax
andq %r12, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc36
addq $0x8, %r14
movl 0x2c(%rbx), %eax
shlq $0x3, %rax
addq 0x48(%rbx), %rax
cmpq %rax, %r14
jbe 0xb147
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa5e2(%rip), %rdi      # 0x1581f
leaq 0x8038(%rip), %rsi      # 0x1327c
leaq 0xa5dc(%rip), %rcx      # 0x15827
movl $0xad3, %edx            # imm = 0xAD3
callq 0x10b0
leaq 0x8d0d(%rip), %rdi      # 0x13f69
leaq 0x8019(%rip), %rsi      # 0x1327c
leaq 0xa5bd(%rip), %rcx      # 0x15827
movl $0xad6, %edx            # imm = 0xAD6
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_remove_learned
void
picosat_remove_learned (PS * ps, unsigned percentage)
{
  enter (ps);
  reset_incremental_usage (ps);
  reduce (ps, percentage);
  leave (ps);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x3eb1
movq %r14, %rdi
callq 0x4601
movq %r14, %rdi
movl %ebx, %esi
callq 0xb2a3
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4375
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_global_default_phase
void
picosat_set_global_default_phase (PS * ps, int phase)
{
  check_ready (ps);
  ABORTIF (phase < 0, "API usage: 'picosat_set_global_default_phase' "
                      "with negative argument");
  ABORTIF (phase > 3, "API usage: 'picosat_set_global_default_phase' "
                      "with argument > 3");
  ps->defaultphase = phase;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x441c
testl %ebx, %ebx
js 0xbb72
cmpl $0x4, %ebx
jae 0xbb77
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x156c
callq 0x1550
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_default_phase_lit
void
picosat_set_default_phase_lit (PS * ps, int int_lit, int phase)
{
  unsigned newphase;
  Lit * lit;
  Var * v;

  check_ready (ps);

  lit = import_lit (ps, int_lit, 1);
  v = LIT2VAR (lit);

  if (phase)
    {
      newphase = (int_lit < 0) == (phase < 0);
      v->defphase = v->phase = newphase;
      v->usedefphase = v->assigned = 1;
    }
  else
    {
      v->usedefphase = v->assigned = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x441c
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74e8
subl 0x38(%r14), %eax
shrl %eax
shlq $0x4, %rax
addq 0x40(%r14), %rax
testl %ebx, %ebx
je 0xbbc7
movl $0xfffffe73, %edx       # imm = 0xFFFFFE73
andl (%rax), %edx
xorl %ebp, %ebx
movl $0x18c, %esi            # imm = 0x18C
movl $0x88, %ecx
cmovnsl %esi, %ecx
orl %edx, %ecx
jmp 0xbbd0
movzwl (%rax), %ecx
andl $0xff77, %ecx           # imm = 0xFF77
movw %cx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_more_important_lit
void
picosat_set_more_important_lit (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  Rnk * r;

  check_ready (ps);

  lit = import_lit (ps, int_lit, 1);
  v = LIT2VAR (lit);
  r = VAR2RNK (v);

  ABORTIF (r->lessimportant, "can not mark variable more and less important"); 

  if (r->moreimportant)
    return;

  r->moreimportant = 1;

  if (r->pos)
    hup (ps, r);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x441c
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74e8
subl 0x38(%rbx), %eax
movq 0x48(%rbx), %rdx
shrl %eax
movl 0x4(%rdx,%rax,8), %ecx
testl %ecx, %ecx
js 0xbc31
cmpl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
ja 0xbc2a
leaq (%rdx,%rax,8), %rsi
movl %ecx, %eax
orl $0x40000000, %eax       # imm = 0x40000000
movl %eax, 0x4(%rsi)
testl %ecx, %ecx
je 0xbc2a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbc36
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1588
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: hup
static void
hup (PS * ps, Rnk * v)
{
  int upos, vpos;
  Rnk *u;

#ifndef NFL
  assert (!ps->simplifying);
#endif

  vpos = v->pos;

  assert (0 < vpos);
  assert (vpos < ps->hhead - ps->heap);
  assert (ps->heap[vpos] == v);

  while (vpos > 1)
    {
      upos = vpos / 2;

      u = ps->heap[upos];

      if (cmp_rnk (u, v) > 0)
	break;

      ps->heap[vpos] = u;
      u->pos = vpos;

      vpos = upos;
    }

  ps->heap[vpos] = v;
  v->pos = vpos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x408(%rdi)
jne 0xbd0f
movq %rsi, %rbx
movl 0x4(%rsi), %r12d
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
je 0xbd2e
movq %rdi, %r14
movq 0x1c8(%rdi), %rbp
movq 0x1d0(%rdi), %rax
subq %rbp, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jle 0xbd4d
cmpq %rbx, (%rbp,%r12,8)
jne 0xbd6c
movl $0x1, %r13d
cmpl $0x1, %r12d
je 0xbcea
movl %r12d, %r13d
shrl %r13d
movq 0x1c8(%r14), %rbp
movq (%rbp,%r13,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdd5c
testl %eax, %eax
jg 0xbce7
movl %r12d, %eax
movq %r15, (%rbp,%rax,8)
movl 0x4(%r15), %eax
movl $0xc0000000, %ecx       # imm = 0xC0000000
andl %ecx, %eax
orl %r12d, %eax
movl %eax, 0x4(%r15)
cmpl $0x3, %r12d
movl %r13d, %r12d
ja 0xbc9d
movq 0x1c8(%r14), %rbp
jmp 0xbcea
movl %r12d, %r13d
movl %r13d, %eax
movq %rbx, (%rbp,%rax,8)
movl $0xc0000000, %eax       # imm = 0xC0000000
andl 0x4(%rbx), %eax
orl %r13d, %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9bf4(%rip), %rdi      # 0x1590a
leaq 0x755f(%rip), %rsi      # 0x1327c
leaq 0x9bf7(%rip), %rcx      # 0x1591b
movl $0x6d7, %edx            # imm = 0x6D7
callq 0x10b0
leaq 0x9bfc(%rip), %rdi      # 0x15931
leaq 0x7540(%rip), %rsi      # 0x1327c
leaq 0x9bd8(%rip), %rcx      # 0x1591b
movl $0x6dc, %edx            # imm = 0x6DC
callq 0x10b0
leaq 0x9be6(%rip), %rdi      # 0x1593a
leaq 0x7521(%rip), %rsi      # 0x1327c
leaq 0x9bb9(%rip), %rcx      # 0x1591b
movl $0x6dd, %edx            # imm = 0x6DD
callq 0x10b0
leaq 0x9be3(%rip), %rdi      # 0x15956
leaq 0x7502(%rip), %rsi      # 0x1327c
leaq 0x9b9a(%rip), %rcx      # 0x1591b
movl $0x6de, %edx            # imm = 0x6DE
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_less_important_lit
void
picosat_set_less_important_lit (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  Rnk * r;

  check_ready (ps);

  lit = import_lit (ps, int_lit, 1);
  v = LIT2VAR (lit);
  r = VAR2RNK (v);

  ABORTIF (r->moreimportant, "can not mark variable more and less important"); 

  if (r->lessimportant)
    return;

  r->lessimportant = 1;

  if (r->pos)
    hdown (ps, r);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x441c
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74e8
subl 0x38(%rbx), %eax
movq 0x48(%rbx), %rdx
shrl %eax
movl 0x4(%rdx,%rax,8), %ecx
btl $0x1e, %ecx
jb 0xbde2
testl %ecx, %ecx
js 0xbddb
leaq (%rdx,%rax,8), %rsi
movl %ecx, %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, 0x4(%rsi)
testl %ecx, %ecx
je 0xbddb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbde7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x15a4
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: hdown
static void
hdown (PS * ps, Rnk * r)
{
  unsigned end, rpos, cpos, opos;
  Rnk *child, *other;

  assert (r->pos > 0);
  assert (ps->heap[r->pos] == r);

  end = ps->hhead - ps->heap;
  rpos = r->pos;

  for (;;)
    {
      cpos = 2 * rpos;
      if (cpos >= end)
	break;

      opos = cpos + 1;
      child = ps->heap[cpos];

      if (cmp_rnk (r, child) < 0)
	{
	  if (opos < end)
	    {
	      other = ps->heap[opos];

	      if (cmp_rnk (child, other) < 0)
		{
		  child = other;
		  cpos = opos;
		}
	    }
	}
      else if (opos < end)
	{
	  child = ps->heap[opos];

	  if (cmp_rnk (r, child) >= 0)
	    break;

	  cpos = opos;
	}
      else
	break;

      ps->heap[rpos] = child;
      child->pos = rpos;
      rpos = cpos;
    }

  r->pos = rpos;
  ps->heap[rpos] = r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x4(%rsi), %eax
movl %eax, %r13d
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
je 0xbf3e
movq 0x1c8(%rdi), %rcx
cmpq %rsi, (%rcx,%r13,8)
jne 0xbf5d
movq 0x1d0(%rdi), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
leal (,%r13,2), %r12d
movq %rdx, 0x8(%rsp)
cmpl %edx, %r12d
jae 0xbefa
movq %rdi, (%rsp)
movl %r12d, %ebp
orl $0x1, %ebp
movq 0x1c8(%rdi), %rbx
movl %r12d, %eax
movq (%rbx,%rax,8), %r15
movq %rsi, %r14
movq %rsi, %rdi
movq %r15, %rsi
callq 0xdd5c
testl %eax, %eax
js 0xbe8b
cmpl 0x8(%rsp), %ebp
jae 0xbeff
movl %ebp, %eax
movq (%rbx,%rax,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xdd5c
movq %r14, %rsi
testl %eax, %eax
js 0xbebe
jmp 0xbf07
cmpl 0x8(%rsp), %ebp
jae 0xbeb8
movl %ebp, %eax
movq (%rbx,%rax,8), %rsi
movq %rsi, 0x10(%rsp)
movq %r15, %rdi
callq 0xdd5c
movq 0x10(%rsp), %rcx
testl %eax, %eax
js 0xbeb3
movl %r12d, %ebp
movq %r15, %rcx
movq %rcx, %r15
jmp 0xbebb
movl %r12d, %ebp
movq %r14, %rsi
movl %r13d, %eax
movq %r15, (%rbx,%rax,8)
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
movl 0x4(%r15), %eax
movl $0xc0000000, %ecx       # imm = 0xC0000000
andl %ecx, %eax
orl %r13d, %eax
movl %eax, 0x4(%r15)
leal (,%rbp,2), %r12d
movl %ebp, %r13d
cmpl 0x8(%rsp), %r12d
movq (%rsp), %rdi
jb 0xbe41
jmp 0xbf0e
movl %r13d, %ebp
jmp 0xbf1a
movl %r13d, %ebp
movq %r14, %rsi
jmp 0xbf0a
movl %r13d, %ebp
movq (%rsp), %rdi
movl 0x4(%rsi), %eax
movl %ebp, %r13d
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
andl $0xc0000000, %eax       # imm = 0xC0000000
orl %ebp, %eax
movl %eax, 0x4(%rsi)
movq 0x1c8(%rdi), %rax
movq %rsi, (%rax,%r13,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9a25(%rip), %rdi      # 0x1596a
leaq 0x7330(%rip), %rsi      # 0x1327c
leaq 0x9a22(%rip), %rcx      # 0x15975
movl $0xa81, %edx            # imm = 0xA81
callq 0x10b0
leaq 0x9a29(%rip), %rdi      # 0x1598d
leaq 0x7311(%rip), %rsi      # 0x1327c
leaq 0x9a03(%rip), %rcx      # 0x15975
movl $0xa82, %edx            # imm = 0xA82
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_simplify
void
picosat_simplify (PS * ps)
{
  enter (ps);
  reset_incremental_usage (ps);
  simplify (ps, 1);
  leave (ps);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3eb1
movq %rbx, %rdi
callq 0x4601
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4a2e
movq %rbx, %rdi
popq %rbx
jmp 0x4375
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: pderef
static int
pderef (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;

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

  v = ps->vars + abs (int_lit);
  if (!v->partial)
    return 0;

  lit = int2lit (ps, int_lit);

  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 0xc33b
movq 0x40(%rdi), %rcx
movl %eax, %edx
shlq $0x4, %rdx
xorl %eax, %eax
testb $0x20, 0x1(%rcx,%rdx)
je 0xc33a
movq 0x38(%rdi), %rax
leal (%rsi,%rsi), %ecx
movl $0x1, %edx
movl $0x1, %edi
subl %ecx, %edi
testl %esi, %esi
cmovnsl %ecx, %edi
movb (%rax,%rdi), %cl
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
negl %eax
cmpb $0x1, %cl
cmovel %edx, %eax
retq
pushq %rax
leaq 0x92da(%rip), %rdi      # 0x1561d
leaq 0x6f32(%rip), %rsi      # 0x1327c
leaq 0x96d1(%rip), %rcx      # 0x15a22
movl $0x1b40, %edx           # imm = 0x1B40
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: base2flt
static Flt
base2flt (unsigned m, int e)
{
  if (!m)
    return ZEROFLT;

  if (m < FLTMSB)
    {
      do
	{
	  if (e <= FLTMINEXPONENT)
	    return EPSFLT;

	  e--;
	  m <<= 1;

	}
      while (m < FLTMSB);
    }
  else
    {
      while (m >= FLTCARRY)
	{
	  if (e >= FLTMAXEXPONENT)
	    return INFFLT;

	  e++;
	  m >>= 1;
	}
    }

  m &= ~FLTMSB;
  return packflt (m, e);
}

// Assembly:
testl %edi, %edi
je 0xc37d
cmpl $0xffffff, %edi         # imm = 0xFFFFFF
ja 0xc380
cmpl $-0x7f, %esi
jl 0xc3a9
decl %esi
leal (%rdi,%rdi), %eax
cmpl $0x800000, %edi         # imm = 0x800000
movl %eax, %edi
jb 0xc367
jmp 0xc3b1
xorl %eax, %eax
retq
cmpl $0x2000000, %edi        # imm = 0x2000000
jb 0xc3af
cmpl $0x7f, %esi
movl $0x7f, %ecx
cmovgl %esi, %ecx
cmpl %esi, %ecx
je 0xc3bd
incl %esi
movl %edi, %eax
shrl %eax
cmpl $0x3ffffff, %edi        # imm = 0x3FFFFFF
movl %eax, %edi
ja 0xc393
jmp 0xc3b1
movl $0x1, %eax
retq
movl %edi, %eax
andl $0x7effffff, %eax       # imm = 0x7EFFFFFF
movl %eax, %edi
jmp 0xc531
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: ascii2flt
static Flt
ascii2flt (const char *str)
{
  Flt ten = base2flt (10, 0);
  Flt onetenth = base2flt (26843546, -28);
  Flt res = ZEROFLT, tmp, base;
  const char *p = str;
  char ch;

  ch = *p++;

  if (ch != '.')
    {
      if (!isdigit (ch))
	return INFFLT;	/* better abort ? */

      res = base2flt (ch - '0', 0);

      while ((ch = *p++))
	{
	  if (ch == '.')
	    break;

	  if (!isdigit (ch))
	    return INFFLT;	/* better abort? */

	  res = mulflt (res, ten);
	  tmp = base2flt (ch - '0', 0);
	  res = addflt (res, tmp);
	}
    }

  if (ch == '.')
    {
      ch = *p++;
      if (!isdigit (ch))
	return INFFLT;	/* better abort ? */

      base = onetenth;
      tmp = mulflt (base2flt (ch - '0', 0), base);
      res = addflt (res, tmp);

      while ((ch = *p++))
	{
	  if (!isdigit (ch))
	    return INFFLT;	/* better abort? */

	  base = mulflt (base, onetenth);
	  tmp = mulflt (base2flt (ch - '0', 0), base);
	  res = addflt (res, tmp);
	}
    }

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x400000, %edi         # imm = 0x400000
movl $0xffffffeb, %esi       # imm = 0xFFFFFFEB
callq 0xc531
movl %eax, %r15d
movsbl (%rbx), %r12d
callq 0x1220
movq %rax, %r14
cmpl $0x2e, %r12d
jne 0xc417
incq %rbx
xorl %r12d, %r12d
movsbq (%rbx), %rdi
movq (%r14), %rax
testb $0x8, 0x1(%rax,%rdi,2)
jne 0xc496
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xc520
movq (%r14), %rax
movslq %r12d, %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb $0x8, 0x1(%rax,%rcx,2)
je 0xc520
addl $-0x30, %r12d
movl %r12d, %edi
xorl %esi, %esi
callq 0xc35b
movl %eax, %r12d
addq $0x2, %rbx
movzbl -0x1(%rbx), %eax
testl %eax, %eax
je 0xc51d
cmpl $0x2e, %eax
je 0xc3fb
movsbl %al, %r13d
movq (%r14), %rax
movslq %r13d, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0xc520
movl %r12d, %edi
movl %r15d, %esi
callq 0xc58c
movl %eax, %r12d
addl $-0x30, %r13d
movl %r13d, %edi
xorl %esi, %esi
callq 0xc35b
movl %r12d, %edi
movl %eax, %esi
callq 0xc620
movl %eax, %r12d
incq %rbx
jmp 0xc442
addl $-0x30, %edi
xorl %esi, %esi
callq 0xc35b
movl $0x6499999a, %r15d      # imm = 0x6499999A
movl %eax, %edi
movl $0x6499999a, %esi       # imm = 0x6499999A
callq 0xc58c
movl %r12d, %edi
movl %eax, %esi
callq 0xc620
movl %eax, %ebp
movb 0x1(%rbx), %al
testb %al, %al
je 0xc520
addq $0x2, %rbx
movq (%r14), %rcx
movsbq %al, %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0xc40d
movsbl %al, %r12d
movl %r15d, %edi
movl $0x6499999a, %esi       # imm = 0x6499999A
callq 0xc58c
movl %eax, %r15d
addl $-0x30, %r12d
movl %r12d, %edi
xorl %esi, %esi
callq 0xc35b
movl %eax, %edi
movl %r15d, %esi
callq 0xc58c
movl %ebp, %edi
movl %eax, %esi
callq 0xc620
movl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0xc4c9
jmp 0xc520
movl %r12d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: packflt
static Flt
packflt (unsigned m, int e)
{
  Flt res;
  assert (m < FLTMSB);
  assert (FLTMINEXPONENT <= e);
  assert (e <= FLTMAXEXPONENT);
  res = m | ((e + 128) << 24);
  return res;
}

// Assembly:
pushq %rax
cmpl $0xffffff7f, %esi       # imm = 0xFFFFFF7F
jle 0xc54e
cmpl $0x80, %esi
jge 0xc56d
xorl $-0x80, %esi
shll $0x18, %esi
orl %edi, %esi
movl %esi, %eax
popq %rcx
retq
leaq 0x7a96(%rip), %rdi      # 0x13feb
leaq 0x6d20(%rip), %rsi      # 0x1327c
leaq 0x7a69(%rip), %rcx      # 0x13fcc
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x10b0
leaq 0x7a8b(%rip), %rdi      # 0x13fff
leaq 0x6d01(%rip), %rsi      # 0x1327c
leaq 0x7a4a(%rip), %rcx      # 0x13fcc
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: mulflt
static Flt
mulflt (Flt a, Flt b)
{
  unsigned ma, mb;
  unsigned long long accu;
  int ea, eb;

  CMPSWAPFLT (a, b);
  if (!b)
    return ZEROFLT;

  UNPACKFLT (a, ma, ea);
  UNPACKFLT (b, mb, eb);

  ea += eb;
  ea += 24;
  if (ea > FLTMAXEXPONENT)
    return INFFLT;

  if (ea < FLTMINEXPONENT)
    return EPSFLT;

  accu = ma;
  accu *= mb;
  accu >>= 24;

  if (accu >= FLTCARRY)
    {
      if (ea == FLTMAXEXPONENT)
	return INFFLT;

      ea++;
      accu >>= 1;

      if (accu >= FLTCARRY)
	return INFFLT;
    }

  assert (accu < FLTCARRY);
  assert (accu & FLTMSB);

  ma = accu;
  ma &= ~FLTMSB;

  return packflt (ma, ea);
}

// Assembly:
cmpl %esi, %edi
movl %esi, %r8d
cmovbl %edi, %r8d
testl %r8d, %r8d
je 0xc60c
cmpl %esi, %edi
cmoval %edi, %esi
movl %esi, %ecx
shrl $0x18, %ecx
movl %r8d, %edi
shrl $0x18, %edi
leal (%rcx,%rdi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x167, %edx            # imm = 0x167
ja 0xc60e
movl $0x1, %eax
cmpl $0x68, %edx
jb 0xc60e
movl $0xffffff, %eax         # imm = 0xFFFFFF
andl %eax, %esi
movl $0x1000000, %r9d        # imm = 0x1000000
orl %r9d, %esi
andl %eax, %r8d
orl %r9d, %r8d
addl %edi, %ecx
addl $0xffffff18, %ecx       # imm = 0xFFFFFF18
movl %esi, %eax
movl %r8d, %edi
imulq %rax, %rdi
movq %rdi, %rax
shrq $0x31, %rax
je 0xc60f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x7f, %ecx
je 0xc60e
addl $0xffffff19, %edx       # imm = 0xFFFFFF19
shrq $0x19, %rdi
movl %edx, %ecx
jmp 0xc613
xorl %eax, %eax
retq
shrq $0x18, %rdi
andl $0x2ffffff, %edi        # imm = 0x2FFFFFF
movl %ecx, %esi
jmp 0xc531
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: addflt
static Flt
addflt (Flt a, Flt b)
{
  unsigned ma, mb, delta;
  int ea, eb;

  CMPSWAPFLT (a, b);
  if (!b)
    return a;

  UNPACKFLT (a, ma, ea);
  UNPACKFLT (b, mb, eb);

  assert (ea >= eb);
  delta = ea - eb;
  mb >>= delta;
  if (!mb)
    return a;

  ma += mb;
  if (ma & FLTCARRY)
    {
      if (ea == FLTMAXEXPONENT)
	return INFFLT;

      ea++;
      ma >>= 1;
    }

  assert (ma < FLTCARRY);
  ma &= FLTMAXMANTISSA;

  return packflt (ma, ea);
}

// Assembly:
movl %edi, %eax
cmpl %esi, %edi
movl %esi, %edi
cmovbl %eax, %edi
cmoval %eax, %esi
testl %edi, %edi
je 0xc675
movl %esi, %edx
shrl $0x18, %edx
movl %edi, %eax
shrl $0x18, %eax
movl %edx, %ecx
subl %eax, %ecx
jb 0xc68c
andl $0xffffff, %edi         # imm = 0xFFFFFF
orl $0x1000000, %edi        # imm = 0x1000000
shrl %cl, %edi
testl %edi, %edi
je 0xc675
andl $0xffffff, %esi         # imm = 0xFFFFFF
leal -0x80(%rdx), %eax
orl $0x1000000, %esi        # imm = 0x1000000
addl %esi, %edi
cmpl $0x2000000, %edi        # imm = 0x2000000
jb 0xc67f
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x7f, %eax
jne 0xc678
movl %esi, %eax
retq
addl $-0x7f, %edx
shrl %edi
movl %edx, %eax
andl $0xffffff, %edi         # imm = 0xFFFFFF
movl %eax, %esi
jmp 0xc531
pushq %rax
leaq 0x797f(%rip), %rdi      # 0x14013
leaq 0x6be1(%rip), %rsi      # 0x1327c
leaq 0x797a(%rip), %rcx      # 0x1401c
movl $0x304, %edx            # imm = 0x304
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: undo
static void
undo (PS * ps, unsigned new_level)
{
  Lit *lit;
  Var *v;

  while (ps->thead > ps->trail)
    {
      lit = *--ps->thead;
      v = LIT2VAR (lit);
      if (v->level == new_level)
	{
	  ps->thead++;		/* fix pre decrement */
	  break;
	}

      unassign (ps, lit);
    }

  ps->LEVEL = new_level;
  ps->ttail = ps->thead;
  ps->ttail2 = ps->thead;
#ifndef NADC
  ps->ttailado = ps->thead;
#endif

#ifdef NO_BINARY_CLAUSES
  if (ps->conflict == &ps->cimpl)
    resetcimpl (ps);
#endif
#ifndef NADC
  if (ps->conflict && ps->conflict == ps->adoconflict)
    resetadoconflict (ps);
#endif
  ps->conflict = ps->mtcls;
  if (ps->LEVEL < ps->adecidelevel)
    {
      assert (ps->als < ps->alshead);
      ps->adecidelevel = 0;
      ps->alstail = ps->als;
    }
  LOG ( fprintf (ps->out, "%sback to level %u\n", ps->prefix, ps->LEVEL));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0xd0(%rdi), %rax
cmpq 0xc8(%rdi), %rax
jbe 0xc70b
leaq -0x8(%rax), %rcx
movq %rcx, 0xd0(%rbx)
movq -0x8(%rax), %rsi
movq 0x40(%rbx), %rcx
movl 0x38(%rbx), %edx
movl %esi, %edi
subl %edx, %edi
shrl %edi
shlq $0x4, %rdi
cmpl %ebp, 0x4(%rcx,%rdi)
je 0xc704
movq %rbx, %rdi
callq 0xc7bb
movq 0xd0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
ja 0xc6c4
jmp 0xc70b
movq %rax, 0xd0(%rbx)
movl %ebp, 0x28(%rbx)
movq %rax, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
leaq 0x98(%rbx), %rax
cmpq %rax, 0x250(%rbx)
jne 0xc73f
cmpl $0x0, 0xc4(%rbx)
je 0xc79c
movl $0x0, 0xc4(%rbx)
movq 0x248(%rbx), %rax
movq %rax, 0x250(%rbx)
cmpl %ebp, 0xf0(%rbx)
jbe 0xc776
movq 0xf8(%rbx), %rax
cmpq 0x100(%rbx), %rax
jae 0xc77d
movl $0x0, 0xf0(%rbx)
movq %rax, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x79a6(%rip), %rdi      # 0x1412a
leaq 0x6af1(%rip), %rsi      # 0x1327c
leaq 0x79ae(%rip), %rcx      # 0x14140
movl $0xc02, %edx            # imm = 0xC02
callq 0x10b0
leaq 0x845c(%rip), %rdi      # 0x14bff
leaq 0x6ad2(%rip), %rsi      # 0x1327c
leaq 0x7a0f(%rip), %rcx      # 0x141c0
movl $0x6ab, %edx            # imm = 0x6AB
callq 0x10b0