LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: setcimpl
static Cls *
setcimpl (PS * ps, Lit * a, Lit * b)
{
  assert (!ps->cimplvalid);
  assert (ps->cimpl.size == 2);

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

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

  return &ps->cimpl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xc4(%rdi)
jne 0xd5d5
movq %rdi, %rbx
cmpl $0x2, 0x98(%rdi)
jne 0xd5f4
leaq 0x98(%rbx), %r14
leaq 0xb0(%rbx), %rdi
movq %rsi, 0xb0(%rbx)
movq %rdx, 0xb8(%rbx)
callq 0xd6ae
movl $0x1, 0xc4(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x561a(%rip), %rdi      # 0x12bf6
leaq 0x3c91(%rip), %rsi      # 0x11274
leaq 0x561c(%rip), %rcx      # 0x12c06
movl $0x69c, %edx            # imm = 0x69C
callq 0x10b0
leaq 0x562d(%rip), %rdi      # 0x12c28
leaq 0x3c72(%rip), %rsi      # 0x11274
leaq 0x55fd(%rip), %rcx      # 0x12c06
movl $0x69d, %edx            # imm = 0x69D
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: setimpl
static Cls *
setimpl (PS * ps, Lit * a, Lit * b)
{
  assert (!ps->implvalid);
  assert (ps->impl.size == 2);

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

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

  return &ps->impl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0xc0(%rdi)
jne 0xd65c
movq %rdi, %rbx
cmpl $0x2, 0x70(%rdi)
jne 0xd67b
leaq 0x70(%rbx), %r14
leaq 0x88(%rbx), %rdi
movq %rsi, 0x88(%rbx)
movq %rdx, 0x90(%rbx)
callq 0xd6ae
movl $0x1, 0xc0(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x506f(%rip), %rdi      # 0x126d2
leaq 0x3c0a(%rip), %rsi      # 0x11274
leaq 0x5070(%rip), %rcx      # 0x126e1
movl $0x687, %edx            # imm = 0x687
callq 0x10b0
leaq 0x5080(%rip), %rdi      # 0x12702
leaq 0x3beb(%rip), %rsi      # 0x11274
leaq 0x5051(%rip), %rcx      # 0x126e1
movl $0x688, %edx            # imm = 0x688
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: sorttwolits
static void
sorttwolits (Lit ** v)
{
  Lit * a = v[0], * b = v[1];

  assert (a != b);

  if (a < b)
    return;

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

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0xd6c4
jb 0xd6c3
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
retq
pushq %rax
leaq 0x5049(%rip), %rdi      # 0x12715
leaq 0x3ba1(%rip), %rsi      # 0x11274
leaq 0x5042(%rip), %rcx      # 0x1271c
movl $0x671, %edx            # imm = 0x671
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: add_antecedent
inline static void
add_antecedent (PS * ps, Cls * c)
{
  assert (c);

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xd7a4
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rdi), %rax
cmpq %rsi, %rax
sete %al
orb %bl, %al
testb $0x1, %al
jne 0xd798
movq 0x2a8(%r14), %rax
movq 0x2b0(%r14), %rcx
cmpq %rcx, %rax
jne 0xd785
movq 0x2a0(%r14), %rsi
cmpq %rax, %rsi
ja 0xd7e2
subq %rsi, %rax
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
andq %rax, %r15
shrq $0x2, %rax
testq %r15, %r15
movl %eax, %eax
pushq $0x1
popq %r12
cmovneq %rax, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x3e40
movq %rax, 0x2a0(%r14)
addq %rax, %r15
movq %r15, 0x2a8(%r14)
leaq (%rax,%r12,8), %rcx
movq %rcx, 0x2b0(%r14)
movq %r15, %rax
cmpq %rcx, %rax
jae 0xd7c3
leaq 0x8(%rax), %rcx
movq %rcx, 0x2a8(%r14)
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x34c8(%rip), %rdi      # 0x10c73
leaq 0x3ac2(%rip), %rsi      # 0x11274
leaq 0x4ff1(%rip), %rcx      # 0x127aa
movl $0x6f8, %edx            # imm = 0x6F8
callq 0x10b0
leaq 0x501d(%rip), %rdi      # 0x127e7
leaq 0x3aa3(%rip), %rsi      # 0x11274
leaq 0x4fd2(%rip), %rcx      # 0x127aa
movl $0x706, %edx            # imm = 0x706
callq 0x10b0
leaq 0x4fe2(%rip), %rdi      # 0x127cb
leaq 0x3a84(%rip), %rsi      # 0x11274
leaq 0x4fb3(%rip), %rcx      # 0x127aa
movl $0x704, %edx            # imm = 0x704
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: impl2reason
static Cls *
impl2reason (PS * ps, Lit * lit)
{
  Lit * other;
  Cls * res;
  other = ps->impl.lits[0];
  if (lit == other)
    other = ps->impl.lits[1];
  assert (other->val == FALSE);
  res = LIT2REASON (NOTLIT (other));
  resetimpl (ps);
  return res;
}

// Assembly:
pushq %rax
movq 0x88(%rdi), %rax
cmpq %rsi, %rax
jne 0xe931
movq 0x90(%rdi), %rax
cmpb $-0x1, (%rax)
jne 0xe958
movq 0x38(%rdi), %rcx
subq %rcx, %rax
xorq $0x1, %rax
cmpb $0x1, (%rcx,%rax)
jne 0xe977
leaq 0x1(,%rax,2), %rax
andl $0x0, 0xc0(%rdi)
popq %rcx
retq
leaq 0x4088(%rip), %rdi      # 0x129e7
leaq 0x290e(%rip), %rsi      # 0x11274
leaq 0x4233(%rip), %rcx      # 0x12ba0
movl $0x738, %edx            # imm = 0x738
callq 0x10b0
leaq 0x407d(%rip), %rdi      # 0x129fb
leaq 0x28ef(%rip), %rsi      # 0x11274
leaq 0x4214(%rip), %rcx      # 0x12ba0
movl $0x739, %edx            # imm = 0x739
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: connect_head_tail
static void
connect_head_tail (PS * ps, Lit * lit, Cls * c)
{
  Cls ** s;
  assert (c->size >= 1);
  if (c->size == 2)
    {
#ifdef NO_BINARY_CLAUSES
      lpush (ps, lit, c);
      return;
#else
      s = LIT2IMPLS (lit);
#endif
    }
  else
    s = LIT2HTPS (lit);

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

  *s = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl (%rdx), %edx
cmpl $0x2, %edx
je 0xe9e4
testl %edx, %edx
je 0xeac9
movq 0x58(%rdi), %rax
movl 0x38(%rdi), %esi
movl %r14d, %ecx
subl %esi, %ecx
cmpq %r14, 0x18(%rbx)
je 0xeab0
cmpl $0x1, %edx
je 0xeb07
cmpq %r14, 0x20(%rbx)
jne 0xeb26
pushq $0x10
jmp 0xeab2
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
movq 0x18(%rbx), %r13
movq 0x68(%rdi), %rcx
movl 0x38(%rdi), %eax
movl %r14d, %edx
subl %eax, %edx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %r12
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rdx
testq %rax, %rax
je 0xea6b
movq %rdx, %rcx
shrq $0x20, %rcx
pushq $0x1
popq %rsi
shll %cl, %esi
cmpl %edx, %esi
jb 0xeae8
jne 0xea8d
pushq $0x2
popq %r8
shll %cl, %r8d
movl %esi, %edx
shlq $0x3, %rdx
shlq $0x3, %r8
movq %rax, %rsi
movq %r8, %rcx
callq 0x3e40
movq %rax, (%r12)
movq 0x8(%r12), %rcx
movl %ecx, %esi
andq %r15, %rcx
addq %rcx, %rsi
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rsi, %rdx
movq %rdx, 0x8(%r12)
jmp 0xea8d
testl %edx, %edx
jne 0xeb45
testq %rdx, %rdx
jne 0xeb64
pushq $0x8
popq %rsi
callq 0x8f50
movq %rax, (%r12)
movq 0x8(%r12), %rdx
xorl %ecx, %ecx
cmpq %r14, %r13
sete %cl
movq 0x18(%rbx,%rcx,8), %rcx
leal 0x1(%rdx), %esi
andq %rdx, %r15
orq %rsi, %r15
movq %r15, 0x8(%r12)
movl %edx, %edx
movq %rcx, (%rax,%rdx,8)
jmp 0xeabf
pushq $0x8
popq %rdx
movq (%rax,%rcx,8), %rsi
movq %rsi, (%rbx,%rdx)
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4031(%rip), %rdi      # 0x12b01
leaq 0x279d(%rip), %rsi      # 0x11274
leaq 0x4030(%rip), %rcx      # 0x12b0e
movl $0x7fe, %edx            # imm = 0x7FE
callq 0x10b0
leaq 0x409d(%rip), %rdi      # 0x12b8c
leaq 0x277e(%rip), %rsi      # 0x11274
leaq 0x405b(%rip), %rcx      # 0x12b58
movl $0x7ec, %edx            # imm = 0x7EC
callq 0x10b0
leaq 0x402b(%rip), %rdi      # 0x12b39
leaq 0x275f(%rip), %rsi      # 0x11274
leaq 0x3ff2(%rip), %rcx      # 0x12b0e
movl $0x80d, %edx            # imm = 0x80D
callq 0x10b0
leaq 0x4019(%rip), %rdi      # 0x12b46
leaq 0x2740(%rip), %rsi      # 0x11274
leaq 0x3fd3(%rip), %rcx      # 0x12b0e
movl $0x80e, %edx            # imm = 0x80E
callq 0x10b0
leaq 0x402b(%rip), %rdi      # 0x12b77
leaq 0x2721(%rip), %rsi      # 0x11274
leaq 0x3ffe(%rip), %rcx      # 0x12b58
movl $0x7e5, %edx            # imm = 0x7E5
callq 0x10b0
leaq 0x4016(%rip), %rdi      # 0x12b81
leaq 0x2702(%rip), %rsi      # 0x11274
leaq 0x3fdf(%rip), %rcx      # 0x12b58
movl $0x7e6, %edx            # imm = 0x7E6
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: incjwh
static void
incjwh (PS * ps, Cls * c)
{
  Lit **p, *lit, ** eol;
  Flt * f, inc, sum;
  unsigned size = 0;
  Var * v;
  Val val;

  eol = end_of_lits (c);

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

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

      if (val == TRUE)
	return;

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

  inc = base2flt (1, -size);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rsi), %r14
movl (%rsi), %eax
leaq (%rsi,%rax,8), %r15
addq $0x18, %r15
xorl %esi, %esi
movq %r14, %rax
cmpq %r15, %rax
jae 0xebe2
movq (%rax), %rdx
movzbl (%rdx), %ecx
testl %ecx, %ecx
je 0xebda
cmpl $0x0, 0x28(%rbx)
je 0xebcd
movq 0x40(%rbx), %rdi
subl 0x38(%rbx), %edx
shrl %edx
shlq $0x4, %rdx
cmpl $0x0, 0x4(%rdi,%rdx)
jne 0xebda
cmpl $0xff, %ecx
je 0xebdc
cmpl $0x1, %ecx
je 0xec15
incl %esi
addq $0x8, %rax
jmp 0xeba4
negl %esi
pushq $0x1
popq %rdi
callq 0xb4b4
movl %eax, %ebp
cmpq %r15, %r14
jae 0xec15
movq (%r14), %r12
movq 0x50(%rbx), %r13
subq 0x38(%rbx), %r12
movl (%r13,%r12,4), %edi
movl %ebp, %esi
callq 0xb721
movl %eax, (%r13,%r12,4)
addq $0x8, %r14
jmp 0xebee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb (%rsi), %cl
movb (%rdx), %al
testb %cl, %cl
sete %r8b
testb %al, %al
setne %r9b
testb %r9b, %r8b
je 0xec3d
pushq $-0x1
jmp 0xec50
testb %cl, %cl
setne %r8b
testb %al, %al
sete %r9b
testb %r9b, %r8b
je 0xec52
pushq $0x1
popq %rax
retq
movl 0x38(%rdi), %r8d
subl %r8d, %esi
andl $-0x2, %esi
shlq $0x3, %rsi
subl %r8d, %edx
andl $-0x2, %edx
shlq $0x3, %rdx
testb %cl, %cl
je 0xec80
testb %al, %al
je 0xecb3
movq 0x40(%rdi), %rcx
movl 0x4(%rcx,%rdx), %eax
subl 0x4(%rcx,%rsi), %eax
jne 0xeca8
movq 0x48(%rdi), %rax
movq %rsi, %rcx
shrq %rcx
movl (%rax,%rcx), %ecx
movq %rdx, %rdi
shrq %rdi
xorl %r8d, %r8d
cmpl (%rax,%rdi), %ecx
seta %r8b
pushq $-0x1
popq %rax
cmovael %r8d, %eax
testl %eax, %eax
je 0xeca9
retq
subq %rdx, %rsi
shrq $0x4, %rsi
movl %esi, %eax
retq
pushq %rax
leaq 0x3dc9(%rip), %rdi      # 0x12a84
leaq 0x25b2(%rip), %rsi      # 0x11274
leaq 0x3dc6(%rip), %rcx      # 0x12a8f
movl $0x65f, %edx            # imm = 0x65F
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: var2reason
static Cls *
var2reason (PS * ps, Var * var)
{
  Cls * res = var->reason;
#ifdef NO_BINARY_CLAUSES
  Lit * this, * other;
  if (ISLITREASON (res))
    {
      this = VAR2LIT (var);
      if (this->val == FALSE)
	this = NOTLIT (this);

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

// Assembly:
pushq %rax
movq 0x8(%rsi), %rax
testb $0x1, %al
jne 0xedac
popq %rcx
retq
movq %rsi, %rcx
movq 0x38(%rdi), %rsi
subq 0x40(%rdi), %rcx
sarq $0x3, %rcx
leaq (%rsi,%rcx), %r8
movq %rcx, %rdx
xorq $0x1, %rdx
addq %rsi, %rdx
cmpb $-0x1, (%rsi,%rcx)
cmovneq %r8, %rdx
shrq %rax
cmpb $0x1, (%rsi,%rax)
jne 0xedec
cmpb $0x1, (%rdx)
jne 0xee0b
xorq $0x1, %rax
addq %rax, %rsi
popq %rax
jmp 0xd613
leaq 0x3ff8(%rip), %rdi      # 0x12deb
leaq 0x247a(%rip), %rsi      # 0x11274
leaq 0x3ffd(%rip), %rcx      # 0x12dfe
movl $0xbcc, %edx            # imm = 0xBCC
callq 0x10b0
leaq 0x4009(%rip), %rdi      # 0x12e1b
leaq 0x245b(%rip), %rsi      # 0x11274
leaq 0x3fde(%rip), %rcx      # 0x12dfe
movl $0xbcd, %edx            # imm = 0xBCD
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x3c0(%rdi), %edx
incl %edx
movl %edx, 0x3c0(%rdi)
pushq $0x1
popq %rdi
pushq $-0x1
popq %r8
movl %edi, %ecx
cmpl $0x20, %ecx
je 0xefa5
movl %r8d, %eax
shll %cl, %eax
xorl %edx, %eax
cmpl $-0x1, %eax
je 0xefd0
incl %ecx
jmp 0xef90
movl %edi, %eax
leal -0x1(%rax), %ecx
movl %edi, %r9d
shll %cl, %r9d
cmpl %edx, %r9d
jg 0xefc5
movl %r8d, %r10d
movl %eax, %ecx
shll %cl, %r10d
notl %r10d
cmpl %r10d, %edx
jl 0xefc9
incl %eax
jmp 0xefa7
subl %r9d, %edx
incl %edx
jmp 0xef8e
pushq $0x32
popq %rbp
shll %cl, %ebp
movl 0x41c(%rbx), %eax
addl %ebp, %eax
movl %eax, 0x3bc(%rbx)
cmpl $0x0, 0x3c8(%rbx)
je 0xeffe
xorl %eax, %eax
testl %esi, %esi
sete %al
leal 0x4e(,%rax,4), %edx
pushq $0x1
jmp 0xf00e
xorl %eax, %eax
testl %esi, %esi
sete %al
leal 0x6e(,%rax,4), %edx
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7c11
xorl %eax, %eax
cmpl 0x3c4(%rbx), %ebp
jbe 0xf02a
movl %ebp, 0x3c4(%rbx)
pushq $0x1
popq %rax
movl %eax, 0x3c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rrng
static unsigned
rrng (PS * ps, unsigned low, unsigned high)
{
  unsigned long long tmp;
  unsigned res, elements;
  assert (low <= high);
  elements = high - low + 1;
  tmp = rng (ps);
  tmp *= elements;
  tmp >>= 32;
  tmp += low;
  res = tmp;
  NOLOG ( fprintf (ps->out, "%srrng (ps, %u, %u) = %u\n", ps->prefix, low, high, res));
  assert (low <= res);
  assert (res <= high);
  return res;
}

// Assembly:
pushq %rax
testl %esi, %esi
je 0xf065
movl 0x320(%rdi), %ecx
imull $0x19660d, %ecx, %eax   # imm = 0x19660D
addl $0x3c6ef35f, %eax       # imm = 0x3C6EF35F
movl %eax, 0x320(%rdi)
movl %esi, %eax
imulq %rcx, %rax
shrq $0x20, %rax
cmpl %esi, %eax
jae 0xf084
incl %eax
popq %rcx
retq
leaq 0x437a(%rip), %rdi      # 0x133e6
leaq 0x2201(%rip), %rsi      # 0x11274
leaq 0x4378(%rip), %rcx      # 0x133f2
movl $0x15f4, %edx           # imm = 0x15F4
callq 0x10b0
leaq 0x439b(%rip), %rdi      # 0x13426
leaq 0x21e2(%rip), %rsi      # 0x11274
leaq 0x4359(%rip), %rcx      # 0x133f2
movl $0x15fd, %edx           # imm = 0x15FD
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: push_mcsass
static void
push_mcsass (PS * ps, int lit)
{
  if (ps->nmcsass == ps->szmcsass)
    {
      ps->szmcsass = ps->szmcsass ? 2*ps->szmcsass : 1;
      RESIZEN (ps->mcsass, ps->nmcsass, ps->szmcsass);
    }

  ps->mcsass[ps->nmcsass++] = lit;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x1a0(%rdi), %ecx
cmpl 0x1a4(%rdi), %ecx
jne 0xf4b0
movslq %ecx, %rdx
leal (%rcx,%rcx), %eax
testl %ecx, %ecx
pushq $0x1
popq %rcx
cmovnel %eax, %ecx
movl %ecx, 0x1a4(%r14)
shlq $0x2, %rdx
movslq %ecx, %rcx
shlq $0x2, %rcx
movq 0x198(%r14), %rsi
movq %r14, %rdi
callq 0x3e40
movq %rax, 0x198(%r14)
movl 0x1a0(%r14), %ecx
jmp 0xf4b7
movq 0x198(%r14), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x1a0(%r14)
movslq %ecx, %rcx
movl %ebx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: cmp_glue_activity_size
static int
cmp_glue_activity_size (PS * ps, Cls * c, Cls * d)
{
  Act a, b, * p, * q;

  (void) ps;

  assert (c->learned);
  assert (d->learned);

  if (c->glue < d->glue)		// smaller glue preferred
    return 1;

  if (c->glue > d->glue)
    return -1;

  p = CLS2ACT (c);
  q = CLS2ACT (d);
  a = *p;
  b = *q;

  if (a < b)				// then higher activity
    return -1;

  if (b < a)
    return 1;

  if (c->size < d->size)		// then smaller size
    return 1;

  if (c->size > d->size)
    return -1;

  return 0;
}

// Assembly:
pushq %rax
movl 0x4(%rdi), %eax
testb $0x2, %al
je 0xf53a
movl 0x4(%rsi), %edx
testb $0x2, %dl
je 0xf559
shrl $0x5, %eax
movl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
andl %ecx, %eax
shrl $0x5, %edx
andl %ecx, %edx
pushq $0x1
popq %rcx
cmpl %edx, %eax
jae 0xf4f9
movl %ecx, %eax
jmp 0xf538
pushq $-0x1
popq %rax
ja 0xf538
movl (%rdi), %edx
cmpq $0x2, %rdx
jbe 0xf578
movl (%rsi), %r8d
cmpq $0x2, %r8
jbe 0xf597
movl 0x18(%rdi,%rdx,8), %edi
movl 0x18(%rsi,%r8,8), %esi
cmpl %esi, %edi
jb 0xf538
seta %al
cmpl %r8d, %edx
setb %sil
orb %al, %sil
movl %ecx, %eax
jne 0xf538
xorl %eax, %eax
cmpl %edx, %r8d
sbbl %eax, %eax
popq %rcx
retq
leaq 0x3d6a(%rip), %rdi      # 0x132ab
leaq 0x1d2c(%rip), %rsi      # 0x11274
leaq 0x4353(%rip), %rcx      # 0x138a2
movl $0x1551, %edx           # imm = 0x1551
callq 0x10b0
leaq 0x4371(%rip), %rdi      # 0x138d1
leaq 0x1d0d(%rip), %rsi      # 0x11274
leaq 0x4334(%rip), %rcx      # 0x138a2
movl $0x1552, %edx           # imm = 0x1552
callq 0x10b0
leaq 0x37e6(%rip), %rdi      # 0x12d65
leaq 0x1cee(%rip), %rsi      # 0x11274
leaq 0x4315(%rip), %rcx      # 0x138a2
movl $0x155a, %edx           # imm = 0x155A
callq 0x10b0
leaq 0x433e(%rip), %rdi      # 0x138dc
leaq 0x1ccf(%rip), %rsi      # 0x11274
leaq 0x42f6(%rip), %rcx      # 0x138a2
movl $0x155b, %edx           # imm = 0x155B
callq 0x10b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: newVertexSet(long)
VertexSet* newVertexSet(VertexIdx nVertices)
{
    VertexSet *vs = new VertexSet();
    vs->nVertices = nVertices;
    vs->vertices = new VertexIdx[nVertices];
    return vs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x32a0
movq %rax, %r14
movq %rbx, (%rax)
movq %rbx, %rax
shrq $0x3d, %rax
shlq $0x3, %rbx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbx, %rdi
callq 0x3030
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: delVertexSet(VertexSet*)
void delVertexSet(VertexSet* v)
{
    if (v != NULL)
    {
        if (v->nVertices != 0)
            delete[] v->vertices;
        delete v;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3b9d
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3b91
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3b91
callq 0x3330
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x32b0
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: intersect(VertexSet*, VertexSet*)
VertexSet* intersect(VertexSet* v1, VertexSet* v2) 
{
    VertexSet *s=v2, *l=v1;
    if (v1->nVertices < v2->nVertices)
    {
        s = v1;
        l = v2;
    }

    VertexSet* v = newVertexSet(s->nVertices);
    int j = 0;
    for (int i=0; i<s->nVertices;i++)
    {
        if (l->contains(s->vertices[i]))
        {
            v->vertices[j] = s->vertices[i];
            j++;
        }
    }
    v->nVertices = j;
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rcx
movq (%rsi), %rax
cmpq %rax, %rcx
movq %rdi, %r14
cmovlq %rsi, %r14
cmovlq %rcx, %rax
cmovlq %rdi, %rbx
movq %rax, %rdi
callq 0x3aa8
movq %rax, (%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq %ebp, %r15
cmpq %r13, (%rbx)
jle 0x3c0b
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3ae8
testb %al, %al
je 0x3c06
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %r12, (%rax,%r15,8)
incl %r15d
movl %r15d, %ebp
incq %r13
jmp 0x3bd5
movq (%rsp), %rax
movq %r15, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: newPartialClique(VertexSet*, VertexSet*)
PartialClique* newPartialClique(VertexSet* path, VertexSet* nbrs)
{
    PartialClique* pc = new PartialClique;
    pc->path = path;
    pc->nbrs = nbrs;
    return pc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x32a0
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: delPartialClique(PartialClique*)
void delPartialClique(PartialClique* pc)
{
    if (pc != NULL)
    {
        delVertexSet(pc->path);
        delVertexSet(pc->nbrs);
        delete pc;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3c68
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3b74
movq 0x8(%rbx), %rdi
callq 0x3b74
pushq $0x10
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x32b0
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: Stack::push(PartialClique*)
void Stack::push(PartialClique* pc)
{
    StackItem* si = new StackItem;
    si->pc = pc;
    si->next = top;
    top = si;
    i++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x32a0
movq %rbx, (%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
incl 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: Stack::pop()
StackItem* Stack::pop()
{
    StackItem *si = top;
    if (top == NULL) return NULL;
    top = si->next;
    si->next = NULL;
    i--;
    return si;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x3ce9
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
andq $0x0, 0x8(%rax)
decl 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: isClique(long*, int, Escape::CGraph&)
bool isClique(VertexIdx *vertices, int n, CGraph &CG)
{
    for (int i=0; i<n-1; i++)
    {
        for (int j=i+1; j<n; j++)
            if (CG.isEdge(vertices[i], vertices[j]) == -1)
                return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
leal -0x1(%rsi), %eax
xorl %r12d, %r12d
testl %eax, %eax
movl $0x0, %ecx
movl %eax, 0x4(%rsp)
cmovgl %eax, %ecx
movq %rdi, %rbp
movl %esi, %r13d
movq %rdi, %r14
movq %rcx, 0x8(%rsp)
cmpq %rcx, %r12
je 0x3d84
leaq 0x1(%r12), %rax
movq %rax, 0x10(%rsp)
pushq $0x1
popq %r15
cmpq %r15, %r13
je 0x3d71
movq (%rbp,%r12,8), %rsi
movq (%r14,%r15,8), %rdx
movq %rbx, %rdi
callq 0x7112
incq %r15
cmpl $-0x1, %eax
jne 0x3d51
jmp 0x3d84
decq %r13
addq $0x8, %r14
movq 0x10(%rsp), %r12
movq 0x8(%rsp), %rcx
jmp 0x3d3e
movslq 0x4(%rsp), %rax
cmpq %rax, %r12
setge %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/tests/../Escape/Digraph.h
// Function: DegreeComp::operator()(long, long)
bool operator () (VertexIdx u, VertexIdx v)
    {
        VertexIdx degu = g->offsets[u+1] - g->offsets[u];  // Degree of u
        VertexIdx degv = g->offsets[v+1] - g->offsets[v];  // Degree of v
    
        if (degu < degv || (degu == degv && u < v))    // Comparing degrees and breaking ties by id
            return true;
        else
            return false;
    }

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax,%rsi,8), %rcx
subq (%rax,%rsi,8), %rcx
movq 0x8(%rax,%rdx,8), %rdi
subq (%rax,%rdx,8), %rdi
movb $0x1, %al
cmpq %rdi, %rcx
jl 0x5fb1
sete %cl
cmpq %rdx, %rsi
setl %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::binarySearch(long*, long, long)
VertexIdx Escape::binarySearch(EdgeIdx* array, VertexIdx end, EdgeIdx val)
{
    VertexIdx low = 0;
    VertexIdx high = end-1;
    VertexIdx mid;

    while (low <= high)
    {
        mid = (low+high)/2;
        if (array[mid] == val)
            return mid;
        if (array[mid] > val)
            high = mid-1;
        if (array[mid] < val)
            low = mid+1;
    }
    return -1;
}

// Assembly:
decq %rsi
xorl %ecx, %ecx
pushq $-0x1
popq %rax
cmpq %rsi, %rcx
jg 0x6e4c
leaq (%rsi,%rcx), %r8
shrq %r8
movq (%rdi,%r8,8), %r9
cmpq %rdx, %r9
je 0x6e49
leaq -0x1(%r8), %r10
incq %r8
cmpq %rdx, %r9
cmovgq %r10, %rsi
cmovlq %r8, %rcx
jmp 0x6e20
movq %r8, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::Graph::copy() const
Graph Graph::copy() const
{
  Graph ret = newGraph(nVertices, nEdges);
  std::copy(srcs, srcs + nEdges, ret.srcs);
  std::copy(dsts, dsts + nEdges, ret.dsts);
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x6e6b
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x6efe
movq 0x10(%r14), %rsi
shlq $0x3, %rdx
movq 0x10(%rbx), %rdi
callq 0x3460
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x6efe
movq 0x18(%r14), %rsi
shlq $0x3, %rdx
movq 0x18(%rbx), %rdi
callq 0x3460
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::CGraph::copy() const
CGraph CGraph::copy() const
{
  CGraph ret = newCGraph(nVertices, nEdges);
  std::copy(offsets, offsets + nVertices + 1, ret.offsets);
  std::copy(nbors, nbors + nEdges, ret.nbors);
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0x6f96
movq (%r14), %rax
movq 0x10(%r14), %rsi
leaq (%rsi,%rax,8), %rdx
addq $0x8, %rdx
subq %rsi, %rdx
je 0x702f
movq 0x10(%rbx), %rdi
callq 0x3460
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x7049
movq 0x18(%r14), %rsi
shlq $0x3, %rdx
movq 0x18(%rbx), %rdi
callq 0x3460
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::CGraph::print(_IO_FILE*) const
void CGraph::print(FILE *f) const
{
  fprintf(f, "nVertices=%ld nEdges=%ld\n", (int64_t) nVertices, (int64_t) nEdges);
  for (VertexIdx i = 0; i < nVertices; ++i)
  {
    fprintf(f, "%ld: ", (int64_t) i);
    for (EdgeIdx j = offsets[i]; j < offsets[i + 1]; ++j)
      fprintf(f, "%ld ", (int64_t) nbors[j]);
    fprintf(f, "\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
leaq 0x44d5(%rip), %rsi      # 0xb548
movq %rbx, %rdi
xorl %eax, %eax
callq 0x33a0
leaq 0x44f8(%rip), %r12      # 0xb57c
pushq $0xa
popq %rbp
xorl %r13d, %r13d
cmpq (%r14), %r13
jge 0x70de
movq %rbx, %rdi
leaq 0x44dd(%rip), %rsi      # 0xb576
movq %r13, %rdx
xorl %eax, %eax
callq 0x33a0
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %r15
incq %r13
cmpq (%rax,%r13,8), %r15
jge 0x70d2
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x33a0
incq %r15
movq 0x10(%r14), %rax
jmp 0x70ae
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3320
jmp 0x708a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::CGraph::isEdge(long, long)
int CGraph::isEdge(VertexIdx v1, VertexIdx v2)
{
    if (v1 >= nVertices)
        return -1;
    for (EdgeIdx i=offsets[v1]; i < offsets[v1+1]; ++i)
        if (nbors[i] == v2)
            return i;
    return -1;
}

// Assembly:
pushq $-0x1
popq %rax
cmpq %rsi, (%rdi)
jle 0x713d
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rdi
movq (%r8,%rsi,8), %rcx
movq 0x8(%r8,%rsi,8), %rsi
cmpq %rsi, %rcx
jge 0x713d
cmpq %rdx, (%rdi,%rcx,8)
je 0x713b
incq %rcx
jmp 0x712b
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::CGraph::getEdgeBinary(long, long) const
EdgeIdx CGraph::getEdgeBinary(VertexIdx v1, VertexIdx v2) const
{
    if (v1 >= nVertices)
        return -1;
    EdgeIdx low = offsets[v1];
    EdgeIdx high = offsets[v1+1]-1;
    EdgeIdx mid;

    while(low <= high)
    {
        mid = (low+high)/2;
        if (nbors[mid] == v2)
            return mid;
        if (nbors[mid] > v2)
            high = mid-1;
        else
            low = mid+1;
    }
    return -1;
}

// Assembly:
pushq $-0x1
popq %rcx
cmpq %rsi, (%rdi)
jle 0x718f
movq %rdx, %r8
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rdi
movq (%rax,%rsi,8), %r9
movq 0x8(%rax,%rsi,8), %rsi
decq %rsi
pushq $0x2
popq %r10
cmpq %rsi, %r9
jg 0x718f
leaq (%rsi,%r9), %rax
cqto
idivq %r10
movq (%rdi,%rax,8), %rdx
cmpq %r8, %rdx
je 0x718c
leaq -0x1(%rax), %r11
incq %rax
cmpq %r8, %rdx
cmovleq %rax, %r9
cmovgq %r11, %rsi
jmp 0x7161
movq %rax, %rcx
movq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::CGraph::getEdge(long, long) const
EdgeIdx CGraph::getEdge(VertexIdx v1, VertexIdx v2) const
{
    if (v1 >= nVertices)
        return -1;
    for (EdgeIdx i=offsets[v1]; i < offsets[v1+1]; ++i)
        if (nbors[i] == v2)
            return i;
    return -1;
}

// Assembly:
pushq $-0x1
popq %rax
cmpq %rsi, (%rdi)
jle 0x720e
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rdi
movq (%r8,%rsi,8), %rcx
movq 0x8(%r8,%rsi,8), %rsi
cmpq %rsi, %rcx
jge 0x720e
cmpq %rdx, (%rdi,%rcx,8)
je 0x720b
incq %rcx
jmp 0x71fb
movq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::makeCSR(Escape::Graph, bool)
CGraph Escape::makeCSR(Graph g, bool inPlace)
{
  //create a temporary graph for sorting unless the user requests in-place
  //operation.
  printf("In makeCSR. number of edges = %ld \n", g.nEdges);
  auto tmpG = inPlace ? g : g.copy();

  auto begin = JSIterator<VertexIdx, VertexIdx>{tmpG.srcs, tmpG.dsts};
  auto end   = begin + tmpG.nEdges;
  std::sort(begin, end);

  //We steal the dsts array from tmpG.
  CGraph ret = {g.nVertices, g.nEdges, new EdgeIdx[g.nVertices + 1], tmpG.dsts};

  //Now we have everything sorted by src, compress:
  VertexIdx cv = 0;
  for (EdgeIdx i = 0; i < tmpG.nEdges; ++i)
  {
    auto src = tmpG.srcs[i];
    while (cv <= src)
      ret.offsets[cv++] = i;
  }
  while (cv <= g.nVertices)
    ret.offsets[cv++] = g.nEdges;

  delete[] tmpG.srcs; //we retain tmpG.dsts in the output

  ret.sortById();

  return ret; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, (%rsp)
leaq 0x70(%rsp), %r12
movq 0x8(%r12), %r14
leaq 0x4188(%rip), %rdi      # 0xb581
movq %r14, %rsi
xorl %eax, %eax
callq 0x3040
testl %ebp, %ebp
je 0x741e
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
jmp 0x742b
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x6eb4
movq 0x18(%rsp), %rbp
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rsi
movq %rsi, 0x8(%rsp)
leaq (%r15,%rbp,8), %rdx
leaq (%rsi,%rbp,8), %rcx
movq %r15, %rdi
callq 0x85cf
movq (%r12), %r12
movq (%rsp), %r13
movq %r12, (%r13)
movq %r14, 0x8(%r13)
leaq 0x1(%r12), %rax
shrq $0x3d, %rax
leaq 0x8(,%r12,8), %rcx
xorl %ebx, %ebx
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x3030
movq %rax, 0x10(%r13)
movq 0x8(%rsp), %rcx
movq %rcx, 0x18(%r13)
testq %rbp, %rbp
cmovleq %rbx, %rbp
xorl %ecx, %ecx
cmpq %rbp, %rbx
je 0x74be
movq (%r15,%rbx,8), %rdx
cmpq %rdx, %rcx
jg 0x74b2
movq %rbx, (%rax,%rcx,8)
incq %rcx
jmp 0x74a4
incq %rbx
jmp 0x749b
movq %r14, (%rax,%rcx,8)
incq %rcx
cmpq %r12, %rcx
jle 0x74b7
testq %r15, %r15
je 0x74d0
movq %r15, %rdi
callq 0x3330
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x724e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::countWedges(Escape::CGraph&)
double Escape::countWedges(CGraph &g)
{
  double wedges = 0;
  for (VertexIdx i = 0; i < g.nVertices; i++)
  {
    double deg = g.degree(i);
    wedges += deg * (deg - 1) / 2;
  }
  return wedges;
}

// Assembly:
movq (%rdi), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
movq 0x10(%rdi), %rdx
xorpd %xmm0, %xmm0
movsd 0x37f6(%rip), %xmm1     # 0xb018
movsd 0x3d16(%rip), %xmm2     # 0xb540
cmpq %rcx, %rax
je 0x7856
movq 0x8(%rdx,%rcx,8), %rsi
subq (%rdx,%rcx,8), %rsi
cvtsi2sd %rsi, %xmm3
movapd %xmm3, %xmm4
addsd %xmm1, %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm4, %xmm0
incq %rcx
jmp 0x782a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/GraphIO.cpp
// Function: Escape::loadGraph(char const*, Escape::Graph&, int, Escape::IOFormat)
ErrorCode Escape::loadGraph(const char *path, Graph& graph, int undirected, IOFormat fmt)
{
  switch (fmt)
  {
    case IOFormat::escape:
      return loadGraph_Escape(path, graph, undirected);
    
    default:
      return ecUnsupportedFormat;
  }
}

// Assembly:
cmpl $0x1, %ecx
jne 0x9a9f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1742(%rip), %rsi      # 0xb0e3
callq 0x32f0
testq %rax, %rax
je 0x9ac8
movq %rax, %r14
andq $0x0, (%rbx)
xorl %r12d, %r12d
testl %ebp, %ebp
setne %r12b
leaq 0x20(%rsp), %r13
xorl %r15d, %r15d
movq %r13, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x3420
testq %rax, %rax
je 0x9aa3
cmpb $0x23, 0x20(%rsp)
je 0x99c7
movq %r13, %rdi
callq 0x9d02
testb %al, %al
jne 0x99c7
movq %r13, %rdi
leaq 0x1bdb(%rip), %rsi      # 0xb5d8
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x3270
cmpq $0x0, (%rbx)
movq 0x18(%rsp), %rcx
je 0x9a47
movq 0x10(%rbx), %rax
movq %rcx, (%rax,%r15,8)
movq 0x10(%rsp), %rdx
movq 0x18(%rbx), %rcx
movq %rdx, (%rcx,%r15,8)
testl %ebp, %ebp
je 0x9a97
movq %rdx, 0x8(%rax,%r15,8)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rcx,%r15,8)
addq $0x2, %r15
jmp 0x99c7
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movl %r12d, %ecx
shlq %cl, %rax
movq %rax, 0x8(%rbx)
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
negq %rcx
movl %ebp, 0xc(%rsp)
movl $0x0, %ebp
sbbq %rbp, %rbp
orq %rax, %rbp
movq %rbp, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
movq %rbp, %rdi
movl 0xc(%rsp), %ebp
callq 0x3030
movq %rax, 0x18(%rbx)
jmp 0x99c7
incq %r15
jmp 0x99c7
pushq $0x3
popq %rax
retq
movq %r14, %rdi
callq 0x3290
movq 0x8(%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %r15
jl 0x9ae7
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7509(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
leaq 0x1ae7(%rip), %rsi      # 0xb5c0
movq %r15, %rdx
xorl %eax, %eax
callq 0x33a0
pushq $0x1
jmp 0x9b04
movq 0x74ea(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
leaq 0x1ae7(%rip), %rsi      # 0xb5df
movq %r15, %rcx
xorl %eax, %eax
callq 0x33a0
pushq $0x4
popq %rax
jmp 0x9ab6
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/GraphIO.cpp
// Function: Escape::loadGraph_p(char const*, Escape::Graph&, int, Escape::IOFormat, float)
ErrorCode Escape::loadGraph_p(const char *path, Graph& graph, int undirected, IOFormat fmt, float p)
{
  switch (fmt)
  {
    case IOFormat::escape:
      return loadGraph_Escape_p(path, graph, undirected, p);
    
    default:
      return ecUnsupportedFormat;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b38, %rsp           # imm = 0x2B38
cmpl $0x1, %ecx
jne 0x9c91
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movss %xmm0, 0x8(%rsp)
leaq 0x15ad(%rip), %rsi      # 0xb0e3
callq 0x32f0
testq %rax, %rax
je 0x9cc9
movq %rax, %r14
andq $0x0, (%rbx)
cvtss2sd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
testl %ebp, %ebp
setne %r15b
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq %r13, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x3420
testq %rax, %rax
je 0x9c96
cmpb $0x23, 0x20(%rsp)
je 0x9b68
movq %r13, %rdi
callq 0x9d02
testb %al, %al
jne 0x9b68
movl %ebp, 0x4(%rsp)
movq %r13, %rdi
leaq 0x1a36(%rip), %rsi      # 0xb5d8
leaq 0x10(%rsp), %rdx
leaq 0x18(%rsp), %rcx
xorl %eax, %eax
callq 0x3270
leaq 0x428(%rsp), %rbp
movq %rbp, %rdi
callq 0x9d2a
movq %rbp, %rdi
callq 0x3370
leaq 0x17b0(%rsp), %rbp
movl %eax, %esi
movq %rbp, %rdi
callq 0x9d90
movq %rbp, %rdi
callq 0x9dc7
cmpq $0x0, (%rbx)
je 0x9c2e
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9c76
movq 0x10(%rsp), %rcx
movq 0x10(%rbx), %rax
movq %rcx, (%rax,%r12,8)
movq 0x18(%rsp), %rdx
movq 0x18(%rbx), %rcx
movq %rdx, (%rcx,%r12,8)
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
je 0x9c8c
movq %rdx, 0x8(%rax,%r12,8)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rcx,%r12,8)
addq $0x2, %r12
jmp 0x9c7a
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
movl %r15d, %ecx
shlq %cl, %rax
movq %rax, 0x8(%rbx)
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
negq %rcx
movl $0x0, %ebp
sbbq %rbp, %rbp
orq %rax, %rbp
movq %rbp, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
movq %rbp, %rdi
callq 0x3030
movq %rax, 0x18(%rbx)
movl 0x4(%rsp), %ebp
leaq 0x428(%rsp), %rdi
callq 0x9d80
jmp 0x9b68
incq %r12
jmp 0x9c7a
pushq $0x3
popq %rbx
jmp 0x9cb5
movq %r14, %rdi
callq 0x3290
movq %r12, 0x8(%rbx)
leaq 0x1958(%rip), %rdi      # 0xb601
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x3040
movl %ebx, %eax
addq $0x2b38, %rsp           # imm = 0x2B38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7308(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
leaq 0x18e6(%rip), %rsi      # 0xb5c0
movq %r15, %rdx
xorl %eax, %eax
callq 0x33a0
pushq $0x1
jmp 0x9c93
jmp 0x9cea
movq %rax, %rbx
leaq 0x428(%rsp), %rdi
callq 0x9d80
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/sjain12[P]CliqueCounting/GraphIO.cpp
// Function: isBlankLine(char const*)
static bool isBlankLine( const char* line )
{
  while( *line )
  {
    if( !isspace( *line ) )
      return false;
    ++line;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbl (%rbx), %ebp
testl %ebp, %ebp
je 0x9d1d
movl %ebp, %edi
callq 0x3060
incq %rbx
testl %eax, %eax
jne 0x9d08
testb %bpl, %bpl
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yuang-chen[P]paraGCN/src/gcn.cpp
// Function: GCN::get_accuracy()
float GCN::get_accuracy() {
    int wrong = 0, total = 0;

    for(int i = 0; i < params.num_nodes; i++) {
        if(truth[i] < 0) {
            continue;
        }
        total++;
        float truth_logit = output->data[i * params.output_dim + truth[i]];
        for(int j = 0; j < params.output_dim; j++) {
            if(output->data[i * params.output_dim + j] > truth_logit) {
                wrong++;
                break;
            }
        }
    }
    return float(total - wrong) / total;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x98(%rdi), %eax
movq 0x40(%rdi), %rcx
movslq 0xa4(%rdi), %rdx
xorl %esi, %esi
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
movq 0x48(%rdi), %rdi
testl %eax, %eax
cmovlel %esi, %eax
leaq (,%rdx,4), %r10
xorl %ebx, %ebx
xorl %r9d, %r9d
xorl %r11d, %r11d
cmpq %rax, %rbx
je 0x3d00
movslq (%rdi,%rbx,4), %r15
testq %r15, %r15
js 0x3cf8
incl %r9d
movq %rbx, %r12
imulq %rdx, %r12
movq (%rcx), %r14
leaq (%r14,%r12,4), %r12
movss (%r12,%r15,4), %xmm0
addq %rsi, %r14
xorl %r15d, %r15d
cmpq %r15, %r8
je 0x3cf8
movss (%r14,%r15,4), %xmm1
incq %r15
ucomiss %xmm0, %xmm1
jbe 0x3ce2
incl %r11d
incq %rbx
addq %r10, %rsi
jmp 0x3cb7
cvtsi2ss %r9d, %xmm1
subl %r11d, %r9d
cvtsi2ss %r9d, %xmm0
divss %xmm1, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yuang-chen[P]paraGCN/src/gcn.cpp
// Function: GCN::get_l2_penalty()
float GCN::get_l2_penalty() {
     float l2 = 0;

     for(int i = 0; i < variables[2].data.size(); i++) {
         float x = variables[2].data[i];
         l2 += x * x;
     }
     return params.weight_decay * l2 / 2;
 }

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x90(%rcx), %rax
movq 0x98(%rcx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x3d4f
movss (%rax,%rdx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rdx
jmp 0x3d38
mulss 0xb0(%rdi), %xmm0
mulss 0x42d1(%rip), %xmm0     # 0x8030
retq
// File: /workspace/github_cpp_makefile_star2_O2/yuang-chen[P]paraGCN/src/gcn.cpp
// Function: GCN::train_epoch()
pair<float, float> GCN::train_epoch() {
    set_input();
    set_truth(1);

    for(auto m: modules) {
        m->forward(true);
    }

    float train_loss = loss + get_l2_penalty();
    float train_acc = get_accuracy();

    for(int i = modules.size() - 1; i >= 0; i--) {
        modules[i]->backward();
    }
    optimizer.step();
    return {train_loss, train_acc};
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x3c0c
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3c40
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
je 0x3d9c
movq (%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *(%rax)
addq $0x8, %r14
jmp 0x3d87
movss 0x60(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x3d1a
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
callq 0x3c78
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
movaps %xmm0, 0x20(%rsp)
shrq $0x3, %rax
movl %eax, %r14d
decq %r14
testl %r14d, %r14d
js 0x3df0
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq 0x8(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3dd0
movaps 0x10(%rsp), %xmm0
addss 0xc(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x6a6e
movaps 0x10(%rsp), %xmm0
unpcklps 0x20(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yuang-chen[P]paraGCN/src/gcn.cpp
// Function: GCN::eval(int)
pair<float, float> GCN::eval(int current_split) {
     set_input();
     set_truth(current_split);
     for(auto m: modules) {
         m->forward(false);
     }
     float test_loss = loss + get_l2_penalty();
     float test_acc = get_accuracy();
     return {test_loss, test_acc};
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3c0c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3c40
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
cmpq %r15, %r14
je 0x3e5d
movq (%r14), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
addq $0x8, %r14
jmp 0x3e48
movss 0x60(%rbx), %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3d1a
addss (%rsp), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3c78
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yuang-chen[P]paraGCN/src/parser.cpp
// Function: Parser::Parser(GCNParams*, GCNData*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Parser::Parser(GCNParams *gcnParams, GCNData *gcnData, string graph_name) {
    this->graph_file.open("/data/cppGCN/" + graph_name + ".graph");
    this->split_file.open("/data/cppGCN/" + graph_name + ".split");
    this->svmlight_file.open("/data/cppGCN/" + graph_name + ".svmlight");
    this->gcnParams = gcnParams;
    this->gcnData = gcnData;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x3220
leaq 0x208(%rbx), %r14
movq %r14, %rdi
callq 0x3220
leaq 0x410(%rbx), %r15
movq %r15, %rdi
callq 0x3220
leaq 0x3173(%rip), %rsi      # 0x813b
leaq 0x8(%rsp), %rdi
movq %rbp, %rdx
callq 0x5620
leaq 0x316d(%rip), %rdx      # 0x8149
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5601
leaq 0x28(%rsp), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x31b0
leaq 0x28(%rsp), %rdi
callq 0x3100
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x3125(%rip), %rsi      # 0x813b
leaq 0x8(%rsp), %rdi
movq %rbp, %rdx
callq 0x5620
leaq 0x3126(%rip), %rdx      # 0x8150
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5601
leaq 0x28(%rsp), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x31b0
leaq 0x28(%rsp), %rdi
callq 0x3100
leaq 0x8(%rsp), %rdi
callq 0x3100
leaq 0x30d7(%rip), %rsi      # 0x813b
leaq 0x8(%rsp), %rdi
movq %rbp, %rdx
callq 0x5620
leaq 0x30df(%rip), %rdx      # 0x8157
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5601
leaq 0x28(%rsp), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x31b0
leaq 0x28(%rsp), %rdi
callq 0x3100
leaq 0x8(%rsp), %rdi
callq 0x3100
movq %r13, 0x618(%rbx)
movq %r12, 0x620(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50d4
jmp 0x50e3
jmp 0x50f2
jmp 0x50d4
jmp 0x50e3
jmp 0x50f2
movq %rax, %r12
leaq 0x28(%rsp), %rdi
callq 0x3100
jmp 0x50e6
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x3100
jmp 0x50f5
movq %rax, %r12
movq %r15, %rdi
callq 0x30a0
movq %r14, %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x30a0
movq %r12, %rdi
callq 0x3360
movq %rax, %r12
jmp 0x50fd
movq %rax, %r12
jmp 0x5105
nop