LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3de6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f65
testq %rax, %rax
je 0xa2d5
movq 0x198(%rbx), %r14
jmp 0xa2d8
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x41bd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: 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 0x4264
movq %rbx, %rdi
callq 0xa63c
testl %ebp, %ebp
je 0xa637
movl %ebp, %ecx
negl %ecx
cmovsl %ebp, %ecx
xorl %eax, %eax
cmpl 0x2c(%rbx), %ecx
jg 0xa630
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 0x1508
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11a0
xorpd %xmm0, %xmm0
testl %eax, %eax
jne 0xab97
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rsp), %xmm0
cvtsi2sdq 0x10(%rsp), %xmm1
movsd 0x75de(%rip), %xmm2     # 0x12148
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_O1/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 0xaeb9
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 0xaf10
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 0x11b0
movq 0x10(%rbx), %rsi
movl $0xa, %edi
callq 0x10f0
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
movq %rbx, %rdi
callq 0x8b95
movl 0x498(%rbx), %ecx
movl 0x49c(%rbx), %edx
cmpl %ecx, %edx
ja 0xaf4c
movq 0x490(%rbx), %rax
cmpq 0x468(%rbx), %rax
je 0xaf55
xorl %eax, %eax
cmpl %ecx, %edx
setbe %al
popq %rbx
retq
leaq 0x7db1(%rip), %rdi      # 0x12d0d
leaq 0x7349(%rip), %rsi      # 0x122ac
leaq 0x7dc8(%rip), %rcx      # 0x12d32
movl $0x2047, %edx           # imm = 0x2047
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x1c8(%rdi), %rax
addq $0x8, %rax
movq %rax, 0x1d0(%rdi)
cmpl $0x0, 0x2c(%rdi)
je 0xb042
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
addq $0x8, %r14
movq $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb043
addq $0x8, %r14
movl 0x2c(%rbx), %eax
shlq $0x3, %rax
addq 0x48(%rbx), %rax
cmpq %rax, %r14
jbe 0xb015
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: 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 %r13
pushq %r12
pushq %rbx
testl $0x3fffffff, 0x4(%rsi)  # imm = 0x3FFFFFFF
jne 0xb132
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d0(%rdi), %r15
movq 0x1d8(%rdi), %rdx
cmpq %rdx, %r15
jne 0xb0d7
movq 0x1c8(%r14), %rsi
cmpq %rdx, %rsi
ja 0xb151
subq %rsi, %r15
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %r12      # imm = 0x7FFFFFFF8
andq %r12, %rdx
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,8), %rcx
movq %r14, %rdi
callq 0x4593
movq %rax, 0x1c8(%r14)
andq %r12, %r15
addq %rax, %r15
movq %r15, 0x1d0(%r14)
leaq (%rax,%r13,8), %rax
movq %rax, 0x1d8(%r14)
movq 0x1d0(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x1d0(%r14)
subq 0x1c8(%r14), %rax
movabsq $0x1fffffff8, %rcx      # imm = 0x1FFFFFFF8
andq %rax, %rcx
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
movq %rbx, (%rax,%rcx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xbb76
leaq 0x974a(%rip), %rdi      # 0x14883
leaq 0x716c(%rip), %rsi      # 0x122ac
leaq 0x9744(%rip), %rcx      # 0x1488b
movl $0xad3, %edx            # imm = 0xAD3
callq 0x10b0
leaq 0x7e41(%rip), %rdi      # 0x12f99
leaq 0x714d(%rip), %rsi      # 0x122ac
leaq 0x9725(%rip), %rcx      # 0x1488b
movl $0xad6, %edx            # imm = 0xAD6
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3de6
movq %r14, %rdi
callq 0x4460
movq %r14, %rdi
movl %ebx, %esi
callq 0xb19f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41bd
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
testl %ebx, %ebx
js 0xbab2
cmpl $0x4, %ebx
jge 0xbab7
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x155c
callq 0x1540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74d1
subl 0x38(%r14), %eax
shrl %eax
shlq $0x4, %rax
addq 0x40(%r14), %rax
testl %ebx, %ebx
je 0xbb07
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 0xbb10
movzwl (%rax), %ecx
andl $0xff77, %ecx           # imm = 0xFF77
movw %cx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74d1
subl 0x38(%rbx), %eax
movq 0x48(%rbx), %rdx
shrl %eax
movl 0x4(%rdx,%rax,8), %ecx
testl %ecx, %ecx
js 0xbb71
cmpl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
ja 0xbb6a
leaq (%rdx,%rax,8), %rsi
movl %ecx, %eax
orl $0x40000000, %eax       # imm = 0x40000000
movl %eax, 0x4(%rsi)
testl %ecx, %ecx
je 0xbb6a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbb76
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1578
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbc47
movq %rsi, %rbx
movl 0x4(%rsi), %r12d
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
je 0xbc66
movq %rdi, %r14
movq 0x1c8(%rdi), %rax
movq 0x1d0(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jle 0xbc85
cmpq %rbx, (%rax,%r12,8)
jne 0xbca4
cmpl $0x1, %r12d
jne 0xbbd8
movl %r12d, %r13d
jmp 0xbc1c
movl %r12d, %r13d
shrl %r13d
movq 0x1c8(%r14), %rbp
movq (%rbp,%r13,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdbc3
testl %eax, %eax
jg 0xbbd3
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 0xbbdb
movq 0x1c8(%r14), %rax
movl %r13d, %ecx
movq %rbx, (%rax,%rcx,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 0x8d20(%rip), %rdi      # 0x1496e
leaq 0x6657(%rip), %rsi      # 0x122ac
leaq 0x8d23(%rip), %rcx      # 0x1497f
movl $0x6d7, %edx            # imm = 0x6D7
callq 0x10b0
leaq 0x8d28(%rip), %rdi      # 0x14995
leaq 0x6638(%rip), %rsi      # 0x122ac
leaq 0x8d04(%rip), %rcx      # 0x1497f
movl $0x6dc, %edx            # imm = 0x6DC
callq 0x10b0
leaq 0x8d12(%rip), %rdi      # 0x1499e
leaq 0x6619(%rip), %rsi      # 0x122ac
leaq 0x8ce5(%rip), %rcx      # 0x1497f
movl $0x6dd, %edx            # imm = 0x6DD
callq 0x10b0
leaq 0x8d0f(%rip), %rdi      # 0x149ba
leaq 0x65fa(%rip), %rsi      # 0x122ac
leaq 0x8cc6(%rip), %rcx      # 0x1497f
movl $0x6de, %edx            # imm = 0x6DE
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4264
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x74d1
subl 0x38(%rbx), %eax
movq 0x48(%rbx), %rdx
shrl %eax
movl 0x4(%rdx,%rax,8), %ecx
btl $0x1e, %ecx
jb 0xbd1a
testl %ecx, %ecx
js 0xbd13
leaq (%rdx,%rax,8), %rsi
movl %ecx, %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, 0x4(%rsi)
testl %ecx, %ecx
je 0xbd13
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbd1f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1594
// File: /workspace/github_cpp_makefile_star2_O1/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), %r13d
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
je 0xbe77
movq 0x1c8(%rdi), %rax
cmpq %rsi, (%rax,%r13,8)
jne 0xbe96
movq 0x1d0(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
leal (,%r13,2), %r12d
movq %rcx, 0x8(%rsp)
cmpl %ecx, %r12d
jae 0xbe31
movq %rdi, (%rsp)
movl %r12d, %r14d
orl $0x1, %r14d
movq 0x1c8(%rdi), %rbx
movl %r12d, %eax
movq (%rbx,%rax,8), %r15
movq %rsi, %rbp
movq %rsi, %rdi
movq %r15, %rsi
callq 0xdbc3
testl %eax, %eax
js 0xbdc4
cmpl 0x8(%rsp), %r14d
jae 0xbe36
movl %r14d, %eax
movq (%rbx,%rax,8), %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0xdbc3
movq %rbp, %rsi
testl %eax, %eax
js 0xbdf9
jmp 0xbe3e
cmpl 0x8(%rsp), %r14d
jae 0xbdf3
movl %r14d, %eax
movq (%rbx,%rax,8), %rsi
movq %rsi, 0x10(%rsp)
movq %r15, %rdi
callq 0xdbc3
movq 0x10(%rsp), %rcx
testl %eax, %eax
js 0xbdee
movl %r12d, %r14d
movq %r15, %rcx
movq %rcx, %r15
jmp 0xbdf6
movl %r12d, %r14d
movq %rbp, %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 (%r14,%r14), %r12d
movl %r14d, %r13d
cmpl 0x8(%rsp), %r12d
movq (%rsp), %rdi
jb 0xbd77
jmp 0xbe45
movl %r13d, %r14d
jmp 0xbe45
movl %r13d, %r14d
movq %rbp, %rsi
jmp 0xbe41
movl %r13d, %r14d
movq (%rsp), %rdi
movl %r14d, %eax
andl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
movl $0xc0000000, %ecx       # imm = 0xC0000000
andl 0x4(%rsi), %ecx
orl %r14d, %ecx
movl %ecx, 0x4(%rsi)
movq 0x1c8(%rdi), %rcx
movq %rsi, (%rcx,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8b50(%rip), %rdi      # 0x149ce
leaq 0x6427(%rip), %rsi      # 0x122ac
leaq 0x8b4d(%rip), %rcx      # 0x149d9
movl $0xa81, %edx            # imm = 0xA81
callq 0x10b0
leaq 0x8b54(%rip), %rdi      # 0x149f1
leaq 0x6408(%rip), %rsi      # 0x122ac
leaq 0x8b2e(%rip), %rcx      # 0x149d9
movl $0xa82, %edx            # imm = 0xA82
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3de6
movq %rbx, %rdi
callq 0x4460
movq %rbx, %rdi
movl $0x1, %esi
callq 0x489f
movq %rbx, %rdi
popq %rbx
jmp 0x41bd
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc289
movq 0x40(%rdi), %rcx
movl %eax, %edx
shlq $0x4, %rdx
xorl %eax, %eax
testb $0x20, 0x1(%rcx,%rdx)
je 0xc288
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 0x83f0(%rip), %rdi      # 0x14681
leaq 0x6014(%rip), %rsi      # 0x122ac
leaq 0x87e7(%rip), %rcx      # 0x14a86
movl $0x1b40, %edx           # imm = 0x1B40
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc2cb
cmpl $0xffffff, %edi         # imm = 0xFFFFFF
ja 0xc2ce
cmpl $-0x7f, %esi
jl 0xc2f7
decl %esi
leal (%rdi,%rdi), %eax
cmpl $0x800000, %edi         # imm = 0x800000
movl %eax, %edi
jb 0xc2b5
jmp 0xc2ff
xorl %eax, %eax
retq
cmpl $0x2000000, %edi        # imm = 0x2000000
jb 0xc2fd
cmpl $0x7f, %esi
movl $0x7f, %ecx
cmovgl %esi, %ecx
cmpl %esi, %ecx
je 0xc30b
incl %esi
movl %edi, %eax
shrl %eax
cmpl $0x3ffffff, %edi        # imm = 0x3FFFFFF
movl %eax, %edi
ja 0xc2e1
jmp 0xc2ff
movl $0x1, %eax
retq
movl %edi, %eax
andl $0x7effffff, %eax       # imm = 0x7EFFFFFF
movl %eax, %edi
jmp 0xc48e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc48e
movsbl (%rbx), %r15d
cmpl $0x2e, %r15d
jne 0xc345
incq %rbx
xorl %r15d, %r15d
movb $0x1, %al
jmp 0xc3ce
movl %eax, %r14d
callq 0x1210
movq %rax, %r12
movq (%rax), %rax
movslq %r15d, %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb $0x8, 0x1(%rax,%rcx,2)
je 0xc3f3
addl $-0x30, %r15d
movl %r15d, %edi
xorl %esi, %esi
callq 0xc2a9
movl %eax, %r15d
addq $0x2, %rbx
movzbl -0x1(%rbx), %eax
testl %eax, %eax
je 0xc3c9
cmpl $0x2e, %eax
je 0xc3c9
movsbq %al, %rcx
movq (%r12), %rdx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0xc3f3
movsbl %al, %r13d
movl %r15d, %edi
movl %r14d, %esi
callq 0xc4e9
movl %eax, %r15d
addl $-0x30, %r13d
movl %r13d, %edi
xorl %esi, %esi
callq 0xc2a9
movl %r15d, %edi
movl %eax, %esi
callq 0xc57d
movl %eax, %r15d
incq %rbx
jmp 0xc37b
cmpb $0x2e, %al
sete %al
testb %al, %al
je 0xc3f0
movsbq (%rbx), %r12
callq 0x1210
movq %rax, %r14
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r12,2)
jne 0xc404
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xc3f3
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0x30, %r12d
movl %r12d, %edi
xorl %esi, %esi
callq 0xc2a9
movl $0x6499999a, %r12d      # imm = 0x6499999A
movl %eax, %edi
movl $0x6499999a, %esi       # imm = 0x6499999A
callq 0xc4e9
movl %r15d, %edi
movl %eax, %esi
callq 0xc57d
movl %eax, %ebp
movb 0x1(%rbx), %al
testb %al, %al
je 0xc3f3
addq $0x2, %rbx
movq (%r14), %rcx
movsbq %al, %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0xc3e9
movsbl %al, %r15d
movl %r12d, %edi
movl $0x6499999a, %esi       # imm = 0x6499999A
callq 0xc4e9
movl %eax, %r12d
addl $-0x30, %r15d
movl %r15d, %edi
xorl %esi, %esi
callq 0xc2a9
movl %eax, %edi
movl %r12d, %esi
callq 0xc4e9
movl %ebp, %edi
movl %eax, %esi
callq 0xc57d
movl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0xc43b
jmp 0xc3f3
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc4ab
cmpl $0x80, %esi
jge 0xc4ca
xorl $-0x80, %esi
shll $0x18, %esi
orl %edi, %esi
movl %esi, %eax
popq %rcx
retq
leaq 0x6b69(%rip), %rdi      # 0x1301b
leaq 0x5df3(%rip), %rsi      # 0x122ac
leaq 0x6b3c(%rip), %rcx      # 0x12ffc
movl $0x2ce, %edx            # imm = 0x2CE
callq 0x10b0
leaq 0x6b5e(%rip), %rdi      # 0x1302f
leaq 0x5dd4(%rip), %rsi      # 0x122ac
leaq 0x6b1d(%rip), %rcx      # 0x12ffc
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc569
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 0xc56b
movl $0x1, %eax
cmpl $0x68, %edx
jb 0xc56b
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 0xc56c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x7f, %ecx
je 0xc56b
addl $0xffffff19, %edx       # imm = 0xFFFFFF19
shrq $0x19, %rdi
movl %edx, %ecx
jmp 0xc570
xorl %eax, %eax
retq
shrq $0x18, %rdi
andl $0x2ffffff, %edi        # imm = 0x2FFFFFF
movl %ecx, %esi
jmp 0xc48e
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
movl %edi, %eax
cmpl %esi, %edi
movl %esi, %edi
cmovbl %eax, %edi
cmoval %eax, %esi
testl %edi, %edi
je 0xc5d3
movl %esi, %edx
shrl $0x18, %edx
movl %edi, %eax
shrl $0x18, %eax
movl %edx, %ecx
subl %eax, %ecx
jb 0xc5f4
andl $0xffffff, %edi         # imm = 0xFFFFFF
orl $0x1000000, %edi        # imm = 0x1000000
shrl %cl, %edi
testl %edi, %edi
je 0xc5d3
andl $0xffffff, %esi         # imm = 0xFFFFFF
leal -0x80(%rdx), %eax
orl $0x1000000, %esi        # imm = 0x1000000
addl %esi, %edi
cmpl $0x2000000, %edi        # imm = 0x2000000
jb 0xc5de
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x7f, %eax
jne 0xc5d7
movl %esi, %eax
popq %rcx
retq
addl $-0x7f, %edx
shrl %edi
movl %edx, %eax
cmpl $0x2000000, %edi        # imm = 0x2000000
jae 0xc613
andl $0xffffff, %edi         # imm = 0xFFFFFF
movl %eax, %esi
popq %rax
jmp 0xc48e
leaq 0x6a48(%rip), %rdi      # 0x13043
leaq 0x5caa(%rip), %rsi      # 0x122ac
leaq 0x6a43(%rip), %rcx      # 0x1304c
movl $0x304, %edx            # imm = 0x304
callq 0x10b0
leaq 0x6a47(%rip), %rdi      # 0x13061
leaq 0x5c8b(%rip), %rsi      # 0x122ac
leaq 0x6a24(%rip), %rcx      # 0x1304c
movl $0x314, %edx            # imm = 0x314
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc691
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 0xc68a
movq %rbx, %rdi
callq 0xc74b
movq 0xd0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
ja 0xc64a
jmp 0xc691
movq %rax, 0xd0(%rbx)
movl %ebp, 0x28(%rbx)
movq 0xd0(%rbx), %rax
movq 0x250(%rbx), %rcx
movq %rax, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
leaq 0x98(%rbx), %rax
cmpq %rax, %rcx
jne 0xc6cf
cmpl $0x0, 0xc4(%rbx)
je 0xc72c
movl $0x0, 0xc4(%rbx)
movq 0x248(%rbx), %rax
movq %rax, 0x250(%rbx)
cmpl %ebp, 0xf0(%rbx)
jbe 0xc706
movq 0xf8(%rbx), %rax
cmpq 0x100(%rbx), %rax
jae 0xc70d
movl $0x0, 0xf0(%rbx)
movq %rax, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6a54(%rip), %rdi      # 0x13168
leaq 0x5b91(%rip), %rsi      # 0x122ac
leaq 0x6a5c(%rip), %rcx      # 0x1317e
movl $0xc02, %edx            # imm = 0xC02
callq 0x10b0
leaq 0x750a(%rip), %rdi      # 0x13c3d
leaq 0x5b72(%rip), %rsi      # 0x122ac
leaq 0x6abd(%rip), %rcx      # 0x131fe
movl $0x6ab, %edx            # imm = 0x6AB
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: 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 0xc973
cmpq $0x0, 0x1b8(%rdi)
jne 0xc992
movq 0x108(%rdi), %rcx
xorl %eax, %eax
cmpq 0x100(%rdi), %rcx
jb 0xc971
cmpq $0x0, 0x250(%rdi)
jne 0xc9d0
movq 0xd0(%rdi), %rcx
cmpq %rcx, 0xe0(%rdi)
jne 0xc9b1
cmpq %rcx, 0xe8(%rdi)
jne 0xc9b1
movl 0x2c(%rdi), %edx
shlq $0x3, %rdx
addq 0xc8(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
sete %al
popq %rcx
retq
leaq 0x693a(%rip), %rdi      # 0x132b4
leaq 0x592b(%rip), %rsi      # 0x122ac
leaq 0x6a81(%rip), %rcx      # 0x13409
movl $0xd47, %edx            # imm = 0xD47
callq 0x10b0
leaq 0x6a84(%rip), %rdi      # 0x1341d
leaq 0x590c(%rip), %rsi      # 0x122ac
leaq 0x6a62(%rip), %rcx      # 0x13409
movl $0xd48, %edx            # imm = 0xD48
callq 0x10b0
leaq 0x6a8a(%rip), %rdi      # 0x13442
leaq 0x58ed(%rip), %rsi      # 0x122ac
leaq 0x6a43(%rip), %rcx      # 0x13409
movl $0xd4c, %edx            # imm = 0xD4C
callq 0x10b0
leaq 0x6a5d(%rip), %rdi      # 0x13434
leaq 0x58ce(%rip), %rsi      # 0x122ac
leaq 0x6a24(%rip), %rcx      # 0x13409
movl $0xd4b, %edx            # imm = 0xD4B
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rsi), %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0xca2a
leaq (%rsi,%rcx,8), %rcx
addq $0x18, %rcx
addq $0x18, %rsi
movq (%rsi), %rdx
cmpb $0x1, (%rdx)
jne 0xca21
movq 0x40(%rdi), %r8
subl 0x38(%rdi), %edx
shrl %edx
shlq $0x4, %rdx
cmpl $0x0, 0x4(%r8,%rdx)
je 0xca2b
addq $0x8, %rsi
cmpq %rcx, %rsi
jb 0xca04
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rax
subq 0x48(%rdi), %rax
movq %rdx, %r14
movq 0x50(%rdi), %rcx
movl (%rcx,%rax), %ebp
movl 0x4(%rcx,%rax), %r12d
movl %ebp, %edi
movl %r12d, %esi
callq 0xc4e9
movl %eax, %r13d
movl %ebp, %edi
movl %r12d, %esi
callq 0xc57d
movl %eax, %edi
movl $0x5e000000, %esi       # imm = 0x5E000000
callq 0xc4e9
movl %r13d, %edi
movl %eax, %esi
callq 0xc57d
movq %r14, %rcx
subq 0x48(%r15), %rcx
movl %eax, %ebp
movq 0x50(%r15), %rax
movl (%rax,%rcx), %r15d
movl 0x4(%rax,%rcx), %r12d
movl %r15d, %edi
movl %r12d, %esi
callq 0xc4e9
movl %eax, %r13d
movl %r15d, %edi
movl %r12d, %esi
callq 0xc57d
movl %eax, %edi
movl $0x5e000000, %esi       # imm = 0x5E000000
callq 0xc4e9
movl %r13d, %edi
movl %eax, %esi
callq 0xc57d
xorl %ecx, %ecx
cmpl %eax, %ebp
seta %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %ecx, %eax
testl %eax, %eax
jne 0xcef2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdbc3
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
btl $0x1e, %ecx
jb 0xdbdd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x40, 0x7(%rsi)
jne 0xdc01
btl $0x1e, %ecx
jae 0xdbe8
movl $0x1, %eax
testb $0x40, 0x7(%rsi)
je 0xdc01
testl %ecx, %ecx
js 0xdbf6
cmpl $0x0, 0x4(%rsi)
js 0xdc19
testl %ecx, %ecx
jns 0xdc02
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, 0x4(%rsi)
js 0xdc02
retq
movl (%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, (%rdi)
jb 0xdc01
movl $0x1, %eax
ja 0xdc01
subl %edi, %esi
movl %esi, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde0e
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rcx
subq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rsi
movl %ecx, %edi
shrl %edi
shlq $0x4, %rdi
leaq (%rsi,%rdi), %rax
movl 0x28(%r14), %r8d
movl %r8d, 0x4(%rsi,%rdi)
testl %r8d, %r8d
je 0xdc68
cmpl $0x0, 0x408(%r14)
jne 0xdcd4
movl %ecx, %esi
notl %esi
andl $0x1, %esi
testb $0x8, (%rax)
je 0xdcc6
movl 0x488(%r14), %edi
movl $0xd1b71759, %r8d       # imm = 0xD1B71759
imulq %rdi, %r8
shrq $0x2d, %r8
subl %r8d, %edi
movl %edi, 0x488(%r14)
btl $0x2, (%rax)
movl %esi, %r8d
sbbl $0x0, %r8d
je 0xdcc6
addl $0x3e8, %edi            # imm = 0x3E8
movl %edi, 0x488(%r14)
incq 0x468(%r14)
shrl %ecx
cmpl 0x49c(%r14), %ecx
jae 0xdcc6
movl %ecx, 0x49c(%r14)
movl (%rax), %ecx
andl $-0xd, %ecx
leal (%rcx,%rsi,4), %ecx
addl $0x8, %ecx
movw %cx, (%rax)
movb $0x1, (%rbx)
movq 0x38(%r14), %rcx
movq %rbx, %rsi
subq %rcx, %rsi
xorq $0x1, %rsi
movb $-0x1, (%rcx,%rsi)
leaq 0x70(%r14), %rsi
cmpq %rdx, %rsi
je 0xde2d
movq %rdx, 0x8(%rax)
cmpq %rbx, %rcx
jae 0xddef
movl 0x2c(%r14), %eax
addl %eax, %eax
addq %rcx, %rax
incq %rax
cmpq %rbx, %rax
jb 0xddef
movq 0xd0(%r14), %r15
movq 0xd8(%r14), %rdx
cmpq %rdx, %r15
jne 0xddcb
movq 0xc8(%r14), %rsi
cmpq %rdx, %rsi
ja 0xde4c
subq %rsi, %r15
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %rcx      # imm = 0x7FFFFFFF8
andq %rcx, %rdx
movl %eax, %eax
movl $0x1, %ebp
cmovneq %rax, %rbp
movq 0xe0(%r14), %r12
movq 0xe8(%r14), %r13
subq %rsi, %r12
subq %rsi, %r13
leaq (,%rbp,8), %rcx
movq %r14, %rdi
callq 0x4593
movq %rax, 0xc8(%r14)
movabsq $0x7fffffff8, %rdx      # imm = 0x7FFFFFFF8
andq %rdx, %r15
addq %rax, %r15
movq %r15, 0xd0(%r14)
leaq (%rax,%rbp,8), %rcx
movq %rcx, 0xd8(%r14)
andq %rdx, %r12
addq %rax, %r12
movq %r12, 0xe0(%r14)
andq %rdx, %r13
addq %rax, %r13
movq %r13, 0xe8(%r14)
movq 0xd0(%r14), %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 0x5817(%rip), %rdi      # 0x1360d
leaq 0x44af(%rip), %rsi      # 0x122ac
leaq 0x5840(%rip), %rcx      # 0x13644
movl $0x5f5, %edx            # imm = 0x5F5
callq 0x10b0
leaq 0x5f07(%rip), %rdi      # 0x13d1c
leaq 0x4490(%rip), %rsi      # 0x122ac
leaq 0x57a3(%rip), %rcx      # 0x135c6
movl $0x643, %edx            # imm = 0x643
callq 0x10b0
leaq 0x5394(%rip), %rdi      # 0x131c8
leaq 0x4471(%rip), %rsi      # 0x122ac
leaq 0x57a4(%rip), %rcx      # 0x135e6
movl $0x60c, %edx            # imm = 0x60C
callq 0x10b0
leaq 0x5809(%rip), %rdi      # 0x1365c
leaq 0x4452(%rip), %rsi      # 0x122ac
leaq 0x57e3(%rip), %rcx      # 0x13644
movl $0x5fd, %edx            # imm = 0x5FD
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: setcimpl
static Cls *
setcimpl (PS * ps, Lit * a, Lit * b)
{
  assert (!ps->cimplvalid);
  assert (ps->cimpl.size == 2);

  ps->cimpl.lits[0] = a;
  ps->cimpl.lits[1] = b;

  sorttwolits (ps->cimpl.lits);
  ps->cimplvalid = 1;

  return &ps->cimpl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xc4(%rdi)
jne 0xe8cc
movq %rdi, %rbx
cmpl $0x2, 0x98(%rdi)
jne 0xe8eb
leaq 0x98(%rbx), %r14
leaq 0xb0(%rbx), %rdi
movq %rsi, 0xb0(%rbx)
movq %rdx, 0xb8(%rbx)
callq 0xe991
movl $0x1, 0xc4(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5369(%rip), %rdi      # 0x13c3c
leaq 0x39d2(%rip), %rsi      # 0x122ac
leaq 0x536b(%rip), %rcx      # 0x13c4c
movl $0x69c, %edx            # imm = 0x69C
callq 0x10b0
leaq 0x537c(%rip), %rdi      # 0x13c6e
leaq 0x39b3(%rip), %rsi      # 0x122ac
leaq 0x534c(%rip), %rcx      # 0x13c4c
movl $0x69d, %edx            # imm = 0x69D
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: setimpl
static Cls *
setimpl (PS * ps, Lit * a, Lit * b)
{
  assert (!ps->implvalid);
  assert (ps->impl.size == 2);

  ps->impl.lits[0] = a;
  ps->impl.lits[1] = b;

  sorttwolits (ps->impl.lits);
  ps->implvalid = 1;

  return &ps->impl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xc0(%rdi)
jne 0xe953
movq %rdi, %rbx
cmpl $0x2, 0x70(%rdi)
jne 0xe972
leaq 0x70(%rbx), %r14
leaq 0x88(%rbx), %rdi
movq %rsi, 0x88(%rbx)
movq %rdx, 0x90(%rbx)
callq 0xe991
movl $0x1, 0xc0(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4dbe(%rip), %rdi      # 0x13718
leaq 0x394b(%rip), %rsi      # 0x122ac
leaq 0x4dbf(%rip), %rcx      # 0x13727
movl $0x687, %edx            # imm = 0x687
callq 0x10b0
leaq 0x4dcf(%rip), %rdi      # 0x13748
leaq 0x392c(%rip), %rsi      # 0x122ac
leaq 0x4da0(%rip), %rcx      # 0x13727
movl $0x688, %edx            # imm = 0x688
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: sorttwolits
static void
sorttwolits (Lit ** v)
{
  Lit * a = v[0], * b = v[1];

  assert (a != b);

  if (a < b)
    return;

  v[0] = b;
  v[1] = a;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0xe9a7
jb 0xe9a6
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
retq
pushq %rax
leaq 0x4dac(%rip), %rdi      # 0x1375b
leaq 0x38f6(%rip), %rsi      # 0x122ac
leaq 0x4da5(%rip), %rcx      # 0x13762
movl $0x671, %edx            # imm = 0x671
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: add_antecedent
inline static void
add_antecedent (PS * ps, Cls * c)
{
  assert (c);

#ifdef NO_BINARY_CLAUSES
  if (ISLITREASON (c))
    return;

  if (c == &ps->impl)
    return;
#elif defined(STATS) && defined(TRACE)
  ps->antecedents++;
#endif
  if (ps->rhead == ps->eor)
    ENLARGE (ps->resolved, ps->rhead, ps->eor);

  assert (ps->rhead < ps->eor);
  *ps->rhead++ = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xea93
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rdi), %rax
cmpq %rsi, %rax
sete %al
orb %bl, %al
testb $0x1, %al
jne 0xea89
movq 0x2a8(%r14), %r15
movq 0x2b0(%r14), %rdx
cmpq %rdx, %r15
jne 0xea6b
movq 0x2a0(%r14), %rsi
cmpq %rdx, %rsi
ja 0xead1
subq %rsi, %r15
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x2, %rax
movabsq $0x7fffffff8, %r12      # imm = 0x7FFFFFFF8
andq %r12, %rdx
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,8), %rcx
movq %r14, %rdi
callq 0x4593
movq %rax, 0x2a0(%r14)
andq %r12, %r15
addq %rax, %r15
movq %r15, 0x2a8(%r14)
leaq (%rax,%r13,8), %rax
movq %rax, 0x2b0(%r14)
movq 0x2a8(%r14), %rax
cmpq 0x2b0(%r14), %rax
jae 0xeab2
leaq 0x8(%rax), %rcx
movq %rcx, 0x2a8(%r14)
movq %rbx, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2eed(%rip), %rdi      # 0x11987
leaq 0x380b(%rip), %rsi      # 0x122ac
leaq 0x4d48(%rip), %rcx      # 0x137f0
movl $0x6f8, %edx            # imm = 0x6F8
callq 0x10b0
leaq 0x4d74(%rip), %rdi      # 0x1382d
leaq 0x37ec(%rip), %rsi      # 0x122ac
leaq 0x4d29(%rip), %rcx      # 0x137f0
movl $0x706, %edx            # imm = 0x706
callq 0x10b0
leaq 0x4d39(%rip), %rdi      # 0x13811
leaq 0x37cd(%rip), %rsi      # 0x122ac
leaq 0x4d0a(%rip), %rcx      # 0x137f0
movl $0x704, %edx            # imm = 0x704
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: impl2reason
static Cls *
impl2reason (PS * ps, Lit * lit)
{
  Lit * other;
  Cls * res;
  other = ps->impl.lits[0];
  if (lit == other)
    other = ps->impl.lits[1];
  assert (other->val == FALSE);
  res = LIT2REASON (NOTLIT (other));
  resetimpl (ps);
  return res;
}

// Assembly:
pushq %rax
movq 0x88(%rdi), %rax
cmpq %rsi, %rax
jne 0x10232
movq 0x90(%rdi), %rax
cmpb $-0x1, (%rax)
jne 0x1025c
movq 0x38(%rdi), %rcx
subq %rcx, %rax
xorq $0x1, %rax
cmpb $0x1, (%rcx,%rax)
jne 0x1027b
leaq 0x1(,%rax,2), %rax
movl $0x0, 0xc0(%rdi)
popq %rcx
retq
leaq 0x37ca(%rip), %rdi      # 0x13a2d
leaq 0x2042(%rip), %rsi      # 0x122ac
leaq 0x3975(%rip), %rcx      # 0x13be6
movl $0x738, %edx            # imm = 0x738
callq 0x10b0
leaq 0x37bf(%rip), %rdi      # 0x13a41
leaq 0x2023(%rip), %rsi      # 0x122ac
leaq 0x3956(%rip), %rcx      # 0x13be6
movl $0x739, %edx            # imm = 0x739
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: connect_head_tail
static void
connect_head_tail (PS * ps, Lit * lit, Cls * c)
{
  Cls ** s;
  assert (c->size >= 1);
  if (c->size == 2)
    {
#ifdef NO_BINARY_CLAUSES
      lpush (ps, lit, c);
      return;
#else
      s = LIT2IMPLS (lit);
#endif
    }
  else
    s = LIT2HTPS (lit);

  if (c->lits[0] != lit)
    {
      assert (c->size >= 2);
      assert (c->lits[1] == lit);
      c->next[1] = *s;
    }
  else
    c->next[0] = *s;

  *s = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl (%rdx), %edx
cmpl $0x2, %edx
je 0x10305
testl %edx, %edx
je 0x103f1
movq 0x58(%rdi), %rax
movl 0x38(%rdi), %esi
movl %r14d, %ecx
subl %esi, %ecx
cmpq %r14, 0x18(%rbx)
je 0x103d6
cmpl $0x1, %edx
je 0x1042f
movl $0x10, %edx
cmpq %r14, 0x20(%rbx)
je 0x103db
leaq 0x389f(%rip), %rdi      # 0x13b8c
leaq 0x1fb8(%rip), %rsi      # 0x122ac
leaq 0x3859(%rip), %rcx      # 0x13b54
movl $0x80e, %edx            # imm = 0x80E
callq 0x10b0
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
movq 0x18(%rbx), %r13
movq 0x68(%rdi), %rax
movl 0x38(%rdi), %ecx
movl %r14d, %edx
subl %ecx, %edx
shlq $0x4, %rdx
leaq (%rax,%rdx), %r12
movq (%rax,%rdx), %rsi
movq 0x8(%rax,%rdx), %rax
testq %rsi, %rsi
je 0x1038b
movq %rax, %rcx
shrq $0x20, %rcx
movl $0x1, %edx
shll %cl, %edx
cmpl %eax, %edx
jb 0x10410
jne 0x103aa
movl $0x2, %eax
shll %cl, %eax
movl %edx, %edx
shlq $0x3, %rdx
shlq $0x3, %rax
movq %rax, %rcx
callq 0x4593
movq %rax, (%r12)
movq 0x8(%r12), %rax
movl %eax, %ecx
andq %r15, %rax
addq %rax, %rcx
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rcx, %rax
movq %rax, 0x8(%r12)
jmp 0x103aa
testl %eax, %eax
jne 0x1044e
testq %rax, %rax
jne 0x1046d
movl $0x8, %esi
callq 0x9bf6
movq %rax, (%r12)
xorl %eax, %eax
cmpq %r14, %r13
sete %al
movq 0x18(%rbx,%rax,8), %rax
movq (%r12), %rcx
movq 0x8(%r12), %rdx
leal 0x1(%rdx), %esi
andq %rdx, %r15
orq %rsi, %r15
movq %r15, 0x8(%r12)
movl %edx, %edx
movq %rax, (%rcx,%rdx,8)
jmp 0x103e7
movl $0x8, %edx
movq (%rax,%rcx,8), %rsi
movq %rsi, (%rbx,%rdx)
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x374f(%rip), %rdi      # 0x13b47
leaq 0x1ead(%rip), %rsi      # 0x122ac
leaq 0x374e(%rip), %rcx      # 0x13b54
movl $0x7fe, %edx            # imm = 0x7FE
callq 0x10b0
leaq 0x37bb(%rip), %rdi      # 0x13bd2
leaq 0x1e8e(%rip), %rsi      # 0x122ac
leaq 0x3779(%rip), %rcx      # 0x13b9e
movl $0x7ec, %edx            # imm = 0x7EC
callq 0x10b0
leaq 0x3749(%rip), %rdi      # 0x13b7f
leaq 0x1e6f(%rip), %rsi      # 0x122ac
leaq 0x3710(%rip), %rcx      # 0x13b54
movl $0x80d, %edx            # imm = 0x80D
callq 0x10b0
leaq 0x3768(%rip), %rdi      # 0x13bbd
leaq 0x1e50(%rip), %rsi      # 0x122ac
leaq 0x373b(%rip), %rcx      # 0x13b9e
movl $0x7e5, %edx            # imm = 0x7E5
callq 0x10b0
leaq 0x3753(%rip), %rdi      # 0x13bc7
leaq 0x1e31(%rip), %rsi      # 0x122ac
leaq 0x371c(%rip), %rcx      # 0x13b9e
movl $0x7e6, %edx            # imm = 0x7E6
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: incjwh
static void
incjwh (PS * ps, Cls * c)
{
  Lit **p, *lit, ** eol;
  Flt * f, inc, sum;
  unsigned size = 0;
  Var * v;
  Val val;

  eol = end_of_lits (c);

  for (p = c->lits; p < eol; p++)
    {
      lit = *p;
      val = lit->val;

      if (val && ps->LEVEL > 0)
	{
	  v = LIT2VAR (lit);
	  if (v->level > 0)
	    val = UNDEF;
	}

      if (val == TRUE)
	return;

      if (val != FALSE)
	size++;
    }

  inc = base2flt (1, -size);

  for (p = c->lits; p < eol; p++)
    {
      lit = *p;
      f = LIT2JWH (lit);
      sum = addflt (*f, inc);
      *f = sum;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rsi), %r14
movl (%rsi), %r12d
leaq (%rsi,%r12,8), %r15
addq $0x18, %r15
xorl %esi, %esi
testq %r12, %r12
je 0x104f5
movq %r14, %rax
movq (%rax), %rdx
movb (%rdx), %cl
testb %cl, %cl
je 0x104dd
cmpl $0x0, 0x28(%rbx)
je 0x104dd
movq 0x40(%rbx), %rdi
subl 0x38(%rbx), %edx
shrl %edx
shlq $0x4, %rdx
cmpl $0x0, 0x4(%rdi,%rdx)
je 0x104da
xorl %ecx, %ecx
jmp 0x104dd
movzbl %cl, %ecx
cmpb $-0x1, %cl
je 0x104ec
movzbl %cl, %ecx
cmpl $0x1, %ecx
je 0x1055b
incl %esi
addq $0x8, %rax
cmpq %r15, %rax
jb 0x104b3
negl %esi
cmpl $-0x80, %esi
movl $0xffffff80, %ecx       # imm = 0xFFFFFF80
cmovll %esi, %ecx
movl %esi, %eax
subl %ecx, %eax
movl $0x1, %ebp
movl $0x1, %ecx
cmpl $0x18, %eax
jb 0x10531
decl %esi
leal (%rcx,%rcx), %edi
cmpl $0x800000, %ecx         # imm = 0x800000
movl %edi, %ecx
jb 0x10510
andl $0x7efffffe, %edi       # imm = 0x7EFFFFFE
callq 0xc48e
movl %eax, %ebp
testl %r12d, %r12d
je 0x1055b
movq (%r14), %r12
movq 0x50(%rbx), %r13
subq 0x38(%rbx), %r12
movl (%r13,%r12,4), %edi
movl %ebp, %esi
callq 0xc57d
movl %eax, (%r13,%r12,4)
addq $0x8, %r14
cmpq %r15, %r14
jb 0x10536
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: var2reason
static Cls *
var2reason (PS * ps, Var * var)
{
  Cls * res = var->reason;
#ifdef NO_BINARY_CLAUSES
  Lit * this, * other;
  if (ISLITREASON (res))
    {
      this = VAR2LIT (var);
      if (this->val == FALSE)
	this = NOTLIT (this);

      other = REASON2LIT (res);
      assert (other->val == TRUE);
      assert (this->val == TRUE);
      res = setimpl (ps, NOTLIT (other), this);
    }
#else
  (void) ps;
#endif
  return res;
}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rax
testb $0x1, %al
jne 0x10636
popq %rcx
retq
movq %rsi, %rcx
movq 0x38(%rdi), %rsi
subq 0x40(%rdi), %rcx
sarq $0x3, %rcx
leaq (%rsi,%rcx), %r8
movq %rcx, %rdx
xorq $0x1, %rdx
addq %rsi, %rdx
cmpb $-0x1, (%rsi,%rcx)
cmovneq %r8, %rdx
shrq %rax
cmpb $0x1, (%rsi,%rax)
jne 0x10676
cmpb $0x1, (%rdx)
jne 0x10695
xorq $0x1, %rax
addq %rax, %rsi
popq %rax
jmp 0xe90a
leaq 0x37da(%rip), %rdi      # 0x13e57
leaq 0x1c28(%rip), %rsi      # 0x122ac
leaq 0x37df(%rip), %rcx      # 0x13e6a
movl $0xbcc, %edx            # imm = 0xBCC
callq 0x10b0
leaq 0x37eb(%rip), %rdi      # 0x13e87
leaq 0x1c09(%rip), %rsi      # 0x122ac
leaq 0x37c0(%rip), %rcx      # 0x13e6a
movl $0xbcd, %edx            # imm = 0xBCD
callq 0x10b0