LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::averageMol(Molecule*, Molecule*, int&)
void Analyze::averageMol (Molecule* cmpmol, Molecule* refmol, int &ndataIO){
  unsigned int i,j;
  Atom *atm;
  std::vector<Coor> coor;

  //Check selection sizes and resize matrices
  if (cmpmol->getNAtomSelected() != refmol->getNAtomSelected()){
    std::cerr << std::endl << "Error: Atom number mismatch in RMSD calculation" << std::endl;
    std::cerr << "CMP-NATOM: " << cmpmol->getNAtomSelected() << ", ";
    std::cerr << "REF-NATOM: " << refmol->getNAtomSelected() << std::endl;
  }
  else{
    for (i=0; i< cmpmol->getNAtom(); i++){
      atm=cmpmol->getAtom(i);
      if (atm->getSel() == false){
        continue;
      }
      coor.push_back(atm->getCoor());
    }

    j=0;
    for (i=0; i< refmol->getNAtom(); i++){
      atm=refmol->getAtom(i);
      if (atm->getSel() == false){
        continue;
      }
      atm->setCoor(coor.at(j)+atm->getCoor());
      j++;
    }
    ndataIO++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
callq 0x1b756
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1b756
cmpl %eax, %ebp
jne 0x8ffa
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
movl %ebp, 0xc(%rsp)
movq %r15, %rdi
callq 0x1b6a8
cmpl %eax, %ebp
jae 0x9086
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ab66
movq %rax, %rbp
movq %rax, %rdi
callq 0xea64
cmpb $0x0, (%rax)
je 0x8ff2
movq %rbp, %rdi
callq 0xea3c
movq %r13, %rdi
movq %rax, %rsi
callq 0xc9b6
movl 0xc(%rsp), %ebp
incl %ebp
jmp 0x8fb0
movq 0x3dbfef(%rip), %rdi    # 0x3e4ff0
callq 0x4180
leaq 0x24586(%rip), %rsi     # 0x2d593
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
movq 0x3dbfcc(%rip), %rdi    # 0x3e4ff0
leaq 0x24598(%rip), %rsi     # 0x2d5c3
callq 0x4300
movq %rax, %r14
movq %r15, %rdi
callq 0x1b756
movl %eax, %esi
movq %r14, %rdi
callq 0x4200
leaq 0x24583(%rip), %rsi     # 0x2d5cf
movq %rax, %rdi
callq 0x4300
movq 0x3dbf95(%rip), %rdi    # 0x3e4ff0
leaq 0x24570(%rip), %rsi     # 0x2d5d2
callq 0x4300
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b756
movl %eax, %esi
movq %r14, %rdi
callq 0x4200
movq %rax, %rdi
callq 0x4180
jmp 0x9103
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
leaq 0x30(%rsp), %r13
xorl %r12d, %r12d
movl %ebp, 0xc(%rsp)
movq %rbx, %rdi
callq 0x1b6a8
cmpl %eax, %ebp
jae 0x90fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %rbp
movq %rax, %rdi
callq 0xea64
cmpb $0x0, (%rax)
je 0x90f4
movl %r12d, %esi
leaq 0x10(%rsp), %rdi
callq 0xc9e2
movq %rax, %r14
movq %rbp, %rdi
callq 0xea3c
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2bf88
movq %rbp, %rdi
movq %r13, %rsi
callq 0xee3e
incl %r12d
movl 0xc(%rsp), %ebp
incl %ebp
jmp 0x9095
movq 0x28(%rsp), %rax
incl (%rax)
leaq 0x10(%rsp), %rdi
callq 0xd5f8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9122
jmp 0x9122
jmp 0x9122
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd5f8
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::angle(Coor const&, Coor const&, Coor const&)
double Analyze::angle (const Coor& u, const Coor& v, const Coor& w){
  double angle;
  Coor dx, dy;
  double dp, nx, ny;

  dx=u-v;
  dy=w-v;

  nx=dx.norm();
  ny=dy.norm();

  dp=dx.dot(dy);

  angle=acos(dp/(nx*ny));

  return angle/PI*180.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x2bf34
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2bf34
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2c014
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2bf62
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2c014
movq %r14, %rdi
movq %r13, %rsi
callq 0x2bf62
movq %rbx, %rdi
callq 0x2c24c
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x2c24c
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c1e0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x42f0
divsd 0x3dbf75(%rip), %xmm0   # 0x3e5330
mulsd 0x24085(%rip), %xmm0    # 0x2d448
addq $0x58, %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/Analyze.cpp
// Function: AnalyzeDihedral::runAnalysis()
void AnalyzeDihedral::runAnalysis(){
  unsigned int i;

  std::cout << std::fixed;

  for (i=0; i< this->getNMol()-3; i=i+4){
    std::cout << std::setw(9) << std::right << std::setprecision(3) << Analyze::dihedral(Analyze::centerOfGeometry(this->getMol(i)), Analyze::centerOfGeometry(this->getMol(i+1)), Analyze::centerOfGeometry(this->getMol(i+2)), Analyze::centerOfGeometry(this->getMol(i+3)));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x3dbbde(%rip), %rdx    # 0x3e4fc8
movq (%rdx), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rdx,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rdx,%rax)
xorl %r15d, %r15d
pushq $0x1
popq %r13
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
shrq $0x3, %rax
addl $-0x3, %eax
cmpl %eax, %r15d
jae 0x951f
movq 0x3dbba1(%rip), %rdi    # 0x3e4fc8
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movq $0x9, 0x10(%rdi,%rcx)
movq -0x18(%rax), %rcx
movl 0x18(%rdi,%rcx), %edx
movl $0xffffff4f, %esi       # imm = 0xFFFFFF4F
andl %esi, %edx
orl $0x80, %edx
movl %edx, 0x18(%rdi,%rcx)
movq -0x18(%rax), %rax
movq $0x3, 0x8(%rdi,%rax)
movl %r15d, 0x14(%rsp)
movq %rbx, %rdi
leaq 0x14(%rsp), %rsi
callq 0x8be4
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x8e74
leal 0x1(%r15), %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x8be4
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x8e74
leal 0x2(%r15), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x8be4
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x8e74
leal 0x3(%r15), %eax
movl %eax, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x8be4
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x8e74
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x952e
movq 0x3dbab7(%rip), %rdi    # 0x3e4fc8
callq 0x44d0
addl $0x4, %r15d
jmp 0x9408
addq $0x78, %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/Analyze.cpp
// Function: AnalyzePairwiseDistance::runAnalysis()
void AnalyzePairwiseDistance::runAnalysis(){
//  std::map<std::pair<Atom*, Atom*>, double> pdist;
  std::vector<std::vector<double> > pdist;
  Atom* ai;
  Atom* aj;
  
  this->getMol(0)->assignAtmInx();
  Analyze::pairwiseDistance(this->getMol(0), pdist);

  for (unsigned int i=0; i< this->getMol(0)->getAtmVecSize(); i++){
    ai=this->getMol(0)->getAtom(i);
    for (unsigned int j=i+1; j< this->getMol(0)->getAtmVecSize(); j++){
      aj=this->getMol(0)->getAtom(j);
//      std::cout << "  " << ai->getSummary() << "-" << aj->getSummary();
      std::cout << std::fixed;
      std::cout << std::setw(9) << std::right << std::setprecision(3) << pdist.at(ai->getAtmInx()).at(aj->getAtmInx());
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x8be4
movq %rax, %rdi
callq 0x1c84c
leaq 0x4(%rsp), %r12
andl $0x0, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8be4
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x9948
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
movq 0x3db7e6(%rip), %r13    # 0x3e4fc8
movl %ebp, 0x4(%rsp)
andl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8be4
movq %rax, %rdi
callq 0x1ac18
cmpl %eax, %ebp
jae 0x990e
andl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8be4
movq %rax, %rdi
movq %r12, %rsi
callq 0x1ab66
movq %rax, %r14
movl (%r12), %ebp
incl %ebp
movl %ebp, 0xc(%rsp)
andl $0x0, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x8be4
movq %rax, %rdi
callq 0x1ac18
cmpl %eax, %ebp
jae 0x98fe
andl $0x0, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x8be4
movq %rax, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %rbp
movq (%r13), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r13,%rcx), %edx
movl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
andl %esi, %edx
orl $0x4, %edx
movl %edx, 0x18(%r13,%rcx)
movq -0x18(%rax), %rcx
movq $0x9, 0x10(%r13,%rcx)
movq -0x18(%rax), %rcx
movl 0x18(%r13,%rcx), %edx
movl $0xffffff4f, %esi       # imm = 0xFFFFFF4F
andl %esi, %edx
orl $0x80, %edx
movl %edx, 0x18(%r13,%rcx)
movq -0x18(%rax), %rax
movq $0x3, 0x8(%r13,%rax)
movq %r14, %rdi
callq 0xea8c
movl (%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0xc8f8
movq %rax, %r12
movq %rbp, %rdi
callq 0xea8c
movl (%rax), %esi
movq %r12, %rdi
callq 0xc916
movsd (%rax), %xmm0
movq %r13, %rdi
callq 0x44d0
movq %r15, %r12
jmp 0x9824
movl 0x4(%rsp), %ebp
incl %ebp
leaq 0x4(%rsp), %r12
jmp 0x97e2
leaq 0x10(%rsp), %rdi
callq 0xc78a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9933
jmp 0x9933
jmp 0x9933
jmp 0x9933
jmp 0x9933
jmp 0x9933
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc78a
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeAverage::postAnalysis()
void AnalyzeAverage::postAnalysis(){
  unsigned int i;
  Atom *atm;

  std::cout << std::fixed;
  for(i=0; i< this->getMol(1)->getNAtomSelected(); i++){
    atm=this->getMol(1)->getAtom(i);
    if (atm->getSel() == false){
      continue;
    }
    atm->setCoor(atm->getCoor()/getNData());
  }
  this->getMol(1)->writePDB();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x3d92a4(%rip), %rax    # 0x3e4fc8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rax,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rax,%rcx)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movl %ebp, 0x4(%rsp)
movl $0x1, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8be4
movq %rax, %rdi
callq 0x1b756
cmpl %eax, %ebp
jae 0xbdc3
movl $0x1, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8be4
movq %rax, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %r12
movq %rax, %rdi
callq 0xea64
cmpb $0x0, (%rax)
je 0xbdbb
movq %r12, %rdi
callq 0xea3c
cvtsi2sdl 0x68(%rbx), %xmm0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2c178
movq %r12, %rdi
movq %r14, %rsi
callq 0xee3e
movl 0x4(%rsp), %ebp
incl %ebp
jmp 0xbd47
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x8be4
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a226
movq %rbx, %rdi
callq 0x4170
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::reset()
void Atom::reset(){
  tag="NoID";
  recname="ATOM";
  atmnum=0;
  atmname="    ";
  atmtype="  ";
  alt=" ";
  res=NULL;
  resname="   ";
  chn=NULL;
  chainid=" ";
  realid=" ";
  resid=0;
  coor=Coor(0.0, 0.0, 0.0);
  occu=0.0;
  bfac=0.0;
  elem=" ";
  segid="  ";
  sel=true;
  summary="";
  ss="";
  mass=1.0;
  charge=0.0;
  data.clear();
  bonds.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1ef42(%rip), %rsi     # 0x2d62b
callq 0x45c0
leaq 0x20(%rbx), %rdi
leaq 0x1ef37(%rip), %rsi     # 0x2d630
callq 0x45c0
andl $0x0, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x1feb4(%rip), %rsi     # 0x2e5c1
callq 0x45c0
leaq 0x68(%rbx), %rdi
leaq 0x1fea6(%rip), %r14     # 0x2e5c3
movq %r14, %rsi
callq 0x45c0
leaq 0x88(%rbx), %rdi
leaq 0x1fe91(%rip), %r15     # 0x2e5c4
movq %r15, %rsi
callq 0x45c0
andq $0x0, 0xa8(%rbx)
leaq 0xb0(%rbx), %rdi
leaq 0x1fe71(%rip), %rsi     # 0x2e5c2
callq 0x45c0
andq $0x0, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
movq %r15, %rsi
callq 0x45c0
leaq 0xf8(%rbx), %rdi
movq %r15, %rsi
callq 0x45c0
andl $0x0, 0x118(%rbx)
movq %rsp, %r12
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x2bf40
leaq 0x140(%rbx), %rdi
movq %r12, %rsi
callq 0x2bf62
leaq 0x1e0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq %r15, %rsi
callq 0x45c0
leaq 0x168(%rbx), %rdi
movq %r14, %rsi
callq 0x45c0
movb $0x1, 0x188(%rbx)
leaq 0x190(%rbx), %rdi
leaq 0x1ecb3(%rip), %r14     # 0x2d496
movq %r14, %rsi
callq 0x45c0
leaq 0x1b0(%rbx), %rdi
movq %r14, %rsi
callq 0x45c0
movsd 0x1ec4e(%rip), %xmm0    # 0x2d450
movups %xmm0, 0x1d0(%rbx)
movq 0x208(%rbx), %rax
cmpq %rax, 0x210(%rbx)
je 0xe820
movq %rax, 0x210(%rbx)
movq 0x220(%rbx), %rax
cmpq %rax, 0x228(%rbx)
je 0xe837
movq %rax, 0x228(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::clone(Atom*)
void Atom::clone(Atom* atmin){
  tag=atmin->getTag();
  recname=atmin->getRecName();
  atmnum=atmin->getAtmNum();
  atmname=atmin->getAtmName();
  atmtype=atmin->getAtmType();
  alt=atmin->getAlt();
  res=atmin->getResidue();
  resname=atmin->getResName();
  chn=atmin->getChain();
  chainid=atmin->getChainId();
  realid=atmin->getRealId();
  resid=atmin->getResId();
  icode=atmin->getICode();
  coor=atmin->getCoor();
  occu=atmin->getOccu();
  bfac=atmin->getBFac();
  elem=atmin->getElem();
  segid=atmin->getSegId();
  sel=atmin->getSel();
  summary=atmin->getSummary();
  ss=atmin->getSS();
  mass=atmin->getMass();
  charge=atmin->getCharge();
  atminx=atmin->getAtmInx();
  data=atmin->getData();
  bonds=atmin->getBonds();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x41a0
leaq 0x20(%rbx), %rsi
leaq 0x20(%r14), %rdi
callq 0x41a0
movl 0x40(%rbx), %eax
movl %eax, 0x40(%r14)
leaq 0x48(%rbx), %rsi
leaq 0x48(%r14), %rdi
callq 0x41a0
leaq 0x68(%rbx), %rsi
leaq 0x68(%r14), %rdi
callq 0x41a0
movl $0x88, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movq 0xa8(%rbx), %rax
movq %rax, 0xa8(%r14)
movl $0xb0, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movq 0xd0(%rbx), %rax
movq %rax, 0xd0(%r14)
movl $0xd8, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movl $0xf8, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movl 0x118(%rbx), %eax
movl %eax, 0x118(%r14)
movl $0x120, %edi            # imm = 0x120
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movl $0x140, %edi            # imm = 0x140
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x2bf62
movsd 0x158(%rbx), %xmm0
movsd %xmm0, 0x158(%r14)
movsd 0x160(%rbx), %xmm0
movsd %xmm0, 0x160(%r14)
movl $0x1e0, %edi            # imm = 0x1E0
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movl $0x168, %edi            # imm = 0x168
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movb 0x188(%rbx), %al
movb %al, 0x188(%r14)
movl $0x190, %edi            # imm = 0x190
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movl $0x1b0, %edi            # imm = 0x1B0
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x41a0
movsd 0x1d0(%rbx), %xmm0
movsd %xmm0, 0x1d0(%r14)
movsd 0x1d8(%rbx), %xmm0
movsd %xmm0, 0x1d8(%r14)
movl 0x200(%rbx), %eax
movl %eax, 0x200(%r14)
movl $0x208, %edi            # imm = 0x208
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0xca9c
movl $0x220, %eax            # imm = 0x220
addq %rax, %rbx
addq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xef2c
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::dummy()
void Atom::dummy(){
  tag="NoID";
  recname="ATOM";
  atmnum=1;
  atmname="CA";
  atmtype="C.3";
  alt=" ";
  res=NULL;
  resname="ALA";
  chn=NULL;
  chainid="+";
  realid="+";
  resid=999;
  coor=Coor(0.0, 0.0, 0.0);
  occu=0.0;
  bfac=0.0;
  elem=" ";
  segid="DUMY";
  sel=true;
  summary="";
  ss="";
  mass=1.0;
  charge=0.0;
  atminx=std::numeric_limits<unsigned int>::max();
  data.clear();
  bonds.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x1eb74(%rip), %rsi     # 0x2d62b
callq 0x45c0
leaq 0x20(%rbx), %rdi
leaq 0x1eb69(%rip), %rsi     # 0x2d630
callq 0x45c0
movl $0x1, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x1e79f(%rip), %rsi     # 0x2d27d
callq 0x45c0
leaq 0x68(%rbx), %rdi
leaq 0x1eb47(%rip), %rsi     # 0x2d635
callq 0x45c0
leaq 0x88(%rbx), %rdi
leaq 0x1fac3(%rip), %r14     # 0x2e5c4
movq %r14, %rsi
callq 0x45c0
andq $0x0, 0xa8(%rbx)
leaq 0xb0(%rbx), %rdi
leaq 0x1ecbe(%rip), %rsi     # 0x2d7dd
callq 0x45c0
andq $0x0, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
leaq 0x1eaff(%rip), %r15     # 0x2d639
movq %r15, %rsi
callq 0x45c0
leaq 0xf8(%rbx), %rdi
movq %r15, %rsi
callq 0x45c0
movl $0x3e7, 0x118(%rbx)     # imm = 0x3E7
leaq 0x8(%rsp), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x2bf40
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x2bf62
leaq 0x1e0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq %r14, %rsi
callq 0x45c0
leaq 0x168(%rbx), %rdi
leaq 0x1ea94(%rip), %rsi     # 0x2d63b
callq 0x45c0
movb $0x1, 0x188(%rbx)
leaq 0x190(%rbx), %rdi
leaq 0x1e8d5(%rip), %r14     # 0x2d496
movq %r14, %rsi
callq 0x45c0
leaq 0x1b0(%rbx), %rdi
movq %r14, %rsi
callq 0x45c0
movsd 0x1e870(%rip), %xmm0    # 0x2d450
movups %xmm0, 0x1d0(%rbx)
orl $-0x1, 0x200(%rbx)
movq 0x208(%rbx), %rax
cmpq %rax, 0x210(%rbx)
je 0xec05
movq %rax, 0x210(%rbx)
movq 0x220(%rbx), %rax
cmpq %rax, 0x228(%rbx)
je 0xec1c
movq %rax, 0x228(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::CASA(Molecule*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
CASA::CASA (Molecule *mol, const std::string fparmfile, const std::string freffile, const std::string fsasa){
    this->initializeAminoAcids();        
    this->initializeHist();

    /* load SASA info from file */
    if (fsasa.length() > 0){
      this->loadSASAFile(fsasa);
    }
    /* load parameters */
    if (fparmfile.length() > 0){
      this->loadParmFile(fparmfile);
    } 
    else {
    	this->initializeSASACoef();
    }
    /* load reference SASA */
    if (freffile.length() > 0){
      this->loadRefFile(freffile);
    }
    else {
    	this->initializeRefSASA();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rax
andl $0x0, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x50(%rdi), %rax
andl $0x0, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movq %rax, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
leaq 0x80(%rdi), %rax
andl $0x0, 0x80(%rdi)
andq $0x0, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movq %rax, 0x98(%rdi)
andq $0x0, 0xa0(%rdi)
leaq 0xb0(%rdi), %rax
andl $0x0, 0xb0(%rdi)
andq $0x0, 0xb8(%rdi)
movq %rax, 0xc0(%rdi)
movq %rax, 0xc8(%rdi)
andq $0x0, 0xd0(%rdi)
callq 0xf3c0
movq %rbx, %rdi
callq 0xf7d6
cmpq $0x0, 0x8(%r12)
je 0xf2e9
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x4430
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf854
leaq 0x40(%rsp), %rdi
callq 0x4170
cmpq $0x0, 0x8(%r15)
je 0xf316
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x4430
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xfc0c
leaq 0x20(%rsp), %rdi
callq 0x4170
jmp 0xf31e
movq %rbx, %rdi
callq 0xfec4
cmpq $0x0, 0x8(%r14)
je 0xf345
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4430
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1622a
movq %rsp, %rdi
callq 0x4170
jmp 0xf34d
movq %rbx, %rdi
callq 0x164e2
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
jmp 0xf375
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0xf375
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4170
jmp 0xf37f
movq %rax, %r14
leaq 0xa8(%rbx), %rdi
leaq 0x78(%rbx), %r15
leaq 0x48(%rbx), %r12
leaq 0x18(%rbx), %r13
callq 0x171a6
movq %r15, %rdi
callq 0x171a6
movq %r12, %rdi
callq 0x171a6
movq %r13, %rdi
callq 0x171a6
movq %rbx, %rdi
callq 0x59a0
movq %r14, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::setHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
void CASA::setHist(const std::string &key, const double &val){
    if (this->hist.find (key) != this->hist.end()){
      this->hist.at(key) = val;
    } else {
      this->hist.insert(std::pair<std::string, double>(key, val));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x1769c
subq $-0x80, %r12
cmpq %r12, %rax
je 0x16a1b
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x170f6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x16a43
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1713c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x174a0
leaq 0x10(%rsp), %rdi
callq 0x4170
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::accumHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
void CASA::accumHist(const std::string &key, const double &val){
    if (this->hist.find (key) != this->hist.end()){
      this->hist.at(key) += val;
    } else {
      this->hist.insert(std::pair<std::string, double>(key, val));
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x1769c
subq $-0x80, %r12
cmpq %r12, %rax
je 0x16ab3
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x170f6
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x16adb
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1713c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x174a0
leaq 0x10(%rsp), %rdi
callq 0x4170
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::predictHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::predictHist(const std::string &resname){
  double predSASA = 0.0;
  std::string res = "";
  std::string key = "";
  for (unsigned int i=0; i< this->aminoAcids.size(); i++){
    res = this->aminoAcids.at(i);
    key = resname+":"+res;
    predSASA += this->sasaCoef.at(key)*this->hist.at(res);
  }
  return(predSASA);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
leaq 0x1697a(%rip), %rbx     # 0x2d496
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0x58d8
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rdx
movq %rbx, %rsi
callq 0x58d8
leaq 0x48(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%r14), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x48(%rsp), %rbp
leaq 0x68(%rsp), %rbx
leaq 0x88(%rsp), %r15
leaq 0x28(%rsp), %r12
movl %r13d, %r13d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x16c26
movq %r14, %rdi
movq %r13, %rsi
callq 0x5914
movq %rbp, %rdi
movq %rax, %rsi
callq 0x41a0
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
leaq 0x1667f(%rip), %rdx     # 0x2d233
callq 0xc97d
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x1715d
movq %r12, %rdi
movq %r15, %rsi
callq 0x4390
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4170
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x170f6
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x170f6
movsd 0x20(%rsp), %xmm1
mulsd (%rax), %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
incl %r13d
jmp 0x16b78
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
movsd (%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x16c74
jmp 0x16c67
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4170
jmp 0x16c6a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4170
leaq 0x48(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getRefSASA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getRefSASA(const std::string &key){
    if (this->refSASA.find (key) == this->refSASA.end()){
        return 0.0;
    } else {
        return (this->refSASA.at(key));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x1769c
addq $0x20, %r15
cmpq %r15, %rax
je 0x16d93
movq %r14, %rdi
movq %rbx, %rsi
callq 0x170f6
movsd (%rax), %xmm0
jmp 0x16d96
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4220
leaq 0x166cd(%rip), %rsi     # 0x2d496
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x58d8
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4470
leaq 0x10(%rsp), %rdi
callq 0x4170
leaq 0x40(%rsp), %r13
leaq 0x18(%r15), %rbp
xorl %r12d, %r12d
leaq 0x1674e(%rip), %rbx     # 0x2d552
movl %r12d, %r12d
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x16e64
movq %r15, %rdi
movq %r12, %rsi
callq 0x5914
movq %rax, %rdi
movq %r14, %rsi
callq 0x1717c
movl %eax, %ecx
movq %r13, %rax
movq %rbx, %rsi
testb %cl, %cl
je 0x16e57
movq %rbp, %rdi
movq %r14, %rsi
callq 0x170f6
movsd (%rax), %xmm0
movq %r13, %rdi
callq 0x44d0
leaq 0x1776d(%rip), %rsi     # 0x2e5c4
movq %rax, %rdi
callq 0x4300
incl %r12d
jmp 0x16e04
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x44a0
leaq 0x30(%rsp), %rdi
callq 0x4260
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16ea8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
jmp 0x16eab
jmp 0x16ea8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4220
leaq 0x165ae(%rip), %rsi     # 0x2d496
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x58d8
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4470
leaq 0x10(%rsp), %rdi
callq 0x4170
xorl %r12d, %r12d
leaq 0x40(%rsp), %r13
leaq 0x173ea(%rip), %rbp     # 0x2e309
leaq 0x1769e(%rip), %r15     # 0x2e5c4
movl %r12d, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x16f6d
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4300
movq %rax, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5914
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x4300
incl %r12d
jmp 0x16f26
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x44a0
leaq 0x30(%rsp), %rdi
callq 0x4260
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16fb1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
jmp 0x16fb4
jmp 0x16fb1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1769c
addq $0x50, %r15
cmpq %r15, %rax
je 0x16ff7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x170f6
movsd (%rax), %xmm0
jmp 0x16ffa
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1769c
subq $-0x80, %r15
cmpq %r15, %rax
je 0x17031
movq %r14, %rdi
movq %rbx, %rsi
callq 0x170f6
movsd (%rax), %xmm0
jmp 0x17034
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1769c
addq $0xb0, %r15
cmpq %r15, %rax
je 0x17071
movq %r14, %rdi
movq %rbx, %rsi
callq 0x170f6
movsd (%rax), %xmm0
jmp 0x17074
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %esi
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x177ff
pushq %rax
addq $0x18, %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/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), %esi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x17822
pushq %rax
callq 0x1792e
movq (%rax), %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::selAll()
void Chain::selAll(){
//  sel=true;
  unsigned int i;
//  for (i=0; i< this->getResVecSize(); i++){
//    this->getResidue(i)->setSel(true);
//  }
  for (i=0; i< this->getAtmVecSize(); i++){
    this->getAtom(i)->setSel(true);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x4(%rsp), %r14
pushq $0x1
popq %rbp
movl %r15d, 0x4(%rsp)
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %r15d
jae 0x178bd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x177da
movq %rax, %rdi
movl %ebp, %esi
callq 0xee92
incl %r15d
jmp 0x1788d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::deselAll()
void Chain::deselAll(){
//  sel=false;
  unsigned int i;
//  for (i=0; i< this->getResVecSize(); i++){
//    this->getResidue(i)->setSel(false);
//  }
  for (i=0; i< this->getAtmVecSize(); i++){
    this->getAtom(i)->setSel(false);
  }  
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0xc(%rsp), %r14
movl %ebp, 0xc(%rsp)
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jae 0x17907
movq %rbx, %rdi
movq %r14, %rsi
callq 0x177da
movq %rax, %rdi
xorl %esi, %esi
callq 0xee92
incl %ebp
jmp 0x178da
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17b53
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x17b14
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x17b14
leaq 0x20(%rbx), %rdi
callq 0x4170
pushq $0x40
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4330
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movsd %xmm0, (%rsp)
movq %rdi, %r12
movq 0x10(%rsi), %rbp
testq %rbp, %rbp
je 0x17bac
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4430
movq %r12, %rdi
movsd (%rsp), %xmm0
movq %rbp, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x17b54
leaq 0x28(%rsp), %rdi
callq 0x4170
jmp 0x17be8
pushq $0x40
popq %rdi
callq 0x4320
leaq 0x30(%rax), %rcx
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
leaq 0x20(%rax), %rdi
movb $0x0, 0x30(%rax)
movq %rax, 0x10(%r15)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, %rsi
callq 0x41a0
movq 0x18(%r15), %rbp
testq %rbp, %rbp
je 0x17c22
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4430
movq %r12, %rdi
movsd (%rsp), %xmm0
movq %rbp, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x17b54
leaq 0x8(%rsp), %rdi
callq 0x4170
jmp 0x17c5e
pushq $0x40
popq %rdi
callq 0x4320
leaq 0x30(%rax), %rcx
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
leaq 0x20(%rax), %rdi
movb $0x0, 0x30(%rax)
movq %rax, 0x18(%r15)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, %rsi
callq 0x41a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17c6f
movq %rax, %rbx
movq %r13, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %rdx
testq %rax, %rax
je 0x17fab
testq %rdx, %rdx
movq %rax, %rdx
je 0x17f60
movl 0x8(%r15), %esi
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x17fe5
movq %r12, %rdi
callq 0x18520
movsd (%r15), %xmm0
xorl %ecx, %ecx
ucomisd (%rax), %xmm0
setb %cl
movq 0x10(%r15,%rcx,8), %rdx
jmp 0x17f60
testq %rdx, %rdx
jne 0x17f60
addq $0x20, %r15
cmpl $0x0, 0x30(%r14)
je 0x18031
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4430
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x18064
leaq 0x8(%rsp), %rdi
callq 0x4170
jmp 0x1803c
movq 0x3cd004(%rip), %rdi    # 0x3e4ff0
leaq 0x16363(%rip), %rsi     # 0x2e356
callq 0x4300
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x4200
leaq 0x1636a(%rip), %rsi     # 0x2e375
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x15474(%rip), %rsi     # 0x2d496
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x58d8
jmp 0x1803c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18874
addq $0x10, %r12
cmpq %r12, %rax
je 0x180a5
movq %r15, %rdi
movq %r14, %rsi
callq 0x1858e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4430
jmp 0x180ee
movq 0x3ccf44(%rip), %rdi    # 0x3e4ff0
leaq 0x162c7(%rip), %rsi     # 0x2e37a
callq 0x4300
movq %rax, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0x1634e(%rip), %rsi     # 0x2e418
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x153b5(%rip), %rsi     # 0x2d496
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x58d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r15
movq (%rdi), %r12
testq %r12, %r12
je 0x1815f
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4430
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %r12, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x17b54
leaq 0x10(%rsp), %rdi
callq 0x4170
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x40
popq %rdi
callq 0x4320
leaq 0x20(%rax), %rdi
leaq 0x30(%rax), %rcx
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movq %rax, (%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, %rsi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x41a0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x184a7
movq %rbx, %rdi
callq 0x17f4c
jmp 0x184bb
leaq 0x15eca(%rip), %rsi     # 0x2e378
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x58d8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::splitStr(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::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>>>>&, bool)
void Misc::splitStr (const std::string &str, const std::string &delim, std::vector<std::string> &out, const bool repeat){
  size_t p0=0;
  size_t p1=std::string::npos;
  size_t plast=std::string::npos;
  out.clear();

  //"repeat" = true means that a blank string is added when there are
  //back-to-back delimiters. Otherwise, repeat=false ignores back-to-back delimiters.

  plast=str.find_last_not_of(delim);
  p1=str.find_first_of(delim,p0);

  while (p1 != std::string::npos){
    if (p1-p0 > 0){
      out.push_back(str.substr(p0,p1-p0));
    }
    else{
      if (repeat){
        out.push_back(str.substr(p0,p1-p0));
      }
    }
    p0=p1+1;
    p1=str.find_first_of(delim, p0);
  }
  //After last delimiter
  if (plast != std::string::npos && plast >= p0 ){
    out.push_back(str.substr(p0,p1-p0));
  }
  else{
    if (repeat){
      out.push_back(str.substr(p0,p1-p0));
    }
  }
  //std::cerr << out.size() << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x58a4
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x45a0
movq %rax, 0x30(%rsp)
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x42d0
movq %rax, %r13
leaq 0x10(%rsp), %r12
cmpq $-0x1, %r13
je 0x189b5
movq %r13, %rcx
subq %rbp, %rcx
jne 0x1897b
cmpb $0x0, 0xc(%rsp)
je 0x1899c
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x4340
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1720a
jmp 0x18994
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x4340
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1720a
movq %r12, %rdi
callq 0x4170
incq %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x42d0
movq %r13, %rbp
movq %rax, %r13
jmp 0x18949
movq 0x30(%rsp), %rcx
cmpq $-0x1, %rcx
sete %al
cmpq %rbp, %rcx
setb %cl
orb %al, %cl
je 0x189f8
cmpb $0x0, 0xc(%rsp)
je 0x18a26
movq %rbp, %rcx
notq %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x4340
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1720a
jmp 0x18a1c
movq %rbp, %rcx
notq %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x4340
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1720a
leaq 0x10(%rsp), %rdi
callq 0x4170
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18a3b
jmp 0x18a3b
jmp 0x18a3b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x41a0
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4600
cmpq $-0x1, %rax
je 0x18ab5
movq %rax, %r12
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x4130
addq 0x8(%r14), %r12
subq 0x8(%r15), %r12
incq %r12
testb %bpl, %bpl
jne 0x18a7c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18ac3
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::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 (%rdi), %rax
movq 0x8(%rdi), %rdx
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
cmpq %r8, %rdx
jbe 0x18b2a
movzbl (%rax,%r8), %r8d
leal -0x30(%r8), %r9d
cmpl $0xa, %r9d
jae 0x18b16
incl %edi
jmp 0x18afb
cmpl $0x2e, %r8d
je 0x18b26
movl %edi, %esi
cmpl $0x2d, %r8d
je 0x18b12
jmp 0x18b38
incl %ecx
jmp 0x18b12
cmpl $0x2, %ecx
setb %cl
testl %esi, %esi
sete %al
andb %cl, %al
retq
xorl %eax, %eax
retq
nop