LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::run_gtrie(Graph*, GraphTree*)
void CmdLine::run_gtrie(Graph *g, GraphTree *sg) {
  printf("Reading G-Trie\n");
  gt_original = new GTrie();
  Timer::start(0);
  gt_original->readFromFile(gtrie_file);
  Timer::stop(0);
  printf("Creation time: %.2f\n", Timer::elapsed(0));
  printf("Compression rate = %.2f%%\n\n", gt_original->compressionRate()*100);

  gt_original->census(g);
  gt_original->populateGraphTree(sg, motif_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1c440(%rip), %rdi     # 0x200b7
xorl %eax, %eax
callq 0x3060
movl $0x8, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x13610
jmp 0x3c99
movq -0x28(%rbp), %rax
movq %rax, 0x29544(%rip)     # 0x2d1e8
xorl %edi, %edi
callq 0x18b40
movq 0x29536(%rip), %rdi     # 0x2d1e8
leaq 0x284d7(%rip), %rsi     # 0x2c190
callq 0x14040
xorl %edi, %edi
callq 0x18b80
xorl %edi, %edi
callq 0x18bc0
leaq 0x1c377(%rip), %rdi     # 0x2004a
movb $0x1, %al
callq 0x3060
movq 0x29507(%rip), %rdi     # 0x2d1e8
callq 0x13c20
movsd 0x1c31a(%rip), %xmm1    # 0x20008
mulsd %xmm1, %xmm0
leaq 0x1c385(%rip), %rdi     # 0x2007e
movb $0x1, %al
callq 0x3060
movq 0x294e1(%rip), %rdi     # 0x2d1e8
movq -0x8(%rbp), %rsi
callq 0x13cc0
movq 0x294d1(%rip), %rdi     # 0x2d1e8
movq -0x10(%rbp), %rsi
movl 0x29473(%rip), %edx     # 0x2d194
callq 0x140d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x3280
movq -0x18(%rbp), %rdi
callq 0x3440
nop
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::compare_results(void const*, void const*)
int CmdLine::compare_results(const void *a, const void *b) {
  ResultType *r1 = (ResultType *)a;
  ResultType *r2 = (ResultType *)b;

  if (r1->z_score > r2->z_score) return -1;
  if (r1->z_score < r2->z_score) return +1;
  if (r1->f_original > r2->f_original) return -1;
  if (r1->f_original < r2->f_original) return +1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x28(%rbp), %rax
ucomisd 0x20(%rax), %xmm0
jbe 0x3d89
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3de3
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3daa
movl $0x1, -0x4(%rbp)
jmp 0x3de3
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x3dc3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3de3
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3ddc
movl $0x1, -0x4(%rbp)
jmp 0x3de3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::prepare_files()
void CmdLine::prepare_files() {

  // Check output format
  if (output == NOOUTPUT)
    Error::msg("No valid output format specified");    

  if (!strcmp(output_file,  DEFAULT_RESULTS)) {
    if (output == TEXT) strcat(output_file, ".txt");
    else if (output == HTML) strcat(output_file, ".html");
  }

  f_output = fopen(output_file, "w");
  if (f_output==NULL)
    Error::msg("Unable to open output file \"%s\"", output_file);    

  if (occurrences) {
    f_occ = fopen(occ_file, "w");
    if (f_occ==NULL)
      Error::msg("Unable to open occurrences file \"%s\"", occ_file);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x293c5(%rip)     # 0x2d1c0
jne 0x3e0b
leaq 0x1c2c3(%rip), %rdi     # 0x200c7
movb $0x0, %al
callq 0xfb80
leaq 0x28b7e(%rip), %rdi     # 0x2c990
leaq 0x1c2cf(%rip), %rsi     # 0x200e8
callq 0x3390
cmpl $0x0, %eax
jne 0x3e61
cmpl $0x1, 0x29396(%rip)     # 0x2d1c0
jne 0x3e41
leaq 0x28b5d(%rip), %rdi     # 0x2c990
leaq 0x1c2b6(%rip), %rsi     # 0x200f0
callq 0x3460
jmp 0x3e5f
cmpl $0x2, 0x29378(%rip)     # 0x2d1c0
jne 0x3e5d
leaq 0x28b3f(%rip), %rdi     # 0x2c990
leaq 0x1c29d(%rip), %rsi     # 0x200f5
callq 0x3460
jmp 0x3e5f
jmp 0x3e61
leaq 0x28b28(%rip), %rdi     # 0x2c990
leaq 0x1c28c(%rip), %rsi     # 0x200fb
callq 0x3310
movq %rax, 0x29355(%rip)     # 0x2d1d0
cmpq $0x0, 0x2934d(%rip)     # 0x2d1d0
jne 0x3e9a
leaq 0x1c271(%rip), %rdi     # 0x200fd
leaq 0x28afd(%rip), %rsi     # 0x2c990
movb $0x0, %al
callq 0xfb80
testb $0x1, 0x292f0(%rip)     # 0x2d191
je 0x3ede
leaq 0x28ee6(%rip), %rdi     # 0x2cd90
leaq 0x1c24a(%rip), %rsi     # 0x200fb
callq 0x3310
movq %rax, 0x2931b(%rip)     # 0x2d1d8
cmpq $0x0, 0x29313(%rip)     # 0x2d1d8
jne 0x3edc
leaq 0x1c24f(%rip), %rdi     # 0x2011d
leaq 0x28ebb(%rip), %rsi     # 0x2cd90
movb $0x0, %al
callq 0xfb80
jmp 0x3ede
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::compute_original()
void CmdLine::compute_original() {

  // Print method description
  if (method == ESU)
    printf("Method:     ESU on original network\n");
  else if (method == GTRIE)
    printf("Method:     GTRIE with file containing complete g-trie\n");
  else if (method == SUBGRAPHS)
    printf("Method:     GTRIE with subgraphs read from file\n");

  // Compute frequency
  Global::show_occ = occurrences;
  Global::occ_file = f_occ;
  puts("\nCounting subgraph frequency on 'ORIGINAL NETWORK'");
  Timer::start(0);
  if (method == ESU) run_esu(g, &sg_original);
  else if (method == SUBGRAPHS) run_subgraphs(g, &sg_original);
  else if (method == GTRIE) run_gtrie(g, &sg_original);
  Timer::stop(0);  
  printf("%d subgraphs, ",   sg_original.countGraphs());
  printf("%.0f occurrences\n", sg_original.countOccurrences());
  printf("Time elapsed: %.6fs\n\n", Timer::elapsed(0));
  Global::show_occ = false;

  time_original = Timer::elapsed(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0x290dd(%rip)     # 0x2d1b8
jne 0x40ed
leaq 0x1c0f1(%rip), %rdi     # 0x201d5
movb $0x0, %al
callq 0x3060
jmp 0x4121
cmpl $0x2, 0x290c4(%rip)     # 0x2d1b8
jne 0x4106
leaq 0x1c0fd(%rip), %rdi     # 0x201fa
movb $0x0, %al
callq 0x3060
jmp 0x411f
cmpl $0x3, 0x290ab(%rip)     # 0x2d1b8
jne 0x411d
leaq 0x1c11c(%rip), %rdi     # 0x20232
movb $0x0, %al
callq 0x3060
jmp 0x411f
jmp 0x4121
movb 0x2906a(%rip), %cl      # 0x2d191
andb $0x1, %cl
leaq 0x39440(%rip), %rax     # 0x3d571
movb %cl, (%rax)
movq 0x2909e(%rip), %rcx     # 0x2d1d8
leaq 0x39437(%rip), %rax     # 0x3d578
movq %rcx, (%rax)
leaq 0x1c118(%rip), %rdi     # 0x20263
callq 0x33d0
xorl %edi, %edi
callq 0x18b40
cmpl $0x1, 0x2905a(%rip)     # 0x2d1b8
jne 0x4175
movq 0x29061(%rip), %rdi     # 0x2d1c8
leaq 0x29082(%rip), %rsi     # 0x2d1f0
callq 0x3b30
jmp 0x41b3
cmpl $0x3, 0x2903c(%rip)     # 0x2d1b8
jne 0x4193
movq 0x29043(%rip), %rdi     # 0x2d1c8
leaq 0x29064(%rip), %rsi     # 0x2d1f0
callq 0x3b60
jmp 0x41b1
cmpl $0x2, 0x2901e(%rip)     # 0x2d1b8
jne 0x41af
movq 0x29025(%rip), %rdi     # 0x2d1c8
leaq 0x29046(%rip), %rsi     # 0x2d1f0
callq 0x3c60
jmp 0x41b1
jmp 0x41b3
xorl %edi, %edi
callq 0x18b80
leaq 0x2902f(%rip), %rdi     # 0x2d1f0
callq 0x1a020
movl %eax, %esi
leaq 0x1c0c7(%rip), %rdi     # 0x20296
movb $0x0, %al
callq 0x3060
leaq 0x29013(%rip), %rdi     # 0x2d1f0
callq 0x1a000
leaq 0x1c0bc(%rip), %rdi     # 0x202a5
movb $0x1, %al
callq 0x3060
xorl %edi, %edi
callq 0x18bc0
leaq 0x1c0b9(%rip), %rdi     # 0x202b7
movb $0x1, %al
callq 0x3060
leaq 0x39365(%rip), %rax     # 0x3d571
movb $0x0, (%rax)
xorl %edi, %edi
callq 0x18bc0
movsd %xmm0, 0x28f8a(%rip)    # 0x2d1a8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, %edi
callq 0x3240
movq %rax, 0x27ae4(%rip)     # 0x2d1f8
testb $0x1, 0x27a77(%rip)     # 0x2d192
je 0x5724
callq 0x39b0
jmp 0x574f
cmpl $0x0, 0x27a8d(%rip)     # 0x2d1b8
jne 0x573b
leaq 0x1b2d0(%rip), %rdi     # 0x20a04
movb $0x0, %al
callq 0xfb80
callq 0x3ee0
callq 0x3df0
callq 0x40d0
callq 0x4220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x57b0
callq 0x57f0
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x58a0
movl 0x27a09(%rip), %edi     # 0x2d194
movb 0x279ff(%rip), %al      # 0x2d190
andb $0x1, %al
movzbl %al, %esi
callq 0xd9c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
leaq 0x26595(%rip), %rdi     # 0x2bd90
leaq 0x1a940(%rip), %rsi     # 0x20142
callq 0x3250
movb $0x0, 0x27982(%rip)     # 0x2d190
movl $0xffffffff, 0x2797c(%rip) # imm = 0xFFFFFFFF
movl $0x1, 0x27996(%rip)     # 0x2d1b8
leaq 0x27167(%rip), %rdi     # 0x2c990
leaq 0x1a8b8(%rip), %rsi     # 0x200e8
callq 0x3250
leaq 0x27554(%rip), %rdi     # 0x2cd90
leaq 0x1b1f0(%rip), %rsi     # 0x20a33
callq 0x3250
movl $0x0, 0x27946(%rip)     # 0x2d198
xorl %eax, %eax
movl %eax, %edi
callq 0x3240
movl %eax, 0x2793b(%rip)     # 0x2d19c
movl $0x3, 0x27935(%rip)     # 0x2d1a0
movl $0xa, 0x2792f(%rip)     # 0x2d1a4
movb $0x0, 0x27916(%rip)     # 0x2d192
movl $0x2, 0x27936(%rip)     # 0x2d1bc
movl $0x1, 0x27930(%rip)     # 0x2d1c0
movb $0x0, 0x278fa(%rip)     # 0x2d191
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x27317(%rip)     # 0x2d192
jne 0x5ea0
movq 0x2734c(%rip), %rdi     # 0x2d1d0
callq 0x3260
testb $0x1, 0x27301(%rip)     # 0x2d191
je 0x5e9e
movq 0x2733f(%rip), %rdi     # 0x2d1d8
callq 0x3260
jmp 0x5ea0
callq 0xda60
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1ab70(%rip), %rsi     # 0x20a37
callq 0x3390
cmpl $0x0, %eax
jne 0x5eda
movl $0x1, -0x4(%rbp)
jmp 0x5f1d
movq -0x10(%rbp), %rdi
leaq 0x1ab56(%rip), %rsi     # 0x20a3b
callq 0x3390
cmpl $0x0, %eax
jne 0x5ef8
movl $0x2, -0x4(%rbp)
jmp 0x5f1d
movq -0x10(%rbp), %rdi
leaq 0x1ab3e(%rip), %rsi     # 0x20a41
callq 0x3390
cmpl $0x0, %eax
jne 0x5f16
movl $0x3, -0x4(%rbp)
jmp 0x5f1d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::_init()
void GraphMatrix::_init() {
  _num_nodes = _num_edges = 0;

  _adjM             = NULL;
  _adjOut           = NULL;
  _adjIn            = NULL;
  _neighbours       = NULL;  
  _in               = NULL;
  _out              = NULL;
  _num_neighbours   = NULL;
  _array_neighbours = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x38(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x7bed
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x48(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x8650
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x8650
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x8650
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x7bdd
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7bae
jmp 0x7bdf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7b22
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x7f35
jmp 0x8024
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movb $0x1, (%rcx,%rdx)
movq 0x40(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x8690
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movq 0x48(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x8690
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x8024
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x8690
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movq 0x50(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x8690
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x8065
jmp 0x8150
movq -0x18(%rbp), %rdi
movq 0x30(%rdi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x40(%rdi), %rsi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0x10(%rbp), %edx
callq 0x8160
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x48(%rdi), %rsi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0x8160
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $-0x1, %esi
movl %esi, (%rcx,%rdx,4)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x30(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
testb $0x1, (%rax,%rcx)
jne 0x8150
movq -0x18(%rbp), %rdi
movq 0x50(%rdi), %rsi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0x10(%rbp), %edx
callq 0x8160
movq -0x18(%rbp), %rdi
movq 0x28(%rdi), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x50(%rdi), %rsi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0x8160
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8700
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x81b1
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x8720
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x81a4
jmp 0x81b1
jmp 0x81a6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8186
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x81fd
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x87b0
movq %rax, -0x38(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x87e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8820
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8740
movq %rax, -0x40(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x88a0
movq -0x30(%rbp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x84a9
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x8700
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rsi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x87b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x8900
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x88c0
testb $0x1, %al
jne 0x844a
jmp 0x8483
leaq -0x18(%rbp), %rdi
callq 0x8930
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %edx
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq -0x18(%rbp), %rdi
callq 0x8950
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x841b
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x8650
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8398
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x88a0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x8542
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x28(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x8535
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rdi
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x8690
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x84e7
jmp 0x8537
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x84d4
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x85c2
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x85a5
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8598
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8596
movq -0x28(%rbp), %rdi
callq 0x3360
jmp 0x8598
jmp 0x859a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8554
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x85c0
movq -0x30(%rbp), %rdi
callq 0x3360
jmp 0x85c2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
je 0xae61
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x18(%rax)
jmp 0xae73
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x18(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xaed5
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xaec8
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0xaebb
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0xaebd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xae89
jmp 0xaeca
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xae7a
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphUtils.cpp
// Function: GraphUtils::_compare_degree(void const*, void const*)
int GraphUtils::_compare_degree(const void *a, const void *b) {
  int n1 = *((int *)a);
  int n2 = *((int *)b);

  if (_neighbours[n1] < _neighbours[n2]) return -1;
  if (_neighbours[n1] > _neighbours[n2]) return +1;

  return 0;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq 0x222bb(%rip), %rax     # 0x2d220
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x222ad(%rip), %rcx     # 0x2d220
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xaf85
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xafb3
movq 0x22294(%rip), %rax     # 0x2d220
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x22286(%rip), %rcx     # 0x2d220
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0xafac
movl $0x1, -0x4(%rbp)
jmp 0xafb3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x218c0(%rip)     # 0x2d22c
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, 0x218b4(%rip)     # 0x2d230
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x21890(%rip)     # 0x2d238
movslq 0x21881(%rip), %rax     # 0x2d230
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x21869(%rip)     # 0x2d240
movl $0x0, 0x21853(%rip)     # 0x2d234
movq -0x8(%rbp), %rax
movq %rax, 0x2185c(%rip)     # 0x2d248
movq -0x18(%rbp), %rax
movq %rax, 0x21861(%rip)     # 0x2d258
movq -0x18(%rbp), %rdi
callq 0x19d10
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x21820(%rip), %eax     # 0x2d230
jge 0xba2d
movl -0x1c(%rbp), %edi
leaq -0x20(%rbp), %rcx
xorl %edx, %edx
movl %edx, %esi
callq 0xb450
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xba07
movq 0x21804(%rip), %rax     # 0x2d238
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xba47
movq -0x28(%rbp), %rdi
callq 0x3360
movq 0x217f2(%rip), %rax     # 0x2d240
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xba61
movq -0x30(%rbp), %rdi
callq 0x3360
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x2179c(%rip)     # 0x2d22c
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, 0x21790(%rip)     # 0x2d230
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x2176c(%rip)     # 0x2d238
movslq 0x2175d(%rip), %rax     # 0x2d230
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x21745(%rip)     # 0x2d240
movl $0x0, 0x2172f(%rip)     # 0x2d234
movq -0x8(%rbp), %rax
movq %rax, 0x21738(%rip)     # 0x2d248
movq -0x18(%rbp), %rax
movq %rax, 0x2173d(%rip)     # 0x2d258
movq -0x20(%rbp), %rax
movq %rax, 0x2172a(%rip)     # 0x2d250
movq -0x18(%rbp), %rdi
callq 0x19d10
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x216f1(%rip), %eax     # 0x2d230
jge 0xbb77
callq 0x18ce0
movaps %xmm0, %xmm1
movq 0x21700(%rip), %rax     # 0x2d250
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xbb6a
movl -0x24(%rbp), %edi
leaq -0x28(%rbp), %rcx
xorl %edx, %edx
movl %edx, %esi
callq 0xb700
jmp 0xbb6c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbb36
movq 0x216ba(%rip), %rax     # 0x2d238
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbb91
movq -0x30(%rbp), %rdi
callq 0x3360
movq 0x216a8(%rip), %rax     # 0x2d240
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xbbab
movq -0x38(%rbp), %rdi
callq 0x3360
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x10(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xbc92
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbc6c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xbcbf
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbc99
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
andb $0x1, %al
movb %al, -0x5(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x275d4(%rip)     # 0x34fb0
movl 0x275ce(%rip), %eax     # 0x34fb0
addl $0x20, %eax
subl $0x1, %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, 0x275be(%rip)     # 0x34fb4
movl 0x275b8(%rip), %esi     # 0x34fb4
movl 0x275ae(%rip), %edx     # 0x34fb0
movl $0x20, %edi
movl $0x960, %ecx            # imm = 0x960
callq 0x1b6b0
movb -0x5(%rbp), %al
andb $0x1, %al
movb %al, 0x2799c(%rip)      # 0x353b8
movl $0x1, 0x1d87a(%rip)     # 0x2b2a0
movl $0x0, 0x1d878(%rip)     # 0x2b2a8
testb $0x1, 0x27981(%rip)     # 0x353b8
je 0xda45
movl $0x1, 0x1d861(%rip)     # 0x2b2a4
jmp 0xda4f
movl $0x0, 0x1d855(%rip)     # 0x2b2a4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xf18f
movq -0x40(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf170
movl -0x14(%rbp), %ecx
imull %ecx, %ecx
movl %ecx, %eax
incl %eax
addl $0x10, %ecx
andl $-0x10, %ecx
movl %ecx, %edx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0xf1de
movq -0x50(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x32, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf1b9
movq -0x50(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3250
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x50(%rbp), %rax
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %r9d
xorl %edi, %edi
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0xecf0
addq $0x10, %rsp
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xfbb5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xfc02
callq 0x3050
movl (%rax), %edi
callq 0x30c0
movq %rax, %rsi
leaq 0x10fb5(%rip), %rdi     # 0x20bae
movb $0x0, %al
callq 0xfb80
jmp 0xfc71
movq 0x1b3cf(%rip), %rax     # 0x2afd8
movq (%rax), %rdi
leaq 0x10f9e(%rip), %rsi     # 0x20bb1
movb $0x0, %al
callq 0x33a0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1b393(%rip), %rax     # 0x2afd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3380
leaq -0x20(%rbp), %rax
movq 0x1b378(%rip), %rax     # 0x2afd8
movq (%rax), %rdi
leaq 0x1042e(%rip), %rsi     # 0x20098
movb $0x0, %al
callq 0x33a0
movl $0x1, %edi
callq 0x3330
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x15240
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x15260
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x15280
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x4c(%rax)
movb $0x0, 0x50(%rax)
movl $0x0, 0x54(%rax)
movl $0x0, 0x74(%rax)
cmpl $0x0, -0xc(%rbp)
je 0xfd76
movslq -0xc(%rbp), %rdi
callq 0x3030
movq %rax, -0x40(%rbp)
jmp 0xfcf3
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x58(%rax)
movslq -0xc(%rbp), %rdi
callq 0x3030
movq %rax, -0x48(%rbp)
jmp 0xfd0e
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x60(%rax)
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x50(%rbp)
jmp 0xfd3f
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x78(%rax)
jmp 0xfd92
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x15330
movq -0x38(%rbp), %rdi
callq 0x15350
movq -0x28(%rbp), %rdi
callq 0x15370
jmp 0xfddc
movq -0x28(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x78(%rax)
movq -0x28(%rbp), %rdi
movl $0x0, 0x70(%rdi)
movl $0x0, 0x6c(%rdi)
movl $0x0, 0x68(%rdi)
addq $0x30, %rdi
callq 0x152a0
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x152d0
movq -0x28(%rbp), %rdi
callq 0x15300
movq -0x28(%rbp), %rax
movb $0x0, 0x48(%rax)
movb $0x0, 0x49(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x4c(%rax)
je 0xfe84
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xfe32
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xfe30
movq -0x38(%rbp), %rdi
callq 0x3360
jmp 0xfe32
movq -0x30(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xfe5a
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xfe58
movq -0x40(%rbp), %rdi
callq 0x3360
jmp 0xfe5a
movq -0x30(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0xfe82
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xfe80
movq -0x48(%rbp), %rdi
callq 0x3360
jmp 0xfe82
jmp 0xfe84
leaq -0x10(%rbp), %rdi
callq 0x15390
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x153b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x15410
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x153e0
testb $0x1, %al
jne 0xfeca
jmp 0xff0a
leaq -0x10(%rbp), %rdi
callq 0x15440
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xfef7
movq -0x50(%rbp), %rdi
callq 0xfdf0
movq -0x50(%rbp), %rdi
movl $0x80, %esi
callq 0x3280
jmp 0xfef9
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15460
movq %rax, -0x28(%rbp)
jmp 0xfea6
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x15330
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x15350
movq -0x30(%rbp), %rdi
callq 0x15370
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x50(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
jne 0x1052a
movq -0x50(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1068b
leaq -0x20(%rbp), %rdi
callq 0x15390
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x153b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x15410
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x153e0
testb $0x1, %al
jne 0x10573
jmp 0x10646
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x4c(%rcx), %eax
jg 0x10622
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x4c(%rax), %esi
movl -0x24(%rbp), %edx
movq (%rdi), %rax
callq *0x50(%rax)
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15440
movq %rax, %rcx
movl -0x54(%rbp), %eax
movq (%rcx), %rcx
movq 0x60(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movb (%rcx,%rdx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x10610
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl 0x4c(%rax), %edx
movq (%rdi), %rax
callq *0x50(%rax)
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15440
movq %rax, %rcx
movl -0x58(%rbp), %eax
movq (%rcx), %rcx
movq 0x58(%rcx), %rcx
movslq -0x24(%rbp), %rdx
movb (%rcx,%rdx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x10612
jmp 0x10622
jmp 0x10614
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1057a
movq -0x50(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x4c(%rcx), %eax
jle 0x10630
jmp 0x10646
jmp 0x10632
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x15460
movq %rax, -0x40(%rbp)
jmp 0x1054c
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x15410
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x153e0
testb $0x1, %al
jne 0x1066a
jmp 0x10684
leaq -0x20(%rbp), %rdi
callq 0x15440
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x104f0
movl %eax, -0x4(%rbp)
jmp 0x1068b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::_is_intset_included(std::__cxx11::list<int, std::allocator<int>>, std::__cxx11::list<int, std::allocator<int>>)
bool GTrieNode::_is_intset_included(list<int> a, list<int> b) {
  list<int>::iterator aa, bb;

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

  while (aa!=a.end() && bb!=b.end()) {
    if (*aa == *bb) {
      aa++;
      bb++;
    } else {
      bb++;
    }      
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x15660
leaq -0x30(%rbp), %rdi
callq 0x15660
movq -0x80(%rbp), %rdi
callq 0x15760
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x15760
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x80(%rbp), %rdi
callq 0x157c0
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x15790
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x81(%rbp)
jne 0x112d6
jmp 0x112f6
movq -0x78(%rbp), %rdi
callq 0x157c0
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x15790
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x11302
jmp 0x1135d
leaq -0x28(%rbp), %rdi
callq 0x157f0
movl (%rax), %eax
movl %eax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x157f0
movq %rax, %rcx
movl -0x88(%rbp), %eax
cmpl (%rcx), %eax
jne 0x11349
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x15810
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x15810
movq %rax, -0x60(%rbp)
jmp 0x11358
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x15810
movq %rax, -0x68(%rbp)
jmp 0x112ab
movq -0x80(%rbp), %rdi
callq 0x157c0
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x158e0
testb $0x1, %al
jne 0x1137d
jmp 0x11383
movb $0x1, -0x1(%rbp)
jmp 0x11387
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)