LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::decide_action()
void CmdLine::decide_action() {

  t_start = time(0);

  if (create) {
    create_gtrie();
  } else {
      // Check method
      if (method == NOMETHOD)
	Error::msg("No valid method specified");    
      
      prepare_graph();
      prepare_files();
      compute_original();
      compute_results();
  }

}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x21c0
movq %rax, 0x15a5f(%rip)     # 0x19768
cmpb $0x1, 0x159f2(%rip)     # 0x19702
jne 0x3d18
popq %rax
jmp 0x29dc
cmpl $0x0, 0x15a09(%rip)     # 0x19728
jne 0x3d2f
leaq 0xdcaf(%rip), %rdi      # 0x119d7
xorl %eax, %eax
callq 0x8240
callq 0x2df0
callq 0x2d06
callq 0x2f88
popq %rax
jmp 0x30a6
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::init(int, char**)
void CmdLine::init(int argc, char **argv) {
  about();
  defaults();
  parse_cmdargs(argc, argv);
  Isomorphism::initNauty(motif_size, dir);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x3d78
callq 0x3dae
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3e4e
movl 0x1599e(%rip), %edi     # 0x19704
movzbl 0x15993(%rip), %esi     # 0x19700
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6e54
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::defaults()
void CmdLine::defaults() {

  strcpy(graph_file, INVALID_FILE);
  dir        = false;
  motif_size = -1;

  method = ESU;

  strcpy(output_file, DEFAULT_RESULTS);
  strcpy(occ_file, DEFAULT_OCC);

  random_number    = 0;
  random_seed      = time(0);
  random_exchanges = 3;
  random_tries     = 10;

  create = false;
  format = SIMPLE_WEIGHT;
  output = TEXT;
  occurrences = false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movabsq $0x5f5f4c4c554e5f5f, %rax # imm = 0x5F5F4C4C554E5F5F
movq %rax, 0x1453e(%rip)     # 0x18300
xorl %ebx, %ebx
movb %bl, 0x1453e(%rip)      # 0x18308
movb %bl, 0x15930(%rip)      # 0x19700
movl $0xffffffff, 0x1592a(%rip) # imm = 0xFFFFFFFF
movl $0x1, %ebp
movl %ebp, 0x15943(%rip)     # 0x19728
movabsq $0x73746c75736572, %rax # imm = 0x73746C75736572
movq %rax, 0x1510a(%rip)     # 0x18f00
movl $0x63636f, 0x15500(%rip) # imm = 0x63636F
movl $0x0, 0x158fe(%rip)     # 0x19708
xorl %edi, %edi
callq 0x21c0
movl %eax, 0x158f5(%rip)     # 0x1970c
movl $0x3, 0x158ef(%rip)     # 0x19710
movl $0xa, 0x158e9(%rip)     # 0x19714
movb %bl, 0x158d1(%rip)      # 0x19702
movl $0x2, 0x158f1(%rip)     # 0x1972c
movl %ebp, 0x158ef(%rip)     # 0x19730
movb %bl, 0x158ba(%rip)      # 0x19701
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::finish()
void CmdLine::finish() { 
  if (!create) {
    fclose(f_output);
    if (occurrences) fclose(f_occ);
  }
  Isomorphism::finishNauty();
}

// Assembly:
cmpb $0x0, 0x153ef(%rip)     # 0x19702
jne 0x6ea4
pushq %rax
movq 0x1541f(%rip), %rdi     # 0x19740
callq 0x21e0
cmpb $0x1, 0x153d4(%rip)     # 0x19701
jne 0x433b
movq 0x15412(%rip), %rdi     # 0x19748
callq 0x21e0
addq $0x8, %rsp
jmp 0x6ea4
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::str_to_method(char*)
MethodType CmdLine::str_to_method(char *s) {
  if      (!strcmp(s, "esu"))       return ESU;
  else if (!strcmp(s, "gtrie"))     return GTRIE;
  else if (!strcmp(s, "subgraphs")) return SUBGRAPHS;
  else return NOMETHOD;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xd6b7(%rip), %rsi      # 0x11a06
callq 0x22c0
testl %eax, %eax
je 0x4386
leaq 0xd6ab(%rip), %rsi      # 0x11a0a
movq %rbx, %rdi
callq 0x22c0
testl %eax, %eax
je 0x438d
leaq 0xd69e(%rip), %rsi      # 0x11a10
movq %rbx, %rdi
callq 0x22c0
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x4392
movl $0x1, %eax
jmp 0x4392
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::_delete()
void GraphMatrix::_delete() {
  int i;

  if (_adjM!=NULL) {
    for (i=0; i<_num_nodes; i++)
      if (_adjM[i]!=NULL) delete[] _adjM[i];
    delete[] _adjM;
  }
  if (_adjIn!=NULL) delete[] _adjIn;
  if (_adjOut!=NULL) delete[] _adjOut;
  if (_neighbours!=NULL) delete[] _neighbours;

  if (_in!=NULL) delete[] _in;
  if (_out!=NULL) delete[] _out;
  if (_out!=NULL) delete[] _num_neighbours;

  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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x498e
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x4989
xorl %r14d, %r14d
movq 0x30(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4975
callq 0x2290
movl 0xc(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x4960
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x498e
callq 0x2290
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x49e0
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x49cc
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x49c6
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2200
addq $-0x18, %r12
jne 0x49b0
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x23f0
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x4a32
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x4a1e
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x4a18
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2200
addq $-0x18, %r12
jne 0x4a02
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x23f0
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x4a84
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x4a70
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x4a6a
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2200
addq $-0x18, %r12
jne 0x4a54
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x23f0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4a92
callq 0x2290
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x4ab5
callq 0x2290
cmpq $0x0, 0x20(%rbx)
je 0x4ab5
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4ab5
callq 0x2290
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x4b01
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x4af1
xorl %r14d, %r14d
movq 0x38(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4add
callq 0x2290
movl 0xc(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x4ac8
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x4b01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::zero()
void GraphMatrix::zero() {
  int i,j;
  _num_edges = 0;

  for (i=0; i<_num_nodes;i++) {
    _in[i] = 0;
    _out[i] = 0;
    _num_neighbours[i] = 0;
    _adjIn[i].clear();
    _adjOut[i].clear();
    _neighbours[i].clear();
    for (j=0; j<_num_nodes;j++)
      _adjM[i][j]=false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
cmpl $0x0, 0xc(%rdi)
jle 0x4c04
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x48(%rax), %rbp
movq 0x40(%rax), %r15
movq 0x50(%rax), %r12
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x2, %r13d
xorl %ebx, %ebx
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax,%rbx,4)
movq 0x18(%rsp), %rax
movl %ecx, (%rax,%rbx,4)
movq 0x10(%rsp), %rax
movl %ecx, (%rax,%rbx,4)
movq -0x8(%rbp,%r13,4), %rax
cmpq %rax, (%rbp,%r13,4)
je 0x4bba
movq %rax, (%rbp,%r13,4)
movq -0x8(%r15,%r13,4), %rax
cmpq %rax, (%r15,%r13,4)
je 0x4bc9
movq %rax, (%r15,%r13,4)
movq -0x8(%r12,%r13,4), %rax
cmpq %rax, (%r12,%r13,4)
je 0x4bd8
movq %rax, (%r12,%r13,4)
movq (%rsp), %rax
movslq 0xc(%rax), %r14
testq %r14, %r14
jle 0x4bf8
movq 0x8(%rsp), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2120
incq %rbx
addq $0x6, %r13
cmpq %r14, %rbx
jl 0x4b8f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::createGraph(int, GraphType)
void GraphMatrix::createGraph(int n, GraphType t) {
  int i;

  _num_nodes = n;
  _type = t;

  _delete();

  _adjM = new bool*[n];  
  for (i=0; i<n; i++) _adjM[i] = new bool[n];
  _adjIn      = new vector<int>[n];
  _adjOut     = new vector<int>[n];
  _neighbours = new vector<int>[n];

  _in             = new int[n]; 
  _out            = new int[n];
  _num_neighbours = new int[n];

  zero();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rdi)
movl %edx, 0x8(%rdi)
callq 0x4942
movslq %ebp, %r14
leaq (,%r14,8), %rdi
testl %r14d, %r14d
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, 0x30(%rbx)
testl %r14d, %r14d
jle 0x4c74
movl %ebp, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x2030
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x4c5c
movl $0x18, %ecx
movq %r14, %rax
mulq %rcx
movq %rax, %r12
seto %al
movq %r12, %r15
addq $0x8, %r15
cmovbq %r13, %r15
testb %al, %al
cmovneq %r13, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r13
movq %r14, (%rax)
addq $0x8, %r13
testl %ebp, %ebp
je 0x4d25
addq $-0x18, %r12
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %r12, %rax
mulq %rcx
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %r12
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %r13, 0x48(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r13
movq %r14, (%rax)
addq $0x8, %r13
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %r13, 0x40(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
jmp 0x4d4e
movq %r13, 0x48(%rbx)
movq %r15, %rdi
callq 0x2030
movq %r14, (%rax)
addq $0x8, %rax
movq %rax, 0x40(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, (%rax)
addq $0x8, %r15
shlq $0x2, %r14
testl %ebp, %ebp
movq %r15, 0x50(%rbx)
movq $-0x1, %r15
cmovnsq %r14, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x28(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x28(%rax)
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::addEdge(int, int)
void GraphMatrix::addEdge(int a, int b) {

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

  _adjM[a][b] = true;

  _adjOut[a].push_back(b);
  _out[a]++;

  _adjIn[b].push_back(a);
  _in[b]++;

  _num_edges++;

  if (!_adjM[b][a]) {
    _neighbours[a].push_back(b);
    _num_neighbours[a]++;
    _neighbours[b].push_back(a);
    _num_neighbours[b]++;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x30(%rdi), %rax
movslq %esi, %r14
movq (%rax,%r14,8), %rax
movslq %edx, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x4ed4
movl %esi, %ebp
movq %rdi, %rbx
movb $0x1, (%rax,%rcx)
movq 0x40(%rdi), %rax
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4df1
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4dfb
leaq 0x8(%rsp), %rdx
callq 0x52ec
movq 0x20(%rbx), %rax
incl (%rax,%r14,4)
movq 0x48(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4e2a
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4e34
leaq 0xc(%rsp), %rdx
callq 0x52ec
movq 0x18(%rbx), %rax
movslq 0x8(%rsp), %rcx
incl (%rax,%rcx,4)
incl 0x10(%rbx)
movq 0x30(%rbx), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rdx
cmpb $0x0, (%rax,%rdx)
jne 0x4ed4
movq 0x50(%rbx), %rax
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4e7d
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4e8b
leaq 0x8(%rsp), %rdx
callq 0x52ec
movq 0x50(%rbx), %rax
movq 0x28(%rbx), %rcx
movslq 0xc(%rsp), %rdx
incl (%rcx,%rdx,4)
movslq 0x8(%rsp), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4ebe
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4ecc
leaq 0xc(%rsp), %rdx
callq 0x52ec
movq 0x28(%rbx), %rcx
movslq 0x8(%rsp), %rax
incl (%rcx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4f86
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 0x4f90
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 0x4f90
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 0x4f86
addq 0x50(%rbx), %r12
movq %r12, %rsi
movl %r14d, %edx
callq 0x4f90
movq 0x28(%rbx), %rax
decl (%rax,%r15,4)
addq 0x50(%rbx), %r13
movq %r13, %rsi
movl %r15d, %edx
callq 0x4f90
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_O3/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 0x4ff4
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
shlq $0x2, %rsi
xorl %r8d, %r8d
cmpl %eax, (%rdi,%r8)
je 0x4fcc
addq $0x4, %r8
cmpq %r8, %rsi
jne 0x4fbb
jmp 0x4ff4
leaq (%rdi,%r8), %rsi
addq $0x4, %rsi
cmpq %rcx, %rsi
je 0x4fec
addq %r8, %rdi
subq %r8, %rdx
addq $-0x4, %rdx
callq 0x2340
movq 0x8(%rbx), %rcx
addq $-0x4, %rcx
movq %rcx, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0x38(%rbx)
testq %r15, %r15
jle 0x5164
movq 0x50(%rbx), %rax
xorl %r15d, %r15d
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 0x5158
addq %rax, %r12
movq 0x38(%rbx), %rsi
movq (%rsi,%r15,8), %rsi
xorl %edi, %edi
leaq (%rcx,%rdi), %r8
addq $0x4, %r8
movl -0x4(%r8), %r9d
movl %r9d, (%rsi,%rdi)
addq $0x4, %rdi
cmpq %rdx, %r8
jne 0x5135
cmpq %rdx, %rcx
je 0x5158
movq %rcx, 0x8(%r12)
incq %r15
movslq 0xc(%rbx), %rcx
cmpq %rcx, %r15
jl 0x50f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
jle 0x51ed
movq 0x28(%rbx), %rax
xorl %r14d, %r14d
cmpl $0x0, (%rax,%r14,4)
jle 0x51e2
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x38(%rbx), %rcx
movq 0x50(%rbx), %rdx
leaq (%rdx,%r15,8), %rdi
movq (%rcx,%r14,8), %rdx
addq %r12, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x51c6
movl (%rdx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x51cf
callq 0x52ec
movq 0x28(%rbx), %rax
incq %r13
movslq (%rax,%r14,4), %rcx
addq $0x4, %r12
cmpq %rcx, %r13
jl 0x519b
movl 0xc(%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x518a
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5234
testl %ecx, %ecx
jle 0x5226
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5212
callq 0x2290
movl 0xc(%rbx), %ecx
incq %r14
movslq %ecx, %rax
cmpq %rax, %r14
jl 0x51fd
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5234
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2290
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5a37
movl %ebp, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpb $0x31, (%rbx,%r12)
jne 0x5a24
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq *0x30(%rax)
incq %r12
cmpq %r12, %r13
jne 0x5a0e
incq %r15
addq %r13, %rbx
cmpq %r13, %r15
jne 0x5a0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1354c(%rip)     # 0x1979c
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r15d
movl %eax, 0x13541(%rip)     # 0x197a0
movl %ebp, %edi
shlq $0x2, %rdi
testl %ebp, %ebp
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x1352a(%rip)     # 0x197a8
movl %r15d, %edi
shlq $0x2, %rdi
testl %r15d, %r15d
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x13518(%rip)     # 0x197b0
movl $0x0, 0x13502(%rip)     # 0x197a4
movq %r14, 0x1350f(%rip)     # 0x197b8
movq %rbx, 0x13518(%rip)     # 0x197c8
movq %rbx, %rdi
callq 0xbd98
cmpl $0x0, 0x134e1(%rip)     # 0x197a0
jle 0x62e0
xorl %ebx, %ebx
leaq 0xc(%rsp), %r14
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x5e50
incl %ebx
cmpl 0x134c2(%rip), %ebx     # 0x197a0
jl 0x62c8
movq 0x134c1(%rip), %rdi     # 0x197a8
testq %rdi, %rdi
je 0x62f1
callq 0x2290
movq 0x134b8(%rip), %rdi     # 0x197b0
addq $0x10, %rsp
testq %rdi, %rdi
je 0x630e
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_O3/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, 0x13468(%rip)     # 0x1979c
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %r12d
movl %eax, 0x1345d(%rip)     # 0x197a0
movl %ebp, %edi
shlq $0x2, %rdi
testl %ebp, %ebp
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, 0x13446(%rip)     # 0x197a8
movl %r12d, %edi
shlq $0x2, %rdi
testl %r12d, %r12d
cmovsq %r13, %rdi
callq 0x2030
movq %rax, 0x13434(%rip)     # 0x197b0
movl $0x0, 0x1341e(%rip)     # 0x197a4
movq %r15, 0x1342b(%rip)     # 0x197b8
movq %rbx, 0x13434(%rip)     # 0x197c8
movq %r14, 0x13425(%rip)     # 0x197c0
movq %rbx, %rdi
callq 0xbd98
cmpl $0x0, 0x133f6(%rip)     # 0x197a0
jle 0x63e1
xorl %ebx, %ebx
leaq 0x4(%rsp), %r14
callq 0xb396
movq 0x13401(%rip), %rax     # 0x197c0
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0x63d7
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x606c
incl %ebx
cmpl 0x133c1(%rip), %ebx     # 0x197a0
jl 0x63b3
movq 0x133c0(%rip), %rdi     # 0x197a8
testq %rdi, %rdi
je 0x63f2
callq 0x2290
movq 0x133b7(%rip), %rdi     # 0x197b0
addq $0x8, %rsp
testq %rdi, %rdi
je 0x6411
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_O3/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)
movl %esi, %r14d
shlq $0x2, %r14
testl %esi, %esi
movq $-0x1, %r13
movq %r14, %rdi
cmovsq %r13, %rdi
callq 0x2030
movq %rax, (%rsp)
movq %rax, 0x8(%r12)
movl %ebx, %r15d
shlq $0x2, %r15
testl %ebx, %ebx
cmovnsq %r15, %r13
movq %r13, %rdi
callq 0x2030
movq %rax, %r13
movq %rax, 0x10(%r12)
testl %ebp, %ebp
jle 0x6490
movq (%rsp), %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x2120
testl %ebx, %ebx
jle 0x64b2
movq %r13, %rdi
movl $0xff, %esi
movq %r15, %rdx
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_O3/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, 0x1a6c1(%rip)     # 0x21520
leal 0x1f(%rdx), %eax
leal 0x3e(%rdx), %esi
testl %eax, %eax
cmovnsl %eax, %esi
sarl $0x5, %esi
movl %esi, 0x1a6b1(%rip)     # 0x21524
movl $0x20, %edi
movl $0x960, %ecx            # imm = 0x960
callq 0xd170
movb %bl, 0x1aaa0(%rip)      # 0x21928
movl $0x1, 0x11386(%rip)     # 0x18218
movl $0x0, 0x11384(%rip)     # 0x18220
movl %ebx, 0x1137a(%rip)     # 0x1821c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]gtrieScanner/Isomorphism.cpp
// Function: Isomorphism::canonicalStrNauty(Graph*, int*, char*)
void Isomorphism::canonicalStrNauty(Graph *myg, int *v, char *s) {
  int i, j, aux;

  static bool **adjM = myg->adjacencyMatrix();

  for (i=0; i<n; i++) {
    gv = GRAPHROW(g,i,m);
    EMPTYSET(gv,m);
    for (j=0; j<n; j++)
      if (adjM[v[i]][v[j]]) 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++)
         s[aux++] = ISELEMENT(gv,j)?'1':'0';
  }
  s[aux]=0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movb 0x1ac5e(%rip), %al      # 0x21b28
testb %al, %al
je 0x7042
movslq 0x1a647(%rip), %r10     # 0x21520
movslq 0x1a644(%rip), %rax     # 0x21524
testq %r10, %r10
jle 0x6f64
leaq 0x1a644(%rip), %rcx     # 0x21530
movq 0x1ac2d(%rip), %rdx     # 0x21b20
xorl %esi, %esi
leaq 0xad54(%rip), %rdi      # 0x11c50
movq %rsi, %r8
imulq %rax, %r8
leaq (%rcx,%r8,4), %r8
movq %r8, 0x1a61a(%rip)      # 0x21528
leaq (%r8,%rax,4), %r9
addq $-0x4, %r9
cmpq %r8, %r9
jb 0x6f28
movl $0x0, (%r9)
addq $-0x4, %r9
jmp 0x6f16
xorl %r9d, %r9d
movslq (%r14,%rsi,4), %r11
movq (%rdx,%r11,8), %r11
movslq (%r14,%r9,4), %r15
cmpb $0x1, (%r11,%r15)
jne 0x6f54
movl %r9d, %r11d
andl $0x1f, %r11d
movl (%rdi,%r11,4), %r11d
movl %r9d, %r15d
shrl $0x5, %r15d
orl %r11d, (%r8,%r15,4)
incq %r9
cmpq %r9, %r10
jne 0x6f2b
incq %rsi
cmpq %r10, %rsi
jne 0x6efc
leaq 0x1aa25(%rip), %r14     # 0x21990
leaq 0x128ae(%rip), %r11     # 0x19820
leaq 0x1a9b7(%rip), %r12     # 0x21930
leaq 0x1a5b0(%rip), %rdi     # 0x21530
leaq 0x1a739(%rip), %rsi     # 0x216c0
leaq 0x1a802(%rip), %rdx     # 0x21790
leaq 0x1a8cb(%rip), %r8      # 0x21860
leaq 0x1127c(%rip), %r9      # 0x18218
xorl %r15d, %r15d
xorl %ecx, %ecx
pushq %r14
pushq %r10
pushq %rax
pushq $0x1f40                 # imm = 0x1F40
pushq %r11
pushq %r12
callq 0xbed0
addq $0x30, %rsp
movl 0x1a562(%rip), %edx     # 0x21520
testl %edx, %edx
jle 0x7031
leaq 0xac87(%rip), %rax      # 0x11c50
xorl %ecx, %ecx
movslq 0x1a552(%rip), %rsi     # 0x21524
imulq %rcx, %rsi
leaq (%r14,%rsi,4), %rsi
movq %rsi, 0x1a547(%rip)     # 0x21528
testl %edx, %edx
jle 0x7023
movslq %r15d, %rsi
addq %rbx, %rsi
xorl %edi, %edi
movq 0x1a534(%rip), %rdx     # 0x21528
movl %edi, %r8d
shrl $0x5, %r8d
movl %edi, %r9d
andl $0x1f, %r9d
movl (%rax,%r9,4), %r9d
testl %r9d, (%rdx,%r8,4)
sete %dl
xorb $0x31, %dl
movb %dl, (%rsi,%rdi)
movl 0x1a507(%rip), %edx     # 0x21520
incq %rdi
cmpl %edx, %edi
jl 0x6fed
addl %edi, %r15d
incq %rcx
movslq %edx, %rsi
cmpq %rsi, %rcx
jl 0x6fcb
movslq %r15d, %r15
movb $0x0, (%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdi, %r15
leaq 0x1aadc(%rip), %rdi     # 0x21b28
callq 0x2390
testl %eax, %eax
je 0x6ed2
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq %rax, 0x1aab8(%rip)     # 0x21b20
leaq 0x1aab9(%rip), %rdi     # 0x21b28
callq 0x2140
jmp 0x6ed2
movq %rax, %rbx
leaq 0x1aaa5(%rip), %rdi     # 0x21b28
callq 0x2130
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O3/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 0x1a298(%rip), %r10     # 0x21520
movslq 0x1a295(%rip), %rax     # 0x21524
testq %r10, %r10
jle 0x7306
leaq 0x1a295(%rip), %rcx     # 0x21530
movslq %edx, %rdx
xorl %esi, %esi
leaq 0xa9a9(%rip), %r8       # 0x11c50
movq %rsi, %r9
imulq %rax, %r9
leaq (%rcx,%r9,4), %r9
movq %r9, 0x1a26f(%rip)      # 0x21528
leaq (%r9,%rax,4), %r11
addq $-0x4, %r11
cmpq %r9, %r11
jb 0x72d3
movl $0x0, (%r11)
addq $-0x4, %r11
jmp 0x72c1
xorl %r11d, %r11d
cmpb $0x31, (%rdi,%r11)
jne 0x72f3
movl %r11d, %r14d
andl $0x1f, %r14d
movl (%r8,%r14,4), %ebp
movl %r11d, %r14d
shrl $0x5, %r14d
orl %ebp, (%r9,%r14,4)
incq %r11
cmpq %r11, %r10
jne 0x72d6
incq %rsi
addq %rdx, %rdi
cmpq %r10, %rsi
jne 0x72a7
leaq 0x1a683(%rip), %r14     # 0x21990
leaq 0x1250c(%rip), %r11     # 0x19820
leaq 0x1a615(%rip), %r12     # 0x21930
leaq 0x1a20e(%rip), %rdi     # 0x21530
leaq 0x1a397(%rip), %rsi     # 0x216c0
leaq 0x1a460(%rip), %rdx     # 0x21790
leaq 0x1a529(%rip), %r8      # 0x21860
leaq 0x10eda(%rip), %r9      # 0x18218
xorl %r15d, %r15d
xorl %ecx, %ecx
pushq %r14
pushq %r10
pushq %rax
pushq $0x1f40                 # imm = 0x1F40
pushq %r11
pushq %r12
callq 0xbed0
addq $0x30, %rsp
movl 0x1a1c0(%rip), %edx     # 0x21520
testl %edx, %edx
jle 0x73d3
leaq 0xa8e5(%rip), %rax      # 0x11c50
xorl %ecx, %ecx
movslq 0x1a1b0(%rip), %rsi     # 0x21524
imulq %rcx, %rsi
leaq (%r14,%rsi,4), %rsi
movq %rsi, 0x1a1a5(%rip)     # 0x21528
testl %edx, %edx
jle 0x73c5
movslq %r15d, %rsi
addq %rbx, %rsi
xorl %edi, %edi
movq 0x1a192(%rip), %rdx     # 0x21528
movl %edi, %r8d
shrl $0x5, %r8d
movl %edi, %r9d
andl $0x1f, %r9d
movl (%rax,%r9,4), %r9d
testl %r9d, (%rdx,%r8,4)
sete %dl
xorb $0x31, %dl
movb %dl, (%rsi,%rdi)
movl 0x1a165(%rip), %edx     # 0x21520
incq %rdi
cmpl %edx, %edi
jl 0x738f
addl %edi, %r15d
incq %rcx
movslq %edx, %rsi
cmpq %rsi, %rcx
jl 0x736d
movslq %r15d, %r15
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, %r12
leaq 0xf(,%rdx,4), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movq %rsp, %r13
leaq 0xf(%rdx), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
testl %ebx, %ebx
movl %ebx, -0x2c(%rbp)
jle 0x7d0a
movq %r13, %rdi
xorl %esi, %esi
callq 0x2120
movl %ebx, %eax
imull %eax, %eax
movq %rsp, %r14
leaq 0x10(%rax), %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
jmp 0x7d24
movl %ebx, %eax
imull %eax, %eax
movq %rsp, %r14
leaq 0x10(%rax), %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
testl %ebx, %ebx
je 0x7d83
movl %eax, %r15d
cmpq $0x1, %r15
movq %r15, %rdx
adcq $0x0, %rdx
movq %r14, %rdi
movl $0x32, %esi
callq 0x2120
movb $0x0, (%r14,%r15)
movq -0x40(%rbp), %r15
movq %r15, %rdi
movq -0x38(%rbp), %rbx
movq %rbx, %rsi
callq 0x21d0
subq $0x8, %rsp
xorl %edi, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
movl -0x2c(%rbp), %r9d
pushq %r14
callq 0x7984
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x7d3f
// File: /workspace/github_c_makefile_star2_O3/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 0x829e
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 0x82c0
callq 0x2050
movl (%rax), %edi
callq 0x20b0
leaq 0x9a44(%rip), %rdi      # 0x11cfa
movq %rax, %rsi
xorl %eax, %eax
callq 0x8240
movq %rdi, %rbx
movq 0xfd0e(%rip), %r14      # 0x17fd8
movq (%r14), %rcx
leaq 0x9a29(%rip), %rdi      # 0x11cfd
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_O3/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 0x83ae
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 0x83bd
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 0xadea
movq %r14, %rdi
callq 0xafd4
movq %r14, 0x20(%rbx)
movq %r14, 0x18(%rbx)
movq %r12, 0x28(%rbx)
movq %rbx, %rdi
callq 0xb02c
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 0xafd4
movq %rbx, %rdi
callq 0xb02c
movq %r15, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O3/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 0x845f
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x8443
callq 0x2290
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x8451
callq 0x2290
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x845f
callq 0x2290
leaq 0x30(%rbx), %r12
movq 0x30(%rbx), %r14
cmpq %r12, %r14
je 0x8496
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x847d
movq %r15, %rdi
callq 0x8424
movl $0x80, %esi
movq %r15, %rdi
callq 0x2200
movq (%r14), %r14
cmpq %r12, %r14
jne 0x846c
movq (%r12), %r14
cmpq %r12, %r14
je 0x84b3
movq (%r14), %r15
movl $0x18, %esi
movq %r14, %rdi
callq 0x2200
movq %r15, %r14
cmpq %r12, %r15
jne 0x849b
leaq 0x18(%rbx), %rdi
callq 0xafd4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb02c
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x40(%rax)
movl 0x4c(%rbx), %edx
cmpl %edx, %eax
jne 0x87c5
movl 0x54(%rbx), %eax
jmp 0x885b
leaq 0x4c(%rbx), %r12
addq $0x30, %rbx
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x8856
xorl %r15d, %r15d
testl %edx, %edx
js 0x8830
movq (%r14), %rax
movq %r14, %rdi
movl %edx, %esi
movl %r15d, %edx
callq *0x50(%rax)
movq 0x10(%r13), %rcx
movq 0x60(%rcx), %rcx
movl (%r12), %edx
cmpb %al, (%rcx,%r15)
jne 0x8830
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
callq *0x50(%rax)
movq 0x10(%r13), %rcx
movq 0x58(%rcx), %rcx
movl (%r12), %edx
cmpb %al, (%rcx,%r15)
jne 0x8830
movslq %edx, %rcx
leaq 0x1(%r15), %rax
cmpq %rcx, %r15
movq %rax, %r15
jl 0x87e0
movl %eax, %r15d
cmpl %edx, %r15d
jle 0x87d0
movq 0x10(%r13), %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
leaq 0x4c(%rbx), %r12
movl 0x4c(%rbx), %edx
cmpl %edx, %eax
jne 0x87c9
jmp 0x87bd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x90b7
movq 0x10(%r14), %rdi
callq 0x908e
addl %eax, %ebp
movq (%r14), %r14
jmp 0x90a2
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x90e7
movq 0x10(%r14), %rdi
callq 0x90be
movq (%r14), %r14
jmp 0x90d4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x910e
movl 0x54(%rbx), %esi
leaq 0x8c3a(%rip), %rdi      # 0x11d41
xorl %eax, %eax
callq 0x2060
movq 0x30(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x9129
movq 0x10(%r14), %rdi
callq 0x90f0
movq (%r14), %r14
jmp 0x9116
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x915d
movq 0x10(%r14), %rdi
callq 0x9132
incl %eax
cmpl %eax, %ebp
cmovlel %eax, %ebp
movq (%r14), %r14
jmp 0x9143
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x97fc
movq 0x10(%r15), %rdi
callq 0x97ca
addl %eax, %ebx
movq (%r15), %r15
jmp 0x97e7
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x982d
movq 0x10(%r15), %rdi
callq 0x9804
addl %eax, %ebx
movq (%r15), %r15
jmp 0x9818
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x984a
movl 0x4c(%r14), %ebx
movq 0x30(%r14), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x9867
movq 0x10(%r15), %rdi
callq 0x9836
addl %eax, %ebx
movq (%r15), %r15
jmp 0x9852
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x988f
movl 0x54(%rbx), %eax
testl %eax, %eax
jle 0x988f
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x30(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x98c2
movsd %xmm0, (%rsp)
movq 0x10(%r14), %rdi
callq 0x9870
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq (%r14), %r14
jmp 0x9897
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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), %eax
testl %eax, %eax
jle 0x9edd
decl %eax
movl %eax, %ecx
imull %ebx, %ecx
movslq %ecx, %rcx
movslq %ebx, %rdx
addq %r14, %rcx
addq %r14, %rax
xorl %esi, %esi
movq 0x60(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rcx,%rsi)
movq 0x58(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rax)
incq %rsi
movslq 0x4c(%r12), %rdi
addq %rdx, %rax
cmpq %rdi, %rsi
jl 0x9eac
cmpb $0x1, 0x50(%r12)
jne 0x9ef5
movl 0x54(%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xbdae
movq 0x30(%r12), %r13
addq $0x30, %r12
cmpq %r12, %r13
je 0x9f1a
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x9e7c
movq (%r13), %r13
jmp 0x9efe
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %eax
testl %eax, %eax
jle 0x9f8a
decl %eax
movl %eax, %ecx
imull %ebx, %ecx
movslq %ecx, %rcx
movslq %ebx, %rdx
addq %r14, %rcx
addq %r14, %rax
xorl %esi, %esi
movq 0x60(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rcx,%rsi)
movq 0x58(%r12), %rdi
movb (%rdi,%rsi), %dil
orb $0x30, %dil
movb %dil, (%rax)
incq %rsi
movslq 0x4c(%r12), %rdi
addq %rdx, %rax
cmpq %rdi, %rsi
jl 0x9f59
cmpb $0x1, 0x50(%r12)
jne 0x9fd8
movl 0x54(%r12), %ebp
testl %ebp, %ebp
jle 0x9fd8
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0xaf96
movq %r15, %rdi
movq %r13, %rsi
callq 0xaf1a
movl %ebp, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x30(%r12), %r13
addq $0x30, %r12
cmpq %r12, %r13
je 0x9ffd
movq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x9f24
movq (%r13), %r13
jmp 0x9fe1
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 0xa02a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2370