LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: new_clause
static Cls *
new_clause (PS * ps, unsigned size, unsigned learned)
{
  size_t bytes;
  void * tmp;
#ifdef TRACE
  Trd *trd;
#endif
  Cls *res;

  bytes = bytes_clause (ps, size, learned);
  tmp = new (ps, bytes);

#ifdef TRACE
  if (ps->trace)
    {
      trd = tmp;

      if (learned)
	trd->idx = LIDX2IDX (ps->lhead - ps->lclauses);
      else
	trd->idx = OIDX2IDX (ps->ohead - ps->oclauses);

      res = trd->cls;
    }
  else
#endif
    res = tmp;

  res->size = size;
  res->learned = learned;

  res->collect = 0;
#ifndef NDEBUG
  res->connected = 0;
#endif
  res->locked = 0;
  res->used = 0;
#ifdef TRACE
  res->core = 0;
  res->collected = 0;
#endif

  if (learned && size > 2)
    {
      Act * p = CLS2ACT (res);
      *p = ps->cinc;
    }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x167d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9900
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x1, %edx
shll %edx
andl $-0x3, %ecx
orl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $-0x11, %ecx
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $-0x5, %ecx
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $-0x9, %ecx
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x16327
cmpl $0x2, -0xc(%rbp)
jbe 0x16327
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x162b5
jmp 0x162d4
leaq 0x8892(%rip), %rdi      # 0x1eb4e
leaq 0x6fe1(%rip), %rsi      # 0x1d2a4
movl $0x534, %edx            # imm = 0x534
leaq 0x888e(%rip), %rcx      # 0x1eb5d
callq 0x10b0
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0x162df
jmp 0x162fe
leaq 0x88a9(%rip), %rdi      # 0x1eb8f
leaq 0x6fb7(%rip), %rsi      # 0x1d2a4
movl $0x534, %edx            # imm = 0x534
leaq 0x8864(%rip), %rcx      # 0x1eb5d
callq 0x10b0
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x310(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: write_rup_header
static void
write_rup_header (PS * ps, FILE * file)
{
  char line[80];
  int i;

  sprintf (line, "%%RUPD32 %u %u", ps->rupvariables, ps->rupclauses);

  fputs (line, file);
  for (i = 255 - strlen (line); i >= 0; i--)
    fputc (' ', file);

  fputc ('\n', file);
  fflush (file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x23c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x240(%rax), %ecx
leaq 0x882e(%rip), %rsi      # 0x1eb9d
movb $0x0, %al
callq 0x11d0
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
leaq -0x60(%rbp), %rdi
callq 0x1090
movq %rax, %rcx
movl $0xff, %eax
subq %rcx, %rax
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
jl 0x163b9
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x10f0
movl -0x64(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x1639a
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x1160
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jb 0x163ff
jmp 0x1641e
leaq 0x87a6(%rip), %rdi      # 0x1ebac
leaq 0x6e97(%rip), %rsi      # 0x1d2a4
movl $0x7fe, %edx            # imm = 0x7FE
leaq 0x87a0(%rip), %rcx      # 0x1ebb9
callq 0x10b0
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x1643d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16820
jmp 0x164f3
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x164d9
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jb 0x1647a
jmp 0x16499
leaq 0x8763(%rip), %rdi      # 0x1ebe4
leaq 0x6e1c(%rip), %rsi      # 0x1d2a4
movl $0x80d, %edx            # imm = 0x80D
leaq 0x8725(%rip), %rcx      # 0x1ebb9
callq 0x10b0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x164a9
jmp 0x164c8
leaq 0x8741(%rip), %rdi      # 0x1ebf1
leaq 0x6ded(%rip), %rsi      # 0x1d2a4
movl $0x80e, %edx            # imm = 0x80E
leaq 0x86f6(%rip), %rcx      # 0x1ebb9
callq 0x10b0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x164e8
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb980
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x165ce
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x49(%rbp)
movsbl -0x49(%rbp), %eax
cmpl $0x0, %eax
je 0x1659b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jbe 0x1659b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%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, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x16599
movb $0x0, -0x49(%rbp)
jmp 0x1659b
movsbl -0x49(%rbp), %eax
cmpl $0x1, %eax
jne 0x165a9
jmp 0x1664b
movsbl -0x49(%rbp), %eax
cmpl $-0x1, %eax
je 0x165bb
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x165bd
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x16530
xorl %esi, %esi
subl -0x3c(%rbp), %esi
movl $0x1, %edi
callq 0xdfd0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1664b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movl -0x34(%rbp), %esi
callq 0xe500
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x165ec
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: cmp_added
inline static int
cmp_added (PS * ps, Lit * k, Lit * l)
{
  Val a = k->val, b = l->val;
  Var *u, *v;
  int res;

  if (a == UNDEF && b != UNDEF)
    return -1;

  if (a != UNDEF && b == UNDEF)
    return 1;

  u = LIT2VAR (k);
  v = LIT2VAR (l);

  if (a != UNDEF)
    {
      assert (b != UNDEF);
      res = v->level - u->level;
      if (res)
	return res;		/* larger level first */
    }

  res = cmpflt (VAR2RNK (u)->score, VAR2RNK (v)->score);
  if (res)
    return res;			/* smaller activity first */

  return u - v;			/* smaller index first */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x22(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x166a4
movsbl -0x22(%rbp), %eax
cmpl $0x0, %eax
je 0x166a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x167c6
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x166c2
movsbl -0x22(%rbp), %eax
cmpl $0x0, %eax
jne 0x166c2
movl $0x1, -0x4(%rbp)
jmp 0x167c6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%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, -0x30(%rbp)
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)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x16762
movsbl -0x22(%rbp), %eax
cmpl $0x0, %eax
je 0x16722
jmp 0x16741
leaq 0x83f8(%rip), %rdi      # 0x1eb21
leaq 0x6b74(%rip), %rsi      # 0x1d2a4
movl $0x65f, %edx            # imm = 0x65F
leaq 0x83f0(%rip), %rcx      # 0x1eb2c
callq 0x10b0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x30(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x16760
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x167c6
jmp 0x16762
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movl (%rax,%rcx,8), %edi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq 0x40(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movl (%rax,%rcx,8), %esi
callq 0x12960
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x167b4
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x167c6
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: bytes_clause
static size_t
bytes_clause (PS * ps, unsigned size, unsigned learned)
{
  size_t res;

  res = sizeof (Cls);
  res += size * sizeof (Lit *);
  res -= 2 * sizeof (Lit *);

  if (learned && size > 2)
    res += sizeof (Act);	/* add activity */

#ifdef TRACE
  if (ps->trace)
    res += sizeof (Trd);	/* add trace data */
#else
  (void) ps;
#endif

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x28, -0x18(%rbp)
movl -0xc(%rbp), %eax
shlq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x10, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x16819
cmpl $0x2, -0xc(%rbp)
jbe 0x16819
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: should_disconnect_head_tail
static int
should_disconnect_head_tail (PS * ps, Lit * lit)
{
  unsigned litlevel;
  Var * v;

  assert (lit->val == TRUE);

  v = LIT2VAR (lit);
  litlevel = v->level;

  if (!litlevel)
    return 1;

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

  return litlevel < ps->LEVEL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x16a9e
jmp 0x16abd
leaq 0x7736(%rip), %rdi      # 0x1e1db
leaq 0x67f8(%rip), %rsi      # 0x1d2a4
movl $0xf7b, %edx            # imm = 0xF7B
leaq 0x8305(%rip), %rcx      # 0x1edbd
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%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, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x16afc
movl $0x1, -0x4(%rbp)
jmp 0x16b27
movq -0x10(%rbp), %rax
cmpl $0x0, 0x408(%rax)
je 0x16b12
movl $0x0, -0x4(%rbp)
jmp 0x16b27
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: drive
static unsigned
drive (PS * ps)
{
  unsigned res, vlevel;
  Lit **p;
  Var *v;

  res = 0;
  for (p = ps->added; p < ps->ahead; p++)
    {
      v = LIT2VAR (*p);
      vlevel = v->level;
      assert (vlevel <= ps->LEVEL);
      if (vlevel < ps->LEVEL && vlevel > res)
	res = vlevel;
    }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x260(%rcx), %rax
jae 0x17734
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%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
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
ja 0x176e8
jmp 0x17707
leaq 0x7911(%rip), %rdi      # 0x1f000
leaq 0x5bae(%rip), %rsi      # 0x1d2a4
movl $0x10f4, %edx           # imm = 0x10F4
leaq 0x7912(%rip), %rcx      # 0x1f014
callq 0x10b0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x17721
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x17721
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x17723
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x17692
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: inc_activity
static void
inc_activity (PS * ps, Cls * c)
{
  Act *p;

  if (!c->learned)
    return;

  if (c->size <= 2)
    return;

  p = CLS2ACT (c);
  *p = addflt (*p, ps->cinc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x179b6
jmp 0x17a56
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
ja 0x179c4
jmp 0x17a56
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x179d7
jmp 0x179f6
leaq 0x74b9(%rip), %rdi      # 0x1ee97
leaq 0x58bf(%rip), %rsi      # 0x1d2a4
movl $0xd88, %edx            # imm = 0xD88
leaq 0x74b3(%rip), %rcx      # 0x1eea4
callq 0x10b0
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0x17a01
jmp 0x17a20
leaq 0x74bb(%rip), %rdi      # 0x1eec3
leaq 0x5895(%rip), %rsi      # 0x1d2a4
movl $0xd88, %edx            # imm = 0xD88
leaq 0x7489(%rip), %rcx      # 0x1eea4
callq 0x10b0
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movl 0x310(%rax), %esi
callq 0xe500
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: inc_score
static void
inc_score (PS * ps, Var * v)
{
  Flt score;
  Rnk *r;

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

  if (!v->level)
    return;

  if (v->internal)
    return;

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

  assert (score != INFFLT);

  score = addflt (score, ps->vinc);
  assert (score < INFFLT);
  r->score = score;
  if (r->pos > 0)
    hup (ps, r);

  if (score > ps->lscore)
    vrescore (ps);
}

// 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)
je 0x17a82
jmp 0x17b7e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x17a91
jmp 0x17b7e
movq -0x10(%rbp), %rax
movw (%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x17aad
jmp 0x17b7e
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, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x17ae4
jmp 0x17b03
leaq 0x73e4(%rip), %rdi      # 0x1eecf
leaq 0x57b2(%rip), %rsi      # 0x1d2a4
movl $0xd71, %edx            # imm = 0xD71
leaq 0x73e1(%rip), %rcx      # 0x1eedf
callq 0x10b0
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x300(%rax), %esi
callq 0xe500
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jae 0x17b20
jmp 0x17b3f
leaq 0x73d4(%rip), %rdi      # 0x1eefb
leaq 0x5776(%rip), %rsi      # 0x1d2a4
movl $0xd74, %edx            # imm = 0xD74
leaq 0x73a5(%rip), %rcx      # 0x1eedf
callq 0x10b0
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x0, %eax
jle 0x17b66
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd190
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x304(%rcx), %eax
jbe 0x17b7e
movq -0x8(%rbp), %rdi
callq 0x180c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x17e50
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
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x17db1
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
xorq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17dd5
jmp 0x17df4
leaq 0x716d(%rip), %rdi      # 0x1ef49
leaq 0x54c1(%rip), %rsi      # 0x1d2a4
movl $0xbcc, %edx            # imm = 0xBCC
leaq 0x716d(%rip), %rcx      # 0x1ef5c
callq 0x10b0
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x17e02
jmp 0x17e21
leaq 0x7170(%rip), %rdi      # 0x1ef79
leaq 0x5494(%rip), %rsi      # 0x1d2a4
movl $0xbcd, %edx            # imm = 0xBCD
leaq 0x7140(%rip), %rcx      # 0x1ef5c
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
xorq $0x1, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x13b90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: vrescore
static void
vrescore (PS * ps)
{
  Rnk *p, *eor = ps->rnks + ps->max_var;
  for (p = ps->rnks + 1; p <= eor; p++)
    if (p->score != INFFLT)
      p->score = mulflt (p->score, ps->ilvinc);
  ps->vinc = mulflt (ps->vinc, ps->ilvinc);;
#ifdef VISCORES
  ps->nvinc = mulflt (ps->nvinc, ps->lscore);;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x2c(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x18136
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x18126
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movl 0x308(%rax), %esi
callq 0xe350
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x18128
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x180f6
movq -0x8(%rbp), %rax
movl 0x300(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x308(%rax), %esi
callq 0xe350
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x300(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: collect_clause
static int
collect_clause (PS * ps, Cls * c)
{
  assert (c->collect);
  c->collect = 0;

#ifdef TRACE
  assert (!c->collected);
  c->collected = 1;
#endif
  disconnect_clause (ps, c);

#ifdef TRACE
  if (ps->trace && (!c->learned || c->used))
    return 0;
#endif
  delete_clause (ps, c);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x18191
jmp 0x181b0
leaq 0x625d(%rip), %rdi      # 0x1e3f5
leaq 0x5105(%rip), %rsi      # 0x1d2a4
movl $0x1223, %edx           # imm = 0x1223
leaq 0x6f46(%rip), %rcx      # 0x1f0f1
callq 0x10b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
andl $-0x2, %ecx
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x181f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18390
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: disconnect_clause
static void
disconnect_clause (PS * ps, Cls * c)
{
  assert (c->connected);

  if (c->size > 2)
    {
      if (c->learned)
	{
	  assert (ps->nlclauses > 0);
	  ps->nlclauses--;

	  assert (ps->llits >= c->size);
	  ps->llits -= c->size;
	}
      else
	{
	  assert (ps->noclauses > 0);
	  ps->noclauses--;

	  assert (ps->olits >= c->size);
	  ps->olits -= c->size;
	}
    }

#ifndef NDEBUG
  c->connected = 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x18214
jmp 0x18233
leaq 0x6ef6(%rip), %rdi      # 0x1f111
leaq 0x5082(%rip), %rsi      # 0x1d2a4
movl $0x11f1, %edx           # imm = 0x11F1
leaq 0x6ef0(%rip), %rcx      # 0x1f11e
callq 0x10b0
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0x18374
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x182e6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x42c(%rax)
jbe 0x18264
jmp 0x18283
leaq 0x6ed7(%rip), %rdi      # 0x1f142
leaq 0x5032(%rip), %rsi      # 0x1d2a4
movl $0x11f7, %edx           # imm = 0x11F7
leaq 0x6ea0(%rip), %rcx      # 0x1f11e
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x42c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x42c(%rax)
movq -0x8(%rbp), %rax
movl 0x434(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x182aa
jmp 0x182c9
leaq 0x6ea3(%rip), %rdi      # 0x1f154
leaq 0x4fec(%rip), %rsi      # 0x1d2a4
movl $0x11fa, %edx           # imm = 0x11FA
leaq 0x6e5a(%rip), %rcx      # 0x1f11e
callq 0x10b0
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x434(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x434(%rax)
jmp 0x18372
movq -0x8(%rbp), %rax
cmpl $0x0, 0x428(%rax)
jbe 0x182f5
jmp 0x18314
leaq 0x6e6d(%rip), %rdi      # 0x1f169
leaq 0x4fa1(%rip), %rsi      # 0x1d2a4
movl $0x11ff, %edx           # imm = 0x11FF
leaq 0x6e0f(%rip), %rcx      # 0x1f11e
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x428(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x428(%rax)
movq -0x8(%rbp), %rax
movl 0x430(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x1833b
jmp 0x1835a
leaq 0x6e39(%rip), %rdi      # 0x1f17b
leaq 0x4f5b(%rip), %rsi      # 0x1d2a4
movl $0x1202, %edx           # imm = 0x1202
leaq 0x6dc9(%rip), %rcx      # 0x1f11e
callq 0x10b0
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x430(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x430(%rax)
jmp 0x18374
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
andl $-0x11, %ecx
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: delete_prefix
static void
delete_prefix (PS * ps)
{
  if (!ps->prefix)
    return;
    
  delete (ps, ps->prefix, strlen (ps->prefix) + 1);
  ps->prefix = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x183f9
jmp 0x1843a
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1090
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x97a0
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: delete_clauses
static void
delete_clauses (PS * ps)
{
  Cls **p;
  for (p = SOC; p != EOC; p = NXC (p))
    if (*p)
      delete_clause (ps, *p);

  DELETEN (ps->oclauses, ps->eoo - ps->oclauses);
  DELETEN (ps->lclauses, ps->EOL - ps->lclauses);

  ps->ohead = ps->eoo = ps->lhead = ps->EOL = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jne 0x18475
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x18484
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x200(%rcx), %rax
je 0x184f5
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x184b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x18390
jmp 0x184b9
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jne 0x184df
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x184eb
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1848c
jmp 0x184f7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
subq %rax, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
callq 0x97a0
movq -0x8(%rbp), %rax
movq $0x0, 0x1e0(%rax)
jmp 0x1853d
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
subq %rax, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
callq 0x97a0
movq -0x8(%rbp), %rax
movq $0x0, 0x1f8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x208(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1f0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1e8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: init_restart
static void
init_restart (PS * ps)
{
#ifdef NLUBY
  /* TODO: why is it better in incremental usage to have smaller initial
   * outer restart interval?
   */
  ps->ddrestart = ps->calls > 1 ? MINRESTART : 1000;
  ps->drestart = MINRESTART;
  ps->lrestart = ps->conflicts + ps->drestart;
#else
  ps->lubycnt = 0;
  ps->lubymaxdelta = 0;
  ps->waslubymaxdelta = 0;
  inc_lrestart (ps, 0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c8(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x196a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: init_reduce
static void
init_reduce (PS * ps)
{
  // lreduce = loadded / 2;
  ps->lreduce = 1000;

  if (ps->lreduce < 100)
    ps->lreduce = 100;

  if (ps->verbosity)
     fprintf (ps->out, 
             "%s\n%sinitial reduction limit %u clauses\n%s\n",
	     ps->prefix, ps->prefix, ps->lreduce, ps->prefix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, 0x3a8(%rax)     # imm = 0x3E8
movq -0x8(%rbp), %rax
cmpl $0x64, 0x3a8(%rax)
jae 0x191b5
movq -0x8(%rbp), %rax
movl $0x64, 0x3a8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x191f8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x3a8(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r9
leaq 0x6215(%rip), %rsi      # 0x1f406
movb $0x0, %al
callq 0x1130
addq $0x10, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: original_clauses_satisfied
static void
original_clauses_satisfied (PS * ps)
{
  Cls **p, *c;

  for (p = ps->oclauses; p < ps->ohead; p++)
    {
      c = *p;

      if (!c)
	continue;

      if (c->learned)
	continue;

      assert (clause_satisfied (c));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1e8(%rcx), %rax
jae 0x192c2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x19270
jmp 0x192b4
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x19283
jmp 0x192b4
movq -0x18(%rbp), %rdi
callq 0x19aa0
cmpl $0x0, %eax
je 0x19293
jmp 0x192b2
leaq 0x61bd(%rip), %rdi      # 0x1f457
leaq 0x4003(%rip), %rsi      # 0x1d2a4
movl $0xc2a, %edx            # imm = 0xC2A
leaq 0x61bf(%rip), %rcx      # 0x1f46c
callq 0x10b0
jmp 0x192b4
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1924b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assumptions_satisfied
static void
assumptions_satisfied (PS * ps)
{
  Lit *lit, ** p;

  for (p = ps->als; p < ps->alshead; p++)
    {
      lit = *p;
      assert (lit->val == TRUE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0x19344
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x19315
jmp 0x19334
leaq 0x4ebf(%rip), %rdi      # 0x1e1db
leaq 0x3f81(%rip), %rsi      # 0x1d2a4
movl $0xc36, %edx            # imm = 0xC36
leaq 0x6163(%rip), %rcx      # 0x1f492
callq 0x10b0
jmp 0x19336
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x192eb
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: iteration
static void
iteration (PS * ps)
{
  assert (!ps->LEVEL);
  assert (bcp_queue_is_empty (ps));
  assert (ps->isimplify < ps->fixed);

  ps->iterations++;
  report (ps, 2, 'i');
#ifdef NLUBY
  ps->drestart = MINRESTART;
  ps->lrestart = ps->conflicts + ps->drestart;
#else
  init_restart (ps);
#endif
  ps->isimplify = ps->fixed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x19368
jmp 0x19387
leaq 0x512a(%rip), %rdi      # 0x1e499
leaq 0x3f2e(%rip), %rsi      # 0x1d2a4
movl $0x153b, %edx           # imm = 0x153B
leaq 0x6131(%rip), %rcx      # 0x1f4b3
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x12590
cmpl $0x0, %eax
je 0x19397
jmp 0x193b6
leaq 0x50e3(%rip), %rdi      # 0x1e481
leaq 0x3eff(%rip), %rsi      # 0x1d2a4
movl $0x153c, %edx           # imm = 0x153C
leaq 0x6102(%rip), %rcx      # 0x1f4b3
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x3a0(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3e8(%rcx), %eax
jae 0x193ce
jmp 0x193ed
leaq 0x60f3(%rip), %rdi      # 0x1f4c8
leaq 0x3ec8(%rip), %rsi      # 0x1d2a4
movl $0x153d, %edx           # imm = 0x153D
leaq 0x60cb(%rip), %rcx      # 0x1f4b3
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x380(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x380(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x69, %edx
callq 0x79c0
movq -0x8(%rbp), %rdi
callq 0x19130
movq -0x8(%rbp), %rax
movl 0x3e8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3a0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: decide
static void
decide (PS * ps)
{
  Lit * lit;

  assert (!satisfied (ps));
  assert (!ps->conflict);

  if (ps->alstail < ps->alshead && (lit = adecide (ps)))
    ;
  else if (ps->failed_assumption)
    return;
  else if (satisfied (ps))
    return;
  else if (!(lit = rdecide (ps)))
    lit = sdecide (ps);

  assert (lit);
  assign_decision (ps, lit);

  ps->levelsum += ps->LEVEL;
  ps->decisions++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf050
cmpl $0x0, %eax
jne 0x1955c
jmp 0x1957b
leaq 0x4db4(%rip), %rdi      # 0x1e317
leaq 0x3d3a(%rip), %rsi      # 0x1d2a4
movl $0x16d9, %edx           # imm = 0x16D9
leaq 0x5fab(%rip), %rcx      # 0x1f521
callq 0x10b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
jne 0x1958b
jmp 0x195aa
leaq 0x4ee1(%rip), %rdi      # 0x1e473
leaq 0x3d0b(%rip), %rsi      # 0x1d2a4
movl $0x16da, %edx           # imm = 0x16DA
leaq 0x5f7c(%rip), %rcx      # 0x1f521
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0x195d7
movq -0x8(%rbp), %rdi
callq 0x19b90
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x195d7
jmp 0x19623
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
je 0x195ea
jmp 0x1968b
movq -0x8(%rbp), %rdi
callq 0xf050
cmpl $0x0, %eax
je 0x195fd
jmp 0x1968b
movq -0x8(%rbp), %rdi
callq 0x19d40
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1961d
movq -0x8(%rbp), %rdi
callq 0x19ee0
movq %rax, -0x10(%rbp)
jmp 0x1961f
jmp 0x19621
jmp 0x19623
cmpq $0x0, -0x10(%rbp)
je 0x1962c
jmp 0x1964b
leaq 0x55cc(%rip), %rdi      # 0x1ebff
leaq 0x3c6a(%rip), %rsi      # 0x1d2a4
movl $0x16e5, %edx           # imm = 0x16E5
leaq 0x5edb(%rip), %rcx      # 0x1f521
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x126e0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
cvtsi2sd %rax, %xmm0
movq -0x8(%rbp), %rax
addsd 0x378(%rax), %xmm0
movsd %xmm0, 0x378(%rax)
movq -0x8(%rbp), %rax
movl 0x390(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x390(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: inc_lrestart
static void
inc_lrestart (PS * ps, int skip)
{
  unsigned delta;

  delta = 100 * luby (++ps->lubycnt);
  ps->lrestart = ps->conflicts + delta;

  if (ps->waslubymaxdelta)
    report (ps, 1, skip ? 'N' : 'R');
  else
    report (ps, 2, skip ? 'n' : 'r');

  if (delta > ps->lubymaxdelta)
    {
      ps->lubymaxdelta = delta;
      ps->waslubymaxdelta = 1;
    }
  else
    ps->waslubymaxdelta = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x3c0(%rax), %edi
addl $0x1, %edi
movl %edi, 0x3c0(%rax)
callq 0x19780
imull $0x64, %eax, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x41c(%rax), %ecx
addl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3bc(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3c8(%rax)
je 0x19717
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x52, %eax
movl $0x4e, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl $0x1, %esi
movsbl %al, %edx
callq 0x79c0
jmp 0x1973b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x72, %eax
movl $0x6e, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl $0x2, %esi
movsbl %al, %edx
callq 0x79c0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3c4(%rcx), %eax
jbe 0x19767
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x3c8(%rax)
jmp 0x19775
movq -0x8(%rbp), %rax
movl $0x0, 0x3c8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: luby
static int
luby (int i)
{
  int k;
  for (k = 1; k < 32; k++)
    if (i == (1 << k) - 1)
      return 1 << (k - 1);

  for (k = 1;; k++)
    if ((1 << (k - 1)) <= i && i < (1 << k) - 1)
      return luby (i - (1 << (k-1)) + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x197cd
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x197c0
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x4(%rbp)
jmp 0x19828
jmp 0x197c2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19792
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl -0x8(%rbp), %eax
jg 0x1981b
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1981b
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
subl %eax, %edi
addl $0x1, %edi
callq 0x19780
movl %eax, -0x4(%rbp)
jmp 0x19828
jmp 0x1981d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x197d4
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: crescore
static void
crescore (PS * ps)
{
  Cls **p, *c;
  Act *a;
  Flt factor;
  int l = log2flt (ps->cinc);
  assert (l > 0);
  factor = base2flt (1, -l);

  for (p = ps->lclauses; p != ps->lhead; p++)
    {
      c = *p;

      if (!c)
	continue;

#ifdef TRACE
      if (c->collected)
	continue;
#endif
      assert (c->learned);

      if (c->size <= 2)
	continue;

      a = CLS2ACT (c);
      *a = mulflt (*a, factor);
    }

  ps->cinc = mulflt (ps->cinc, factor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x310(%rax), %edi
callq 0x19a80
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x19906
jmp 0x19925
leaq 0x5b25(%rip), %rdi      # 0x1f432
leaq 0x3990(%rip), %rsi      # 0x1d2a4
movl $0x113d, %edx           # imm = 0x113D
leaq 0x5b18(%rip), %rcx      # 0x1f438
callq 0x10b0
xorl %esi, %esi
subl -0x28(%rbp), %esi
movl $0x1, %edi
callq 0xdfd0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x1f8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x200(%rcx), %rax
je 0x19a4e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x19972
jmp 0x19a3d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x19985
jmp 0x199a4
leaq 0x5ac0(%rip), %rdi      # 0x1f44c
leaq 0x3911(%rip), %rsi      # 0x1d2a4
movl $0x114b, %edx           # imm = 0x114B
leaq 0x5a99(%rip), %rcx      # 0x1f438
callq 0x10b0
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
ja 0x199b2
jmp 0x19a3d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x199c5
jmp 0x199e4
leaq 0x54cb(%rip), %rdi      # 0x1ee97
leaq 0x38d1(%rip), %rsi      # 0x1d2a4
movl $0x1150, %edx           # imm = 0x1150
leaq 0x5a59(%rip), %rcx      # 0x1f438
callq 0x10b0
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jbe 0x199ef
jmp 0x19a0e
leaq 0x54cd(%rip), %rdi      # 0x1eec3
leaq 0x38a7(%rip), %rsi      # 0x1d2a4
movl $0x1150, %edx           # imm = 0x1150
leaq 0x5a2f(%rip), %rcx      # 0x1f438
callq 0x10b0
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
callq 0xe350
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x19946
movq -0x8(%rbp), %rax
movl 0x310(%rax), %edi
movl -0x24(%rbp), %esi
callq 0xe350
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x310(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: clause_satisfied
static int
clause_satisfied (Cls * c)
{
  Lit **p, **eol, *lit;

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb980
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x19aff
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x19aef
movl $0x1, -0x4(%rbp)
jmp 0x19b06
jmp 0x19af1
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x19ac5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: adecide
static Lit *
adecide (PS * ps)
{
  Lit *lit;
  Var * v;

  assert (ps->als < ps->alshead);
  assert (!ps->failed_assumption);

  while (ps->alstail < ps->alshead)
    {
      lit = *ps->alstail++;

      if (lit->val == FALSE)
	{
	  ps->failed_assumption = lit;
	  v = LIT2VAR (lit);

	  use_var (ps, v);

	  LOG ( fprintf (ps->out, "%sfirst failed assumption %d\n",
			ps->prefix, LIT2INT (ps->failed_assumption)));
	  fanalyze (ps);
	  return 0;
	}

      if (lit->val == TRUE)
	{
	  v = LIT2VAR (lit);
	  if (v->level > ps->adecidelevel)
	    ps->adecidelevel = v->level;
	  continue;
	}

#ifdef STATS
      ps->assumptions++;
#endif
      LOG ( fprintf (ps->out, "%sadecide %d\n", ps->prefix, LIT2INT (lit)));
      ps->adecidelevel = ps->LEVEL + 1;

      return lit;
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0x19bb6
jmp 0x19bd5
leaq 0x45ea(%rip), %rdi      # 0x1e1a7
leaq 0x36e0(%rip), %rsi      # 0x1d2a4
movl $0x16ac, %edx           # imm = 0x16AC
leaq 0x5963(%rip), %rcx      # 0x1f533
callq 0x10b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
jne 0x19be5
jmp 0x19c04
leaq 0x4870(%rip), %rdi      # 0x1e45c
leaq 0x36b1(%rip), %rsi      # 0x1d2a4
movl $0x16ad, %edx           # imm = 0x16AD
leaq 0x5934(%rip), %rcx      # 0x1f533
callq 0x10b0
jmp 0x19c06
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x100(%rcx), %rax
jae 0x19d25
movq -0x10(%rbp), %rcx
movq 0x108(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x108(%rcx)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x19ca8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%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, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13c50
jmp 0x19c92
movq -0x10(%rbp), %rdi
callq 0x19f60
movq $0x0, -0x8(%rbp)
jmp 0x19d2d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x19d03
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%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, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xf0(%rcx), %eax
jbe 0x19cfe
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf0(%rax)
jmp 0x19c06
jmp 0x19d05
jmp 0x19d07
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf0(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19d2d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rdecide
static Lit *
rdecide (PS * ps)
{
  unsigned idx, delta, spread;
  Lit * res;

  spread = RDECIDE;
  if (rrng (ps, 1, spread) != 2)
    return 0;

  assert (1 <= ps->max_var);
  idx = rrng (ps, 1, ps->max_var);
  res = int2lit (ps, idx);

  if (res->val != UNDEF)
    {
      delta = rrng (ps, 1, ps->max_var);
      while (gcd (delta, ps->max_var) != 1)
	delta--;

      assert (1 <= delta);
      assert (delta <= ps->max_var);

      do {
	idx += delta;
	if (idx > ps->max_var)
	  idx -= ps->max_var;
	res = int2lit (ps, idx);
      } while (res->val != UNDEF);
    }

#ifdef STATS
  ps->rdecisions++;
#endif
  res = decide_phase (ps, res);
  LOG ( fprintf (ps->out, "%srdecide %d\n", ps->prefix, LIT2INT (res)));

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x3e8, -0x1c(%rbp)     # imm = 0x3E8
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0x1, %esi
callq 0x1a5f0
cmpl $0x2, %eax
je 0x19d76
movq $0x0, -0x8(%rbp)
jmp 0x19ecb
movq -0x10(%rbp), %rcx
movl $0x1, %eax
cmpl 0x2c(%rcx), %eax
ja 0x19d86
jmp 0x19da5
leaq 0x581a(%rip), %rdi      # 0x1f5a7
leaq 0x3510(%rip), %rsi      # 0x1d2a4
movl $0x166b, %edx           # imm = 0x166B
leaq 0x5818(%rip), %rcx      # 0x1f5b8
callq 0x10b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edx
movl $0x1, %esi
callq 0x1a5f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ef0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x19eb0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edx
movl $0x1, %esi
callq 0x1a5f0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x1a6d0
cmpl $0x1, %eax
je 0x19e14
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19df5
movl $0x1, %eax
cmpl -0x18(%rbp), %eax
ja 0x19e20
jmp 0x19e3f
leaq 0x57a4(%rip), %rdi      # 0x1f5cb
leaq 0x3476(%rip), %rsi      # 0x1d2a4
movl $0x1675, %edx           # imm = 0x1675
leaq 0x577e(%rip), %rcx      # 0x1f5b8
callq 0x10b0
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
ja 0x19e4d
jmp 0x19e6c
leaq 0x5782(%rip), %rdi      # 0x1f5d6
leaq 0x3449(%rip), %rsi      # 0x1d2a4
movl $0x1676, %edx           # imm = 0x1676
leaq 0x5751(%rip), %rcx      # 0x1f5b8
callq 0x10b0
jmp 0x19e6e
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jbe 0x19e92
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ef0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x19e6e
jmp 0x19eb0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1a7a0
movq %rax, -0x28(%rbp)
jmp 0x19ec3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)