LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::rmEdge(int, int)
void GraphMatrix::rmEdge(int a, int b) {

  if (!_adjM[a][b]) return;

  _adjM[a][b] = false;

  _removeVector(_adjOut[a], b);
  _out[a]--;

  _removeVector(_adjIn[b], a);
  _in[b]--;

  _num_edges--;

  if (!_adjM[b][a]) {
    _removeVector(_neighbours[a],b);
    _num_neighbours[a]--;
    _removeVector(_neighbours[b],a);
    _num_neighbours[b]--;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x30(%rdi), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %rax
movslq %edx, %r14
cmpb $0x1, (%rax,%r14)
jne 0x4ef4
movq %rdi, %rbx
movb $0x0, (%rax,%r14)
leaq (%r15,%r15,2), %r12
shlq $0x3, %r12
movq 0x40(%rdi), %rsi
addq %r12, %rsi
movl %r14d, %edx
callq 0x4efe
movq 0x20(%rbx), %rax
decl (%rax,%r15,4)
leaq (%r14,%r14,2), %r13
shlq $0x3, %r13
movq 0x48(%rbx), %rsi
addq %r13, %rsi
movl %r15d, %edx
callq 0x4efe
movq 0x18(%rbx), %rax
decl (%rax,%r14,4)
decl 0x10(%rbx)
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
cmpb $0x0, (%rax,%r15)
jne 0x4ef4
addq 0x50(%rbx), %r12
movq %r12, %rsi
movl %r14d, %edx
callq 0x4efe
movq 0x28(%rbx), %rax
decl (%rax,%r15,4)
addq 0x50(%rbx), %r13
movq %r13, %rsi
movl %r15d, %edx
callq 0x4efe
movq 0x28(%rbx), %rax
decl (%rax,%r14,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::_removeVector(std::vector<int, std::allocator<int>>&, int)
void GraphMatrix::_removeVector(vector<int> &v, int b) {
  int i, s = v.size();
  for (i=0; i<s; i++)
    if (v[i] == b) break;
  if (i<s) v.erase(v.begin()+i);
}

// Assembly:
pushq %rbx
movl %edx, %eax
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rcx
movq %rcx, %rdx
subq %rdi, %rdx
movq %rdx, %rsi
shrq $0x2, %rsi
testl %esi, %esi
jle 0x4f5b
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
xorl %r8d, %r8d
cmpl %eax, (%rdi,%r8)
je 0x4f3a
addq $0x4, %r8
cmpq %r8, %rsi
jne 0x4f29
jmp 0x4f5b
leaq (%rdi,%r8), %rsi
addq $0x4, %rsi
cmpq %rcx, %rsi
je 0x4f56
addq %r8, %rdi
subq %r8, %rdx
addq $-0x4, %rdx
callq 0x2340
addq $-0x4, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::makeArrayNeighbours()
void GraphMatrix::makeArrayNeighbours() {
  int i,j;
  vector<int>:: iterator ii;
  _array_neighbours = new int*[_num_nodes];  
  for (i=0; i<_num_nodes; i++) {
    _array_neighbours[i] = new int[_neighbours[i].size()];
    for (ii=_neighbours[i].begin(), j=0; ii!=_neighbours[i].end(); ++ii, j++)
      _array_neighbours[i][j] = *ii;
    _neighbours[i].clear();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xc(%rdi), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0x38(%rbx)
cmpl $0x0, 0xc(%rbx)
jle 0x50c3
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,2), %r12
movq 0x8(%rax,%r12), %rdi
subq (%rax,%r12), %rdi
cmovsq %r14, %rdi
callq 0x2030
movq 0x38(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x50(%rbx), %rax
movq (%rax,%r12), %rcx
movq 0x8(%rax,%r12), %rdx
cmpq %rdx, %rcx
je 0x50ab
movq 0x38(%rbx), %rsi
movq (%rsi,%r15,8), %rsi
movq %rcx, %rdi
movl (%rdi), %r8d
movl %r8d, (%rsi)
addq $0x4, %rdi
addq $0x4, %rsi
cmpq %rdx, %rdi
jne 0x5098
cmpq %rcx, %rdx
je 0x50b7
addq %r12, %rax
movq %rcx, 0x8(%rax)
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x5051
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::makeVectorNeighbours()
void GraphMatrix::makeVectorNeighbours() {
  int i,j;
  vector<int>:: iterator ii;

  for (i=0; i<_num_nodes; i++)
    for (j=0; j<_num_neighbours[i]; j++)
      _neighbours[i].push_back(_array_neighbours[i][j]);

  if (_array_neighbours!=NULL) {
    for (i=0; i<_num_nodes; i++)
      if (_array_neighbours[i]!=NULL) delete[] _array_neighbours[i];
    delete[] _array_neighbours;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
jle 0x514a
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x513e
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x38(%rbx), %rax
movq 0x50(%rbx), %rcx
leaq (%rcx,%r15,8), %rdi
movq (%rax,%r14,8), %rdx
addq %r12, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5125
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x512a
callq 0x5248
incq %r13
movq 0x28(%rbx), %rax
movslq (%rax,%r14,4), %rax
addq $0x4, %r12
cmpq %rax, %r13
jl 0x50fa
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x50e5
cmpq $0x0, 0x38(%rbx)
je 0x518f
cmpl $0x0, 0xc(%rbx)
jle 0x5178
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x516c
callq 0x2290
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x515a
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x518f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2290
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphUtils.cpp
// Function: GraphUtils::strToGraph(Graph*, char const*, int, bool)
void GraphUtils::strToGraph(Graph *g, const char *s, int size, bool dir) {
  int i,j;

  if (dir)  g->createGraph(size, DIRECTED);
  else      g->createGraph(size, UNDIRECTED);

  for (i=0; i<size; i++)
    for (j=0; j<size; j++)
      if (s[i*size+j]=='1') g->addEdge(i, j);  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
xorb $0x1, %cl
movzbl %cl, %edx
movl %ebp, %esi
callq *0x18(%rax)
testl %ebp, %ebp
jle 0x59b5
movl %ebp, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpb $0x31, (%rbx,%r12)
jne 0x59a2
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq *0x30(%rax)
incq %r12
cmpq %r12, %r13
jne 0x598c
incq %r15
addq %r13, %rbx
cmpq %r13, %r15
jne 0x5989
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Esu.cpp
// Function: Esu::countSubgraphs(Graph*, int, GraphTree*)
void Esu::countSubgraphs(Graph *g, int k, GraphTree *sg) {
  int i, v[1];

  _motif_size = k;
  _graph_size = g->numNodes();
  _current = new int[k];
  _ext = new int[_graph_size];
  _next = 0;
  _g = g;
  _sg = sg;

  sg->zeroFrequency();

   for (i=0; i<_graph_size; i++)
    _go(i, 0, 0, v);
  
  delete[] _current;
  delete[] _ext;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0x136b4(%rip)     # 0x1979c
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r15d
movl %eax, 0x136a9(%rip)     # 0x197a0
movslq %ebp, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x1368d(%rip)     # 0x197a8
movslq %r15d, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x13678(%rip)     # 0x197b0
movl $0x0, 0x13662(%rip)     # 0x197a4
movq %r14, 0x1366f(%rip)     # 0x197b8
movq %rbx, 0x13678(%rip)     # 0x197c8
movq %rbx, %rdi
callq 0xbc44
cmpl $0x0, 0x13641(%rip)     # 0x197a0
jle 0x6180
xorl %ebx, %ebx
leaq 0xc(%rsp), %r14
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x5cfc
incl %ebx
cmpl 0x13622(%rip), %ebx     # 0x197a0
jl 0x6168
movq 0x13621(%rip), %rdi     # 0x197a8
testq %rdi, %rdi
je 0x6191
callq 0x2290
movq 0x13618(%rip), %rdi     # 0x197b0
addq $0x10, %rsp
testq %rdi, %rdi
je 0x61ae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2290
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Esu.cpp
// Function: Esu::countSubgraphsSample(Graph*, int, GraphTree*, double*)
void Esu::countSubgraphsSample(Graph *g, int k, GraphTree *sg, double *p) {
  int i, v[1];

  _motif_size = k;
  _graph_size = g->numNodes();
  _current = new int[k];
  _ext = new int[_graph_size];
  _next = 0;
  _g = g;
  _sg = sg;
  _prob = p;

  sg->zeroFrequency();

  for (i=0; i<_graph_size; i++)
    if (Random::getDouble()<=_prob[0])
      _goSample(i, 0, 0, v);
  
  delete[] _current;
  delete[] _ext;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl %esi, 0x135c8(%rip)     # 0x1979c
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r12d
movl %eax, 0x135bd(%rip)     # 0x197a0
movslq %ebp, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, 0x135a1(%rip)     # 0x197a8
movslq %r12d, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
cmovsq %r13, %rdi
callq 0x2030
movq %rax, 0x1358c(%rip)     # 0x197b0
movl $0x0, 0x13576(%rip)     # 0x197a4
movq %r15, 0x13583(%rip)     # 0x197b8
movq %rbx, 0x1358c(%rip)     # 0x197c8
movq %r14, 0x1357d(%rip)     # 0x197c0
movq %rbx, %rdi
callq 0xbc44
cmpl $0x0, 0x1354e(%rip)     # 0x197a0
jle 0x6289
xorl %ebx, %ebx
leaq 0x4(%rsp), %r14
callq 0xb21a
movq 0x13559(%rip), %rax     # 0x197c0
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0x627f
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x5f0e
incl %ebx
cmpl 0x13519(%rip), %ebx     # 0x197a0
jl 0x625b
movq 0x13518(%rip), %rdi     # 0x197a8
testq %rdi, %rdi
je 0x629a
callq 0x2290
movq 0x1350f(%rip), %rdi     # 0x197b0
addq $0x8, %rsp
testq %rdi, %rdi
je 0x62b9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2290
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Conditions.cpp
// Function: GMap::GMap(int, int)
GMap::GMap(int nf, int nr) {
  int i;

  numf = nf;
  numr = nr;
  f = new int[nf];
  r = new int[nr];

  for (i=0; i<nf; i++)
    f[i] = INVALID;

  for (i=0; i<nr; i++)
    r[i] = INVALID;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r12
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movslq %esi, %r13
leaq (,%r13,4), %rdi
testl %r13d, %r13d
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%r12)
movslq %ebx, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
cmovsq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, 0x10(%r12)
testl %r13d, %r13d
jle 0x633d
movl %ebp, %edx
shlq $0x2, %rdx
movq %r15, %rdi
movl $0xff, %esi
callq 0x2120
testl %ebx, %ebx
jle 0x6362
movl %ebx, %edx
shlq $0x2, %rdx
movq %r14, %rdi
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Isomorphism.cpp
// Function: Isomorphism::initNauty(int, bool)
void Isomorphism::initNauty(int size, bool directed) {
  n = size;  
  m = (n + WORDSIZE - 1) / WORDSIZE;
  nauty_check(WORDSIZE,m,n,NAUTYVERSIONID);
  
  dir = directed;

  options.getcanon = TRUE;
  options.writeautoms = FALSE;
  if (dir) options.digraph = TRUE;
  else     options.digraph = FALSE;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %edi, %edx
movl %edi, 0x1a7d1(%rip)     # 0x21520
leal 0x1f(%rdx), %eax
leal 0x3e(%rdx), %esi
testl %eax, %eax
cmovnsl %eax, %esi
sarl $0x5, %esi
movl %esi, 0x1a7c1(%rip)     # 0x21524
movl $0x20, %edi
movl $0x960, %ecx            # imm = 0x960
callq 0xcf65
movb %bl, 0x1abb0(%rip)      # 0x21928
movl $0x1, 0x11496(%rip)     # 0x18218
movl $0x0, 0x11494(%rip)     # 0x18220
movl %ebx, 0x1148a(%rip)     # 0x1821c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Isomorphism.cpp
// Function: Isomorphism::canonicalNauty(char const*, char*, int)
void Isomorphism::canonicalNauty(const char *in, char *best, int size) {
  int i, j, aux;

  for (i=0; i<n; i++) {
    gv = GRAPHROW(g,i,m);
    EMPTYSET(gv,m);
    for (j=0; j<n; j++)
      if (in[i*size+j]=='1') ADDELEMENT(gv,j);
  }

  nauty(g,lab,ptn,NULL,orbits,&options,&stats,
	workspace,WORKSPACE_SIZE,m,n,mm);

  aux=0;
  for (i=0; i<n; i++) {
    gv = GRAPHROW(mm,i,m); 
    for (j=0; j<n; j++)
         best[aux++] = ISELEMENT(gv,j)?'1':'0';
  }
  best[aux]=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq 0x1a378(%rip), %rax     # 0x21520
testq %rax, %rax
jle 0x7235
movslq 0x1a36c(%rip), %rcx     # 0x21524
movl 0x1a362(%rip), %esi     # 0x21520
movslq %edx, %rdx
xorl %r8d, %r8d
leaq 0x1a365(%rip), %r9      # 0x21530
leaq 0xaa6e(%rip), %r10      # 0x11c40
movq %r8, %r11
imulq %rcx, %r11
leaq (%r9,%r11,4), %r11
movq %r11, 0x1a344(%rip)     # 0x21528
leaq (%r11,%rcx,4), %r14
addq $-0x4, %r14
cmpq %r11, %r14
jb 0x71fe
movl $0x0, (%r14)
addq $-0x4, %r14
jmp 0x71ec
testl %esi, %esi
jle 0x722a
xorl %r14d, %r14d
cmpb $0x31, (%rdi,%r14)
jne 0x7222
movl %r14d, %r15d
andl $0x1f, %r15d
movl (%r10,%r15,4), %ebp
movl %r14d, %r15d
shrl $0x5, %r15d
orl %ebp, (%r11,%r15,4)
incq %r14
cmpq %r14, %rsi
jne 0x7205
incq %r8
addq %rdx, %rdi
cmpq %rax, %r8
jne 0x71d2
movl 0x1a2e8(%rip), %r10d    # 0x21524
leaq 0x1a74d(%rip), %r14     # 0x21990
leaq 0x125d6(%rip), %r11     # 0x19820
leaq 0x1a6df(%rip), %r12     # 0x21930
leaq 0x1a2d8(%rip), %rdi     # 0x21530
leaq 0x1a461(%rip), %rsi     # 0x216c0
leaq 0x1a52a(%rip), %rdx     # 0x21790
leaq 0x1a5f3(%rip), %r8      # 0x21860
leaq 0x10fa4(%rip), %r9      # 0x18218
xorl %r15d, %r15d
xorl %ecx, %ecx
pushq %r14
pushq %rax
pushq %r10
pushq $0x1f40                 # imm = 0x1F40
pushq %r11
pushq %r12
callq 0xbd7c
addq $0x30, %rsp
cmpl $0x0, 0x1a289(%rip)     # 0x21520
jle 0x7312
leaq 0xa9a0(%rip), %rax      # 0x11c40
xorl %ecx, %ecx
movslq 0x1a27b(%rip), %rdx     # 0x21524
imulq %rcx, %rdx
leaq (%r14,%rdx,4), %rdx
movq %rdx, 0x1a270(%rip)     # 0x21528
cmpl $0x0, 0x1a261(%rip)     # 0x21520
jle 0x7300
movslq %r15d, %rdx
addq %rbx, %rdx
xorl %esi, %esi
movq 0x1a258(%rip), %rdi     # 0x21528
movl %esi, %r8d
shrl $0x5, %r8d
movl %esi, %r9d
andl $0x1f, %r9d
movl (%rax,%r9,4), %r9d
testl %r9d, (%rdi,%r8,4)
sete %dil
xorb $0x31, %dil
movb %dil, (%rdx,%rsi)
incq %rsi
cmpl 0x1a225(%rip), %esi     # 0x21520
jl 0x72c9
addl %esi, %r15d
incq %rcx
movslq 0x1a216(%rip), %rdx     # 0x21520
cmpq %rdx, %rcx
jl 0x72a2
movslq %r15d, %r15
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Isomorphism.cpp
// Function: Isomorphism::canonicalBigger2(char const*, char*, int)
void Isomorphism::canonicalBigger2(const char *in, char *best, int size) {
  int i;

  int perm[size];
  bool used[size];

  for (i=0; i<size; i++) used[i]=false;

  char current[size*size+1];
  for (i=0; i<size*size; i++) current[i]='2';
  current[size*size]=0;

  strcpy(best, in);

  _goCan2(0, in, perm, used, best, size, current);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movl %edx, %edx
movq %rsp, %rcx
leaq 0xf(,%rdx,4), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rsp, %r13
leaq 0xf(%rdx), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
testl %ebx, %ebx
jle 0x7bdd
movq %r13, %rdi
xorl %esi, %esi
callq 0x2120
movl %ebx, %r15d
imull %r15d, %r15d
movq %rsp, %r14
leaq 0x10(%r15), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testl %ebx, %ebx
je 0x7c10
cmpl $0x1, %r15d
movl %r15d, %edx
adcl $0x0, %edx
movq %r14, %rdi
movl $0x32, %esi
callq 0x2120
movl %r15d, %eax
movb $0x0, (%r14,%rax)
movq -0x40(%rbp), %r15
movq %r15, %rdi
movq -0x38(%rbp), %r12
movq %r12, %rsi
callq 0x21d0
subq $0x8, %rsp
xorl %edi, %edi
movq %r12, %rsi
movq -0x30(%rbp), %rdx
movq %r13, %rcx
movq %r15, %r8
movl %ebx, %r9d
pushq %r14
callq 0x78c6
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Error.cpp
// Function: Error::msg(char const*, ...)
void Error::msg(const char *format, ...) {
  va_list p;
  if (format == NULL)
    msg("%s", (char *)strerror (errno));
  else {
      fprintf (stderr, ERROR_HEADER);
      va_start (p, format);
      vfprintf (stderr, format, p);
      va_end (p);
      fprintf (stderr, "\n");
    }

  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x816e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
jne 0x8190
callq 0x2050
movl (%rax), %edi
callq 0x20b0
leaq 0x9b64(%rip), %rdi      # 0x11cea
movq %rax, %rsi
xorl %eax, %eax
callq 0x8110
movq %rdi, %rbx
movq 0xfe3e(%rip), %r14      # 0x17fd8
movq (%r14), %rcx
leaq 0x9b49(%rip), %rdi      # 0x11ced
movl $0x7, %esi
movl $0x1, %edx
callq 0x23e0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x22b0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x2280
movl $0x1, %edi
callq 0x2270
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::GTrieNode(int)
GTrieNode::GTrieNode(int d) {

  depth     = d;

  is_graph  = false;
  frequency = 0;
  nconn=0;

  if (d!=0) {
    in   = new bool[d];
    out  = new bool[d];
    conn = new int[d];
  } else {
    in = out = NULL;
    conn = NULL;
  }

  total_in = total_out = total_edges = 0;

  child.clear();
  cond.clear();
  this_node_cond.clear();

  cond_ok = false;
  cond_this_ok = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
movq %r14, 0x20(%rdi)
movq %r14, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %r15
movq %r15, 0x38(%rdi)
movq %r15, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movl %esi, 0x4c(%rdi)
movb $0x0, 0x50(%rdi)
movl %eax, 0x54(%rdi)
movl %eax, 0x74(%rdi)
testl %esi, %esi
je 0x827e
movl %esi, %ebp
movslq %esi, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, 0x58(%rbx)
movq %r12, %rdi
callq 0x2030
movq %rax, 0x60(%rbx)
shlq $0x2, %r12
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, 0x78(%rbx)
jmp 0x828d
movq $0x0, 0x78(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movl $0x0, 0x70(%rbx)
xorl %r12d, %r12d
movq %r12, 0x68(%rbx)
movq %r15, %rdi
callq 0xac80
movq %r14, %rdi
callq 0xae5e
movq %r14, 0x20(%rbx)
movq %r14, 0x18(%rbx)
movq %r12, 0x28(%rbx)
movq %rbx, %rdi
callq 0xaeb6
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq %r12, 0x10(%rbx)
movw $0x0, 0x48(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0xae5e
movq %rbx, %rdi
callq 0xaeb6
movq %r15, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::~GTrieNode()
GTrieNode::~GTrieNode() {
  if (depth!=0) {
    if (in  != NULL) delete[] in;
    if (out != NULL) delete[] out;
    if (conn != NULL) delete[] conn;
  }
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    delete *ii;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4c(%rdi)
je 0x832f
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x8313
callq 0x2290
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x8321
callq 0x2290
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x832f
callq 0x2290
leaq 0x30(%rbx), %r15
movq 0x30(%rbx), %r12
cmpq %r15, %r12
je 0x8361
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x835b
movq %r14, %rdi
callq 0x82f4
movl $0x80, %esi
movq %r14, %rdi
callq 0x2200
movq (%r12), %r12
jmp 0x8337
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x837e
movq (%rdi), %r14
movl $0x18, %esi
callq 0x2200
movq %r14, %rdi
cmpq %r15, %r14
jne 0x8369
leaq 0x18(%rbx), %rdi
callq 0xae5e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaeb6
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::frequencyGraph(Graph*)
int GTrieNode::frequencyGraph(Graph *g) {
  if (g->numNodes()==depth)
    return frequency;
  list<GTrieNode *>::iterator ii;
  int i;
  for(ii=child.begin(); ii!=child.end(); ii++) {
    for (i=0; i<=depth; i++)
      if (g->hasEdge(depth, i) != (*ii)->out[i] ||
	  g->hasEdge(i, depth) != (*ii)->in[i])
	break;
    if (i>depth) break;
  }
  if (ii!=child.end())
    return (*ii)->frequencyGraph(g);
  else
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
cmpl 0x4c(%r14), %eax
je 0x8714
leaq 0x30(%r14), %r13
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x8718
movl 0x4c(%r14), %esi
testl %esi, %esi
js 0x86fd
xorl %r15d, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %edx
callq *0x50(%rax)
movq 0x10(%r12), %rcx
movq 0x60(%rcx), %rcx
cmpb %al, (%rcx,%r15)
jne 0x86f8
movl 0x4c(%r14), %edx
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x50(%rax)
movq 0x10(%r12), %rcx
movq 0x58(%rcx), %rcx
cmpb %al, (%rcx,%r15)
jne 0x86f8
leaq 0x1(%r15), %rax
movslq 0x4c(%r14), %rsi
cmpq %rsi, %r15
movq %rax, %r15
jl 0x86ac
jmp 0x86ff
movq %r15, %rax
jmp 0x86ff
xorl %eax, %eax
cmpl 0x4c(%r14), %eax
jle 0x8698
cmpq %r13, %r12
je 0x8718
movq 0x10(%r12), %r14
jmp 0x867e
movl 0x54(%r14), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::insert(Graph*)
void GTrieNode::insert(Graph *g) {
  int i;


  if (g->numNodes() == depth) {
    is_graph = true;
  } else {
    list<GTrieNode *>::iterator ii;
    for(ii=child.begin(); ii!=child.end(); ii++) {
      for (i=0; i<=depth; i++)
	if (g->hasEdge(depth, i) != (*ii)->out[i] ||
	    g->hasEdge(i, depth) != (*ii)->in[i])
	  break;
      if (i>depth) break;
    }
    if (ii==child.end()) {
      GTrieNode *gt = new GTrieNode(depth+1);
      for (i=0; i<=depth; i++) {
      	gt->out[i] = g->hasEdge(depth, i);	
      	gt->in[i]  = g->hasEdge(i, depth);
	if (g->isConnected(depth, i)) 
	  gt->conn[(gt->nconn)++] = i;

	if (gt->in[i])  { (gt->total_in)++;  (gt->total_edges)++;}
	if (gt->out[i]) { (gt->total_out)++; (gt->total_edges)++;}
      }
      gt->insert(g);
      child.push_back(gt);
    } else
      (*ii)->insert(g);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
cmpl 0x4c(%rbx), %eax
je 0x87c5
leaq 0x30(%rbx), %r15
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x87b7
movl 0x4c(%rbx), %esi
testl %esi, %esi
js 0x87b0
xorl %r12d, %r12d
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %edx
callq *0x50(%rax)
movq 0x10(%r13), %rcx
movq 0x60(%rcx), %rcx
cmpb %al, (%rcx,%r12)
jne 0x87ab
movl 0x4c(%rbx), %edx
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %esi
callq *0x50(%rax)
movq 0x10(%r13), %rcx
movq 0x58(%rcx), %rcx
cmpb %al, (%rcx,%r12)
jne 0x87ab
leaq 0x1(%r12), %rax
movslq 0x4c(%rbx), %rsi
cmpq %rsi, %r12
movq %rax, %r12
jl 0x8761
jmp 0x87b2
movq %r12, %rax
jmp 0x87b2
xorl %eax, %eax
cmpl 0x4c(%rbx), %eax
jle 0x874e
cmpq %r15, %r13
je 0x87ce
movq 0x10(%r13), %rbx
jmp 0x8739
movb $0x1, 0x50(%rbx)
jmp 0x88b4
movl $0x80, %edi
callq 0x21f0
movq %rax, %r12
movl 0x4c(%rbx), %esi
incl %esi
movq %rax, %rdi
callq 0x81fc
movl 0x4c(%rbx), %esi
testl %esi, %esi
js 0x888c
xorl %r13d, %r13d
movq (%r14), %rax
movq %r14, %rdi
movl %r13d, %edx
callq *0x50(%rax)
movq 0x60(%r12), %rcx
movb %al, (%rcx,%r13)
movl 0x4c(%rbx), %edx
movq (%r14), %rax
movq %r14, %rdi
movl %r13d, %esi
callq *0x50(%rax)
movq 0x58(%r12), %rcx
movb %al, (%rcx,%r13)
movl 0x4c(%rbx), %esi
movq (%r14), %rax
movq %r14, %rdi
movl %r13d, %edx
callq *0x58(%rax)
testb %al, %al
je 0x884c
movq 0x78(%r12), %rax
movslq 0x74(%r12), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x74(%r12)
movl %r13d, (%rax,%rcx,4)
movq 0x58(%r12), %rax
cmpb $0x1, (%rax,%r13)
jne 0x8862
incl 0x68(%r12)
incl 0x70(%r12)
movq 0x60(%r12), %rax
cmpb $0x1, (%rax,%r13)
jne 0x8878
incl 0x6c(%r12)
incl 0x70(%r12)
leaq 0x1(%r13), %rax
movslq 0x4c(%rbx), %rsi
cmpq %rsi, %r13
movq %rax, %r13
jl 0x87f6
movq %r12, %rdi
movq %r14, %rsi
callq 0x872a
movl $0x18, %edi
callq 0x21f0
movq %r12, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2070
incq 0x40(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x80, %esi
movq %r12, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::countNodes()
int GTrieNode::countNodes() {
  int aux=1;
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    aux += (*ii)->countNodes();

  return aux;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
addq $0x30, %rbx
movl $0x1, %ebp
cmpq %rbx, %r14
je 0x8f25
movq 0x10(%r14), %rdi
callq 0x8efc
addl %eax, %ebp
movq (%r14), %r14
jmp 0x8f10
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::zeroFrequency()
void GTrieNode::zeroFrequency() {
  frequency = 0;
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    (*ii)->zeroFrequency();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x54(%rdi)
movq 0x30(%rdi), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x8f55
movq 0x10(%r14), %rdi
callq 0x8f2c
movq (%r14), %r14
jmp 0x8f42
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::showFrequency()
void GTrieNode::showFrequency() {
  if (is_graph) printf("%d \n", frequency);
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    (*ii)->showFrequency();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x50(%rdi)
jne 0x8f7c
movl 0x54(%rbx), %esi
leaq 0x8da4(%rip), %rdi      # 0x11d19
xorl %eax, %eax
callq 0x2060
movq 0x30(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x8f97
movq 0x10(%r14), %rdi
callq 0x8f5e
movq (%r14), %r14
jmp 0x8f84
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::maxDepth()
int GTrieNode::maxDepth() {
  int aux = 0;
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    aux=max(aux, 1+(*ii)->maxDepth());
  return aux;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
addq $0x30, %rbx
xorl %ebp, %ebp
cmpq %rbx, %r14
je 0x8fcb
movq 0x10(%r14), %rdi
callq 0x8fa0
incl %eax
cmpl %eax, %ebp
cmovlel %eax, %ebp
movq (%r14), %r14
jmp 0x8fb1
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::countGraphsApp()
int GTrieNode::countGraphsApp() {
  int aux=0;
  if (is_graph && frequency>0) aux++;
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    aux += (*ii)->countGraphsApp();

  return aux;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $0x0, 0x54(%rdi)
setg %al
andb 0x50(%rdi), %al
movzbl %al, %ebx
movq 0x30(%rdi), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x96a8
movq 0x10(%r15), %rdi
callq 0x9676
addl %eax, %ebx
movq (%r15), %r15
jmp 0x9693
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::countGraphs()
int GTrieNode::countGraphs() {
  int aux=0;
  if (is_graph) aux=1;
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    aux += (*ii)->countGraphs();

  return aux;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movzbl 0x50(%rdi), %ebx
movq 0x30(%rdi), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x96d9
movq 0x10(%r15), %rdi
callq 0x96b0
addl %eax, %ebx
movq (%r15), %r15
jmp 0x96c4
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::countGraphPaths()
int GTrieNode::countGraphPaths() {
  int aux=0;
  if (is_graph) aux=depth;
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    aux += (*ii)->countGraphPaths();

  return aux;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
cmpb $0x0, 0x50(%rdi)
je 0x96f6
movl 0x4c(%r14), %ebx
movq 0x30(%r14), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x9713
movq 0x10(%r15), %rdi
callq 0x96e2
addl %eax, %ebx
movq (%r15), %r15
jmp 0x96fe
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::countOccurrences()
double GTrieNode::countOccurrences() {
  double aux=0;
  if (is_graph && frequency>0) aux+=frequency;
  
  list<GTrieNode *>::iterator ii;
  for(ii=child.begin(); ii!=child.end(); ii++)
    aux += (*ii)->countOccurrences();

  return aux;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
cmpb $0x1, 0x50(%rdi)
jne 0x973b
movl 0x54(%rbx), %eax
testl %eax, %eax
jle 0x973b
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x30(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x976e
movsd %xmm0, (%rsp)
movq 0x10(%r14), %rdi
callq 0x971c
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq (%r14), %r14
jmp 0x9743
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::populateGraphTree(GraphTree*, char*, int)
void GTrieNode::populateGraphTree(GraphTree *tree, char *s, int size) {
  int i, pos=depth-1;
  
  for (i=0;i<depth;i++) {
    s[pos*size+i]=out[i]?'1':'0';
    s[i*size+pos]=in[i]?'1':'0';
  }

  if (is_graph)
    tree->setString(s, frequency);

  list<GTrieNode *>::const_iterator ii, iiend;
  for(ii=child.begin(), iiend = child.end(); ii!=iiend; ++ii)
    (*ii)->populateGraphTree(tree, s, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x4c(%rdi), %rdx
testq %rdx, %rdx
jle 0x9d63
leaq -0x1(%rdx), %rax
imull %ebx, %eax
cltq
movslq %ebx, %rcx
addq %r14, %rax
addq %r14, %rdx
decq %rdx
xorl %esi, %esi
movq 0x60(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rax,%rsi)
movq 0x58(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rdx)
incq %rsi
movslq 0x4c(%r12), %rdi
addq %rcx, %rdx
cmpq %rdi, %rsi
jl 0x9d32
cmpb $0x1, 0x50(%r12)
jne 0x9d7b
movl 0x54(%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xbc5a
movq 0x30(%r12), %r13
addq $0x30, %r12
cmpq %r12, %r13
je 0x9da0
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x9cfe
movq (%r13), %r13
jmp 0x9d84
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::populateMap(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>*, char*, int)
void GTrieNode::populateMap(mapStringInt *m, char *s, int size) {
  int i, pos=depth-1;

  for (i=0;i<depth;i++) {
    s[pos*size+i]=out[i]?'1':'0';
    s[i*size+pos]=in[i]?'1':'0';
  }

  if (is_graph && frequency>0) (*m)[s]=frequency;

  list<GTrieNode *>::const_iterator ii, iiend;
  for(ii=child.begin(), iiend = child.end(); ii!=iiend; ++ii)
    (*ii)->populateMap(m, s, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x4c(%rdi), %rdx
testq %rdx, %rdx
jle 0x9e14
leaq -0x1(%rdx), %rax
imull %ebx, %eax
cltq
movslq %ebx, %rcx
addq %r14, %rax
addq %r14, %rdx
decq %rdx
xorl %esi, %esi
movq 0x60(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rax,%rsi)
movq 0x58(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rdx)
incq %rsi
movslq 0x4c(%r12), %rdi
addq %rcx, %rdx
cmpq %rdi, %rsi
jl 0x9de3
cmpb $0x1, 0x50(%r12)
jne 0x9e62
movl 0x54(%r12), %ebp
testl %ebp, %ebp
jle 0x9e62
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0xae20
movq %r15, %rdi
movq %r13, %rsi
callq 0xada4
movl %ebp, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e62
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x30(%r12), %r13
addq $0x30, %r12
cmpq %r12, %r13
je 0x9e87
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x9daa
movq (%r13), %r13
jmp 0x9e6b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9eb4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::frequencyGraphString(int, char const*)
int GTrie::frequencyGraphString(int size, const char *s) {
  char larger[size*size+1];
  Isomorphism::canonicalBasedNauty(s, larger, size);

  Graph *g = new GraphMatrix();
  GraphUtils::strToGraph(g, larger, size, DIRECTED); // May change later
  int aux = _root->frequencyGraph(g);
  delete g;
  
  return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %eax
imull %eax, %eax
movq %rsp, %r12
addl $0x10, %eax
andl $-0x10, %eax
subq %rax, %r12
movq %r12, %rsp
movq %rdx, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x7320
movl $0x58, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x485c
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x595e
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x8668
movl %eax, %ebx
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movl %ebx, %eax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::insertGraphString(int, char const*)
void GTrie::insertGraphString(int size, const char *s) {
  char larger[size*size+1];
  Isomorphism::canonicalBigger(s, larger, size);


  Graph *g = new GraphMatrix();
  GraphUtils::strToGraph(g, larger, size, DIRECTED); // May change later
  list<iPair> *cond = new list<iPair>;
  Conditions::symmetryConditions(g, cond);

  insertGraphCond(g, cond);

  delete cond;
  delete g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %eax
imull %eax, %eax
movq %rsp, %r12
addl $0x10, %eax
andl $-0x10, %eax
subq %rax, %r12
movq %r12, %rsp
movq %rdx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x7706
movl $0x58, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x485c
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x595e
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x69ac
movq (%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x88d6
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xa07e
movq (%rdi), %r14
movl $0x18, %esi
callq 0x2200
movq %r14, %rdi
cmpq %r15, %r14
jne 0xa069
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::readSubgraphs(int, bool, char*)
void GTrie::readSubgraphs(int size, bool dir, char *s) {
  char buf[MAX_BUF];

  FILE *f = fopen(s, "r");
  if (!f) Error::msg(NULL);
  while (fscanf(f, "%s", buf)==1) {
    insertGraphNautyString(size, buf, dir, 1);
  }
  fclose(f);
  cleanConditions();  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x79d5(%rip), %rsi      # 0x11aaf
movq %rcx, %rdi
callq 0x2250
movq %rax, %r14
testq %rax, %rax
jne 0xa0f3
xorl %edi, %edi
xorl %eax, %eax
callq 0x8110
leaq 0x7bf0(%rip), %rsi      # 0x11cea
movq %rsp, %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x23b0
cmpl $0x1, %eax
jne 0xa145
movzbl %r15b, %r15d
movq %rsp, %r12
leaq 0x7bd0(%rip), %r13      # 0x11cea
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %r15d, %ecx
movl $0x1, %r8d
callq 0xa168
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x23b0
cmpl $0x1, %eax
je 0xa11a
movq %r14, %rdi
callq 0x21e0
movq (%rbx), %rdi
callq 0xaba8
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::insertGraphNautyString(int, char const*, bool, int)
void GTrie::insertGraphNautyString(int size, const char *s, bool dir, int label) {
  char larger[size*size+1];

  if (label==2)
    Isomorphism::canonicalBigger(s, larger, size);
  else if (label==3)
    Isomorphism::canonicalRandom(s, larger, size);
  else if (label==4)
    Isomorphism::canonicalBasedNautyReverse(s, larger, size);
  else
    Isomorphism::canonicalBasedNauty(s, larger, size);

  Graph *g = new GraphMatrix();

  if (dir)  GraphUtils::strToGraph(g, larger, size, DIRECTED);
  else      GraphUtils::strToGraph(g, larger, size, UNDIRECTED);

  g->makeArrayNeighbours();

  list<iPair> *cond = new list<iPair>;
  Conditions::symmetryConditions(g, cond);  

  insertGraphCond(g, cond);

  delete cond;
  delete g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %eax
imull %eax, %eax
movq %rsp, %r13
addl $0x10, %eax
andl $-0x10, %eax
subq %rax, %r13
movq %r13, %rsp
movq %rdx, %rdi
movq %r13, %rsi
movl %r15d, %edx
cmpl $0x4, %r8d
je 0xa1bc
cmpl $0x3, %r8d
je 0xa1b5
cmpl $0x2, %r8d
jne 0xa1c3
callq 0x7706
jmp 0xa1c8
callq 0x7c58
jmp 0xa1c8
callq 0x7e28
jmp 0xa1c8
callq 0x7320
movl $0x58, %edi
callq 0x21f0
movq %rax, %r14
movq %rax, %rdi
callq 0x485c
xorb $0x1, %r12b
movzbl %r12b, %ecx
movq %r14, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x595e
movq (%r14), %rax
movq %r14, %rdi
callq *0x88(%rax)
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x69ac
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x88d6
movq (%r15), %rdi
cmpq %r15, %rdi
je 0xa251
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x2200
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0xa23c
movl $0x18, %esi
movq %r15, %rdi
callq 0x2200
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r14, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::writeToFile(char*)
void GTrie::writeToFile(char *s) {
  FILE *f;
  
  f=fopen(s,"w");
  if (f!=NULL) {
    fputs("GTRIEFORMAT VERSION 1\n", f);
    _root->writeToFile(f);
    fclose(f);
  } else
    Error::msg("Unable to open g-trie output file \"%s\")", s);    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6c5c(%rip), %rsi      # 0x110f2
movq %r15, %rdi
callq 0x2250
testq %rax, %rax
je 0xa4cd
movq %rax, %r14
leaq 0x7896(%rip), %rdi      # 0x11d43
movq %rax, %rsi
callq 0x2220
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x9776
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
leaq 0x7886(%rip), %rdi      # 0x11d5a
movq %r15, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8110
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::readFromFile(char*)
void GTrie::readFromFile(char *s) {
  FILE *f;
  char *dummy, buf[MAX_BUF];
  
  f=fopen(s,"r");
  if (!f) Error::msg(NULL);
  dummy=fgets(buf, MAX_BUF, f);
  _root->readFromFile(f);
  fclose(f);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rax
movq %rdi, %r14
leaq 0x75b4(%rip), %rsi      # 0x11aaf
movq %rax, %rdi
callq 0x2250
movq %rax, %rbx
testq %rax, %rax
jne 0xa514
xorl %edi, %edi
xorl %eax, %eax
callq 0x8110
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x2320
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x9968
movq %rbx, %rdi
callq 0x21e0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::censusSample(Graph*, double*)
void GTrie::censusSample(Graph *g, double *p) {
  int i;
  int subgraph_size = maxDepth();
  int num_nodes = g->numNodes();

  _root->zeroFrequency();
  
  GTrieNode::mymap = new int[subgraph_size];
  GTrieNode::used  = new bool[num_nodes];
  GTrieNode::numNodes = num_nodes;
  GTrieNode::fastnei  = g->matrixNeighbours();
  GTrieNode::adjM     = g->adjacencyMatrix();
  GTrieNode::numnei   = g->arrayNumNeighbours(); 
  GTrieNode::prob     = p;

  if (g->type() == DIRECTED) GTrieNode::isdir = true;
  else                       GTrieNode::isdir = false;
  for (i=0; i<num_nodes; i++)
    GTrieNode::used[i]=false;


  list<GTrieNode *>::iterator ii, iiend;
  GTrieNode::glk=0;
  for(ii=_root->child.begin(), iiend = _root->child.end(); ii!=iiend; ii++)
    if (Random::getDouble()<=GTrieNode::prob[0]) {
      (*ii)->goCondSample();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8fa0
movl %eax, %r12d
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x8f2c
movslq %r12d, %rax
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, 0x1754f(%rip)     # 0x21b40
movslq %ebp, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, 0x17545(%rip)     # 0x21b48
movl %r12d, 0x17562(%rip)    # 0x21b6c
movq (%r14), %rax
movq %r14, %rdi
callq *0xa0(%rax)
movq %rax, 0x1753b(%rip)     # 0x21b58
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, 0x17524(%rip)     # 0x21b50
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
movq %rax, 0x17521(%rip)     # 0x21b60
movq %r15, 0x17532(%rip)     # 0x21b78
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testl %eax, %eax
sete 0x17518(%rip)           # 0x21b70
testl %r12d, %r12d
jle 0xa66d
movq 0x174e4(%rip), %rdi     # 0x21b48
movl %ebp, %edx
xorl %esi, %esi
callq 0x2120
movl $0x0, 0x174f1(%rip)     # 0x21b68
movq (%rbx), %rbx
movq 0x30(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0xa6ab
callq 0xb21a
movq 0x174e5(%rip), %rax     # 0x21b78
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0xa6a6
movq 0x10(%r14), %rdi
callq 0xa6b4
movq (%r14), %r14
jmp 0xa682
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::clean(int, int)
void GTrieNode::clean(int a, int b) {
  list< list<iPair> >::iterator ii;
  list<iPair> ::iterator jj;

  if (cond.size()>0) {

    for (ii=cond.begin(); ii!=cond.end(); ii++) {
      for (jj=ii->begin(); jj!=ii->end();)
	  if (jj->first==a && jj->second==b)
	    jj = ii->erase(jj);
	  else
	    jj++;
      if (ii->size()==0) {
	ii->clear();
	cond_ok = true;
      }
    }    
  }

  list<GTrieNode *>::iterator cc;
  for(cc=child.begin(); cc!=child.end(); cc++)
    (*cc)->clean(a, b);	

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x28(%rdi)
je 0xab74
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq (%rax), %r13
movq %rax, 0x10(%rsp)
cmpq %rax, %r13
je 0xab74
leaq 0x10(%r13), %r15
movq 0x10(%r13), %r12
cmpq %r15, %r12
je 0xab51
cmpl %ebp, 0x10(%r12)
jne 0xab4b
cmpl %ebx, 0x14(%r12)
jne 0xab4b
movq (%r12), %r14
decq 0x20(%r13)
movq %r12, %rdi
callq 0x2350
movl $0x18, %esi
movq %r12, %rdi
callq 0x2200
movq %r14, %r12
jmp 0xab16
movq (%r12), %r12
jmp 0xab16
cmpq $0x0, 0x20(%r13)
jne 0xab69
movq %r15, %rdi
callq 0x6bca
movq 0x8(%rsp), %rax
movb $0x1, 0x48(%rax)
movq (%r13), %r13
cmpq 0x10(%rsp), %r13
jne 0xab0e
movq 0x8(%rsp), %r14
movq 0x30(%r14), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0xab98
movq 0x10(%r15), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xaada
movq (%r15), %r15
jmp 0xab81
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::cleanConditions()
void GTrieNode::cleanConditions() {
  int a, b;
  list< list<iPair> >::iterator ii;
  list<iPair> ::iterator jj, kk;

  if (cond.size()>0) {
    for (jj=cond.begin()->begin(); jj!=cond.begin()->end();jj++) {
      a=jj->first;
      b=jj->second;
      for (ii=cond.begin(); ii!=cond.end(); ii++) {
	for (kk=ii->begin(); kk!=ii->end(); kk++)
	  if (kk->first==a && kk->second==b) break;
	if (kk==ii->end()) break;
      }
      if (ii==cond.end())  {
	list<GTrieNode *>::iterator ii;
	for(ii=child.begin(); ii!=child.end(); ii++)
	  (*ii)->clean(a, b);	
      }
    }
  }

  list<GTrieNode *>::iterator cc;
  for(cc=child.begin(); cc!=child.end(); cc++)
    (*cc)->cleanConditions();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, 0x28(%rdi)
je 0xac52
movq (%rsp), %rax
leaq 0x18(%rax), %r15
movq (%r15), %rax
leaq 0x10(%rax), %rcx
movq 0x10(%rax), %r12
cmpq %rcx, %r12
je 0xac52
movq (%rsp), %rcx
leaq 0x30(%rcx), %r13
movl 0x10(%r12), %ebp
movl 0x14(%r12), %r14d
cmpq %r15, %rax
je 0xac18
leaq 0x10(%rax), %rcx
movq 0x10(%rax), %rdx
cmpq %rcx, %rdx
je 0xac0e
cmpl %ebp, 0x10(%rdx)
jne 0xac09
cmpl %r14d, 0x14(%rdx)
je 0xac0e
movq (%rdx), %rdx
jmp 0xabf9
cmpq %rcx, %rdx
je 0xac18
movq (%rax), %rax
jmp 0xabec
cmpq %r15, %rax
setne %al
movq (%r13), %rbx
cmpq %r13, %rbx
sete %cl
orb %al, %cl
jne 0xac42
movq 0x10(%rbx), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0xaada
movq (%rbx), %rbx
cmpq %r13, %rbx
jne 0xac2c
movq (%r12), %r12
movq (%r15), %rax
leaq 0x10(%rax), %rcx
cmpq %rcx, %r12
jne 0xabe2
movq (%rsp), %r14
movq 0x30(%r14), %rbx
addq $0x30, %r14
cmpq %r14, %rbx
je 0xac71
movq 0x10(%rbx), %rdi
callq 0xaba8
movq (%rbx), %rbx
jmp 0xac5e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq