LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: sdecide
static Lit *
sdecide (PS * ps)
{
  Lit *res;
  Rnk *r;

  for (;;)
    {
      r = htop (ps);
      res = RNK2LIT (r);
      if (res->val == UNDEF) break;
      (void) hpop (ps);
      NOLOG ( fprintf (ps->out, 
                      "%shpop %u %u %u\n",
		      ps->prefix, r - ps->rnks,
		      FLTMANTISSA(r->score),
		      FLTEXPONENT(r->score)));
    }

#ifdef STATS
  ps->sdecisions++;
#endif
  res = decide_phase (ps, res);

  LOG ( fprintf (ps->out, "%ssdecide %d\n", ps->prefix, LIT2INT (res)));

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a9c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x48(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x19f2c
jmp 0x19f39
movq -0x8(%rbp), %rdi
callq 0x1aa30
jmp 0x19f37
jmp 0x19eec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1a7a0
movq %rax, -0x10(%rbp)
jmp 0x19f4c
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: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x1a60c
jmp 0x1a62b
leaq 0x4fd8(%rip), %rdi      # 0x1f5eb
leaq 0x2c8a(%rip), %rsi      # 0x1d2a4
movl $0x15f4, %edx           # imm = 0x15F4
leaq 0x4fd1(%rip), %rcx      # 0x1f5f7
callq 0x10b0
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a970
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
jmp 0x1a672
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0x1a67c
jmp 0x1a69b
leaq 0x4fa8(%rip), %rdi      # 0x1f62b
leaq 0x2c1a(%rip), %rsi      # 0x1d2a4
movl $0x15fc, %edx           # imm = 0x15FC
leaq 0x4f61(%rip), %rcx      # 0x1f5f7
callq 0x10b0
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x1a6a5
jmp 0x1a6c4
leaq 0x4f8a(%rip), %rdi      # 0x1f636
leaq 0x2bf1(%rip), %rsi      # 0x1d2a4
movl $0x15fd, %edx           # imm = 0x15FD
leaq 0x4f38(%rip), %rcx      # 0x1f5f7
callq 0x10b0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: gcd
static unsigned
gcd (unsigned a, unsigned b)
{
  unsigned tmp;

  assert (a);
  assert (b);

  if (a < b)
    {
      tmp = a;
      a = b;
      b = tmp;
    }

  while (b)
    {
      assert (a >= b);
      tmp = b;
      b = a % b;
      a = tmp;
    }

  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1a6e6
jmp 0x1a705
leaq 0x201d(%rip), %rdi      # 0x1c70a
leaq 0x2bb0(%rip), %rsi      # 0x1d2a4
movl $0x164c, %edx           # imm = 0x164C
leaq 0x4f42(%rip), %rcx      # 0x1f642
callq 0x10b0
cmpl $0x0, -0x8(%rbp)
je 0x1a70d
jmp 0x1a72c
leaq 0x408b(%rip), %rdi      # 0x1e79f
leaq 0x2b89(%rip), %rsi      # 0x1d2a4
movl $0x164d, %edx           # imm = 0x164D
leaq 0x4f1b(%rip), %rcx      # 0x1f642
callq 0x10b0
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x1a746
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x1a748
cmpl $0x0, -0x8(%rbp)
je 0x1a790
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jb 0x1a758
jmp 0x1a777
leaq 0x4f10(%rip), %rdi      # 0x1f66f
leaq 0x2b3e(%rip), %rsi      # 0x1d2a4
movl $0x1658, %edx           # imm = 0x1658
leaq 0x4ed0(%rip), %rcx      # 0x1f642
callq 0x10b0
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl -0x8(%rbp)
movl %edx, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a748
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: rng
static unsigned
rng (PS * ps)
{
  unsigned res = ps->srng;
  ps->srng *= 1664525u;
  ps->srng += 1013904223u;
  NOLOG ( fprintf (ps->out, "%srng () = %u\n", ps->prefix, res));
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x320(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
imull $0x19660d, 0x320(%rax), %ecx # imm = 0x19660D
movl %ecx, 0x320(%rax)
movq -0x8(%rbp), %rax
movl 0x320(%rax), %ecx
addl $0x3c6ef35f, %ecx       # imm = 0x3C6EF35F
movl %ecx, 0x320(%rax)
jmp 0x1a9b1
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: hpop
static Rnk *
hpop (PS * ps)
{
  Rnk *res, *last;
  unsigned end;

  assert (ps->hhead > ps->heap + 1);

  res = ps->heap[1];
  res->pos = 0;

  end = --ps->hhead - ps->heap;
  if (end == 1)
    return res;

  last = ps->heap[end];

  ps->heap[last->pos = 1] = last;
  hdown (ps, last);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x1d0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x1c8(%rcx), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jbe 0x1aa5d
jmp 0x1aa7c
leaq 0x4c43(%rip), %rdi      # 0x1f6a7
leaq 0x2839(%rip), %rsi      # 0x1d2a4
movl $0xabf, %edx            # imm = 0xABF
leaq 0x4c59(%rip), %rcx      # 0x1f6d0
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x1c8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl $0x0, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq 0x1d0(%rcx), %rax
addq $-0x8, %rax
movq %rax, 0x1d0(%rcx)
movq -0x10(%rbp), %rcx
movq 0x1c8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x1aadd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ab2e
movq -0x10(%rbp), %rax
movq 0x1c8(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x1c8(%rax), %rax
movq -0x20(%rbp), %rdx
movl 0x4(%rdx), %esi
andl $0xc0000000, %esi       # imm = 0xC0000000
orl $0x1, %esi
movl %esi, 0x4(%rdx)
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd440
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: relemdata
static void
relemdata (PS * ps)
{
  char *p;
  int x;

  if (ps->reports < 0)
    {
      /* strip trailing white space 
       */
      for (x = 0; x <= 1; x++)
	{
	  p = ps->rline[x] + strlen (ps->rline[x]);
	  while (p-- > ps->rline[x])
	    {
	      if (*p != ' ')
		break;

	      *p = 0;
	    }
	}

      rheader (ps);
    }
  else
    fputc ('\n', ps->out);

  ps->RCOUNT = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x384(%rax)
jge 0x1b0d4
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jg 0x1b0c9
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x360(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x360(%rax,%rcx,8), %rdi
callq 0x1090
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpq 0x360(%rcx,%rdx,8), %rax
jbe 0x1b0b9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x1b0b0
jmp 0x1b0b9
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x1b081
jmp 0x1b0bb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b044
movq -0x8(%rbp), %rdi
callq 0x7ca0
jmp 0x1b0e6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movq -0x8(%rbp), %rax
movl $0x0, 0x374(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picosat.c
// Function: check_mss_flags_clean
static void
check_mss_flags_clean (PS * ps)
{
#ifndef NDEBUG
  unsigned i;
  for (i = 1; i <= ps->max_var; i++)
    {
      assert (!ps->vars[i].msspos);
      assert (!ps->vars[i].mssneg);
    }
#else
  (void) ps;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
ja 0x1b1bf
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %ax
shrw $0x9, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x1b14a
jmp 0x1b169
leaq 0x483b(%rip), %rdi      # 0x1f98c
leaq 0x214c(%rip), %rsi      # 0x1d2a4
movl $0x1ddf, %edx           # imm = 0x1DDF
leaq 0x483c(%rip), %rcx      # 0x1f9a0
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movw (%rax), %ax
shrw $0xa, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x1b190
jmp 0x1b1af
leaq 0x482a(%rip), %rdi      # 0x1f9c1
leaq 0x2106(%rip), %rsi      # 0x1d2a4
movl $0x1de0, %edx           # imm = 0x1DE0
leaq 0x47f6(%rip), %rcx      # 0x1f9a0
callq 0x10b0
jmp 0x1b1b1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b113
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1a0(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1a4(%rcx), %eax
jne 0x1b280
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1a4(%rax)
je 0x1b217
movq -0x8(%rbp), %rax
movl 0x1a4(%rax), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x1b221
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b221
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1a4(%rax)
movq -0x8(%rbp), %rax
movslq 0x1a0(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq 0x1a4(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4f30
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x198(%rax)
jmp 0x1b280
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x1a0(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x1a0(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x3320
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x3190
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: VertexSet::contains(long) const
bool VertexSet::contains(VertexIdx v) const
{
    for (int i=0; i<nVertices; i++)
        if (vertices[i] == v)
            return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rax
cmpq (%rcx), %rax
jge 0x40f1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x40e4
movb $0x1, -0x1(%rbp)
jmp 0x40f5
jmp 0x40e6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40bb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41d8
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x41ba
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x41b8
movq -0x10(%rbp), %rdi
callq 0x3400
jmp 0x41ba
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x41d6
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0x3330
jmp 0x41d8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x4220
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4020
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x42a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x40a0
testb $0x1, %al
jne 0x426a
jmp 0x4293
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4295
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x423e
movslq -0x2c(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x3320
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x434a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4180
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4348
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x3330
jmp 0x434a
addq $0x10, %rsp
popq %rbp
retq
// File: sjain12[P]CliqueCounting/tests/../Escape/CliqueHelper.h
// Function: newStack()
Stack* newStack()
{
    Stack* s = new Stack();
    s->top = NULL;
    s->i = 0;
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x3320
movq %rax, %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x3190
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x3320
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, (%rax)
jne 0x44c7
movq $0x0, -0x8(%rbp)
jmp 0x44f3
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x45be
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x45b1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0xda80
cmpl $-0x1, %eax
jne 0x45a4
movb $0x0, -0x1(%rbp)
jmp 0x45c2
jmp 0x45a6
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4570
jmp 0x45b3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x455a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdx
movq 0x8(%rax,%rdx,8), %rax
movq (%rcx), %rdx
movq 0x10(%rdx), %rdx
movq -0x18(%rbp), %rsi
subq (%rdx,%rsi,8), %rax
movq %rax, -0x28(%rbp)
movq (%rcx), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rdx
movq 0x8(%rax,%rdx,8), %rax
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
subq (%rcx,%rdx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jl 0x8cd8
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x8cde
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x8cde
movb $0x1, -0x1(%rbp)
jmp 0x8ce2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0xd58e
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0xd550
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd596
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jle 0xd56e
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jge 0xd58c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xd514
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xd620
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x10(%rax), %rdx
callq 0x73c0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rdi
movq 0x18(%rcx), %rsi
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x18(%rax), %rdx
callq 0x73c0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0xd820
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rcx), %rdi
movq 0x10(%rcx), %rsi
movq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
addq $0x8, %rsi
movq 0x10(%rax), %rdx
callq 0x73c0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rdi
movq 0x18(%rcx), %rsi
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq 0x18(%rax), %rdx
callq 0x73c0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0xbc46(%rip), %rsi      # 0x195b0
movb $0x0, %al
callq 0x3450
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jge 0xda1e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xbc45(%rip), %rsi      # 0x195de
movb $0x0, %al
callq 0x3450
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jge 0xd9fb
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xbbfe(%rip), %rsi      # 0x195e4
movb $0x0, %al
callq 0x3450
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd9b4
movq -0x10(%rbp), %rdi
leaq 0xb9de(%rip), %rsi      # 0x193e4
movb $0x0, %al
callq 0x3450
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd979
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jl 0xdaaa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdb0b
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jge 0xdb04
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0xdaf4
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0xdb0b
jmp 0xdaf6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdabe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jl 0xdb3e
movq $-0x1, -0x8(%rbp)
jmp 0xdbe4
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0xdbdc
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0xdbaa
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdbe4
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jle 0xdbce
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xdbda
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdb67
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: sjain12[P]CliqueCounting/Graph.cpp
// Function: Escape::CGraph::isEdgeBinary(long, long) const
bool CGraph::isEdgeBinary(VertexIdx v1, VertexIdx v2) const
{
    VertexIdx deg1 = offsets[v1+1] - offsets[v1];
    VertexIdx deg2 = offsets[v2+1] - offsets[v2];

//     if(deg2 < deg1)
//     {
//         VertexIdx swp = v1;
//         v1 = v2;
//         v2 = swp;
//     }
// 
    EdgeIdx low = offsets[v1];
    EdgeIdx high = offsets[v1+1]-1;
    EdgeIdx mid;

    while(low <= high)
    {
        mid = (low+high)/2;

        if (nbors[mid] == v2)
            return true;
        if (nbors[mid] > v2)
            high = mid-1;
        else
            low = mid+1;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rsi
subq (%rdx,%rsi,8), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rsi
subq (%rdx,%rsi,8), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0xdcd8
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq 0x18(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0xdca6
movb $0x1, -0x1(%rbp)
jmp 0xdcdc
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jle 0xdcca
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xdcd6
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xdc67
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq (%rcx), %rax
jl 0xdd1b
movq $-0x1, -0x8(%rbp)
jmp 0xdd7e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jge 0xdd76
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0xdd66
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdd7e
jmp 0xdd68
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xdd2f
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0xe90e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xeb40
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0xa726(%rip), %xmm2     # 0x19008
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0xa726(%rip), %xmm1     # 0x19018
divsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe8ac
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x180ba
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x3070
cmpl $0x0, %eax
jne 0x180ac
movb $0x0, -0x1(%rbp)
jmp 0x180be
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1808c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x98(%rcx), %eax
jge 0x44f8
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5540
cmpl $0x0, (%rax)
jge 0x4447
jmp 0x44ea
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq 0x40(%rdi), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
imull 0xa4(%rdi), %eax
movl %eax, -0x2c(%rbp)
addq $0x48, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5540
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl -0x2c(%rbp), %eax
addl (%rcx), %eax
movslq %eax, %rsi
callq 0x5520
movss (%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xa4(%rcx), %eax
jge 0x44e8
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rdi
movl -0x14(%rbp), %eax
imull 0xa4(%rcx), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x5520
movss (%rax), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x44db
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44e8
jmp 0x44dd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x449a
jmp 0x44ea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4419
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0x5560
movq %rax, %rdi
callq 0x5500
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x45bf
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl $0x2, %esi
callq 0x5560
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x5520
movss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
movss -0xc(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4543
movq -0x20(%rbp), %rax
movss 0xb0(%rax), %xmm0
mulss -0xc(%rbp), %xmm0
movss 0xba38(%rip), %xmm1     # 0x10010
divss %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x42c0
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x4350
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5420
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5450
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5480
testb $0x1, %al
jne 0x4650
jmp 0x4679
leaq -0x20(%rbp), %rdi
callq 0x54c0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *(%rax)
leaq -0x20(%rbp), %rdi
callq 0x54e0
jmp 0x463d
movq -0x48(%rbp), %rdi
movss 0x60(%rdi), %xmm0
movss %xmm0, -0x4c(%rbp)
callq 0x4520
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movss -0x4c(%rbp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
callq 0x43f0
movq -0x48(%rbp), %rdi
movss %xmm0, -0x38(%rbp)
addq $0x8, %rdi
callq 0x5580
subq $0x1, %rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x46ea
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x55a0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x46bf
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0xda70
leaq -0x8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x55c0
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x42c0
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4350
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5420
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5450
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5480
testb $0x1, %al
jne 0x4781
jmp 0x47a7
leaq -0x28(%rbp), %rdi
callq 0x54c0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
leaq -0x28(%rbp), %rdi
callq 0x54e0
jmp 0x476e
movq -0x48(%rbp), %rdi
movss 0x60(%rdi), %xmm0
movss %xmm0, -0x4c(%rbp)
callq 0x4520
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movss -0x4c(%rbp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
callq 0x43f0
movss %xmm0, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x55c0
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yuang-chen[P]paraGCN/src/parser.cpp
// Function: Parser::parseGraph()
void Parser::parseGraph() {
    int node = 0; 
    string line;

    auto &graph_sparse_index = this->gcnData->graph;
    graph_sparse_index.indptr.push_back(0);
 
    while(getline(this->graph_file, line)) {    // get the line out of the graph file, which iilutrates node relation
        graph_sparse_index.indices.push_back(node);  
        graph_sparse_index.indptr.push_back(graph_sparse_index.indptr.back() + 1);
        node++;
        
        istringstream ss(line);    // analyze the line 
        int neighbor;
        while(ss >> neighbor) {       // get the number out of the line
            graph_sparse_index.indices.push_back(neighbor);
            graph_sparse_index.indptr.back() += 1;
        }
    }
    this->gcnParams->num_nodes = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3340
movq -0x1e0(%rbp), %rax
movq 0x620(%rax), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movl $0x0, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0xa6c0
jmp 0x9e8a
jmp 0x9e8c
movq -0x1e0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3090
movq %rax, -0x1e8(%rbp)
jmp 0x9ea5
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x1e9(%rbp)
jmp 0x9ec3
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x9ed2
jmp 0x9fd6
movq -0x38(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xa6f0
jmp 0x9ee1
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xa760
movq -0x1f8(%rbp), %rdi
movl (%rax), %eax
incl %eax
movl %eax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xa6c0
jmp 0x9f0e
movl -0xc(%rbp), %eax
incl %eax
movl %eax, -0xc(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x33f0
jmp 0x9f2d
jmp 0x9f2f
leaq -0x1d0(%rbp), %rdi
leaq -0x1d4(%rbp), %rsi
callq 0x3190
movq %rax, -0x200(%rbp)
jmp 0x9f4b
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x201(%rbp)
jmp 0x9f69
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x9f75
jmp 0x9fc5
movq -0x38(%rbp), %rdi
leaq -0x1d4(%rbp), %rsi
callq 0xa6f0
jmp 0x9f87
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0xa760
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x9f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x9ffb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3140
jmp 0x9ffb
leaq -0x1d0(%rbp), %rdi
callq 0x3140
jmp 0x9e8c
movq -0x1e0(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x618(%rax), %rax
movl %ecx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x31a0
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: yuang-chen[P]paraGCN/src/parser.cpp
// Function: Parser::parseSplit()
void Parser::parseSplit() {
    auto &split = this->gcnData->split;
    string line;
    while(getline(split_file, line)) {
       split.push_back(stoi(line));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x620(%rax), %rax
addq $0x60, %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3340
movq -0x48(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
leaq -0x30(%rbp), %rsi
callq 0x3090
movq %rax, -0x50(%rbp)
jmp 0xa3a6
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x51(%rbp)
jmp 0xa3be
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xa3c7
jmp 0xa414
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movl $0xa, %edx
callq 0xa850
movl %eax, -0x58(%rbp)
jmp 0xa3e6
movq -0x60(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0xa6c0
jmp 0xa3fb
jmp 0xa38c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0xa423
leaq -0x30(%rbp), %rdi
callq 0x31a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: yuang-chen[P]paraGCN/src/parser.cpp
// Function: Parser::parse()
bool Parser::parse() {
    if(!isValidInput()) return false;
    this->parseGraph();
    cout << "parse Graph successfully" << endl;
    this->parseNode();
    cout << "parse Node successfully" << endl;
    this->parseSplit();
    cout << "parse Split successfully" << endl;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xa430
testb $0x1, %al
jne 0xa4c6
movb $0x0, -0x1(%rbp)
jmp 0xa54b
movq -0x18(%rbp), %rdi
callq 0x9e30
movq 0xdaf2(%rip), %rdi      # 0x17fc8
leaq 0x5c65(%rip), %rsi      # 0x10142
callq 0x3250
movq %rax, %rdi
movq 0xdacc(%rip), %rsi      # 0x17fb8
callq 0x3280
movq -0x18(%rbp), %rdi
callq 0xa010
movq 0xdac7(%rip), %rdi      # 0x17fc8
leaq 0x5c53(%rip), %rsi      # 0x1015b
callq 0x3250
movq %rax, %rdi
movq 0xdaa1(%rip), %rsi      # 0x17fb8
callq 0x3280
movq -0x18(%rbp), %rdi
callq 0xa360
movq 0xda9c(%rip), %rdi      # 0x17fc8
leaq 0x5c40(%rip), %rsi      # 0x10173
callq 0x3250
movq %rax, %rdi
movq 0xda76(%rip), %rsi      # 0x17fb8
callq 0x3280
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yuang-chen[P]paraGCN/src/sparse.cpp
// Function: SparseIndex::print()
void SparseIndex::print() {
    cout << "----sparse index info----" << endl;

    cout << "indptr: ";
    for(auto i: indptr) {
        cout << i << " ";
    } 
    cout << endl;

    
    cout << "indices: ";
    for(auto i: indices) {
        cout << i << " ";
    } 
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0xcabd(%rip), %rdi      # 0x17fc8
leaq 0x4c7f(%rip), %rsi      # 0x10191
callq 0x3250
movq %rax, %rdi
movq 0xca97(%rip), %rsi      # 0x17fb8
callq 0x3280
movq 0xca9b(%rip), %rdi      # 0x17fc8
leaq 0x4c77(%rip), %rsi      # 0x101ab
callq 0x3250
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xad90
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb660
testb $0x1, %al
jne 0xb572
jmp 0xb5a9
leaq -0x18(%rbp), %rdi
callq 0xb2f0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
movq 0xca3e(%rip), %rdi      # 0x17fc8
callq 0x3410
movq %rax, %rdi
leaq 0x4c19(%rip), %rsi      # 0x101b2
callq 0x3250
leaq -0x18(%rbp), %rdi
callq 0xb6a0
jmp 0xb55f
movq 0xca18(%rip), %rdi      # 0x17fc8
movq 0xca01(%rip), %rsi      # 0x17fb8
callq 0x3280
movq 0xca05(%rip), %rdi      # 0x17fc8
leaq 0x4bea(%rip), %rsi      # 0x101b4
callq 0x3250
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xaf00
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xad90
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb660
testb $0x1, %al
jne 0xb604
jmp 0xb63b
leaq -0x38(%rbp), %rdi
callq 0xb2f0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
movq 0xc9ac(%rip), %rdi      # 0x17fc8
callq 0x3410
movq %rax, %rdi
leaq 0x4b87(%rip), %rsi      # 0x101b2
callq 0x3250
leaq -0x38(%rbp), %rdi
callq 0xb6a0
jmp 0xb5f1
movq 0xc986(%rip), %rdi      # 0x17fc8
movq 0xc96f(%rip), %rsi      # 0x17fb8
callq 0x3280
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop