LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/network.cc
// Function: loadMass(bool, ATOM_NETWORK*)
void loadMass(bool useMassFlag, ATOM_NETWORK *atmnet){
  vector <ATOM> ::iterator iter = atmnet->atoms.begin();
  while(iter != atmnet->atoms.end()){
    if(useMassFlag)
      {
      iter->mass = lookupMass(iter->type);
      }else
      {
      iter->mass = 0.0;
      };
    iter++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xd0f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xd160
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd120
testb $0x1, %al
jne 0x97a2
jmp 0x982f
testb $0x1, -0x1(%rbp)
je 0x980a
leaq -0x18(%rbp), %rdi
callq 0xd190
movq %rax, %rsi
addq $0x40, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5220
movq -0x68(%rbp), %rdi
callq 0x46ae0
movsd %xmm0, -0x60(%rbp)
jmp 0x97d5
leaq -0x18(%rbp), %rdi
callq 0xd190
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
leaq -0x40(%rbp), %rdi
callq 0x5300
jmp 0x981b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5300
jmp 0x9835
leaq -0x18(%rbp), %rdi
callq 0xd190
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xd220
movq %rax, -0x58(%rbp)
jmp 0x9778
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x58f0
nop
// File: Luthaf[P]zeopp/networkinfo.cc
// Function: lookupRadius(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
double lookupRadius(string atomType, bool radial){

  if(stripAtomNameInternalFlag == true) atomType = stripAtomName(atomType);

  if(!radial)
    return 0.0;
  map <string,double>::iterator  info = radTable.find(atomType);
  if(info == radTable.end()){
    cerr << "Unable to find radius for " << atomType << " in table. Please provide it " << "\n"
	 << "in a reference file or check you input file." << "\n"
	 << "Exiting ..." << "\n";
    exit(1);
  }
  else
    return info->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb 0x22cfc7(%rip), %al     # 0x2736c8
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4676c
movq -0x80(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5220
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x46870
jmp 0x46731
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5680
leaq -0x38(%rbp), %rdi
callq 0x5300
leaq -0x58(%rbp), %rdi
callq 0x5300
jmp 0x4676c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5300
jmp 0x4685d
testb $0x1, -0x11(%rbp)
jne 0x4677f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4684f
movq -0x80(%rbp), %rsi
leaq 0x22ce1e(%rip), %rdi    # 0x2735a8
callq 0x47660
movq %rax, -0x70(%rbp)
leaq 0x22ce0e(%rip), %rdi    # 0x2735a8
callq 0x476c0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x47690
testb $0x1, %al
jne 0x467b9
jmp 0x4683c
movq 0x22c830(%rip), %rdi    # 0x272ff0
leaq 0x1ac146(%rip), %rsi    # 0x1f290d
callq 0x5540
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
leaq 0x1ac146(%rip), %rsi    # 0x1f2928
callq 0x5540
movq %rax, %rdi
leaq 0x1b2e34(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1ac146(%rip), %rsi    # 0x1f2946
callq 0x5540
movq %rax, %rdi
leaq 0x1b2e16(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1ac3e5(%rip), %rsi    # 0x1f2c03
callq 0x5540
movq %rax, %rdi
leaq 0x1b2df8(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
leaq -0x70(%rbp), %rdi
callq 0x476f0
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkinfo.cc
// Function: stripAtomName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string stripAtomName(std::string extAtom) {
        string atom2 = extAtom.substr(0, 2);
        string atom1 = extAtom.substr(0, 1);
        if (periodicTable.find(atom2) != periodicTable.end()) {
                return atom2;
        } else if (periodicTable.find(atom1) != periodicTable.end()) {
                return atom1;
        } else {
                return extAtom;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %ecx
callq 0x5590
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movl $0x1, %ecx
callq 0x5590
jmp 0x468d2
leaq 0x22cdbf(%rip), %rdi    # 0x273698
leaq -0x30(%rbp), %rsi
callq 0x478a0
movq %rax, -0xb0(%rbp)
jmp 0x468eb
movq -0xb0(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x22cd9b(%rip), %rdi    # 0x273698
callq 0x478e0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x47870
testb $0x1, %al
jne 0x46919
jmp 0x46960
movq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x52e0
movl $0x1, -0x74(%rbp)
jmp 0x469e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x46a02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5300
jmp 0x46a02
leaq 0x22cd31(%rip), %rdi    # 0x273698
leaq -0x50(%rbp), %rsi
callq 0x478a0
movq %rax, -0xb8(%rbp)
jmp 0x46979
movq -0xb8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x22cd0d(%rip), %rdi    # 0x273698
callq 0x478e0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x47870
testb $0x1, %al
jne 0x469ad
jmp 0x469c6
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x52e0
movl $0x1, -0x74(%rbp)
jmp 0x469e0
movq -0x98(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x52e0
movl $0x1, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5300
leaq -0x30(%rbp), %rdi
callq 0x5300
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x5300
movq -0x58(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkinfo.cc
// Function: lookupCovRadius(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double lookupCovRadius(string atomType){
  map <string,double>::iterator  info = covRadTable.find(atomType);
  if(info == covRadTable.end()){
    cerr << "Unable to find covalent radius for " << atomType << " in table. Please modify networkinfo.cc and recomplie the code " << "\n"
         << "Exiting ..." << "\n";
    exit(1);
  }
  else
   return info->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x22cb9e(%rip), %rdi    # 0x2735d8
callq 0x47660
movq %rax, -0x10(%rbp)
leaq 0x22cb8e(%rip), %rdi    # 0x2735d8
callq 0x476c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x47690
testb $0x1, %al
jne 0x46a66
jmp 0x46acb
movq 0x22c583(%rip), %rdi    # 0x272ff0
leaq 0x1abeff(%rip), %rsi    # 0x1f2973
callq 0x5540
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
leaq 0x1abf08(%rip), %rsi    # 0x1f2997
callq 0x5540
movq %rax, %rdi
leaq 0x1b2b87(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1ac156(%rip), %rsi    # 0x1f2c03
callq 0x5540
movq %rax, %rdi
leaq 0x1b2b69(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
leaq -0x10(%rbp), %rdi
callq 0x476f0
movsd 0x20(%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/networkinfo.cc
// Function: lookupMass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double lookupMass(string atomType){

  if(stripAtomNameInternalFlag == true) atomType = stripAtomName(atomType);

  map <string,double>::iterator  info = massTable.find(atomType);
  if(info == massTable.end()){
    cerr << "Unable to find molar mass for " << atomType << " in table. Please provide it " << "\n"
	 << "in a reference file or check you input file." << "\n"
	 << "Exiting ..." << "\n";
    exit(1);
  }
  else
    return info->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movb 0x22cbcf(%rip), %al     # 0x2736c8
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x46b5e
movq -0x70(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5220
movq -0x78(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x46870
jmp 0x46b23
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5680
leaq -0x28(%rbp), %rdi
callq 0x5300
leaq -0x48(%rbp), %rdi
callq 0x5300
jmp 0x46b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5300
jmp 0x46c32
movq -0x70(%rbp), %rsi
leaq 0x22ca9f(%rip), %rdi    # 0x273608
callq 0x47660
movq %rax, -0x60(%rbp)
leaq 0x22ca8f(%rip), %rdi    # 0x273608
callq 0x476c0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x47690
testb $0x1, %al
jne 0x46b98
jmp 0x46c1b
movq 0x22c451(%rip), %rdi    # 0x272ff0
leaq 0x1abe31(%rip), %rsi    # 0x1f29d7
callq 0x5540
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
leaq 0x1abd67(%rip), %rsi    # 0x1f2928
callq 0x5540
movq %rax, %rdi
leaq 0x1b2a55(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1abd67(%rip), %rsi    # 0x1f2946
callq 0x5540
movq %rax, %rdi
leaq 0x1b2a37(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1ac006(%rip), %rsi    # 0x1f2c03
callq 0x5540
movq %rax, %rdi
leaq 0x1b2a19(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
leaq -0x60(%rbp), %rdi
callq 0x476f0
movsd 0x20(%rax), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x58f0
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/networkinfo.cc
// Function: lookupAtomicNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int lookupAtomicNumber(string atomType){
  map <string,int>::iterator  info = atomicNumberTable.find(atomType);
  if(info == atomicNumberTable.end()){
    cerr << "Unable to find atomic number for " << atomType << " in table. Please provide it " << "\n"
         << "in the source code and recompile the code." << "\n"
         << "Exiting ..." << "\n";
    exit(1);
  }
  else
    return info->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x22c9de(%rip), %rdi    # 0x273638
callq 0x47710
movq %rax, -0x10(%rbp)
leaq 0x22c9ce(%rip), %rdi    # 0x273638
callq 0x47770
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x47740
testb $0x1, %al
jne 0x46c89
jmp 0x46d0c
movq 0x22c360(%rip), %rdi    # 0x272ff0
leaq 0x1abd5f(%rip), %rsi    # 0x1f29f6
callq 0x5540
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
leaq 0x1abc76(%rip), %rsi    # 0x1f2928
callq 0x5540
movq %rax, %rdi
leaq 0x1b2964(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1abd48(%rip), %rsi    # 0x1f2a18
callq 0x5540
movq %rax, %rdi
leaq 0x1b2946(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1abf15(%rip), %rsi    # 0x1f2c03
callq 0x5540
movq %rax, %rdi
leaq 0x1b2928(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
leaq -0x10(%rbp), %rdi
callq 0x477a0
movl 0x20(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/networkinfo.cc
// Function: isMetal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool isMetal(string atomType){
  map <string,bool>::iterator  info = atomicCharacterTable.find(atomType);
  if(info == atomicCharacterTable.end()){
    cerr << "Unable to find character information for " << atomType << " in table. Please modify networkinfo.cc and recomplie the code " << "\n" 
         << "Exiting ..." << "\n";
    exit(1);
  }
  else
    return info->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x22c92e(%rip), %rdi    # 0x273668
callq 0x477c0
movq %rax, -0x10(%rbp)
leaq 0x22c91e(%rip), %rdi    # 0x273668
callq 0x47820
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x477f0
testb $0x1, %al
jne 0x46d66
jmp 0x46dcb
movq 0x22c283(%rip), %rdi    # 0x272ff0
leaq 0x1abccf(%rip), %rsi    # 0x1f2a43
callq 0x5540
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
leaq 0x1abc08(%rip), %rsi    # 0x1f2997
callq 0x5540
movq %rax, %rdi
leaq 0x1b2887(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1abe56(%rip), %rsi    # 0x1f2c03
callq 0x5540
movq %rax, %rdi
leaq 0x1b2869(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
leaq -0x10(%rbp), %rdi
callq 0x47850
movb 0x20(%rax), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/networkio.cc
// Function: changeAtomType(ATOM*)
void changeAtomType(ATOM *atom){
    switch(atom->type[0]){
        case 'O': case 'o':
            atom->type = "O";
            break;
        case 'T': case 't':
            atom->type = "Si";
            break;
        case 'A': case 'a':
            atom->type = "Si";
            break;
        case 'H': case 'h':
            atom->type = "H";
            break;
        case 'S': case 's':
            if(tolower(atom->type[1]) == 'i')
                atom->type = "Si";
            else
                atom->type = "S";
            break;
        default:
            cerr<< "Error: Atom name not recognized " << atom->type << "\n";
            //	<< "Exiting..." << "\n";
            //    exit(1);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5a00
movsbl (%rax), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x33, %eax
ja 0x4ffc2
movq -0x10(%rbp), %rax
leaq 0x1a2be7(%rip), %rcx    # 0x1f2af4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1a2866(%rip), %rsi    # 0x1f278b
callq 0x5710
jmp 0x4fff4
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1a2858(%rip), %rsi    # 0x1f2796
callq 0x5710
jmp 0x4fff4
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1a283f(%rip), %rsi    # 0x1f2796
callq 0x5710
jmp 0x4fff4
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1af14c(%rip), %rsi    # 0x1ff0bc
callq 0x5710
jmp 0x4fff4
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movl $0x1, %esi
callq 0x5a00
movsbl (%rax), %edi
callq 0x5760
cmpl $0x69, %eax
jne 0x4ffac
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1a27f1(%rip), %rsi    # 0x1f2796
callq 0x5710
jmp 0x4ffc0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1acf32(%rip), %rsi    # 0x1fceed
callq 0x5710
jmp 0x4fff4
movq 0x223027(%rip), %rdi    # 0x272ff0
leaq 0x1a3a84(%rip), %rsi    # 0x1f3a54
callq 0x5540
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x40, %rsi
callq 0x5480
movq %rax, %rdi
leaq 0x1a9636(%rip), %rsi    # 0x1f9625
callq 0x5540
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/networkio.cc
// Function: readNetFile(char*, VORONOI_NETWORK*)
bool readNetFile(char * filename, VORONOI_NETWORK *vornet){
  fstream input;
  input.open(filename);
  if(!input.is_open()){
    cout<< "Failed to open .nt2 file " << filename << "\n";
    cout<<"Exiting ..." << "\n";
//    exit(1);
    return false;
  }
  else{
    readNet(&input, vornet);
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x5660
movq -0x10(%rbp), %rax
movq %rax, -0x248(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x47640
movl %eax, -0x23c(%rbp)
jmp 0x542b1
movl -0x23c(%rbp), %edx
movq -0x248(%rbp), %rsi
leaq -0x228(%rbp), %rdi
callq 0x54b0
jmp 0x542cc
leaq -0x228(%rbp), %rdi
callq 0x58b0
movb %al, -0x249(%rbp)
jmp 0x542e0
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x5439b
jmp 0x542f0
movq 0x21ecc9(%rip), %rdi    # 0x272fc0
leaq 0x19f262(%rip), %rsi    # 0x1f3560
callq 0x5540
movq %rax, -0x258(%rbp)
jmp 0x5430c
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5540
movq %rax, -0x260(%rbp)
jmp 0x54325
movq -0x260(%rbp), %rdi
leaq 0x1a52f2(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x5433a
movq 0x21ec7f(%rip), %rdi    # 0x272fc0
leaq 0x19e8bb(%rip), %rsi    # 0x1f2c03
callq 0x5540
movq %rax, -0x268(%rbp)
jmp 0x54356
movq -0x268(%rbp), %rdi
leaq 0x1a52c1(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x5436b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x238(%rbp)
jmp 0x543bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x5150
jmp 0x543d7
movq -0x18(%rbp), %rsi
leaq -0x228(%rbp), %rdi
callq 0x53e10
jmp 0x543ad
jmp 0x543af
movb $0x1, -0x1(%rbp)
movl $0x1, -0x238(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x5150
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkio.cc
// Function: get_timestamp[abi:cxx11]()
string get_timestamp()
{
    char buff[80];
    time_t rawtime;
    struct tm* timeinfo;

    time(&rawtime);
    timeinfo = localtime(&rawtime);
    strftime(buff, 80, "%F_%T", timeinfo);

    return string(buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x54c0
movq -0xa8(%rbp), %rdi
callq 0x53a0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
leaq 0x19e1bd(%rip), %rdx    # 0x1f3608
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x50, %esi
callq 0x5410
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5900
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x47530
jmp 0x5548c
leaq -0x71(%rbp), %rdi
callq 0x55d0
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x55d0
movq -0x80(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkio.cc
// Function: stripAtomNames(ATOM_NETWORK*)
void stripAtomNames(ATOM_NETWORK *cell)
{
 for(unsigned int na = 0; na < cell->atoms.size(); na++)
  cell->atoms[na].type = stripAtomName(cell->atoms[na].type);
// for (vector<ATOM>::const_iterator it=cell->atoms.begin(); it!=cell->atoms.end(); ++it){
//   it->type = stripAtomName(it->type);
//   cout << stripAtomName(it->type) << "\n";
//    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x5922e
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xfcc0
movq %rax, %rsi
addq $0x40, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5220
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x46870
jmp 0x591d2
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq -0x30(%rbp), %rsi
callq 0x5680
leaq -0x30(%rbp), %rdi
callq 0x5300
leaq -0x50(%rbp), %rdi
callq 0x5300
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x59173
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5300
jmp 0x59234
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: PATH::PATH()
PATH::PATH(){
  max_radius = max_inc_radius = length = -1;
  visitedNodes = vector<DIJKSTRA_NODE> ();
  toSink = false;
  visitedSourceIDs = set<int> ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x64310
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm3, %xmm3
movl $0x1, %edx
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x94580
jmp 0x5ceb5
movq -0x70(%rbp), %rdi
addq $0x80, %rdi
callq 0xd0d0
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
callq 0xf690
movq -0x70(%rbp), %rax
movsd 0x195897(%rip), %xmm0   # 0x1f2778
movsd %xmm0, 0x70(%rax)
movsd 0x19588a(%rip), %xmm0   # 0x1f2778
movsd %xmm0, 0x68(%rax)
movsd 0x19587d(%rip), %xmm0   # 0x1f2778
movsd %xmm0, 0x60(%rax)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x30(%rbp), %rdi
callq 0x64310
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x64330
leaq -0x30(%rbp), %rdi
callq 0x10e40
movq -0x70(%rbp), %rax
movb $0x0, 0x78(%rax)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x52a0
leaq -0x60(%rbp), %rdi
callq 0xf690
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
leaq -0x60(%rbp), %rsi
callq 0x64360
leaq -0x60(%rbp), %rdi
callq 0xf880
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x10e40
movq -0x10(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: PATH::PATH(DIJKSTRA_NODE, double, double, double)
PATH::PATH(DIJKSTRA_NODE cNode, double maxRadius, double maxIncRadius, double len){
  currentNode = cNode;
  max_radius = maxRadius;
  max_inc_radius = maxIncRadius;
  length = len;
  visitedNodes = vector<DIJKSTRA_NODE> ();
  toSink = false;
  visitedSourceIDs = set<int> ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
callq 0x64310
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x88(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm3, %xmm3
movl $0x1, %edx
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x94580
jmp 0x5d012
movq -0x98(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0xb0(%rbp)
callq 0xd0d0
movq -0x98(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xf690
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
addq $0x18, %rdi
callq 0x64390
jmp 0x5d05c
movq -0x98(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x60(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x68(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x70(%rax)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x50(%rbp), %rdi
callq 0x64310
movq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x64330
leaq -0x50(%rbp), %rdi
callq 0x10e40
movq -0x98(%rbp), %rax
movb $0x0, 0x78(%rax)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x52a0
leaq -0x80(%rbp), %rdi
callq 0xf690
movq -0x98(%rbp), %rdi
addq $0x98, %rdi
leaq -0x80(%rbp), %rsi
callq 0x64360
leaq -0x80(%rbp), %rdi
callq 0xf880
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5d13e
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xf880
movq -0xb0(%rbp), %rdi
callq 0xec80
movq -0x88(%rbp), %rdi
callq 0x100e0
movq -0x90(%rbp), %rdi
callq 0x10e40
movq -0x30(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: PATH::printPathEdges(std::vector<int, std::allocator<int>>, DIJKSTRA_NETWORK*)
void PATH::printPathEdges (vector<int> nodeList, DIJKSTRA_NETWORK *dnet){
  if(nodeList.size() < 2)
    return;
  
  unsigned int index = 0;
  int from, to;
  
  while(index < nodeList.size()-1){
    from = nodeList.at(index);
    to = nodeList.at(index+1);
    
    DIJKSTRA_NODE node = dnet->nodes.at(from);
    for(unsigned int i = 0; i < node.connections.size(); i++){
      CONN conn = node.connections.at(i);
      if(conn.to == to){
	conn.print();
      }
    }
    index++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rax
movq -0xc0(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x10090
cmpq $0x2, %rax
jae 0x5d19f
jmp 0x5d2df
movl $0x0, -0x1c(%rbp)
movq -0xb8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0xc8(%rbp)
callq 0x10090
movq %rax, %rcx
movq -0xc8(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x5d2df
movq -0xb8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x101d0
movq -0xb8(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x101d0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x10130
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x64400
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %eax
movq %rax, -0xd0(%rbp)
leaq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x2a9e0
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x5d2c8
leaq -0x50(%rbp), %rdi
movl -0x74(%rbp), %eax
movl %eax, %esi
callq 0x64470
movq %rax, -0xd8(%rbp)
jmp 0x5d261
movq -0xd8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x28, %edx
callq 0x5430
movl -0x9c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x5d2b8
movq 0x215d35(%rip), %rsi    # 0x272fc0
leaq -0xa0(%rbp), %rdi
callq 0x94480
jmp 0x5d299
jmp 0x5d2b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x100e0
jmp 0x5d2e8
jmp 0x5d2ba
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x5d224
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x100e0
jmp 0x5d1a6
addq $0xe0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: PATH::print(std::ostream&)
void PATH::print(ostream &output){
  output << "  "<< "Node lineage: ";
  for(unsigned int i=0; i<visitedNodes.size()-1; i++){
    output << "   " << visitedNodes.at(i).id << " -> ";
  }
  output << "   " << visitedNodes.back().id << "\n"
	   << "  Current node: "   << currentNode.id << "\n"
	 << "  Maximum radius: " << max_radius     << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x195165(%rip), %rsi    # 0x1f2488
callq 0x5540
movq %rax, %rdi
leaq 0x19904e(%rip), %rsi    # 0x1f6380
callq 0x5540
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x10100
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x5d3a5
movq -0x10(%rbp), %rdi
leaq 0x19511e(%rip), %rsi    # 0x1f2487
callq 0x5540
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x10130
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x196528(%rip), %rsi    # 0x1f38bd
callq 0x5540
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5d33e
movq -0x10(%rbp), %rdi
leaq 0x1950d7(%rip), %rsi    # 0x1f2487
callq 0x5540
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x29cb0
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x19c24e(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x198fa9(%rip), %rsi    # 0x1f638f
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x19c221(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x198f8d(%rip), %rsi    # 0x1f63a0
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x60(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x19c1f2(%rip), %rsi    # 0x1f9625
callq 0x5540
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: TRAVERSAL_NETWORK::TRAVERSAL_NETWORK(int, int, int, std::vector<int, std::allocator<int>>, std::vector<std::vector<CONN, std::allocator<CONN>>, std::allocator<std::vector<CONN, std::allocator<CONN>>>>, std::vector<std::vector<CONN, std::allocator<CONN>>, std::allocator<std::vector<CONN, std::allocator<CONN>>>>, std::vector<std::vector<CONN, std::allocator<CONN>>, std::allocator<std::vector<CONN, std::allocator<CONN>>>>, DIJKSTRA_NETWORK*)
TRAVERSAL_NETWORK::TRAVERSAL_NETWORK(int dx, int dy, int dz, vector<int> srcIDs, vector< vector<CONN> > regConns, 
				     vector< vector<CONN> > srcConns, vector< vector<CONN> > sinkConns, DIJKSTRA_NETWORK * dnetwork){
  sourceNodeIDs = srcIDs;
  regConnections = regConns;
  connectToSource = srcConns;
  connectToSink = sinkConns;
  direction = DELTA_POS(dx,dy,dz);
  dnet = dnetwork;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %r9, -0x88(%rbp)
movq %r8, -0x80(%rbp)
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0xd0d0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x60(%rbp)
callq 0x644b0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x58(%rbp)
callq 0x644b0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x50(%rbp)
callq 0x644b0
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x94010
jmp 0x5d50b
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x17a10
jmp 0x5d51a
movq -0x88(%rbp), %rsi
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
callq 0x644d0
jmp 0x5d530
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
callq 0x644d0
jmp 0x5d543
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
addq $0x48, %rdi
callq 0x644d0
jmp 0x5d556
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq -0x40(%rbp), %rdi
callq 0x94010
jmp 0x5d56a
movq -0x68(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl -0x38(%rbp), %ecx
movl %ecx, 0x68(%rax)
movq 0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x110b0
movq -0x58(%rbp), %rdi
callq 0x110b0
movq -0x60(%rbp), %rdi
callq 0x110b0
movq -0x48(%rbp), %rdi
callq 0xec80
movq -0x30(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: findMaxIncludedSphere(VORONOI_NETWORK*)
double findMaxIncludedSphere(VORONOI_NETWORK *vornet){
  double max = 0;
  vector<VOR_NODE> ::iterator iter = vornet->nodes.begin();
  while(iter != vornet->nodes.end()){
      if(iter->rad_stat_sphere > max)
	max = iter->rad_stat_sphere;
      iter++;
  }
  return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x25230
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x250b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x599b0
testb $0x1, %al
jne 0x5fe09
jmp 0x5fe42
leaq -0x18(%rbp), %rdi
callq 0x599f0
movsd 0x18(%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x5fe31
leaq -0x18(%rbp), %rdi
callq 0x599f0
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x59a10
movq %rax, -0x28(%rbp)
jmp 0x5fde5
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: CAGE::getNodeOffset(int)
DELTA_POS CAGE::getNodeOffset(int nodeID){
  map<int,int>::iterator iter = nodeIndices.find(nodeID);
  if(iter == nodeIndices.end()){
    cerr << "Error: Node #" << nodeID << " not found in cage." << "\n"
	 << "Exiting..." << "\n";
    exit(1);
  }
  else
    return nodeOffsets[iter->second];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x102e0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x658c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25e10
testb $0x1, %al
jne 0x61da4
jmp 0x61e08
movq 0x211245(%rip), %rdi    # 0x272ff0
leaq 0x1946e8(%rip), %rsi    # 0x1f649a
callq 0x5540
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x1946dc(%rip), %rsi    # 0x1f64a8
callq 0x5540
movq %rax, %rdi
leaq 0x19784a(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x199530(%rip), %rsi    # 0x1fb31a
callq 0x5540
movq %rax, %rdi
leaq 0x19782c(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x1, %edi
callq 0x67c0
movq -0x48(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10350
movq -0x50(%rbp), %rdi
movslq 0x4(%rax), %rsi
callq 0x658f0
movl 0x8(%rax), %ecx
movl %ecx, -0x8(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %edx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkanalysis.cc
// Function: CAGE::writeToVMD(int, std::basic_fstream<char, std::char_traits<char>>&)
void CAGE::writeToVMD(int cageIndex, fstream &output){
  output << "set cages(" << cageIndex << ") {" << "\n"
	 << "{color $cageColors(" << cageIndex << ")}" << "\n"
	 << "{sphere {" << cx << " " << cy << " " << cz << "} radius " << radius << " resolution 100 }" << "\n"
	 <<"}" << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
leaq 0x1945a2(%rip), %rsi    # 0x1f64bc
callq 0x5540
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x199161(%rip), %rsi    # 0x1fb095
callq 0x5540
movq %rax, %rdi
leaq 0x1976e2(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x194575(%rip), %rsi    # 0x1f64c7
callq 0x5540
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x199145(%rip), %rsi    # 0x1fb0b1
callq 0x5540
movq %rax, %rdi
leaq 0x1976aa(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x194551(%rip), %rsi    # 0x1f64db
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x60(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x19a304(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x68(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x19a2e4(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x70(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x1944fb(%rip), %rsi    # 0x1f64e5
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x78(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x1944e5(%rip), %rsi    # 0x1f64ef
callq 0x5540
movq %rax, %rdi
leaq 0x19760c(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x198fd3(%rip), %rsi    # 0x1faffb
callq 0x5540
movq %rax, %rdi
leaq 0x1975ee(%rip), %rsi    # 0x1f9625
callq 0x5540
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/./heap.h
// Function: HEAP<PATH>::pop()
T pop(){
    std::pop_heap(elements.begin(), elements.end(), comparator);
    T most = elements.back();
    elements.pop_back();
    return most;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6b970
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x6b9a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6ca80
movq -0x30(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x6caf0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x64d10
movq -0x30(%rbp), %rdi
callq 0x6cb30
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x64ea6
movq -0x38(%rbp), %rdi
callq 0x10df0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/area_and_volume.cc
// Function: calcDensity(ATOM_NETWORK*)
double calcDensity(ATOM_NETWORK *atmnet){
  double volume = calcDeterminant(atmnet->ucVectors); // Units of A^3
  vector<ATOM>::iterator iter = atmnet->atoms.begin();
  double massSum = 0;
  while(iter != atmnet->atoms.end()){
    massSum += iter->mass; 
    iter++;
  }
  return  massSum/(AVOGRADOS_NUMBER*volume)*1.0e24; // Units of g/cm^3
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
callq 0xe9390
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xd0f0
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xd160
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd120
testb $0x1, %al
jne 0x74fc4
jmp 0x74fed
leaq -0x18(%rbp), %rdi
callq 0xd190
movsd 0x38(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xd220
movq %rax, -0x30(%rbp)
jmp 0x74f9d
movsd -0x20(%rbp), %xmm0
movsd 0x181606(%rip), %xmm1   # 0x1f6600
mulsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x1815ed(%rip), %xmm1   # 0x1f65f8
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/area_and_volume.cc
// Function: reportResampledPoints(std::ostream&, std::vector<std::pair<int, Point>, std::allocator<std::pair<int, Point>>>)
void reportResampledPoints(ostream &output, vector< pair<int, Point> > resampledInfo){
  output << "set num_resamples " << resampledInfo.size() << "\n";
   for(unsigned int i = 0; i < resampledInfo.size(); i++){
    Point coords = resampledInfo[i].second;
    output << "set rpoints(" << i << ") {" <<  coords[0] << " " << coords[1] << " " << coords[2] << "} " << "\n";
    output << "set rcenters(" << i << ") " << resampledInfo[i].first << "\n"; 
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1806d9(%rip), %rsi    # 0x1f66e8
callq 0x5540
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x84600
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, %rdi
leaq 0x1835ee(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x84600
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x761ad
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x84620
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x180667(%rip), %rsi    # 0x1f66fb
callq 0x5540
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x56f0
movq %rax, %rdi
leaq 0x184fe7(%rip), %rsi    # 0x1fb095
callq 0x5540
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xe9d70
movq -0x68(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x1861d5(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xe9d70
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x1861a7(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0xe9d70
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x18047b(%rip), %rsi    # 0x1f65b0
callq 0x5540
movq %rax, %rdi
leaq 0x1834e1(%rip), %rsi    # 0x1f9625
callq 0x5540
movq -0x8(%rbp), %rdi
leaq 0x1805b4(%rip), %rsi    # 0x1f6708
callq 0x5540
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x56f0
movq %rax, %rdi
leaq 0x185862(%rip), %rsi    # 0x1fb9d0
callq 0x5540
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x84620
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x18348b(%rip), %rsi    # 0x1f9625
callq 0x5540
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x76043
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/area_and_volume.cc
// Function: reportPointsVisIT(std::ostream&, std::vector<Point, std::allocator<Point>>, std::vector<Point, std::allocator<Point>>)
void reportPointsVisIT(ostream &output, vector<Point> axsPoints, vector<Point> inaxsPoints){
  for(unsigned int i = 0; i < axsPoints.size(); i++){
    Point coords = axsPoints.at(i);
    output << coords[0] << " " << coords[1] << " " << coords[2] << " 1 a" << "\n";
   }
  for(unsigned int i = 0; i < inaxsPoints.size(); i++){
    Point coords = inaxsPoints.at(i);
    output <<  coords[0] << " " << coords[1] << " " << coords[2] << " 0 n" << "\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x68(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x70(%rbp)
callq 0x17c60
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x762d9
movq -0x68(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x59c60
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xe9d70
movq -0x88(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x186053(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0xe9d70
movq -0x80(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x186025(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0xe9d70
movq -0x78(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x18045f(%rip), %rsi    # 0x1f6716
callq 0x5540
movq %rax, %rdi
leaq 0x18335f(%rip), %rsi    # 0x1f9625
callq 0x5540
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x761e6
movl $0x0, -0x3c(%rbp)
movq -0x60(%rbp), %rdi
movl -0x3c(%rbp), %eax
movq %rax, -0x90(%rbp)
callq 0x17c60
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x763e5
movq -0x60(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x59c60
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0xe9d70
movq -0xa8(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x185f53(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0xa0(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0xe9d70
movq -0xa0(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x185f1f(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0x98(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0xe9d70
movq -0x98(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x180358(%rip), %rsi    # 0x1f671b
callq 0x5540
movq %rax, %rdi
leaq 0x183253(%rip), %rsi    # 0x1f9625
callq 0x5540
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x762e0
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/area_and_volume.cc
// Function: calcAV[abi:cxx11](ATOM_NETWORK*, ATOM_NETWORK*, bool, double, double, int, bool, double, double)
string calcAV(ATOM_NETWORK *atmnet, ATOM_NETWORK *orgatmnet, bool highAccuracy, double r_probe_chan, double r_probe, int numSamples, bool excludePockets,  double low_dist_cutoff, double high_dist_cutoff)
{
    stringstream output;
    string filename = "No filename";
    double vol = calcAV(atmnet, orgatmnet, highAccuracy, r_probe_chan, r_probe, numSamples, excludePockets, output, (char *)filename.data(), false, false, false, false, low_dist_cutoff, high_dist_cutoff, false);
    return output.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x228(%rbp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
andb $0x1, %al
movb %al, -0x35(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm3, -0x48(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x5370
leaq -0x1f1(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x5900
movq -0x218(%rbp), %rdx
leaq 0x1732e4(%rip), %rsi    # 0x1f708f
leaq -0x1f0(%rbp), %rdi
callq 0x47530
jmp 0x83db9
leaq -0x1f1(%rbp), %rdi
callq 0x55d0
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x258(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x250(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x248(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x23c(%rbp)
leaq -0x1c0(%rbp), %rax
movq %rax, -0x238(%rbp)
movzbl -0x35(%rbp), %eax
movl %eax, -0x264(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x268(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x52c0
movl -0x268(%rbp), %edx
movl -0x264(%rbp), %r8d
movq -0x260(%rbp), %rdi
movq -0x258(%rbp), %rsi
movsd -0x250(%rbp), %xmm0
movsd -0x248(%rbp), %xmm1
movl -0x23c(%rbp), %ecx
movq -0x238(%rbp), %r9
movq %rax, %r10
movsd -0x40(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
movq %rsp, %rax
movq %r10, (%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
andl $0x1, %edx
andl $0x1, %r8d
callq 0x767b0
movsd %xmm0, -0x230(%rbp)
jmp 0x83eb0
movq -0x228(%rbp), %rdi
movsd -0x230(%rbp), %xmm0
movsd %xmm0, -0x210(%rbp)
leaq -0x1d0(%rbp), %rsi
callq 0x5530
jmp 0x83ed5
leaq -0x1f0(%rbp), %rdi
callq 0x5300
leaq -0x1d0(%rbp), %rdi
callq 0x53c0
movq -0x220(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
leaq -0x1f1(%rbp), %rdi
callq 0x55d0
jmp 0x83f3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x200(%rbp)
movl %eax, -0x204(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x5300
leaq -0x1d0(%rbp), %rdi
callq 0x53c0
movq -0x200(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/./networkaccessibility.h
// Function: AccessibilityClass::lastChannelOrPocket()
std::pair <int,int> lastChannelOrPocket()
    {
        if(channelMapping[tempNodeID]<0 && pocketMapping[tempNodeID]<0){
            std::cerr << "CoP_error: cannot determine point accessiblity. Consider running at higher accuracy (-ha flag).(minDist=" << tempMinDist << ")." << std::endl;
            std::cerr << "NodeID= " << tempNodeID << "  minDistAtomID= " << tempMinDistAtomID << " resampleFlag= " << needToResampleFlag << std::endl;
            abort();
        }
        return std::pair <int,int> (channelMapping[tempNodeID],pocketMapping[tempNodeID]);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, %rdi
addq $0x9b8, %rdi            # imm = 0x9B8
movslq 0xa1c(%rax), %rsi
callq 0xed60
cmpl $0x0, (%rax)
jge 0x8495b
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x9d0, %rdi            # imm = 0x9D0
movslq 0xa1c(%rax), %rsi
callq 0xed60
cmpl $0x0, (%rax)
jge 0x8495b
movq 0x1ee753(%rip), %rdi    # 0x272ff0
leaq 0x1729b6(%rip), %rsi    # 0x1f725a
callq 0x5540
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsd 0x9f8(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x1772fa(%rip), %rsi    # 0x1fbbc1
callq 0x5540
movq %rax, %rdi
movq 0x1ee6c2(%rip), %rsi    # 0x272f98
callq 0x55b0
movq 0x1ee70e(%rip), %rdi    # 0x272ff0
leaq 0x1729da(%rip), %rsi    # 0x1f72c3
callq 0x5540
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xa1c(%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x1729c2(%rip), %rsi    # 0x1f72cc
callq 0x5540
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xa18(%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x1729b3(%rip), %rsi    # 0x1f72de
callq 0x5540
movq %rax, %rdi
movq -0x18(%rbp), %rax
movb 0xa3c(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x5920
movq %rax, %rdi
movq 0x1ee647(%rip), %rsi    # 0x272f98
callq 0x55b0
callq 0x52b0
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x9b8, %rdi            # imm = 0x9B8
movslq 0xa1c(%rax), %rsi
callq 0xed60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rax, %rdi
addq $0x9d0, %rdi            # imm = 0x9D0
movslq 0xa1c(%rax), %rsi
callq 0xed60
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq -0x8(%rbp), %rdi
callq 0xf590
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq