LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15887(%rip), %rsi     # 0x2e3f0
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x41b0
cmpq $-0x1, %rax
je 0x18b82
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x15871(%rip), %rsi     # 0x2e3fa
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x45f0
cmpq $-0x1, %rax
je 0x18b79
leaq 0x15857(%rip), %rsi     # 0x2e3fa
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x41b0
testq %rax, %rax
jne 0x18b79
leaq 0x1583e(%rip), %r14     # 0x2e3fa
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4580
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x45f0
cmpq %rax, %r15
setae %r14b
jmp 0x18b79
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x4430
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45a0
cmpq $-0x1, %rax
je 0x18c3f
incq %rax
cmpq %rax, 0x8(%rbx)
je 0x18c1e
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40a0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x42a0
testq %rax, %rax
je 0x18c4e
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40a0
jmp 0x18c4e
leaq 0x14850(%rip), %rsi     # 0x2d496
movq %rbx, %rdi
callq 0x45c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x318, %rsp            # imm = 0x318
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4220
leaq 0x8(%rsp), %rdi
pushq $0x18
popq %rdx
movq %r15, %rsi
callq 0x44b0
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x41d0
leaq 0x8(%rsp), %rdi
callq 0x4260
leaq 0x8(%rsp), %rdi
pushq $0x18
popq %rdx
movq %r14, %rsi
callq 0x44b0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x41d0
leaq 0x8(%rsp), %rdi
callq 0x4260
leaq 0x1a0(%rsp), %r14
movl (%rsp), %esi
movq %r14, %rdi
callq 0x4520
movl (%rsp), %ebp
incl %ebp
movl %ebp, (%rsp)
leaq 0x14938(%rip), %r15     # 0x2d639
cmpl 0x4(%rsp), %ebp
jg 0x18d20
movq %r14, %rdi
movq %r15, %rsi
callq 0x4300
movq %rax, %rdi
movl %ebp, %esi
callq 0x4520
incl %ebp
jmp 0x18d01
leaq 0x1a8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44a0
leaq 0x190(%rsp), %rdi
callq 0x4260
movq %rbx, %rax
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18d52
jmp 0x18d65
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4260
jmp 0x18d68
jmp 0x18d65
jmp 0x18d65
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl %esi, %ebx
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4340
movq %r15, %rdi
callq 0x18b42
movl %eax, %ebp
movq %r15, %rdi
callq 0x4170
xorl %eax, %eax
testb %bpl, %bpl
je 0x18e67
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4340
movq (%r15), %rbx
movq %r15, %rdi
callq 0x4170
movsbl (%rbx), %eax
addl $-0x40, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
movsd (%rsi), %xmm2
jne 0x18e86
jnp 0x18e9f
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd 0x145ba(%rip), %xmm2    # 0x2d450
sqrtsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
retq
ucomisd %xmm0, %xmm2
jne 0x18ea7
jnp 0x18ebf
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd 0x14599(%rip), %xmm1    # 0x2d450
sqrtsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3caf0f(%rip), %rax    # 0x3e4d40
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
andl $0x0, 0x60(%rdi)
leaq 0x20(%rdi), %r12
andq $0x0, 0x68(%rdi)
leaq 0x38(%rdi), %r13
leaq 0x60(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
andq $0x0, 0x48(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rax, 0x70(%rdi)
movq %rax, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
leaq 0x98(%rdi), %rax
movq %rax, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
leaq 0x58(%rdi), %r15
leaq 0x88(%rdi), %rbp
movb $0x0, 0x98(%rdi)
addq $0xb0, %rdi
callq 0x21d04
leaq 0x170(%rbx), %rax
movq %rax, 0x160(%rbx)
andq $0x0, 0x168(%rbx)
xorl %eax, %eax
movb %al, 0x170(%rbx)
leaq 0x190(%rbx), %rcx
movq %rcx, 0x180(%rbx)
andq $0x0, 0x188(%rbx)
movb %al, 0x190(%rbx)
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x19ef1
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x19eff
movq %rax, 0x28(%rbx)
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x19f0d
movq %rax, 0x40(%rbx)
xorl %ebp, %ebp
movb %bpl, 0x50(%rbx)
movq %r15, %rdi
callq 0x1de88
andq $0x0, 0x90(%rbx)
movq 0x88(%rbx), %rax
movb %bpl, (%rax)
movb %bpl, 0xa8(%rbx)
andl $0x0, 0x158(%rbx)
andq $0x0, 0x168(%rbx)
movq 0x160(%rbx), %rax
movb %bpl, (%rax)
andq $0x0, 0x188(%rbx)
movq 0x180(%rbx), %rax
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0x4170
movq %r15, %rdi
callq 0x1cec2
movq %r13, %rdi
callq 0xf036
movq %r12, %rdi
callq 0x1de6a
movq %r14, %rdi
callq 0x1de36
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %esi
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x19fd5
pushq %rax
addq $0x8, %rdi
callq 0x1cc12
movq (%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x1a063
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x4430
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x4430
movzbl %bpl, %ecx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %ebx, %esi
xorl %r8d, %r8d
callq 0x1feca
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x28(%rsp), %rdi
callq 0x4170
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x1a0ad
movq 0x3caf86(%rip), %rdi    # 0x3e4ff0
leaq 0x14397(%rip), %rsi     # 0x2e408
callq 0x4300
movq %rax, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0x14392(%rip), %rsi     # 0x2e41a
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x4320
movq %rax, %rbx
movq %rax, %rdi
callq 0x19e1c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
callq 0x4330
jmp 0x1a0e9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4170
jmp 0x1a0df
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4410
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x1f8d8
testb %bpl, %bpl
je 0x1a1d6
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x44a0
movq 0x3cae06(%rip), %rdi    # 0x3e4fc8
leaq 0x8(%rsp), %rsi
callq 0x42c0
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x44a0
leaq 0x28(%rsp), %rdi
callq 0x40c0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
jmp 0x1a214
jmp 0x1a211
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::checkICode()
bool Molecule::checkICode(){
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    if (this->getAtom(i)->getICode().length() != 0 && this->getAtom(i)->getICode().compare(0,1," ") != 0){
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x4(%rsp), %r14
leaq 0x13fb3(%rip), %r15     # 0x2e5c4
pushq $0x1
popq %r12
movl %r13d, 0x4(%rsp)
movq 0x40(%rbx), %rbp
subq 0x38(%rbx), %rbp
shrq $0x3, %rbp
cmpl %ebp, %r13d
jae 0x1a671
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ab66
movq %rax, %rdi
callq 0xea34
cmpq $0x0, 0x8(%rax)
je 0x1a66c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ab66
movq %rax, %rdi
callq 0xea34
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x43f0
testl %eax, %eax
jne 0x1a671
incl %r13d
jmp 0x1a615
cmpl %ebp, %r13d
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %esi
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x1ab8b
pushq %rax
addq $0x38, %rdi
callq 0xeff6
movq (%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0xc(%rsp), %r12
movl %ebx, 0xc(%rsp)
movq 0x40(%r15), %rax
subq 0x38(%r15), %rax
shrq $0x3, %rax
cmpl %eax, %ebx
jae 0x1ac09
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ab66
movq %rax, %r13
movq %rax, %rdi
callq 0xe9f0
movq %rax, %rbp
movq %r13, %rdi
callq 0xe9f0
movq 0x8(%rax), %rdx
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x43d0
testl %eax, %eax
jne 0x1ac05
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0xed26
incl %ebx
jmp 0x1abae
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movl %ebx, 0xc(%rsp)
movq 0x40(%r15), %rax
subq 0x38(%r15), %rax
shrq $0x3, %rax
cmpl %eax, %ebx
jae 0x1ac99
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x1ab66
movq %rax, %r13
movq (%r14), %rbp
movq 0x8(%r14), %r12
movq %rax, %rdi
callq 0xe9f0
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1deb5
cmpq 0x8(%r14), %rax
je 0x1ac95
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0xed26
incl %ebx
jmp 0x1ac41
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %esi
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x1af15
pushq %rax
addq $0x20, %rdi
callq 0x1792e
movq (%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0xc(%rsp), %r12
movl %ebx, 0xc(%rsp)
movq 0x40(%r15), %rax
subq 0x38(%r15), %rax
shrq $0x3, %rax
cmpl %eax, %ebx
jae 0x1af93
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ab66
movq %rax, %r13
movq %rax, %rdi
callq 0xea0c
movq %rax, %rbp
movq %r13, %rdi
callq 0xea0c
movq 0x8(%rax), %rdx
movq %rbp, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x43d0
testl %eax, %eax
jne 0x1af8f
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0xed82
incl %ebx
jmp 0x1af38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
movl %eax, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x1afee
movq %r14, %rdi
movq %r12, %rsi
callq 0x1cc34
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1af18
leal 0x1(%r12), %eax
jmp 0x1afbb
movq %rbx, 0x10(%rsp)
xorl %ebx, %ebx
movl %ebx, 0xc(%rsp)
movq 0x40(%r15), %rax
subq 0x38(%r15), %rax
shrq $0x3, %rax
cmpl %eax, %ebx
jae 0x1b04d
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x1ab66
movq %rax, %r13
movq (%r14), %rbp
movq 0x8(%r14), %r12
movq %rax, %rdi
callq 0xea0c
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1deb5
cmpq 0x8(%r14), %rax
je 0x1b049
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0xed82
incl %ebx
jmp 0x1aff5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21fea
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b096
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b232
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1b3ae
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::setAtmType(bool)
void Molecule::setAtmType(bool verboseFlag){
  Atom* a;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    a=this->getAtom(i);
    a->setAtmType(this->toppar.getAtmType(Misc::trim(a->getResName()), Misc::trim(a->getAtmName()), verboseFlag));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0xb0(%rdi), %rax
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
leaq 0x68(%rsp), %r14
leaq 0x88(%rsp), %r12
movzbl %sil, %eax
movl %eax, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movl %ebp, 0x14(%rsp)
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jae 0x1b1c6
movq %r12, %rbx
movq %r14, %r12
leaq 0x14(%rsp), %rsi
callq 0x1ab66
movq %rax, %r13
movq %rax, %rdi
callq 0xea0c
movq %rax, %r15
leaq 0x48(%rsp), %r14
movq %r14, %rdi
leaq 0x134b0(%rip), %rsi     # 0x2e5c4
leaq 0xf(%rsp), %rdx
callq 0x58d8
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18be4
movq %r13, %rdi
callq 0xe9f0
movq %rax, %r15
movq %r12, %r14
movq %r12, %rdi
leaq 0x1347e(%rip), %rsi     # 0x2e5c4
leaq 0xe(%rsp), %rdx
callq 0x58d8
movq %rbx, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18be4
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r12, %rcx
movl 0x10(%rsp), %r8d
callq 0x22708
movq %r13, %rdi
movq %rbx, %rsi
callq 0xed40
movq %rbx, %rdi
callq 0x4170
movq %r12, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4170
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
incl %ebp
movq 0x18(%rsp), %rdi
jmp 0x1b0cf
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1b21f
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x4170
jmp 0x1b1f2
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4170
jmp 0x1b206
jmp 0x1b212
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4170
jmp 0x1b215
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::setMass(bool)
void Molecule::setMass(bool verboseFlag){
  Atom* a;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    a=this->getAtom(i);
    a->setMass(this->toppar.getMass(Misc::trim(a->getResName()), Misc::trim(a->getAtmName()), verboseFlag));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0xb0(%rdi), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
leaq 0x68(%rsp), %rbp
leaq 0x88(%rsp), %rbx
movzbl %sil, %eax
movl %eax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movl %r15d, 0xc(%rsp)
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
shrq $0x3, %rax
cmpl %eax, %r15d
jae 0x1b354
movq %rbp, %r14
leaq 0xc(%rsp), %rsi
callq 0x1ab66
movq %rax, %r12
movq %rax, %rdi
callq 0xea0c
movq %rax, %r13
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13314(%rip), %rsi     # 0x2e5c4
leaq 0x7(%rsp), %rdx
callq 0x58d8
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x18be4
movq %r12, %rdi
callq 0xe9f0
movq %rax, %r13
movq %r14, %rbp
movq %r14, %rdi
leaq 0x132e2(%rip), %rsi     # 0x2e5c4
leaq 0x6(%rsp), %rdx
callq 0x58d8
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x18be4
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
movl 0x8(%rsp), %ecx
callq 0x22830
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
callq 0xeeb2
movq %rbx, %rdi
callq 0x4170
movq %rbp, %rdi
callq 0x4170
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
incl %r15d
movq 0x10(%rsp), %rdi
jmp 0x1b26c
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1b39b
jmp 0x1b372
movq %rax, %rbx
jmp 0x1b387
movq %rax, %rbx
jmp 0x1b391
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4170
leaq 0x68(%rsp), %rdi
callq 0x4170
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::setCharge(bool)
void Molecule::setCharge(bool verboseFlag){
  Atom* a;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    a=this->getAtom(i);
    a->setCharge(this->toppar.getCharge(Misc::trim(a->getResName()), Misc::trim(a->getAtmName()), verboseFlag));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0xb0(%rdi), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
leaq 0x68(%rsp), %rbp
leaq 0x88(%rsp), %rbx
movzbl %sil, %eax
movl %eax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movl %r15d, 0xc(%rsp)
movq 0x40(%rdi), %rax
subq 0x38(%rdi), %rax
shrq $0x3, %rax
cmpl %eax, %r15d
jae 0x1b4d0
movq %rbp, %r14
leaq 0xc(%rsp), %rsi
callq 0x1ab66
movq %rax, %r12
movq %rax, %rdi
callq 0xea0c
movq %rax, %r13
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
leaq 0x13198(%rip), %rsi     # 0x2e5c4
leaq 0x7(%rsp), %rdx
callq 0x58d8
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x18be4
movq %r12, %rdi
callq 0xe9f0
movq %rax, %r13
movq %r14, %rbp
movq %r14, %rdi
leaq 0x13166(%rip), %rsi     # 0x2e5c4
leaq 0x6(%rsp), %rdx
callq 0x58d8
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x18be4
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rdx
movl 0x8(%rsp), %ecx
callq 0x2293c
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
callq 0xeec0
movq %rbx, %rdi
callq 0x4170
movq %rbp, %rdi
callq 0x4170
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
incl %r15d
movq 0x10(%rsp), %rdi
jmp 0x1b3e8
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1b517
jmp 0x1b4ee
movq %rax, %rbx
jmp 0x1b503
movq %rax, %rbx
jmp 0x1b50d
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4170
leaq 0x68(%rsp), %rdi
callq 0x4170
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
movl %ebp, 0x4(%rsp)
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jae 0x1b609
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %rdi
callq 0xe9f6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58ac
incl %ebp
jmp 0x1b5d3
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1e3d4
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x17300
subq (%rbx), %rax
sarq $0x5, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1707a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b645
jmp 0x1b645
movq %rax, %r14
movq %rbx, %rdi
callq 0x59a0
movq %r14, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getNAtomSelected()
unsigned int Molecule::getNAtomSelected(){
  unsigned int natom=0;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    if (this->getAtom(i)->getSel() == true){
      natom++;
    }
  }
  return natom;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x4(%rsp), %r14
xorl %ebp, %ebp
movl %r15d, 0x4(%rsp)
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %r15d
jae 0x1b79d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ab66
movq %rax, %rdi
callq 0xea64
movzbl (%rax), %eax
addl %eax, %ebp
incl %r15d
jmp 0x1b76a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
andl $0x0, 0x8(%r14)
andq $0x0, 0x10(%r14)
movq %rsi, 0x10(%rsp)
andl $0x0, 0x18(%r14)
movq %rdi, %r15
andq $0x0, 0x20(%r14)
xorl %r13d, %r13d
leaq 0x4(%rsp), %rbp
movl %r13d, 0xc(%rsp)
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
shrq $0x3, %rax
cmpl %eax, %r13d
jae 0x1b899
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x19fb0
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, 0x18(%rsp)
movl %r12d, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1786c
cmpl %eax, %r12d
jae 0x1b891
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x17802
movq %rax, %r12
movl %r13d, %ebx
movq %r15, %r13
xorl %r15d, %r15d
movl %r15d, 0x4(%rsp)
movq %r12, %rdi
callq 0x23aee
cmpl %eax, %r15d
jae 0x1b87c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x239f2
movq %rax, %rdi
callq 0xea64
movzbl (%rax), %esi
movq %r14, %rdi
callq 0x1cd1c
movl 0x4(%rsp), %r15d
incl %r15d
jmp 0x1b842
movl 0x8(%rsp), %r12d
incl %r12d
movq %r13, %r15
movl %ebx, %r13d
movq 0x18(%rsp), %rbx
jmp 0x1b817
incl %r13d
jmp 0x1b7e5
addq $0x58, %r15
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x1cd5a
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1cdc0
leaq 0x20(%rsp), %rdi
callq 0x1ce56
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b8d6
jmp 0x1b8d6
jmp 0x1b8d6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1ce56
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::recallSel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Molecule::recallSel(std::string key){
  Chain *chn;
  Residue *res;
  Atom *atm;
  unsigned int n;
  std::vector<bool>* storedSelVal;

  n=0;
  storedSelVal=&storedSel[key];
  
  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);
        atm->setSel(storedSelVal->at(n));
        n++;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x58, %rdi
callq 0x1cd5a
movq %rax, %r14
xorl %ecx, %ecx
movq %rsp, %r13
xorl %r12d, %r12d
movq %rbx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %ecx
jae 0x1b9c1
movl %ecx, 0x8(%rsp)
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x19fb0
movq %rax, %rbp
xorl %ebx, %ebx
movl %ebx, 0x4(%rsp)
movq %rbp, %rdi
callq 0x1786c
cmpl %eax, %ebx
jae 0x1b9b1
movq %rbp, %rdi
leaq 0x4(%rsp), %rsi
callq 0x17802
movq %rax, %r15
xorl %ebx, %ebx
movl %ebx, (%rsp)
movq %r15, %rdi
callq 0x23aee
cmpl %eax, %ebx
jae 0x1b9a9
movq %r15, %rdi
movq %r13, %rsi
callq 0x239f2
movq %rax, %rbx
movl %r12d, %esi
movq %r14, %rdi
callq 0x1ce66
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %rbx, %rdi
callq 0xee92
incl %r12d
movl (%rsp), %ebx
incl %ebx
jmp 0x1b966
movl 0x4(%rsp), %ebx
incl %ebx
jmp 0x1b944
movl 0x8(%rsp), %ecx
incl %ecx
movq 0x10(%rsp), %rbx
jmp 0x1b916
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::zeroCoor()
void Molecule::zeroCoor(){
  Chain *chn;
  Residue *res;
  Atom *atm;
  Coor coor;

  coor=Coor(0.0, 0.0, 0.0);

  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);
        atm->setCoor(coor);
      }
    }
  }
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x2bf34
leaq 0x18(%rsp), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x2bf40
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bf62
xorl %ecx, %ecx
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %rbx, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %ecx
jae 0x1bac3
movl %ecx, 0xc(%rsp)
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq 0x19fb0
movq %rax, %rbp
xorl %r15d, %r15d
movl %r15d, 0x8(%rsp)
movq %rbp, %rdi
callq 0x1786c
cmpl %eax, %r15d
jae 0x1bab3
movq %rbp, %rdi
movq %r12, %rsi
callq 0x17802
movq %rax, %r15
xorl %ebx, %ebx
movl %ebx, 0x4(%rsp)
movq %r15, %rdi
callq 0x23aee
cmpl %eax, %ebx
jae 0x1baa9
movq %r15, %rdi
movq %r13, %rsi
callq 0x239f2
movq %rax, %rdi
movq %r14, %rsi
callq 0xee3e
movl 0x4(%rsp), %ebx
incl %ebx
jmp 0x1ba7b
movl 0x8(%rsp), %r15d
incl %r15d
jmp 0x1ba59
movl 0xc(%rsp), %ecx
incl %ecx
movq 0x10(%rsp), %rbx
jmp 0x1ba2a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::modPseudoCenter()
void Molecule::modPseudoCenter(){
  Atom *atmEntry;
  Atom *lastAtom;

  for (unsigned int i=0; i< this->getChnVecSize(); i++){
    atmEntry=NULL;
    lastAtom=NULL;
    for (unsigned int j=0; j< this->getChain(i)->getAtmVecSize(); j++){
      atmEntry=this->getChain(i)->getAtom(j);

      if(lastAtom !=NULL){
        if (lastAtom->getResId()+1 == atmEntry->getResId()){
          //Compute pseudocenter for last atom
          lastAtom->setCoor((lastAtom->getCoor()+atmEntry->getCoor())/2.0);
        }
        else if (lastAtom->getResId() == atmEntry->getResId() && (lastAtom->getICode().compare(0,1,atmEntry->getICode(),0,1) != 0)){
          //Compute pseudocenter for last atom
          lastAtom->setCoor((lastAtom->getCoor()+atmEntry->getCoor())/2.0);
        }
        else{
          //No i+1 neighbor, modify coordinates
          lastAtom->setCoor(Coor(9999.9, 9999.9, 9999.9));
        }
      }
      lastAtom=atmEntry;
    }
    //No i+1 neighbor for last atom in chain, modify coordinates
    lastAtom->setCoor(Coor(9999.9, 9999.9, 9999.9));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
leaq 0xc(%rsp), %r14
movl %ecx, 0xc(%rsp)
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %ecx
jae 0x1c0ac
movq %rcx, 0x10(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r12, %rbp
movl %r15d, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19fb0
movq %rax, %rdi
callq 0x1785e
cmpl %eax, %r15d
jae 0x1c07a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19fb0
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x177da
movq %rax, %r12
testq %rbp, %rbp
je 0x1c06d
movq %rbp, %rdi
callq 0xea2c
movl (%rax), %r15d
incl %r15d
movq %r12, %rdi
callq 0xea2c
cmpl (%rax), %r15d
je 0x1c007
movq %rbp, %rdi
callq 0xea2c
movl (%rax), %r15d
movq %r12, %rdi
callq 0xea2c
cmpl (%rax), %r15d
jne 0x1c047
movq %rbp, %rdi
callq 0xea34
movq %rax, %r15
movq %r12, %rdi
callq 0xea34
movq %r15, %rdi
xorl %esi, %esi
pushq $0x1
popq %rdx
movq %rax, %rcx
xorl %r8d, %r8d
movq %rdx, %r9
callq 0x4060
testl %eax, %eax
je 0x1c047
movq %rbp, %rdi
callq 0xea3c
movq %rax, %r15
movq %r12, %rdi
callq 0xea3c
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2bf88
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movsd 0x123c0(%rip), %xmm0    # 0x2e400
callq 0x2c178
jmp 0x1c062
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movsd 0x11409(%rip), %xmm0    # 0x2d460
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2bf40
movq %rbp, %rdi
movq %r15, %rsi
callq 0xee3e
movl 0x8(%rsp), %r15d
incl %r15d
jmp 0x1bf5f
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movsd 0x113d6(%rip), %xmm0    # 0x2d460
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x2bf40
movq %rbp, %rdi
movq %r15, %rsi
callq 0xee3e
movq 0x10(%rsp), %rcx
incl %ecx
jmp 0x1bf3c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::assignAtmInx()
void Molecule::assignAtmInx(){
  unsigned int natom;

  natom=0;

  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    this->getAtom(i)->setAtmInx(natom);
    natom++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
movq %rdi, %r14
xorl %ebp, %ebp
movq %rsp, %r15
movl %ebp, (%rsp)
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jae 0x1c894
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %rdi
movq %rbx, %rsi
callq 0xeece
incl 0x4(%rsp)
incl %ebp
jmp 0x1c863
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::~Molecule()
Molecule::~Molecule (){
  Chain *c;
  Residue *r;
  Atom *a;

  for (unsigned int i=0; i< this->getChnVecSize(); i++){
    c=this->getChain(i);
    for (unsigned int j=0; j< c->getResVecSize(); j++){
      r=c->getResidue(j);
      if (this->getCopyFlag() == false){
        //Only destruct atoms if molecule is NOT a copy
        for (unsigned int k=0; k< r->getAtmVecSize(); k++){
          a=r->getAtom(k);
          delete a;
        }
      }
      delete r;
    }
    delete c;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x3c8436(%rip), %rax    # 0x3e4d40
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %ecx, %ecx
pushq $0x18
popq %r13
movq %rsp, %rbp
movl %ecx, 0xc(%rsp)
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
shrq $0x3, %rax
movl %ecx, 0x8(%rsp)
cmpl %eax, %ecx
jae 0x1c9f7
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x19fb0
movq %rax, %r15
xorl %ebx, %ebx
movl %ebx, 0x4(%rsp)
movq %r15, %rdi
callq 0x1786c
cmpl %eax, %ebx
jae 0x1c9d9
movq %r15, %rdi
leaq 0x4(%rsp), %rsi
callq 0x17802
movq %rax, %rbx
cmpb $0x0, 0x50(%r14)
je 0x1c994
testq %rbx, %rbx
je 0x1c981
movq %rbx, %rdi
callq 0xf036
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4330
movl 0x4(%rsp), %ebx
incl %ebx
jmp 0x1c94d
xorl %r12d, %r12d
movl %r12d, (%rsp)
movq %rbx, %rdi
callq 0x23aee
cmpl %eax, %r12d
jae 0x1c974
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x239f2
movq %rax, %r12
testq %rax, %rax
je 0x1c9c3
movq %r12, %rdi
callq 0x1ca6a
movl $0x238, %esi            # imm = 0x238
movq %r12, %rdi
callq 0x4330
movl (%rsp), %r12d
incl %r12d
jmp 0x1c997
movq %r15, %rdi
callq 0x1cb16
movq %r15, %rdi
pushq $0x30
popq %rsi
callq 0x4330
movl 0x8(%rsp), %ecx
incl %ecx
jmp 0x1c91f
leaq 0x180(%r14), %rdi
callq 0x4170
leaq 0x160(%r14), %rdi
callq 0x4170
leaq 0xb0(%r14), %rdi
callq 0x1cb2c
leaq 0x88(%r14), %rdi
callq 0x4170
leaq 0x58(%r14), %rdi
callq 0x1cec2
leaq 0x38(%r14), %rdi
callq 0xf036
addq $0x20, %r14
movq %r14, %rdi
callq 0x1de6a
movq 0x10(%rsp), %rdi
callq 0x1de36
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ca62
jmp 0x1ca62
movq %rax, %rdi
callq 0x59c1
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/PDB.cpp
// Function: PDB::formatCHARMMResId(Atom*, Residue*, Residue*)
int PDB::formatCHARMMResId(Atom* atmEntry, Residue* lastRes, Residue* nextRes){
  if (atmEntry->getResName().compare("ACE") == 0 && nextRes != NULL){
    return nextRes->getResId();
  }
  else if ((atmEntry->getResName().compare("AHE") == 0 || atmEntry->getResName().compare("NME") == 0) && lastRes != NULL){
    return lastRes->getResId();
  }
  else{
    return atmEntry->getResId();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xea0c
leaq 0xcd51(%rip), %rsi      # 0x2e4d5
movq %rax, %rdi
callq 0x4100
testq %r15, %r15
je 0x2179a
testl %eax, %eax
jne 0x2179a
movq %r15, %rdi
jmp 0x217d8
movq %rbx, %rdi
callq 0xea0c
leaq 0xcd24(%rip), %rsi      # 0x2e4cd
movq %rax, %rdi
callq 0x4100
testl %eax, %eax
je 0x217e2
movq %rbx, %rdi
callq 0xea0c
leaq 0xcd0d(%rip), %rsi      # 0x2e4d1
movq %rax, %rdi
callq 0x4100
testq %r14, %r14
je 0x217e7
testl %eax, %eax
jne 0x217e7
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x239d8
testq %r14, %r14
jne 0x217d5
movq %rbx, %rdi
callq 0xea2c
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getAtmType(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&, bool)
std::string Prmtop::getAtmType(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (atmtype.find(std::make_pair(resnamein, atmnamein)) != atmtype.end()){
    return  atmtype[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not a find an atom type for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to \"DUMB\"" << std::endl;
    }
    return "DUMB";
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, (%rsp)
leaq 0x60(%rsi), %r12
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x22c22
movq %r12, %rdi
movq %rbx, %rsi
callq 0x23406
movq %rax, %rbx
addq $0x68, %r13
leaq 0x8(%rsp), %rdi
callq 0x18578
cmpq %r13, %rbx
je 0x22797
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x22c22
movq %r12, %rdi
movq %rbx, %rsi
callq 0x22ad4
movq (%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4430
leaq 0x8(%rsp), %rdi
callq 0x18578
jmp 0x22806
testb %bpl, %bpl
je 0x227ee
movq 0x3c284d(%rip), %rbx    # 0x3e4ff0
leaq 0xbf10(%rip), %rsi      # 0x2e6ba
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
movq %r15, %rsi
callq 0x42c0
leaq 0xbe00(%rip), %rsi      # 0x2e5c4
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0xbf0d(%rip), %rsi      # 0x2e6eb
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0xbf0d(%rip), %rsi      # 0x2e702
leaq 0x8(%rsp), %rdx
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x58d8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2281a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18578
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getMass(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&, bool)
double Prmtop::getMass(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (mass.find(std::make_pair(resnamein, atmnamein)) != mass.end()){
    return  mass[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not a find mass for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to 1.0" << std::endl;
    }
    return 1.0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x22c22
movq %r15, %rdi
movq %r12, %rsi
callq 0x236d2
movq %rax, %r12
leaq 0x8(%r15), %r13
leaq 0x8(%rsp), %rdi
callq 0x18578
cmpq %r13, %r12
je 0x228af
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22c22
movq %r15, %rdi
movq %r12, %rsi
callq 0x22b3a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x18578
movsd (%rsp), %xmm0
jmp 0x22916
movsd 0xab99(%rip), %xmm0     # 0x2d450
testb %bpl, %bpl
je 0x22916
movq 0x3c272d(%rip), %r15    # 0x3e4ff0
leaq 0xbe3d(%rip), %rsi      # 0x2e707
movq %r15, %rdi
callq 0x4300
movq %rax, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0xbce0(%rip), %rsi      # 0x2e5c4
movq %r15, %rdi
callq 0x4300
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42c0
leaq 0xbe32(%rip), %rsi      # 0x2e730
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
movsd 0xab3a(%rip), %xmm0     # 0x2d450
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22927
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18578
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getCharge(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&, bool)
double Prmtop::getCharge(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (charge.find(std::make_pair(resnamein, atmnamein)) != charge.end()){
    return charge[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not find a charge for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to 0.0." << std::endl;
    }
    return 0.0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x30(%rdi), %r15
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x22c22
movq %r15, %rdi
movq %r13, %rsi
callq 0x236d2
movq %rax, %r13
addq $0x38, %r12
leaq 0x8(%rsp), %rdi
callq 0x18578
cmpq %r12, %r13
je 0x229bf
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22c22
movq %r15, %rdi
movq %r12, %rsi
callq 0x22b3a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x18578
movsd (%rsp), %xmm0
jmp 0x22a1c
xorps %xmm0, %xmm0
testb %bpl, %bpl
je 0x22a1c
movq 0x3c2622(%rip), %r15    # 0x3e4ff0
leaq 0xbd6f(%rip), %rsi      # 0x2e744
movq %r15, %rdi
callq 0x4300
movq %rax, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0xbbd5(%rip), %rsi      # 0x2e5c4
movq %r15, %rdi
callq 0x4300
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42c0
leaq 0xbd66(%rip), %rsi      # 0x2e76f
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
xorps %xmm0, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22a2d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18578
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Residue.cpp
// Function: Residue::getAtom(unsigned int const&)
Atom* Residue::getAtom (const unsigned int &element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

// Assembly:
movl (%rsi), %esi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x23a12
pushq %rax
callq 0xeff6
movq (%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop