LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
movq %rbx, %rdi
callq 0x813a
testl %ebp, %ebp
jns 0x8188
movq 0xfe7c(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x942e(%rip), %rdi      # 0x115b4
jmp 0x81e7
cmpl %ebp, 0x438(%rbx)
jle 0x81c3
cmpq $0x0, 0x248(%rbx)
jne 0x81d6
cmpq $0x0, 0x1b8(%rbx)
jne 0x81d6
leaq 0x939a(%rip), %rdi      # 0x11545
leaq 0x90c2(%rip), %rsi      # 0x11274
leaq 0x946b(%rip), %rcx      # 0x11624
movl $0x1c50, %edx           # imm = 0x1C50
callq 0x10b0
movq 0xfe2e(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x9418(%rip), %rdi      # 0x115ec
jmp 0x81e7
movq 0xfe1b(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x93a0(%rip), %rdi      # 0x11587
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8267
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3b54
movq %rbx, %rdi
callq 0x813a
xorl %eax, %eax
cmpq $0x0, 0x248(%rbx)
jne 0x8260
cmpq $0x0, 0x1b8(%rbx)
je 0x8282
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
cmpl 0x2c(%rbx), %ecx
jg 0x8260
cmpl $0x0, 0x1c0(%rbx)
jne 0x823d
movq %rbx, %rdi
callq 0x82a1
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x69e3
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
movq 0xfd8a(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x93ce(%rip), %rdi      # 0x11646
callq 0x10c0
callq 0x1060
leaq 0x92c9(%rip), %rdi      # 0x11552
leaq 0x8fe4(%rip), %rsi      # 0x11274
leaq 0x93e3(%rip), %rcx      # 0x1167a
movl $0x1c75, %edx           # imm = 0x1C75
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x851a
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
cmpl 0x2c(%rdi), %eax
jg 0x852d
movq %rbx, %rdi
callq 0x3b54
movq %rbx, %rdi
callq 0x813a
cmpq $0x0, 0x1b8(%rbx)
je 0x8548
cmpl $0x0, 0x1c0(%rbx)
jne 0x84f1
movq %rbx, %rdi
callq 0x82a1
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x69e3
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
movq 0xfad7(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x9178(%rip), %rdi      # 0x116a3
jmp 0x853e
movq 0xfac4(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x9196(%rip), %rdi      # 0x116d4
callq 0x10c0
callq 0x1060
leaq 0x9003(%rip), %rdi      # 0x11552
leaq 0x8d1e(%rip), %rsi      # 0x11274
leaq 0x91a0(%rip), %rcx      # 0x116fd
movl $0x1c88, %edx           # imm = 0x1C88
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
movq %rbx, %rdi
callq 0x813a
cmpq $0x0, 0x248(%rbx)
movabsq $0x3fffffffc, %r12      # imm = 0x3FFFFFFFC
je 0x8623
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %r14
cmpq 0x170(%rbx), %r14
jne 0x8605
cmpq %r14, %rax
ja 0x872a
subq %rax, %r14
movq %r14, %rcx
shrq %rcx
movl %ecx, %r15d
andq %r12, %r14
pushq $0x1
popq %rcx
cmoveq %rcx, %r15
leaq (,%r15,4), %rcx
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x3e40
movq %rax, 0x160(%rbx)
addq %rax, %r14
leaq (%rax,%r15,4), %rcx
movq %rcx, 0x170(%rbx)
leaq 0x4(%r14), %rcx
movq %rcx, 0x168(%rbx)
andl $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x1b8(%rbx)
je 0x870b
cmpl $0x0, 0x1c0(%rbx)
jne 0x8642
movq %rbx, %rdi
callq 0x82a1
movq 0xf8(%rbx), %r13
cmpq 0x100(%rbx), %r13
jae 0x85a4
movl (%r13), %eax
movq 0x40(%rbx), %rdx
subl 0x38(%rbx), %eax
movl %eax, %ecx
shrl %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
testb $0x20, (%rdx,%rsi)
je 0x86e3
movl %ecx, %ebp
negl %ebp
testb $0x1, %al
cmovel %ecx, %ebp
movq 0x168(%rbx), %r14
cmpq 0x170(%rbx), %r14
jne 0x86d5
movq 0x160(%rbx), %rsi
cmpq %r14, %rsi
ja 0x86ec
subq %rsi, %r14
movq %r14, %rax
shrq %rax
andq %r12, %r14
movl %eax, %r15d
pushq $0x1
popq %rax
cmoveq %rax, %r15
leaq (,%r15,4), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3e40
movq %rax, 0x160(%rbx)
addq %rax, %r14
leaq (%rax,%r15,4), %rax
movq %rax, 0x170(%rbx)
leaq 0x4(%r14), %rax
movq %rax, 0x168(%rbx)
movl %ebp, (%r14)
addq $0x8, %r13
jmp 0x8649
leaq 0x905c(%rip), %rdi      # 0x1174f
leaq 0x8b7a(%rip), %rsi      # 0x11274
leaq 0x9022(%rip), %rcx      # 0x11723
movl $0x1ca8, %edx           # imm = 0x1CA8
callq 0x10b0
leaq 0x8e40(%rip), %rdi      # 0x11552
leaq 0x8b5b(%rip), %rsi      # 0x11274
leaq 0x9003(%rip), %rcx      # 0x11723
movl $0x1c9c, %edx           # imm = 0x1C9C
callq 0x10b0
leaq 0x901e(%rip), %rdi      # 0x1174f
leaq 0x8b3c(%rip), %rsi      # 0x11274
leaq 0x8fe4(%rip), %rcx      # 0x11723
movl $0x1cad, %edx           # imm = 0x1CAD
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ec4
testq %rdx, %rdx
je 0x8ed4
movq 0x328(%rdi), %rax
subq %rdx, %rax
jb 0x8ef3
addq $-0x10, %rsi
movq %rax, 0x328(%rdi)
cmpq %rdx, (%rsi)
jne 0x8f12
movq 0x4b8(%rdi), %rax
testq %rax, %rax
je 0x8ecb
addq $0x10, %rdx
movq 0x4a0(%rdi), %rdi
popq %rcx
jmpq *%rax
testq %rdx, %rdx
jne 0x8f31
popq %rax
retq
movq %rsi, %rdi
popq %rax
jmp 0x1050
leaq 0xa7f4(%rip), %rdi      # 0x136cf
leaq 0x8392(%rip), %rsi      # 0x11274
leaq 0xa7b2(%rip), %rcx      # 0x1369b
movl $0x3d5, %edx            # imm = 0x3D5
callq 0x10b0
leaq 0x92d8(%rip), %rdi      # 0x121d2
leaq 0x8373(%rip), %rsi      # 0x11274
leaq 0xa793(%rip), %rcx      # 0x1369b
movl $0x3d8, %edx            # imm = 0x3D8
callq 0x10b0
leaq 0xa7a4(%rip), %rdi      # 0x136bd
leaq 0x8354(%rip), %rsi      # 0x11274
leaq 0xa774(%rip), %rcx      # 0x1369b
movl $0x3db, %edx            # imm = 0x3DB
callq 0x10b0
leaq 0xa75d(%rip), %rdi      # 0x13695
leaq 0x8335(%rip), %rsi      # 0x11274
leaq 0xa755(%rip), %rcx      # 0x1369b
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8f7a
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rsi
movq 0x4a8(%rdi), %rax
testq %rax, %rax
je 0x8f7e
movq 0x4a0(%r14), %rdi
callq *%rax
jmp 0x8f86
xorl %eax, %eax
jmp 0x8fb0
movq %rsi, %rdi
callq 0x1160
testq %rax, %rax
je 0x8fb8
movq %rbx, (%rax)
addq 0x328(%r14), %rbx
movq %rbx, 0x328(%r14)
cmpq 0x330(%r14), %rbx
jbe 0x8fac
movq %rbx, 0x330(%r14)
addq $0x10, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xf039(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0xa70b(%rip), %rdi      # 0x136d4
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq $0x0, 0x248(%rdi)
jne 0x90c2
movq %rdi, %rbx
callq 0x3703
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 0x8f50
movq %rax, %r12
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %rax, %rcx
je 0x9080
movq 0xf8(%rbx), %rdx
movl (%rdx,%rax,8), %edx
subl 0x38(%rbx), %edx
movl %edx, %esi
shrl %esi
movl %esi, %edi
negl %edi
testb $0x1, %dl
cmovel %esi, %edi
movl %edi, (%r12,%rax,4)
incq %rax
jmp 0x9057
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x90dd
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x92c3
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x8e83
movq %rbx, %rdi
callq 0x3ade
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xef2f(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x88b7(%rip), %rdi      # 0x1198a
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3703
movq %rbx, %rdi
xorl %esi, %esi
callq 0x932a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ade
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: 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 0x3703
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x932a
testq %rax, %rax
je 0x962b
movq 0x198(%rbx), %r14
jmp 0x962e
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x3ade
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: 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 0x3b54
movq %rbx, %rdi
callq 0x9973
testl %ebp, %ebp
je 0x9958
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
xorl %eax, %eax
cmpl 0x2c(%rbx), %ecx
jg 0x9951
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
movq 0xe699(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x811f(%rip), %rdi      # 0x11a88
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: sflush
static void
sflush (PS * ps)
{
  double now = picosat_time_stamp ();
  double delta = now - ps->entered;
  delta = (delta < 0) ? 0 : delta;
  ps->seconds += delta;
  ps->entered = now;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9e82
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
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9edd
cvtsi2sdq 0x8(%rsp), %xmm0
cvtsi2sdq 0x10(%rsp), %xmm1
movsd 0x725d(%rip), %xmm2     # 0x11110
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorpd %xmm3, %xmm3
cvtsi2sdq 0x18(%rsp), %xmm4
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_O2/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 0xa1d8
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 0xa22d
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
pushq $0xa
popq %rdi
callq 0x10f0
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
movq %rbx, %rdi
callq 0x7fc8
movl 0x498(%rbx), %ecx
movl 0x49c(%rbx), %edx
cmpl %ecx, %edx
ja 0xa269
movq 0x490(%rbx), %rax
cmpq 0x468(%rbx), %rax
je 0xa272
xorl %eax, %eax
cmpl %ecx, %edx
setbe %al
popq %rbx
retq
leaq 0x7a5c(%rip), %rdi      # 0x11cd5
leaq 0x6ff4(%rip), %rsi      # 0x11274
leaq 0x7a73(%rip), %rcx      # 0x11cfa
movl $0x2047, %edx           # imm = 0x2047
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x1c8(%rdi), %rcx
addq $0x8, %rcx
movq %rcx, 0x1d0(%rdi)
leaq 0x8(%rax), %r14
movl 0x2c(%rbx), %ecx
leaq (%rax,%rcx,8), %rax
cmpq %rax, %r14
ja 0xa34f
andq $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa357
movq 0x48(%rbx), %rax
addq $0x8, %r14
jmp 0xa32a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: hpush
inline static void
hpush (PS * ps, Rnk * r)
{
  assert (!r->pos);

  if (ps->hhead == ps->eoh)
    ENLARGE (ps->heap, ps->hhead, ps->eoh);

  r->pos = ps->hhead++ - ps->heap;
  ps->heap[r->pos] = r;
  hup (ps, r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl $0x3fffffff, 0x4(%rsi)  # imm = 0x3FFFFFFF
jne 0xa436
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1c8(%rdi), %rax
movq 0x1d0(%rdi), %rcx
cmpq 0x1d8(%rdi), %rcx
jne 0xa3e1
cmpq %rcx, %rax
ja 0xa455
subq %rax, %rcx
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rcx, %r15
shrq $0x2, %rcx
testq %r15, %r15
movl %ecx, %ecx
pushq $0x1
popq %r12
cmovneq %rcx, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3e40
movq %rax, 0x1c8(%r14)
addq %rax, %r15
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x1d8(%r14)
movq %r15, %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x1d0(%r14)
subq %rax, %rcx
movq %rcx, %rax
shrq $0x3, %rax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl $0xc0000000, %edx       # imm = 0xC0000000
andl 0x4(%rbx), %edx
orl %eax, %edx
movl %edx, 0x4(%rbx)
movq 0x1c8(%r14), %rax
movabsq $0x1fffffff8, %rdx      # imm = 0x1FFFFFFF8
andq %rcx, %rdx
movq %rbx, (%rax,%rdx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xada3
leaq 0x93c0(%rip), %rdi      # 0x137fd
leaq 0x6e30(%rip), %rsi      # 0x11274
leaq 0x93ba(%rip), %rcx      # 0x13805
movl $0xad3, %edx            # imm = 0xAD3
callq 0x10b0
leaq 0x7b05(%rip), %rdi      # 0x11f61
leaq 0x6e11(%rip), %rsi      # 0x11274
leaq 0x939b(%rip), %rcx      # 0x13805
movl $0xad6, %edx            # imm = 0xAD6
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3703
movq %r14, %rdi
callq 0x3d4b
movq %r14, %rdi
movl %ebx, %esi
callq 0xa4a3
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ade
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
testl %ebx, %ebx
js 0xaca9
cmpl $0x4, %ebx
jae 0xacbc
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd348(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x705a(%rip), %rdi      # 0x11d14
jmp 0xaccd
movq 0xd335(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x709a(%rip), %rdi      # 0x11d67
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x69e3
subl 0x38(%r14), %eax
shrl %eax
shlq $0x4, %rax
addq 0x40(%r14), %rax
testl %ebx, %ebx
je 0xad20
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 0xad29
movzwl (%rax), %ecx
andl $0xff77, %ecx           # imm = 0xFF77
movw %cx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x69e3
subl 0x38(%rbx), %eax
movq 0x48(%rbx), %rdx
shrl %eax
movl 0x4(%rdx,%rax,8), %ecx
testl %ecx, %ecx
js 0xad88
cmpl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
ja 0xad81
leaq (%rdx,%rax,8), %rsi
movl %ecx, %eax
orl $0x40000000, %eax       # imm = 0x40000000
movl %eax, 0x4(%rsi)
testl %ecx, %ecx
je 0xad81
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xada3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xd269(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x701c(%rip), %rdi      # 0x11db5
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, (%rsp)
cmpl $0x0, 0x408(%rdi)
jne 0xae67
movq %rsi, %rbx
movl 0x4(%rsi), %ebp
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
je 0xae86
movq (%rsp), %rax
movq 0x1c8(%rax), %r13
movq 0x1d0(%rax), %rax
subq %r13, %rax
sarq $0x3, %rax
cmpq %rbp, %rax
jle 0xaea5
cmpq %rbx, (%r13,%rbp,8)
jne 0xaec4
movl %ebp, %r14d
cmpl $0x2, %ebp
jb 0xae46
movl %ebp, %r12d
shrl %r12d
movq (%r13,%r12,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xcaeb
testl %eax, %eax
jg 0xae46
movq %r15, (%r13,%r14,8)
movl 0x4(%r15), %eax
movl $0xc0000000, %ecx       # imm = 0xC0000000
andl %ecx, %eax
orl %ebp, %eax
movl %eax, 0x4(%r15)
movq (%rsp), %rax
movq 0x1c8(%rax), %r13
movl %r12d, %ebp
jmp 0xadfe
movq %rbx, (%r13,%r14,8)
movl $0xc0000000, %eax       # imm = 0xC0000000
andl 0x4(%rbx), %eax
orl %ebp, %eax
movl %eax, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8a7a(%rip), %rdi      # 0x138e8
leaq 0x63ff(%rip), %rsi      # 0x11274
leaq 0x8a7d(%rip), %rcx      # 0x138f9
movl $0x6d7, %edx            # imm = 0x6D7
callq 0x10b0
leaq 0x8a82(%rip), %rdi      # 0x1390f
leaq 0x63e0(%rip), %rsi      # 0x11274
leaq 0x8a5e(%rip), %rcx      # 0x138f9
movl $0x6dc, %edx            # imm = 0x6DC
callq 0x10b0
leaq 0x8a6c(%rip), %rdi      # 0x13918
leaq 0x63c1(%rip), %rsi      # 0x11274
leaq 0x8a3f(%rip), %rcx      # 0x138f9
movl $0x6dd, %edx            # imm = 0x6DD
callq 0x10b0
leaq 0x8a69(%rip), %rdi      # 0x13934
leaq 0x63a2(%rip), %rsi      # 0x11274
leaq 0x8a20(%rip), %rcx      # 0x138f9
movl $0x6de, %edx            # imm = 0x6DE
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3b54
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x69e3
subl 0x38(%rbx), %eax
movq 0x48(%rbx), %rdx
shrl %eax
movl 0x4(%rdx,%rax,8), %ecx
btl $0x1e, %ecx
jb 0xaf38
testl %ecx, %ecx
js 0xaf31
leaq (%rdx,%rax,8), %rsi
movl %ecx, %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, 0x4(%rsi)
testl %ecx, %ecx
je 0xaf31
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xaf53
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xd0b9(%rip), %rax      # 0x17ff8
movq (%rax), %rsi
leaq 0x6e6c(%rip), %rdi      # 0x11db5
callq 0x10c0
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl 0x4(%rsi), %r13d
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
je 0xb08c
movq 0x1c8(%rdi), %rax
cmpq %rsi, (%rax,%r13,8)
jne 0xb0ab
movq %rdi, 0x18(%rsp)
movq 0x1d0(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leal (,%r13,2), %ebx
movl %r13d, %r14d
cmpl 0x10(%rsp), %ebx
jae 0xb058
movl %ebx, %ebp
orl $0x1, %ebp
movq 0x18(%rsp), %rax
movq 0x1c8(%rax), %r12
movl %ebx, %eax
movq (%r12,%rax,8), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0xcaeb
movl %ebp, %ecx
testl %eax, %eax
js 0xb002
cmpl 0x10(%rsp), %ebp
movq 0x8(%rsp), %rsi
jae 0xb058
movq (%r12,%rcx,8), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0xcaeb
movq 0x8(%rsp), %rsi
testl %eax, %eax
js 0xb033
jmp 0xb058
cmpl 0x10(%rsp), %ebp
jae 0xb02c
movq (%r12,%rcx,8), %rsi
movq %rsi, 0x20(%rsp)
movq %r15, %rdi
callq 0xcaeb
movq 0x20(%rsp), %rcx
testl %eax, %eax
js 0xb027
movl %ebx, %ebp
movq %r15, %rcx
movq %rcx, %r15
jmp 0xb02e
movl %ebx, %ebp
movq 0x8(%rsp), %rsi
movq %r15, (%r12,%r14,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)
movl %ebp, %r13d
jmp 0xafa0
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
movl $0xc0000000, %eax       # imm = 0xC0000000
andl 0x4(%rsi), %eax
orl %r13d, %eax
movl %eax, 0x4(%rsi)
movq 0x18(%rsp), %rax
movq 0x1c8(%rax), %rax
movq %rsi, (%rax,%r14,8)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x88b5(%rip), %rdi      # 0x13948
leaq 0x61da(%rip), %rsi      # 0x11274
leaq 0x88b2(%rip), %rcx      # 0x13953
movl $0xa81, %edx            # imm = 0xA81
callq 0x10b0
leaq 0x88b9(%rip), %rdi      # 0x1396b
leaq 0x61bb(%rip), %rsi      # 0x11274
leaq 0x8893(%rip), %rcx      # 0x13953
movl $0xa82, %edx            # imm = 0xA82
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3703
movq %rbx, %rdi
callq 0x3d4b
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x4155
movq %rbx, %rdi
popq %rbx
jmp 0x3ade
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb494
movq 0x40(%rdi), %rcx
movl %eax, %edx
shlq $0x4, %rdx
xorl %eax, %eax
testb $0x20, 0x1(%rcx,%rdx)
je 0xb493
movq 0x38(%rdi), %rax
leal (%rsi,%rsi), %ecx
pushq $0x1
popq %rdx
movl %edx, %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 0x815f(%rip), %rdi      # 0x135fb
leaq 0x5dd1(%rip), %rsi      # 0x11274
leaq 0x8556(%rip), %rcx      # 0x13a00
movl $0x1b40, %edx           # imm = 0x1B40
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xa
popq %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xb4b4
movl %eax, %r13d
pushq $-0x1c
popq %rsi
movl $0x199999a, %edi        # imm = 0x199999A
callq 0xb4b4
movl %eax, %r14d
movsbl (%rbx), %ebp
callq 0x1220
movq %rax, %r15
pushq $-0x1
popq %rax
cmpl $0x2e, %ebp
jne 0xb5b0
incq %rbx
movsbq (%rbx), %rbp
movq (%r15), %rcx
testb $0x8, 0x1(%rcx,%rbp,2)
je 0xb621
incq %rbx
movl %r14d, %r13d
movsbl %bpl, %edi
addl $-0x30, %edi
xorl %esi, %esi
callq 0xb4b4
movl %eax, %edi
movl %r13d, %esi
callq 0xb693
movl %r12d, %edi
movl %eax, %esi
callq 0xb721
movl %eax, %r12d
movsbq (%rbx), %rbp
testq %rbp, %rbp
je 0xb619
movq (%r15), %rax
testb $0x8, 0x1(%rax,%rbp,2)
je 0xb61e
movl %r13d, %edi
movl %r14d, %esi
callq 0xb693
movl %eax, %r13d
incq %rbx
jmp 0xb55d
movq (%r15), %rdx
movslq %ebp, %rcx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0xb621
addl $-0x30, %ebp
movl %ebp, %edi
xorl %esi, %esi
callq 0xb4b4
movl %eax, %r12d
addq $0x2, %rbx
movzbl -0x1(%rbx), %eax
testl %eax, %eax
je 0xb619
cmpl $0x2e, %eax
je 0xb630
movsbl %al, %ebp
movq (%r15), %rax
movslq %ebp, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0xb61e
movl %r12d, %edi
movl %r13d, %esi
callq 0xb693
movl %eax, %r12d
addl $-0x30, %ebp
movl %ebp, %edi
xorl %esi, %esi
callq 0xb4b4
movl %r12d, %edi
movl %eax, %esi
callq 0xb721
movl %eax, %r12d
incq %rbx
jmp 0xb5d0
movl %r12d, %eax
jmp 0xb621
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0xb545
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb655
cmpl $0x80, %esi
jge 0xb674
xorl $-0x80, %esi
shll $0x18, %esi
orl %edi, %esi
movl %esi, %eax
popq %rcx
retq
leaq 0x6987(%rip), %rdi      # 0x11fe3
leaq 0x5c11(%rip), %rsi      # 0x11274
leaq 0x695a(%rip), %rcx      # 0x11fc4
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x10b0
leaq 0x697c(%rip), %rdi      # 0x11ff7
leaq 0x5bf2(%rip), %rsi      # 0x11274
leaq 0x693b(%rip), %rcx      # 0x11fc4
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb6c8
cmpl %esi, %edi
cmoval %edi, %esi
movl %esi, %ecx
shrl $0x18, %ecx
movl %r8d, %edi
shrl $0x18, %edi
leal (%rcx,%rdi), %edx
pushq $-0x1
popq %rax
cmpl $0x167, %edx            # imm = 0x167
ja 0xb6ca
cmpl $0x68, %edx
jae 0xb6cb
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
movl $0xffffff, %r9d         # imm = 0xFFFFFF
andl %r9d, %esi
movl $0x1000000, %r10d       # imm = 0x1000000
orl %r10d, %esi
andl %r9d, %r8d
orl %r10d, %r8d
addl %edi, %ecx
addl $0xffffff18, %ecx       # imm = 0xFFFFFF18
movl %esi, %esi
movl %r8d, %edi
imulq %rsi, %rdi
movq %rdi, %rsi
shrq $0x31, %rsi
je 0xb710
cmpl $0x7f, %ecx
je 0xb6ca
addl $0xffffff19, %edx       # imm = 0xFFFFFF19
shrq $0x19, %rdi
movl %edx, %ecx
jmp 0xb714
shrq $0x18, %rdi
andl $0x2ffffff, %edi        # imm = 0x2FFFFFF
movl %ecx, %esi
jmp 0xb638
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb774
movl %esi, %edx
shrl $0x18, %edx
movl %edi, %eax
shrl $0x18, %eax
movl %edx, %ecx
subl %eax, %ecx
jb 0xb78b
andl $0xffffff, %edi         # imm = 0xFFFFFF
orl $0x1000000, %edi        # imm = 0x1000000
shrl %cl, %edi
testl %edi, %edi
je 0xb774
andl $0xffffff, %esi         # imm = 0xFFFFFF
leal -0x80(%rdx), %eax
orl $0x1000000, %esi        # imm = 0x1000000
addl %esi, %edi
cmpl $0x2000000, %edi        # imm = 0x2000000
jb 0xb77e
cmpl $0x7f, %eax
jne 0xb777
pushq $-0x1
popq %rsi
movl %esi, %eax
retq
addl $-0x7f, %edx
shrl %edi
movl %edx, %eax
andl $0xffffff, %edi         # imm = 0xFFFFFF
movl %eax, %esi
jmp 0xb638
pushq %rax
leaq 0x6878(%rip), %rdi      # 0x1200b
leaq 0x5ada(%rip), %rsi      # 0x11274
leaq 0x6873(%rip), %rcx      # 0x12014
movl $0x304, %edx            # imm = 0x304
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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(%rbx), %rax
cmpq 0xc8(%rbx), %rax
jbe 0xb7fa
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 0xb7f3
movq %rbx, %rdi
callq 0xb8b1
jmp 0xb7b3
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 0xb826
movq %rbx, %rdi
callq 0xb880
movl 0x28(%rbx), %ebp
movq 0x248(%rbx), %rax
movq %rax, 0x250(%rbx)
cmpl 0xf0(%rbx), %ebp
jae 0xb85a
movq 0xf8(%rbx), %rax
cmpq 0x100(%rbx), %rax
jae 0xb861
andl $0x0, 0xf0(%rbx)
movq %rax, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x68ba(%rip), %rdi      # 0x12122
leaq 0x5a05(%rip), %rsi      # 0x11274
leaq 0x68c2(%rip), %rcx      # 0x12138
movl $0xc02, %edx            # imm = 0xC02
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: satisfied
static int
satisfied (PS * ps)
{
  assert (!ps->mtcls);
  assert (!ps->failed_assumption);
  if (ps->alstail < ps->alshead)
    return 0;
  assert (!ps->conflict);
  assert (bcp_queue_is_empty (ps));
  return ps->thead == ps->trail + ps->max_var;	/* all assigned */
}

// Assembly:
pushq %rax
cmpq $0x0, 0x248(%rdi)
jne 0xbad9
cmpq $0x0, 0x1b8(%rdi)
jne 0xbaf8
movq 0x108(%rdi), %rcx
xorl %eax, %eax
cmpq 0x100(%rdi), %rcx
jb 0xbad7
cmpq $0x0, 0x250(%rdi)
jne 0xbb36
movq 0xe0(%rdi), %rcx
cmpq 0xd0(%rdi), %rcx
jne 0xbb17
cmpq %rcx, 0xe8(%rdi)
jne 0xbb17
movl 0x2c(%rdi), %edx
shlq $0x3, %rdx
addq 0xc8(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
sete %al
popq %rcx
retq
leaq 0x678e(%rip), %rdi      # 0x1226e
leaq 0x578d(%rip), %rsi      # 0x11274
leaq 0x68d5(%rip), %rcx      # 0x123c3
movl $0xd47, %edx            # imm = 0xD47
callq 0x10b0
leaq 0x68d8(%rip), %rdi      # 0x123d7
leaq 0x576e(%rip), %rsi      # 0x11274
leaq 0x68b6(%rip), %rcx      # 0x123c3
movl $0xd48, %edx            # imm = 0xD48
callq 0x10b0
leaq 0x68de(%rip), %rdi      # 0x123fc
leaq 0x574f(%rip), %rsi      # 0x11274
leaq 0x6897(%rip), %rcx      # 0x123c3
movl $0xd4c, %edx            # imm = 0xD4C
callq 0x10b0
leaq 0x68b1(%rip), %rdi      # 0x123ee
leaq 0x5730(%rip), %rsi      # 0x11274
leaq 0x6878(%rip), %rcx      # 0x123c3
movl $0xd4b, %edx            # imm = 0xD4B
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: clause_is_toplevel_satisfied
static int
clause_is_toplevel_satisfied (PS * ps, Cls * c)
{
  Lit *lit, **p, **eol = end_of_lits (c);
  Var *v;

  for (p = c->lits; p < eol; p++)
    {
      lit = *p;
      if (lit->val == TRUE)
	{
	  v = LIT2VAR (lit);
	  if (!v->level)
	    return 1;
	}
    }

  return 0;
}

// Assembly:
leaq 0x18(%rsi), %rcx
movl (%rsi), %eax
leaq (%rsi,%rax,8), %rdx
addq $0x18, %rdx
pushq $0x1
popq %rax
cmpq %rdx, %rcx
jae 0xbb8e
movq (%rcx), %rsi
cmpb $0x1, (%rsi)
jne 0xbb88
movq 0x40(%rdi), %r8
subl 0x38(%rdi), %esi
shrl %esi
shlq $0x4, %rsi
cmpl $0x0, 0x4(%r8,%rsi)
je 0xbb90
addq $0x8, %rcx
jmp 0xbb66
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: cmp_inverse_jwh_rnk
static int
cmp_inverse_jwh_rnk (PS * ps, Rnk * r, Rnk * s)
{
  Flt a = rnk2jwh (ps, r);
  Flt b = rnk2jwh (ps, s);
  int res = cmpflt (a, b);

  if (res)
    return -res;

  return cmp_inverse_rnk (ps, r, s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xca9f
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xca9f
xorl %ecx, %ecx
cmpl %eax, %ebp
seta %cl
pushq $-0x1
popq %rax
cmovael %ecx, %eax
testl %eax, %eax
jne 0xbfc7
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcaeb
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rnk2jwh
inline static Flt
rnk2jwh (PS * ps, Rnk * r)
{
  Flt res, sum, pjwh, njwh;
  Lit * plit, * nlit;

  plit = RNK2LIT (r);
  nlit = plit + 1;
  
  pjwh = *LIT2JWH (plit);
  njwh = *LIT2JWH (nlit);

  res = mulflt (pjwh, njwh);

  sum = addflt (pjwh, njwh);
  sum = mulflt (sum, base2flt (1, -10));
  res = addflt (res, sum);

  return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq 0x48(%rdi), %rsi
movq 0x50(%rdi), %rax
movl (%rax,%rsi), %ebx
movl 0x4(%rax,%rsi), %ebp
movl %ebx, %edi
movl %ebp, %esi
callq 0xb693
movl %eax, %r14d
movl %ebx, %edi
movl %ebp, %esi
callq 0xb721
movl %eax, %ebx
pushq $0x1
popq %rdi
pushq $-0xa
popq %rsi
callq 0xb4b4
movl %ebx, %edi
movl %eax, %esi
callq 0xb693
movl %r14d, %edi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xb721
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: cmp_rnk
static int
cmp_rnk (Rnk * r, Rnk * s)
{
  if (!r->moreimportant && s->moreimportant)
    return -1;

  if (r->moreimportant && !s->moreimportant)
    return 1;

  if (!r->lessimportant && s->lessimportant)
    return 1;

  if (r->lessimportant && !s->lessimportant)
    return -1;

  if (r->score < s->score)
    return -1;

  if (r->score > s->score)
    return 1;

  return -cmp_ptr (0, r, s);
}

// Assembly:
movl 0x4(%rdi), %r8d
btl $0x1e, %r8d
movl 0x4(%rsi), %edx
pushq $0x1
popq %rcx
pushq $-0x1
popq %rax
jb 0xcb06
btl $0x1e, %edx
jae 0xcb0c
retq
btl $0x1e, %edx
jae 0xcb15
testl %r8d, %r8d
js 0xcb18
testl %edx, %edx
jns 0xcb1c
movl %ecx, %eax
retq
testl %edx, %edx
jns 0xcb05
movl (%rsi), %edx
cmpl %edx, (%rdi)
jb 0xcb05
movl %ecx, %eax
ja 0xcb05
subl %edi, %esi
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assign
inline static void
assign (PS * ps, Lit * lit, Cls * reason)
{
  Var * v = LIT2VAR (lit);
  assert (lit->val == UNDEF);
#ifdef STATS
  ps->assignments++;
#endif
  v->level = ps->LEVEL;
  assign_phase (ps, lit);
  assign_reason (ps, v, reason);
  tpush (ps, lit);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rsi)
jne 0xcd13
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rdx
movq 0x38(%rdi), %rax
movq %rsi, %r8
subq %rax, %r8
movl %r8d, %edi
shrl %edi
shlq $0x4, %rdi
leaq (%rdx,%rdi), %rsi
movl 0x28(%r14), %r9d
movl %r9d, 0x4(%rdx,%rdi)
testl %r9d, %r9d
je 0xcb7b
cmpl $0x0, 0x408(%r14)
jne 0xcbf3
movl %r8d, %r9d
notl %r9d
andl $0x1, %r9d
testb $0x8, (%rsi)
je 0xcbda
movl 0x488(%r14), %edi
movl $0x2710, %r10d          # imm = 0x2710
movl %edi, %eax
xorl %edx, %edx
divl %r10d
subl %eax, %edi
movl %edi, 0x488(%r14)
btl $0x2, (%rsi)
movl %r9d, %eax
sbbl $0x0, %eax
je 0xcbda
addl $0x3e8, %edi            # imm = 0x3E8
movl %edi, 0x488(%r14)
incq 0x468(%r14)
shrl %r8d
cmpl 0x49c(%r14), %r8d
jae 0xcbda
movl %r8d, 0x49c(%r14)
movl (%rsi), %eax
andl $-0xd, %eax
leal (%rax,%r9,4), %eax
addl $0x8, %eax
movw %ax, (%rsi)
movq 0x38(%r14), %rax
movq %rbx, %r8
subq %rax, %r8
movb $0x1, (%rbx)
xorq $0x1, %r8
movb $-0x1, (%rax,%r8)
movq %r14, %rdi
movq %rcx, %rdx
callq 0xcd51
movq 0x38(%r14), %rax
cmpq %rbx, %rax
jae 0xccf4
movl 0x2c(%r14), %ecx
addl %ecx, %ecx
addq %rcx, %rax
incq %rax
cmpq %rbx, %rax
jb 0xccf4
movq 0xd0(%r14), %rax
cmpq 0xd8(%r14), %rax
jne 0xccd7
movq 0xc8(%r14), %rsi
cmpq %rax, %rsi
ja 0xcd32
subq %rsi, %rax
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
movq %rax, %r15
andq %rcx, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
pushq $0x1
popq %r13
cmovneq %rax, %r13
movq 0xe0(%r14), %rbp
movq 0xe8(%r14), %r12
subq %rsi, %rbp
subq %rsi, %r12
leaq (,%r13,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x3e40
movq %rax, 0xc8(%r14)
addq %rax, %r15
leaq (%rax,%r13,8), %rcx
movq %rcx, 0xd8(%r14)
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
andq %rcx, %rbp
addq %rax, %rbp
movq %rbp, 0xe0(%r14)
andq %rcx, %r12
addq %rax, %r12
movq %r12, 0xe8(%r14)
movq %r15, %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0xd0(%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58cc(%rip), %rdi      # 0x125c7
leaq 0x4572(%rip), %rsi      # 0x11274
leaq 0x58f5(%rip), %rcx      # 0x125fe
movl $0x5f5, %edx            # imm = 0x5F5
callq 0x10b0
leaq 0x5f96(%rip), %rdi      # 0x12cb0
leaq 0x4553(%rip), %rsi      # 0x11274
leaq 0x5858(%rip), %rcx      # 0x12580
movl $0x643, %edx            # imm = 0x643
callq 0x10b0
leaq 0x58dd(%rip), %rdi      # 0x12616
leaq 0x4534(%rip), %rsi      # 0x11274
leaq 0x58b7(%rip), %rcx      # 0x125fe
movl $0x5fd, %edx            # imm = 0x5FD
callq 0x10b0