LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x4a5c
movq %rdi, %rbx
movb $0x0, (%rax,%r14)
imulq $0x18, %r15, %r12
movq 0x40(%rdi), %rsi
addq %r12, %rsi
movl %r14d, %edx
callq 0x4a66
movq 0x20(%rbx), %rax
decl (%rax,%r15,4)
imulq $0x18, %r14, %r13
movq 0x48(%rbx), %rsi
addq %r13, %rsi
movl %r15d, %edx
callq 0x4a66
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 0x4a5c
addq 0x50(%rbx), %r12
movq %r12, %rsi
movl %r14d, %edx
callq 0x4a66
movq 0x28(%rbx), %rax
decl (%rax,%r15,4)
addq 0x50(%rbx), %r13
movq %r13, %rsi
movl %r15d, %edx
callq 0x4a66
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_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0xc(%rdi), %r13
leaq (,%r13,8), %rdi
testq %r13, %r13
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, 0x38(%rbx)
xorl %r12d, %r12d
movslq %r13d, %rax
cmpq %rax, %r12
jge 0x4bc0
movq 0x50(%rbx), %rax
imulq $0x18, %r12, %r13
movq 0x8(%rax,%r13), %rdi
subq (%rax,%r13), %rdi
cmovsq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%r12,8)
movq 0x38(%rbx), %r14
movq 0x50(%rbx), %rdx
leaq (%rdx,%r13), %rax
movq (%rdx,%r13), %rcx
movq 0x8(%rdx,%r13), %rdx
xorl %esi, %esi
leaq (%rcx,%rsi), %rdi
cmpq %rdx, %rdi
je 0x4bae
movl (%rdi), %edi
movq (%r14,%r12,8), %r8
movl %edi, (%r8,%rsi)
addq $0x4, %rsi
jmp 0x4b95
cmpq %rcx, %rdx
je 0x4bb7
movq %rcx, 0x8(%rax)
incq %r12
movl 0xc(%rbx), %r13d
jmp 0x4b58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jge 0x4c1e
imulq $0x18, %r14, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r13
jge 0x4c19
movq 0x50(%rbx), %rdi
addq %r15, %rdi
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rsi
addq %r12, %rsi
callq 0x4c68
incq %r13
addq $0x4, %r12
jmp 0x4bec
incq %r14
jmp 0x4bd9
cmpq $0x0, 0x38(%rbx)
je 0x4c5d
xorl %r14d, %r14d
movslq %eax, %rcx
movq 0x38(%rbx), %rdi
cmpq %rcx, %r14
jge 0x4c4a
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4c45
callq 0x22b0
movl 0xc(%rbx), %eax
incq %r14
jmp 0x4c28
testq %rdi, %rdi
je 0x4c5d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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)
movslq %ebp, %rax
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %ebp
cmovgl %eax, %ebp
movq %rax, (%rsp)
movl %eax, %r13d
cmpq %rbp, %r15
je 0x5551
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x5548
cmpb $0x31, (%rbx,%r12)
jne 0x5543
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq *0x30(%rax)
incq %r12
jmp 0x5528
incq %r15
addq (%rsp), %rbx
jmp 0x5520
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x13b48(%rip)     # 0x197bc
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r15d
movl %eax, 0x13b3d(%rip)     # 0x197c0
movl %ebp, %edi
shlq $0x2, %rdi
testl %ebp, %ebp
pushq $-0x1
popq %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x13b29(%rip)     # 0x197c8
movl %r15d, %edi
shlq $0x2, %rdi
testl %r15d, %r15d
cmovsq %r12, %rdi
callq 0x2030
andl $0x0, 0x13b0b(%rip)     # 0x197c4
movq %rax, 0x13b10(%rip)     # 0x197d0
movq %r14, 0x13b11(%rip)     # 0x197d8
movq %rbx, 0x13b1a(%rip)     # 0x197e8
movq %rbx, %rdi
callq 0xb4ac
xorl %ebx, %ebx
leaq 0xc(%rsp), %r14
cmpl 0x13add(%rip), %ebx     # 0x197c0
jge 0x5cf7
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x587c
incl %ebx
jmp 0x5cdd
movq 0x13aca(%rip), %rdi     # 0x197c8
testq %rdi, %rdi
je 0x5d08
callq 0x22b0
movq 0x13ac1(%rip), %rdi     # 0x197d0
addq $0x10, %rsp
testq %rdi, %rdi
je 0x5d25
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x13a72(%rip)     # 0x197bc
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r12d
movl %eax, 0x13a67(%rip)     # 0x197c0
movl %ebp, %edi
shlq $0x2, %rdi
testl %ebp, %ebp
pushq $-0x1
popq %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, 0x13a53(%rip)     # 0x197c8
movl %r12d, %edi
shlq $0x2, %rdi
testl %r12d, %r12d
cmovsq %r13, %rdi
callq 0x2030
andl $0x0, 0x13a35(%rip)     # 0x197c4
movq %rax, 0x13a3a(%rip)     # 0x197d0
movq %r15, 0x13a3b(%rip)     # 0x197d8
movq %rbx, 0x13a44(%rip)     # 0x197e8
movq %r14, 0x13a35(%rip)     # 0x197e0
movq %rbx, %rdi
callq 0xb4ac
xorl %ebx, %ebx
leaq 0x4(%rsp), %r14
cmpl 0x13a00(%rip), %ebx     # 0x197c0
jge 0x5dea
callq 0xab36
movq 0x13a12(%rip), %rax     # 0x197e0
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0x5de6
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x5a92
incl %ebx
jmp 0x5dba
movq 0x139d7(%rip), %rdi     # 0x197c8
testq %rdi, %rdi
je 0x5dfb
callq 0x22b0
movq 0x139ce(%rip), %rdi     # 0x197d0
addq $0x8, %rsp
testq %rdi, %rdi
je 0x5e1a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movq %rdi, %r15
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %esi, %edi
shlq $0x2, %rdi
xorl %r13d, %r13d
testl %esi, %esi
pushq $-0x1
popq %rbp
cmovsq %rbp, %rdi
cmovlel %r13d, %r14d
callq 0x2030
movq %rax, %r12
movq %rax, 0x8(%r15)
movl %ebx, %edi
shlq $0x2, %rdi
testl %ebx, %ebx
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, 0x10(%r15)
cmpq %r13, %r14
je 0x5e8c
orl $-0x1, (%r12,%r13,4)
incq %r13
jmp 0x5e7d
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x5ea1
orl $-0x1, (%rax,%rcx,4)
incq %rcx
jmp 0x5e93
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ecx
movl %edi, 0x1ac65(%rip)     # 0x21540
leal 0x1f(%rcx), %eax
pushq $0x20
popq %rdi
cltd
idivl %edi
movl %eax, 0x1ac5a(%rip)     # 0x21544
movl %eax, %esi
movl %ecx, %edx
movl $0x960, %ecx            # imm = 0x960
callq 0xc7ff
movb %bl, 0x1b04a(%rip)      # 0x21948
movl $0x1, 0x11930(%rip)     # 0x18238
andl $0x0, 0x11931(%rip)     # 0x18240
movl %ebx, 0x11927(%rip)     # 0x1823c
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Isomorphism.cpp
// Function: Isomorphism::_goCan(int, int, char const*, char*, char*, char*, char*, int)
void Isomorphism::_goCan(int x, int pos, const char *in, 
	   char *perm, char *used,
	   char *current, char *best, int size) {
  int i, j;

  if (strcmp(current, best)<0) return;

  if (pos == size) {
    strcpy(best, current);
  } else {

    int nedges[size], max=-1;
    for (i=0; i<size; i++)
      if (!used[i]) {
	nedges[i]=0;
	for (j=0; j<size; j++)
	  if (!used[j] && in[i*size+j]=='1')
	    nedges[i]++;
	if (nedges[i]>max) max=nedges[i];
      }
    

    for (i=0; i<size; i++)
      if (!used[i] /*&& nedges[i]==max*/) {
	used[i]=1;
	perm[pos]=i;
	current[pos*size+pos] = in[i*size+i];
	for (j=0; j<pos; j++) {
	  current[pos*size+j] = in[i*size+perm[j]]; 
	  current[j*size+pos] = in[perm[j]*size+i]; 
	}
	_goCan(i, pos+1, in, perm, used, current, best, size);
	current[pos*size+pos] = '2';
	for (j=0; j<pos; j++) {
	  current[pos*size+j] = '2';
	  current[j*size+pos] = '2';
	}
	used[i]=0;
      }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rdi
movq %r8, 0x18(%rsp)
movq %rcx, %r15
movq %rdx, 0x20(%rsp)
movl %esi, %r13d
movl 0x98(%rsp), %ebx
movq 0x90(%rsp), %rsi
movq %r9, (%rsp)
movq %rsi, 0x10(%rsp)
callq 0x2300
testl %eax, %eax
js 0x6caf
cmpl %ebx, %r13d
jne 0x6b75
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
movq %rsp, 0x28(%rsp)
movslq %ebx, %rbp
xorl %r12d, %r12d
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
movslq %r13d, %rsi
movq %rbx, 0x50(%rsp)
movl %ebx, %eax
imull %r13d, %eax
leal (%rax,%r13), %ecx
movslq %ecx, %rdi
leal 0x1(%r13), %ecx
movl %ecx, 0xc(%rsp)
testl %r13d, %r13d
cmovlel %r12d, %r13d
movslq %eax, %rbx
movq (%rsp), %rax
addq %rax, %rbx
movq %rsi, 0x40(%rsp)
leaq (%rax,%rsi), %r10
movb $0x32, %r14b
movq 0x18(%rsp), %r8
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq %r10, 0x30(%rsp)
cmpq %rdx, %r12
je 0x6caa
cmpb $0x0, (%r8,%r12)
jne 0x6ca2
movb $0x1, (%r8,%r12)
movq 0x40(%rsp), %rax
movb %r12b, (%r15,%rax)
movq %r12, %rax
imulq %rbp, %rax
movq 0x20(%rsp), %rsi
addq %rsi, %rax
movb (%r12,%rax), %cl
movq (%rsp), %rdx
movb %cl, (%rdx,%rdi)
leaq (%rsi,%r12), %rcx
movq %r10, %rdx
xorl %esi, %esi
cmpq %rsi, %r13
je 0x6c47
movsbq (%r15,%rsi), %rdi
movb (%rax,%rdi), %dil
movb %dil, (%rbx,%rsi)
movsbq (%r15,%rsi), %rdi
imulq %rbp, %rdi
movb (%rcx,%rdi), %dil
movb %dil, (%rdx)
incq %rsi
addq %rbp, %rdx
jmp 0x6c1d
movl 0xc(%rsp), %esi
movq 0x20(%rsp), %rdx
movq %r15, %rcx
movq (%rsp), %r9
pushq 0x50(%rsp)
pushq 0x18(%rsp)
callq 0x6b0e
movq 0x40(%rsp), %r10
addq $0x10, %rsp
movq 0x38(%rsp), %rdi
movq (%rsp), %rax
movb $0x32, (%rax,%rdi)
movq %r10, %rax
xorl %ecx, %ecx
movq 0x48(%rsp), %rdx
cmpq %rcx, %r13
je 0x6c98
movb %r14b, (%rbx,%rcx)
movb %r14b, (%rax)
incq %rcx
addq %rbp, %rax
jmp 0x6c84
movq 0x18(%rsp), %r8
movb $0x0, (%r8,%r12)
incq %r12
jmp 0x6bd8
movq 0x28(%rsp), %rsp
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x1a86e(%rip), %eax     # 0x21540
movslq 0x1a86b(%rip), %r10     # 0x21544
movslq %edx, %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
leaq (,%r10,4), %r8
leaq 0x1a859(%rip), %r9      # 0x21550
leaq (%r9,%r10,4), %r11
addq $-0x4, %r11
leaq 0x9eea(%rip), %r14      # 0x10bf0
cmpq %rsi, %rdx
je 0x6d65
movq %rdx, %r15
imulq %r10, %r15
leaq (%r9,%r15,4), %r15
movq %r15, 0x1a82b(%rip)     # 0x21548
movq %r11, %r12
cmpq %r15, %r12
jb 0x6d30
andl $0x0, (%r12)
addq $-0x4, %r12
jmp 0x6d20
xorl %r12d, %r12d
cmpq %r12, %rax
je 0x6d5a
cmpb $0x31, (%rdi,%r12)
jne 0x6d55
movl %r12d, %r13d
andl $0x1f, %r13d
movl (%r14,%r13,4), %ebp
movl %r12d, %r13d
shrl $0x5, %r13d
orl %ebp, (%r15,%r13,4)
incq %r12
jmp 0x6d33
incq %rdx
addq %r8, %r11
addq %rcx, %rdi
jmp 0x6d06
leaq 0x1ac44(%rip), %r15     # 0x219b0
leaq 0x12acd(%rip), %r11     # 0x19840
leaq 0x1abd6(%rip), %r13     # 0x21950
leaq 0x1a7cf(%rip), %rdi     # 0x21550
leaq 0x1a958(%rip), %rsi     # 0x216e0
leaq 0x1aa21(%rip), %rdx     # 0x217b0
leaq 0x1aaea(%rip), %r8      # 0x21880
leaq 0x1149b(%rip), %r9      # 0x18238
xorl %r12d, %r12d
xorl %ecx, %ecx
pushq %r15
pushq %rax
pushq %r10
pushq $0x1f40                 # imm = 0x1F40
pushq %r11
pushq %r13
callq 0xb5e4
addq $0x30, %rsp
movl 0x1a781(%rip), %ecx     # 0x21540
xorl %eax, %eax
movslq %ecx, %rsi
movslq %eax, %rdx
cmpq %rsi, %r12
jge 0x6e21
movslq 0x1a771(%rip), %rsi     # 0x21544
imulq %r12, %rsi
leaq (%r15,%rsi,4), %rsi
movq %rsi, 0x1a766(%rip)     # 0x21548
addq %rbx, %rdx
xorl %esi, %esi
cmpl %ecx, %esi
jge 0x6e1a
movq 0x1a756(%rip), %rcx     # 0x21548
movl %esi, %edi
shrl $0x5, %edi
movl %esi, %r8d
andl $0x1f, %r8d
movl (%r14,%r8,4), %r8d
testl %r8d, (%rcx,%rdi,4)
sete %cl
xorb $0x31, %cl
movb %cl, (%rdx,%rsi)
movl 0x1a72b(%rip), %ecx     # 0x21540
incq %rsi
jmp 0x6de7
addl %esi, %eax
incq %r12
jmp 0x6dc1
movb $0x0, (%rbx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Isomorphism.cpp
// Function: Isomorphism::canonicalBigger(char const*, char*, int)
void Isomorphism::canonicalBigger(const char *in, char *best, int size) {
  int i,j;
  int nedges[size], max;
  char perm[size], current[size*size+1], used[size];

  for (i=0, max=0; i<size; i++) {
    nedges[i]=0;
    for (j=0; j<size; j++)
      nedges[i]+=in[i*size+j]-'0';
    if (nedges[i] > nedges[max]) max = i;
  }


  for (i=0; i<size*size; i++)
    best[i] = in[size*size-1-i];    
  best[size*size]=0;

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

  current[size*size]='\0';
  for (i=0; i<size; i++)
    if (nedges[i]==nedges[max]) {
      used[i]=1;
      perm[0]=i;
      current[0]=in[i*size+i];
      _goCan(i, 1, in, perm, used, current, best, size);
      current[0]=i;
      used[i]=0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ecx
movq %rsp, %r12
leaq 0xf(,%rcx,4), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movq %rsp, %rax
leaq 0xf(%rcx), %r9
andq $-0x10, %r9
subq %r9, %rax
movq %rax, -0x58(%rbp)
movq %rax, %rsp
movl %edx, %eax
imull %eax, %eax
movq %rsp, %r14
leaq 0x10(%rax), %r8
andq $-0x10, %r8
subq %r8, %r14
movq %r14, %rsp
movq %rsp, %r13
subq %r9, %r13
movq %r13, %rsp
movslq %edx, %r11
xorl %ebx, %ebx
testl %r11d, %r11d
movl $0x0, %r8d
movq %rdx, -0x40(%rbp)
cmovgl %edx, %r8d
movq %rdi, %rdx
xorl %r15d, %r15d
movq %r8, -0x30(%rbp)
movslq %r15d, %r15
cmpq %r8, %rbx
je 0x7351
andl $0x0, (%r12,%rbx,4)
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x733d
movsbl (%rdx,%r9), %r10d
addl %r10d, %r8d
addl $-0x30, %r8d
movl %r8d, (%r12,%rbx,4)
incq %r9
jmp 0x7323
cmpl (%r12,%r15,4), %r8d
cmovgl %ebx, %r15d
incq %rbx
addq %r11, %rdx
movq -0x30(%rbp), %r8
jmp 0x7310
movl %eax, %ecx
movq %rcx, %rdx
negq %rdx
decl %eax
xorl %r8d, %r8d
movq %rdx, %r9
addq %r8, %r9
je 0x7377
cltq
movb (%rdi,%rax), %r9b
movb %r9b, (%rsi,%r8)
incq %r8
decl %eax
jmp 0x735e
movb $0x0, (%rsi,%rcx)
xorl %eax, %eax
movq -0x30(%rbp), %rdx
cmpq %rax, %rdx
je 0x7391
movb $0x0, (%r13,%rax)
incq %rax
jmp 0x7381
xorl %eax, %eax
cmpq %rax, %rcx
je 0x73a2
movb $0x32, (%r14,%rax)
incq %rax
jmp 0x7393
movq %r13, -0x48(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %r14, -0x50(%rbp)
movb $0x0, (%r14,%rcx)
movq -0x40(%rbp), %rax
leal 0x1(%rax), %ecx
xorl %esi, %esi
xorl %r13d, %r13d
movl %ecx, -0x34(%rbp)
movq -0x48(%rbp), %rbx
movq -0x50(%rbp), %r14
cmpq %r13, %rdx
je 0x742c
movl (%r12,%r13,4), %eax
cmpl (%r12,%r15,4), %eax
jne 0x7425
movb $0x1, (%rbx,%r13)
movq -0x58(%rbp), %rcx
movb %r13b, (%rcx)
movslq %esi, %rax
movq -0x60(%rbp), %rdx
movb (%rdx,%rax), %al
movb %al, (%r14)
movq %rsi, -0x70(%rbp)
pushq $0x1
popq %rsi
movq %rbx, %r8
movq %r14, %r9
pushq -0x40(%rbp)
pushq -0x68(%rbp)
callq 0x6b0e
movq -0x70(%rbp), %rsi
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rdx
addq $0x10, %rsp
movb %r13b, (%r14)
movb $0x0, (%rbx,%r13)
incq %r13
addl %ecx, %esi
jmp 0x73ce
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %eax
movq %rsp, %rdi
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rsp
movq %rsp, %r13
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %rax, %rcx
je 0x776c
movb $0x0, (%r13,%rax)
incq %rax
jmp 0x775c
movl %ebx, %eax
imull %eax, %eax
movq %rsp, %r14
leal 0x10(%rax), %ecx
andl $-0x10, %ecx
subq %rcx, %r14
movq %r14, %rsp
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x7791
movb $0x32, (%r14,%rcx)
incq %rcx
jmp 0x7782
movb $0x0, (%r14,%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
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 0x743c
popq %rax
popq %rcx
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7cc2
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 0x7ce4
callq 0x2050
movl (%rax), %edi
callq 0x20b0
leaq 0x8fc0(%rip), %rdi      # 0x10c9a
movq %rax, %rsi
xorl %eax, %eax
callq 0x7c64
movq %rdi, %rbx
movq 0x102ea(%rip), %r14     # 0x17fd8
movq (%r14), %rcx
leaq 0x8fa5(%rip), %rdi      # 0x10c9d
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2420
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 0x22e0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x22a0
pushq $0x1
popq %rdi
callq 0x2290
nop
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r14
movq %r14, 0x20(%rdi)
movq %r14, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x30(%rdi), %r15
movq %r15, 0x38(%rdi)
movq %r15, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movl %esi, 0x4c(%rdi)
movb $0x0, 0x50(%rdi)
andl $0x0, 0x54(%rdi)
andl $0x0, 0x74(%rdi)
testl %esi, %esi
je 0x7dc9
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
pushq $-0x1
popq %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, 0x78(%rbx)
jmp 0x7dd5
andq $0x0, 0x78(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
andl $0x0, 0x70(%rbx)
andq $0x0, 0x68(%rbx)
movq %r15, %rdi
callq 0xa2e4
movq %r14, %rdi
callq 0xa2fc
movq %rbx, %rdi
callq 0xa314
andw $0x0, 0x48(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0xa4b8
movq %r14, %rdi
callq 0xa4e2
movq %rbx, %rdi
callq 0xa522
movq %r12, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7e63
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7e47
callq 0x22b0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x7e55
callq 0x22b0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x7e63
callq 0x22b0
leaq 0x30(%rbx), %r14
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x7e94
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x7e85
movq %r15, %rdi
callq 0x7e28
movl $0x80, %esi
movq %r15, %rdi
callq 0x2210
jmp 0x7e6a
movq %r14, %rdi
callq 0xa4b8
leaq 0x18(%rbx), %rdi
callq 0xa4e2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa522
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %r15
pushq $-0x1
popq %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movl 0x4c(%r15), %edx
cmpl %edx, %eax
je 0x8206
leaq 0x30(%r15), %r13
movq %r13, %rbp
movq (%rbp), %rbp
cmpq %r13, %rbp
je 0x820a
xorl %ecx, %ecx
movq %rcx, %r12
movslq %edx, %rax
cmpq %rax, %rcx
jg 0x81fb
movq (%r14), %rax
movq %r14, %rdi
movl %edx, %esi
movl %r12d, %edx
callq *0x50(%rax)
movq 0x10(%rbp), %rcx
movq 0x60(%rcx), %rcx
movl 0x4c(%r15), %edx
cmpb %al, (%rcx,%r12)
jne 0x81fb
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %esi
callq *0x50(%rax)
movq 0x10(%rbp), %rcx
movq 0x58(%rcx), %rsi
leaq 0x1(%r12), %rcx
movl 0x4c(%r15), %edx
cmpb %al, (%rsi,%r12)
je 0x81ad
cmpl %r12d, %edx
jge 0x81a2
movq 0x10(%rbp), %r15
jmp 0x818a
movl 0x54(%r15), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movl 0x4c(%r14), %edx
cmpl %edx, %eax
je 0x83a5
leaq 0x30(%r14), %r15
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x82b7
xorl %ecx, %ecx
movq %rcx, %r12
movslq %edx, %rax
cmpq %rax, %rcx
jg 0x82a4
movq (%rbx), %rax
movq %rbx, %rdi
movl %edx, %esi
movl %r12d, %edx
callq *0x50(%rax)
movq 0x10(%r13), %rcx
movq 0x60(%rcx), %rcx
movl 0x4c(%r14), %edx
cmpb %al, (%rcx,%r12)
jne 0x82a4
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x50(%rax)
movq 0x10(%r13), %rcx
movq 0x58(%rcx), %rsi
leaq 0x1(%r12), %rcx
movl 0x4c(%r14), %edx
cmpb %al, (%rsi,%r12)
je 0x8256
cmpl %r12d, %edx
jge 0x824b
cmpq %r15, %r13
je 0x82b7
movq 0x10(%r13), %r14
jmp 0x822f
movl $0x80, %edi
callq 0x2200
movq %rax, %r12
movl 0x4c(%r14), %esi
incl %esi
movq %rax, %rdi
callq 0x7d48
movq %r12, 0x8(%rsp)
xorl %r13d, %r13d
movslq 0x4c(%r14), %rsi
cmpq %rsi, %r13
jg 0x837f
movq (%rbx), %rax
movq %rbx, %rdi
movl %r13d, %edx
callq *0x50(%rax)
movq 0x60(%r12), %rcx
movb %al, (%rcx,%r13)
movl 0x4c(%r14), %edx
movq (%rbx), %rax
movq %rbx, %rdi
movl %r13d, %esi
callq *0x50(%rax)
movq 0x58(%r12), %rcx
movb %al, (%rcx,%r13)
movl 0x4c(%r14), %esi
movq (%rbx), %rax
movq %rbx, %rdi
movl %r13d, %edx
callq *0x58(%rax)
testb %al, %al
je 0x833f
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 0x8355
incl 0x68(%r12)
incl 0x70(%r12)
movq 0x60(%r12), %rax
cmpb $0x1, (%rax,%r13)
jne 0x8377
movq 0x6c(%r12), %xmm0
psubd 0x8940(%rip), %xmm0     # 0x10cb0
movq %xmm0, 0x6c(%r12)
incq %r13
jmp 0x82da
movq %r12, %rdi
movq %rbx, %rsi
callq 0x821c
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xa32c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, 0x50(%r14)
jmp 0x8397
movq %rax, %rbx
movl $0x80, %esi
movq %r12, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::_is_pairset_included(std::__cxx11::list<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::__cxx11::list<std::pair<int, int>, std::allocator<std::pair<int, int>>>)
bool GTrieNode::_is_pairset_included(list<iPair> a, list<iPair> b) {
  list<iPair>::iterator aa, bb;

  aa = a.begin();
  bb = b.begin();

  while (aa!=a.end() && bb!=b.end()) {
    if ((aa->first == bb->first) && (aa->second == bb->second)) {
      aa++;
      bb++;
    } else {
      bb++;
    }      
  }

  if (aa == a.end()) return true;
  else return false;
}

// Assembly:
movq %rsi, %rax
movq %rdx, %rcx
movq (%rax), %rax
cmpq %rsi, %rax
je 0x882c
movq (%rcx), %rcx
cmpq %rdx, %rcx
je 0x882c
movl 0x10(%rax), %edi
cmpl 0x10(%rcx), %edi
jne 0x880d
movl 0x14(%rax), %edi
cmpl 0x14(%rcx), %edi
jne 0x880d
jmp 0x880a
cmpq %rsi, %rax
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
addq $0x30, %rbx
pushq $0x1
popq %rbp
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x885a
movq 0x10(%r14), %rdi
callq 0x8834
addl %eax, %ebp
jmp 0x8845
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x54(%rdi)
addq $0x30, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x8887
movq 0x10(%r14), %rdi
callq 0x8862
jmp 0x8874
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x88ae
movl 0x54(%rbx), %esi
leaq 0x843a(%rip), %rdi      # 0x10ce1
xorl %eax, %eax
callq 0x2060
addq $0x30, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x88c8
movq 0x10(%r14), %rdi
callq 0x8890
jmp 0x88b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
addq $0x30, %rbx
xorl %ebp, %ebp
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x88fa
movq 0x10(%r14), %rdi
callq 0x88d0
incl %eax
cmpl %eax, %ebp
cmovlel %eax, %ebp
jmp 0x88e0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x54(%rdi)
setg %al
andb 0x50(%rdi), %al
movzbl %al, %ebp
addq $0x30, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x8ef4
movq 0x10(%r14), %rdi
callq 0x8ec4
addl %eax, %ebp
jmp 0x8edf
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
addq $0x30, %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x8f24
movq 0x10(%r15), %rdi
callq 0x8efc
addl %eax, %ebx
jmp 0x8f0f
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
cmpb $0x0, 0x50(%rdi)
je 0x8f3e
movl 0x4c(%rbx), %ebp
addq $0x30, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x8f5a
movq 0x10(%r14), %rdi
callq 0x8f2c
addl %eax, %ebp
jmp 0x8f45
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x8f7e
movl 0x54(%rbx), %eax
testl %eax, %eax
jle 0x8f7e
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
addq $0x30, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x8fab
movq 0x10(%r14), %rdi
callq 0x8f62
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
jmp 0x8f8a
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x4c(%rdi), %edi
leal -0x1(%rdi), %edx
movslq %ecx, %rax
movslq %edx, %rcx
imull %ebx, %edx
movslq %edx, %rdx
addq %r14, %rdx
addq %r14, %rcx
xorl %esi, %esi
movslq %edi, %rdi
cmpq %rdi, %rsi
jge 0x950c
movq 0x60(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rdx,%rsi)
movq 0x58(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rcx)
incq %rsi
movl 0x4c(%r12), %edi
addq %rax, %rcx
jmp 0x94d6
cmpb $0x1, 0x50(%r12)
jne 0x9524
movl 0x54(%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb4c2
addq $0x30, %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x9547
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x94a8
jmp 0x952b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x4c(%rdi), %edi
leal -0x1(%rdi), %edx
movslq %ecx, %rax
movslq %edx, %rcx
imull %ebx, %edx
movslq %edx, %rdx
addq %r14, %rdx
addq %r14, %rcx
xorl %esi, %esi
movslq %edi, %rdi
cmpq %rdi, %rsi
jge 0x95bb
movq 0x60(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rdx,%rsi)
movq 0x58(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rcx)
incq %rsi
movl 0x4c(%r12), %edi
addq %rax, %rcx
jmp 0x9585
cmpb $0x1, 0x50(%r12)
jne 0x95f8
movl 0x54(%r12), %ebp
testl %ebp, %ebp
jle 0x95f8
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0xa46e
movq %r15, %rdi
movq %r13, %rsi
callq 0xa408
movl %ebp, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0x30, %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x961b
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x9552
jmp 0x95ff
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x6e34
pushq $0x58
popq %rdi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
callq 0x44f8
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x54e8
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x8176
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
pushq $0x58
popq %rsi
movq %r15, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O2/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, %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 %r15d, %edx
callq 0x7294
pushq $0x58
popq %rdi
callq 0x2200
movq %rax, %r14
movq %rax, %rdi
callq 0x44f8
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x54e8
pushq $0x18
popq %r15
movq %r15, %rdi
callq 0x2200
movq %rax, %r12
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x6460
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x96a8
movq %r12, %rdi
callq 0x67ea
movq %r12, %rdi
movq %r15, %rsi
callq 0x2210
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x6c73(%rip), %rsi      # 0x104af
movq %rcx, %rdi
callq 0x2270
movq %rax, %r14
testq %rax, %rax
jne 0x9855
xorl %edi, %edi
xorl %eax, %eax
callq 0x7c64
movq %rsp, %r13
movzbl %r15b, %r15d
pushq $0x1
popq %r12
movq %r14, %rdi
leaq 0x7430(%rip), %rsi      # 0x10c9a
movq %r13, %rdx
xorl %eax, %eax
callq 0x23f0
cmpl $0x1, %eax
jne 0x988e
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r15d, %ecx
movl %r12d, %r8d
callq 0x98b0
jmp 0x9860
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x99bc
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15d
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
cmpl $0x4, %r8d
je 0x9904
cmpl $0x3, %r8d
je 0x98fd
cmpl $0x2, %r8d
jne 0x990b
callq 0x7294
jmp 0x9910
callq 0x77d0
jmp 0x9910
callq 0x7990
jmp 0x9910
callq 0x6e34
pushq $0x58
popq %rdi
callq 0x2200
movq %rax, %r13
movq %rax, %rdi
callq 0x44f8
xorb $0x1, %r15b
movzbl %r15b, %ecx
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x54e8
movq (%r13), %rax
movq %r13, %rdi
callq *0x88(%rax)
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x2200
movq %rax, %r15
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x6460
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x96a8
movq %r15, %rdi
callq 0x67ea
movq %r15, %rdi
movq %r14, %rsi
callq 0x2210
movq (%r13), %rax
movq %r13, %rdi
callq *0x10(%rax)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r13, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::census(Graph*)
void GTrie::census(Graph *g) {
  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(); 
  
  if (g->type() == DIRECTED) GTrieNode::isdir = true;
  else                       GTrieNode::isdir = false;
  for (i=0; i<num_nodes; i++)
    GTrieNode::used[i]=false;

  GTrieNode *c = *(_root->child.begin());
  list<GTrieNode *>::iterator ii;
  GTrieNode::glk=1;

  for (i = 0; i<num_nodes; i++) {
    GTrieNode::mymap[0] = i;
    GTrieNode::used[i]=true;
    if (g->type() == DIRECTED)
      for(ii=c->child.begin(); ii!=c->child.end(); ii++)
	(*ii)->goCondDir();
    else
      for(ii=c->child.begin(); ii!=c->child.end(); ii++)
	(*ii)->goCondUndir();
    GTrieNode::used[i]=false;
  }
        
  delete [] GTrieNode::mymap;
  delete [] GTrieNode::used;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x99fe
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
movl %eax, %r14d
movq (%r15), %rdi
callq 0x8862
movl %ebp, %eax
shlq $0x2, %rax
testl %ebp, %ebp
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x1810b(%rip)     # 0x21b60
movslq %r14d, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x18101(%rip)     # 0x21b68
movl %r14d, 0x1811e(%rip)    # 0x21b8c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rax, 0x180f7(%rip)     # 0x21b78
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rax, 0x180e0(%rip)     # 0x21b70
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
movq %rax, 0x180dd(%rip)     # 0x21b80
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testl %eax, %eax
sete 0x180db(%rip)           # 0x21b90
movq 0x180ac(%rip), %rdi     # 0x21b68
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0x9ad3
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x9ac5
movq (%r15), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %r15
movl $0x1, 0x180a0(%rip)     # 0x21b88
addq $0x30, %r15
xorl %r12d, %r12d
movq 0x1806a(%rip), %rax     # 0x21b60
cmpq %r14, %r12
je 0x9b4d
movl %r12d, (%rax)
movb $0x1, (%rdi,%r12)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %r15, %r13
testl %eax, %eax
jne 0x9b33
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x9b3c
movq 0x10(%r13), %rdi
callq 0x8bd2
jmp 0x9b16
movq 0x10(%r13), %rdi
callq 0x8902
movq (%r13), %r13
cmpq %r15, %r13
jne 0x9b2a
movq 0x18025(%rip), %rdi     # 0x21b68
movb $0x0, (%rdi,%r12)
incq %r12
jmp 0x9aef
testq %rax, %rax
je 0x9b61
movq %rax, %rdi
callq 0x22b0
movq 0x18007(%rip), %rdi     # 0x21b68
addq $0x8, %rsp
testq %rdi, %rdi
je 0x9b79
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq