LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/segment.cc
// Function: segmentChannels(ATOM_NETWORK*, std::vector<FEATURE, std::allocator<FEATURE>>*, std::ostream&)
void segmentChannels(ATOM_NETWORK *uc,vector<FEATURE>  *channel_list,ostream &output) {
  int i;
  vector <double> segment_list;
  if(channel_list->size()>0) {
    for(i=0;i<(int)channel_list->size();i++){
      channel_list->at(i).segmentChannel(uc);
      segment_list.insert(segment_list.begin(),channel_list->at(i).segment_max_r.begin(),channel_list->at(i).segment_max_r.end());
    }
   }
  
  output << segment_list.size() << "\n";
  for(i=0;i<(int)segment_list.size();i++){
    output << segment_list[i] << "\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf650
movq -0x10(%rbp), %rdi
callq 0x899b0
cmpq $0x0, %rax
jbe 0x89130
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x899b0
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jge 0x8912e
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x899e0
movq %rax, -0x80(%rbp)
jmp 0x8905a
movq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xd8840
jmp 0x89069
leaq -0x38(%rbp), %rdi
callq 0x26bb0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x89ad0
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x899e0
movq %rax, -0x88(%rbp)
jmp 0x89099
movq -0x88(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x26bb0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x899e0
movq %rax, -0x90(%rbp)
jmp 0x890c6
movq -0x90(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x269f0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x89a20
movq %rax, -0x98(%rbp)
jmp 0x890fb
movq -0x98(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8902a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf9d0
jmp 0x891fc
jmp 0x89130
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf990
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xa0(%rbp)
jmp 0x8915c
movq -0xa0(%rbp), %rdi
leaq 0x1704bb(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x89171
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xac(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf990
movq %rax, %rcx
movl -0xac(%rbp), %eax
cmpl %ecx, %eax
jge 0x891ea
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xedb0
movq -0xc0(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, -0xb8(%rbp)
jmp 0x891c8
movq -0xb8(%rbp), %rdi
leaq 0x17044f(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x891dd
jmp 0x891df
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x89178
leaq -0x38(%rbp), %rdi
callq 0xf9d0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/string_additions.cc
// Function: strCmpList(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>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int strCmpList(vector<string> list,string str){
  for (unsigned int ndx=0;ndx<list.size();ndx++){
    if(list[ndx].compare(str) == 0){
      return ndx;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x592f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x8a60f
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x59310
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5050
cmpl $0x0, %eax
jne 0x8a602
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8a616
jmp 0x8a604
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8a5bf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/string_additions.cc
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> split(string line, string delimeter){
  vector<string> token;
  string temp=line;
  int ndx;

  while (!temp.empty()){
    ndx = temp.find_first_of(delimeter);
    if (ndx>0){
      token.push_back(temp.substr(0,ndx));
    }
    else if (ndx ==-1){
      token.push_back(temp);
      return token;
    }
    temp=temp.substr(ndx+1);
  }

  return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb8(%rbp)
movq %rsi, -0xa0(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x59240
movq -0xa0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5220
jmp 0x8a671
jmp 0x8a673
leaq -0x40(%rbp), %rdi
callq 0x5850
xorb $-0x1, %al
testb $0x1, %al
jne 0x8a687
jmp 0x8a77d
movq -0xb8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x54a0
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jle 0x8a714
movslq -0x50(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5590
jmp 0x8a6bb
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x594b0
jmp 0x8a6cd
leaq -0x70(%rbp), %rdi
callq 0x5300
jmp 0x8a73b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8a7c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8a799
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5300
jmp 0x8a799
cmpl $-0x1, -0x50(%rbp)
jne 0x8a739
movq -0xb0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x59330
jmp 0x8a72c
movb $0x1, -0x19(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0x8a788
jmp 0x8a73b
movl -0x50(%rbp), %eax
incl %eax
movslq %eax, %rdx
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq $-0x1, %rcx
callq 0x5590
jmp 0x8a75c
leaq -0x40(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x5680
leaq -0x98(%rbp), %rdi
callq 0x5300
jmp 0x8a673
movb $0x1, -0x19(%rbp)
movl $0x1, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5300
testb $0x1, -0x19(%rbp)
jne 0x8a7b0
jmp 0x8a7a4
leaq -0x40(%rbp), %rdi
callq 0x5300
jmp 0x8a7c0
movq -0xb0(%rbp), %rdi
callq 0x59290
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x59290
movq -0x48(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/string_additions.cc
// Function: strAry2StrVec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
vector<string> strAry2StrVec(string list[]){
  vector<string> veclist;
  int ndx=0;
  while (list[ndx]!="NULL"){
    veclist.push_back(list[ndx]);
    ndx++;
  }
  return veclist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x59240
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq 0x16cc08(%rip), %rsi    # 0x1f7429
callq 0x8aca0
movb %al, -0x39(%rbp)
jmp 0x8a82b
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8a834
jmp 0x8a870
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x59330
jmp 0x8a84e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8a80b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x59290
jmp 0x8a88d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8a883
movq -0x38(%rbp), %rdi
callq 0x59290
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/string_additions.cc
// Function: convertToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double convertToDouble(string const& str){
  istringstream i(str);
  double x;
  if (!(i >> x)){
    cout << "Bad string to double conversion" << endl;
    exit(0);
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movl $0x8, %edx
callq 0x5860
movq -0x1b0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x5420
movq %rax, -0x1a8(%rbp)
jmp 0x8a8e7
movq -0x1a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5250
movb %al, -0x1b1(%rbp)
jmp 0x8a905
movb -0x1b1(%rbp), %al
testb $0x1, %al
jne 0x8a911
jmp 0x8a969
movq 0x1e86a8(%rip), %rdi    # 0x272fc0
leaq 0x16ca01(%rip), %rsi    # 0x1f7320
callq 0x5540
movq %rax, -0x1c0(%rbp)
jmp 0x8a92d
movq -0x1c0(%rbp), %rdi
movq 0x1e865d(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8a942
xorl %edi, %edi
callq 0x67c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x5260
jmp 0x8a996
movsd -0x190(%rbp), %xmm0
movsd %xmm0, -0x1c8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x5260
movsd -0x1c8(%rbp), %xmm0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/string_additions.cc
// Function: convertToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int convertToInt(string const& str){
  istringstream i(str);
  int x;
  if (!(i >> x)){
    cout << "Bad string to int conversion" << endl;
    exit(0);
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movl $0x8, %edx
callq 0x5860
movq -0x1b0(%rbp), %rdi
leaq -0x18c(%rbp), %rsi
callq 0x52f0
movq %rax, -0x1a8(%rbp)
jmp 0x8a9f7
movq -0x1a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5250
movb %al, -0x1b1(%rbp)
jmp 0x8aa15
movb -0x1b1(%rbp), %al
testb $0x1, %al
jne 0x8aa21
jmp 0x8aa79
movq 0x1e8598(%rip), %rdi    # 0x272fc0
leaq 0x16c911(%rip), %rsi    # 0x1f7340
callq 0x5540
movq %rax, -0x1c0(%rbp)
jmp 0x8aa3d
movq -0x1c0(%rbp), %rdi
movq 0x1e854d(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8aa52
xorl %edi, %edi
callq 0x67c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x5260
jmp 0x8aaa0
movl -0x18c(%rbp), %eax
movl %eax, -0x1c4(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x5260
movl -0x1c4(%rbp), %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: Luthaf[P]zeopp/string_additions.cc
// Function: doubleToString[abi:cxx11](float const&)
string doubleToString(float const& dbl){
  ostringstream buffer;
  if (!(buffer << dbl)){
    cout << "Bad double to string conversion" << endl;
    exit(0);
  }
  return buffer.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x5700
movq -0x1a8(%rbp), %rdi
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
callq 0x53b0
movq %rax, -0x1a0(%rbp)
jmp 0x8ab04
movq -0x1a0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5250
movb %al, -0x1b9(%rbp)
jmp 0x8ab22
movb -0x1b9(%rbp), %al
testb $0x1, %al
jne 0x8ab2e
jmp 0x8ab86
movq 0x1e848b(%rip), %rdi    # 0x272fc0
leaq 0x16c821(%rip), %rsi    # 0x1f735d
callq 0x5540
movq %rax, -0x1c8(%rbp)
jmp 0x8ab4a
movq -0x1c8(%rbp), %rdi
movq 0x1e8440(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8ab5f
xorl %edi, %edi
callq 0x67c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x5170
jmp 0x8abb7
movq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x5580
jmp 0x8ab9b
leaq -0x188(%rbp), %rdi
callq 0x5170
movq -0x1b0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/string_additions.cc
// Function: intAsString[abi:cxx11](int)
string intAsString(int number) {
   std::ostringstream sin;
   sin << number;
   std::string val = sin.str();
   return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x5700
movq -0x1a0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x58d0
jmp 0x8ac17
movq -0x1b0(%rbp), %rdi
movb $0x0, -0x195(%rbp)
leaq -0x188(%rbp), %rsi
callq 0x5580
jmp 0x8ac33
movb $0x1, -0x195(%rbp)
testb $0x1, -0x195(%rbp)
jne 0x8ac71
jmp 0x8ac65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x5170
jmp 0x8ac8d
movq -0x1b0(%rbp), %rdi
callq 0x5300
leaq -0x188(%rbp), %rdi
callq 0x5170
movq -0x1a8(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: findClosestSphere(std::vector<Sphere, std::allocator<Sphere>>&, ray&)
hitdata findClosestSphere(vector<Sphere>& s,ray& r)
{
  hitdata hitsphere;
  hitdata hitobject;
  assert(hitobject.object == NULL);
  for (unsigned int i=0;i<s.size();i++)
    {
      s[i].hitSphere(r,hitsphere);
      if (hitsphere.hit == true)			
	{
	  if(hitobject.hit == false || hitobject.dist > hitsphere.dist) //Conditions for this to be closest sphere found so far
	    {
	      hitobject.hit = true;
	      hitobject.dist = hitsphere.dist;
	      hitobject.hitpoint = hitsphere.hitpoint;
	      hitobject.id = i;
	      hitobject.object = &(s[i]);
	    }
	  hitsphere.hit = false;				
	}
    }
  return hitobject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x91b70
movq -0x88(%rbp), %rdi
callq 0x91b70
movq -0x88(%rbp), %rdi
cmpq $0x0, 0x30(%rdi)
jne 0x8c646
jmp 0x8c665
leaq 0x16adc8(%rip), %rdi    # 0x1f7415
leaq 0x16adda(%rip), %rsi    # 0x1f742e
movl $0x4a, %edx
leaq 0x16add5(%rip), %rcx    # 0x1f7435
callq 0x5320
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
callq 0x91bf0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x8c778
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x91c10
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x30, %edx
callq 0x5430
movq -0xa0(%rbp), %rdi
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x48(%rbp), %rsi
callq 0x8bdf0
movb -0x48(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x8c768
movq -0x88(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8c716
movq -0x88(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x8c764
movq -0x88(%rbp), %rax
movb $0x1, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x4c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x91c10
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x30(%rax)
movb $0x0, -0x48(%rbp)
jmp 0x8c76a
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x8c66c
movq -0x90(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: findClosestPlane(std::vector<Plane, std::allocator<Plane>>&, ray&)
hitdata findClosestPlane(vector<Plane>& p,ray& r)
{
  hitdata hitplane;
  hitdata hitobject;

  for (unsigned int i=0;i<p.size();i++)
    {
      p[i].hitPlane(r,hitplane);
      if (hitplane.hit == true)			
	{
	  if(hitobject.hit == false || hitobject.dist > hitplane.dist) //Conditions for this to be closest sphere found so far
	    {
	      hitobject.hit = true;
	      hitobject.dist = hitplane.dist;
	      hitobject.hitpoint = hitplane.hitpoint;
	      hitobject.id = i;
	      hitobject.object = &(p[i]);
	    }
	  hitplane.hit = false;				
	}
    }
  return hitobject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x91b70
movq -0x88(%rbp), %rdi
callq 0x91b70
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdi
callq 0x91c30
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x8c8d9
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x91c60
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x30, %edx
callq 0x5430
movq -0xa0(%rbp), %rdi
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x48(%rbp), %rsi
callq 0x8c2a0
movb -0x48(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x8c8c9
movq -0x88(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8c877
movq -0x88(%rbp), %rax
movsd 0x20(%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x8c8c5
movq -0x88(%rbp), %rax
movb $0x1, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x4c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x91c60
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x30(%rax)
movb $0x0, -0x48(%rbp)
jmp 0x8c8cb
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x8c7cd
movq -0x90(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: convertNodeToSphere(VORONOI_NETWORK&, std::vector<Sphere, std::allocator<Sphere>>&, std::vector<bool, std::allocator<bool>>&)
void convertNodeToSphere(VORONOI_NETWORK& vornet,vector<Sphere>& nodes, vector<bool>& accessInfo)
{
  Sphere temp_sphere;
  VOR_NODE temp_vornode;
  
  nodes.clear();
#if DEBUG
  cout << "Adding: " << vornet.nodes.size() << " nodes (if all accessible)." << endl;
#endif
  // for each node check if it intersects the unitcell
  for (unsigned int i=0; i<vornet.nodes.size(); i++)
    {
      if (accessInfo[i] ==true)
	{
	  temp_vornode = vornet.nodes[i];
	  temp_sphere.center = Point(temp_vornode.x,temp_vornode.y,temp_vornode.z);
	  temp_sphere.radius = temp_vornode.rad_stat_sphere;
	  nodes.push_back(temp_sphere);
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x91d30
leaq -0x80(%rbp), %rdi
callq 0x99ae0
movq -0x10(%rbp), %rdi
callq 0x91dd0
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %eax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0xf270
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
jae 0x8d514
movq -0x18(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, %esi
callq 0x29990
movq %rdx, -0xd8(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x8d43a
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x101a0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x8d4fe
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movl -0x84(%rbp), %eax
movl %eax, %esi
callq 0x24e20
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x91df0
jmp 0x8d493
movsd -0x80(%rbp), %xmm0
movsd -0x78(%rbp), %xmm1
movsd -0x70(%rbp), %xmm2
leaq -0xc0(%rbp), %rdi
callq 0xe9c70
jmp 0x8d4b0
movq -0xb0(%rbp), %rax
movq %rax, -0x30(%rbp)
movups -0xc0(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x91d60
jmp 0x8d4df
jmp 0x8d4fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xf5c0
jmp 0x8d526
jmp 0x8d500
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x8d3ec
leaq -0x80(%rbp), %rdi
callq 0xf5c0
addq $0xe0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: convertAtomToSphere(ATOM_NETWORK*, std::vector<Sphere, std::allocator<Sphere>>&)
void convertAtomToSphere(ATOM_NETWORK *cell,vector<Sphere>& atoms)
{
  Sphere temp_sphere;
  ATOM temp_atom;
  
  atoms.clear();
#if DEBUG
  cout << "Adding: " << cell->atoms.size() << " atoms." << endl;
#endif
  // for each node check if it intersects the unitcell
  for (unsigned int i=0; i<cell->atoms.size(); i++)
    {
      temp_atom = cell->atoms[i];
      temp_sphere.center = Point(temp_atom.x,temp_atom.y,temp_atom.z);
      temp_sphere.radius = temp_atom.radius;
      atoms.push_back(temp_sphere);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x91d30
leaq -0xc8(%rbp), %rdi
callq 0x954b0
movq -0x10(%rbp), %rdi
callq 0x91dd0
movl $0x0, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
movq %rax, -0x100(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq %rax, %rcx
movq -0x100(%rbp), %rax
cmpq %rcx, %rax
jae 0x8d662
movq -0x8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0xcc(%rbp), %eax
movl %eax, %esi
callq 0xfcc0
movq %rax, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x595e0
jmp 0x8d5d4
movsd -0xc8(%rbp), %xmm0
movsd -0xc0(%rbp), %xmm1
movsd -0xb8(%rbp), %xmm2
leaq -0xf8(%rbp), %rdi
callq 0xe9c70
jmp 0x8d5fa
movq -0xe8(%rbp), %rax
movq %rax, -0x20(%rbp)
movups -0xf8(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x91d60
jmp 0x8d62c
jmp 0x8d62e
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x8d57b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0xf200
jmp 0x8d677
leaq -0xc8(%rbp), %rdi
callq 0xf200
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: findSphereOfPoint(Point, std::vector<Sphere, std::allocator<Sphere>>&, int&)
bool findSphereOfPoint(Point p,vector<Sphere>& spheres,int& id)
{
  for (unsigned int i=0; i<spheres.size(); i++){
    if ((calcEuclideanDistance(p,spheres[i].center) < spheres[i].radius) && (int)i != id){ 
      id = i;			
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x91bf0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x8d79f
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x91c10
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rcx
leaq -0x50(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0xebb80
movsd %xmm0, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x91c10
movsd -0x68(%rbp), %xmm1
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8d78f
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x8d78f
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8d7a3
jmp 0x8d791
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8d6b2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: genRandomVec()
Point genRandomVec()
{
  // Randomly sample point on a sphere of radius 1
  double theta = (rand()*1.0/RAND_MAX)*2*PI;
  double cosphi = 1.0 - (rand()*1.0/RAND_MAX)*2.0;
  double phi = acos(cosphi);
  
  // Convert spherical coordinates to xyz coordinates
  double x = sin(phi)*cos(theta); //Don't need abs(sin(phi)) becase phi is from 0 to PI
  double y = sin(phi)*sin(theta);
  double z = cosphi;
  Point temp(x,y,z);
  if (temp.magnitude() == 0){
    temp = genRandomVec();
  }
  return temp.unit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
callq 0x5190
cvtsi2sd %eax, %xmm0
movsd 0x16486c(%rip), %xmm1   # 0x1f2050
mulsd %xmm1, %xmm0
movsd 0x168e18(%rip), %xmm1   # 0x1f6608
divsd %xmm1, %xmm0
movsd 0x16484c(%rip), %xmm1   # 0x1f2048
mulsd %xmm1, %xmm0
movsd 0x168e28(%rip), %xmm1   # 0x1f6630
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x5190
cvtsi2sd %eax, %xmm0
movsd 0x16482e(%rip), %xmm1   # 0x1f2050
mulsd %xmm1, %xmm0
movsd 0x168dda(%rip), %xmm1   # 0x1f6608
divsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd %xmm0, %xmm0
movsd 0x1647fb(%rip), %xmm1   # 0x1f2050
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x54f0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5140
movsd %xmm0, -0x70(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5970
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5140
movsd %xmm0, -0x68(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5140
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
leaq -0x48(%rbp), %rdi
callq 0xe9c70
leaq -0x48(%rbp), %rdi
callq 0xe9fb0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8d918
jp 0x8d918
leaq -0x60(%rbp), %rdi
callq 0x8d7c0
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xea110
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/ray.cc
// Function: genRandomPoint()
Point genRandomPoint()
{
  // Randomly sample ray across the unit cell
  double aPoint = (rand()*1.0)/RAND_MAX;
  double bPoint = (rand()*1.0)/RAND_MAX;
  double cPoint = (rand()*1.0)/RAND_MAX;
  
  return Point(aPoint,bPoint,cPoint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
callq 0x5190
cvtsi2sd %eax, %xmm0
movsd 0x1646ef(%rip), %xmm1   # 0x1f2050
mulsd %xmm1, %xmm0
movsd 0x168c9b(%rip), %xmm1   # 0x1f6608
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x5190
cvtsi2sd %eax, %xmm0
movsd 0x1646c9(%rip), %xmm1   # 0x1f2050
mulsd %xmm1, %xmm0
movsd 0x168c75(%rip), %xmm1   # 0x1f6608
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x5190
movq -0x28(%rbp), %rdi
cvtsi2sd %eax, %xmm0
movsd 0x16469f(%rip), %xmm1   # 0x1f2050
mulsd %xmm1, %xmm0
movsd 0x168c4b(%rip), %xmm1   # 0x1f6608
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
callq 0xe9c70
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/./ray.h
// Function: hitdata::hitdata()
hitdata()
    {
      hit=false;
      hitpoint = Point(0,0,0);
      dist = 0.0;
      id = -1;
      object = NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
leaq -0x20(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/graphstorage.cc
// Function: deltaPosLessThan(DELTA_POS, DELTA_POS)
bool deltaPosLessThan (DELTA_POS p1, DELTA_POS p2) {
    if(p1.x != p2.x)
        return p1.x < p2.x;
    else if(p1.y != p2.y)
        return p1.y < p2.y;
    else if(p1.z != p2.z)
        return p1.z < p2.z;
    else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movl %esi, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq %rdx, -0x3c(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x3c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x943b6
movl -0x10(%rbp), %eax
cmpl -0x2c(%rbp), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x943ea
movl -0xc(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x943ce
movl -0xc(%rbp), %eax
cmpl -0x28(%rbp), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x943ea
movl -0x8(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x943e6
movl -0x8(%rbp), %eax
cmpl -0x24(%rbp), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x943ea
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/graphstorage.cc
// Function: CONN::CONN(int, int, double, double, DELTA_POS)
CONN::CONN(int myFrom, int myTo, double len, double maxR, DELTA_POS deltaP){
    from       = myFrom;
    to         = myTo;
    length     = len;
    max_radius = maxR;
    deltaPos   = deltaP;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x1c(%rbp)
movl %r8d, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x94010
movq -0x48(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movl %ecx, 0x4(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0xc(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/graphstorage.cc
// Function: DIJKSTRA_NODE::DIJKSTRA_NODE(int, double, double, double, double, bool)
DIJKSTRA_NODE::DIJKSTRA_NODE(int myID, double myX, double myY, double myZ, double maxR, bool active_flag){
    id = myID; x = myX; y = myY; z = myZ;
    connections = vector<CONN> ();
    max_radius = maxR;
    active = active_flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x20, %rdi
callq 0x64770
movq -0x58(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x52a0
leaq -0x50(%rbp), %rdi
callq 0x64770
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %rsi
callq 0x6c840
leaq -0x50(%rbp), %rdi
callq 0x11230
movq -0x58(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/graphstorage.cc
// Function: DIJKSTRA_NODE::print(std::ostream&) const
void DIJKSTRA_NODE::print(ostream &out) const {
    out << " Node info:" << "\n"
    << "    #: " << id << "    X: " << x << "    Y: " << y << "    Z:" << z << "\n"
    << "   Connections:" << "\n";
    for(unsigned int i = 0; i<connections.size(); i++){
        out << "     ";
        connections.at(i).print();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1631bd(%rip), %rsi    # 0x1f7820
callq 0x5540
movq %rax, %rdi
leaq 0x164fb3(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x1631ab(%rip), %rsi    # 0x1f782c
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0x163196(%rip), %rsi    # 0x1f7834
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x16317e(%rip), %rsi    # 0x1f783c
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x163166(%rip), %rsi    # 0x1f7844
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x164f27(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, %rdi
leaq 0x16313e(%rip), %rsi    # 0x1f784b
callq 0x5540
movq %rax, %rdi
leaq 0x164f09(%rip), %rsi    # 0x1f9625
callq 0x5540
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x2a9e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x94784
movq -0x10(%rbp), %rdi
leaq 0x15dd32(%rip), %rsi    # 0x1f2485
callq 0x5540
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x94d60
movq %rax, %rdi
movq 0x1de84c(%rip), %rsi    # 0x272fc0
callq 0x94480
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x94728
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/graphstorage.cc
// Function: DIJKSTRA_NETWORK::filterDnetEdges(std::vector<int, std::allocator<int>>, VORONOI_NETWORK*, DIJKSTRA_NETWORK*)
void DIJKSTRA_NETWORK::filterDnetEdges(vector<int> nodeIDs,
                                       VORONOI_NETWORK *origVornet,
                                       DIJKSTRA_NETWORK *newDnet){
    //VORONOI_NETWORK newVorNet;
    //VORONOI_NETWORK::filterVornetEdges(nodeIDs, origVornet, &newVorNet);
    VORONOI_NETWORK newVorNet = origVornet->filterEdges(nodeIDs);
    DIJKSTRA_NETWORK::buildDijkstraNetwork(&newVorNet, newDnet);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xeec0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x99e30
jmp 0x94c87
leaq -0xa8(%rbp), %rdi
callq 0xec80
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x948c0
jmp 0x94ca5
leaq -0x90(%rbp), %rdi
callq 0xf8a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xec80
jmp 0x94cf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xf8a0
movq -0xb0(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM::ATOM()
ATOM::ATOM() {
  type = "";
  label = "";
  radius = 0;
  charge = 0; //because this is not always provided, a default value of zero is set
  keep = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x40, %rdi
movq %rdi, -0x20(%rbp)
callq 0x5720
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x28(%rbp)
callq 0x5720
movq -0x20(%rbp), %rdi
leaq 0x15e0df(%rip), %rsi    # 0x1f35cc
callq 0x5710
jmp 0x954f4
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x15e0c9(%rip), %rsi    # 0x1f35cc
callq 0x5710
jmp 0x9550a
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
movb $0x1, 0x90(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5300
movq -0x20(%rbp), %rdi
callq 0x5300
movq -0x10(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM::ATOM(XYZ, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
ATOM::ATOM(XYZ xyz, string s, double r) {
  x = xyz.x;
  y = xyz.y;
  z = xyz.z;
  type = s;
  label = s;
  radius = r;
  charge = 0;
  keep = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5720
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x50(%rbp)
callq 0x5720
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
callq 0x5060
jmp 0x955da
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x5060
jmp 0x955ed
movq -0x40(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
movb $0x1, 0x90(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5300
movq -0x38(%rbp), %rdi
callq 0x5300
movq -0x20(%rbp), %rdi
callq 0x58f0
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM::ATOM(XYZ, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
ATOM::ATOM(XYZ xyz, string s, string l, double r) {
  x = xyz.x;
  y = xyz.y;
  z = xyz.z;
  type = s;
  label = l;
  radius = r;
  charge = 0;
  keep = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x60(%rbp)
movq %rsi, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x40, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5720
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5720
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
callq 0x5060
jmp 0x956c2
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
callq 0x5060
jmp 0x956d5
movq -0x48(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
movb $0x1, 0x90(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5300
movq -0x40(%rbp), %rdi
callq 0x5300
movq -0x28(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::update_atom_fractional_coords()
void ATOM_NETWORK::update_atom_fractional_coords() {
  for(int i=0; i<numAtoms; i++) {
    XYZ xyz(atoms.at(i).x, atoms.at(i).y, atoms.at(i).z);
    XYZ abc = trans_to_origuc(xyz_to_abc_returning_XYZ(xyz));
    atoms.at(i).a_coord = abc.x;
    atoms.at(i).b_coord = abc.y;
    atoms.at(i).c_coord = abc.z;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x60(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x110(%rcx), %eax
jge 0x95a2b
movq -0x60(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xc(%rbp), %rsi
callq 0xf090
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xc(%rbp), %rsi
callq 0xf090
movq -0x60(%rbp), %rdi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xc(%rbp), %rsi
callq 0xf090
movsd -0x88(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
movsd 0x10(%rax), %xmm2
leaq -0x28(%rbp), %rdi
callq 0xea8e0
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x95a40
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe9320
movq -0x60(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xc(%rbp), %rsi
callq 0xf090
movsd -0x78(%rbp), %xmm0
movq -0x60(%rbp), %rdi
movsd %xmm0, 0x18(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xc(%rbp), %rsi
callq 0xf090
movsd -0x70(%rbp), %xmm0
movq -0x60(%rbp), %rdi
movsd %xmm0, 0x20(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xc(%rbp), %rsi
callq 0xf090
movsd -0x68(%rbp), %xmm0
movsd %xmm0, 0x28(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x958ee
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::make(double, double, double, double, double, double)
void ATOM_NETWORK::make(double a0, double b0, double c0, double alpha0, double beta0, double gamma0){
  a = a0;
  b = b0;
  c = c0;
  alpha = alpha0;
  beta = beta0;
  gamma = gamma0;
  initialize();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x30(%rdi)
callq 0x96250
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::make(XYZ, XYZ, XYZ)
void ATOM_NETWORK::make(XYZ va, XYZ vb, XYZ vc) {
  v_a = va;
  v_b = vb;
  v_c = vc;
  a = v_a.magnitude();
  b = v_b.magnitude();
  c = v_c.magnitude();
  alpha = 360.0*v_b.angle_between(v_c)/(2.0*PI);
  beta = 360.0*v_a.angle_between(v_c)/(2.0*PI);
  gamma = 360.0*v_a.angle_between(v_b)/(2.0*PI);
  initMatrices();
  distanceCalculator = MIN_PER_DISTANCE(v_a.x, v_b.x, v_b.y, v_c.x, v_c.y, v_c.z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x40(%rbp), %rax
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq (%rdx), %rsi
movq %rsi, 0x38(%rdi)
movq 0x8(%rdx), %rsi
movq %rsi, 0x40(%rdi)
movq 0x10(%rdx), %rdx
movq %rdx, 0x48(%rdi)
movq (%rcx), %rdx
movq %rdx, 0x50(%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x58(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x60(%rdi)
movq (%rax), %rcx
movq %rcx, 0x68(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x70(%rdi)
movq 0x10(%rax), %rax
movq %rax, 0x78(%rdi)
addq $0x38, %rdi
callq 0xe9240
movq -0x88(%rbp), %rdi
movsd %xmm0, 0x8(%rdi)
addq $0x50, %rdi
callq 0xe9240
movq -0x88(%rbp), %rdi
movsd %xmm0, 0x10(%rdi)
addq $0x68, %rdi
callq 0xe9240
movq -0x88(%rbp), %rsi
movsd %xmm0, 0x18(%rsi)
movq %rsi, %rdi
addq $0x50, %rdi
addq $0x68, %rsi
callq 0xeac60
movq -0x88(%rbp), %rsi
movaps %xmm0, %xmm1
movsd 0x15c4cc(%rip), %xmm0   # 0x1f2a98
mulsd %xmm1, %xmm0
movsd 0x15c4c8(%rip), %xmm1   # 0x1f2aa0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsi)
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x68, %rsi
callq 0xeac60
movq -0x88(%rbp), %rsi
movaps %xmm0, %xmm1
movsd 0x15c495(%rip), %xmm0   # 0x1f2a98
mulsd %xmm1, %xmm0
movsd 0x15c491(%rip), %xmm1   # 0x1f2aa0
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsi)
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x50, %rsi
callq 0xeac60
movq -0x88(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0x15c45e(%rip), %xmm0   # 0x1f2a98
mulsd %xmm1, %xmm0
movsd 0x15c45a(%rip), %xmm1   # 0x1f2aa0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rdi)
callq 0x966b0
movq -0x88(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd 0x50(%rax), %xmm1
movsd 0x58(%rax), %xmm2
movsd 0x68(%rax), %xmm3
movsd 0x70(%rax), %xmm4
movsd 0x78(%rax), %xmm5
leaq -0x80(%rbp), %rdi
callq 0xd73c0
movq -0x88(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
leaq -0x80(%rbp), %rsi
callq 0xada80
leaq -0x80(%rbp), %rdi
callq 0x122d0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::initMatrices()
void ATOM_NETWORK::initMatrices(){
    ucVectors[0][0] = v_a.x; ucVectors[1][0] = v_a.y; ucVectors[2][0] = v_a.z;
    ucVectors[0][1] = v_b.x; ucVectors[1][1] = v_b.y; ucVectors[2][1] = v_b.z;
    ucVectors[0][2] = v_c.x; ucVectors[1][2] = v_c.y; ucVectors[2][2] = v_c.z;
    valid = tryInvertMatrix(ucVectors,invUCVectors);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x80(%rsi)
movsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x98(%rsi)
movsd 0x48(%rsi), %xmm0
movsd %xmm0, 0xb0(%rsi)
movsd 0x50(%rsi), %xmm0
movsd %xmm0, 0x88(%rsi)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0xa0(%rsi)
movsd 0x60(%rsi), %xmm0
movsd %xmm0, 0xb8(%rsi)
movsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x90(%rsi)
movsd 0x70(%rsi), %xmm0
movsd %xmm0, 0xa8(%rsi)
movsd 0x78(%rsi), %xmm0
movsd %xmm0, 0xc0(%rsi)
movq %rsi, %rdi
addq $0x80, %rdi
addq $0xc8, %rsi
callq 0xe98f0
movb %al, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x3b8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)