LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::recallSel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Molecule::recallSel(std::string key){
  Chain *chn;
  Residue *res;
  Atom *atm;
  unsigned int n;
  std::vector<bool>* storedSelVal;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x58, %rdi
callq 0x27336
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x25b41
xorl %edx, %edx
movq %rsp, %r12
xorl %r15d, %r15d
movq %rdx, 0x10(%rsp)
movq (%rax,%rdx,8), %r13
movl $0x0, 0x4(%rsp)
movq %r13, %rdi
callq 0x20664
testl %eax, %eax
je 0x25b1a
movq %r13, %rdi
leaq 0x4(%rsp), %rsi
callq 0x2060a
movq %rax, %rbp
movl $0x0, (%rsp)
movq %rax, %rdi
callq 0x2f884
testl %eax, %eax
je 0x25b04
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2f7ae
movq %rax, %rbx
movl %r15d, %esi
movq %r14, %rdi
callq 0x27452
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %rbx, %rdi
callq 0x150b0
incl %r15d
movl (%rsp), %ebx
incl %ebx
movl %ebx, (%rsp)
movq %rbp, %rdi
callq 0x2f884
cmpl %eax, %ebx
jb 0x25ac3
movl 0x4(%rsp), %ebx
incl %ebx
movl %ebx, 0x4(%rsp)
movq %r13, %rdi
callq 0x20664
cmpl %eax, %ebx
jb 0x25aa0
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %ecx
cmpq %rcx, %rdx
jb 0x25a83
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::zeroCoor()
void Molecule::zeroCoor(){
  Chain *chn;
  Residue *res;
  Atom *atm;
  Coor coor;

  coor=Coor(0.0, 0.0, 0.0);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3a27c
leaq 0x18(%rsp), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x3a28c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a2ae
movq 0x8(%rbx), %rax
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x25c80
xorl %edx, %edx
leaq 0x18(%rsp), %r14
leaq 0x4(%rsp), %r15
leaq 0x30(%rsp), %r12
movq %rdx, 0x10(%rsp)
movq (%rax,%rdx,8), %r13
movl $0x0, 0x18(%rsp)
movq %r13, %rdi
callq 0x20664
testl %eax, %eax
je 0x25c59
movq %r13, %rdi
movq %r14, %rsi
callq 0x2060a
movq %rax, %rbp
movl $0x0, 0x4(%rsp)
movq %rax, %rdi
callq 0x2f884
testl %eax, %eax
je 0x25c43
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2f7ae
movq %rax, %rdi
movq %r12, %rsi
callq 0x1504e
movl 0x4(%rsp), %ebx
incl %ebx
movl %ebx, 0x4(%rsp)
movq %rbp, %rdi
callq 0x2f884
cmpl %eax, %ebx
jb 0x25c17
movl 0x18(%rsp), %ebp
incl %ebp
movl %ebp, 0x18(%rsp)
movq %r13, %rdi
callq 0x20664
cmpl %eax, %ebp
jb 0x25bf5
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %ecx
cmpq %rcx, %rdx
jb 0x25bd8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::assignAtmInx()
void Molecule::assignAtmInx(){
  unsigned int natom;

  natom=0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x0, 0xc(%rsp)
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0x26d86
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x150ec
incl 0xc(%rsp)
incq %r15
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %ecx
cmpq %rcx, %r15
jb 0x26d5d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::~Molecule()
Molecule::~Molecule (){
  Chain *c;
  Residue *r;
  Atom *a;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3c9f2a(%rip), %rax    # 0x3f0d30
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
testl %edx, %edx
je 0x26f40
xorl %esi, %esi
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
sarq $0x3, %rcx
cmpq %rsi, %rcx
movq %rsi, 0x10(%rsp)
jbe 0x26e43
movq (%rax,%rsi,8), %r12
jmp 0x26e46
xorl %r12d, %r12d
xorl %ebp, %ebp
movl %ebp, 0xc(%rsp)
movq %r12, %rdi
callq 0x20664
cmpl %eax, %ebp
jae 0x26ee1
movq %r12, %rdi
movq %r14, %rsi
callq 0x2060a
movq %rax, %r13
cmpb $0x0, 0x50(%rbx)
je 0x26e9f
testq %r13, %r13
je 0x26e97
movq (%r13), %rdi
testq %rdi, %rdi
je 0x26e8a
movq 0x10(%r13), %rsi
subq %rdi, %rsi
callq 0x42e0
movl $0x18, %esi
movq %r13, %rdi
callq 0x42e0
movl 0xc(%rsp), %ebp
incl %ebp
jmp 0x26e48
xorl %ebp, %ebp
movl %ebp, 0x8(%rsp)
movq %r13, %rdi
callq 0x2f884
cmpl %eax, %ebp
jae 0x26e70
movq %r13, %rdi
movq %r15, %rsi
callq 0x2f7ae
movq %rax, %rbp
testq %rax, %rax
je 0x26ed9
movq %rbp, %rdi
callq 0x2702e
movl $0x238, %esi            # imm = 0x238
movq %rbp, %rdi
callq 0x42e0
movl 0x8(%rsp), %ebp
incl %ebp
jmp 0x26ea1
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x26ef8
movq 0x28(%r12), %rsi
subq %rdi, %rsi
callq 0x42e0
movq (%r12), %rdi
testq %rdi, %rdi
je 0x26f0e
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x42e0
movl $0x30, %esi
movq %r12, %rdi
callq 0x42e0
movq 0x10(%rsp), %rsi
incq %rsi
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, %edx
cmpq %rdx, %rsi
jb 0x26e2f
movq 0x180(%rbx), %rdi
leaq 0x190(%rbx), %rax
cmpq %rax, %rdi
je 0x26f5e
movq (%rax), %rsi
incq %rsi
callq 0x42e0
movq 0x160(%rbx), %rdi
leaq 0x170(%rbx), %rax
cmpq %rax, %rdi
je 0x26f7c
movq (%rax), %rsi
incq %rsi
callq 0x42e0
leaq 0xb0(%rbx), %r14
leaq 0x140(%rbx), %rdi
callq 0x6420
leaq 0x110(%rbx), %rdi
callq 0x2755c
leaq 0xe0(%rbx), %rdi
callq 0x27606
movq %r14, %rdi
callq 0x27606
movq 0x88(%rbx), %rdi
leaq 0x98(%rbx), %rax
cmpq %rax, %rdi
je 0x26fcd
movq (%rax), %rsi
incq %rsi
callq 0x42e0
leaq 0x58(%rbx), %rdi
callq 0x274d0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x26feb
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x42e0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x27000
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x42e0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x27015
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x42e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27026
movq %rax, %rdi
callq 0x647b
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/PDB.cpp
// Function: PDB::formatCHARMMResId(Atom*, Residue*, Residue*)
int PDB::formatCHARMMResId(Atom* atmEntry, Residue* lastRes, Residue* nextRes){
  if (atmEntry->getResName().compare("ACE") == 0 && nextRes != NULL){
    return nextRes->getResId();
  }
  else if ((atmEntry->getResName().compare("AHE") == 0 || atmEntry->getResName().compare("NME") == 0) && lastRes != NULL){
    return lastRes->getResId();
  }
  else{
    return atmEntry->getResId();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14a8e
leaq 0x10a41(%rip), %rsi     # 0x3d56d
movq %rax, %rdi
callq 0x40e0
testq %r15, %r15
je 0x2cb42
testl %eax, %eax
jne 0x2cb42
movq %r15, %rdi
jmp 0x2cb80
movq %rbx, %rdi
callq 0x14a8e
leaq 0x10a14(%rip), %rsi     # 0x3d565
movq %rax, %rdi
callq 0x40e0
testl %eax, %eax
je 0x2cb8a
movq %rbx, %rdi
callq 0x14a8e
leaq 0x109fd(%rip), %rsi     # 0x3d569
movq %rax, %rdi
callq 0x40e0
testq %r14, %r14
je 0x2cb8f
testl %eax, %eax
jne 0x2cb8f
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2f79e
testq %r14, %r14
jne 0x2cb7d
movq %rbx, %rdi
callq 0x14aae
movl (%rax), %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getAtmType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
std::string Prmtop::getAtmType(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (atmtype.find(std::make_pair(resnamein, atmnamein)) != atmtype.end()){
    return  atmtype[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not a find an atom type for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to \"DUMB\"" << std::endl;
    }
    return "DUMB";
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x60(%rsi), %r12
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x2ea2c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2f2a0
movq %rax, %rbp
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e211
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x68, %r13
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e230
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq %r13, %rbp
je 0x2e2ad
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2ea2c
movq %r12, %rdi
movq %r13, %rsi
callq 0x2e834
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6486
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2e288
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e360
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x2e360
cmpb $0x0, 0x4(%rsp)
je 0x2e343
movq 0x3c2d31(%rip), %r12    # 0x3f0ff0
leaq 0xf4d0(%rip), %rsi      # 0x3d796
movl $0x30, %edx
movq %r12, %rdi
callq 0x4340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x4340
leaq 0xf3b7(%rip), %rsi      # 0x3d6a0
movl $0x1, %edx
movq %r12, %rdi
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x4340
movq %rax, %r14
leaq 0xf4b8(%rip), %rsi      # 0x3d7c7
movl $0x16, %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 0xf48d(%rip), %rsi      # 0x3d7de
leaq 0xf48a(%rip), %rdx      # 0x3d7e2
movq %rbx, %rdi
callq 0x6516
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e374
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21730
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getMass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
double Prmtop::getMass(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (mass.find(std::make_pair(resnamein, atmnamein)) != mass.end()){
    return  mass[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not a find mass for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to 1.0" << std::endl;
    }
    return 1.0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2ea2c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f4ec
movq %rax, %r12
movl %ebp, (%rsp)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e3dc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x8(%r15), %r13
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x2e3fb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq %r13, %r12
je 0x2e46d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ea2c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e8ce
movsd (%rax), %xmm0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
movsd %xmm0, (%rsp)
je 0x2e448
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movsd (%rsp), %xmm0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e512
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movsd (%rsp), %xmm0
jmp 0x2e512
movsd 0xdfdb(%rip), %xmm0     # 0x3c450
cmpb $0x0, (%rsp)
je 0x2e512
movq 0x3c2b6a(%rip), %r15    # 0x3f0ff0
leaq 0xf356(%rip), %rsi      # 0x3d7e3
movl $0x28, %edx
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4340
leaq 0xf1f0(%rip), %rsi      # 0x3d6a0
movl $0x1, %edx
movq %r15, %rdi
callq 0x4340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x4340
movq %rax, %rbx
leaq 0xf336(%rip), %rsi      # 0x3d80c
movl $0x13, %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
movsd 0xdf3e(%rip), %xmm0     # 0x3c450
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e523
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21730
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Prmtop.cpp
// Function: Prmtop::getCharge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
double Prmtop::getCharge(const std::string& resnamein, const std::string& atmnamein, bool verboseFlag){
  if (charge.find(std::make_pair(resnamein, atmnamein)) != charge.end()){
    return charge[std::make_pair(resnamein, atmnamein)];
  }
  else{
    if (verboseFlag == true){
      std::cerr << "Warning: Could not find a charge for atom " << resnamein;
      std::cerr << " " << atmnamein << " and was set to 0.0." << std::endl;
    }
    return 0.0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x30(%rdi), %r15
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x2ea2c
movq %r15, %rdi
movq %r13, %rsi
callq 0x2f4ec
movq %rax, %r13
movl %ebp, (%rsp)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e58e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x38, %r12
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x2e5ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
cmpq %r12, %r13
je 0x2e61f
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ea2c
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e8ce
movsd (%rax), %xmm0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
movsd %xmm0, (%rsp)
je 0x2e5fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42e0
movsd (%rsp), %xmm0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2e6ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42e0
movsd (%rsp), %xmm0
jmp 0x2e6ba
xorps %xmm0, %xmm0
cmpb $0x0, (%rsp)
je 0x2e6ba
movq 0x3c29bd(%rip), %r15    # 0x3f0ff0
leaq 0xf1e6(%rip), %rsi      # 0x3d820
movl $0x2a, %edx
movq %r15, %rdi
callq 0x4340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4340
leaq 0xf043(%rip), %rsi      # 0x3d6a0
movl $0x1, %edx
movq %r15, %rdi
callq 0x4340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x4340
movq %rax, %rbx
leaq 0xf1c8(%rip), %rsi      # 0x3d84b
movl $0x14, %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
xorps %xmm0, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e6cb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21730
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Residue.cpp
// Function: Residue::getAtom(unsigned int const&)
Atom* Residue::getAtom (const unsigned int &element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

// Assembly:
movl (%rsi), %eax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x2f7c8
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Select.cpp
// Function: Select::atom(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::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&)
bool Select::atom(const std::string &str, std::string typein, const std::vector<std::string> &AtomVec){
  size_t pos;
  std::string atmType;

  pos=str.find_first_not_of("0123456789");
  atmType=str.substr(pos,1);

  if (typein.compare("heavy") == 0 && atmType.compare("H") != 0 && std::find(AtomVec.begin(),AtomVec.end(), str) == AtomVec.end()){
    return true;
  }
  else if (atmType.compare(typein) == 0 && std::find(AtomVec.begin(),AtomVec.end(), str) == AtomVec.end()){
    return true;
  }
  else{
    return false;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x6e41(%rip), %rsi      # 0x3d3f0
movl $0xa, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44e0
leaq 0x20(%rsp), %rdi
movl $0x1, %ecx
movq %r14, %rsi
movq %rax, %rdx
callq 0x4300
movq %rsp, %rdi
leaq 0x20(%rsp), %r12
movq %r12, %rsi
callq 0x4370
movq (%r12), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x365fe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
leaq 0x762c(%rip), %rsi      # 0x3dc31
movq %r15, %rdi
callq 0x40e0
testl %eax, %eax
je 0x36639
movq %rsp, %rdi
movq %r15, %rsi
callq 0x4050
testl %eax, %eax
jne 0x36635
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x285b5
cmpq 0x8(%rbx), %rax
je 0x36661
xorl %ebx, %ebx
jmp 0x36663
leaq 0x70d7(%rip), %rsi      # 0x3d717
movq %rsp, %rdi
callq 0x40e0
testl %eax, %eax
je 0x36611
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x285b5
cmpq 0x8(%rbx), %rax
jne 0x36611
movb $0x1, %bl
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x36679
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3668f
jmp 0x3668f
jmp 0x3668f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x366a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %r14d, %r14d
movq %r14, 0x8(%rdi)
movb %r14b, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
leaq 0x68(%rdi), %rax
movq %rax, 0x58(%rdi)
movq %r14, 0x60(%rdi)
movb %r14b, 0x68(%rdi)
addq $0xb0, %rdi
movups %xmm0, 0xb0(%rbx)
movq %r14, 0xc0(%rbx)
leaq 0x188(%rbx), %rax
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x140(%rbx)
movups %xmm0, 0x150(%rbx)
movups %xmm0, 0x160(%rbx)
movq %r14, 0x170(%rbx)
movq %rax, 0x178(%rbx)
movq %r14, 0x180(%rbx)
movb %r14b, 0x188(%rbx)
movb %r14b, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movw $0x0, 0x30(%rbx)
movups %xmm0, 0x34(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x78(%rbx)
movl %r14d, 0x88(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movq 0xb0(%rbx), %rsi
callq 0x12974
movl %r14d, 0xc8(%rbx)
movq 0xd0(%rbx), %rax
cmpq %rax, 0xd8(%rbx)
je 0x37622
movq %rax, 0xd8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::setDefaultHeader()
void Trajectory::setDefaultHeader(){
  this->setFormat("CHARMM");
  this->setHdr("CORD");
  this->setNFrame(0);
  this->setNPriv(1);
  this->setNSavc(1);
  this->setNStep(1);
  this->setQVelocity(false);
  this->setDOF(0);
  this->setNFixed(0);
  this->setTStep(1.0);
  this->setQCrystal(false);
  this->setQ4D(false);
  this->setQCharge(false);
  this->setQCheck(false);
  this->setVersion(0);
  title.clear();
  this->setNAtom(0);
  fixinx.clear();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5f55(%rip), %rsi      # 0x3d59a
leaq 0x5f54(%rip), %rdx      # 0x3d5a0
movq %rsp, %rdi
callq 0x6516
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4180
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x37675
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x6936(%rip), %rsi      # 0x3dfb8
leaq 0x6933(%rip), %rdx      # 0x3dfbc
callq 0x6516
leaq 0x58(%rbx), %rdi
movq %rsp, %rsi
callq 0x4180
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x376b0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movaps 0x68d9(%rip), %xmm0     # 0x3df90
movups %xmm0, 0x78(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x88(%rbx)
movq $0x0, 0x90(%rbx)
movl $0x41a3a347, 0x98(%rbx) # imm = 0x41A3A347
leaq 0xb0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x9c(%rbx)
movl %ebp, 0xac(%rbx)
movq 0xb0(%rbx), %rsi
callq 0x12974
movl %ebp, 0xc8(%rbx)
movq 0xd0(%rbx), %rax
cmpq %rax, 0xd8(%rbx)
je 0x37718
movq %rax, 0xd8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x37725
jmp 0x37740
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x37743
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x37743
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::findFormat(std::basic_ifstream<char, std::char_traits<char>>&)
bool Trajectory::findFormat(std::ifstream &trjin){
  binbuf *buffer;
  int length;

  buffer=NULL;

  trjin.seekg(0, std::ios::beg);

  buffer=readFortran(trjin, buffer, length);

  hdr.assign(buffer[0].c,4);

  if (length == 84 && hdr.compare("CORD") == 0){
    format="CHARMM";
    swab=false;
  }

  if (buffer != NULL){
    delete buffer;
  }

  trjin.seekg(0, std::ios::beg);

  clearHeader();

  if (format.length() > 0){
    return true;
  }
  else{
    return false;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x43e0
leaq 0xc(%rsp), %r13
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x39c84
movq %rax, %r15
leaq 0x58(%rbx), %r12
movq 0x60(%rbx), %rdx
movl $0x4, %r8d
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x4470
cmpl $0x54, (%r13)
jne 0x378a9
leaq 0x673a(%rip), %rsi      # 0x3dfb8
movq %r12, %rdi
callq 0x40e0
testl %eax, %eax
jne 0x378a9
movq 0x8(%rbx), %rdx
leaq 0x5d05(%rip), %rcx      # 0x3d59a
movl $0x6, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4470
movb $0x0, 0x20(%rbx)
testq %r15, %r15
je 0x378bb
movl $0x4, %esi
movq %r15, %rdi
callq 0x42e0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x43e0
movq %rbx, %rdi
callq 0x378e6
cmpq $0x0, 0x8(%rbx)
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::clearHeader()
void Trajectory::clearHeader(){
  hdr.clear();
  nframe=0;
  npriv=0;
  nsavc=0;
  nstep=0;
  qvelocity=0;
  dof=0;
  nfixed=0;
  tstep=0.0;
  qcrystal=0;
  q4d=0;
  qcharge=0;
  qcheck=0;
  version=0;
  title.clear();
  natom=0;
  fixinx.clear();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x60(%rdi)
movq 0x58(%rdi), %rax
movb $0x0, (%rax)
addq $0xb0, %rdi
xorl %ebp, %ebp
movl %ebp, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movq 0xb0(%rbx), %rsi
callq 0x12974
movl %ebp, 0xc8(%rbx)
movq 0xd0(%rbx), %rax
cmpq %rax, 0xd8(%rbx)
je 0x37948
movq %rax, 0xd8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::cloneHeader(Trajectory*)
void Trajectory::cloneHeader(Trajectory *ftrjin){
  format=ftrjin->getFormat();
  hdr=ftrjin->getHdr();
  nframe=ftrjin->getNFrame();
  npriv=ftrjin->getNPriv();
  nsavc=ftrjin->getNSavc();
  nstep=ftrjin->getNStep();
  qvelocity=ftrjin->getQVelocity();

  dof=ftrjin->getDOF();
  nfixed=ftrjin->getNFixed();
  tstep=ftrjin->getTStepAKMA();
  qcrystal=ftrjin->getQCrystal();
  q4d=ftrjin->getQ4D();
  qcharge=ftrjin->getQCharge();
  qcheck=ftrjin->getQCheck();

  version=ftrjin->getVersion();

  title=ftrjin->getTitle();
  natom=ftrjin->getNAtom();
  for (unsigned int i=0; i< ftrjin->getFixInxVecSize(); i++){
    fixinx.push_back(ftrjin->getFixInx(i));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x6486
movq %r14, %rdi
movq %r15, %rsi
callq 0x4370
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x38867
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rsp, %r15
movq %r12, (%r15)
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x6486
leaq 0x58(%r14), %rdi
movq %r15, %rsi
callq 0x4370
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x388a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movups 0x78(%rbx), %xmm0
movups %xmm0, 0x78(%r14)
movl 0x88(%rbx), %eax
movl %eax, 0x88(%r14)
movq 0x90(%rbx), %rax
movq %rax, 0x90(%r14)
movss 0x98(%rbx), %xmm0
movss %xmm0, 0x98(%r14)
movups 0x9c(%rbx), %xmm0
movups %xmm0, 0x9c(%r14)
movl 0xac(%rbx), %eax
movl %eax, 0xac(%r14)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x38a4c
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movups 0xb0(%r14), %xmm0
movq 0xc0(%r14), %rax
movaps (%r15), %xmm1
movups %xmm1, 0xb0(%r14)
movq 0x10(%r15), %rcx
movq %rcx, 0xc0(%r14)
movq 0x10(%rdi), %rcx
movq %rax, 0x10(%rdi)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movaps %xmm1, (%r15)
movq %rcx, 0x10(%r15)
callq 0x6420
movq %r15, %rdi
callq 0x6420
movl 0xc8(%rbx), %eax
movl %eax, 0xc8(%r14)
movq 0xd0(%rbx), %rax
movq 0xd8(%rbx), %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
je 0x389eb
leaq 0xd0(%r14), %r15
xorl %ebp, %ebp
movq %rsp, %r12
movslq %ebp, %rsi
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x389f8
movl (%rax,%rsi,4), %eax
movl %eax, (%rsp)
movq 0xd8(%r14), %rsi
cmpq 0xe0(%r14), %rsi
je 0x389c2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xd8(%r14)
jmp 0x389cd
movq %r15, %rdi
movq %r12, %rdx
callq 0x3a098
incl %ebp
movq 0xd0(%rbx), %rax
movq 0xd8(%rbx), %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x2, %rcx
cmpl %ecx, %ebp
jb 0x38991
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x392a(%rip), %rdi      # 0x3c329
xorl %eax, %eax
callq 0x4440
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::getTitle[abi:cxx11]()
std::vector<std::string> Trajectory::getTitle(){
  for (unsigned int i=0; i< title.size(); i++){
    if (title[i].find("*") != 0){
      title[i].insert(0,"*");
    }
    title[i].resize(80, ' ');
  }
  return title;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb0(%rsi), %r14
movq 0xb0(%rsi), %rdi
cmpq %rdi, 0xb8(%rsi)
je 0x38aee
movq %rsi, %r15
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x561c(%rip), %r12      # 0x3e09f
shlq $0x5, %r13
addq %r13, %rdi
movl $0x1, %ecx
movq %r12, %rsi
xorl %edx, %edx
callq 0x4520
testq %rax, %rax
je 0x38ab6
movq (%r14), %rdi
addq %r13, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x4320
addq 0xb0(%r15), %r13
movl $0x50, %esi
movq %r13, %rdi
movl $0x20, %edx
callq 0x40f0
movl %ebp, %r13d
movq 0xb0(%r15), %rdi
movq 0xb8(%r15), %rax
subq %rdi, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r13, %rax
ja 0x38a83
movq %rbx, %rdi
movq %r14, %rsi
callq 0x276e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::setTitle(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&)
void Trajectory::setTitle(const std::vector<std::string> &titlein){
  title=titlein;
  if (title.size() == 1){
    title.resize(2);
  }
  for (unsigned int i=0; i< title.size(); i++){
    if (title[i].find("*") != 0){
      title[i].insert(0,"*");
    }
    title[i].resize(80, ' ');
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xb0(%rdi), %r14
movq %r14, %rdi
callq 0x27cfe
movq 0xb8(%rbx), %rax
subq 0xb0(%rbx), %rax
cmpq $0x20, %rax
jne 0x399e3
movl $0x2, %esi
movq %r14, %rdi
callq 0x1fd76
movq 0xb0(%rbx), %rdi
cmpq %rdi, 0xb8(%rbx)
je 0x39a6d
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x469d(%rip), %r15      # 0x3e09f
shlq $0x5, %r12
addq %r12, %rdi
movl $0x1, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x4520
testq %rax, %rax
je 0x39a35
movq (%r14), %rdi
addq %r12, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4320
addq 0xb0(%rbx), %r12
movl $0x50, %esi
movq %r12, %rdi
movl $0x20, %edx
callq 0x40f0
movl %ebp, %r12d
movq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r12, %rax
ja 0x39a02
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::setTitle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&)
void Trajectory::setTitle(const std::string &titlein, const unsigned int &element){
  if (title.size() < element){
    title.resize(element);
  }
  title[element]=titlein;
  if (title.size() == 1){
    title.resize(2);
  }
  for (unsigned int i=0; i< title.size(); i++){
    if (title[i].find("*") != 0){
      title[i].insert(0,"*");
    }
    title[i].resize(80, ' ');
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0xb8(%rdi), %rax
subq 0xb0(%rdi), %rax
leaq 0xb0(%rdi), %r14
sarq $0x5, %rax
movl (%rdx), %esi
cmpq %rsi, %rax
jae 0x39aaf
movq %r14, %rdi
callq 0x1fd76
movl (%r12), %edi
shlq $0x5, %rdi
addq 0xb0(%rbx), %rdi
movq %r15, %rsi
callq 0x4180
movq 0xb8(%rbx), %rax
subq 0xb0(%rbx), %rax
cmpq $0x20, %rax
jne 0x39ae7
movl $0x2, %esi
movq %r14, %rdi
callq 0x1fd76
movq 0xb0(%rbx), %rdi
cmpq %rdi, 0xb8(%rbx)
je 0x39b71
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x4599(%rip), %r15      # 0x3e09f
shlq $0x5, %r12
addq %r12, %rdi
movl $0x1, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x4520
testq %rax, %rax
je 0x39b39
movq (%r14), %rdi
addq %r12, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4320
addq 0xb0(%rbx), %r12
movl $0x50, %esi
movq %r12, %rdi
movl $0x20, %edx
callq 0x40f0
movl %ebp, %r12d
movq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r12, %rax
ja 0x39b06
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::addTitle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Trajectory::addTitle(const std::string &titlein){
  title.push_back(titlein);
  for (unsigned int i=0; i< title.size(); i++){
    if (title[i].find("*") != 0){
      title[i].insert(0,"*");
    }
    title[i].resize(80, ' ');
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xb0(%rdi), %r14
movq %r14, %rdi
callq 0x62fa
movq 0xb0(%rbx), %rdi
cmpq %rdi, 0xb8(%rbx)
je 0x39c32
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x44d8(%rip), %r15      # 0x3e09f
shlq $0x5, %r12
addq %r12, %rdi
movl $0x1, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x4520
testq %rax, %rax
je 0x39bfa
movq (%r14), %rdi
addq %r12, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4320
addq 0xb0(%rbx), %r12
movl $0x50, %esi
movq %r12, %rdi
movl $0x20, %edx
callq 0x40f0
movl %ebp, %r12d
movq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r12, %rax
ja 0x39bc7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: Trajectory::binbuf* Trajectory::readFortran<Trajectory::binbuf>(std::basic_ifstream<char, std::char_traits<char>>&, Trajectory::binbuf*, int&)
BinBuf* Trajectory::readFortran(std::ifstream &trjin, BinBuf *buffer, int &length){
  int recStart;
  int recEnd;
  BinBuf *binOut;

  binOut=NULL;

  //Read Fortran record lengths and buffer
  trjin.read(reinterpret_cast<char*>(&recStart), sizeof(int));
  binOut = new BinBuf [recStart];
  trjin.read(reinterpret_cast<char*>(binOut), recStart);
  trjin.read(reinterpret_cast<char*>(&recEnd), sizeof(int));

  //Check Fortran record length mismatch
  if (recStart == recEnd){
    length=recStart;
  }
  else{
    std::cerr << "Error: Fortran record length marker mismatch" << std::endl;
    std::exit(0);
  }

  return binOut;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r15
leaq 0xc(%rsp), %r14
movl $0x4, %edx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x4390
movslq (%r14), %r13
leaq (,%r13,4), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x4030
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x4390
leaq 0x8(%rsp), %r13
movl $0x4, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x4390
movl (%r14), %eax
cmpl (%r13), %eax
jne 0x39d0c
movl %eax, (%rbx)
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3b72dd(%rip), %rdi    # 0x3f0ff0
leaq 0x42a3(%rip), %rsi      # 0x3dfbd
callq 0x42b0
movq %rax, %rdi
callq 0x4150
xorl %edi, %edi
callq 0x4360
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Trajectory.cpp
// Function: void Trajectory::writeFortran<Trajectory::binbuf>(std::basic_ofstream<char, std::char_traits<char>>&, Trajectory::binbuf*, int&)
void Trajectory::writeFortran(std::ofstream &trjout, BinBuf *buffer, int &length){
  
  //Write Fortran record lengths and buffer
  trjout.write(reinterpret_cast<char*>(&length), sizeof(int));
  trjout.write(reinterpret_cast<char*>(buffer), length);
  trjout.write(reinterpret_cast<char*>(&length), sizeof(int));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x4, %edx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x43b0
movslq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x43b0
movl $0x4, %edx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Coor.cpp
// Function: Coor::operator=(Coor const&)
Coor& Coor::operator= (const Coor& vec){
  xcoor=vec.xcoor;
  ycoor=vec.ycoor;
  zcoor=vec.zcoor;
  return(*this);
}

// Assembly:
movq %rdi, %rax
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Coor.cpp
// Function: Coor::operator=(double)
Coor& Coor::operator= (const double val){
  xcoor=val;
  ycoor=val;
  zcoor=val;
  return(*this);
}

// Assembly:
movq %rdi, %rax
movsd %xmm0, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Coor.cpp
// Function: Coor::operator+=(Coor const&)
Coor& Coor::operator+= (const Coor& vec){
  xcoor+=vec.xcoor;
  ycoor+=vec.ycoor;
  zcoor+=vec.zcoor;
  return(*this);
}

// Assembly:
movq %rdi, %rax
movupd (%rsi), %xmm0
movupd (%rdi), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Coor.cpp
// Function: Coor::operator+=(double)
Coor& Coor::operator+= (const double val){
  xcoor+=val;
  ycoor+=val;
  zcoor+=val;
  return(*this);
}

// Assembly:
movq %rdi, %rax
movupd (%rdi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
addpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Coor.cpp
// Function: Coor::cross(Coor const&) const
Coor Coor::cross (const Coor& vec) const { //Cross Product
  return Coor(ycoor*vec.zcoor - zcoor*vec.ycoor,
                zcoor*vec.xcoor - xcoor*vec.zcoor,
                xcoor*vec.ycoor - ycoor*vec.xcoor);
}

// Assembly:
movq %rdi, %rax
movsd (%rdx), %xmm0
movsd (%rsi), %xmm1
movupd 0x8(%rsi), %xmm2
movupd 0x8(%rdx), %xmm3
movapd %xmm2, %xmm4
shufpd $0x1, %xmm1, %xmm4      # xmm4 = xmm4[1],xmm1[0]
mulpd %xmm3, %xmm4
mulsd %xmm3, %xmm1
shufpd $0x1, %xmm0, %xmm3      # xmm3 = xmm3[1],xmm0[0]
mulpd %xmm2, %xmm3
subpd %xmm4, %xmm3
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movupd %xmm3, (%rdi)
movsd %xmm1, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/klmr[P]multifunction/./multicast.hpp
// Function: util::multifunction<void (int)>::remove(util::multifunction<void (int)>::handle)
void remove(handle handle) {
        auto i = handle_lookup[handle.id];

        if (i == NIL) return;

        // Adjust handle_lookup positions which have shifted.
        for (auto& handle_index : handle_lookup) {
            if (handle_index > i and handle_index != NIL) {
                --handle_index;
            }
        }

        listeners.erase(listeners.begin() + i);
        handle_lookup[handle.id] = NIL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq 0x18(%rdi), %rax
movq (%rax,%r14,8), %rsi
cmpq $-0x1, %rsi
je 0x202f
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
je 0x2014
movq (%rax), %rdx
cmpq %rsi, %rdx
setbe %dil
cmpq $-0x1, %rdx
sete %r8b
orb %dil, %r8b
jne 0x200e
decq %rdx
movq %rdx, (%rax)
addq $0x8, %rax
jmp 0x1fec
shlq $0x5, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2038
movq 0x18(%rbx), %rax
movq $-0x1, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/suyunu[P]Discrete-Event-Simulation/Main.cc
// Function: main
int main(int argc, char *argv[]){
	srand(time(0));
	
	RandQueuing rndQue(argv[1]);
	MinQueuing minQue(argv[1]);
	
	rndQue.simulate();
	minQue.simulate();
	
	rndQue.print(argv[2]);
	minQue.print(argv[3]);
	
	return (0-0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq 0x8(%rbx), %rsi
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x20b0
leaq -0x110(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x29f0
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2535
callq 0x2150
movq 0x8(%rbx), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x20b0
leaq -0xd0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3d10
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2568
callq 0x2150
leaq -0x110(%rbp), %rdi
callq 0x2ef2
leaq -0xd0(%rbp), %rdi
callq 0x4212
movq 0x10(%rbx), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x20b0
leaq -0x110(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x32d2
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25b3
callq 0x2150
movq 0x18(%rbx), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x20b0
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4622
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25e6
callq 0x2150
leaq -0xd0(%rbp), %rdi
callq 0x4134
leaq -0x110(%rbp), %rdi
callq 0x2e14
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
jmp 0x261c
jmp 0x2666
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2669
callq 0x2150
jmp 0x2669
jmp 0x2666
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2675
callq 0x2150
jmp 0x2675
movq %rax, %rbx
jmp 0x2675
movq %rax, %rbx
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2681
callq 0x2150
jmp 0x2681
movq %rax, %rbx
jmp 0x2681
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x4134
leaq -0x110(%rbp), %rdi
callq 0x2e14
movq %rbx, %rdi
callq 0x2250
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/suyunu[P]Discrete-Event-Simulation/Job.cpp
// Function: Job::initialize(int, double)
void Job::initialize(int No, double enter_time){
	no = No;
	enterTime = enter_time;
	timeToGo = enter_time;
	cond = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm0, 0x10(%rdi)
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/suyunu[P]Discrete-Event-Simulation/RandQueuing.cpp
// Function: RandQueuing::work(Job&, int)
bool RandQueuing::work(Job& myJob, int k){
	myJob.cond = k;
	if(!units[k].isWorking){
		units[k].Jcounter++;
		units[k].isWorking = true;
		myJob.timeToGo += units[k].procTime;
		
		order.push_back(myJob);
		push_heap (order.begin(),order.end(),greater1());
	}
	else{
		units[k].jobQ.push(myJob);
		if(units[k].jobQ.size() > units[k].maxQ){
			units[k].maxQ = units[k].jobQ.size();
		}
	}
	jobs[myJob.no] = myJob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %edx, 0x18(%rsi)
movq 0x20(%rdi), %rax
movslq %edx, %rcx
imulq $0x70, %rcx, %r14
leaq (%rax,%r14), %rdi
cmpb $0x0, 0x6c(%rax,%r14)
je 0x3241
addq $0x10, %rdi
callq 0x366c
movq 0x20(%rbx), %rax
leaq (%rax,%r14), %rdi
addq $0x10, %rdi
callq 0x369c
movq 0x20(%rbx), %rax
leaq (%rax,%r14), %rdi
addq $0x10, %rdi
callq 0x369c
incl 0x64(%rdi)
movb $0x1, 0x6c(%rax,%r14)
movsd 0x8(%rax,%r14), %xmm0
addsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rsi)
leaq 0x28(%rbx), %rdi
callq 0x353c
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x35ad
nop
// File: /workspace/github_cpp_makefile_star2_O1/suyunu[P]Discrete-Event-Simulation/RandQueuing.cpp
// Function: RandQueuing::whereToGoRand(Job&)
int RandQueuing::whereToGoRand(Job& myJob){
	if(units[myJob.cond].edges > 0){
		int rnd = rand() % units[myJob.cond].edges;
		list<int>::iterator it = adj[myJob.cond].begin();
		for(int i = 0 ; i < rnd ; i++, it++);
		return *it;
	}
	else
		return -1;
}

// Assembly:
movq 0x20(%rdi), %rax
movslq 0x18(%rsi), %rcx
imulq $0x70, %rcx, %rcx
cmpl $0x0, 0x68(%rax,%rcx)
jle 0x32cc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2070
movq 0x20(%rbx), %rcx
movslq 0x18(%r14), %rsi
imulq $0x70, %rsi, %rdi
cltd
idivl 0x68(%rcx,%rdi)
leaq (%rsi,%rsi,2), %rax
shlq $0x3, %rax
addq 0x10(%rbx), %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
incl %ecx
movq (%rax), %rax
decl %ecx
jne 0x32bd
movl 0x10(%rax), %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/suyunu[P]Discrete-Event-Simulation/MinQueuing.cpp
// Function: MinQueuing::whereToGoMin(Job&)
int MinQueuing::whereToGoMin(Job& myJob){
	int i, minQ, xQ;
	minQ = N_job+1;
	if(units[myJob.cond].edges > 0){
		for(list<int>::iterator it = adj[myJob.cond].begin() ; it != adj[myJob.cond].end() ; it++){
			if(units[*it].jobQ.size() < minQ){
				minQ = units[*it].jobQ.size();
				xQ = *it;
			}
		}
		return xQ;
	}
	else
		return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x20(%rdi), %rcx
movslq 0x18(%rsi), %rax
imulq $0x70, %rax, %rdx
cmpl $0x0, 0x68(%rcx,%rdx)
jle 0x461a
movl (%rdi), %edx
incl %edx
movq 0x10(%rdi), %rsi
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax,8), %rsi
movq (%rsi), %rdi
movslq 0x10(%rdi), %r8
imulq $0x70, %r8, %r9
movq 0x58(%rcx,%r9), %r10
movq %r10, %r11
subq 0x38(%rcx,%r9), %r11
shrq $0x3, %r11
cmpq $0x1, %r10
adcq $-0x1, %r11
shlq $0x4, %r11
movq 0x30(%rcx,%r9), %r10
movq 0x40(%rcx,%r9), %rbx
subq 0x48(%rcx,%r9), %rbx
subq 0x20(%rcx,%r9), %r10
sarq $0x5, %rbx
sarq $0x5, %r10
addq %rbx, %r10
addq %r11, %r10
movslq %edx, %rdx
cmpq %rdx, %r10
cmovbl %r10d, %edx
cmovbl %r8d, %eax
movq (%rdi), %rdi
cmpq %rsi, %rdi
jne 0x45bb
jmp 0x461f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dlbeer[P]summary_map/test_rbt.cpp
// Function: check_present(summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>>> const&, unsigned int, unsigned int)
static void check_present(const test_map& m, const test_vector& vec,
			  unsigned int start, unsigned int end)
{
    for (unsigned int i = start; i < end; i++) {
	test_map::const_iterator it = m.find(vec[i].first);

	assert(it != m.end());
	assert(it->first == vec[i].first);
	assert(it->second == vec[i].second);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testl %edx, %edx
je 0x2963
movl %edx, %ebx
movq %rsi, %r14
movq (%rsp), %rax
leaq 0x8(%rax), %r12
xorl %ebp, %ebp
movq (%r14), %rsi
addq %rbp, %rsi
movq (%rsp), %rdi
movq %r12, %rdx
callq 0x2ae2
cmpq %r12, %rax
je 0x2991
movq %rax, %r13
movq (%r14), %r15
movq 0x8(%rax), %rdx
cmpq 0x8(%r15,%rbp), %rdx
jne 0x2972
testq %rdx, %rdx
je 0x2950
movq (%r15,%rbp), %rsi
movq (%r13), %rdi
callq 0x2140
testl %eax, %eax
jne 0x2972
movl 0x20(%r13), %eax
cmpl 0x20(%r15,%rbp), %eax
jne 0x29b0
addq $0x28, %rbp
decl %ebx
jne 0x2912
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1844(%rip), %rdi      # 0x41bd
leaq 0x16c1(%rip), %rsi      # 0x4041
leaq 0x17e0(%rip), %rcx      # 0x4167
movl $0x20, %edx
callq 0x20b0
leaq 0x17c1(%rip), %rdi      # 0x4159
leaq 0x16a2(%rip), %rsi      # 0x4041
leaq 0x17c1(%rip), %rcx      # 0x4167
movl $0x1f, %edx
callq 0x20b0
leaq 0x1820(%rip), %rdi      # 0x41d7
leaq 0x1683(%rip), %rsi      # 0x4041
leaq 0x17a2(%rip), %rcx      # 0x4167
movl $0x21, %edx
callq 0x20b0
nop