LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::printRefSASAVec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CASA::printRefSASAVec(const std::string &key){    
    std::stringstream s;
    s.str("");
    for (unsigned int i=0; i< this->aminoAcids.size(); i++){
    	if (this->aminoAcids.at(i) == key){
    		 s << this->refSASA.at(key) << " ";
    	}
    	else {
    		s << "0.0 ";
    	}
    }
    return(s.str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4210
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1caef(%rip), %rdx     # 0x3c4b6
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6516
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4430
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f9fe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x1faad
leaq 0x40(%rsp), %r13
leaq 0x18(%r15), %rcx
movq %rcx, 0x8(%rsp)
movl $0x1, %ebx
xorl %ecx, %ecx
leaq 0x1cb4b(%rip), %rbp     # 0x3c572
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdx
movl $0x4, %r12d
cmpq 0x8(%r14), %rdx
jne 0x1fa84
testq %rdx, %rdx
je 0x1fa59
addq %rcx, %rax
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42f0
movq %r13, %rdi
movq %rbp, %rsi
testl %eax, %eax
jne 0x1fa8a
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1fda6
movsd (%rax), %xmm0
movq %r13, %rdi
callq 0x44a0
movq %rax, %rdi
movl $0x1, %r12d
leaq 0x1dc1e(%rip), %rsi     # 0x3d6a0
jmp 0x1fa8a
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4340
movl %ebx, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebx
cmpq %rcx, %rdx
ja 0x1fa27
movq (%rsp), %rbx
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x4480
movq 0x3d14e3(%rip), %rsi    # 0x3f0fa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fb11
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1fb14
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x1fb14
jmp 0x1fb11
movq %rax, %rbx
movq 0x3d148d(%rip), %rsi    # 0x3f0fa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::printRefSASAVecHeader[abi:cxx11]()
std::string CASA::printRefSASAVecHeader(){    
	std::stringstream s;
	s.str("");
	for (unsigned int i=0; i< this->aminoAcids.size(); i++){
		s << "RefSASA_" << aminoAcids.at(i) << " ";
	}
	return(s.str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4210
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c949(%rip), %rdx     # 0x3c4b6
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6516
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4430
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fba0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x1fc21
movl $0x1, %ebx
leaq 0x40(%rsp), %r12
xorl %r15d, %r15d
leaq 0x1d76c(%rip), %r13     # 0x3d329
leaq 0x1dadc(%rip), %rbp     # 0x3d6a0
movl $0x8, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x4340
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x1fc66
shlq $0x5, %r15
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
movq %r12, %rdi
callq 0x4340
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4340
movq 0x8(%r14), %rax
subq (%r14), %rax
movl %ebx, %r15d
sarq $0x5, %rax
incl %ebx
cmpq %r15, %rax
ja 0x1fbc4
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x4480
movq 0x3d136e(%rip), %rsi    # 0x3f0fa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c6bc(%rip), %rdi     # 0x3c329
movq %r15, %rsi
xorl %eax, %eax
callq 0x4440
jmp 0x1fc99
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fc9c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x1fc9c
jmp 0x1fc99
jmp 0x1fc99
movq %rax, %rbx
movq 0x3d1305(%rip), %rsi    # 0x3f0fa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getSASACoef(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getSASACoef(const std::string &key){
    if (this->sasaCoef.find (key) == this->sasaCoef.end()){
        return 0.0;
    } else {
        return (this->sasaCoef.at(key));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x2045c
addq $0x50, %r15
cmpq %r15, %rax
je 0x1fcf3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fda6
movsd (%rax), %xmm0
jmp 0x1fcf6
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getHist(const std::string &key){
    if (this->hist.find (key) == this->hist.end()){
        return 0.0;
    } else {
        return (this->hist.at(key));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x78(%rdi), %r14
movq %r14, %rdi
callq 0x2045c
subq $-0x80, %r15
cmpq %r15, %rax
je 0x1fd2d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fda6
movsd (%rax), %xmm0
jmp 0x1fd30
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getTargetSASA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getTargetSASA(const std::string &key){
    if (this->targetSASA.find (key) == this->targetSASA.end()){
        return 0.0;
    } else {
        return (this->targetSASA.at(key));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xa8(%rdi), %r14
movq %r14, %rdi
callq 0x2045c
addq $0xb0, %r15
cmpq %r15, %rax
je 0x1fd6d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fda6
movsd (%rax), %xmm0
jmp 0x1fd70
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::getAtom(unsigned int const&)
Atom* Chain::getAtom (const unsigned int& element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

// Assembly:
movl (%rsi), %eax
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x20607
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::getResidue(unsigned int const&)
Residue* Chain::getResidue (const unsigned int& element){
  if (element >= resVec.size()){
    return NULL;
  }
  else{
    return resVec.at(element);
  }
}

// Assembly:
movl (%rsi), %eax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x20624
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::delDTree(DTreeNode*)
void DTree::delDTree(DTreeNode *node){
  if (node != NULL){
    delDTree(node->left);
    delDTree(node->right);
    delete node;
  }
}

// Assembly:
testq %rsi, %rsi
je 0x208e2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x20892
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x20892
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x208ce
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x40, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42e0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::addDTree(double, DTreeNode*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DTree::addDTree(double key, DTreeNode *node, unsigned int index, std::string classin){
  if (node->left != NULL){
    addDTree(key, node->left, index, classin);
  }
  else{
    node->left=new DTreeNode;
    node->left->key_value=key;
    node->left->inx=index;
    node->left->left=NULL; //Sets left child of child node to NULL
    node->left->right=NULL; //Sets right child of child node to NULL
    node->left->leaf=classin; //The class of this node node
  }
  if (node->right != NULL){
    addDTree(key, node->right, index, classin);
  }
  else{
    node->right=new DTreeNode;
    node->right->key_value=key;
    node->right->inx=index;
    node->right->left=NULL; //Sets left child of child node to NULL
    node->right->right=NULL; //Sets right child of child node to NULL
    node->right->leaf=classin; //The class of this node node
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r12
movsd %xmm0, (%rsp)
movq %rdi, %rbp
movq 0x10(%rsi), %r13
testq %r13, %r13
je 0x20964
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x6486
movl %ebx, %edx
movq %rbp, %rbx
movq %rbp, %rdi
movsd (%rsp), %xmm0
movq %r13, %rsi
movl %edx, %r13d
leaq 0x8(%rsp), %rcx
callq 0x208e4
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
movq %rbx, %rbp
movl %r13d, %ebx
je 0x209a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x209a6
movl $0x40, %edi
callq 0x42d0
leaq 0x20(%rax), %rdi
leaq 0x30(%rax), %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movq %rax, 0x10(%r12)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, %rsi
callq 0x4180
movq 0x18(%r12), %r13
testq %r13, %r13
je 0x209fe
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6486
movq %rbp, %rdi
movsd (%rsp), %xmm0
movq %r13, %rsi
movl %ebx, %edx
movq %r14, %rcx
callq 0x208e4
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x20a40
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x20a40
movl $0x40, %edi
callq 0x42d0
leaq 0x20(%rax), %rdi
leaq 0x30(%rax), %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movq %rax, 0x18(%r12)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, %rsi
callq 0x4180
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x20a61
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x20a71
movq (%r15), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::getDTreeClass[abi:cxx11](DTreeNode*, std::vector<double, std::allocator<double>> const&)
std::string DTree::getDTreeClass(DTreeNode *node, const std::vector<double> &fin){
  if (node->left == NULL && node->right == NULL){
    //Return class
    if (this->getClassSize() != 0){
      return this->getClass(node->leaf);
    }
    else{
      return node->leaf;
    }
  }
  else if (node->left == NULL || node->right == NULL){
    if (node->left != NULL){
      //Go deeper
      return getDTreeClass(node->left, fin);
    }
    else{
      //Go deeper
      return getDTreeClass(node->right, fin);
    }
  }
  else{
    if (node->inx >= fin.size()){
      std::cerr << "Error: Missing feature (inx = " << node->inx << " )" << std::endl;
      return "";
    }
    else if (fin.at(node->inx) <= node->key_value){
      //Go deeper
      return getDTreeClass(node->left, fin);
    }
    else{
      //Go deeper
      return getDTreeClass(node->right, fin);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x20ee1
cmpq $0x0, 0x18(%r15)
je 0x20fa0
testq %rdx, %rdx
je 0x20f1a
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x20f15
movl 0x8(%r15), %esi
movq (%rcx), %rdi
movq 0x8(%rcx), %r8
subq %rdi, %r8
sarq $0x3, %r8
cmpq %rsi, %r8
jbe 0x20f20
movsd (%r15), %xmm0
ucomisd (%rdi,%rsi,8), %xmm0
jb 0x20f10
movq %rdx, %rax
movq %rax, %rdx
jmp 0x20ec5
testq %rdx, %rdx
jne 0x20ec5
movq 0x18(%r15), %rdx
jmp 0x20ec5
movq 0x3d00c9(%rip), %r14    # 0x3f0ff0
leaq 0x1c448(%rip), %rsi     # 0x3d376
movl $0x1e, %edx
movq %r14, %rdi
callq 0x4340
movl 0x8(%r15), %esi
movq %r14, %rdi
callq 0x41e0
movq %rax, %r14
leaq 0x1c444(%rip), %rsi     # 0x3d395
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b523(%rip), %rdx     # 0x3c4b6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6516
jmp 0x2100a
cmpl $0x0, 0x30(%r14)
je 0x20ff0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6486
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21040
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2100a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x2100a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6486
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x21033
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::getClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string DTree::getClass(std::string valin){
  if (classMap.find(valin) != classMap.end()){
    return classMap.at(valin);
  }
  else{
    std::cerr << "Error: Unrecognized class mapping \"" << valin << "\"" << std::endl;
    return "";
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x21aaa
addq $0x10, %r12
cmpq %r12, %rax
je 0x21092
movq %r15, %rdi
movq %r14, %rsi
callq 0x21766
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6486
jmp 0x21113
movq 0x3cff57(%rip), %r15    # 0x3f0ff0
leaq 0x1c2fa(%rip), %rsi     # 0x3d39a
movl $0x23, %edx
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4340
movq %rax, %r14
leaq 0x1c3ea(%rip), %rsi     # 0x3d4b0
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b3ae(%rip), %rdx     # 0x3c4b6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6516
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::addDTree(double, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DTree::addDTree(double key, unsigned int index, std::string classin){
  //Public version of the addDTree function
  //Takes care of when the root node has not been initialized
  if (root != NULL){
    addDTree(key, root, index, classin);
  }
  else{
    root=new DTreeNode;
    root->key_value=key;
    root->inx=index;
    root->left=NULL;
    root->right=NULL;
    root->leaf=classin;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
movq (%rdi), %r12
testq %r12, %r12
je 0x211a0
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x6486
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %r12, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0x208e4
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x21192
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x40, %edi
callq 0x42d0
leaq 0x20(%rax), %rdi
leaq 0x30(%rax), %rcx
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movq %rax, (%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, %rsi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4180
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x21208
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::getDTreeClass[abi:cxx11](std::vector<double, std::allocator<double>> const&)
std::string DTree::getDTreeClass(const std::vector<double> &fin){
  //Public version of the getDTreeClass function
  if (root != NULL){
    return getDTreeClass(root, fin);
  }
  else{
    return "?"; 
  }
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x21621
movq %rbx, %rdi
callq 0x20eb4
jmp 0x2163e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1bd69(%rip), %rsi     # 0x3d398
leaq 0x1bd63(%rip), %rdx     # 0x3d399
movq %rbx, %rdi
callq 0x6516
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
std::string Misc::replace (const std::string &str, const std::string searchStr, const std::string replaceStr, const bool globalFlag){
  std::string out;

  out=str;
  for (std::string::size_type pos=0; (pos=out.find(searchStr, pos)) != std::string::npos;){
    out.replace(pos, searchStr.length(), replaceStr);
    pos += replaceStr.length()-searchStr.length()+1;
    if (globalFlag == false){
      break;
    }
  }

  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x4180
xorl %r12d, %r12d
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4520
cmpq $-0x1, %rax
je 0x21d5b
movq %rax, %r12
movq 0x8(%r15), %rdx
movq (%r14), %rcx
movq 0x8(%r14), %r8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4320
addq 0x8(%r14), %r12
subq 0x8(%r15), %r12
incq %r12
testb %bpl, %bpl
jne 0x21d1a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21d6f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x21d86
movq (%r13), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::isdouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Misc::isdouble (const std::string &str){
  unsigned int nDecimals=0; 
  unsigned int negPos=0;

  for (unsigned int i=0; i< str.size(); i++){
    switch (str[i]){
      case '-': negPos=i;
        continue;
      case '.': nDecimals++;
        continue;
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        continue;
      default:
        return false;
    }
  }
  if (nDecimals > 1 || negPos != 0){
    return false;
  }
  return true;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x21e02
movq (%rdi), %rcx
xorl %r8d, %r8d
movl $0x1, %edx
xorl %edi, %edi
xorl %esi, %esi
movzbl (%rcx,%r8), %r8d
leal -0x30(%r8), %r9d
cmpl $0xa, %r9d
jae 0x21ddf
movl %edx, %r8d
incl %edx
cmpq %r8, %rax
ja 0x21dc4
jmp 0x21df4
cmpl $0x2e, %r8d
je 0x21df0
cmpl $0x2d, %r8d
jne 0x21e05
leal -0x1(%rdx), %edi
jmp 0x21dd3
incl %esi
jmp 0x21dd3
cmpl $0x2, %esi
setb %cl
testl %edi, %edi
sete %al
andb %cl, %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::isrange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Misc::isrange (const std::string &str){

  if (str.find_first_not_of("0123456789-") != std::string::npos){
    return false;
  }
  if (str.find("-") == std::string::npos){
    return false;
  }
  if (str.find_first_not_of("-") != 0 || str.find_last_not_of("-") < str.find("-")){
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1b5a9(%rip), %rsi     # 0x3d430
xorl %r14d, %r14d
movl $0xb, %ecx
xorl %edx, %edx
callq 0x44e0
cmpq $-0x1, %rax
je 0x21ea5
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b58e(%rip), %rsi     # 0x3d43a
xorl %r14d, %r14d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4520
cmpq $-0x1, %rax
je 0x21e9c
leaq 0x1b56f(%rip), %rsi     # 0x3d43a
xorl %r14d, %r14d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x44e0
testq %rax, %rax
jne 0x21e9c
leaq 0x1b551(%rip), %r14     # 0x3d43a
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
callq 0x44b0
movq %rax, %r15
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4520
cmpq %rax, %r15
setae %r14b
jmp 0x21e9c
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Misc::trim (const std::string &str, const std::string t){
  std::string out=str;

  size_t pos = out.find_last_not_of(t);
  if (pos != std::string::npos){
    if (out.length() != pos+1){
      out.erase(pos+1);
    }
    pos=out.find_first_not_of(t);
    if (pos != 0){
      out.erase(0, pos);
    }
  }
  else{
    out="";
  }

  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x6486
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x44b0
movq 0x8(%rbx), %r8
cmpq $-0x1, %rax
je 0x21fa4
leaq 0x1(%rax), %rdx
cmpq %rdx, %r8
je 0x21f7f
cmpq %rax, %r8
jbe 0x21fc4
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x44e0
testq %rax, %rax
je 0x21fbb
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40a0
jmp 0x21fbb
leaq 0x1a50b(%rip), %rcx     # 0x3c4b6
movq %rbx, %rdi
xorl %esi, %esi
movq %r8, %rdx
xorl %r8d, %r8d
callq 0x4470
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b471(%rip), %rdi     # 0x3d43c
leaq 0x1b4a1(%rip), %rsi     # 0x3d473
movq %r8, %rcx
xorl %eax, %eax
callq 0x4440
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x21ff2
movq (%r15), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::processRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Misc::processRange (const std::string &start, const std::string &end){
  std::stringstream ss;
  int i, istart, iend;
  
  std::stringstream(start) >> istart;
  std::stringstream(end) >> iend;

  ss << istart;
  istart++;

  for (i=istart; i<=iend; i++){
    ss << "+" << i;
  }

  return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x318, %rsp            # imm = 0x318
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4210
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x4490
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x41b0
movq 0x3cef64(%rip), %rsi    # 0x3f0fa8
leaq 0x8(%rsp), %rdi
callq 0x4240
leaq 0x88(%rsp), %rdi
callq 0x4110
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x18, %edx
callq 0x4490
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x41b0
movq 0x3cef25(%rip), %rsi    # 0x3f0fa8
leaq 0x8(%rsp), %rdi
callq 0x4240
leaq 0x88(%rsp), %rdi
callq 0x4110
leaq 0x1a0(%rsp), %r14
movl (%rsp), %esi
movq %r14, %rdi
callq 0x4500
movl (%rsp), %r15d
leal 0x1(%r15), %eax
movl %eax, (%rsp)
cmpl 0x4(%rsp), %r15d
jge 0x220eb
leaq 0x1a593(%rip), %r12     # 0x3c659
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4340
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x4500
cmpl 0x4(%rsp), %r15d
jl 0x220c6
leaq 0x1a8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4480
movq 0x3ceea6(%rip), %rsi    # 0x3f0fa8
leaq 0x190(%rsp), %rdi
callq 0x4240
leaq 0x210(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x22132
jmp 0x22159
movq %rax, %rbx
movq 0x3cee6c(%rip), %rsi    # 0x3f0fa8
leaq 0x8(%rsp), %rdi
callq 0x4240
leaq 0x88(%rsp), %rdi
callq 0x4110
jmp 0x2215c
jmp 0x22159
jmp 0x22159
movq %rax, %rbx
movq 0x3cee45(%rip), %rsi    # 0x3f0fa8
leaq 0x190(%rsp), %rdi
callq 0x4240
leaq 0x210(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::atoi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int)
int Misc::atoi (std::string &str, const unsigned int offset){
  int val;
  const char *a;
  val=0;

  if (Misc::isalpha(str.substr(offset, 1))){
    a=str.substr(offset,1).c_str();
    val=static_cast<int>(a[0]-'A')+1; //A = 1, B = 2, etc
  }
  return val;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl %esi, %ebx
movq %rsp, %r13
movl $0x1, %ecx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4300
leaq 0x1b196(%rip), %rsi     # 0x3d3fb
xorl %r15d, %r15d
movl $0x34, %ecx
movq %r13, %rdi
xorl %edx, %edx
callq 0x44e0
movq %rax, %r12
movq (%r13), %rdi
leaq 0x10(%rsp), %r13
cmpq %r13, %rdi
je 0x22295
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $-0x1, %r12
jne 0x222d1
movq %rsp, %r15
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4300
movq (%r15), %rbx
cmpq %r13, %rbx
je 0x222c9
movq 0x10(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x42e0
movsbl (%rbx), %r15d
addl $-0x40, %r15d
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::hypot(double const&, double const&)
double Misc::hypot (const double &a, const double &b){
  if (a !=0){
    return a*sqrt(1+(b/a)*(b/a));
  }
  else if (b !=0){
    return b*sqrt(1+(a/b)*(a/b));
  }
  else{
    return 0.0;
  }
}

// Assembly:
movsd (%rdi), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movsd (%rsi), %xmm1
jne 0x222f6
jnp 0x2230c
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd 0x1a14a(%rip), %xmm1    # 0x3c450
movapd %xmm1, %xmm0
jmp 0x2232c
ucomisd %xmm0, %xmm1
jne 0x22314
jnp 0x22358
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd 0x1a12c(%rip), %xmm2    # 0x3c450
movapd %xmm2, %xmm0
movapd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2233c
sqrtsd %xmm0, %xmm0
jmp 0x22350
pushq %rax
movsd %xmm2, (%rsp)
callq 0x4260
movsd (%rsp), %xmm2
addq $0x8, %rsp
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::Molecule()
Molecule::Molecule (){
  chnVec.clear();
  resVec.clear();
  atmVec.clear();
  copyFlag=false;
  storedSel.clear();
  remarks.clear();
  iCodeFlag=false;
  year=0;
  exp.clear();
  tag.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3cd71d(%rip), %rax    # 0x3f0d30
movq %rax, (%rdi)
leaq 0x8(%rdi), %r12
leaq 0x58(%rdi), %r14
leaq 0x60(%rdi), %rax
movl $0x0, 0x60(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x68(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movq %rcx, 0x80(%rdi)
leaq 0x98(%rdi), %r13
movq %r13, 0x88(%rdi)
movq %rcx, 0x90(%rdi)
movb $0x0, 0x98(%rdi)
addq $0xb0, %rdi
callq 0x2d084
leaq 0x170(%rbx), %rax
movq %rax, 0x160(%rbx)
xorl %eax, %eax
movq %rax, 0x168(%rbx)
movb %al, 0x170(%rbx)
leaq 0x190(%rbx), %rcx
movq %rcx, 0x180(%rbx)
movq %rax, 0x188(%rbx)
movb %al, 0x190(%rbx)
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x236c3
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x236d1
movq %rax, 0x28(%rbx)
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x236df
movq %rax, 0x40(%rbx)
xorl %r15d, %r15d
movb %r15b, 0x50(%rbx)
movq %r14, %rdi
callq 0x28588
movq %r15, 0x90(%rbx)
movq 0x88(%rbx), %rax
movb %r15b, (%rax)
movb %r15b, 0xa8(%rbx)
movl $0x0, 0x158(%rbx)
movq %r15, 0x168(%rbx)
movq 0x160(%rbx), %rax
movb %r15b, (%rax)
movq %r15, 0x188(%rbx)
movq 0x180(%rbx), %rax
movb %r15b, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x88(%rbx), %rdi
cmpq %r13, %rdi
je 0x23757
movq (%r13), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x274d0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x23774
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x42e0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x23789
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x42e0
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2379e
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x42e0
movq %r15, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getChain(unsigned int const&)
Chain* Molecule::getChain(const unsigned int& element){
  if (element >= chnVec.size()){
    return 0;
  }
  else{
    return chnVec.at(element);
  }
}

// Assembly:
movl (%rsi), %eax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x237cf
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::readPDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Molecule* Molecule::readPDB (const std::string ifile, const int model, const std::string format, const bool hetFlag){
  if (ifile.length() == 0){
    std::cerr << "Error: PDB file \"" << ifile << "\" cannot be found" << std::endl;
    return new Molecule;
  }
  else{
    Molecule* mol=PDB::readPDB(ifile, model, format, hetFlag);
    mol->format();
    return mol;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x23897
movl %ecx, %ebp
movl %esi, %ebx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x6486
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x6486
movzbl %bpl, %ecx
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movl %ebx, %esi
xorl %r8d, %r8d
callq 0x2a578
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23875
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2388c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x23914
movq 0x3cd752(%rip), %rbx    # 0x3f0ff0
leaq 0x19bfb(%rip), %rsi     # 0x3d4a0
movl $0x11, %edx
movq %rbx, %rdi
callq 0x4340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x4340
movq %rax, %rbx
leaq 0x19be7(%rip), %rsi     # 0x3d4b2
movl $0x11, %edx
movq %rax, %rdi
callq 0x4340
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41f0
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x42d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x23600
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
jmp 0x23961
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2394f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x2394f
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x23966
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::writePDB[abi:cxx11](bool, bool)
std::string Molecule::writePDB(bool selFlag, bool print){

  std::ostringstream out;

  PDB::writePDBFormat(this, out, selFlag);

  if (print == true){
    std::cout << out.str();
  }
  
  return out.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x43d0
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x29e9a
testb %bpl, %bpl
je 0x23ac6
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4480
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x3cd522(%rip), %rdi    # 0x3f0fc8
callq 0x4340
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23ac6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x4480
movq 0x3cd4e6(%rip), %rsi    # 0x3f0fc0
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x23b29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x23b29
jmp 0x23b26
movq %rax, %rbx
movq 0x3cd490(%rip), %rsi    # 0x3f0fc0
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getAtom(unsigned int const&)
Atom* Molecule::getAtom(const unsigned int& element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

// Assembly:
movl (%rsi), %eax
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x24791
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::renameAtom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Molecule::renameAtom(const std::string &search, const std::string &replace){
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    Atom *atm=this->getAtom(i);
    if (atm->getAtmName().compare(0,atm->getAtmName().length(),search) == 0){
      atm->setAtmName(replace);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x24821
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x247cf
movq (%rax,%rbp,8), %r12
jmp 0x247d2
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x14a72
movq %rax, %r13
movq %r12, %rdi
callq 0x14a72
movq 0x8(%rax), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x43a0
testl %eax, %eax
jne 0x24805
movq %r12, %rdi
movq %rbx, %rsi
callq 0x14ed8
incq %rbp
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %rbp
jb 0x247c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::renameAtom(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Molecule::renameAtom(const std::vector<std::string> &search, const std::string &replace){
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    Atom *atm=this->getAtom(i);
    if (std::find(search.begin(), search.end(), atm->getAtmName()) != search.end()){
      atm->setAtmName(replace);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x248c8
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x2487a
movq (%rax,%rbx,8), %r12
jmp 0x2487d
xorl %r12d, %r12d
movq (%r14), %r13
movq 0x8(%r14), %rbp
movq %r12, %rdi
callq 0x14a72
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x285b5
cmpq 0x8(%r14), %rax
je 0x248ac
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x14ed8
incq %rbx
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %rbx
jb 0x2486b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getResidue(unsigned int const&)
Residue* Molecule::getResidue(const unsigned int& element){
  if (element >= resVec.size()){
    return NULL;
  }
  else{
    return resVec.at(element);
  }
}

// Assembly:
movl (%rsi), %eax
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x24c0f
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::renameRes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Molecule::renameRes(const std::string &search, const std::string &replace){
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    Atom *atm=this->getAtom(i);
    if (atm->getResName().compare(0,atm->getResName().length(),search) == 0){
      atm->setResName(replace);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x24c9f
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x24c4d
movq (%rax,%rbp,8), %r12
jmp 0x24c50
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x14a8e
movq %rax, %r13
movq %r12, %rdi
callq 0x14a8e
movq 0x8(%rax), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x43a0
testl %eax, %eax
jne 0x24c83
movq %r12, %rdi
movq %rbx, %rsi
callq 0x14f5a
incq %rbp
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %rbp
jb 0x24c3e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::renameRes(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Molecule::renameRes(const std::vector<std::string> &search, const std::string &replace){
  for (unsigned int i=0; i< search.size(); i++){
    this->renameRes(search.at(i), replace);
  }
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    Atom *atm=this->getAtom(i);
    if (std::find(search.begin(), search.end(), atm->getResName()) != search.end()){
      atm->setResName(replace);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x24cfb
movl $0x1, %ebx
xorl %esi, %esi
shlq $0x5, %rsi
addq %rax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x24c12
movl %ebx, %esi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebx
cmpq %rsi, %rcx
ja 0x24cd2
movq %r12, (%rsp)
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x24d74
xorl %ebx, %ebx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x24d26
movq (%rax,%rbx,8), %r12
jmp 0x24d29
xorl %r12d, %r12d
movq (%r14), %r13
movq 0x8(%r14), %rbp
movq %r12, %rdi
callq 0x14a8e
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x285b5
cmpq 0x8(%r14), %rax
je 0x24d58
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x14f5a
incq %rbx
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %rbx
jb 0x24d17
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::readTopology(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void Molecule::readTopology(const std::string& topin, bool verboseFlag){
  this->toppar.readTopology(topin);
  this->setAtmType(verboseFlag);
  this->setMass(verboseFlag);
  this->setCharge(verboseFlag);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
addq $0xb0, %rdi
callq 0x2d364
movq %r14, %rdi
movl %ebx, %esi
callq 0x24dbe
movq %r14, %rdi
movl %ebx, %esi
callq 0x2505c
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2529a
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getAtomTypes[abi:cxx11]()
std::vector<std::string> Molecule::getAtomTypes(){
  std::vector<std::string> atomTypes;

  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    atomTypes.push_back(this->getAtom(i)->getAtmType());
  }

  std::sort(atomTypes.begin(), atomTypes.end());
  std::vector<std::string>::iterator it=std::unique(atomTypes.begin(), atomTypes.end());
  atomTypes.resize(std::distance(atomTypes.begin(),it));

  return atomTypes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x256b8
movq %rsi, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
callq 0x14a78
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62fa
incq %r15
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %ecx
cmpq %rcx, %r15
jb 0x2568b
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x256f1
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x28a30
movq %r14, %rdi
movq %r15, %rsi
callq 0x28b14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x2007a
subq (%rbx), %rax
sarq $0x5, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1fd76
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2571c
jmp 0x2571c
movq %rax, %r14
movq %rbx, %rdi
callq 0x6420
movq %r14, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::storeSel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Molecule::storeSel(std::string key){
  std::vector<bool> selFlags;
  Chain *chn;
  Residue *res;
  Atom *atm;

  for (unsigned int i=0; i< this->getChnVecSize(); i++){
    chn=this->getChain(i);
    for (unsigned int j=0; j< chn->getResVecSize(); j++){
      res=chn->getResidue(j);
      for (unsigned int k=0; k< res->getAtmVecSize(); k++){
        atm=res->getAtom(k);
        selFlags.push_back(atm->getSel());
      }
    }
  }

  storedSel[key]=selFlags;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x8(%rdi), %rax
movq %rdi, 0x38(%rsp)
movq 0x10(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x259a3
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x25915
movq (%rax,%r15,8), %rbp
jmp 0x25917
xorl %ebp, %ebp
xorl %ebx, %ebx
movl %ebx, 0xc(%rsp)
movq %rbp, %rdi
callq 0x20664
cmpl %eax, %ebx
jae 0x2597e
movq %rbp, %rdi
leaq 0xc(%rsp), %rsi
callq 0x2060a
movq %rax, %rbx
xorl %r14d, %r14d
movl %r14d, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2f884
cmpl %eax, %r14d
jae 0x25976
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2f7ae
movq %rax, %rdi
callq 0x14ae6
movzbl (%rax), %esi
movq %r13, %rdi
callq 0x272e8
movl 0x8(%rsp), %r14d
incl %r14d
jmp 0x2593c
movl 0xc(%rsp), %ebx
incl %ebx
jmp 0x25919
incq %r15
movq 0x38(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %r15
jb 0x25906
movq 0x38(%rsp), %rdi
addq $0x58, %rdi
movq 0x40(%rsp), %rsi
callq 0x27336
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x273b2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x259f3
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x42e0
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25a06
jmp 0x25a06
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25a39
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x42e0
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
callq 0x4550
nop