LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::reset()
void Atom::reset(){
  tag="NoID";
  recname="ATOM";
  atmnum=0;
  atmname="    ";
  atmtype="  ";
  alt=" ";
  res=NULL;
  resname="   ";
  chn=NULL;
  chainid=" ";
  realid=" ";
  resid=0;
  coor=Coor(0.0, 0.0, 0.0);
  occu=0.0;
  bfac=0.0;
  elem=" ";
  segid="  ";
  sel=true;
  summary="";
  ss="";
  mass=1.0;
  charge=0.0;
  data.clear();
  bonds.clear();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x5c4f0(%rip), %rsi     # 0x7b5d9
callq 0x55f0
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x5c4e1(%rip), %rsi     # 0x7b5de
callq 0x55f0
movq (%rsp), %rdi
movl $0x0, 0x40(%rdi)
addq $0x48, %rdi
leaq 0x5d47d(%rip), %rsi     # 0x7c595
callq 0x55f0
movq (%rsp), %rdi
addq $0x68, %rdi
leaq 0x5d46b(%rip), %rsi     # 0x7c597
callq 0x55f0
movq (%rsp), %rdi
addq $0x88, %rdi
leaq 0x5d455(%rip), %rsi     # 0x7c598
callq 0x55f0
movq (%rsp), %rdi
movq $0x0, 0xa8(%rdi)
addq $0xb0, %rdi
leaq 0x5d431(%rip), %rsi     # 0x7c596
callq 0x55f0
movq (%rsp), %rdi
movq $0x0, 0xd0(%rdi)
addq $0xd8, %rdi
leaq 0x5d411(%rip), %rsi     # 0x7c598
callq 0x55f0
movq (%rsp), %rdi
addq $0xf8, %rdi
leaq 0x5d3fa(%rip), %rsi     # 0x7c598
callq 0x55f0
movq (%rsp), %rax
movl $0x0, 0x118(%rax)
leaq 0x8(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x76090
movq (%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq 0x8(%rsp), %rsi
callq 0x76110
movq (%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rdi)
addq $0x1e0, %rdi            # imm = 0x1E0
leaq 0x5d397(%rip), %rsi     # 0x7c598
callq 0x55f0
movq (%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
leaq 0x5d37f(%rip), %rsi     # 0x7c597
callq 0x55f0
movq (%rsp), %rdi
movb $0x1, 0x188(%rdi)
addq $0x190, %rdi            # imm = 0x190
leaq 0x5c17c(%rip), %rsi     # 0x7b3b2
callq 0x55f0
movq (%rsp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
leaq 0x5c165(%rip), %rsi     # 0x7b3b2
callq 0x55f0
movq (%rsp), %rdi
movsd 0x5c112(%rip), %xmm0    # 0x7b370
movsd %xmm0, 0x1d0(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d8(%rdi)
addq $0x208, %rdi            # imm = 0x208
callq 0x16980
movq (%rsp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x202c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::dummy()
void Atom::dummy(){
  tag="NoID";
  recname="ATOM";
  atmnum=1;
  atmname="CA";
  atmtype="C.3";
  alt=" ";
  res=NULL;
  resname="ALA";
  chn=NULL;
  chainid="+";
  realid="+";
  resid=999;
  coor=Coor(0.0, 0.0, 0.0);
  occu=0.0;
  bfac=0.0;
  elem=" ";
  segid="DUMY";
  sel=true;
  summary="";
  ss="";
  mass=1.0;
  charge=0.0;
  atminx=std::numeric_limits<unsigned int>::max();
  data.clear();
  bonds.clear();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x5bd40(%rip), %rsi     # 0x7b5d9
callq 0x55f0
movq (%rsp), %rdi
addq $0x20, %rdi
leaq 0x5bd31(%rip), %rsi     # 0x7b5de
callq 0x55f0
movq (%rsp), %rdi
movl $0x1, 0x40(%rdi)
addq $0x48, %rdi
leaq 0x5b9a9(%rip), %rsi     # 0x7b271
callq 0x55f0
movq (%rsp), %rdi
addq $0x68, %rdi
leaq 0x5bd07(%rip), %rsi     # 0x7b5e3
callq 0x55f0
movq (%rsp), %rdi
addq $0x88, %rdi
leaq 0x5cca5(%rip), %rsi     # 0x7c598
callq 0x55f0
movq (%rsp), %rdi
movq $0x0, 0xa8(%rdi)
addq $0xb0, %rdi
leaq 0x5be76(%rip), %rsi     # 0x7b78b
callq 0x55f0
movq (%rsp), %rdi
movq $0x0, 0xd0(%rdi)
addq $0xd8, %rdi
leaq 0x5bcb0(%rip), %rsi     # 0x7b5e7
callq 0x55f0
movq (%rsp), %rdi
addq $0xf8, %rdi
leaq 0x5bc99(%rip), %rsi     # 0x7b5e7
callq 0x55f0
movq (%rsp), %rax
movl $0x3e7, 0x118(%rax)     # imm = 0x3E7
leaq 0x8(%rsp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x76090
movq (%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq 0x8(%rsp), %rsi
callq 0x76110
movq (%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rdi)
addq $0x1e0, %rdi            # imm = 0x1E0
leaq 0x5cbe7(%rip), %rsi     # 0x7c598
callq 0x55f0
movq (%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
leaq 0x5bc21(%rip), %rsi     # 0x7b5e9
callq 0x55f0
movq (%rsp), %rdi
movb $0x1, 0x188(%rdi)
addq $0x190, %rdi            # imm = 0x190
leaq 0x5b9cc(%rip), %rsi     # 0x7b3b2
callq 0x55f0
movq (%rsp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
leaq 0x5b9b5(%rip), %rsi     # 0x7b3b2
callq 0x55f0
movq (%rsp), %rax
movsd 0x5b962(%rip), %xmm0    # 0x7b370
movsd %xmm0, 0x1d0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d8(%rax)
callq 0x202b0
movq (%rsp), %rdi
movl %eax, 0x200(%rdi)
addq $0x208, %rdi            # imm = 0x208
callq 0x16980
movq (%rsp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x202c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::CASA(Molecule*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
CASA::CASA (Molecule *mol, const std::string fparmfile, const std::string freffile, const std::string fsasa){
    this->initializeAminoAcids();        
    this->initializeHist();

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

// Assembly:
subq $0xe8, %rsp
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x77e0
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x28(%rsp)
callq 0x38530
movq 0x48(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x30(%rsp)
callq 0x38530
movq 0x48(%rsp), %rdi
addq $0x78, %rdi
movq %rdi, 0x38(%rsp)
callq 0x38530
movq 0x48(%rsp), %rdi
addq $0xa8, %rdi
movq %rdi, 0x40(%rsp)
callq 0x38530
movq 0x48(%rsp), %rdi
callq 0x21ae0
jmp 0x21923
movq 0x20(%rsp), %rdi
callq 0x22a00
jmp 0x2192f
movq 0x18(%rsp), %rdi
callq 0x5630
cmpq $0x0, %rax
jbe 0x219b5
movq 0x18(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x51b0
jmp 0x21953
movq 0x20(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x22b10
jmp 0x21967
leaq 0x90(%rsp), %rdi
callq 0x5250
jmp 0x219b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x21a98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5250
jmp 0x21a98
movq 0x8(%rsp), %rdi
callq 0x5630
cmpq $0x0, %rax
jbe 0x21a16
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x51b0
jmp 0x219d6
movq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x231b0
jmp 0x219e7
leaq 0x70(%rsp), %rdi
callq 0x5250
jmp 0x21a24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5250
jmp 0x21a98
movq 0x20(%rsp), %rdi
callq 0x23710
jmp 0x21a22
jmp 0x21a24
movq 0x10(%rsp), %rdi
callq 0x5630
cmpq $0x0, %rax
jbe 0x21a82
movq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x51b0
jmp 0x21a45
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x36470
jmp 0x21a56
leaq 0x50(%rsp), %rdi
callq 0x5250
jmp 0x21a90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5250
jmp 0x21a98
movq 0x20(%rsp), %rdi
callq 0x369d0
jmp 0x21a8e
jmp 0x21a90
addq $0xe8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x38540
movq 0x38(%rsp), %rdi
callq 0x38540
movq 0x30(%rsp), %rdi
callq 0x38540
movq 0x28(%rsp), %rdi
callq 0x38540
movq 0x48(%rsp), %rdi
callq 0x7ab0
movq 0xb8(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::setHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
void CASA::setHist(const std::string &key, const double &val){
    if (this->hist.find (key) != this->hist.end()){
      this->hist.at(key) = val;
    } else {
      this->hist.insert(std::pair<std::string, double>(key, val));
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x78, %rdi
movq 0x98(%rsp), %rsi
callq 0x38890
movq 0x30(%rsp), %rdi
movq %rax, 0x88(%rsp)
addq $0x78, %rdi
callq 0x388c0
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x38870
testb $0x1, %al
jne 0x37926
jmp 0x3795a
movq 0x30(%rsp), %rdi
movq 0x90(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
addq $0x78, %rdi
movq 0x98(%rsp), %rsi
callq 0x388f0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x379d9
movq 0x30(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x389a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x386b0
movb %dl, 0x1f(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x379a1
movb 0x1f(%rsp), %al
movq 0x20(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x38790
jmp 0x379d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x38790
jmp 0x379e1
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::accumHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
void CASA::accumHist(const std::string &key, const double &val){
    if (this->hist.find (key) != this->hist.end()){
      this->hist.at(key) += val;
    } else {
      this->hist.insert(std::pair<std::string, double>(key, val));
    }
    
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x78, %rdi
movq 0x98(%rsp), %rsi
callq 0x38890
movq 0x30(%rsp), %rdi
movq %rax, 0x88(%rsp)
addq $0x78, %rdi
callq 0x388c0
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x38870
testb $0x1, %al
jne 0x37a66
jmp 0x37a9e
movq 0x30(%rsp), %rdi
movq 0x90(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
addq $0x78, %rdi
movq 0x98(%rsp), %rsi
callq 0x388f0
movsd 0x28(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x37b1d
movq 0x30(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x389a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x386b0
movb %dl, 0x1f(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x37ae5
movb 0x1f(%rsp), %al
movq 0x20(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x38790
jmp 0x37b1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x38790
jmp 0x37b25
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x5720
nop
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::predictHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::predictHist(const std::string &resname){
  double predSASA = 0.0;
  std::string res = "";
  std::string key = "";
  for (unsigned int i=0; i< this->aminoAcids.size(); i++){
    res = this->aminoAcids.at(i);
    key = resname+":"+res;
    predSASA += this->sasaCoef.at(key)*this->hist.at(res);
  }
  return(predSASA);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x50(%rsp)
movq $0x0, 0x100(%rsp)
leaq 0xdf(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x5730
movq 0x58(%rsp), %rdx
leaq 0x43834(%rip), %rsi     # 0x7b3b2
leaq 0xe0(%rsp), %rdi
callq 0x7900
jmp 0x37b8d
leaq 0xdf(%rsp), %rdi
callq 0x5480
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x5730
movq 0x48(%rsp), %rdx
leaq 0x437fa(%rip), %rsi     # 0x7b3b2
leaq 0xa8(%rsp), %rdi
callq 0x7900
jmp 0x37bc7
leaq 0xa7(%rsp), %rdi
callq 0x5480
movl $0x0, 0xa0(%rsp)
movq 0x50(%rsp), %rdi
movl 0xa0(%rsp), %eax
movq %rax, 0x40(%rsp)
callq 0x78e0
movq %rax, %rcx
movq 0x40(%rsp), %rax
cmpq %rcx, %rax
jae 0x37da2
movq 0x50(%rsp), %rdi
movl 0xa0(%rsp), %eax
movl %eax, %esi
callq 0x79c0
movq %rax, 0x38(%rsp)
jmp 0x37c20
movq 0x38(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x5060
jmp 0x37c34
movq 0x108(%rsp), %rsi
leaq 0x435e4(%rip), %rdx     # 0x7b227
leaq 0x60(%rsp), %rdi
callq 0x17210
jmp 0x37c4f
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
callq 0x389e0
jmp 0x37c6b
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x80(%rsp), %rsi
movq %rsi, 0x20(%rsp)
callq 0x5510
movq 0x20(%rsp), %rdi
callq 0x5250
leaq 0x60(%rsp), %rdi
callq 0x5250
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x48, %rdi
callq 0x388f0
movq %rax, 0x30(%rsp)
jmp 0x37cb8
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x78, %rdi
leaq 0xe0(%rsp), %rsi
callq 0x388f0
movq %rax, 0x18(%rsp)
jmp 0x37ce4
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd (%rax), %xmm2
movsd 0x100(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x100(%rsp)
movl 0xa0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa0(%rsp)
jmp 0x37bdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xdf(%rsp), %rdi
callq 0x5480
jmp 0x37df3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0xa7(%rsp), %rdi
callq 0x5480
jmp 0x37de6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x37dd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5250
jmp 0x37dd9
movsd 0x100(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x5250
leaq 0xe0(%rsp), %rdi
callq 0x5250
movsd 0x8(%rsp), %xmm0
addq $0x118, %rsp            # imm = 0x118
retq
leaq 0xa8(%rsp), %rdi
callq 0x5250
leaq 0xe0(%rsp), %rdi
callq 0x5250
movq 0xd0(%rsp), %rdi
callq 0x5720
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getRefSASA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getRefSASA(const std::string &key){
    if (this->refSASA.find (key) == this->refSASA.end()){
        return 0.0;
    } else {
        return (this->refSASA.at(key));
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x38890
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x388c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38a40
testb $0x1, %al
jne 0x37f93
jmp 0x37f9e
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x37fbb
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x388f0
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::printRefSASAVec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string CASA::printRefSASAVec(const std::string &key){    
    std::stringstream s;
    s.str("");
    for (unsigned int i=0; i< this->aminoAcids.size(); i++){
    	if (this->aminoAcids.at(i) == key){
    		 s << this->refSASA.at(key) << " ";
    	}
    	else {
    		s << "0.0 ";
    	}
    }
    return(s.str());
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq %rdx, 0x210(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x52a0
leaq 0x67(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x5730
movq 0x48(%rsp), %rdx
leaq 0x43381(%rip), %rsi     # 0x7b3b2
leaq 0x68(%rsp), %rdi
callq 0x7900
jmp 0x3803d
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x54d0
jmp 0x38051
leaq 0x68(%rsp), %rdi
callq 0x5250
leaq 0x67(%rsp), %rdi
callq 0x5480
movl $0x0, 0x50(%rsp)
movq 0x40(%rsp), %rdi
movl 0x50(%rsp), %eax
movq %rax, 0x28(%rsp)
callq 0x78e0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x3818a
movq 0x40(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0x79c0
movq %rax, 0x20(%rsp)
jmp 0x380a8
movq 0x20(%rsp), %rdi
movq 0x210(%rsp), %rsi
callq 0x38a60
testb $0x1, %al
jne 0x380c3
jmp 0x38160
movq 0x40(%rsp), %rdi
leaq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
movq 0x210(%rsp), %rsi
callq 0x388f0
movq %rax, 0x18(%rsp)
jmp 0x380ed
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
callq 0x5780
movq %rax, 0x8(%rsp)
jmp 0x38107
movq 0x8(%rsp), %rdi
leaq 0x44485(%rip), %rsi     # 0x7c598
callq 0x53f0
jmp 0x3811a
jmp 0x38178
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x38144
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5250
leaq 0x67(%rsp), %rdi
callq 0x5480
jmp 0x381b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x381b8
leaq 0x98(%rsp), %rdi
leaq 0x432ff(%rip), %rsi     # 0x7b46e
callq 0x53f0
jmp 0x38176
jmp 0x38178
jmp 0x3817a
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x3806d
movq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x53e0
jmp 0x3819e
leaq 0x88(%rsp), %rdi
callq 0x52e0
movq 0x38(%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
retq
leaq 0x88(%rsp), %rdi
callq 0x52e0
movq 0x58(%rsp), %rdi
callq 0x5720
nop
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::printRefSASAVecHeader[abi:cxx11]()
std::string CASA::printRefSASAVecHeader(){    
	std::stringstream s;
	s.str("");
	for (unsigned int i=0; i< this->aminoAcids.size(); i++){
		s << "RefSASA_" << aminoAcids.at(i) << " ";
	}
	return(s.str());
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq 0x208(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x52a0
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x5730
movq 0x40(%rsp), %rdx
leaq 0x43189(%rip), %rsi     # 0x7b3b2
leaq 0x60(%rsp), %rdi
callq 0x7900
jmp 0x38235
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x54d0
jmp 0x38249
leaq 0x60(%rsp), %rdi
callq 0x5250
leaq 0x5f(%rsp), %rdi
callq 0x5480
movl $0x0, 0x48(%rsp)
movq 0x38(%rsp), %rdi
movl 0x48(%rsp), %eax
movq %rax, 0x20(%rsp)
callq 0x78e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x3833a
leaq 0x90(%rsp), %rdi
leaq 0x4401f(%rip), %rsi     # 0x7c2b7
callq 0x53f0
movq %rax, 0x18(%rsp)
jmp 0x382a4
movq 0x38(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x79c0
movq %rax, 0x10(%rsp)
jmp 0x382bb
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x5390
movq %rax, 0x8(%rsp)
jmp 0x382d1
movq 0x8(%rsp), %rdi
leaq 0x442bb(%rip), %rsi     # 0x7c598
callq 0x53f0
jmp 0x382e4
jmp 0x382e6
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x38265
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3831e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x5250
leaq 0x5f(%rsp), %rdi
callq 0x5480
jmp 0x38368
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x38368
movq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x53e0
jmp 0x3834e
leaq 0x80(%rsp), %rdi
callq 0x52e0
movq 0x30(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
leaq 0x80(%rsp), %rdi
callq 0x52e0
movq 0x50(%rsp), %rdi
callq 0x5720
nop
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getSASACoef(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getSASACoef(const std::string &key){
    if (this->sasaCoef.find (key) == this->sasaCoef.end()){
        return 0.0;
    } else {
        return (this->sasaCoef.at(key));
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x48, %rdi
movq 0x20(%rsp), %rsi
callq 0x38890
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x48, %rdi
callq 0x388c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38a40
testb $0x1, %al
jne 0x383d3
jmp 0x383de
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x383fb
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movq 0x20(%rsp), %rsi
callq 0x388f0
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getHist(const std::string &key){
    if (this->hist.find (key) == this->hist.end()){
        return 0.0;
    } else {
        return (this->hist.at(key));
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x78, %rdi
movq 0x20(%rsp), %rsi
callq 0x38890
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x78, %rdi
callq 0x388c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38a40
testb $0x1, %al
jne 0x38463
jmp 0x3846e
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x3848b
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
movq 0x20(%rsp), %rsi
callq 0x388f0
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getTargetSASA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getTargetSASA(const std::string &key){
    if (this->targetSASA.find (key) == this->targetSASA.end()){
        return 0.0;
    } else {
        return (this->targetSASA.at(key));
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xa8, %rdi
movq 0x20(%rsp), %rsi
callq 0x38890
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0xa8, %rdi
callq 0x388c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38a40
testb $0x1, %al
jne 0x384f9
jmp 0x38504
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x38524
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
movq 0x20(%rsp), %rsi
callq 0x388f0
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::getAtom(unsigned int const&)
Atom* Chain::getAtom (const unsigned int& element){
  if (element >= atmVec.size()){
    return NULL;
  }
  else{
    return atmVec.at(element);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x20600
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x3a464
movq $0x0, 0x20(%rsp)
jmp 0x3a482
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x20620
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::getResidue(unsigned int const&)
Residue* Chain::getResidue (const unsigned int& element){
  if (element >= resVec.size()){
    return NULL;
  }
  else{
    return resVec.at(element);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
callq 0x3a700
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x3a4d0
movq $0x0, 0x20(%rsp)
jmp 0x3a4ea
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x3a720
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::selAll()
void Chain::selAll(){
//  sel=true;
  unsigned int i;
//  for (i=0; i< this->getResVecSize(); i++){
//    this->getResidue(i)->setSel(true);
//  }
  for (i=0; i< this->getAtmVecSize(); i++){
    this->getAtom(i)->setSel(true);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3a550
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x3a5e0
movq 0x10(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x3a420
movq %rax, %rdi
movl $0x1, %esi
callq 0x200f0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3a59b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Chain.cpp
// Function: Chain::deselAll()
void Chain::deselAll(){
//  sel=false;
  unsigned int i;
//  for (i=0; i< this->getResVecSize(); i++){
//    this->getResidue(i)->setSel(false);
//  }
  for (i=0; i< this->getAtmVecSize(); i++){
    this->getAtom(i)->setSel(false);
  }  
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3a550
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x3a64d
movq 0x10(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x3a420
movq %rax, %rdi
xorl %esi, %esi
callq 0x200f0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3a60b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::delDTree(DTreeNode*)
void DTree::delDTree(DTreeNode *node){
  if (node != NULL){
    delDTree(node->left);
    delDTree(node->right);
    delete node;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3b211
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x3b1a0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x3b1a0
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3b20f
movq 0x8(%rsp), %rdi
callq 0x3c710
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x5420
jmp 0x3b211
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::getClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string DTree::getClass(std::string valin){
  if (classMap.find(valin) != classMap.end()){
    return classMap.at(valin);
  }
  else{
    std::cerr << "Error: Unrecognized class mapping \"" << valin << "\"" << std::endl;
    return "";
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rdi, 0x10(%rsp)
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x8, %rdi
callq 0x3c910
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x8, %rdi
callq 0x3c940
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3c8f0
testb $0x1, %al
jne 0x3bdbd
jmp 0x3bde2
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x3c970
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x51b0
jmp 0x3be6b
movq 0x3ff207(%rip), %rdi    # 0x43aff0
leaq 0x40538(%rip), %rsi     # 0x7c328
callq 0x53f0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
leaq 0x405e0(%rip), %rsi     # 0x7c3ec
callq 0x53f0
movq %rax, %rdi
movq 0x3ff18d(%rip), %rsi    # 0x43afa8
callq 0x5460
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5730
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x3f574(%rip), %rsi     # 0x7b3b2
callq 0x7900
jmp 0x3be45
leaq 0x3f(%rsp), %rdi
callq 0x5480
jmp 0x3be6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x5480
jmp 0x3be75
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5720
nop
// File: atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::addDTree(double, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DTree::addDTree(double key, unsigned int index, std::string classin){
  //Public version of the addDTree function
  //Takes care of when the root node has not been initialized
  if (root != NULL){
    addDTree(key, root, index, classin);
  }
  else{
    root=new DTreeNode;
    root->key_value=key;
    root->inx=index;
    root->left=NULL;
    root->right=NULL;
    root->leaf=classin;
  }
}

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, (%rax)
je 0x3bf31
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rsi
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x51b0
movq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rcx
callq 0x3b220
jmp 0x3bf0b
leaq 0x48(%rsp), %rdi
callq 0x5250
jmp 0x3bf91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5250
jmp 0x3bf99
movl $0x40, %edi
callq 0x5410
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x3c730
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rsi
movq %rcx, (%rax)
movsd 0x78(%rsp), %xmm0
movq (%rax), %rcx
movsd %xmm0, (%rcx)
movl 0x74(%rsp), %edx
movq (%rax), %rcx
movl %edx, 0x8(%rcx)
movq (%rax), %rcx
movq $0x0, 0x10(%rcx)
movq (%rax), %rcx
movq $0x0, 0x18(%rcx)
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x5060
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::getDTreeRoot()
DTreeNode* DTree::getDTreeRoot(){
  if (root != NULL){
    return root;
  }
  else{
    return NULL;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, (%rax)
je 0x3c544
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x3c54d
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/DTree.cpp
// Function: DTree::getDTreeClass[abi:cxx11](std::vector<double, std::allocator<double>> const&)
std::string DTree::getDTreeClass(const std::vector<double> &fin){
  //Public version of the getDTreeClass function
  if (root != NULL){
    return getDTreeClass(root, fin);
  }
  else{
    return "?"; 
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, (%rax)
je 0x3c5a9
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq (%rsi), %rdx
movq 0x40(%rsp), %rcx
callq 0x3bac0
jmp 0x3c5f6
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5730
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3fd5d(%rip), %rsi     # 0x7c326
callq 0x7900
jmp 0x3c5d0
leaq 0x3f(%rsp), %rdi
callq 0x5480
jmp 0x3c5f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x5480
jmp 0x3c600
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
std::string Misc::replace (const std::string &str, const std::string searchStr, const std::string replaceStr, const bool globalFlag){
  std::string out;

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

  return out;
}

// Assembly:
subq $0x78, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x30(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movb $0x0, 0x56(%rsp)
callq 0x5600
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x5060
jmp 0x3dbe3
movq $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
callq 0x57e0
movq %rax, 0x38(%rsp)
cmpq $-0x1, %rax
je 0x3dc9d
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x5630
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq %rax, %rdx
callq 0x5180
jmp 0x3dc3c
movq 0x18(%rsp), %rdi
callq 0x5630
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x5630
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
addq $0x1, %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3dc98
jmp 0x3dc9d
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x5250
jmp 0x3dcbd
jmp 0x3dbec
movb $0x1, 0x56(%rsp)
testb $0x1, 0x56(%rsp)
jne 0x3dcb3
movq 0x30(%rsp), %rdi
callq 0x5250
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::isdouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Misc::isdouble (const std::string &str){
  unsigned int nDecimals=0; 
  unsigned int negPos=0;

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5290
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3dda8
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x54a0
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x2d, %eax
je 0x3dd78
jmp 0x3dd5f
movl 0xc(%rsp), %eax
subl $0x2e, %eax
je 0x3dd82
jmp 0x3dd6a
movl 0xc(%rsp), %eax
addl $-0x30, %eax
subl $0xa, %eax
jb 0x3dd8f
jmp 0x3dd91
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x3dd98
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3dd98
jmp 0x3dd98
movb $0x0, 0x37(%rsp)
jmp 0x3ddc2
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3dd21
cmpl $0x1, 0x24(%rsp)
ja 0x3ddb6
cmpl $0x0, 0x20(%rsp)
je 0x3ddbd
movb $0x0, 0x37(%rsp)
jmp 0x3ddc2
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::isrange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Misc::isrange (const std::string &str){

  if (str.find_first_not_of("0123456789-") != std::string::npos){
    return false;
  }
  if (str.find("-") == std::string::npos){
    return false;
  }
  if (str.find_first_not_of("-") != 0 || str.find_last_not_of("-") < str.find("-")){
    return false;
  }

  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x3e58b(%rip), %rsi     # 0x7c3c0
xorl %eax, %eax
movl %eax, %edx
callq 0x5200
cmpq $-0x1, %rax
je 0x3de4e
movb $0x0, 0x17(%rsp)
jmp 0x3ded4
movq 0x8(%rsp), %rdi
leaq 0x3e570(%rip), %rsi     # 0x7c3ca
xorl %eax, %eax
movl %eax, %edx
callq 0x57d0
cmpq $-0x1, %rax
jne 0x3de70
movb $0x0, 0x17(%rsp)
jmp 0x3ded4
movq 0x8(%rsp), %rdi
leaq 0x3e54e(%rip), %rsi     # 0x7c3ca
xorl %eax, %eax
movl %eax, %edx
callq 0x5200
cmpq $0x0, %rax
jne 0x3dec8
movq 0x8(%rsp), %rdi
leaq 0x3e533(%rip), %rsi     # 0x7c3ca
movq $-0x1, %rdx
callq 0x5750
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x3e517(%rip), %rsi     # 0x7c3ca
xorl %eax, %eax
movl %eax, %edx
callq 0x57d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x3decf
movb $0x0, 0x17(%rsp)
jmp 0x3ded4
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Misc::trim (const std::string &str, const std::string t){
  std::string out=str;

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

  return out;
}

// Assembly:
subq $0x58, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x48(%rsp), %rsi
callq 0x51b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq $-0x1, %rdx
callq 0x5770
movq %rax, 0x30(%rsp)
cmpq $-0x1, 0x30(%rsp)
je 0x3dfc3
movq 0x10(%rsp), %rdi
callq 0x5630
movq 0x30(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x3df8a
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
incq %rsi
movq $-0x1, %rdx
callq 0x50f0
jmp 0x3df6e
jmp 0x3df8a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5250
jmp 0x3dff8
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5350
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x3dfc1
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x50f0
jmp 0x3dfbf
jmp 0x3dfc1
jmp 0x3dfd8
movq 0x10(%rsp), %rdi
leaq 0x3d3e3(%rip), %rsi     # 0x7b3b2
callq 0x55f0
jmp 0x3dfd6
jmp 0x3dfd8
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x3dfee
movq 0x10(%rsp), %rdi
callq 0x5250
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::processRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Misc::processRange (const std::string &start, const std::string &end){
  std::stringstream ss;
  int i, istart, iend;
  
  std::stringstream(start) >> istart;
  std::stringstream(end) >> iend;

  ss << istart;
  istart++;

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

  return ss.str();
}

// Assembly:
subq $0x508, %rsp            # imm = 0x508
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x500(%rsp)
movq %rsi, 0x4f8(%rsp)
movq %rdx, 0x4f0(%rsp)
leaq 0x368(%rsp), %rdi
callq 0x52a0
movq 0x4f8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x7850
movl %eax, 0x34(%rsp)
jmp 0x3e06b
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rsi
leaq 0x1d0(%rsp), %rdi
callq 0x5670
jmp 0x3e083
leaq 0x1d0(%rsp), %rdi
leaq 0x360(%rsp), %rsi
callq 0x7820
jmp 0x3e09a
leaq 0x1d0(%rsp), %rdi
callq 0x52e0
movq 0x4f0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x7850
movl %eax, 0x14(%rsp)
jmp 0x3e0c9
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x5670
jmp 0x3e0de
leaq 0x38(%rsp), %rdi
leaq 0x35c(%rsp), %rsi
callq 0x7820
jmp 0x3e0f2
leaq 0x38(%rsp), %rdi
callq 0x52e0
leaq 0x378(%rsp), %rdi
movl 0x360(%rsp), %esi
callq 0x56f0
jmp 0x3e112
movl 0x360(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x360(%rsp)
movl 0x360(%rsp), %eax
movl %eax, 0x364(%rsp)
movl 0x364(%rsp), %eax
cmpl 0x35c(%rsp), %eax
jg 0x3e1df
leaq 0x378(%rsp), %rdi
leaq 0x3d493(%rip), %rsi     # 0x7b5e7
callq 0x53f0
movq %rax, (%rsp)
jmp 0x3e15f
movq (%rsp), %rdi
movl 0x364(%rsp), %esi
callq 0x56f0
jmp 0x3e171
jmp 0x3e173
movl 0x364(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x364(%rsp)
jmp 0x3e131
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c8(%rsp)
movl %eax, 0x1c4(%rsp)
jmp 0x3e20d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c8(%rsp)
movl %eax, 0x1c4(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x52e0
jmp 0x3e20d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c8(%rsp)
movl %eax, 0x1c4(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x52e0
jmp 0x3e20d
movq 0x18(%rsp), %rdi
leaq 0x368(%rsp), %rsi
callq 0x53e0
jmp 0x3e1f3
leaq 0x368(%rsp), %rdi
callq 0x52e0
movq 0x20(%rsp), %rax
addq $0x508, %rsp            # imm = 0x508
retq
leaq 0x368(%rsp), %rdi
callq 0x52e0
movq 0x1c8(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::atoi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int)
int Misc::atoi (std::string &str, const unsigned int offset){
  int val;
  const char *a;
  val=0;

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %eax
movl %eax, %edx
leaq 0x30(%rsp), %rdi
movl $0x1, %ecx
callq 0x5440
leaq 0x30(%rsp), %rdi
callq 0x3ddf0
movb %al, 0xf(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5250
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3e421
jmp 0x3e466
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %eax
movl %eax, %edx
leaq 0x10(%rsp), %rdi
movl $0x1, %ecx
callq 0x5440
leaq 0x10(%rsp), %rdi
callq 0x51a0
movq %rax, 0x50(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x5250
movq 0x50(%rsp), %rax
movsbl (%rax), %eax
subl $0x41, %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
addq $0x68, %rsp
retq
nop
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::hypot(double const&, double const&)
double Misc::hypot (const double &a, const double &b){
  if (a !=0){
    return a*sqrt(1+(b/a)*(b/a));
  }
  else if (b !=0){
    return b*sqrt(1+(a/b)*(a/b));
  }
  else{
    return 0.0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3e494
jp 0x3e494
jmp 0x3e4f1
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
divsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movq 0x18(%rsp), %rax
divsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x3ce9d(%rip), %xmm1    # 0x7b370
addsd %xmm1, %xmm0
callq 0x5300
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e56b
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3e507
jp 0x3e507
jmp 0x3e562
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
divsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd (%rax), %xmm1
movq 0x10(%rsp), %rax
divsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x3ce2b(%rip), %xmm1    # 0x7b370
addsd %xmm1, %xmm0
callq 0x5300
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3e56b
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::rmse(std::vector<double, std::allocator<double>>)
double Misc::rmse (std::vector<double> errorVec){
    double error=0.0;
    if(errorVec.size()>0){    
      for (unsigned int i=0; i<errorVec.size();i++){
          error += errorVec.at(i)*errorVec.at(i);
      }
      return sqrt(error/errorVec.size());
    } else {
      return 0.0;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
callq 0x17a60
cmpq $0x0, %rax
jbe 0x3e677
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x17a60
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x3e623
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x16f90
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x16f90
movsd 0x10(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3e5ae
movq 0x20(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x17a60
movsd 0x8(%rsp), %xmm0
movq %rax, %xmm1
movaps 0x3dd05(%rip), %xmm2    # 0x7c350
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x3dd09(%rip), %xmm2    # 0x7c360
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x5300
movsd %xmm0, 0x40(%rsp)
jmp 0x3e680
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/Misc.cpp
// Function: Misc::mae(std::vector<double, std::allocator<double>>)
double Misc::mae (std::vector<double> errorVec){
    double error=0.0;
    if(errorVec.size()>0){
      for (unsigned int i=0; i<errorVec.size();i++){
          error += fabs(errorVec.at(i));
      }
      return error/errorVec.size();
    } else {
      return 0.0;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x17a60
cmpq $0x0, %rax
jbe 0x3e763
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
callq 0x17a60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3e716
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x16f90
movsd (%rax), %xmm0
movaps 0x3dc77(%rip), %xmm1    # 0x7c370
pand %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3e6be
movq 0x10(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
callq 0x17a60
movsd (%rsp), %xmm0
movq %rax, %xmm1
movaps 0x3dc14(%rip), %xmm2    # 0x7c350
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x3dc18(%rip), %xmm2    # 0x7c360
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x3e76c
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: atfrank[P]PCASA/lib/Molecule.cpp
// Function: Molecule::Molecule()
Molecule::Molecule (){
  chnVec.clear();
  resVec.clear();
  atmVec.clear();
  copyFlag=false;
  storedSel.clear();
  remarks.clear();
  iCodeFlag=false;
  year=0;
  exp.clear();
  tag.clear();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x3f92ee(%rip), %rax    # 0x43ad28
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0x46d70
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0x3a660
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x10(%rsp)
callq 0x202a0
movq 0x28(%rsp), %rdi
addq $0x58, %rdi
movq %rdi, 0x18(%rsp)
callq 0x46d80
movq 0x28(%rsp), %rdi
addq $0x88, %rdi
movq %rdi, 0x20(%rsp)
callq 0x5600
movq 0x28(%rsp), %rdi
addq $0xb0, %rdi
callq 0x58060
jmp 0x41aac
movq 0x28(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x5600
movq 0x28(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x5600
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x46d90
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x3a670
movq 0x28(%rsp), %rdi
addq $0x38, %rdi
callq 0x202c0
movq 0x28(%rsp), %rdi
movb $0x0, 0x50(%rdi)
addq $0x58, %rdi
callq 0x46db0
movq 0x28(%rsp), %rdi
addq $0x88, %rdi
callq 0x5580
movq 0x28(%rsp), %rdi
movb $0x0, 0xa8(%rdi)
movl $0x0, 0x158(%rdi)
addq $0x160, %rdi            # imm = 0x160
callq 0x5580
movq 0x28(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x5580
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x5250
movq 0x18(%rsp), %rdi
callq 0x46dc0
movq 0x10(%rsp), %rdi
callq 0x202e0
movq 0x8(%rsp), %rdi
callq 0x46dd0
movq (%rsp), %rdi
callq 0x46e30
movq 0x38(%rsp), %rdi
callq 0x5720
nopl (%rax)