LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_add_lits
int
picosat_add_lits (PS * ps, int * lits)
{
  const int * p;
  int lit;
  for (p = lits; (lit = *p); p++)
    (void) picosat_add (ps, lit);
  return picosat_add (ps, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x71e0
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6880
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x71b8
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x6880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_assume
void
picosat_assume (PS * ps, int int_lit)
{
  Lit *lit;

  if (ps->measurealltimeinlib)
    enter (ps);
  else
    check_ready (ps);

  if (ps->state != READY)
    reset_incremental_usage (ps);

  assume_contexts (ps);
  lit = import_lit (ps, int_lit, 1);
  assume (ps, lit);

  if (ps->measurealltimeinlib)
    leave (ps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x35c(%rax)
je 0x7257
movq -0x8(%rbp), %rdi
callq 0x43a0
jmp 0x7260
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7272
movq -0x8(%rbp), %rdi
callq 0x4db0
movq -0x8(%rbp), %rdi
callq 0x72c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x6af0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7330
movq -0x8(%rbp), %rax
cmpl $0x0, 0x35c(%rax)
je 0x72b3
movq -0x8(%rbp), %rdi
callq 0x4910
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assume_contexts
static void
assume_contexts (PS * ps)
{
  Lit ** p;
  if (ps->als != ps->alshead)
    return;
  for (p = ps->CLS; p != ps->clshead; p++)
    assume (ps, *p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x100(%rcx), %rax
je 0x72e6
jmp 0x7324
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
je 0x7324
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7330
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x72f5
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: assume
static void
assume (PS * ps, Lit * lit)
{
  if (ps->alshead == ps->eoals)
    {
      assert (ps->alstail == ps->als);
      ENLARGE (ps->als, ps->alshead, ps->eoals);
      ps->alstail = ps->als;
    }

  *ps->alshead++ = lit;
  LOG ( fprintf (ps->out, "%sassumption %d\n", ps->prefix, LIT2INT (lit)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x74cd
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xf8(%rcx), %rax
jne 0x7376
jmp 0x7395
leaq 0x1802d(%rip), %rdi     # 0x1f3aa
leaq 0x15f20(%rip), %rsi     # 0x1d2a4
movl $0x1b08, %edx           # imm = 0x1B08
leaq 0x18031(%rip), %rcx     # 0x1f3c1
callq 0x10b0
jmp 0x7397
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x73c7
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0x73d1
movl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x73d1
movl -0x3c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x110(%rcx), %rax
ja 0x7414
jmp 0x7433
leaq 0x17fbf(%rip), %rdi     # 0x1f3da
leaq 0x15e82(%rip), %rsi     # 0x1d2a4
movl $0x1b09, %edx           # imm = 0x1B09
leaq 0x17f93(%rip), %rcx     # 0x1f3c1
callq 0x10b0
jmp 0x7435
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 0xf8(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4f30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rcx
movl -0x24(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rcx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x100(%rdx), %rax
movq %rax, %rsi
addq $0x8, %rsi
movq %rsi, 0x100(%rdx)
movq %rcx, (%rax)
jmp 0x74ef
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_sat
int
picosat_sat (PS * ps, int l)
{
  int res;
  char ch;

  enter (ps);

  ps->calls++;
  LOG ( fprintf (ps->out, "%sSTART call %u\n", ps->prefix, ps->calls));

  if (ps->added < ps->ahead)
    {
#ifndef NADC
      if (ps->addingtoado)
	ABORT ("API usage: incomplete all different constraint");
      else
#endif
	ABORT ("API usage: incomplete clause");
    }

  if (ps->state != READY)
    reset_incremental_usage (ps);

  assume_contexts (ps);

  res = sat (ps, l);

  assert (ps->state == READY);

  switch (res)
    {
    case PICOSAT_UNSATISFIABLE:
      ch = '0';
      ps->state = UNSAT;
      break;
    case PICOSAT_SATISFIABLE:
      ch = '1';
      ps->state = SAT;
      break;
    default:
      ch = '?';
      ps->state = UNKNOWN;
      break;
    }

  if (ps->verbosity)
    {
      report (ps, 1, ch);
      rheader (ps);
    }

  leave (ps);
  LOG ( fprintf (ps->out, "%sEND call %u result %d\n", ps->prefix, ps->calls, res));

  ps->last_sat_call_result = res;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rax
movl 0x38c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38c(%rax)
jmp 0x752d
movq -0x8(%rbp), %rax
movq 0x258(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x260(%rcx), %rax
jae 0x7562
jmp 0x7547
movq 0x1caaa(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x15dc3(%rip), %rdi     # 0x1d31b
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x7574
movq -0x8(%rbp), %rdi
callq 0x4db0
movq -0x8(%rbp), %rdi
callq 0x72c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7640
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x7597
jmp 0x75b6
leaq 0x15f00(%rip), %rdi     # 0x1d49e
leaq 0x15cff(%rip), %rsi     # 0x1d2a4
movl $0x1bd2, %edx           # imm = 0x1BD2
leaq 0x15f00(%rip), %rcx     # 0x1d4b1
callq 0x10b0
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0xa, %eax
je 0x75dd
jmp 0x75c3
movl -0x18(%rbp), %eax
subl $0x14, %eax
jne 0x75ed
jmp 0x75cd
movb $0x30, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, (%rax)
jmp 0x75fb
movb $0x31, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
jmp 0x75fb
movb $0x3f, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x7620
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movsbl -0x11(%rbp), %edx
callq 0x79c0
movq -0x8(%rbp), %rdi
callq 0x7ca0
movq -0x8(%rbp), %rdi
callq 0x4910
jmp 0x762b
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rheader
static void
rheader (PS * ps)
{
  assert (ps->lastrheader <= ps->reports);

  if (ps->lastrheader == ps->reports)
    return;

  ps->lastrheader = ps->reports;

   fprintf (ps->out, "%s\n", ps->prefix);
   fprintf (ps->out, "%s %s\n", ps->prefix, ps->rline[0]);
   fprintf (ps->out, "%s %s\n", ps->prefix, ps->rline[1]);
   fprintf (ps->out, "%s\n", ps->prefix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x388(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x384(%rcx), %eax
jg 0x7cc4
jmp 0x7ce3
leaq 0x17ae2(%rip), %rdi     # 0x1f7ad
leaq 0x155d2(%rip), %rsi     # 0x1d2a4
movl $0xc55, %edx            # imm = 0xC55
leaq 0x17aee(%rip), %rcx     # 0x1f7cc
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x388(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x384(%rcx), %eax
jne 0x7cfe
jmp 0x7da0
movq -0x8(%rbp), %rax
movl 0x384(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x388(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x17705(%rip), %rsi     # 0x1f42e
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x360(%rax), %rcx
leaq 0x17a8d(%rip), %rsi     # 0x1f7df
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rcx
leaq 0x17a64(%rip), %rsi     # 0x1f7df
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x17695(%rip), %rsi     # 0x1f42e
movb $0x0, %al
callq 0x1130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_deref
int
picosat_deref (PS * ps, int int_lit)
{
  Lit *lit;

  check_ready (ps);
  check_sat_state (ps);
  ABORTIF (!int_lit, "API usage: can not deref zero literal");
  ABORTIF (ps->mtcls, "API usage: deref after empty clause generated");

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

  if (abs (int_lit) > (int) ps->max_var)
    return 0;

  lit = int2lit (ps, int_lit);

  if (lit->val == TRUE)
    return 1;

  if (lit->val == FALSE)
    return -1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49e0
movq -0x10(%rbp), %rdi
callq 0x7eb0
cmpl $0x0, -0x14(%rbp)
je 0x7df9
jmp 0x7e16
jmp 0x7dfb
movq 0x1c1f6(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x156c0(%rip), %rdi     # 0x1d4cc
callq 0x10c0
callq 0x1060
jmp 0x7e18
movq -0x10(%rbp), %rax
cmpq $0x0, 0x248(%rax)
jne 0x7e28
jmp 0x7e45
jmp 0x7e2a
movq 0x1c1c7(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x156c5(%rip), %rdi     # 0x1d500
callq 0x10c0
callq 0x1060
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x7e61
movl $0x0, -0x4(%rbp)
jmp 0x7ea2
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 0x7e86
movl $0x1, -0x4(%rbp)
jmp 0x7ea2
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x7e9b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ea2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_deref_toplevel
int
picosat_deref_toplevel (PS * ps, int int_lit)
{
  check_ready (ps);
  ABORTIF (!int_lit, "API usage: can not deref zero literal");

#ifdef STATS
  ps->derefs++;
#endif
  if (abs (int_lit) > (int) ps->max_var)
    return 0;

  return tderef (ps, int_lit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49e0
cmpl $0x0, -0x14(%rbp)
je 0x7f10
jmp 0x7f2d
jmp 0x7f12
movq 0x1c0df(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x155a9(%rip), %rdi     # 0x1d4cc
callq 0x10c0
callq 0x1060
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x7f49
movl $0x0, -0x4(%rbp)
jmp 0x7f58
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7f70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: tderef
static int
tderef (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;

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

  lit = int2lit (ps, int_lit);

  v = LIT2VAR (lit);
  if (v->level > 0)
    return 0;

  if (lit->val == TRUE)
    return 1;

  if (lit->val == FALSE)
    return -1;

  return 0;
}

// Assembly:
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 0x7f94
jmp 0x7fb3
leaq 0x17880(%rip), %rdi     # 0x1f81b
leaq 0x15302(%rip), %rsi     # 0x1d2a4
movl $0x1b29, %edx           # imm = 0x1B29
leaq 0x17890(%rip), %rcx     # 0x1f83e
callq 0x10b0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4ef0
movq %rax, -0x20(%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, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x7ffc
movl $0x0, -0x4(%rbp)
jmp 0x802d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x8011
movl $0x1, -0x4(%rbp)
jmp 0x802d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x8026
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x802d
movl $0x0, -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: picosat_corelit
int
picosat_corelit (PS * ps, int int_lit)
{
  check_ready (ps);
  check_unsat_state (ps);
  ABORTIF (!int_lit, "API usage: zero literal can not be in core");

  assert (ps->mtcls || ps->failed_assumption);

#ifdef TRACE
  {
    int res = 0;
    ABORTIF (!ps->trace, "tracing disabled");
    if (ps->measurealltimeinlib)
      enter (ps);
    core (ps);
    if (abs (int_lit) <= (int) ps->max_var)
      res = ps->vars[abs (int_lit)].core;
    assert (!res || ps->failed_assumption || ps->vars[abs (int_lit)].used);
    if (ps->measurealltimeinlib)
      leave (ps);
    return res;
  }
#else
  ABORT ("compiled without trace support");
  return 0;
#endif
}

// Assembly:
pushq %rbp
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 0x8110
cmpl $0x0, -0xc(%rbp)
je 0x8099
jmp 0x80b6
jmp 0x809b
movq 0x1bf56(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x15490(%rip), %rdi     # 0x1d53c
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
jne 0x80d2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
je 0x80d4
jmp 0x80f3
leaq 0x1549a(%rip), %rdi     # 0x1d575
leaq 0x151c2(%rip), %rsi     # 0x1d2a4
movl $0x1c31, %edx           # imm = 0x1C31
leaq 0x154aa(%rip), %rcx     # 0x1d598
callq 0x10b0
jmp 0x80f5
movq 0x1befc(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x154b1(%rip), %rdi     # 0x1d5b7
callq 0x10c0
callq 0x1060
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_coreclause
int
picosat_coreclause (PS * ps, int ocls)
{
  check_ready (ps);
  check_unsat_state (ps);

  ABORTIF (ocls < 0, "API usage: negative original clause index");
  ABORTIF (ocls >= (int)ps->oadded, "API usage: original clause index exceeded");

  assert (ps->mtcls || ps->failed_assumption);

#ifdef TRACE
  {
    Cls ** clsptr, * c;
    int res  = 0;

    ABORTIF (!ps->trace, "tracing disabled");
    if (ps->measurealltimeinlib)
      enter (ps);
    core (ps);
    clsptr = ps->oclauses + ocls;
    assert (clsptr < ps->ohead);
    c = *clsptr;
    if (c) 
      res = c->core;
    if (ps->measurealltimeinlib)
      leave (ps);

    return res;
  }
#else
  ABORT ("compiled without trace support");
  return 0;
#endif
}

// Assembly:
pushq %rbp
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 0x8110
cmpl $0x0, -0xc(%rbp)
jl 0x8179
jmp 0x8196
jmp 0x817b
movq 0x1be76(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x15458(%rip), %rdi     # 0x1d5e4
callq 0x10c0
callq 0x1060
jmp 0x8198
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x438(%rcx), %eax
jge 0x81a9
jmp 0x81c6
jmp 0x81ab
movq 0x1be46(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x15460(%rip), %rdi     # 0x1d61c
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
jne 0x81e2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
je 0x81e4
jmp 0x8203
leaq 0x1538a(%rip), %rdi     # 0x1d575
leaq 0x150b2(%rip), %rsi     # 0x1d2a4
movl $0x1c50, %edx           # imm = 0x1C50
leaq 0x15456(%rip), %rcx     # 0x1d654
callq 0x10b0
jmp 0x8205
movq 0x1bdec(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x153a1(%rip), %rdi     # 0x1d5b7
callq 0x10c0
callq 0x1060
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_failed_assumption
int
picosat_failed_assumption (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  ABORTIF (!int_lit, "API usage: zero literal as assumption");
  check_ready (ps);
  check_unsat_state (ps);
  if (ps->mtcls)
    return 0;
  assert (ps->failed_assumption);
  if (abs (int_lit) > (int) ps->max_var)
    return 0;
  if (!ps->extracted_all_failed_assumptions)
    extract_all_failed_assumptions (ps);
  lit = import_lit (ps, int_lit, 1);
  v = LIT2VAR (lit);
  return v->failed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x8237
jmp 0x8254
jmp 0x8239
movq 0x1bdb8(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x1542c(%rip), %rdi     # 0x1d676
callq 0x10c0
callq 0x1060
movq -0x10(%rbp), %rdi
callq 0x49e0
movq -0x10(%rbp), %rdi
callq 0x8110
movq -0x10(%rbp), %rax
cmpq $0x0, 0x248(%rax)
je 0x8280
movl $0x0, -0x4(%rbp)
jmp 0x8331
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
je 0x8290
jmp 0x82af
leaq 0x152eb(%rip), %rdi     # 0x1d582
leaq 0x15006(%rip), %rsi     # 0x1d2a4
movl $0x1c75, %edx           # imm = 0x1C75
leaq 0x15400(%rip), %rcx     # 0x1d6aa
callq 0x10b0
movl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x82cb
movl $0x0, -0x4(%rbp)
jmp 0x8331
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c0(%rax)
jne 0x82e1
movq -0x10(%rbp), %rdi
callq 0x8340
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x6af0
movq %rax, -0x20(%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, -0x28(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_failed_context
int
picosat_failed_context (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  ABORTIF (!int_lit, "API usage: zero literal as context");
  ABORTIF (abs (int_lit) > (int) ps->max_var, "API usage: invalid context");
  check_ready (ps);
  check_unsat_state (ps);
  assert (ps->failed_assumption);
  if (!ps->extracted_all_failed_assumptions)
    extract_all_failed_assumptions (ps);
  lit = import_lit (ps, int_lit, 0);
  v = LIT2VAR (lit);
  return v->failed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x8797
jmp 0x87b4
jmp 0x8799
movq 0x1b858(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x14f29(%rip), %rdi     # 0x1d6d3
callq 0x10c0
callq 0x1060
jmp 0x87b6
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jg 0x87cb
jmp 0x87e8
jmp 0x87cd
movq 0x1b824(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x14f26(%rip), %rdi     # 0x1d704
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
callq 0x8110
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1b8(%rax)
je 0x880a
jmp 0x8829
leaq 0x14d71(%rip), %rdi     # 0x1d582
leaq 0x14a8c(%rip), %rsi     # 0x1d2a4
movl $0x1c88, %edx           # imm = 0x1C88
leaq 0x14f09(%rip), %rcx     # 0x1d72d
callq 0x10b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c0(%rax)
jne 0x883f
movq -0x8(%rbp), %rdi
callq 0x8340
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %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 -0x20(%rbp), %rax
movw (%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: delete
static void
delete (PS * ps, void *void_ptr, size_t size)
{
  size_t bytes;
  Blk *b;

  if (!void_ptr)
    {
      assert (!size);
      return;
    }

  assert (size);
  b = PTR2BLK (void_ptr);

  assert (size <= ps->current_bytes);
  ps->current_bytes -= size;

  assert (b->header.size == size);

  bytes = size + SIZE_OF_BLK;
  if (ps->edelete)
    ps->edelete (ps->emgr, b, bytes);
  else
    free (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x97e8
cmpq $0x0, -0x18(%rbp)
jne 0x97c4
jmp 0x97e3
leaq 0x160ea(%rip), %rdi     # 0x1f8b5
leaq 0x13ad2(%rip), %rsi     # 0x1d2a4
movl $0x3d1, %edx            # imm = 0x3D1
leaq 0x160dd(%rip), %rcx     # 0x1f8bb
callq 0x10b0
jmp 0x98f3
cmpq $0x0, -0x18(%rbp)
je 0x97f1
jmp 0x9810
leaq 0x160f7(%rip), %rdi     # 0x1f8ef
leaq 0x13aa5(%rip), %rsi     # 0x1d2a4
movl $0x3d5, %edx            # imm = 0x3D5
leaq 0x160b0(%rip), %rcx     # 0x1f8bb
callq 0x10b0
cmpq $0x0, -0x10(%rbp)
je 0x9825
movq -0x10(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x982d
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x982d
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x328(%rcx), %rax
ja 0x9848
jmp 0x9867
leaq 0x14a08(%rip), %rdi     # 0x1e257
leaq 0x13a4e(%rip), %rsi     # 0x1d2a4
movl $0x3d8, %edx            # imm = 0x3D8
leaq 0x16059(%rip), %rcx     # 0x1f8bb
callq 0x10b0
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x328(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x328(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x988f
jmp 0x98ae
leaq 0x16047(%rip), %rdi     # 0x1f8dd
leaq 0x13a07(%rip), %rsi     # 0x1d2a4
movl $0x3db, %edx            # imm = 0x3DB
leaq 0x16012(%rip), %rcx     # 0x1f8bb
callq 0x10b0
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x4b8(%rax)
je 0x98ea
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x4a0(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
jmp 0x98f3
movq -0x28(%rbp), %rdi
callq 0x1050
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: new
static void *
new (PS * ps, size_t size)
{
  size_t bytes;
  Blk *b;
  
  if (!size)
    return 0;

  bytes = size + SIZE_OF_BLK;

  if (ps->enew)
    b = ps->enew (ps->emgr, bytes);
  else
    b = malloc (bytes);

  ABORTIF (!b, "out of memory in 'new'");
#ifndef NDEBUG
  b->header.size = size;
#endif
  ps->current_bytes += size;
  if (ps->current_bytes > ps->max_bytes)
    ps->max_bytes = ps->current_bytes;
  return b->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9924
movq $0x0, -0x8(%rbp)
jmp 0x99f0
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4a8(%rax)
je 0x9960
movq -0x10(%rbp), %rax
movq 0x4a8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x4a0(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
jmp 0x996d
movq -0x20(%rbp), %rdi
callq 0x1150
movq %rax, -0x28(%rbp)
jmp 0x996f
cmpq $0x0, -0x28(%rbp)
je 0x9978
jmp 0x9995
jmp 0x997a
movq 0x1a677(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x15f69(%rip), %rdi     # 0x1f8f4
callq 0x10c0
callq 0x1060
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x328(%rax), %rcx
movq %rcx, 0x328(%rax)
movq -0x10(%rbp), %rax
movq 0x328(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x330(%rcx), %rax
jbe 0x99e4
movq -0x10(%rbp), %rax
movq 0x328(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x330(%rax)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: enumstr
static const char * enumstr (int i) {
  int last = i % 10;
  if (last == 1) return "st";
  if (last == 2) return "nd";
  if (last == 3) return "rd";
  return "th";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x9a28
leaq 0x161c7(%rip), %rax     # 0x1fbe9
movq %rax, -0x8(%rbp)
jmp 0x9a59
cmpl $0x2, -0x10(%rbp)
jne 0x9a3b
leaq 0x14502(%rip), %rax     # 0x1df37
movq %rax, -0x8(%rbp)
jmp 0x9a59
cmpl $0x3, -0x10(%rbp)
jne 0x9a4e
leaq 0x15ed1(%rip), %rax     # 0x1f919
movq %rax, -0x8(%rbp)
jmp 0x9a59
leaq 0x15ec7(%rip), %rax     # 0x1f91c
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_maximal_satisfiable_subset_of_assumptions
const int *
picosat_maximal_satisfiable_subset_of_assumptions (PS * ps)
{
  const int * res;
  int i, *a, size;

  ABORTIF (ps->mtcls,
           "API usage: CNF inconsistent (use 'picosat_inconsistent')");

  enter (ps);

  size = ps->alshead - ps->als;
  NEWN (a, size);

  for (i = 0; i < size; i++)
    a[i] = LIT2INT (ps->als[i]);

  res = mss (ps, a, size);
  reassume (ps, a, size);

  DELETEN (a, size);

  leave (ps);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
jne 0x9a7c
jmp 0x9a99
jmp 0x9a7e
movq 0x1a573(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x13f2b(%rip), %rdi     # 0x1d9ba
callq 0x10c0
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
shlq $0x2, %rsi
callq 0x9900
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x9b52
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
andl $0x1, %ecx
movl $0x1, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, %ecx
cmovnel %eax, %edx
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
shrl %eax
imull %eax, %edx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9ade
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x9bb0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x9e50
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
shlq $0x2, %rdx
callq 0x97a0
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4910
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: reassume
static void
reassume (PS * ps, const int * a, int size)
{
  int i;
  LOG ( fprintf (ps->out, "%sreassuming all assumptions\n", ps->prefix));
  for (i = 0; i < size; i++)
    picosat_assume (ps, a[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0x9e65
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9e93
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x7230
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9e6c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_next_maximal_satisfiable_subset_of_assumptions
const int *
picosat_next_maximal_satisfiable_subset_of_assumptions (PS * ps)
{
  const int * res;
  enter (ps);
  res = next_mss (ps, 0);
  leave (ps);
  return  res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x9ee0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4910
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_next_minimal_correcting_subset_of_assumptions
const int *
picosat_next_minimal_correcting_subset_of_assumptions (PS * ps)
{
  const int * res, * tmp;
  enter (ps);
  tmp = next_mss (ps, 1);
  res = tmp ? ps->mcsass : 0;
  leave (ps);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x9ee0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa3bf
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa3c7
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0xa3c7
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4910
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_usedlit
int
picosat_usedlit (PS * ps, int int_lit)
{
  int res;
  check_ready (ps);
  check_sat_or_unsat_or_unknown_state (ps);
  ABORTIF (!int_lit, "API usage: zero literal can not be used");
  int_lit = abs (int_lit);
  res = (int_lit <= (int) ps->max_var) ? ps->vars[int_lit].used : 0;
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
callq 0xa940
cmpl $0x0, -0xc(%rbp)
je 0xa8c9
jmp 0xa8e6
jmp 0xa8cb
movq 0x19726(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x131dc(%rip), %rdi     # 0x1dab8
callq 0x10c0
callq 0x1060
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jg 0xa925
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
jmp 0xa92c
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0xa92c
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: sflush
static void
sflush (PS * ps)
{
  double now = picosat_time_stamp ();
  double delta = now - ps->entered;
  delta = (delta < 0) ? 0 : delta;
  ps->seconds += delta;
  ps->entered = now;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xb380
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
subsd 0x350(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0xb330
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xb33a
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x340(%rax), %xmm0
movsd %xmm0, 0x340(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x350(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_time_stamp
double
picosat_time_stamp (void)
{
  double res = -1;
#ifndef NGETRUSAGE
  struct rusage u;
  res = 0;
  if (!getrusage (RUSAGE_SELF, &u))
    {
      res += u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
      res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
    }
#endif
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movsd 0x11d7d(%rip), %xmm0    # 0x1d110
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
xorl %edi, %edi
leaq -0x98(%rbp), %rsi
callq 0x11a0
cmpl $0x0, %eax
jne 0xb408
cvtsi2sdq -0x98(%rbp), %xmm1
cvtsi2sdq -0x90(%rbp), %xmm0
movsd 0x11d4b(%rip), %xmm2    # 0x1d118
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
cvtsi2sdq -0x88(%rbp), %xmm1
cvtsi2sdq -0x80(%rbp), %xmm0
movsd 0x11d22(%rip), %xmm2    # 0x1d118
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_message
void
picosat_message (PS * ps, int vlevel, const char * fmt, ...)
{
  va_list ap;

  if (vlevel > ps->verbosity)
    return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xba18
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0xba46
jmp 0xbaaa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10c0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11b0
leaq -0x30(%rbp), %rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0xa, %edi
callq 0x10f0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_changed
int
picosat_changed (PS * ps)
{
  int res;

  check_ready (ps);
  check_sat_state (ps);

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

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
callq 0x7eb0
movq -0x8(%rbp), %rax
movl 0x49c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x498(%rcx), %eax
setbe %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xbb1b
movq -0x8(%rbp), %rax
movq 0x490(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x468(%rcx), %rax
je 0xbb1d
jmp 0xbb3c
leaq 0x121e1(%rip), %rdi     # 0x1dd05
leaq 0x11779(%rip), %rsi     # 0x1d2a4
movl $0x2047, %edx           # imm = 0x2047
leaq 0x121f3(%rip), %rcx     # 0x1dd2a
callq 0x10b0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rebias
static void
rebias (PS * ps)
{
  Cls ** p, * c;
  Var * v;

  for (v = ps->vars + 1; v <= ps->vars + ps->max_var; v++)
    v->assigned = 0;

  memset (ps->jwh, 0, 2 * (ps->max_var + 1) * sizeof *ps->jwh);

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

      if (!c) 
	continue;

      if (c->learned)
	continue;

      incjwh (ps, c);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x2c(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0xbbcb
movq -0x20(%rbp), %rax
movw (%rax), %cx
andw $-0x9, %cx
orw $0x0, %cx
movw %cx, (%rax)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0xbb8c
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
addl $0x1, %eax
shll %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10d0
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 0xbc50
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbc22
jmp 0xbc42
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xbc35
jmp 0xbc42
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16500
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xbbfd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_reset_scores
void
picosat_reset_scores (PS * ps)
{
  Rnk * r;
  ps->hhead = ps->heap + 1;
  for (r = ps->rnks + 1; r <= ps->rnks + ps->max_var; r++)
    {
      CLR (r);
      hpush (ps, r);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1d0(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x2c(%rdx), %edx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0xbce2
jmp 0xbcb7
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbcf0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xbc96
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: hpush
inline static void
hpush (PS * ps, Rnk * r)
{
  assert (!r->pos);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x0, %eax
jne 0xbd13
jmp 0xbd32
leaq 0x13d03(%rip), %rdi     # 0x1fa1d
leaq 0x11583(%rip), %rsi     # 0x1d2a4
movl $0xad3, %edx            # imm = 0xAD3
leaq 0x13cf8(%rip), %rcx     # 0x1fa25
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1d8(%rcx), %rax
jne 0xbe72
jmp 0xbd50
movq -0x8(%rbp), %rax
movq 0x1d8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1c8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xbd80
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0xbd8a
movl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xbd8a
movl -0x3c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1c8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x1d8(%rcx), %rax
ja 0xbdcd
jmp 0xbdec
leaq 0x121c6(%rip), %rdi     # 0x1df9a
leaq 0x114c9(%rip), %rsi     # 0x1d2a4
movl $0xad6, %edx            # imm = 0xAD6
leaq 0x13c3e(%rip), %rcx     # 0x1fa25
callq 0x10b0
jmp 0xbdee
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 0x1c8(%rax), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x4f30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1c8(%rax)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rcx
movl -0x24(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1d0(%rax)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rcx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1d8(%rax)
jmp 0xbe72
movq -0x8(%rbp), %rcx
movq 0x1d0(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x1d0(%rcx)
movq -0x8(%rbp), %rcx
movq 0x1c8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %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)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd190
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_remove_learned
void
picosat_remove_learned (PS * ps, unsigned percentage)
{
  enter (ps);
  reset_incremental_usage (ps);
  reduce (ps, percentage);
  leave (ps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43a0
movq -0x8(%rbp), %rdi
callq 0x4db0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbf30
movq -0x8(%rbp), %rdi
callq 0x4910
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_global_default_phase
void
picosat_set_global_default_phase (PS * ps, int phase)
{
  check_ready (ps);
  ABORTIF (phase < 0, "API usage: 'picosat_set_global_default_phase' "
                      "with negative argument");
  ABORTIF (phase > 3, "API usage: 'picosat_set_global_default_phase' "
                      "with argument > 3");
  ps->defaultphase = phase;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
cmpl $0x0, -0xc(%rbp)
jl 0xcf10
jmp 0xcf2d
jmp 0xcf12
movq 0x170df(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x10e21(%rip), %rdi     # 0x1dd44
callq 0x10c0
callq 0x1060
jmp 0xcf2f
cmpl $0x3, -0xc(%rbp)
jg 0xcf37
jmp 0xcf54
jmp 0xcf39
movq 0x170b8(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x10e4d(%rip), %rdi     # 0x1dd97
callq 0x10c0
callq 0x1060
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_default_phase_lit
void
picosat_set_default_phase_lit (PS * ps, int int_lit, int phase)
{
  unsigned newphase;
  Lit * lit;
  Var * v;

  check_ready (ps);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x6af0
movq %rax, -0x20(%rbp)
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, -0x28(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xd05d
cmpl $0x0, -0xc(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, -0x10(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %dx
andw $0x1, %ax
movw %ax, %si
shlw $0x2, %si
andw $-0x5, %dx
orw %si, %dx
movw %dx, (%rcx)
movzwl %ax, %ecx
movq -0x28(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, (%rax)
movq -0x28(%rbp), %rax
movw (%rax), %cx
andw $-0x9, %cx
orw $0x8, %cx
movw %cx, (%rax)
movq -0x28(%rbp), %rax
movw (%rax), %cx
andw $0xff7f, %cx            # imm = 0xFF7F
orw $0x80, %cx
movw %cx, (%rax)
jmp 0xd082
movq -0x28(%rbp), %rax
movw (%rax), %cx
andw $-0x9, %cx
orw $0x0, %cx
movw %cx, (%rax)
movq -0x28(%rbp), %rax
movw (%rax), %cx
andw $0xff7f, %cx            # imm = 0xFF7F
orw $0x0, %cx
movw %cx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: picosat_set_more_important_lit
void
picosat_set_more_important_lit (PS * ps, int int_lit)
{
  Lit * lit;
  Var * v;
  Rnk * r;

  check_ready (ps);

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

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

  if (r->moreimportant)
    return;

  r->moreimportant = 1;

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

// Assembly:
pushq %rbp
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 $0x1f, %eax
cmpl $0x0, %eax
jne 0xd11a
jmp 0xd137
jmp 0xd11c
movq 0x16ed5(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
leaq 0x10cb8(%rip), %rdi     # 0x1dde5
callq 0x10c0
callq 0x1060
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd14b
jmp 0xd17f
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xbfffffff, %ecx       # imm = 0xBFFFFFFF
orl $0x40000000, %ecx       # imm = 0x40000000
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpl $0x0, %eax
je 0xd17f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd190
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)