LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rdi), %rdx
leaq 0x270f6(%rip), %rcx     # 0x3b64b
xorl %r12d, %r12d
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x270dc(%rip), %rcx     # 0x3b650
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
movl %r12d, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rdx
leaq 0x280e9(%rip), %rcx     # 0x3c67d
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rdx
leaq 0x280cf(%rip), %r14     # 0x3c67f
movl $0x2, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
leaq 0x88(%rbx), %rdi
movq 0x90(%rbx), %rdx
leaq 0x280ab(%rip), %r15     # 0x3c680
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
movq %r12, 0xa8(%rbx)
leaq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rdx
leaq 0x2807d(%rip), %rcx     # 0x3c67e
movl $0x3, %r8d
xorl %esi, %esi
callq 0x4470
movq %r12, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
leaq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
movl %r12d, 0x118(%rbx)
movq %rsp, %r12
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x39fe4
leaq 0x140(%rbx), %rdi
movq %r12, %rsi
callq 0x3a006
leaq 0x1e0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq 0x1e8(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
leaq 0x168(%rbx), %rdi
movq 0x170(%rbx), %rdx
movl $0x2, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
movb $0x1, 0x188(%rbx)
leaq 0x190(%rbx), %rdi
movq 0x198(%rbx), %rdx
leaq 0x26dd9(%rip), %r14     # 0x3b4b6
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
leaq 0x1b0(%rbx), %rdi
movq 0x1b8(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
movsd 0x26d43(%rip), %xmm0    # 0x3b450
movups %xmm0, 0x1d0(%rbx)
movq 0x208(%rbx), %rax
cmpq %rax, 0x210(%rbx)
je 0x1472b
movq %rax, 0x210(%rbx)
movq 0x220(%rbx), %rax
cmpq %rax, 0x228(%rbx)
je 0x14742
movq %rax, 0x228(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rdi), %rdx
leaq 0x26c86(%rip), %rcx     # 0x3b64b
xorl %r15d, %r15d
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x26c6c(%rip), %rcx     # 0x3b650
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
movl $0x1, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rdx
leaq 0x26876(%rip), %rcx     # 0x3b27d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rdx
leaq 0x26c32(%rip), %rcx     # 0x3b655
movl $0x3, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x88(%rbx), %rdi
movq 0x90(%rbx), %rdx
leaq 0x27c3b(%rip), %r14     # 0x3c680
movl $0x1, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
movq %r15, 0xa8(%rbx)
leaq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rdx
leaq 0x26d8c(%rip), %rcx     # 0x3b7fd
movl $0x3, %r8d
xorl %esi, %esi
callq 0x4470
movq %r15, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
leaq 0x26bbf(%rip), %r15     # 0x3b659
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
leaq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
movl $0x3e7, 0x118(%rbx)     # imm = 0x3E7
leaq 0x8(%rsp), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x39fe4
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x3a006
leaq 0x1e0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq 0x1e8(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
leaq 0x168(%rbx), %rdi
movq 0x170(%rbx), %rdx
leaq 0x26b27(%rip), %rcx     # 0x3b65b
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
movb $0x1, 0x188(%rbx)
leaq 0x190(%rbx), %rdi
movq 0x198(%rbx), %rdx
leaq 0x26959(%rip), %r14     # 0x3b4b6
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
leaq 0x1b0(%rbx), %rdi
movq 0x1b8(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
movsd 0x268c3(%rip), %xmm0    # 0x3b450
movups %xmm0, 0x1d0(%rbx)
movl $0xffffffff, 0x200(%rbx) # imm = 0xFFFFFFFF
movq 0x208(%rbx), %rax
cmpq %rax, 0x210(%rbx)
je 0x14bb5
movq %rax, 0x210(%rbx)
movq 0x220(%rbx), %rax
cmpq %rax, 0x228(%rbx)
je 0x14bcc
movq %rax, 0x228(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x202fc
subq $-0x80, %r12
cmpq %r12, %rax
je 0x1f30d
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fc3e
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x1f35b
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x647c
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2012e
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f35b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f381
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x202fc
subq $-0x80, %r12
cmpq %r12, %rax
je 0x1f3d9
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fc3e
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x1f427
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x647c
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2012e
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f427
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f44d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x202fc
addq $0x20, %r15
cmpq %r15, %rax
je 0x1f821
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fc3e
movsd (%rax), %xmm0
jmp 0x1f824
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::printRefSASAVec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CASA::printRefSASAVec(const std::string &key){    
    std::stringstream s;
    s.str("");
    for (unsigned int i=0; i< this->aminoAcids.size(); i++){
    	if (this->aminoAcids.at(i) == key){
    		 s << this->refSASA.at(key) << " ";
    	}
    	else {
    		s << "0.0 ";
    	}
    }
    return(s.str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4210
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1bc57(%rip), %rdx     # 0x3b4b6
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6512
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4430
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f896
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x1f945
leaq 0x40(%rsp), %r13
leaq 0x18(%r15), %rcx
movq %rcx, 0x8(%rsp)
movl $0x1, %ebx
xorl %ecx, %ecx
leaq 0x1bcb3(%rip), %rbp     # 0x3b572
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rdx
movl $0x4, %r12d
cmpq 0x8(%r14), %rdx
jne 0x1f91c
testq %rdx, %rdx
je 0x1f8f1
addq %rcx, %rax
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x42f0
movq %r13, %rdi
movq %rbp, %rsi
testl %eax, %eax
jne 0x1f922
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1fc3e
movsd (%rax), %xmm0
movq %r13, %rdi
callq 0x44a0
movq %rax, %rdi
movl $0x1, %r12d
leaq 0x1cd66(%rip), %rsi     # 0x3c680
jmp 0x1f922
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x4340
movl %ebx, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebx
cmpq %rcx, %rdx
ja 0x1f8bf
movq (%rsp), %rbx
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x4480
movq 0x3d064b(%rip), %rsi    # 0x3effa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f9a9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f9ac
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x1f9ac
jmp 0x1f9a9
movq %rax, %rbx
movq 0x3d05f5(%rip), %rsi    # 0x3effa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::printRefSASAVecHeader[abi:cxx11]()
std::string CASA::printRefSASAVecHeader(){    
	std::stringstream s;
	s.str("");
	for (unsigned int i=0; i< this->aminoAcids.size(); i++){
		s << "RefSASA_" << aminoAcids.at(i) << " ";
	}
	return(s.str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4210
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bab1(%rip), %rdx     # 0x3b4b6
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6512
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4430
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fa38
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x1fab9
movl $0x1, %ebx
leaq 0x40(%rsp), %r12
xorl %r15d, %r15d
leaq 0x1c8d4(%rip), %r13     # 0x3c329
leaq 0x1cc24(%rip), %rbp     # 0x3c680
movl $0x8, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x4340
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x1fafe
shlq $0x5, %r15
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
movq %r12, %rdi
callq 0x4340
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4340
movq 0x8(%r14), %rax
subq (%r14), %rax
movl %ebx, %r15d
sarq $0x5, %rax
incl %ebx
cmpq %r15, %rax
ja 0x1fa5c
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x4480
movq 0x3d04d6(%rip), %rsi    # 0x3effa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b824(%rip), %rdi     # 0x3b329
movq %r15, %rsi
xorl %eax, %eax
callq 0x4440
jmp 0x1fb31
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fb34
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x1fb34
jmp 0x1fb31
jmp 0x1fb31
movq %rax, %rbx
movq 0x3d046d(%rip), %rsi    # 0x3effa8
leaq 0x30(%rsp), %rdi
callq 0x4240
leaq 0xb0(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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 0x202fc
addq $0x50, %r15
cmpq %r15, %rax
je 0x1fb8b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fc3e
movsd (%rax), %xmm0
jmp 0x1fb8e
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x202fc
subq $-0x80, %r15
cmpq %r15, %rax
je 0x1fbc5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fc3e
movsd (%rax), %xmm0
jmp 0x1fbc8
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x202fc
addq $0xb0, %r15
cmpq %r15, %rax
je 0x1fc05
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fc3e
movsd (%rax), %xmm0
jmp 0x1fc08
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::getAtom(unsigned int const&)
Atom* Chain::getAtom (const unsigned int& element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

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

// Assembly:
movl (%rsi), %eax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x204a0
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2075e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x2070e
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2070e
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x2074a
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movl $0x40, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42e0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::addDTree(double, DTreeNode*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DTree::addDTree(double key, DTreeNode *node, unsigned int index, std::string classin){
  if (node->left != NULL){
    addDTree(key, node->left, index, classin);
  }
  else{
    node->left=new DTreeNode;
    node->left->key_value=key;
    node->left->inx=index;
    node->left->left=NULL; //Sets left child of child node to NULL
    node->left->right=NULL; //Sets right child of child node to NULL
    node->left->leaf=classin; //The class of this node node
  }
  if (node->right != NULL){
    addDTree(key, node->right, index, classin);
  }
  else{
    node->right=new DTreeNode;
    node->right->key_value=key;
    node->right->inx=index;
    node->right->left=NULL; //Sets left child of child node to NULL
    node->right->right=NULL; //Sets right child of child node to NULL
    node->right->leaf=classin; //The class of this node node
  }
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rdx, %r15
movq 0x10(%rdx), %rdx
movq 0x18(%r15), %rsi
testq %rdx, %rdx
je 0x20d81
testq %rsi, %rsi
je 0x20d4f
movl 0x8(%r15), %edi
cmpq %rdi, %rcx
jbe 0x20de4
movsd (%r15), %xmm0
ucomisd (%rax,%rdi,8), %xmm0
jb 0x20d7c
movq %rdx, %rsi
movq %rsi, %rdx
jmp 0x20d4f
movq %rsi, %rdx
testq %rsi, %rsi
jne 0x20d4f
cmpl $0x0, 0x30(%r14)
je 0x20e64
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x647c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20eb4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x20e7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x20e7e
movq 0x3cf205(%rip), %r14    # 0x3efff0
leaq 0x1b584(%rip), %rsi     # 0x3c376
movl $0x1e, %edx
movq %r14, %rdi
callq 0x4340
movl 0x8(%r15), %esi
movq %r14, %rdi
callq 0x41e0
movq %rax, %r14
leaq 0x1b580(%rip), %rsi     # 0x3c395
movl $0x2, %edx
movq %rax, %rdi
callq 0x4340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a65f(%rip), %rdx     # 0x3b4b6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6512
jmp 0x20e7e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x647c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x20ea7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2190a
addq $0x10, %r12
cmpq %r12, %rax
je 0x20f06
movq %r15, %rdi
movq %r14, %rsi
callq 0x215c6
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x647c
jmp 0x20f87
movq 0x3cf0e3(%rip), %r15    # 0x3efff0
leaq 0x1b486(%rip), %rsi     # 0x3c39a
movl $0x23, %edx
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4340
movq %rax, %r14
leaq 0x1b556(%rip), %rsi     # 0x3c490
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a53a(%rip), %rdx     # 0x3b4b6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6512
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::addDTree(double, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DTree::addDTree(double key, unsigned int index, std::string classin){
  //Public version of the addDTree function
  //Takes care of when the root node has not been initialized
  if (root != NULL){
    addDTree(key, root, index, classin);
  }
  else{
    root=new DTreeNode;
    root->key_value=key;
    root->inx=index;
    root->left=NULL;
    root->right=NULL;
    root->leaf=classin;
  }
}

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

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x21481
movq %rbx, %rdi
callq 0x20d30
jmp 0x2149e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1af09(%rip), %rsi     # 0x3c398
leaq 0x1af03(%rip), %rdx     # 0x3c399
movq %rbx, %rdi
callq 0x6512
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
std::string Misc::replace (const std::string &str, const std::string searchStr, const std::string replaceStr, const bool globalFlag){
  std::string out;

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

  return out;
}

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

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

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x21c66
movq (%rdi), %rcx
xorl %r8d, %r8d
movl $0x1, %edx
xorl %edi, %edi
xorl %esi, %esi
movzbl (%rcx,%r8), %r8d
leal -0x30(%r8), %r9d
cmpl $0xa, %r9d
jae 0x21c43
movl %edx, %r8d
incl %edx
cmpq %r8, %rax
ja 0x21c28
jmp 0x21c58
cmpl $0x2e, %r8d
je 0x21c54
cmpl $0x2d, %r8d
jne 0x21c69
leal -0x1(%rdx), %edi
jmp 0x21c37
incl %esi
jmp 0x21c37
cmpl $0x2, %esi
setb %cl
testl %edi, %edi
sete %al
andb %cl, %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a725(%rip), %rsi     # 0x3c410
xorl %r14d, %r14d
movl $0xb, %ecx
xorl %edx, %edx
callq 0x44e0
cmpq $-0x1, %rax
je 0x21d09
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a70a(%rip), %rsi     # 0x3c41a
xorl %r14d, %r14d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4520
cmpq $-0x1, %rax
je 0x21d00
leaq 0x1a6eb(%rip), %rsi     # 0x3c41a
xorl %r14d, %r14d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x44e0
testq %rax, %rax
jne 0x21d00
leaq 0x1a6cd(%rip), %r14     # 0x3c41a
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
callq 0x44b0
movq %rax, %r15
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4520
cmpq %rax, %r15
setae %r14b
jmp 0x21d00
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Misc::trim (const std::string &str, const std::string t){
  std::string out=str;

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

  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x647c
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x44b0
movq 0x8(%rbx), %r8
cmpq $-0x1, %rax
je 0x21e08
leaq 0x1(%rax), %rdx
cmpq %rdx, %r8
je 0x21de3
cmpq %rax, %r8
jbe 0x21e28
movq %rdx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdx)
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x44e0
testq %rax, %rax
je 0x21e1f
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x40a0
jmp 0x21e1f
leaq 0x196a7(%rip), %rcx     # 0x3b4b6
movq %rbx, %rdi
xorl %esi, %esi
movq %r8, %rdx
xorl %r8d, %r8d
callq 0x4470
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a5ed(%rip), %rdi     # 0x3c41c
leaq 0x1a61d(%rip), %rsi     # 0x3c453
movq %r8, %rcx
xorl %eax, %eax
callq 0x4440
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x21e56
movq (%r15), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::processRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Misc::processRange (const std::string &start, const std::string &end){
  std::stringstream ss;
  int i, istart, iend;
  
  std::stringstream(start) >> istart;
  std::stringstream(end) >> iend;

  ss << istart;
  istart++;

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

  return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x318, %rsp            # imm = 0x318
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4210
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x18, %edx
callq 0x4490
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x41b0
movq 0x3ce100(%rip), %rsi    # 0x3effa8
leaq 0x8(%rsp), %rdi
callq 0x4240
leaq 0x88(%rsp), %rdi
callq 0x4110
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x18, %edx
callq 0x4490
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x41b0
movq 0x3ce0c1(%rip), %rsi    # 0x3effa8
leaq 0x8(%rsp), %rdi
callq 0x4240
leaq 0x88(%rsp), %rdi
callq 0x4110
leaq 0x1a0(%rsp), %r14
movl (%rsp), %esi
movq %r14, %rdi
callq 0x4500
movl (%rsp), %r15d
leal 0x1(%r15), %eax
movl %eax, (%rsp)
cmpl 0x4(%rsp), %r15d
jge 0x21f4f
leaq 0x1972f(%rip), %r12     # 0x3b659
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4340
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x4500
cmpl 0x4(%rsp), %r15d
jl 0x21f2a
leaq 0x1a8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4480
movq 0x3ce042(%rip), %rsi    # 0x3effa8
leaq 0x190(%rsp), %rdi
callq 0x4240
leaq 0x210(%rsp), %rdi
callq 0x4110
movq %rbx, %rax
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x21f96
jmp 0x21fbd
movq %rax, %rbx
movq 0x3ce008(%rip), %rsi    # 0x3effa8
leaq 0x8(%rsp), %rdi
callq 0x4240
leaq 0x88(%rsp), %rdi
callq 0x4110
jmp 0x21fc0
jmp 0x21fbd
jmp 0x21fbd
movq %rax, %rbx
movq 0x3cdfe1(%rip), %rsi    # 0x3effa8
leaq 0x190(%rsp), %rdi
callq 0x4240
leaq 0x210(%rsp), %rdi
callq 0x4110
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::atoi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int)
int Misc::atoi (std::string &str, const unsigned int offset){
  int val;
  const char *a;
  val=0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl %esi, %ebx
movq %rsp, %r13
movl $0x1, %ecx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4300
leaq 0x1a312(%rip), %rsi     # 0x3c3db
xorl %r15d, %r15d
movl $0x34, %ecx
movq %r13, %rdi
xorl %edx, %edx
callq 0x44e0
movq %rax, %r12
movq (%r13), %rdi
leaq 0x10(%rsp), %r13
cmpq %r13, %rdi
je 0x220f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq $-0x1, %r12
jne 0x22135
movq %rsp, %r15
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4300
movq (%r15), %rbx
cmpq %r13, %rbx
je 0x2212d
movq 0x10(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x42e0
movsbl (%rbx), %r15d
addl $-0x40, %r15d
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2215a
jnp 0x22176
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd 0x192e6(%rip), %xmm2    # 0x3b450
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
retq
ucomisd %xmm0, %xmm2
jne 0x2217e
jnp 0x22199
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd 0x192c2(%rip), %xmm1    # 0x3b450
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::Molecule()
Molecule::Molecule (){
  chnVec.clear();
  resVec.clear();
  atmVec.clear();
  copyFlag=false;
  storedSel.clear();
  remarks.clear();
  iCodeFlag=false;
  year=0;
  exp.clear();
  tag.clear();
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x236a7
movl %ecx, %ebp
movl %esi, %ebx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x647c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x647c
movzbl %bpl, %ecx
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movl %ebx, %esi
xorl %r8d, %r8d
callq 0x2a2fa
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x23685
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2369c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x23724
movq 0x3cc942(%rip), %rbx    # 0x3efff0
leaq 0x18dcb(%rip), %rsi     # 0x3c480
movl $0x11, %edx
movq %rbx, %rdi
callq 0x4340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x4340
movq %rax, %rbx
leaq 0x18db7(%rip), %rsi     # 0x3c492
movl $0x11, %edx
movq %rax, %rdi
callq 0x4340
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x41f0
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x42d0
movq %rax, %rbx
movq %rax, %rdi
callq 0x23410
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbx, %rdi
jmp 0x23771
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2375f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x2375f
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x23776
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::writePDB[abi:cxx11](bool, bool)
std::string Molecule::writePDB(bool selFlag, bool print){

  std::ostringstream out;

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x24a97
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x24a45
movq (%rax,%rbp,8), %r12
jmp 0x24a48
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x14916
movq %rax, %r13
movq %r12, %rdi
callq 0x14916
movq 0x8(%rax), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x43a0
testl %eax, %eax
jne 0x24a7b
movq %r12, %rdi
movq %rbx, %rsi
callq 0x14de8
incq %rbp
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %rbp
jb 0x24a36
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq