LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x408(%rax)
jne 0xd1af
jmp 0xd1ce
leaq 0x1295f(%rip), %rdi     # 0x1fb15
leaq 0x100e7(%rip), %rsi     # 0x1d2a4
movl $0x6d7, %edx            # imm = 0x6D7
leaq 0x1295d(%rip), %rcx     # 0x1fb26
callq 0x10b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jge 0xd1e6
jmp 0xd205
leaq 0x1294f(%rip), %rdi     # 0x1fb3c
leaq 0x100b0(%rip), %rsi     # 0x1d2a4
movl $0x6dc, %edx            # imm = 0x6DC
leaq 0x12926(%rip), %rcx     # 0x1fb26
callq 0x10b0
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x1d0(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x1c8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
jge 0xd22d
jmp 0xd24c
leaq 0x12911(%rip), %rdi     # 0x1fb45
leaq 0x10069(%rip), %rsi     # 0x1d2a4
movl $0x6dd, %edx            # imm = 0x6DD
leaq 0x128df(%rip), %rcx     # 0x1fb26
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0xd267
jmp 0xd286
leaq 0x128f3(%rip), %rdi     # 0x1fb61
leaq 0x1002f(%rip), %rsi     # 0x1d2a4
movl $0x6de, %edx            # imm = 0x6DE
leaq 0x128a5(%rip), %rcx     # 0x1fb26
callq 0x10b0
jmp 0xd288
cmpl $0x1, -0x18(%rbp)
jle 0xd301
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x129a0
cmpl $0x0, %eax
jle 0xd2c7
jmp 0xd301
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl %edx, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xd288
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl %edx, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x6af0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xd3cd
jmp 0xd3ea
jmp 0xd3cf
movq 0x16c22(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x10a05(%rip), %rdi     # 0x1dde5
callq 0x10c0
callq 0x1060
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0xd3fb
jmp 0xd42f
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x0, %eax
je 0xd42f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd440
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rdi
callq 0x4db0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5480
movq -0x8(%rbp), %rdi
callq 0x4910
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_deref_partial
int
picosat_deref_partial (PS * ps, int int_lit) 
{
  check_ready (ps);
  check_sat_state (ps);
  ABORTIF (!int_lit, "API usage: can not partial deref zero literal");
  ABORTIF (ps->mtcls, "API usage: deref partial after empty clause generated");
  ABORTIF (!ps->saveorig, "API usage: 'picosat_save_original_clauses' missing");

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

  if (!ps->partial)
    minautarky (ps);

  return pderef (ps, int_lit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
callq 0x7eb0
cmpl $0x0, -0xc(%rbp)
je 0xd739
jmp 0xd756
jmp 0xd73b
movq 0x168b6(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x10717(%rip), %rdi     # 0x1de63
callq 0x10c0
callq 0x1060
jmp 0xd758
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
jne 0xd768
jmp 0xd785
jmp 0xd76a
movq 0x16887(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x10724(%rip), %rdi     # 0x1de9f
callq 0x10c0
callq 0x1060
jmp 0xd787
movq -0x8(%rbp), %rax
cmpl $0x0, 0x228(%rax)
je 0xd796
jmp 0xd7b3
jmp 0xd798
movq 0x16859(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x1073a(%rip), %rdi     # 0x1dee3
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rax
cmpl $0x0, 0x22c(%rax)
jne 0xd7c9
movq -0x8(%rbp), %rdi
callq 0xd7e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xdbe0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jg 0xdc04
jmp 0xdc23
leaq 0x11c10(%rip), %rdi     # 0x1f81b
leaq 0xf692(%rip), %rsi      # 0x1d2a4
movl $0x1b40, %edx           # imm = 0x1B40
leaq 0x1201c(%rip), %rcx     # 0x1fc3a
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw $0xd, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xdc63
movl $0x0, -0x4(%rbp)
jmp 0xdca4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ef0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0xdc88
movl $0x1, -0x4(%rbp)
jmp 0xdca4
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0xdc9d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdca4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: dumpcls
static void
dumpcls (PS * ps, Cls * c)
{
  Lit **end;

  if (c)
    {
      end = end_of_lits (c);
      dumplits (ps, c->lits, end);
#ifdef TRACE
      if (ps->trace)
	 fprintf (ps->out, " clause(%u)", CLS2IDX (c));
#endif
    }
  else
    fputs ("DECISION", ps->out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdceb
movq -0x10(%rbp), %rdi
callq 0xb980
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
callq 0xdd10
jmp 0xdcff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x1022a(%rip), %rdi     # 0x1df24
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xdfed
movl $0x0, -0x4(%rbp)
jmp 0xe06b
cmpl $0x1000000, -0x8(%rbp)  # imm = 0x1000000
jae 0xe023
jmp 0xdff8
cmpl $-0x80, -0xc(%rbp)
jg 0xe007
movl $0x1, -0x4(%rbp)
jmp 0xe06b
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0x8(%rbp)
cmpl $0x1000000, -0x8(%rbp)  # imm = 0x1000000
jb 0xdff8
jmp 0xe052
jmp 0xe025
cmpl $0x2000000, -0x8(%rbp)  # imm = 0x2000000
jb 0xe050
cmpl $0x7f, -0xc(%rbp)
jl 0xe03d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe06b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
jmp 0xe025
jmp 0xe052
movl -0x8(%rbp), %eax
andl $0xfeffffff, %eax       # imm = 0xFEFFFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xe2a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x1000000, -0x4(%rbp)  # imm = 0x1000000
jae 0xe2b9
jmp 0xe2d8
leaq 0xfd3d(%rip), %rdi      # 0x1dffd
leaq 0xefdd(%rip), %rsi      # 0x1d2a4
movl $0x2cd, %edx            # imm = 0x2CD
leaq 0xfd35(%rip), %rcx      # 0x1e008
callq 0x10b0
movl $0xffffff80, %eax       # imm = 0xFFFFFF80
cmpl -0x8(%rbp), %eax
jg 0xe2e4
jmp 0xe303
leaq 0xfd3c(%rip), %rdi      # 0x1e027
leaq 0xefb2(%rip), %rsi      # 0x1d2a4
movl $0x2ce, %edx            # imm = 0x2CE
leaq 0xfd0a(%rip), %rcx      # 0x1e008
callq 0x10b0
cmpl $0x7f, -0x8(%rbp)
jg 0xe30b
jmp 0xe32a
leaq 0xfd29(%rip), %rdi      # 0x1e03b
leaq 0xef8b(%rip), %rsi      # 0x1d2a4
movl $0x2cf, %edx            # imm = 0x2CF
leaq 0xfce3(%rip), %rcx      # 0x1e008
callq 0x10b0
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
addl $0x80, %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0xe528
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xe52a
cmpl $0x0, -0xc(%rbp)
jne 0xe53b
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe64b
jmp 0xe53d
movl -0x8(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
shrl $0x18, %eax
subl $0x80, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, -0x10(%rbp)
jmp 0xe563
movl -0xc(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
subl $0x80, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0xe591
jmp 0xe5b0
leaq 0xfaea(%rip), %rdi      # 0x1e082
leaq 0xed05(%rip), %rsi      # 0x1d2a4
movl $0x304, %edx            # imm = 0x304
leaq 0xfae0(%rip), %rcx      # 0x1e08b
callq 0x10b0
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xe5d2
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe64b
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x2000000, %eax        # imm = 0x2000000
cmpl $0x0, %eax
je 0xe608
cmpl $0x7f, -0x1c(%rbp)
jne 0xe5f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe64b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
cmpl $0x2000000, -0x10(%rbp) # imm = 0x2000000
jae 0xe613
jmp 0xe632
leaq 0xfa86(%rip), %rdi      # 0x1e0a0
leaq 0xec83(%rip), %rsi      # 0x1d2a4
movl $0x314, %edx            # imm = 0x314
leaq 0xfa5e(%rip), %rcx      # 0x1e08b
callq 0x10b0
movl -0x10(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0xe2a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: fix_clause_lits
static void
fix_clause_lits (PS * ps, long delta)
{
  Cls **p, *clause;
  Lit **q, *lit, **eol;

  for (p = SOC; p != EOC; p = NXC (p))
    {
      clause = *p;
      if (!clause)
	continue;

      q = clause->lits;
      eol = end_of_lits (clause);
      while (q < eol)
	{
	  assert (q - clause->lits <= (int) clause->size);
	  lit = *q;
	  lit += delta;
	  *q++ = lit;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jne 0xe6e9
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xe6f8
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x200(%rcx), %rax
je 0xe7ff
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe72c
jmp 0xe7c0
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb980
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xe7be
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jg 0xe770
jmp 0xe78f
leaq 0xf970(%rip), %rdi      # 0x1e0e7
leaq 0xeb26(%rip), %rsi      # 0x1d2a4
movl $0xb02, %edx            # imm = 0xB02
leaq 0xf984(%rip), %rcx      # 0x1e10e
callq 0x10b0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x28(%rbp)
movq %rcx, (%rax)
jmp 0xe745
jmp 0xe7c0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jne 0xe7e6
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe7f2
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xe700
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: fix_impl_lits
static void
fix_impl_lits (PS * ps, long delta)
{
  Ltk * s;
  Lit ** p;

  for (s = ps->impls + 2; s <= ps->impls + 2 * ps->max_var + 1; s++)
    for (p = s->start; p < s->start + s->count; p++)
      *p += delta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x2c(%rdx), %edx
shll %edx
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
ja 0xe9a8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rsi
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq 0x8(%rsi), %rdx
movl %edx, %edx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xe995
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0xe94e
jmp 0xe997
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0xe91c
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xc8(%rcx), %rax
jbe 0xeab4
movq -0x8(%rbp), %rcx
movq 0xd0(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0xd0(%rcx)
movq -0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xeaa2
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0xd0(%rax)
jmp 0xeab4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed30
jmp 0xea1f
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe8(%rax)
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x98, %rcx
cmpq %rcx, %rax
jne 0xeb0e
movq -0x8(%rbp), %rdi
callq 0xec70
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x250(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf0(%rcx), %eax
jae 0xeb94
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0xeb51
jmp 0xeb70
leaq 0xf64f(%rip), %rdi      # 0x1e1a7
leaq 0xe745(%rip), %rsi      # 0x1d2a4
movl $0xc02, %edx            # imm = 0xC02
leaq 0xf652(%rip), %rcx      # 0x1e1bd
callq 0x10b0
movq -0x8(%rbp), %rax
movl $0x0, 0xf0(%rax)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x108(%rax)
jmp 0xeb96
jmp 0xeb98
addq $0x20, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: reset_assumptions
static void
reset_assumptions (PS * ps)
{
  Lit ** p;

  ps->failed_assumption = 0;

  if (ps->extracted_all_failed_assumptions)
    {
      for (p = ps->als; p < ps->alshead; p++)
	LIT2VAR (*p)->failed = 0;

      ps->extracted_all_failed_assumptions = 0;
    }

  ps->alstail = ps->alshead = ps->als;
  ps->adecidelevel = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x1b8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c0(%rax)
je 0xec33
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0xec25
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %cx
andw $-0x21, %cx
orw $0x0, %cx
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xebd3
movq -0x8(%rbp), %rax
movl $0x0, 0x1c0(%rax)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xf0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: reset_partial
static void
reset_partial (PS * ps)
{
  unsigned idx;
  if (!ps->partial)
    return;
  for (idx = 1; idx <= ps->max_var; idx++)
    ps->vars[idx].partial = 0;
  ps->partial = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x22c(%rax)
jne 0xecd7
jmp 0xed24
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
ja 0xed16
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %cx
andw $0xdfff, %cx            # imm = 0xDFFF
orw $0x0, %cx
movw %cx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xecde
movq -0x8(%rbp), %rax
movl $0x0, 0x22c(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x248(%rax)
jne 0xf06c
jmp 0xf08b
leaq 0xf280(%rip), %rdi      # 0x1e2f3
leaq 0xe22a(%rip), %rsi      # 0x1d2a4
movl $0xd47, %edx            # imm = 0xD47
leaq 0xf3c2(%rip), %rcx      # 0x1e448
callq 0x10b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
jne 0xf09b
jmp 0xf0ba
leaq 0xf3ba(%rip), %rdi      # 0x1e45c
leaq 0xe1fb(%rip), %rsi      # 0x1d2a4
movl $0xd48, %edx            # imm = 0xD48
leaq 0xf393(%rip), %rcx      # 0x1e448
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0xf0de
movl $0x0, -0x4(%rbp)
jmp 0xf16e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x250(%rax)
jne 0xf0ee
jmp 0xf10d
leaq 0xf37e(%rip), %rdi      # 0x1e473
leaq 0xe1a8(%rip), %rsi      # 0x1d2a4
movl $0xd4b, %edx            # imm = 0xD4B
leaq 0xf340(%rip), %rcx      # 0x1e448
callq 0x10b0
movq -0x10(%rbp), %rdi
callq 0x12590
cmpl $0x0, %eax
je 0xf11d
jmp 0xf13c
leaq 0xf35d(%rip), %rdi      # 0x1e481
leaq 0xe179(%rip), %rsi      # 0x1d2a4
movl $0xd4c, %edx            # imm = 0xD4C
leaq 0xf311(%rip), %rcx      # 0x1e448
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xc8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x2c(%rdx), %edx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb980
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x11f65
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x11f55
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x11f53
movl $0x1, -0x4(%rbp)
jmp 0x11f6c
jmp 0x11f55
jmp 0x11f57
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x11ef9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: bcp_queue_is_empty
static int
bcp_queue_is_empty (PS * ps)
{
  if (ps->ttail != ps->thead)
    return 0;

  if (ps->ttail2 != ps->thead)
    return 0;

#ifndef NADC
  if (ps->ttailado != ps->thead)
    return 0;
#endif

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xd0(%rcx), %rax
je 0x125b9
movl $0x0, -0x4(%rbp)
jmp 0x125e1
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xd0(%rcx), %rax
je 0x125da
movl $0x0, -0x4(%rbp)
jmp 0x125e1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12890
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12890
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x12960
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x12642
xorl %eax, %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12656
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12660
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assign_decision
inline static void
assign_decision (PS * ps, Lit * lit)
{
  assert (!ps->conflict);

  ps->LEVEL++;

  LOG ( fprintf (ps->out, "%snew level %u\n", ps->prefix, ps->LEVEL));
  LOG ( fprintf (ps->out,
		 "%sassign %d at level %d <= DECISION\n",
		 ps->prefix, LIT2INT (lit), ps->LEVEL));

  assign (ps, lit, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
jne 0x12700
jmp 0x1271f
leaq 0xbd6c(%rip), %rdi      # 0x1e473
leaq 0xab96(%rip), %rsi      # 0x1d2a4
movl $0x1342, %edx           # imm = 0x1342
leaq 0xbec9(%rip), %rcx      # 0x1e5e3
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x1272e
jmp 0x12730
jmp 0x12732
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12ad0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x48(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0xe350
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0xe500
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movl $0x1, %edi
movl $0xfffffff6, %esi       # imm = 0xFFFFFFF6
callq 0xdfd0
movl -0x34(%rbp), %edi
movl %eax, %esi
callq 0xe350
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xe500
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: cmpflt
static int
cmpflt (Flt a, Flt b)
{
  if (a < b)
    return -1;

  if (a > b)
    return 1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1297b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12993
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x1298c
movl $0x1, -0x4(%rbp)
jmp 0x12993
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x129e0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x129e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12aa6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12a10
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x12a10
movl $0x1, -0x4(%rbp)
jmp 0x12aa6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x12a37
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x12a37
movl $0x1, -0x4(%rbp)
jmp 0x12aa6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x12a5e
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x12a5e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12aa6
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x12a75
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12aa6
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x12a8c
movl $0x1, -0x4(%rbp)
jmp 0x12aa6
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x12ab0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shrl %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x12b18
jmp 0x12b37
leaq 0xc28c(%rip), %rdi      # 0x1edab
leaq 0xa77e(%rip), %rsi      # 0x1d2a4
movl $0x643, %edx            # imm = 0x643
leaq 0xbad3(%rip), %rcx      # 0x1e605
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12b80
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12d20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12d80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: bcp
static void
bcp (PS * ps)
{
  int props = 0;
  assert (!ps->conflict);

  if (ps->mtcls)
    return;

  for (;;)
    {
      if (ps->ttail2 < ps->thead)	/* prioritize implications */
	{
	  props++;
	  prop2 (ps, NOTLIT (*ps->ttail2++));
	}
      else if (ps->ttail < ps->thead)	/* unit clauses or clauses with length > 2 */
	{
	  if (ps->conflict) break;
	  propl (ps, NOTLIT (*ps->ttail++));
	  if (ps->conflict) break;
	}
#ifndef NADC
      else if (ps->ttailado < ps->thead)
	{
	  if (ps->conflict) break;
	  propado (ps, LIT2VAR (*ps->ttailado++));
	  if (ps->conflict) break;
	}
#endif
      else
	break;		/* all assignments propagated, so break */
    }

  ps->propagations += props;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
jne 0x12ff3
jmp 0x13012
leaq 0xb479(%rip), %rdi      # 0x1e473
leaq 0xa2a3(%rip), %rsi      # 0x1d2a4
movl $0x10c7, %edx           # imm = 0x10C7
leaq 0xb6a7(%rip), %rcx      # 0x1e6b4
callq 0x10b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
je 0x13025
jmp 0x13121
jmp 0x13027
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xd0(%rcx), %rax
jae 0x13089
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rcx
movq 0xe8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0xe8(%rcx)
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
xorq $0x1, %rax
addq %rax, %rsi
callq 0x13130
jmp 0x13106
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xd0(%rcx), %rax
jae 0x13102
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
je 0x130b1
jmp 0x1310b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0xe0(%rcx)
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
xorq $0x1, %rax
addq %rax, %rsi
callq 0x13300
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
je 0x13100
jmp 0x1310b
jmp 0x13104
jmp 0x1310b
jmp 0x13106
jmp 0x13027
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x3d8(%rax), %rcx
movq %rcx, 0x3d8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc4(%rax)
jne 0x13af3
jmp 0x13b12
leaq 0xb1b4(%rip), %rdi      # 0x1ecae
leaq 0x97a3(%rip), %rsi      # 0x1d2a4
movl $0x69c, %edx            # imm = 0x69C
leaq 0xb1b1(%rip), %rcx      # 0x1ecbe
callq 0x10b0
movq -0x8(%rbp), %rax
cmpl $0x2, 0x98(%rax)
jne 0x13b21
jmp 0x13b40
leaq 0xb1b8(%rip), %rdi      # 0x1ece0
leaq 0x9775(%rip), %rsi      # 0x1d2a4
movl $0x69d, %edx            # imm = 0x69D
leaq 0xb183(%rip), %rcx      # 0x1ecbe
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
addq $0x18, %rdi
callq 0x13fe0
movq -0x8(%rbp), %rax
movl $0x1, 0xc4(%rax)
movq -0x8(%rbp), %rax
addq $0x98, %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc0(%rax)
jne 0x13bb3
jmp 0x13bd2
leaq 0xab9d(%rip), %rdi      # 0x1e757
leaq 0x96e3(%rip), %rsi      # 0x1d2a4
movl $0x687, %edx            # imm = 0x687
leaq 0xab99(%rip), %rcx      # 0x1e766
callq 0x10b0
movq -0x8(%rbp), %rax
cmpl $0x2, 0x70(%rax)
jne 0x13bde
jmp 0x13bfd
leaq 0xaba2(%rip), %rdi      # 0x1e787
leaq 0x96b8(%rip), %rsi      # 0x1d2a4
movl $0x688, %edx            # imm = 0x688
leaq 0xab6e(%rip), %rcx      # 0x1e766
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
addq $0x18, %rdi
callq 0x13fe0
movq -0x8(%rbp), %rax
movl $0x1, 0xc0(%rax)
movq -0x8(%rbp), %rax
addq $0x70, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: use_var
static void
use_var (PS * ps, Var * v)
{
  if (v->used)
    return;

  v->used = 1;
  ps->vused++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x13c75
jmp 0x13c9a
movq -0x10(%rbp), %rax
movw (%rax), %cx
andw $-0x11, %cx
orw $0x10, %cx
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movl 0x44c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44c(%rax)
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: fixvar
static void
fixvar (PS * ps, Var * v)
{
  Rnk * r;

  assert (VAR2LIT (v) != UNDEF);
  assert (!v->level);

  ps->fixed++;

  r = VAR2RNK (v);
  r->score = INFFLT;

#ifndef NFL
  if (ps->simplifying)
    return;
#endif

  if (!r->pos)
    return;

  hup (ps, r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shlq %rcx
addq %rcx, %rax
cmpq $0x0, %rax
je 0x13f19
jmp 0x13f38
leaq 0xad56(%rip), %rdi      # 0x1ec76
leaq 0x937d(%rip), %rsi      # 0x1d2a4
movl $0x780, %edx            # imm = 0x780
leaq 0xad58(%rip), %rcx      # 0x1ec8b
callq 0x10b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x13f44
jmp 0x13f63
leaq 0xad59(%rip), %rdi      # 0x1eca4
leaq 0x9352(%rip), %rsi      # 0x1d2a4
movl $0x781, %edx            # imm = 0x781
leaq 0xad2d(%rip), %rcx      # 0x1ec8b
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x3e8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3e8(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpl $0x0, 0x408(%rax)
je 0x13fb5
jmp 0x13fd5
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x0, %eax
jne 0x13fc8
jmp 0x13fd5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x1400f
jmp 0x1402e
leaq 0xa784(%rip), %rdi      # 0x1e79a
leaq 0x9287(%rip), %rsi      # 0x1d2a4
movl $0x671, %edx            # imm = 0x671
leaq 0xa778(%rip), %rcx      # 0x1e7a1
callq 0x10b0
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1403a
jmp 0x14051
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14079
jmp 0x14098
leaq 0x8907(%rip), %rdi      # 0x1c987
leaq 0x921d(%rip), %rsi      # 0x1d2a4
movl $0x6f8, %edx            # imm = 0x6F8
leaq 0xa79c(%rip), %rcx      # 0x1e82f
callq 0x10b0
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x140ab
jmp 0x1425a
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x70, %rcx
cmpq %rcx, %rax
jne 0x140c1
jmp 0x1425a
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2b0(%rcx), %rax
jne 0x14201
jmp 0x140df
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1410f
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0x14119
movl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14119
movl -0x3c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2b0(%rcx), %rax
ja 0x1415c
jmp 0x1417b
leaq 0xa6ed(%rip), %rdi      # 0x1e850
leaq 0x913a(%rip), %rsi      # 0x1d2a4
movl $0x704, %edx            # imm = 0x704
leaq 0xa6b9(%rip), %rcx      # 0x1e82f
callq 0x10b0
jmp 0x1417d
movl -0x14(%rbp), %eax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4f30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2a0(%rax)
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rcx
movl -0x24(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2a8(%rax)
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rcx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
jmp 0x14201
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2b0(%rcx), %rax
jae 0x1421b
jmp 0x1423a
leaq 0xa64a(%rip), %rdi      # 0x1e86c
leaq 0x907b(%rip), %rsi      # 0x1d2a4
movl $0x706, %edx            # imm = 0x706
leaq 0xa5fa(%rip), %rcx      # 0x1e82f
callq 0x10b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x2a8(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x2a8(%rdx)
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x15748
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x15756
jmp 0x15775
leaq 0x9327(%rip), %rdi      # 0x1ea84
leaq 0x7b40(%rip), %rsi      # 0x1d2a4
movl $0x738, %edx            # imm = 0x738
leaq 0x94e8(%rip), %rcx      # 0x1ec58
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
xorq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x1579b
jmp 0x157ba
leaq 0x92f6(%rip), %rdi      # 0x1ea98
leaq 0x7afb(%rip), %rsi      # 0x1d2a4
movl $0x739, %edx            # imm = 0x739
leaq 0x94a3(%rip), %rcx      # 0x1ec58
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
xorq $0x1, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13ec0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)