LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x47430
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x41e84
movq $0x0, 0x20(%rsp)
jmp 0x41ea2
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x47450
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movb %cl, %al
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq %rdx, 0x88(%rsp)
andb $0x1, %al
movb %al, 0x87(%rsp)
callq 0x5630
cmpq $0x0, %rax
jne 0x41fc0
movq 0x3f90b7(%rip), %rdi    # 0x43aff0
leaq 0x3a49c(%rip), %rsi     # 0x7c3dc
callq 0x53f0
movq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
leaq 0x3a492(%rip), %rsi     # 0x7c3ee
callq 0x53f0
movq %rax, %rdi
movq 0x3f903d(%rip), %rsi    # 0x43afa8
callq 0x5460
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x5410
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x41a20
jmp 0x41f8c
movq 0x10(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x4207d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl $0x1a0, %esi            # imm = 0x1A0
callq 0x5420
jmp 0x4208d
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x51b0
movq 0x18(%rsp), %rsi
movl 0x94(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x51b0
jmp 0x41feb
movl 0xc(%rsp), %esi
movzbl 0x87(%rsp), %ecx
andl $0x1, %ecx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
xorl %r8d, %r8d
callq 0x53c80
movq %rax, (%rsp)
jmp 0x42012
leaq 0x28(%rsp), %rdi
callq 0x5250
leaq 0x48(%rsp), %rdi
callq 0x5250
movq (%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x4207d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x42071
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5250
leaq 0x48(%rsp), %rdi
callq 0x5250
jmp 0x4208d
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x8(%rsp)
movb %cl, %al
movb %dl, %cl
movq %rdi, %rdx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
andb $0x1, %cl
movb %cl, 0x1d7(%rsp)
andb $0x1, %al
movb %al, 0x1d6(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x55d0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movzbl 0x1d7(%rsp), %edx
andl $0x1, %edx
callq 0x53050
jmp 0x421d3
movb 0x1d6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4223e
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5430
jmp 0x421f5
movq 0x3f8dbc(%rip), %rdi    # 0x43afb8
leaq 0x28(%rsp), %rsi
callq 0x5390
jmp 0x42208
leaq 0x28(%rsp), %rdi
callq 0x5250
jmp 0x4223e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x42266
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5250
jmp 0x42266
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5430
jmp 0x4224f
leaq 0x58(%rsp), %rdi
callq 0x5100
movq 0x10(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
leaq 0x58(%rsp), %rdi
callq 0x5100
movq 0x50(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::checkICode()
bool Molecule::checkICode(){
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    if (this->getAtom(i)->getICode().length() != 0 && this->getAtom(i)->getICode().compare(0,1," ") != 0){
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x42b59
movq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x43580
movq %rax, %rdi
callq 0x1f6c0
movq %rax, %rdi
callq 0x5630
cmpq $0x0, %rax
je 0x42b47
movq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x43580
movq %rax, %rdi
callq 0x1f6c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
leaq 0x39a62(%rip), %rcx     # 0x7c598
callq 0x55a0
cmpl $0x0, %eax
je 0x42b47
movb $0x1, 0x27(%rsp)
jmp 0x42b5e
jmp 0x42b49
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x42acb
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
addq $0x38, %rdi
callq 0x20600
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x435c4
movq $0x0, 0x20(%rsp)
jmp 0x435e2
movq (%rsp), %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x20620
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x436a2
movq 0x18(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x43580
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f5c0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f5c0
movq %rax, %rdi
callq 0x5630
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x38(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x5570
cmpl $0x0, %eax
jne 0x43690
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1fc90
jmp 0x43692
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x43615
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x437ad
movq 0x8(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x43580
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0x470d0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
callq 0x47100
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1f5c0
movq %rax, %rdx
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x47070
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x47100
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x47030
testb $0x1, %al
jne 0x4378c
jmp 0x4379b
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1fc90
jmp 0x4379d
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x436f5
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
callq 0x3a700
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x43c24
movq $0x0, 0x20(%rsp)
jmp 0x43c42
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x3a720
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x43d02
movq 0x18(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x43580
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f620
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f620
movq %rax, %rdi
callq 0x5630
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movq 0x38(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x5570
cmpl $0x0, %eax
jne 0x43cf0
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1fda0
jmp 0x43cf2
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x43c75
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::renameRes(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Molecule::renameRes(const std::vector<std::string> &search, const std::string &replace){
  for (unsigned int i=0; i< search.size(); i++){
    this->renameRes(search.at(i), replace);
  }
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    Atom *atm=this->getAtom(i);
    if (std::find(search.begin(), search.end(), atm->getResName()) != search.end()){
      atm->setResName(replace);
    }
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x78e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x43d84
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x47490
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x50(%rsp), %rdx
callq 0x43c50
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x43d35
movl $0x0, 0x48(%rsp)
movq 0x18(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x43e44
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x43580
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0x470d0
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
callq 0x47100
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1f620
movq %rax, %rdx
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x47070
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
callq 0x47100
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x47030
testb $0x1, %al
jne 0x43e23
jmp 0x43e32
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x1fda0
jmp 0x43e34
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x43d8c
addq $0x68, %rsp
retq
nopl (%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::readTopology(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void Molecule::readTopology(const std::string& topin, bool verboseFlag){
  this->toppar.readTopology(topin);
  this->setAtmType(verboseFlag);
  this->setMass(verboseFlag);
  this->setCharge(verboseFlag);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xb0, %rdi
movq 0x18(%rsp), %rsi
callq 0x58c00
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x43ec0
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x441b0
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x44470
addq $0x28, %rsp
retq
nop
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::setAtmType(bool)
void Molecule::setAtmType(bool verboseFlag){
  Atom* a;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    a=this->getAtom(i);
    a->setAtmType(this->toppar.getAtmType(Misc::trim(a->getResName()), Misc::trim(a->getAtmName()), verboseFlag));
  }
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movb %sil, %al
movq %rdi, 0x120(%rsp)
andb $0x1, %al
movb %al, 0x11f(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x10c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x10c(%rsp), %eax
movl %eax, 0x3c(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x3c(%rsp), %eax
cmpl %ecx, %eax
jae 0x44193
movq 0x40(%rsp), %rdi
leaq 0x10c(%rsp), %rsi
callq 0x43580
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x110(%rsp)
movq 0x110(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0xb0, %rax
movq %rax, 0x20(%rsp)
callq 0x1f620
movq %rax, 0x28(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5730
movq 0x30(%rsp), %rdx
leaq 0x38620(%rip), %rsi     # 0x7c598
leaq 0xa8(%rsp), %rdi
callq 0x7900
jmp 0x43f87
movq 0x28(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0x3dee0
jmp 0x43fa3
movq 0x110(%rsp), %rdi
callq 0x1f5c0
movq %rax, 0x10(%rsp)
jmp 0x43fb7
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5730
movq 0x8(%rsp), %rdx
leaq 0x385c6(%rip), %rsi     # 0x7c598
leaq 0x50(%rsp), %rdi
callq 0x7900
jmp 0x43fde
movq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x3dee0
jmp 0x43ff4
movq 0x20(%rsp), %rsi
movzbl 0x11f(%rsp), %r8d
andl $0x1, %r8d
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
leaq 0x70(%rsp), %rcx
callq 0x59c10
jmp 0x44022
movq 0x18(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x1fce0
jmp 0x44036
leaq 0xe8(%rsp), %rdi
callq 0x5250
leaq 0x70(%rsp), %rdi
callq 0x5250
leaq 0x50(%rsp), %rdi
callq 0x5250
leaq 0x4f(%rsp), %rdi
callq 0x5480
leaq 0xc8(%rsp), %rdi
callq 0x5250
leaq 0xa8(%rsp), %rdi
callq 0x5250
leaq 0xa7(%rsp), %rdi
callq 0x5480
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
jmp 0x43ef3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x44184
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x44177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4416a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x44160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x44156
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4414c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x5250
leaq 0x70(%rsp), %rdi
callq 0x5250
leaq 0x50(%rsp), %rdi
callq 0x5250
leaq 0x4f(%rsp), %rdi
callq 0x5480
leaq 0xc8(%rsp), %rdi
callq 0x5250
leaq 0xa8(%rsp), %rdi
callq 0x5250
leaq 0xa7(%rsp), %rdi
callq 0x5480
jmp 0x4419b
addq $0x128, %rsp            # imm = 0x128
retq
movq 0x98(%rsp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::setMass(bool)
void Molecule::setMass(bool verboseFlag){
  Atom* a;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    a=this->getAtom(i);
    a->setMass(this->toppar.getMass(Misc::trim(a->getResName()), Misc::trim(a->getAtmName()), verboseFlag));
  }
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movb %sil, %al
movq %rdi, 0x110(%rsp)
andb $0x1, %al
movb %al, 0x10f(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0xfc(%rsp)
movq 0x48(%rsp), %rdi
movl 0xfc(%rsp), %eax
movl %eax, 0x44(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x44(%rsp), %eax
cmpl %ecx, %eax
jae 0x4445b
movq 0x48(%rsp), %rdi
leaq 0xfc(%rsp), %rsi
callq 0x43580
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x100(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0xb0, %rax
movq %rax, 0x28(%rsp)
callq 0x1f620
movq %rax, 0x30(%rsp)
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x5730
movq 0x38(%rsp), %rdx
leaq 0x38330(%rip), %rsi     # 0x7c598
leaq 0xb0(%rsp), %rdi
callq 0x7900
jmp 0x44277
movq 0x30(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x3dee0
jmp 0x44293
movq 0x100(%rsp), %rdi
callq 0x1f5c0
movq %rax, 0x18(%rsp)
jmp 0x442a7
leaq 0x57(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5730
movq 0x10(%rsp), %rdx
leaq 0x382d6(%rip), %rsi     # 0x7c598
leaq 0x58(%rsp), %rdi
callq 0x7900
jmp 0x442ce
movq 0x18(%rsp), %rsi
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x3dee0
jmp 0x442e4
movq 0x28(%rsp), %rdi
movzbl 0x10f(%rsp), %ecx
andl $0x1, %ecx
leaq 0xd0(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x59e80
movsd %xmm0, 0x8(%rsp)
jmp 0x4430e
movq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x20180
jmp 0x44331
leaq 0x78(%rsp), %rdi
callq 0x5250
leaq 0x58(%rsp), %rdi
callq 0x5250
leaq 0x57(%rsp), %rdi
callq 0x5480
leaq 0xd0(%rsp), %rdi
callq 0x5250
leaq 0xb0(%rsp), %rdi
callq 0x5250
leaq 0xaf(%rsp), %rdi
callq 0x5480
movl 0xfc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xfc(%rsp)
jmp 0x441e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x4444c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x4443f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x44432
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x44428
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x4441e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5250
leaq 0x58(%rsp), %rdi
callq 0x5250
leaq 0x57(%rsp), %rdi
callq 0x5480
leaq 0xd0(%rsp), %rdi
callq 0x5250
leaq 0xb0(%rsp), %rdi
callq 0x5250
leaq 0xaf(%rsp), %rdi
callq 0x5480
jmp 0x44463
addq $0x118, %rsp            # imm = 0x118
retq
movq 0xa0(%rsp), %rdi
callq 0x5720
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::setCharge(bool)
void Molecule::setCharge(bool verboseFlag){
  Atom* a;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    a=this->getAtom(i);
    a->setCharge(this->toppar.getCharge(Misc::trim(a->getResName()), Misc::trim(a->getAtmName()), verboseFlag));
  }
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movb %sil, %al
movq %rdi, 0x110(%rsp)
andb $0x1, %al
movb %al, 0x10f(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0xfc(%rsp)
movq 0x48(%rsp), %rdi
movl 0xfc(%rsp), %eax
movl %eax, 0x44(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x44(%rsp), %eax
cmpl %ecx, %eax
jae 0x4471b
movq 0x48(%rsp), %rdi
leaq 0xfc(%rsp), %rsi
callq 0x43580
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x100(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0xb0, %rax
movq %rax, 0x28(%rsp)
callq 0x1f620
movq %rax, 0x30(%rsp)
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x5730
movq 0x38(%rsp), %rdx
leaq 0x38070(%rip), %rsi     # 0x7c598
leaq 0xb0(%rsp), %rdi
callq 0x7900
jmp 0x44537
movq 0x30(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x3dee0
jmp 0x44553
movq 0x100(%rsp), %rdi
callq 0x1f5c0
movq %rax, 0x18(%rsp)
jmp 0x44567
leaq 0x57(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5730
movq 0x10(%rsp), %rdx
leaq 0x38016(%rip), %rsi     # 0x7c598
leaq 0x58(%rsp), %rdi
callq 0x7900
jmp 0x4458e
movq 0x18(%rsp), %rsi
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x3dee0
jmp 0x445a4
movq 0x28(%rsp), %rdi
movzbl 0x10f(%rsp), %ecx
andl $0x1, %ecx
leaq 0xd0(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x5a080
movsd %xmm0, 0x8(%rsp)
jmp 0x445ce
movq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x201b0
jmp 0x445f1
leaq 0x78(%rsp), %rdi
callq 0x5250
leaq 0x58(%rsp), %rdi
callq 0x5250
leaq 0x57(%rsp), %rdi
callq 0x5480
leaq 0xd0(%rsp), %rdi
callq 0x5250
leaq 0xb0(%rsp), %rdi
callq 0x5250
leaq 0xaf(%rsp), %rdi
callq 0x5480
movl 0xfc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xfc(%rsp)
jmp 0x444a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x4470c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x446ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x446f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x446e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x446de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5250
leaq 0x58(%rsp), %rdi
callq 0x5250
leaq 0x57(%rsp), %rdi
callq 0x5480
leaq 0xd0(%rsp), %rdi
callq 0x5250
leaq 0xb0(%rsp), %rdi
callq 0x5250
leaq 0xaf(%rsp), %rdi
callq 0x5480
jmp 0x44723
addq $0x118, %rsp            # imm = 0x118
retq
movq 0xa0(%rsp), %rdi
callq 0x5720
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getAtomTypes[abi:cxx11]()
std::vector<std::string> Molecule::getAtomTypes(){
  std::vector<std::string> atomTypes;

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

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

  return atomTypes;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
movb $0x0, 0x97(%rsp)
callq 0x77e0
movl $0x0, 0x90(%rsp)
movq 0x40(%rsp), %rdi
movl 0x90(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jae 0x4492b
movq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x43580
movq %rax, 0x20(%rsp)
jmp 0x448d1
movq 0x20(%rsp), %rdi
callq 0x1f5d0
movq %rax, 0x18(%rsp)
jmp 0x448e2
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x7870
jmp 0x448f3
jmp 0x448f5
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x44899
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x7ab0
jmp 0x44a01
movq 0x30(%rsp), %rdi
callq 0x8840
movq 0x30(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x86b0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x47630
jmp 0x4495a
movq 0x30(%rsp), %rdi
callq 0x8840
movq 0x30(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x86b0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x38580
movq %rax, 0x10(%rsp)
jmp 0x4498e
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x68(%rsp)
callq 0x8840
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x38670
movq %rax, 0x8(%rsp)
jmp 0x449c7
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x385d0
jmp 0x449d8
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x449f4
movq 0x30(%rsp), %rdi
callq 0x7ab0
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x5720
nop
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::getNAtomSelected()
unsigned int Molecule::getNAtomSelected(){
  unsigned int natom=0;
  for (unsigned int i=0; i< this->getAtmVecSize(); i++){
    if (this->getAtom(i)->getSel() == true){
      natom++;
    }
  }
  return natom;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x44c1c
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x43580
movq %rax, %rdi
callq 0x1f780
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x44c0d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x44c0f
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x44bc3
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::storeSel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Molecule::storeSel(std::string key){
  std::vector<bool> selFlags;
  Chain *chn;
  Residue *res;
  Atom *atm;

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

  storedSel[key]=selFlags;
}

// Assembly:
subq $0xc8, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x47670
movl $0x0, 0x74(%rsp)
movq 0x50(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x44(%rsp)
callq 0x41e20
movl %eax, %ecx
movl 0x44(%rsp), %eax
cmpl %ecx, %eax
jae 0x44dda
movq 0x50(%rsp), %rdi
leaq 0x74(%rsp), %rsi
callq 0x41e40
movq %rax, 0x38(%rsp)
jmp 0x44ca4
movq 0x38(%rsp), %rax
movq %rax, 0x88(%rsp)
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x88(%rsp), %rdi
callq 0x3a570
movl %eax, 0x34(%rsp)
jmp 0x44cd4
movl 0x30(%rsp), %eax
movl 0x34(%rsp), %ecx
cmpl %ecx, %eax
jae 0x44dc8
movq 0x88(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x3a490
movq %rax, 0x28(%rsp)
jmp 0x44cfd
movq 0x28(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
callq 0x5e110
movl %eax, 0x24(%rsp)
jmp 0x44d2d
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jae 0x44db6
movq 0x80(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x5df30
movq %rax, 0x18(%rsp)
jmp 0x44d52
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x1f780
movq %rax, 0x10(%rsp)
jmp 0x44d6d
movq 0x10(%rsp), %rax
movzbl (%rax), %esi
andl $0x1, %esi
leaq 0x90(%rsp), %rdi
callq 0x47680
jmp 0x44d87
jmp 0x44d89
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x44d12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x479e0
jmp 0x44e1d
jmp 0x44db8
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x44cb9
jmp 0x44dca
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x44c6e
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdi
addq $0x58, %rdi
callq 0x47760
movq %rax, 0x8(%rsp)
jmp 0x44df4
movq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x47850
jmp 0x44e08
leaq 0x90(%rsp), %rdi
callq 0x479e0
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::recallSel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Molecule::recallSel(std::string key){
  Chain *chn;
  Residue *res;
  Atom *atm;
  unsigned int n;
  std::vector<bool>* storedSelVal;

  n=0;
  storedSelVal=&storedSel[key];
  
  for (unsigned int i=0; i< this->getChnVecSize(); i++){
    chn=this->getChain(i);
    for (unsigned int j=0; j< chn->getResVecSize(); j++){
      res=chn->getResidue(j);
      for (unsigned int k=0; k< res->getAtmVecSize(); k++){
        atm=res->getAtom(k);
        atm->setSel(storedSelVal->at(n));
        n++;
      }
    }
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x0, 0x4c(%rsp)
addq $0x58, %rdi
callq 0x47760
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x41e20
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x44f89
movq 0x18(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x41e40
movq %rax, 0x60(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x3a570
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jae 0x44f77
movq 0x60(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3a490
movq %rax, 0x58(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rdi
callq 0x5e110
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x44f65
movq 0x58(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x5df30
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x479f0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x47a40
movq (%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x200f0
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x44ede
jmp 0x44f67
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x44ea2
jmp 0x44f79
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x44e66
addq $0x78, %rsp
retq
nop
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::zeroCoor()
void Molecule::zeroCoor(){
  Chain *chn;
  Residue *res;
  Atom *atm;
  Coor coor;

  coor=Coor(0.0, 0.0, 0.0);

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

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x76060
leaq 0x28(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x76090
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x76110
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x41e20
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x450eb
movq 0x10(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x41e40
movq %rax, 0x68(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x3a570
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jae 0x450d9
movq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3a490
movq %rax, 0x60(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5e110
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x450c7
movq 0x60(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x5df30
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1ffe0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4507b
jmp 0x450c9
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x45043
jmp 0x450db
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x45007
addq $0x78, %rsp
retq
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::assignAtmInx()
void Molecule::assignAtmInx(){
  unsigned int natom;

  natom=0;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x436b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x46ce3
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x43580
movq %rax, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x201e0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x46c93
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/PDB.cpp
// Function: PDB::formatCHARMMResId(Atom*, Residue*, Residue*)
int PDB::formatCHARMMResId(Atom* atmEntry, Residue* lastRes, Residue* nextRes){
  if (atmEntry->getResName().compare("ACE") == 0 && nextRes != NULL){
    return nextRes->getResId();
  }
  else if ((atmEntry->getResName().compare("AHE") == 0 || atmEntry->getResName().compare("NME") == 0) && lastRes != NULL){
    return lastRes->getResId();
  }
  else{
    return atmEntry->getResId();
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1f620
movq %rax, %rdi
leaq 0x25972(%rip), %rsi     # 0x7c4a9
callq 0x5140
cmpl $0x0, %eax
jne 0x56b59
cmpq $0x0, 0x8(%rsp)
je 0x56b59
movq 0x8(%rsp), %rdi
callq 0x5df00
movl %eax, 0x24(%rsp)
jmp 0x56bbd
movq 0x18(%rsp), %rdi
callq 0x1f620
movq %rax, %rdi
leaq 0x25934(%rip), %rsi     # 0x7c4a1
callq 0x5140
cmpl $0x0, %eax
je 0x56b95
movq 0x18(%rsp), %rdi
callq 0x1f620
movq %rax, %rdi
leaq 0x2591a(%rip), %rsi     # 0x7c4a5
callq 0x5140
cmpl $0x0, %eax
jne 0x56bad
cmpq $0x0, 0x10(%rsp)
je 0x56bad
movq 0x10(%rsp), %rdi
callq 0x5df00
movl %eax, 0x24(%rsp)
jmp 0x56bbd
movq 0x18(%rsp), %rdi
callq 0x1f6a0
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getAtmType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
std::string Prmtop::getAtmType(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (atmtype.find(std::make_pair(resnamein, atmnamein)) != atmtype.end()){
    return  atmtype[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not a find an atom type for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to \"DUMB\"" << std::endl;
    }
    return "DUMB";
  }
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x28(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x30(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x108(%rsp)
andb $0x1, %al
movb %al, 0x107(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x60, %rax
movq %rax, 0x40(%rsp)
movq 0x110(%rsp), %rsi
movq 0x108(%rsp), %rdx
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x5a830
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x5a800
movq %rax, 0x50(%rsp)
jmp 0x59c9e
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0xf8(%rsp)
addq $0x60, %rdi
callq 0x5a870
movq %rax, 0xa0(%rsp)
leaq 0xf8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x5a7e0
movb %al, 0x27(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x3c8c0
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x59cf4
jmp 0x59da0
movq 0x38(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0x110(%rsp), %rsi
movq 0x108(%rsp), %rdx
leaq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5a830
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x5a8a0
movq %rax, 0x18(%rsp)
jmp 0x59d37
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x51b0
jmp 0x59d48
leaq 0x60(%rsp), %rdi
callq 0x3c8c0
jmp 0x59e66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x3c8c0
jmp 0x59e73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3c8c0
jmp 0x59e73
movb 0x107(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x59e15
movq 0x3e1238(%rip), %rdi    # 0x43aff0
leaq 0x228cf(%rip), %rsi     # 0x7c68e
callq 0x53f0
movq %rax, %rdi
movq 0x110(%rsp), %rsi
callq 0x5390
movq 0x3e1215(%rip), %rdi    # 0x43aff0
leaq 0x227b6(%rip), %rsi     # 0x7c598
callq 0x53f0
movq %rax, %rdi
movq 0x108(%rsp), %rsi
callq 0x5390
movq %rax, %rdi
leaq 0x228be(%rip), %rsi     # 0x7c6bf
callq 0x53f0
movq %rax, %rdi
movq 0x3e1198(%rip), %rsi    # 0x43afa8
callq 0x5460
leaq 0x5f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5730
movq 0x28(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x228a3(%rip), %rsi     # 0x7c6d6
callq 0x7900
jmp 0x59e3a
leaq 0x5f(%rsp), %rdi
callq 0x5480
jmp 0x59e66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x5480
jmp 0x59e73
movq 0x30(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
movq 0xb0(%rsp), %rdi
callq 0x5720
// File: atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getMass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
double Prmtop::getMass(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (mass.find(std::make_pair(resnamein, atmnamein)) != mass.end()){
    return  mass[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not a find mass for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to 1.0" << std::endl;
    }
    return 1.0;
  }
}

// Assembly:
subq $0xf8, %rsp
movb %cl, %al
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
andb $0x1, %al
movb %al, 0xd7(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5a830
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5a9b0
movq %rax, 0x28(%rsp)
jmp 0x59eef
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0xc8(%rsp)
callq 0x5a9e0
movq %rax, 0x70(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5a990
movb %al, 0x17(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x3c8c0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x59f3b
jmp 0x59fd2
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5a830
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x5aa10
movq %rax, 0x8(%rsp)
jmp 0x59f6e
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0xf0(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3c8c0
jmp 0x5a058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x3c8c0
jmp 0x5a069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3c8c0
jmp 0x5a069
movb 0xd7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5a047
movq 0x3e1006(%rip), %rdi    # 0x43aff0
leaq 0x226ea(%rip), %rsi     # 0x7c6db
callq 0x53f0
movq %rax, %rdi
movq 0xe0(%rsp), %rsi
callq 0x5390
movq 0x3e0fe3(%rip), %rdi    # 0x43aff0
leaq 0x22584(%rip), %rsi     # 0x7c598
callq 0x53f0
movq %rax, %rdi
movq 0xd8(%rsp), %rsi
callq 0x5390
movq %rax, %rdi
leaq 0x226d1(%rip), %rsi     # 0x7c704
callq 0x53f0
movq %rax, %rdi
movq 0x3e0f66(%rip), %rsi    # 0x43afa8
callq 0x5460
movsd 0x21321(%rip), %xmm0    # 0x7b370
movsd %xmm0, 0xf0(%rsp)
movsd 0xf0(%rsp), %xmm0
addq $0xf8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getCharge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
double Prmtop::getCharge(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (charge.find(std::make_pair(resnamein, atmnamein)) != charge.end()){
    return charge[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not find a charge for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to 0.0." << std::endl;
    }
    return 0.0;
  }
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movb %cl, %al
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
andb $0x1, %al
movb %al, 0xe7(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x30, %rax
movq %rax, 0x28(%rsp)
movq 0xf0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
leaq 0x98(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5a830
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x5a9b0
movq %rax, 0x38(%rsp)
jmp 0x5a0f8
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0xd8(%rsp)
addq $0x30, %rdi
callq 0x5a9e0
movq %rax, 0x80(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x5a990
movb %al, 0x1f(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3c8c0
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x5a14e
jmp 0x5a1f9
movq 0x20(%rsp), %rax
addq $0x30, %rax
movq %rax, (%rsp)
movq 0xf0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5a830
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5aa10
movq %rax, 0x10(%rsp)
jmp 0x5a18f
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x100(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3c8c0
jmp 0x5a27a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x3c8c0
jmp 0x5a28b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3c8c0
jmp 0x5a28b
movb 0xe7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x5a26e
movq 0x3e0ddf(%rip), %rdi    # 0x43aff0
leaq 0x22500(%rip), %rsi     # 0x7c718
callq 0x53f0
movq %rax, %rdi
movq 0xf0(%rsp), %rsi
callq 0x5390
movq 0x3e0dbc(%rip), %rdi    # 0x43aff0
leaq 0x2235d(%rip), %rsi     # 0x7c598
callq 0x53f0
movq %rax, %rdi
movq 0xe8(%rsp), %rsi
callq 0x5390
movq %rax, %rdi
leaq 0x224e9(%rip), %rsi     # 0x7c743
callq 0x53f0
movq %rax, %rdi
movq 0x3e0d3f(%rip), %rsi    # 0x43afa8
callq 0x5460
xorps %xmm0, %xmm0
movsd %xmm0, 0x100(%rsp)
movsd 0x100(%rsp), %xmm0
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x90(%rsp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/Residue.cpp
// Function: Residue::getAtom(unsigned int const&)
Atom* Residue::getAtom (const unsigned int &element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
callq 0x20600
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x5df70
movq $0x0, 0x20(%rsp)
jmp 0x5df8a
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x20620
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::Trajectory()
Trajectory::Trajectory (){
  swab=false;
  mol=NULL;
  show=false;
  scan=false;
  iframe=0;
  hdrSize=0;
  frameSize=0;
  lastFrame=0;
  lastPos=0;
  hdr.clear();
  nframe=0;
  npriv=0;
  nsavc=0;
  nstep=0;
  qvelocity=false;
  dof=0;
  nfixed=0;
  tstep=0.0;
  qcrystal=false;
  q4d=false;
  qcharge=false;
  qcheck=false;
  version=0;
  title.clear();
  natom=0;
  fixinx.clear();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
callq 0x5600
movq 0x48(%rsp), %rdi
addq $0x48, %rdi
callq 0x74aa0
jmp 0x70cd0
movq 0x40(%rsp), %rdi
addq $0x58, %rdi
movq %rdi, (%rsp)
callq 0x5600
movq 0x40(%rsp), %rdi
addq $0xb0, %rdi
movq %rdi, 0x8(%rsp)
callq 0x77e0
movq 0x40(%rsp), %rdi
addq $0xd0, %rdi
movq %rdi, 0x10(%rsp)
callq 0x74ad0
movq 0x40(%rsp), %rdi
addq $0xe8, %rdi
movq %rdi, 0x18(%rsp)
callq 0x16940
movq 0x40(%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq %rdi, 0x20(%rsp)
callq 0x74ae0
movq 0x40(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq %rdi, 0x28(%rsp)
callq 0x74ae0
movq 0x40(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, 0x30(%rsp)
callq 0x74ae0
movq 0x40(%rsp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, 0x38(%rsp)
callq 0x5600
movq 0x40(%rsp), %rax
movb $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movb $0x0, 0x31(%rax)
movl $0x0, 0x34(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x3c(%rax)
movl $0x0, 0x40(%rax)
xorl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x74af0
jmp 0x70dc1
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rdi)
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rdi)
addq $0x58, %rdi
callq 0x5580
movq 0x40(%rsp), %rdi
movl $0x0, 0x78(%rdi)
movl $0x0, 0x7c(%rdi)
movl $0x0, 0x80(%rdi)
movl $0x0, 0x84(%rdi)
movl $0x0, 0x88(%rdi)
movl $0x0, 0x90(%rdi)
movl $0x0, 0x94(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0x98(%rdi)
movl $0x0, 0x9c(%rdi)
movl $0x0, 0xa0(%rdi)
movl $0x0, 0xa4(%rdi)
movl $0x0, 0xa8(%rdi)
movl $0x0, 0xac(%rdi)
addq $0xb0, %rdi
callq 0x7800
movq 0x40(%rsp), %rdi
movl $0x0, 0xc8(%rdi)
addq $0xd0, %rdi
callq 0x3ec90
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x70efc
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x5250
movq 0x30(%rsp), %rdi
callq 0x7ba0
movq 0x28(%rsp), %rdi
callq 0x7ba0
movq 0x20(%rsp), %rdi
callq 0x7ba0
movq 0x18(%rsp), %rdi
callq 0x7c00
movq 0x10(%rsp), %rdi
callq 0x7c60
movq 0x8(%rsp), %rdi
callq 0x7ab0
movq (%rsp), %rdi
callq 0x5250
movq 0x48(%rsp), %rdi
callq 0x5250
movq 0x68(%rsp), %rdi
callq 0x5720