LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::writeToFile(char*)
void GTrie::writeToFile(char *s) {
  FILE *f;
  
  f=fopen(s,"w");
  if (f!=NULL) {
    fputs("GTRIEFORMAT VERSION 1\n", f);
    _root->writeToFile(f);
    fclose(f);
  } else
    Error::msg("Unable to open g-trie output file \"%s\")", s);    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6544(%rip), %rsi      # 0x100f2
movq %r15, %rdi
callq 0x2270
testq %rax, %rax
je 0x9be5
movq %rax, %r14
leaq 0x7146(%rip), %rdi      # 0x10d0b
movq %rax, %rsi
callq 0x2240
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8fb8
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21f0
leaq 0x7136(%rip), %rdi      # 0x10d22
movq %r15, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x7c64
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::readFromFile(char*)
void GTrie::readFromFile(char *s) {
  FILE *f;
  char *dummy, buf[MAX_BUF];
  
  f=fopen(s,"r");
  if (!f) Error::msg(NULL);
  dummy=fgets(buf, MAX_BUF, f);
  _root->readFromFile(f);
  fclose(f);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rax
movq %rdi, %r14
leaq 0x689c(%rip), %rsi      # 0x104af
movq %rax, %rdi
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x9c2c
xorl %edi, %edi
xorl %eax, %eax
callq 0x7c64
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x2360
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x914e
movq %rbx, %rdi
callq 0x21f0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrie::censusSample(Graph*, double*)
void GTrie::censusSample(Graph *g, double *p) {
  int i;
  int subgraph_size = maxDepth();
  int num_nodes = g->numNodes();

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

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


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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x99fe
movl %eax, %ebp
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movl %eax, %r12d
movq (%rbx), %rdi
callq 0x8862
movl %ebp, %eax
shlq $0x2, %rax
testl %ebp, %ebp
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x17e63(%rip)     # 0x21b60
movslq %r12d, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, 0x17e59(%rip)     # 0x21b68
movl %r12d, 0x17e76(%rip)    # 0x21b8c
movq (%r14), %rax
movq %r14, %rdi
callq *0xa0(%rax)
movq %rax, 0x17e4f(%rip)     # 0x21b78
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %rax, 0x17e38(%rip)     # 0x21b70
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
movq %rax, 0x17e35(%rip)     # 0x21b80
movq %r15, 0x17e46(%rip)     # 0x21b98
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testl %eax, %eax
sete 0x17e2c(%rip)           # 0x21b90
movq 0x17dfd(%rip), %rax     # 0x21b68
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
cmpq %rcx, %r12
je 0x9d82
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x9d74
andl $0x0, 0x17dff(%rip)     # 0x21b88
movq (%rbx), %rbx
addq $0x30, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x9dbc
callq 0xab36
movq 0x17df1(%rip), %rax     # 0x21b98
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0x9d93
movq 0x10(%r14), %rdi
callq 0x9dc6
jmp 0x9d93
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::clean(int, int)
void GTrieNode::clean(int a, int b) {
  list< list<iPair> >::iterator ii;
  list<iPair> ::iterator jj;

  if (cond.size()>0) {

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

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

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0x0, 0x28(%rdi)
je 0xa1f2
leaq 0x18(%r14), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0xa1f2
leaq 0x10(%r13), %r15
movq 0x10(%r13), %rax
cmpq %r15, %rax
je 0xa1dc
cmpl %ebp, 0x10(%rax)
jne 0xa1d7
cmpl %ebx, 0x14(%rax)
jne 0xa1d7
movq %r15, %rdi
movq %rax, %rsi
callq 0xa4aa
jmp 0xa1bb
movq (%rax), %rax
jmp 0xa1bb
cmpq $0x0, 0x20(%r13)
jne 0xa1aa
movq %r15, %rdi
callq 0x664e
movb $0x1, 0x48(%r14)
jmp 0xa1aa
addq $0x30, %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0xa210
movq 0x10(%r15), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xa18a
jmp 0xa1f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GTrie.cpp
// Function: GTrieNode::cleanConditions()
void GTrieNode::cleanConditions() {
  int a, b;
  list< list<iPair> >::iterator ii;
  list<iPair> ::iterator jj, kk;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
cmpq $0x0, 0x28(%rdi)
je 0xa2ba
leaq 0x18(%r13), %r15
movq 0x18(%r13), %rax
leaq 0x10(%rax), %r12
leaq 0x30(%r13), %rbx
movq %r13, (%rsp)
leaq 0x10(%rax), %rcx
movq (%r12), %r12
cmpq %rcx, %r12
je 0xa2ba
movl 0x10(%r12), %ebp
movl 0x14(%r12), %r14d
movq %rax, %rdx
cmpq %r15, %rdx
je 0xa295
leaq 0x10(%rdx), %rsi
movq %rsi, %rdi
movq (%rdi), %rdi
cmpq %rsi, %rdi
je 0xa290
cmpl %ebp, 0x10(%rdi)
jne 0xa273
cmpl %r14d, 0x14(%rdi)
jne 0xa273
cmpq %rsi, %rdi
je 0xa290
movq (%rdx), %rdx
jmp 0xa267
cmpq %r15, %rdx
jne 0xa251
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0xa2b1
movq 0x10(%r13), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0xa18a
jmp 0xa298
movq (%r15), %rax
movq (%rsp), %r13
jmp 0xa24d
addq $0x30, %r13
movq %r13, %rbx
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0xa2d4
movq 0x10(%rbx), %rdi
callq 0xa220
jmp 0xa2c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::incrementString(int, char*)
void GraphTreeNode::incrementString(int pos, char *s) {
  if (s[pos]==0) frequency++;
  else {
    if (s[pos]=='1') {
      if (one==NULL) one = new GraphTreeNode();
      one->incrementString(pos+1, s);
    } else if (s[pos]=='0') {
      if (zero==NULL) zero = new GraphTreeNode();
      zero->incrementString(pos+1, s);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r15
addq %rdx, %r15
pushq $0x18
popq %r14
movzbl (%r15), %eax
cmpl $0x30, %eax
je 0xae11
cmpl $0x31, %eax
jne 0xae3b
movq 0x10(%rbx), %rax
testq %rax, %rax
jne 0xae33
addq $0x10, %rbx
jmp 0xae1e
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0xae33
addq $0x8, %rbx
movq %r14, %rdi
callq 0x2200
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%rbx)
incq %r15
movq %rax, %rbx
jmp 0xadf4
testl %eax, %eax
jne 0xae41
incl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::setString(int, char*, int)
void GraphTreeNode::setString(int pos, char *s, int f) {
  if (s[pos]==0) frequency=f;
  else {
    if (s[pos]=='1') {
      if (one==NULL) one = new GraphTreeNode();
      one->setString(pos+1, s, f);
    } else if (s[pos]=='0') {
      if (zero==NULL) zero = new GraphTreeNode();
      zero->setString(pos+1, s, f);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
movslq %esi, %r12
addq %rdx, %r12
pushq $0x18
popq %r15
movzbl (%r12), %eax
cmpl $0x30, %eax
je 0xae7d
cmpl $0x31, %eax
jne 0xaea7
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0xae9f
addq $0x10, %r14
jmp 0xae8a
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xae9f
addq $0x8, %r14
movq %r15, %rdi
callq 0x2200
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r14)
incq %r12
movq %rax, %r14
jmp 0xae5f
testl %eax, %eax
jne 0xaeae
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::addString(int, char*, int)
void GraphTreeNode::addString(int pos, char *s, int f) {
  if (s[pos]==0) frequency+=f;
  else {
    if (s[pos]=='1') {
      if (one==NULL) one = new GraphTreeNode();
      one->addString(pos+1, s, f);
    } else if (s[pos]=='0') {
      if (zero==NULL) zero = new GraphTreeNode();
      zero->addString(pos+1, s, f);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
movslq %esi, %r12
addq %rdx, %r12
pushq $0x18
popq %r15
movzbl (%r12), %eax
cmpl $0x30, %eax
je 0xaeef
cmpl $0x31, %eax
jne 0xaf19
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0xaf11
addq $0x10, %r14
jmp 0xaefc
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xaf11
addq $0x8, %r14
movq %r15, %rdi
callq 0x2200
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r14)
incq %r12
movq %rax, %r14
jmp 0xaed1
testl %eax, %eax
jne 0xaf20
addl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::showFrequency(int, char*)
void GraphTreeNode::showFrequency(int pos, char *s) {
  if (zero == NULL && one == NULL) {
    s[pos]=0;
    printf("%s: %d\n", s, frequency);
  } else {
    if (zero != NULL) {
      s[pos]='0';
      zero->showFrequency(pos+1, s);
    }
    if (one != NULL) {
      s[pos]='1';
      one->showFrequency(pos+1, s);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r12
movq %r12, %r15
shlq $0x20, %r15
leal 0x1(%r12), %ebp
addq %rdx, %r12
movabsq $0x100000000, %r13      # imm = 0x100000000
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
movq %rcx, %rdx
orq %rax, %rdx
je 0xaf9d
testq %rcx, %rcx
je 0xaf85
movb $0x30, (%r12)
movq 0x8(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xaf2c
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xafc8
movb $0x31, (%r12)
movq 0x10(%r14), %r14
addq %r13, %r15
incl %ebp
incq %r12
jmp 0xaf59
sarq $0x20, %r15
movb $0x0, (%rbx,%r15)
movl (%r14), %edx
leaq 0x5dd8(%rip), %rdi      # 0x10d88
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::equal(GraphTreeNode*, int, char*)
bool GraphTreeNode::equal(GraphTreeNode *gt, int pos, char *s) {
  if (zero == NULL && gt->zero!=NULL) return false;
  if (zero != NULL && gt->zero==NULL) return false;
  if (one  == NULL && gt->one !=NULL) return false;
  if (one  != NULL && gt->one ==NULL) return false;

  if (zero == NULL && one == NULL) {
    s[pos]=0;
    if (frequency != gt->frequency) 
      printf("NOT EQUAL TREE %s: %d != %d\n", s, frequency, gt->frequency);
    return (frequency == gt->frequency);
  } else {
    bool fzero, fone;
    fzero = fone = true;
    if (zero != NULL) {
      s[pos]='0';
      fzero = zero->equal(gt->zero, pos+1, s);
    }
    if (one != NULL) {
      s[pos]='1';
      fone = one->equal(gt->one, pos+1, s);
    }
    return fzero && fone;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
testq %rax, %rax
je 0xaffd
testq %rcx, %rcx
jne 0xb002
jmp 0xb024
testq %rcx, %rcx
jne 0xb024
cmpq $0x0, 0x10(%r15)
movq 0x10(%r14), %rcx
movslq %edx, %r12
je 0xb01f
testq %rcx, %rcx
je 0xb024
testq %rax, %rax
jne 0xb02d
movb $0x1, %bpl
jmp 0xb050
testq %rcx, %rcx
je 0xb028
xorl %ebp, %ebp
jmp 0xb072
testq %rax, %rax
je 0xb07d
movb $0x30, (%rbx,%r12)
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
leal 0x1(%r12), %edx
movq %rbx, %rcx
callq 0xafd8
movl %eax, %ebp
cmpq $0x0, 0x10(%r15)
je 0xb06d
movb $0x31, (%rbx,%r12)
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
incl %r12d
movl %r12d, %edx
movq %rbx, %rcx
callq 0xafd8
jmp 0xb06f
movb $0x1, %al
andb %al, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, (%rbx,%r12)
movl (%r15), %edx
movl (%r14), %ecx
cmpl %ecx, %edx
jne 0xb090
movl %edx, %eax
jmp 0xb0a7
leaq 0x5cf9(%rip), %rdi      # 0x10d90
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2060
movl (%r15), %eax
movl (%r14), %edx
cmpl %edx, %eax
sete %bpl
jmp 0xb072
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::equal(GTrie*, int, int, char*)
bool GraphTreeNode::equal(GTrie *gt, int size, int pos, char *s) {
  if (zero == NULL && one == NULL) {
    s[pos]=0;
    int aux = gt->frequencyGraphString(size, s);
    if (frequency != aux)
      printf("NOT EQUAL GTRIE %s: %d != %d\n", s, frequency, aux);
    return (frequency == aux);
  } else {
    bool fzero, fone;
    fzero = fone = true;
    if (zero != NULL) {
      s[pos]='0';
      fzero = zero->equal(gt, size, pos+1, s);
    }
    if (one != NULL) {
      s[pos]='1';
      fone = one->equal(gt, size, pos+1, s);
    }
    return fzero && fone;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
movq %rdx, %rsi
orq %rax, %rsi
jne 0xb0f7
movslq %ecx, %rax
movb $0x0, (%rbx,%rax)
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x96c0
movl %eax, %ebp
movl (%r14), %edx
cmpl %eax, %edx
jne 0xb129
movl %ebp, %eax
jmp 0xb13f
movb $0x1, %sil
movslq %ecx, %r12
testq %rdx, %rdx
je 0xb147
movb $0x30, (%rbx,%r12)
movq 0x8(%r14), %rdi
leal 0x1(%r12), %ecx
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %r8
callq 0xb0b0
movb $0x1, %sil
movl %eax, %r13d
movq 0x10(%r14), %rax
jmp 0xb14a
leaq 0x5c7d(%rip), %rdi      # 0x10dad
movq %rbx, %rsi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2060
movl (%r14), %eax
cmpl %ebp, %eax
sete %r13b
jmp 0xb170
movb $0x1, %r13b
testq %rax, %rax
je 0xb16d
movb $0x31, (%rbx,%r12)
movq 0x10(%r14), %rdi
incl %r12d
movq %r15, %rsi
movl %ebp, %edx
movl %r12d, %ecx
movq %rbx, %r8
callq 0xb0b0
movl %eax, %esi
andb %sil, %r13b
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::populateGTrie(GTrie*, int, int, char*)
void GraphTreeNode::populateGTrie(GTrie *gt, int size, int pos, char *s) {
  if (zero == NULL && one == NULL) {
    s[pos]=0;
    gt->insertGraphString(size, s);
  } else {
    if (zero != NULL) {
      s[pos]='0';
      zero->populateGTrie(gt, size, pos+1, s);
    }
    if (one != NULL) {
      s[pos]='1';
      one->populateGTrie(gt, size, pos+1, s);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movslq %ecx, %r13
movq %r13, %rbp
shlq $0x20, %rbp
leal 0x1(%r13), %r12d
addq %r8, %r13
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
movq %rcx, %rdx
orq %rax, %rdx
je 0xb202
testq %rcx, %rcx
je 0xb1df
movb $0x30, (%r13)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movl %r12d, %ecx
movq %rbx, %r8
callq 0xb182
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xb227
movb $0x31, (%r13)
movq 0x10(%r15), %r15
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %rbp
incl %r12d
incq %r13
jmp 0xb1ab
sarq $0x20, %rbp
movb $0x0, (%rbx,%rbp)
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9752
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::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>>>*, int, int, char*)
void GraphTreeNode::populateMap(mapStringInt *m, int size, int pos, char *s) {
  if (zero == NULL && one == NULL) {
    s[pos]=0;
    char s2[size*size+1];
    Isomorphism::canonicalBasedNauty(s, s2, size);
    (*m)[s2] = frequency;
  } else {
    if (zero != NULL) {
      s[pos]='0';
      zero->populateMap(m, size, pos+1, s);
    }
    if (one != NULL) {
      s[pos]='1';
      one->populateMap(m, size, pos+1, s);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
movq %rdx, %rsi
orq %rax, %rsi
jne 0xb2c6
movq %rsp, -0x38(%rbp)
movslq %ecx, %rax
movb $0x0, (%r14,%rax)
movl %r15d, %eax
imull %eax, %eax
movq %rsp, %r13
addl $0x10, %eax
andl $-0x10, %eax
subq %rax, %r13
movq %r13, %rsp
movq %r14, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x6e34
movl (%r12), %r15d
leaq -0x58(%rbp), %r14
leaq -0x29(%rbp), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0xa46e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa408
movl %r15d, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x20f0
movq -0x38(%rbp), %rsp
jmp 0xb320
movslq %ecx, %r13
testq %rdx, %rdx
je 0xb2ef
movb $0x30, (%r14,%r13)
movq 0x8(%r12), %rdi
leal 0x1(%r13), %ecx
movq %rbx, %rsi
movl %r15d, %edx
movq %r14, %r8
callq 0xb236
movq 0x10(%r12), %rax
testq %rax, %rax
je 0xb320
movb $0x31, (%r14,%r13)
movq 0x10(%r12), %rdi
incl %r13d
movq %rbx, %rsi
movl %r15d, %edx
movl %r13d, %ecx
movq %r14, %r8
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb236
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::populateGTrieNauty(GTrie*, int, int, char*, bool)
void GraphTreeNode::populateGTrieNauty(GTrie *gt, int size, int pos, char *s, bool dir) {
  if (frequency>0) {
    s[pos]=0;
    gt->insertGraphNautyString(size, s, dir, 1);
  }
   
  if (zero != NULL) {
    s[pos]='0';
    zero->populateGTrieNauty(gt, size, pos+1, s, dir);
  }
  if (one != NULL) {
    s[pos]='1';
    one->populateGTrieNauty(gt, size, pos+1, s, dir);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movslq %ecx, %rbp
leal 0x1(%rbp), %r12d
addq %r8, %rbp
movzbl %r9b, %r13d
cmpl $0x0, (%r15)
jle 0xb38a
movb $0x0, (%rbp)
movq %r14, %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
movl %r13d, %ecx
pushq $0x1
popq %r8
callq 0x98b0
cmpq $0x0, 0x8(%r15)
je 0xb3ae
movb $0x30, (%rbp)
movq 0x8(%r15), %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
movl %r12d, %ecx
movq %rbx, %r8
movl %r13d, %r9d
callq 0xb344
cmpq $0x0, 0x10(%r15)
je 0xb3c5
movb $0x31, (%rbp)
movq 0x10(%r15), %r15
incl %r12d
incq %rbp
jmp 0xb36a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::countOccurrences()
double GraphTreeNode::countOccurrences() {
  double aux = frequency;
  if (zero != NULL) aux += zero->countOccurrences();
  if (one != NULL)  aux +=  one->countOccurrences();
  return aux;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cvtsi2sdl (%rdi), %xmm0
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xb40a
movsd %xmm0, 0x8(%rsp)
callq 0xb3d4
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xb434
movsd %xmm0, 0x8(%rsp)
callq 0xb3d4
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphTree.cpp
// Function: GraphTreeNode::countGraphs()
int GraphTreeNode::countGraphs() {
  int aux = 0;
  if (frequency>0) aux++;
  if (zero != NULL) aux += zero->countGraphs();
  if (one != NULL)  aux +=  one->countGraphs();
  return aux;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpl $0x0, (%r14)
setg %bpl
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb45d
callq 0xb43a
addl %eax, %ebp
addl %ebp, %ebx
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0xb443
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nauty.c
// Function: nauty_freedyn
void
nauty_freedyn(void)
{
#if !MAXN
	tcnode *tcp,*tcq;

        tcp = tcnode0.next;
        while (tcp != NULL)
        {   
            tcq = tcp->next;
            FREES(tcp->tcellptr);
            FREES(tcp);
            tcp = tcq;
        }
        alloc_m = 0;
        tcnode0.next = NULL;
        DYNFREE(firsttc,firsttc_sz);
        DYNFREE(canoncode,canoncode_sz);
        DYNFREE(firstcode,firstcode_sz);
        DYNFREE(workperm,workperm_sz);
        DYNFREE(canonlab,canonlab_sz);
        DYNFREE(firstlab,firstlab_sz);
        DYNFREE(defltwork,defltwork_sz);
	DYNFREE(fixedpts,fixedpts_sz);
	DYNFREE(active,active_sz);
#endif  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1d314(%rip), %rbx     # 0x299d0
testq %rbx, %rbx
je 0xc6da
movq (%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x2280
movq %r14, %rbx
jmp 0xc6bc
andl $0x0, 0x1d2e7(%rip)     # 0x299c8
andq $0x0, 0x1d2e7(%rip)     # 0x299d0
cmpq $0x0, 0x1d2c7(%rip)     # 0x299b8
je 0xc707
movq 0x1d2c6(%rip), %rdi     # 0x299c0
callq 0x2280
andq $0x0, 0x1d2b1(%rip)     # 0x299b8
cmpq $0x0, 0x1d299(%rip)     # 0x299a8
je 0xc725
movq 0x1d298(%rip), %rdi     # 0x299b0
callq 0x2280
andq $0x0, 0x1d283(%rip)     # 0x299a8
cmpq $0x0, 0x1d26b(%rip)     # 0x29998
je 0xc743
movq 0x1d26a(%rip), %rdi     # 0x299a0
callq 0x2280
andq $0x0, 0x1d255(%rip)     # 0x29998
cmpq $0x0, 0x1d21d(%rip)     # 0x29968
je 0xc761
movq 0x1d21c(%rip), %rdi     # 0x29970
callq 0x2280
andq $0x0, 0x1d207(%rip)     # 0x29968
cmpq $0x0, 0x1d21f(%rip)     # 0x29988
je 0xc77f
movq 0x1d21e(%rip), %rdi     # 0x29990
callq 0x2280
andq $0x0, 0x1d209(%rip)     # 0x29988
cmpq $0x0, 0x1d1f1(%rip)     # 0x29978
je 0xc79d
movq 0x1d1f0(%rip), %rdi     # 0x29980
callq 0x2280
andq $0x0, 0x1d1db(%rip)     # 0x29978
cmpq $0x0, 0x1d193(%rip)     # 0x29938
je 0xc7bb
movq 0x1d192(%rip), %rdi     # 0x29940
callq 0x2280
andq $0x0, 0x1d17d(%rip)     # 0x29938
cmpq $0x0, 0x1d185(%rip)     # 0x29948
je 0xc7d9
movq 0x1d184(%rip), %rdi     # 0x29950
callq 0x2280
andq $0x0, 0x1d16f(%rip)     # 0x29948
cmpq $0x0, 0x1d177(%rip)     # 0x29958
je 0xc7f7
movq 0x1d176(%rip), %rdi     # 0x29960
callq 0x2280
andq $0x0, 0x1d161(%rip)     # 0x29958
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nauty.c
// Function: extra_autom
void
extra_autom(permutation *p, int n)
{
        if (writeautoms)
            writeperm(outfile,p,cartesian,linelength,n);
        stats->numorbits = orbjoin(orbits,p,n);
        ++stats->numgenerators;
        OPTCALL(userautomproc)(stats->numgenerators,p,orbits,
                                        stats->numorbits,stabvertex,n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x1d1a0(%rip)     # 0x299f8
je 0xc878
movq 0x1d1af(%rip), %rdi     # 0x29a10
movl 0x1d199(%rip), %edx     # 0x29a00
movl 0x1d197(%rip), %ecx     # 0x29a04
movq %r14, %rsi
movl %ebx, %r8d
callq 0xd7b3
movq 0x1d161(%rip), %rdi     # 0x299e0
movq %r14, %rsi
movl %ebx, %edx
callq 0xd741
movq 0x1d158(%rip), %rcx     # 0x299e8
movl %eax, 0xc(%rcx)
movl 0x10(%rcx), %edi
incl %edi
movl %edi, 0x10(%rcx)
movq 0x1d17e(%rip), %r11     # 0x29a20
testq %r11, %r11
je 0xc8c7
movq 0x1d132(%rip), %rdx     # 0x299e0
movl 0x1d1df(%rip), %r8d     # 0x29a94
movq %r14, %rsi
movl %eax, %ecx
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%r11
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nauty.c
// Function: extra_level
void
extra_level(int level, int *lab, int *ptn, int numcells, int tv1, int index,
            int tcellsize, int childcount, int n)
{
        MULTIPLY(stats->grpsize1,stats->grpsize2,index);
        if (domarkers)
            writemarker(level,tv1,index,tcellsize,stats->numorbits,numcells);
        OPTCALL(userlevelproc)(lab,ptn,level,orbits,stats,tv1,index,tcellsize,
                                                        numcells,childcount,n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r14
cvtsi2sd %r9d, %xmm0
movl %edi, %r13d
movq 0x1d0ef(%rip), %rax     # 0x299e8
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
ucomisd 0x44c7(%rip), %xmm0     # 0x10dd0
jb 0xc91b
divsd 0x44bd(%rip), %xmm0     # 0x10dd0
movsd %xmm0, (%rax)
addl $0xa, 0x8(%rax)
movl 0x40(%rsp), %r15d
cmpl $0x0, 0x1d0d5(%rip)     # 0x299fc
je 0xc940
movl 0xc(%rax), %r8d
movl %r13d, %edi
movl %ebp, %esi
movl %ebx, %edx
movl %r15d, %ecx
movq (%rsp), %r9
callq 0xc996
movq 0x1d0e1(%rip), %rax     # 0x29a28
testq %rax, %rax
je 0xc987
movl 0x50(%rsp), %r10d
movl 0x48(%rsp), %r11d
movq 0x1d083(%rip), %rcx     # 0x299e0
movq 0x1d084(%rip), %r8      # 0x299e8
subq $0x8, %rsp
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
movl %ebp, %r9d
pushq %r10
pushq %r11
pushq 0x18(%rsp)
pushq %r15
pushq %rbx
callq *%rax
addq $0x38, %rsp
jmp 0xc98b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nauty.c
// Function: writemarker(int, int, int, int, int, int)
static void
writemarker(int level, int tv, int index, int tcellsize,
            int numorbits, int numcells)
{
        char s[30];

#define PUTINT(i) itos(i,s); putstring(outfile,s)
#define PUTSTR(x) putstring(outfile,x)

        PUTSTR("level ");
        PUTINT(level);
        PUTSTR(":  ");
        if (numcells != numorbits)
        {
            PUTINT(numcells);
            PUTSTR(" cell");
            if (numcells == 1) PUTSTR("; ");
            else               PUTSTR("s; ");
        }
        PUTINT(numorbits);
        PUTSTR(" orbit");
        if (numorbits == 1) PUTSTR("; ");
        else                PUTSTR("s; ");
        PUTINT(tv+labelorg);
        PUTSTR(" fixed; index ");
        PUTINT(index);
        if (tcellsize != index)
        {
            PUTSTR("/");
            PUTINT(tcellsize);
        }
        PUTSTR("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r12d
movl %r8d, %r15d
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r13d
movq 0x1d053(%rip), %rdi     # 0x29a10
leaq 0x45c6(%rip), %rsi      # 0x10f8a
callq 0xd6bf
leaq 0x10(%rsp), %rbx
movl %r13d, %edi
movq %rbx, %rsi
callq 0xd6e5
movq 0x1d030(%rip), %rdi     # 0x29a10
movq %rbx, %rsi
callq 0xd6bf
movq 0x1d021(%rip), %rdi     # 0x29a10
leaq 0x459b(%rip), %rsi      # 0x10f91
callq 0xd6bf
cmpl %r15d, %r12d
je 0xca54
leaq 0x10(%rsp), %rbx
movl %r12d, %edi
movq %rbx, %rsi
callq 0xd6e5
movq 0x1cff9(%rip), %rdi     # 0x29a10
movq %rbx, %rsi
callq 0xd6bf
movq 0x1cfea(%rip), %rdi     # 0x29a10
leaq 0x4568(%rip), %rsi      # 0x10f95
callq 0xd6bf
cmpl $0x1, %r12d
movq 0x1cfd3(%rip), %rdi     # 0x29a10
leaq 0x4558(%rip), %rax      # 0x10f9c
leaq 0x4550(%rip), %rsi      # 0x10f9b
cmoveq %rax, %rsi
callq 0xd6bf
leaq 0x10(%rsp), %r12
movl %r15d, %edi
movq %r12, %rsi
callq 0xd6e5
movq 0x1cfa5(%rip), %rdi     # 0x29a10
movq %r12, %rsi
callq 0xd6bf
movq 0x1cf96(%rip), %rdi     # 0x29a10
leaq 0x451e(%rip), %rsi      # 0x10f9f
callq 0xd6bf
cmpl $0x1, %r15d
leaq 0x450b(%rip), %rax      # 0x10f9c
leaq 0x4503(%rip), %rsi      # 0x10f9b
cmoveq %rax, %rsi
movq 0x1cf6d(%rip), %rdi     # 0x29a10
callq 0xd6bf
leaq 0x1d009(%rip), %rax     # 0x29ab8
addl (%rax), %r14d
movl %r14d, %edi
movq %r12, %rsi
callq 0xd6e5
movq 0x1cf4c(%rip), %rdi     # 0x29a10
movq %r12, %rsi
callq 0xd6bf
movq 0x1cf3d(%rip), %rdi     # 0x29a10
leaq 0x44cc(%rip), %rsi      # 0x10fa6
callq 0xd6bf
movl %ebp, %edi
movq %r12, %rsi
callq 0xd6e5
movq 0x1cf20(%rip), %rdi     # 0x29a10
movq %r12, %rsi
callq 0xd6bf
movl 0xc(%rsp), %eax
cmpl %ebp, %eax
je 0xcb33
movl %eax, %ebp
movq 0x1cf07(%rip), %rdi     # 0x29a10
leaq 0x44a5(%rip), %rsi      # 0x10fb5
callq 0xd6bf
leaq 0x10(%rsp), %rbx
movl %ebp, %edi
movq %rbx, %rsi
callq 0xd6e5
movq 0x1cee5(%rip), %rdi     # 0x29a10
movq %rbx, %rsi
callq 0xd6bf
movq 0x1ced6(%rip), %rdi     # 0x29a10
leaq 0x3566(%rip), %rsi      # 0x100a7
callq 0xd6bf
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nauty.c
// Function: recover(int*, int)
static void
recover(int *ptn, int level)
{
        int i;

        for (i = 0; i < n; ++i)
            if (ptn[i] > level) ptn[i] = NAUTY_INFINITY;

        if (level < noncheaplevel) noncheaplevel = level + 1;
        if (level < eqlev_first) eqlev_first = level;
        if (getcanon)
        {
            if (level < gca_canon) gca_canon = level;
            if (level <= eqlev_canon)
            {
                eqlev_canon = level;
                comp_canon = 0;
            }
        }
}

// Assembly:
movslq 0x1c44d(%rip), %rax     # 0x29934
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0xd4ff
cmpl %esi, (%rdi,%rcx,4)
jle 0xd4fa
movl $0x40000002, (%rdi,%rcx,4) # imm = 0x40000002
incq %rcx
jmp 0xd4e9
cmpl %esi, 0x1c553(%rip)     # 0x29a58
jle 0xd510
leal 0x1(%rsi), %eax
movl %eax, 0x1c548(%rip)     # 0x29a58
cmpl %esi, 0x1c58e(%rip)     # 0x29aa4
jle 0xd51e
movl %esi, 0x1c586(%rip)     # 0x29aa4
cmpl $0x0, 0x1c4cb(%rip)     # 0x299f0
je 0xd54a
cmpl %esi, 0x1c57b(%rip)     # 0x29aa8
jle 0xd535
movl %esi, 0x1c573(%rip)     # 0x29aa8
cmpl %esi, 0x1c521(%rip)     # 0x29a5c
jl 0xd54a
movl %esi, 0x1c519(%rip)     # 0x29a5c
andl $0x0, 0x1c566(%rip)     # 0x29ab0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: nextelement
int
nextelement(set *set1, int m, int pos)
{
	setword setwd;
	int w;

#if  MAXM==1
	if (pos < 0) setwd = set1[0];
	else         setwd = set1[0] & BITMASK(pos);

	if (setwd == 0) return -1;
	else            return FIRSTBIT(setwd);
#else
	if (pos < 0)
	{
	    w = 0;
	    setwd = set1[0];
	}
	else
	{
	    w = SETWD(pos);
	    setwd = set1[w] & BITMASK(SETBT(pos));
	}

	for (;;)
	{
	    if (setwd != 0) return  TIMESWORDSIZE(w) + FIRSTBIT(setwd);
	    if (++w == m) return -1;
	    setwd = set1[w];
	}

#endif
}

// Assembly:
testl %edx, %edx
js 0xd564
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl %edx, %ecx
shrl %cl, %r8d
shrl $0x5, %edx
andl (%rdi,%rdx,4), %r8d
jmp 0xd569
movl (%rdi), %r8d
xorl %edx, %edx
movl %esi, %esi
movl %edx, %ecx
shll $0x5, %ecx
negl %ecx
incq %rdx
pushq $-0x1
popq %rax
testl %r8d, %r8d
jne 0xd58e
cmpq %rdx, %rsi
je 0xd5f4
movl (%rdi,%rdx,4), %r8d
addl $-0x20, %ecx
incq %rdx
jmp 0xd578
cmpl $0x10000, %r8d          # imm = 0x10000
jae 0xd5b2
cmpl $0x100, %r8d            # imm = 0x100
jae 0xd5cf
movl %r8d, %eax
leaq 0x3a96(%rip), %rdx      # 0x11040
movl (%rdx,%rax,4), %eax
addl $0x18, %eax
jmp 0xd5f2
cmpl $0x1000000, %r8d        # imm = 0x1000000
jae 0xd5e3
shrl $0x10, %r8d
leaq 0x3a7a(%rip), %rax      # 0x11040
movl (%rax,%r8,4), %eax
addl $0x8, %eax
jmp 0xd5f2
shrl $0x8, %r8d
leaq 0x3a66(%rip), %rax      # 0x11040
movl (%rax,%r8,4), %eax
addl $0x10, %eax
jmp 0xd5f2
shrl $0x18, %r8d
leaq 0x3a52(%rip), %rax      # 0x11040
movl (%rax,%r8,4), %eax
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: permset
void
permset(set *set1, set *set2, int m, permutation *perm)
{
	setword setw;
	int pos,w,b;

	EMPTYSET(set2,m);

#if  MAXM==1
        setw = set1[0];
	while (setw  != 0)
	{
	    TAKEBIT(b,setw);
	    pos = perm[b];
	    ADDELEMENT(set2,pos);
	}
#else
	for (w = 0; w < m; ++w)
	{
	    setw = set1[w];
	    while (setw != 0)
	    {
		TAKEBIT(b,setw);
	        pos = perm[TIMESWORDSIZE(w)+b];
	        ADDELEMENT(set2,pos);
	    }
	}
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq %edx, %rax
leaq (%rsi,%rax,4), %rax
addq $-0x4, %rax
cmpq %rsi, %rax
jb 0xd612
andl $0x0, (%rax)
addq $-0x4, %rax
jmp 0xd604
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
leaq 0x3a20(%rip), %r8       # 0x11040
leaq 0x3999(%rip), %r9       # 0x10fc0
cmpq %rdx, %rax
je 0xd6ba
movl (%rdi,%rax,4), %r10d
movl %eax, %r11d
shll $0x5, %r11d
testl %r10d, %r10d
je 0xd6b2
cmpl $0x10000, %r10d         # imm = 0x10000
jae 0xd65e
cmpl $0x100, %r10d           # imm = 0x100
jae 0xd676
movl %r10d, %ebx
movl (%r8,%rbx,4), %ebx
addl $0x18, %ebx
jmp 0xd68c
movl %r10d, %ebx
cmpl $0x1000000, %r10d       # imm = 0x1000000
jae 0xd685
shrl $0x10, %ebx
movl (%r8,%rbx,4), %ebx
addl $0x8, %ebx
jmp 0xd68c
movl %r10d, %ebx
shrl $0x8, %ebx
movl (%r8,%rbx,4), %ebx
addl $0x10, %ebx
jmp 0xd68c
shrl $0x18, %ebx
movl (%r8,%rbx,4), %ebx
movslq %ebx, %rbx
xorl (%r9,%rbx,4), %r10d
addl %r11d, %ebx
movslq %ebx, %rbx
movl (%rcx,%rbx,4), %ebx
movl %ebx, %r14d
andl $0x1f, %r14d
movl (%r9,%r14,4), %ebp
sarl $0x5, %ebx
movslq %ebx, %rbx
orl %ebp, (%rsi,%rbx,4)
jmp 0xd63b
incq %rax
jmp 0xd627
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: orbjoin
int
orbjoin(int *orbits, permutation *perm, int n)
{
	int i,j1,j2;

	for (i = 0; i < n; ++i)
	{
	    j1 = orbits[i];
	    while (orbits[j1] != j1) j1 = orbits[j1];
	    j2 = orbits[perm[i]];
	    while (orbits[j2] != j2) j2 = orbits[j2];

	    if (j1 < j2)      orbits[j2] = j1;
	    else if (j1 > j2) orbits[j1] = j2;
	}

	j1 = 0;
	for (i = 0; i < n; ++i)
	    if ((orbits[i] = orbits[orbits[i]]) == i) ++j1;

	return j1;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rdx, %rax
je 0xd78d
movl (%rdi,%rax,4), %r9d
movl %r9d, %r8d
movslq %r9d, %rcx
movl (%rdi,%rcx,4), %r9d
cmpl %ecx, %r9d
jne 0xd751
movslq (%rsi,%rax,4), %r9
movl (%rdi,%r9,4), %r11d
movl %r11d, %r9d
movslq %r11d, %r10
movl (%rdi,%r10,4), %r11d
cmpl %r10d, %r11d
jne 0xd768
cmpl %r9d, %r8d
jge 0xd782
movl %r8d, (%rdi,%r10,4)
jmp 0xd788
jle 0xd788
movl %r9d, (%rdi,%rcx,4)
incq %rax
jmp 0xd748
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0xd7b2
movslq (%rdi,%rcx,4), %rsi
movl (%rdi,%rsi,4), %esi
movl %esi, (%rdi,%rcx,4)
xorl %r8d, %r8d
cmpq %rsi, %rcx
sete %r8b
addl %r8d, %eax
incq %rcx
jmp 0xd791
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: fmperm
void
fmperm(permutation *perm, set *fix, set *mcr, int m, int n)
{
	int i,k,l;

#if !MAXN
	DYNALLOC1(permutation,workperm,workperm_sz,n,"writeperm");
#endif

	EMPTYSET(fix,m);
	EMPTYSET(mcr,m);

	for (i = n; --i >= 0;) workperm[i] = 0;

	for (i = 0; i < n; ++i)
	    if (perm[i] == i)
	    {
	        ADDELEMENT(fix,i);
	        ADDELEMENT(mcr,i);
	    }
	    else if (workperm[i] == 0)
	    {
	        l = i;
	        do
	        {
	            k = l;
	            l = perm[l];
	            workperm[k] = 1;
	        }
	        while (l != i);

	        ADDELEMENT(mcr,i);
	    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq %r8d, %r13
movq 0x1c05a(%rip), %rax     # 0x29ac0
cmpq %r13, %rax
jae 0xda9f
testq %rax, %rax
je 0xda7c
movq 0x1c051(%rip), %rdi     # 0x29ac8
callq 0x2280
movq %r13, 0x1c03d(%rip)     # 0x29ac0
shlq $0x2, %r13
movq %r13, %rdi
callq 0x22d0
movq %rax, 0x1c032(%rip)     # 0x29ac8
testq %rax, %rax
je 0xdb58
movslq %ebp, %rax
leaq (%r15,%rax,4), %rcx
addq $-0x4, %rcx
cmpq %r15, %rcx
jb 0xdab8
andl $0x0, (%rcx)
addq $-0x4, %rcx
jmp 0xdaaa
leaq (%r14,%rax,4), %rax
addq $-0x4, %rax
cmpq %r14, %rax
jb 0xdace
andl $0x0, (%rax)
addq $-0x4, %rax
jmp 0xdac0
movq 0x1bff3(%rip), %rax     # 0x29ac8
movl %ebx, %ecx
testl %ecx, %ecx
jle 0xdae5
andl $0x0, -0x4(%rax,%rcx,4)
decq %rcx
jmp 0xdad7
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
leaq 0x34cd(%rip), %rdx      # 0x10fc0
cmpq %rbx, %rcx
je 0xdb49
movl (%r12,%rcx,4), %esi
cmpq %rsi, %rcx
jne 0xdb16
movl %ecx, %esi
andl $0x1f, %esi
movl (%rdx,%rsi,4), %esi
movq %rcx, %rdi
shrq $0x5, %rdi
orl %esi, (%r15,%rdi,4)
jmp 0xdb40
cmpl $0x0, (%rax,%rcx,4)
jne 0xdb44
movl %ecx, %esi
movslq %esi, %rdi
movl (%r12,%rdi,4), %esi
movl $0x1, (%rax,%rdi,4)
cmpq %rsi, %rcx
jne 0xdb1e
movl %ecx, %esi
andl $0x1f, %esi
movl (%rdx,%rsi,4), %esi
movq %rcx, %rdi
shrq $0x5, %rdi
orl %esi, (%r14,%rdi,4)
incq %rcx
jmp 0xdaf3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38e1(%rip), %rdi      # 0x11440
callq 0xda1f
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: fmptn
void
fmptn(int *lab, int *ptn, int level, set *fix, set *mcr, int m, int n)
{
	int i,lmin;

	EMPTYSET(fix,m);
	EMPTYSET(mcr,m);

	for (i = 0; i < n; ++i)
	    if (ptn[i] <= level)
	    {
	        ADDELEMENT(fix,lab[i]);
	        ADDELEMENT(mcr,lab[i]);
	    }
	    else
	    {
	        lmin = lab[i];
	        do
	            if (lab[++i] < lmin) lmin = lab[i];
	        while (ptn[i] > level);
	        ADDELEMENT(mcr,lmin);
	    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x38(%rsp), %eax
movslq %r9d, %r9
leaq (%rcx,%r9,4), %r10
addq $-0x4, %r10
cmpq %rcx, %r10
jb 0xdb8c
andl $0x0, (%r10)
addq $-0x4, %r10
jmp 0xdb7d
leaq (%r8,%r9,4), %r9
addq $-0x4, %r9
cmpq %r8, %r9
jb 0xdba3
andl $0x0, (%r9)
addq $-0x4, %r9
jmp 0xdb94
leaq 0x4(%rdi), %r9
leaq 0x4(%rsi), %r10
xorl %r11d, %r11d
leaq 0x340b(%rip), %rbx      # 0x10fc0
cmpl %eax, %r11d
jge 0xdc24
movslq %r11d, %r15
movl (%rdi,%r15,4), %r14d
cmpl %edx, (%rsi,%r15,4)
jle 0xdbef
leaq (%r9,%r15,4), %r12
leaq (%r10,%r15,4), %r15
xorl %r13d, %r13d
movq %r13, %rbp
movl (%r12,%r13,4), %r13d
cmpl %r14d, %r13d
cmovll %r13d, %r14d
leaq 0x1(%rbp), %r13
cmpl %edx, (%r15,%rbp,4)
jg 0xdbd2
addl %r13d, %r11d
jmp 0xdc09
movl %r14d, %r12d
andl $0x1f, %r12d
movl (%rbx,%r12,4), %ebp
sarl $0x5, %r14d
movslq %r14d, %r14
orl %ebp, (%rcx,%r14,4)
movl (%rdi,%r15,4), %r14d
movl %r14d, %r15d
andl $0x1f, %r15d
movl (%rbx,%r15,4), %ebp
sarl $0x5, %r14d
movslq %r14d, %r14
orl %ebp, (%r8,%r14,4)
incl %r11d
jmp 0xdbb5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: maketargetcell
void
maketargetcell(graph *g, int *lab, int *ptn, int level, set *tcell,
           int *tcellsize, int *cellpos, int tc_level, boolean digraph,
	   int hint,
           int (*targetcell)(graph*,int*,int*,int,int,boolean,int,int,int),
           int m, int n)
{
	int i,j,k;

	i = (*targetcell)(g,lab,ptn,level,tc_level,digraph,hint,m,n);
	for (j = i + 1; ptn[j] > level; ++j) {}

	*tcellsize = j - i + 1;

	EMPTYSET(tcell,m);
	for (k = i; k <= j; ++k) ADDELEMENT(tcell,lab[k]);

	*cellpos = i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movl 0x68(%rsp), %r13d
movl 0x48(%rsp), %r8d
movl 0x50(%rsp), %r9d
movl 0x58(%rsp), %eax
movl 0x70(%rsp), %r10d
subq $0x8, %rsp
pushq %r10
pushq %r13
pushq %rax
callq *0x80(%rsp)
addq $0x20, %rsp
movslq %eax, %rcx
movq %rcx, %rdx
shlq $0x20, %rdx
leaq (%r12,%rcx,4), %rsi
pushq $0x1
popq %r8
movabsq $0x100000000, %rdi      # imm = 0x100000000
movq %r8, %r9
addq %rdi, %rdx
incq %r8
cmpl %ebp, (%rsi,%r9,4)
jg 0xe048
movl %r8d, (%r15)
movslq %r13d, %rsi
leaq (%rbx,%rsi,4), %rsi
addq $-0x4, %rsi
cmpq %rbx, %rsi
jb 0xe073
andl $0x0, (%rsi)
addq $-0x4, %rsi
jmp 0xe065
sarq $0x20, %rdx
leaq 0x2f42(%rip), %rsi      # 0x10fc0
cmpq %rdx, %rcx
jg 0xe0a1
movl (%r14,%rcx,4), %edi
movl %edi, %r8d
andl $0x1f, %r8d
movl (%rsi,%r8,4), %r8d
sarl $0x5, %edi
movslq %edi, %rdi
orl %r8d, (%rbx,%rdi,4)
incq %rcx
jmp 0xe07e
movq 0x40(%rsp), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: breakout
void
breakout(int *lab, int *ptn, int level, int tc, int tv,
         set *active, int m)
{
	int i,prev,next;

	EMPTYSET(active,m);
	ADDELEMENT(active,tc);

	i = tc;
	prev = tv;

	do
	{
	    next = lab[i];
	    lab[i++] = prev;
	    prev = next;
	}
	while (prev != tv);

	ptn[tc] = level;
}

// Assembly:
movslq 0x8(%rsp), %rax
leaq (%r9,%rax,4), %rax
addq $-0x4, %rax
cmpq %r9, %rax
jb 0xe0ea
andl $0x0, (%rax)
addq $-0x4, %rax
jmp 0xe0dc
movl %ecx, %eax
andl $0x1f, %eax
leaq 0x2eca(%rip), %r10      # 0x10fc0
movl (%r10,%rax,4), %r10d
movslq %ecx, %rax
sarl $0x5, %ecx
movslq %ecx, %rcx
orl %r10d, (%r9,%rcx,4)
leaq (%rdi,%rax,4), %rcx
movl %r8d, %edi
movl (%rcx), %r9d
movl %edi, (%rcx)
addq $0x4, %rcx
movl %r9d, %edi
cmpl %r8d, %r9d
jne 0xe10e
movl %edx, (%rsi,%rax,4)
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/nautil.c
// Function: longprune
void
longprune(set *tcell, set *fix, set *bottom, set *top, int m)
{
	int i;

	while (bottom < top)
	{
	    for (i = 0; i < M; ++i)
	        if (NOTSUBSET(fix[i],bottom[i])) break;
	    bottom += M;

	    if (i == M)
	        for (i = 0; i < M; ++i) INTERSECT(tcell[i],bottom[i]);
	    bottom += M;
	}
}

// Assembly:
pushq %rbx
movslq %r8d, %rax
xorl %r9d, %r9d
testl %eax, %eax
cmovgl %r8d, %r9d
leaq (%rdx,%rax,4), %r10
shlq $0x3, %rax
cmpq %rcx, %rdx
jae 0xe17b
xorl %r11d, %r11d
cmpq %r11, %r9
je 0xe156
movl (%rdx,%r11,4), %ebx
notl %ebx
testl %ebx, (%rsi,%r11,4)
jne 0xe159
incq %r11
jmp 0xe140
movl %r9d, %r11d
cmpl %r8d, %r11d
jne 0xe173
xorl %r11d, %r11d
cmpq %r11, %r9
je 0xe173
movl (%r10,%r11,4), %ebx
andl %ebx, (%rdi,%r11,4)
incq %r11
jmp 0xe161
addq %rax, %rdx
addq %rax, %r10
jmp 0xe138
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/naugraph.c
// Function: isautom
boolean
isautom(graph *g, permutation *perm, boolean digraph, int m, int n)
{
	set *pg;
	int pos;
	set *pgp;
	int posp,i;

	for (pg = g, i = 0; i < n; pg += M, ++i)
	{
	    pgp = GRAPHROW(g,perm[i],M);
	    pos = (digraph ? -1 : i);

	    while ((pos = nextelement(pg,M,pos)) >= 0)
	    {
	        posp = perm[pos];
	        if (!ISELEMENT(pgp,posp)) return FALSE;
	    }
	}
	return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rsi, %r15
xorl %r13d, %r13d
testl %r8d, %r8d
cmovlel %r13d, %r8d
movslq %ecx, %rcx
leaq 0x32bd(%rip), %r14      # 0x114d0
movq %rdi, %r12
movq %r8, 0x20(%rsp)
movl %edx, 0xc(%rsp)
movq %rdi, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq %r8, %r13
je 0xe2a1
movslq (%r15,%r13,4), %rax
imulq %rcx, %rax
leaq (%rdi,%rax,4), %rbx
movl %edx, %eax
negl %eax
movl $0x0, %eax
sbbl %eax, %eax
orl %r13d, %eax
movq %r12, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xd54c
testl %eax, %eax
js 0xe274
movl %eax, %ecx
movl (%r15,%rcx,4), %ecx
movl %ecx, %edx
sarl $0x5, %edx
movslq %edx, %rdx
andl $0x1f, %ecx
movl (%r14,%rcx,4), %ecx
testl %ecx, (%rbx,%rdx,4)
jne 0xe248
jmp 0xe290
movq 0x10(%rsp), %rcx
leaq (%r12,%rcx,4), %r12
incq %r13
movq 0x20(%rsp), %r8
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rdi
jmp 0xe229
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0xe292
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/nauty/naugraph.c
// Function: testcanlab
int
testcanlab(graph *g, graph *canong, int *lab, int *samerows, int m, int n)
{
	int i,j;
	set *ph;

#if !MAXN
	DYNALLOC1(permutation,workperm,workperm_sz,n,"testcanlab");
	DYNALLOC1(set,workset,workset_sz,m,"testcanlab");
#endif

	for (i = 0; i < n; ++i) workperm[lab[i]] = i;

	for (i = 0, ph = canong; i < n; ++i, ph += M)
	{
	    permset(GRAPHROW(g,lab[i],M),workset,M,workperm);
	    for (j = 0; j < M; ++j)
	        if (workset[j] < ph[j])
	        {
	            *samerows = i;
	            return -1;
	        }
	        else if (workset[j] > ph[j])
	        {
	            *samerows = i;
	            return 1;
	        }
	}

	*samerows = n;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movq %rcx, 0x18(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x20(%rsp)
movslq %r9d, %r13
movq 0x1b7fc(%rip), %rax     # 0x29ad0
cmpq %r13, %rax
jae 0xe315
testq %rax, %rax
je 0xe2ea
movq 0x1b7f3(%rip), %rdi     # 0x29ad8
callq 0x2280
movq %r13, 0x1b7df(%rip)     # 0x29ad0
shlq $0x2, %r13
movq %r13, %rdi
callq 0x22d0
movq %rax, 0x1b7d4(%rip)     # 0x29ad8
testq %rax, %rax
jne 0xe315
leaq 0x3640(%rip), %rdi      # 0x11950
callq 0xda1f
movslq %ebx, %r13
movq 0x1b7c1(%rip), %rax     # 0x29ae0
cmpq %r13, %rax
jae 0xe361
testq %rax, %rax
je 0xe335
movq 0x1b7b8(%rip), %rdi     # 0x29ae8
callq 0x2280
movq %r13, 0x1b7a4(%rip)     # 0x29ae0
leaq (,%r13,4), %rdi
callq 0x22d0
movq %rax, 0x1b798(%rip)     # 0x29ae8
testq %rax, %rax
jne 0xe361
leaq 0x35f4(%rip), %rdi      # 0x11950
callq 0xda1f
movq 0x1b770(%rip), %rax     # 0x29ad8
xorl %ecx, %ecx
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %rcx, %r12
je 0xe387
movslq (%r14,%rcx,4), %rdx
movl %ecx, (%rax,%rdx,4)
incq %rcx
jmp 0xe376
movl %ebp, 0xc(%rsp)
testl %r13d, %r13d
movl $0x0, %ebp
cmovgl %r13d, %ebp
leaq (,%r13,4), %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
cmpq %r12, %rbx
je 0xe41f
movslq (%r14,%rbx,4), %rax
imulq %r13, %rax
movq 0x20(%rsp), %rcx
leaq (%rcx,%rax,4), %rdi
movq 0x1b725(%rip), %rsi     # 0x29ae8
movq 0x1b70e(%rip), %rcx     # 0x29ad8
movl %r13d, %edx
callq 0xd5f5
movq 0x1b70f(%rip), %rax     # 0x29ae8
xorl %ecx, %ecx
cmpq %rcx, %rbp
je 0xe3f4
movl (%rax,%rcx,4), %edx
movl (%r15,%rcx,4), %esi
cmpl %esi, %edx
jb 0xe3fe
incq %rcx
cmpl %esi, %edx
jbe 0xe3db
jmp 0xe402
incq %rbx
addq 0x10(%rsp), %r15
jmp 0xe3a6
pushq $-0x1
jmp 0xe404
pushq $0x1
popq %rdx
movl %ebx, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %ecx
xorl %edx, %edx
jmp 0xe407