LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5730
movq 0x10(%rsp), %rdx
leaq 0xb58c(%rip), %rsi      # 0x7c4d6
leaq 0x90(%rsp), %rdi
callq 0x7900
jmp 0x70f59
movq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x711d0
jmp 0x70f6d
leaq 0x90(%rsp), %rdi
callq 0x5250
leaq 0x8f(%rsp), %rdi
callq 0x5480
leaq 0x57(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5730
movq (%rsp), %rdx
leaq 0xbef0(%rip), %rsi      # 0x7ce90
leaq 0x58(%rsp), %rdi
callq 0x7900
jmp 0x70fac
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x71200
jmp 0x70fbd
leaq 0x58(%rsp), %rdi
callq 0x5250
leaq 0x57(%rsp), %rdi
callq 0x5480
movq 0x8(%rsp), %rdi
movl $0x0, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x71230
movq 0x8(%rsp), %rdi
movl $0x1, 0x4c(%rsp)
leaq 0x4c(%rsp), %rsi
callq 0x71250
movq 0x8(%rsp), %rdi
movl $0x1, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x71270
movq 0x8(%rsp), %rdi
movl $0x1, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
callq 0x71290
movq 0x8(%rsp), %rdi
movl $0x0, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x712b0
movq 0x8(%rsp), %rdi
movl $0x0, 0x3c(%rsp)
leaq 0x3c(%rsp), %rsi
callq 0x712d0
movq 0x8(%rsp), %rdi
movl $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x712f0
movq 0x8(%rsp), %rdi
movsd 0xa2f1(%rip), %xmm0     # 0x7b370
movsd %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x71310
movq 0x8(%rsp), %rdi
movl $0x0, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x71380
movq 0x8(%rsp), %rdi
movl $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x713a0
movq 0x8(%rsp), %rdi
movl $0x0, 0x24(%rsp)
leaq 0x24(%rsp), %rsi
callq 0x713c0
movq 0x8(%rsp), %rdi
movl $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x713e0
movq 0x8(%rsp), %rdi
movl $0x0, 0x1c(%rsp)
leaq 0x1c(%rsp), %rsi
callq 0x71400
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
callq 0x7800
movq 0x8(%rsp), %rdi
movl $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x71420
movq 0x8(%rsp), %rdi
addq $0xd0, %rdi
callq 0x3ec90
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x71174
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5250
leaq 0x8f(%rsp), %rdi
callq 0x5480
jmp 0x711bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x711b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5250
leaq 0x57(%rsp), %rdi
callq 0x5480
movq 0x80(%rsp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x55e0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0x74b20
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x58, %rdi
movq 0x18(%rsp), %rsi
movl $0x4, %edx
callq 0x55c0
cmpl $0x54, 0x14(%rsp)
jne 0x714e2
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
leaq 0xb9d2(%rip), %rsi      # 0x7ce90
callq 0x5140
cmpl $0x0, %eax
jne 0x714e2
movq 0x8(%rsp), %rdi
leaq 0xb002(%rip), %rsi      # 0x7c4d6
callq 0x55f0
movq 0x8(%rsp), %rax
movb $0x0, 0x20(%rax)
cmpq $0x0, 0x18(%rsp)
je 0x71509
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x71507
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x5420
jmp 0x71509
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x55e0
movq 0x8(%rsp), %rdi
callq 0x71550
movq 0x8(%rsp), %rdi
callq 0x5630
cmpq $0x0, %rax
jbe 0x7153a
movb $0x1, 0x37(%rsp)
jmp 0x7153f
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x58, %rdi
callq 0x5580
movq 0x8(%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 0x8(%rsp), %rdi
movl $0x0, 0xc8(%rdi)
addq $0xd0, %rdi
callq 0x3ec90
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x72af0
movq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5510
leaq 0x58(%rsp), %rdi
callq 0x5250
movq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x72b20
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
leaq 0x38(%rsp), %rsi
callq 0x5510
leaq 0x38(%rsp), %rdi
callq 0x5250
movq 0x78(%rsp), %rdi
callq 0x72670
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x78(%rax)
movq 0x78(%rsp), %rdi
callq 0x72680
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x7c(%rax)
movq 0x78(%rsp), %rdi
callq 0x72690
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x80(%rax)
movq 0x78(%rsp), %rdi
callq 0x726b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x84(%rax)
movq 0x78(%rsp), %rdi
callq 0x726d0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x88(%rax)
movq 0x78(%rsp), %rdi
callq 0x726f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x90(%rax)
movq 0x78(%rsp), %rdi
callq 0x72710
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x94(%rax)
movq 0x78(%rsp), %rdi
callq 0x72730
movq 0x10(%rsp), %rax
movss %xmm0, 0x98(%rax)
movq 0x78(%rsp), %rdi
callq 0x72750
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x9c(%rax)
movq 0x78(%rsp), %rdi
callq 0x72770
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xa0(%rax)
movq 0x78(%rsp), %rdi
callq 0x72790
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xa4(%rax)
movq 0x78(%rsp), %rdi
callq 0x727b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xa8(%rax)
movq 0x78(%rsp), %rdi
callq 0x727d0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xac(%rax)
movq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x72b50
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
leaq 0x20(%rsp), %rsi
callq 0x750c0
leaq 0x20(%rsp), %rdi
callq 0x7ab0
movq 0x78(%rsp), %rdi
callq 0x72c60
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc8(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x78(%rsp), %rdi
callq 0x72c80
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x72ae0
movq 0x10(%rsp), %rax
addq $0xd0, %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x72ca0
movq (%rsp), %rdi
movl %eax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x75100
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x72a88
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movq %rax, (%rsp)
addq $0xb0, %rdi
callq 0x78e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x72c39
movq 0x18(%rsp), %rdi
addq $0xb0, %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
leaq 0xa3b0(%rip), %rsi      # 0x7cf77
xorl %eax, %eax
movl %eax, %edx
callq 0x57d0
cmpq $0x0, %rax
je 0x72c00
movq 0x18(%rsp), %rdi
addq $0xb0, %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xa37c(%rip), %rdx      # 0x7cf77
callq 0x5110
movq 0x18(%rsp), %rdi
addq $0xb0, %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
movl $0x50, %esi
movl $0x20, %edx
callq 0x5150
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x72b7d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0xb0, %rsi
callq 0x48a70
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
addq $0xb0, %rdi
callq 0x4a090
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
callq 0x78e0
cmpq $0x1, %rax
jne 0x746e6
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl $0x2, %esi
callq 0x385d0
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
addq $0xb0, %rdi
callq 0x78e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x747aa
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
leaq 0x883f(%rip), %rsi      # 0x7cf77
xorl %eax, %eax
movl %eax, %edx
callq 0x57d0
cmpq $0x0, %rax
je 0x74771
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x880b(%rip), %rdx      # 0x7cf77
callq 0x5110
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
movl $0x50, %esi
movl $0x20, %edx
callq 0x5150
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x746ee
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0xb0, %rdi
callq 0x78e0
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x747ff
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x385d0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xb0, %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x9020
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5060
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
callq 0x78e0
cmpq $0x1, %rax
jne 0x7485d
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
movl $0x2, %esi
callq 0x385d0
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, (%rsp)
addq $0xb0, %rdi
callq 0x78e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x74921
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
leaq 0x86c8(%rip), %rsi      # 0x7cf77
xorl %eax, %eax
movl %eax, %edx
callq 0x57d0
cmpq $0x0, %rax
je 0x748e8
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x8694(%rip), %rdx      # 0x7cf77
callq 0x5110
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
movl $0x50, %esi
movl $0x20, %edx
callq 0x5150
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x74865
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xb0, %rdi
movq 0x18(%rsp), %rsi
callq 0x7870
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
addq $0xb0, %rdi
callq 0x78e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x74a3d
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
leaq 0x85ac(%rip), %rsi      # 0x7cf77
xorl %eax, %eax
movl %eax, %edx
callq 0x57d0
cmpq $0x0, %rax
je 0x74a04
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x8578(%rip), %rdx      # 0x7cf77
callq 0x5110
movq 0x8(%rsp), %rdi
addq $0xb0, %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9020
movq %rax, %rdi
movl $0x50, %esi
movl $0x20, %edx
callq 0x5150
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x74981
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
movl $0x4, %edx
callq 0x5540
movslq 0x14(%rsp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x5540
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x5540
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x74bbf
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x74be8
movq 0x3c642a(%rip), %rdi    # 0x43aff0
leaq 0x82c8(%rip), %rsi      # 0x7ce95
callq 0x53f0
movq %rax, %rdi
movq 0x3c63cc(%rip), %rsi    # 0x43afa8
callq 0x5460
xorl %edi, %edi
callq 0x5500
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x5590
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movslq (%rax), %rdx
callq 0x5590
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x4, %edx
callq 0x5590
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rsp), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm2
movsd 0x10(%rax), %xmm1
movq 0x10(%rsp), %rcx
mulsd 0x8(%rcx), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rax), %xmm1
movq 0x10(%rsp), %rcx
movsd (%rcx), %xmm3
movsd (%rax), %xmm2
movq 0x10(%rsp), %rcx
mulsd 0x10(%rcx), %xmm2
movq %xmm2, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd (%rax), %xmm2
movq 0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm4
movsd 0x8(%rax), %xmm3
movq 0x10(%rsp), %rax
mulsd (%rax), %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
callq 0x76090
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x18, %rdi
movl -0x4(%rbp), %eax
movl %eax, %esi
callq 0x4fb0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x4ed8
jmp 0x4fa5
movq -0x60(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4fd0
testb $0x1, %al
jne 0x4f11
jmp 0x4f50
leaq -0x28(%rbp), %rdi
callq 0x42b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jbe 0x4f43
movq -0x38(%rbp), %rax
cmpq $-0x1, (%rax)
je 0x4f43
movq -0x38(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x4f45
leaq -0x28(%rbp), %rdi
callq 0x5010
jmp 0x4efe
movq -0x60(%rbp), %rdi
callq 0x32b0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x50a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x50e0
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x5030
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x18, %rdi
movl -0x4(%rbp), %eax
movl %eax, %esi
callq 0x4fb0
movq $-0x1, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x18(%rcx)
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x6c(%rax)
jne 0x4270
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rax
movslq -0x14(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl 0x64(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x64(%rax)
movq 0x20(%rdi), %rax
movslq -0x14(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x6c(%rax)
movq 0x20(%rdi), %rax
movslq -0x14(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x4770
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x4820
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x4850
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4a80
jmp 0x42ff
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x4b60
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
callq 0x4b90
movq -0x38(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movslq 0x60(%rcx), %rcx
cmpq %rcx, %rax
jbe 0x42fd
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
callq 0x4b90
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x60(%rax)
jmp 0x42ff
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
ud2
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x18(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x68(%rax)
jle 0x43ef
callq 0x2070
movq -0x40(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x18(%rbp), %rdx
movslq 0x18(%rdx), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
cltd
idivl 0x68(%rcx)
movq -0x40(%rbp), %rax
movl %edx, -0x1c(%rbp)
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x18(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x4bb0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x43df
jmp 0x43c5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x4be0
movq %rax, -0x38(%rbp)
jmp 0x43bb
leaq -0x28(%rbp), %rdi
callq 0x4c10
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x43f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x18(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x68(%rax)
jle 0x7b33
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x18(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x4bb0
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x18(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x5230
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7e40
testb $0x1, %al
jne 0x7aa3
jmp 0x7b2b
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4c10
movq -0x50(%rbp), %rdi
movslq (%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
callq 0x4b90
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x7b15
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4c10
movq -0x58(%rbp), %rdi
movslq (%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
callq 0x4b90
movl %eax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4c10
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x7b17
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x4be0
movq %rax, -0x40(%rbp)
jmp 0x7a6d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7b3a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jae 0x2cc0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x3140
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3100
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x3180
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x32f0
testb $0x1, %al
jne 0x2bec
jmp 0x2bee
jmp 0x2c0d
leaq 0x353a(%rip), %rdi      # 0x612f
leaq 0x3445(%rip), %rsi      # 0x6041
movl $0x1f, %edx
leaq 0x3535(%rip), %rcx      # 0x613d
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x33b0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x3140
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3310
testb $0x1, %al
jne 0x2c3f
jmp 0x2c41
jmp 0x2c60
leaq 0x354b(%rip), %rdi      # 0x6193
leaq 0x33f2(%rip), %rsi      # 0x6041
movl $0x20, %edx
leaq 0x34e2(%rip), %rcx      # 0x613d
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x33b0
movl 0x20(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x3140
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl 0x20(%rcx), %eax
jne 0x2c8f
jmp 0x2cae
leaq 0x3517(%rip), %rdi      # 0x61ad
leaq 0x33a4(%rip), %rsi      # 0x6041
movl $0x21, %edx
leaq 0x3494(%rip), %rcx      # 0x613d
callq 0x20e0
jmp 0x2cb0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2b8e
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk-extras/exprtk_instruction_primer.cpp
// Function: bool pgo_primer<double>()::execute::process(double&, double&, exprtk::expression<double>&)
static inline T process(T& x, T& y, expression_t& expression)
      {
         static const T lower_bound = T(-20);
         static const T upper_bound = T(+20);
         static const T delta       = T(0.1);

         T total = T(0);

         for (x = lower_bound; x <= upper_bound; x += delta)
         {
            for (y = lower_bound; y <= upper_bound; y += delta)
            {
               total += expression.value();
            }
         }

         return total;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movsd 0x32a607(%rip), %xmm0   # 0x44c230
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
movsd 0x32a4a6(%rip), %xmm0   # 0x44c0e0
ucomisd (%rax), %xmm0
jb 0x121caa
movq 0x18(%rsp), %rax
movsd 0x32a5e3(%rip), %xmm0   # 0x44c230
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movsd 0x32a482(%rip), %xmm0   # 0x44c0e0
ucomisd (%rax), %xmm0
jb 0x121c91
movq 0x10(%rsp), %rdi
callq 0x44aa80
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movsd 0x32a5b1(%rip), %xmm0   # 0x44c238
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x121c51
jmp 0x121c93
movq 0x20(%rsp), %rax
movsd 0x32a598(%rip), %xmm0   # 0x44c238
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x121c2d
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/apps/mshparam/mshparam.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Check number of arguments
  if (!ParseArgs(argc, argv)) exit(1);

  // Read input mesh
  R3Mesh *mesh = ReadMesh(input_mesh_filename);
  if (!mesh) exit(-1);

  // Segment mesh
  if (!ParameterizeMesh(mesh)) exit(-1);

  // Normalize texture coordinates
  if (!NormalizeTextureCoordinates(mesh)) exit(-1);

  // Flatten mesh
  if (!FlattenMesh(mesh)) exit(-1);

  // Write mesh
  if (!WriteMesh(mesh, output_mesh_filename)) exit(-1);

  // Write textures
  if (!WriteTextures(mesh, output_texture_directory, texel_spacing)) exit(-1);

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x12550
cmpl $0x0, %eax
jne 0x12492
movl $0x1, %edi
callq 0xf5e0
movq 0x14b86f(%rip), %rdi    # 0x15dd08
callq 0x12810
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x124b3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf5e0
movq (%rsp), %rdi
callq 0x12970
cmpl $0x0, %eax
jne 0x124cb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf5e0
movq (%rsp), %rdi
callq 0x12af0
cmpl $0x0, %eax
jne 0x124e3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf5e0
movq (%rsp), %rdi
callq 0x12e70
cmpl $0x0, %eax
jne 0x124fb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf5e0
movq (%rsp), %rdi
movq 0x14b80a(%rip), %rsi    # 0x15dd10
callq 0x12f50
cmpl $0x0, %eax
jne 0x1251a
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf5e0
movq (%rsp), %rdi
movq 0x14b7f3(%rip), %rsi    # 0x15dd18
movsd 0x14afa3(%rip), %xmm0   # 0x15d4d0
callq 0x13060
cmpl $0x0, %eax
jne 0x12541
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf5e0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshparam/mshparam.cpp
// Function: ParameterizeMesh(gaps::R3Mesh*)
static int
ParameterizeMesh(R3Mesh *mesh)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Create segments
  RNArray<Segment *> segments;
  if (!CreateSegments(mesh, segments)) return 0;

  // Parameterize segments
  if (!ParameterizeSegments(mesh, segments)) return 0;
  
  // Delete segments
  if (!DeleteSegments(mesh, segments)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Parameterized mesh ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Segments = %d\n", segments.NEntries());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xbfe30
movq 0x10(%rsp), %rdi
callq 0x16240
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x162d0
movq 0x18(%rsp), %rsi
movq 0x58(%rsp), %rdi
callq 0x15050
movl %eax, 0x24(%rsp)
jmp 0x129b6
movl 0x24(%rsp), %eax
cmpl $0x0, %eax
jne 0x129f1
movl $0x0, 0x64(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x12ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x162e0
jmp 0x12ae5
movq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x15d70
movl %eax, 0xc(%rsp)
jmp 0x12a06
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x12a24
movl $0x0, 0x64(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x12ad2
movq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x160f0
movl %eax, 0x8(%rsp)
jmp 0x12a39
movl 0x8(%rsp), %eax
cmpl $0x0, %eax
jne 0x12a54
movl $0x0, 0x64(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x12ad2
cmpl $0x0, 0x14b2c5(%rip)    # 0x15dd20
je 0x12ac2
leaq 0x10f709(%rip), %rdi    # 0x12216d
xorl %eax, %eax
callq 0xf070
jmp 0x12a6d
leaq 0x48(%rsp), %rdi
callq 0xbfef0
movsd %xmm0, (%rsp)
jmp 0x12a7e
movsd (%rsp), %xmm0
leaq 0x10f699(%rip), %rdi    # 0x122123
movb $0x1, %al
callq 0xf070
jmp 0x12a93
leaq 0x38(%rsp), %rdi
callq 0x162c0
movl %eax, %esi
leaq 0x10f6df(%rip), %rdi    # 0x122185
xorl %eax, %eax
callq 0xf070
jmp 0x12aaf
movq 0x14a4da(%rip), %rax    # 0x15cf90
movq (%rax), %rdi
callq 0xf5b0
jmp 0x12ac0
jmp 0x12ac2
movl $0x1, 0x64(%rsp)
movl $0x1, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x162e0
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xf830
nop
// File: tomfunkhouser[P]gaps/apps/mshparam/mshparam.cpp
// Function: FlattenMesh(gaps::R3Mesh*)
static int
FlattenMesh(R3Mesh *mesh)
{
  // This is useful for debugging
  if (!flatten) return 1;

  // Replace all vertex positions with texture coordinates
  for (int i = 0; i < mesh->NVertices(); i++) {
    R3MeshVertex *vertex = mesh->Vertex(i);
    R2Point texcoords = mesh->VertexTextureCoords(vertex);
    R3Point flattened_position(texcoords.X(), texcoords.Y(), 0);
    mesh->SetVertexPosition(vertex, flattened_position);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
cmpl $0x0, 0x14aea8(%rip)    # 0x15dd28
jne 0x12e8f
movl $0x1, 0x54(%rsp)
jmp 0x12f40
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rdi
callq 0x162a0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x12f38
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x16300
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x19b40
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0xb2290
leaq 0x28(%rsp), %rdi
callq 0x199f0
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x19a40
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
leaq 0x10(%rsp), %rdi
xorps %xmm2, %xmm2
callq 0x617d0
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x21fc0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x12e97
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/mshparam/mshparam.cpp
// Function: WriteMesh(gaps::R3Mesh*, char*)
static int
WriteMesh(R3Mesh *mesh, char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write mesh
  if (!mesh->WriteFile(filename)) {
    fprintf(stderr, "Unable to write mesh to %s\n", filename);
    return 0;
  }

  // Print statistics
  if (print_verbose) {
    printf("Wrote mesh to %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xbfe30
movq %rsp, %rdi
callq 0x16240
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x1d0(%rax)
cmpl $0x0, %eax
jne 0x12fb0
movq 0x14a03b(%rip), %rax    # 0x15cfc8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x10f1fc(%rip), %rsi    # 0x122198
movb $0x0, %al
callq 0xf6d0
movl $0x0, 0x24(%rsp)
jmp 0x1304b
cmpl $0x0, 0x14ad69(%rip)    # 0x15dd20
je 0x13043
movq 0x10(%rsp), %rsi
leaq 0x10f1eb(%rip), %rdi    # 0x1221b4
movb $0x0, %al
callq 0xf070
movq %rsp, %rdi
callq 0xbfef0
leaq 0x10f144(%rip), %rdi    # 0x122123
movb $0x1, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x16260
movl %eax, %esi
leaq 0x10f141(%rip), %rdi    # 0x12213a
movb $0x0, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x16280
movl %eax, %esi
leaq 0x10f137(%rip), %rdi    # 0x12214a
movb $0x0, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x162a0
movl %eax, %esi
leaq 0x10f12d(%rip), %rdi    # 0x12215a
movb $0x0, %al
callq 0xf070
movq 0x149f55(%rip), %rax    # 0x15cf90
movq (%rax), %rdi
callq 0xf5b0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshparam/mshparam.cpp
// Function: DeleteSegments(gaps::R3Mesh*, gaps::RNArray<Segment*> const&)
static int 
DeleteSegments(R3Mesh *mesh, const RNArray<Segment *>& segments)
{
  // Delete each segment
  for (int i = 0; i < segments.NEntries(); i++) {
    Segment *segment = segments.Kth(i);
    delete segment;
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x162c0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x1616d
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x16850
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1615e
movq 0x8(%rsp), %rdi
callq 0x19ae0
movq 0x8(%rsp), %rdi
movl $0xe0, %esi
callq 0xf4c0
jmp 0x16160
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x16106
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshparam/mshparam.cpp
// Function: CompareSegments(void const*, void const*)
static int 
CompareSegments(const void *data1, const void *data2)
{
  // Sort by bbox.xlength
  Segment *segment1 = *((Segment **) data1);
  Segment *segment2 = *((Segment **) data2);
  if (segment1->bbox.XLength() > segment2->bbox.XLength()) return -1;
  else if (segment1->bbox.XLength() < segment2->bbox.XLength()) return 1;
  else return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0xb0, %rdi
callq 0x19870
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
callq 0x19870
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x161e9
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x1622d
movq 0x18(%rsp), %rdi
addq $0xb0, %rdi
callq 0x19870
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
callq 0x19870
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x16225
movl $0x1, 0x34(%rsp)
jmp 0x1622d
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/useStrVec.cc
// Function: getVec(std::istream&)
StrVec getVec(istream& is)
{
	StrVec svec;
	string s;
	while (is >> s)
		svec.push_back(s); // svec.push_back(std::move(s));

	return svec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x31d0
leaq -0x38(%rbp), %rdi
callq 0x21a0
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2170
movq %rax, -0x60(%rbp)
jmp 0x2550
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2160
movb %al, -0x61(%rbp)
jmp 0x2568
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2571
jmp 0x25a2
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3220
jmp 0x2580
jmp 0x253d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq -0x58(%rbp), %rdi
callq 0x3290
jmp 0x25c8
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
testb $0x1, -0x11(%rbp)
jne 0x25be
movq -0x58(%rbp), %rdi
callq 0x3290
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x21f0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/./StrVec.h
// Function: StrVec::StrVec(StrVec const&)
inline
StrVec::StrVec(const StrVec& s)
{
	std::cout << "StrVec copy constructor." << std::endl;
	// call alloc_n_copy to allocate exactly as many elements as in s
	auto newdata = alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x2c49(%rip), %rdi      # 0x5fd8
leaq 0xe03(%rip), %rsi       # 0x4199
callq 0x2110
movq %rax, %rdi
movq 0x2c23(%rip), %rsi      # 0x5fc8
callq 0x2140
movq -0x10(%rbp), %rdi
callq 0x3190
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31b0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rdx
callq 0x3a70
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/./StrVec.h
// Function: StrVec::operator=(StrVec const&)
inline
StrVec& StrVec::operator=(const StrVec& rhs)
{
	std::cout << "StrVec copy assignment." << std::endl;
	// call alloc_n_copy to allocate exactly as many elements as in rhs
	auto data = alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x2bb9(%rip), %rdi      # 0x5fd8
leaq 0xd8c(%rip), %rsi       # 0x41b2
callq 0x2110
movq %rax, %rdi
movq 0x2b93(%rip), %rsi      # 0x5fc8
callq 0x2140
movq -0x10(%rbp), %rdi
callq 0x3190
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31b0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rdx
callq 0x3a70
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3970
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/./StrVec.h
// Function: StrVec::operator=(StrVec&&)
inline
StrVec& StrVec::operator=(StrVec&& rhs) noexcept
{
	std::cout << "StrVec move assignment." << std::endl;
	// direct test for self-assignment
	if (this != &rhs) {
		free();                   // free existing elements
		elements = rhs.elements;  // take over resources from rhs
		first_free = rhs.first_free;
		cap = rhs.cap;
		// leave rhs in a destructible state
		rhs.elements = rhs.first_free = rhs.cap = nullptr;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2b29(%rip), %rdi      # 0x5fd8
leaq 0xd14(%rip), %rsi       # 0x41ca
callq 0x2110
movq %rax, -0x18(%rbp)
jmp 0x34c1
movq -0x18(%rbp), %rdi
movq 0x2afc(%rip), %rsi      # 0x5fc8
callq 0x2140
jmp 0x34d3
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x3531
movq -0x20(%rbp), %rdi
callq 0x3970
jmp 0x34e8
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3a60
nopw %cs:(%rax,%rax)
nopl (%rax)