LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x83f68
leaq 0x20(%rsp), %rdi
callq 0x5521c
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4c138
movq %rax, 0x8(%r14)
movq 0x48(%r15), %r12
cmpq %r12, 0x50(%r15)
je 0x4c21d
movl $0x1, %ebp
xorl %r13d, %r13d
leal -0x1(%rbp), %eax
movq (%rbx), %rcx
shrl $0x6, %eax
movq (%rcx,%rax,8), %rax
btq %r13, %rax
jae 0x4c200
shlq $0x6, %r13
leaq (%r12,%r13), %rsi
addq $0x20, %rsi
movups -0x20(%rsi), %xmm0
movups -0x10(%rsi), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x100d2
addq %r13, %r12
movb 0x38(%r12), %al
movb %al, 0x58(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
leaq 0x60(%rsp), %rdi
callq 0x83f68
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x60(%rsp), %xmm0
movaps %xmm0, (%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x4c1f5
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%r14)
jmp 0x4c200
movq %r14, %rdi
movq %rsp, %rdx
callq 0x503aa
movl %ebp, %r13d
movq 0x48(%r15), %r12
movq 0x50(%r15), %rax
subq %r12, %rax
sarq $0x6, %rax
incl %ebp
cmpq %r13, %rax
ja 0x4c14e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4c234
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c245
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4c25f
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x83f68
leaq 0x40(%rsp), %rdi
callq 0x51264
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4c2a6
movq %rax, 0x8(%rbx)
movq 0x2f0(%r14), %r13
cmpq %r13, 0x2f8(%r14)
je 0x4c3c7
leaq 0x80(%rsp), %r15
movl $0x1, %ebp
xorl %eax, %eax
imulq $0x98, %rax, %r12
leaq (%r12,%r13), %rsi
addq $0x40, %rsi
movups -0x40(%rsi), %xmm0
movups -0x30(%rsi), %xmm1
movups -0x20(%rsi), %xmm2
movups -0x10(%rsi), %xmm3
movaps %xmm3, 0x70(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %r15, %rdi
callq 0x4240
addq %r12, %r13
leaq 0x60(%r13), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x4240
movb 0x90(%r13), %al
movb %al, 0x50(%r15)
movups 0x80(%r13), %xmm0
movups %xmm0, 0x40(%r15)
movsd 0x40(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
leaq 0x28(%rsp), %rdi
callq 0x83f68
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x28(%rsp), %xmm0
movaps %xmm0, (%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4c38c
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%rbx)
jmp 0x4c397
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x503aa
movl %ebp, %eax
movq 0x2f0(%r14), %r13
movq 0x2f8(%r14), %rcx
subq %r13, %rcx
sarq $0x3, %rcx
movabsq $-0x79435e50d79435e5, %rdx # imm = 0x86BCA1AF286BCA1B
imulq %rdx, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x4c2c9
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c3e8
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x4470
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c409
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x4470
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c41d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2f5e8
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x4150
cvtsi2sd %eax, %xmm0
divsd 0x105108(%rip), %xmm0   # 0x1515f0
addsd %xmm0, %xmm0
mulsd 0x10511c(%rip), %xmm0   # 0x151610
movsd %xmm0, 0x10(%rsp)
callq 0x4150
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x10510a(%rip), %xmm0   # 0x151618
addsd %xmm0, %xmm0
addsd 0x100b3e(%rip), %xmm0   # 0x14d058
movsd %xmm0, 0x18(%rsp)
callq 0x4400
movsd %xmm0, (%rsp)
callq 0x4100
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4800
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x4100
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4100
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
callq 0x83f68
movq %r14, %rdi
callq 0x8406c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4c5bd
jp 0x4c5bd
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x4c4cd
movq 0x10(%r14), %rax
movq %rax, 0x30(%rsp)
movupd (%r14), %xmm0
movapd %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x840e2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4150
cvtsi2sd %eax, %xmm0
divsd 0x105002(%rip), %xmm0   # 0x1515f0
movsd %xmm0, 0x8(%rsp)
callq 0x4150
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x104fe8(%rip), %xmm0   # 0x1515f0
movsd %xmm0, (%rsp)
callq 0x4150
cvtsi2sd %eax, %xmm2
divsd 0x104fd2(%rip), %xmm2   # 0x1515f0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x83f68
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/ray.cc
// Function: reportHistogram(std::ostream&, double, int, std::vector<ray, std::allocator<ray>>&)
void reportHistogram(ostream& output,const double binSize,const int maxBins, vector<ray>& rays)
{
  assert(binSize > threshold);
  int bins[maxBins];
  for (int i=0; i<maxBins; i++)
    {
      bins[i] = 0;
    }
  
  //Assemble Hitsogram
  int bin;
  for (unsigned int i=0; i<rays.size(); i++)
    {
      bin = rays[i].vector.magnitude()/binSize;
      if (bin >= maxBins) 
	{
	  bin = maxBins - 1;
	}
      bins[bin]++;
    }
  
  //Output Histogram
  output << "Ray Histogram - Bin Size = " << binSize << " Number of Bins: " << maxBins << "From: 0 To: " << binSize * 1.0 * maxBins<< endl;
  for (int i=0; i<maxBins; i++)
    {
      output << bins[i] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, -0x30(%rbp)
ucomisd 0x102733(%rip), %xmm0   # 0x152278
jbe 0x4fce7
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, -0x48(%rbp)
movl %esi, %ebx
movq %rsp, %r14
leaq 0xf(,%rbx,4), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testl %esi, %esi
jle 0x4fb82
leaq (,%rbx,4), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4250
movq %rbx, -0x40(%rbp)
movq (%r12), %rax
cmpq %rax, 0x8(%r12)
je 0x4fbf2
leal -0x1(%r15), %ecx
movl %ecx, -0x34(%rbp)
movl $0x1, %ebx
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
addq $0x18, %rdi
callq 0x8406c
divsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
cmpl %r15d, %eax
jl 0x4fbcf
movl -0x34(%rbp), %eax
cltq
incl (%r14,%rax,4)
movl %ebx, %ecx
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r13, %rdx
incl %ebx
cmpq %rcx, %rdx
ja 0x4fba9
leaq 0x102aa8(%rip), %rsi    # 0x1526a1
movl $0x1b, %edx
movq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0x44e0
movq %r13, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x46b0
movq %rax, %r12
leaq 0x102a9c(%rip), %rsi    # 0x1526bd
movl $0x11, %edx
movq %rax, %rdi
callq 0x44e0
movq %r12, %rdi
movl %r15d, %esi
callq 0x4750
movq %rax, %r12
leaq 0x102a8c(%rip), %rsi    # 0x1526cf
movl $0xc, %edx
movq %rax, %rdi
callq 0x44e0
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd -0x30(%rbp), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4420
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42c0
testl %r15d, %r15d
movq -0x40(%rbp), %r12
jle 0x4fcd8
xorl %ebx, %ebx
movl (%r14,%rbx,4), %esi
movq %r13, %rdi
callq 0x4750
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4420
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x42c0
incq %rbx
cmpq %rbx, %r12
jne 0x4fc9a
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x102957(%rip), %rdi    # 0x152645
leaq 0x102629(%rip), %rsi    # 0x15231e
leaq 0x10295d(%rip), %rcx    # 0x152659
movl $0x57b, %edx            # imm = 0x57B
callq 0x4290
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %esi, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movsd %xmm3, 0x38(%rdi)
movb %dl, 0x40(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x101d88(%rip), %rsi    # 0x152710
movl $0xb, %edx
movq %rbx, %rdi
callq 0x44e0
leaq 0x102c82(%rip), %r15    # 0x15361e
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x101d69(%rip), %rsi    # 0x15271c
movl $0x7, %edx
movq %rbx, %rdi
callq 0x44e0
movl (%r14), %esi
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0x4750
movq %rax, %r12
leaq 0x101d4b(%rip), %rsi    # 0x152724
movl $0x7, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x8(%r14), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x101d2e(%rip), %rsi    # 0x15272c
movl $0x7, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x10(%r14), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x101d11(%rip), %rsi    # 0x152734
movl $0x6, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x18(%r14), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x101ce3(%rip), %rsi    # 0x15273b
movl $0xf, %edx
movq %r12, %rdi
callq 0x44e0
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x44e0
movq 0x28(%r14), %rax
cmpq 0x20(%r14), %rax
je 0x50af2
movl $0x1, %ebp
xorl %r15d, %r15d
leaq 0xfca4e(%rip), %r12     # 0x14d4dc
movabsq $-0x3333333333333333, %rbx # imm = 0xCCCCCCCCCCCCCCCD
movq 0x144521(%rip), %r13    # 0x194fc0
movl $0x5, %edx
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x44e0
movq 0x20(%r14), %rax
movq 0x28(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %r15, %rdx
jbe 0x50b01
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,8), %rdi
movq %r13, %rsi
callq 0x50832
movl %ebp, %r15d
movq 0x28(%r14), %rax
subq 0x20(%r14), %rax
sarq $0x3, %rax
imulq %rbx, %rax
incl %ebp
cmpq %r15, %rax
ja 0x50a9f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfcbed(%rip), %rdi     # 0x14d6f5
movq %r15, %rsi
xorl %eax, %eax
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0xe8f8
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5542e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x50e22
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x50c10
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x50e49
movq 0x88(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x60(%rsp), %rdi
callq 0xf256
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xeb2a
jmp 0x50e88
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x50e88
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xfd154(%rip), %rcx     # 0x14e3f3
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x4670
movq 0x68(%r15), %rdx
leaq 0xfd13a(%rip), %rcx     # 0x14e3f3
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x4670
xorl %eax, %eax
movq %rax, 0x30(%r15)
movq %rax, 0x88(%r15)
movb $0x1, 0x90(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x512fd
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ec3
movq %r15, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r12
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x70(%rdi), %rbp
movq %rbp, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rdi)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
movq %rbx, %rdi
callq 0x4240
movq %r13, %rdi
movq %r12, %rsi
callq 0x4240
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r15)
movq $0x0, 0x88(%r15)
movb $0x1, 0x90(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x513b9
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ed7
movq %r15, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %r12
movq %rdi, %r15
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %r14
movq %r14, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r13
leaq 0x70(%rdi), %rbp
movq %rbp, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rdi)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
movq %rbx, %rdi
callq 0x4240
movq %r13, %rdi
movq %r12, %rsi
callq 0x4240
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r15)
movq $0x0, 0x88(%r15)
movb $0x1, 0x90(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x51475
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4eeb
movq %r15, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x0, 0x110(%rdi)
jle 0x516f9
movq %rdi, %rbx
movq 0x2f0(%rdi), %rcx
movq 0x2f8(%rdi), %rdx
xorl %ebp, %ebp
movabsq $-0x79435e50d79435e5, %r15 # imm = 0x86BCA1AF286BCA1B
leaq 0x50(%rsp), %r12
leaq 0x30(%rsp), %r13
xorl %r14d, %r14d
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %r15, %rdx
cmpq %r14, %rdx
jbe 0x51717
movsd (%rcx,%rbp), %xmm0
movsd 0x8(%rcx,%rbp), %xmm1
movsd 0x10(%rcx,%rbp), %xmm2
leaq 0x18(%rsp), %rdi
callq 0x84364
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movq %r12, %rdi
movq %rbx, %rsi
callq 0x52f42
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x83a19
movq 0x2f0(%rbx), %rcx
movq 0x2f8(%rbx), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
imulq %r15, %rax
cmpq %r14, %rax
jbe 0x51708
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x18(%rcx,%rbp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x28(%rcx,%rbp)
incq %r14
movslq 0x110(%rbx), %rax
addq $0x98, %rbp
cmpq %rax, %r14
jl 0x51641
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfbfe6(%rip), %rdi     # 0x14d6f5
movq %r14, %rsi
movq %rax, %rdx
jmp 0x51721
leaq 0xfbfd7(%rip), %rdi     # 0x14d6f5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::print(std::ostream&)
void ATOM_NETWORK::print(ostream &out){
    out << "Name: " << name << "\n"
    << "A: " << a <<"     B: " << b << "     C: " << c << "\n"
    << "Alpha: " << alpha <<"     Beta: " << beta << "     Gamma: " << gamma
    << "\n";
    out << "v_a: "; v_a.print();
    out << "v_b: "; v_b.print();
    out << "v_c: "; v_c.print();
    out << "Number of atoms: " << numAtoms << "\n";
    for(int i = 0; i<numAtoms; i++)
        atoms.at(i).print();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1005e6(%rip), %rsi    # 0x1529c0
movl $0x6, %edx
movq %r14, %rdi
callq 0x44e0
movq 0x320(%rbx), %rsi
movq 0x328(%rbx), %rdx
movq %r14, %rdi
callq 0x44e0
movq %rax, %r12
leaq 0x101217(%rip), %r15    # 0x15361e
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0xffc18(%rip), %rsi     # 0x152036
movl $0x3, %edx
movq %r12, %rdi
callq 0x44e0
movsd 0x8(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x100585(%rip), %rsi    # 0x1529c7
movl $0x8, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x10(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x10056a(%rip), %rsi    # 0x1529d0
movl $0x8, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x18(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x10053f(%rip), %rsi    # 0x1529d9
movl $0x7, %edx
movq %r12, %rdi
callq 0x44e0
movsd 0x20(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x100523(%rip), %rsi    # 0x1529e1
movl $0xb, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x28(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movq %rax, %r12
leaq 0x10050b(%rip), %rsi    # 0x1529ed
movl $0xc, %edx
movq %rax, %rdi
callq 0x44e0
movsd 0x30(%rbx), %xmm0
movq %r12, %rdi
callq 0x46b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
leaq 0x1004e7(%rip), %rsi    # 0x1529fa
movl $0x5, %edx
movq %r14, %rdi
callq 0x44e0
leaq 0x38(%rbx), %rdi
movq 0x142a95(%rip), %r12    # 0x194fc0
movq %r12, %rsi
callq 0x84374
leaq 0x1004c6(%rip), %rsi    # 0x152a00
movl $0x5, %edx
movq %r14, %rdi
callq 0x44e0
leaq 0x50(%rbx), %rdi
movq %r12, %rsi
callq 0x84374
leaq 0x1004ac(%rip), %rsi    # 0x152a06
movl $0x5, %edx
movq %r14, %rdi
callq 0x44e0
leaq 0x68(%rbx), %rdi
movq %r12, %rsi
callq 0x84374
leaq 0x100492(%rip), %rsi    # 0x152a0c
movl $0x11, %edx
movq %r14, %rdi
callq 0x44e0
movl 0x110(%rbx), %esi
movq %r14, %rdi
callq 0x4750
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
cmpl $0x0, 0x110(%rbx)
jle 0x52604
xorl %r12d, %r12d
movabsq $-0x79435e50d79435e5, %r13 # imm = 0x86BCA1AF286BCA1B
movq 0x1429fe(%rip), %r15    # 0x194fc0
xorl %r14d, %r14d
movq 0x2f0(%rbx), %rdi
movq 0x2f8(%rbx), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x5260e
addq %r12, %rdi
movq %r15, %rsi
callq 0x51488
incq %r14
movslq 0x110(%rbx), %rax
addq $0x98, %r12
cmpq %rax, %r14
jl 0x525c5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xfb0e0(%rip), %rdi     # 0x14d6f5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::copy(ATOM_NETWORK*)
void ATOM_NETWORK::copy(ATOM_NETWORK *newNet){
    newNet->a = a; newNet->b = b; newNet->c = c;
    newNet->alpha = alpha; newNet->beta = beta; newNet->gamma = gamma;
    newNet->v_a = v_a; newNet->v_b = v_b; newNet->v_c = v_c;
    newNet->numAtoms = numAtoms; newNet->name = name;
    newNet->atoms.clear(); newNet->atoms = atoms;
    newNet->IDmapping.clear(); newNet->IDmapping = IDmapping;

    newNet->vertices.clear(); newNet->vertices = vertices;
    newNet->orphan_edge_starts.clear(); newNet->orphan_edge_starts = orphan_edge_starts;
    newNet->orphan_edge_ends.clear(); newNet->orphan_edge_ends = orphan_edge_ends;
    newNet->vertex_basic_indices.clear(); newNet->vertex_basic_indices = vertex_basic_indices;
    newNet->vertex_symmetry_operators.clear(); newNet->vertex_symmetry_operators = vertex_symmetry_operators;
    newNet->sym_ID = sym_ID;
    newNet->sym_name = sym_name;
    newNet->valid = valid;

    newNet->initialize();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movups 0x8(%rdi), %xmm0
movups %xmm0, 0x8(%rsi)
movups 0x18(%rdi), %xmm0
movups %xmm0, 0x18(%rsi)
movups 0x28(%rdi), %xmm0
movups %xmm0, 0x28(%rsi)
movq 0x48(%rdi), %rax
movq %rax, 0x48(%rsi)
movups 0x38(%rdi), %xmm0
movups %xmm0, 0x38(%rsi)
movq 0x60(%rdi), %rax
movq %rax, 0x60(%rsi)
movups 0x50(%rdi), %xmm0
movups %xmm0, 0x50(%rsi)
movups 0x68(%rdi), %xmm0
movups %xmm0, 0x68(%rsi)
movq 0x78(%rdi), %rax
movq %rax, 0x78(%rsi)
movl 0x110(%rdi), %eax
movl %eax, 0x110(%rsi)
movl $0x320, %edi            # imm = 0x320
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x4240
movl $0x2f0, %r15d           # imm = 0x2F0
leaq (%rbx,%r15), %r12
movq 0x2f0(%rbx), %rsi
movq %r12, %rdi
callq 0x12ea6
addq %r14, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x66dea
leaq 0x308(%rbx), %rdi
movq 0x308(%rbx), %rax
cmpq %rax, 0x310(%rbx)
je 0x526d8
movq %rax, 0x310(%rbx)
leaq 0x308(%r14), %rsi
callq 0x100d2
movl $0x3c0, %r15d           # imm = 0x3C0
leaq (%rbx,%r15), %r12
movq 0x3c0(%rbx), %rsi
movq %r12, %rdi
callq 0x67fb0
addq %r14, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x66ec0
leaq 0x3d8(%rbx), %rdi
movq 0x3d8(%rbx), %rax
cmpq %rax, 0x3e0(%rbx)
je 0x52729
movq %rax, 0x3e0(%rbx)
leaq 0x3d8(%r14), %rsi
callq 0x66f96
leaq 0x3f0(%rbx), %rdi
movq 0x3f0(%rbx), %rax
cmpq %rax, 0x3f8(%rbx)
je 0x52753
movq %rax, 0x3f8(%rbx)
leaq 0x3f0(%r14), %rsi
callq 0x66f96
leaq 0x408(%rbx), %rdi
movq 0x408(%rbx), %rax
cmpq %rax, 0x410(%rbx)
je 0x5277d
movq %rax, 0x410(%rbx)
leaq 0x408(%r14), %rsi
callq 0x100d2
leaq 0x420(%rbx), %rdi
movq 0x420(%rbx), %rax
cmpq %rax, 0x428(%rbx)
je 0x527a7
movq %rax, 0x428(%rbx)
leaq 0x420(%r14), %rsi
callq 0x100d2
movl 0x438(%r14), %eax
movl %eax, 0x438(%rbx)
movl $0x440, %edi            # imm = 0x440
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0x4240
movb 0x3b8(%r14), %al
movb %al, 0x3b8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51db4
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::abc_to_xyz(double, double, double) const
const Point ATOM_NETWORK::abc_to_xyz(double a, double b, double c) const {
    //Point xyzCoords;
    /*
     xyzCoords.x = a*cell->v_a.x+b*cell->v_b.x+c*cell->v_c.x;
     xyzCoords.y = a*cell->v_a.y+b*cell->v_b.y+c*cell->v_c.y;
     xyzCoords.z = a*cell->v_a.z+b*cell->v_b.z+c*cell->v_c.z;
     if(fabs(xyzCoords.x) < 0.00001) xyzCoords.x = 0;
     if(fabs(xyzCoords.y) < 0.00001) xyzCoords.y = 0;
     if(fabs(xyzCoords.z) < 0.00001) xyzCoords.z = 0;
     */
    
    // Use only non-zero elements in computation
    double xt = a*v_a.x+b*v_b.x+c*v_c.x;
    double yt = b*v_b.y+c*v_c.y;
    double zt = c*v_c.z;
    return Point(xt, yt, zt);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x50(%rsi), %xmm3
mulsd 0x38(%rsi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0x68(%rsi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0x70(%rsi), %xmm3
mulsd 0x58(%rsi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x78(%rsi), %xmm2
callq 0x83f68
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::calcDistanceXYZ(double, double, double, double, double, double) const
double ATOM_NETWORK::calcDistanceXYZ(double x1, double y1, double z1, double x2, double y2, double z2) const {
    Point abcCoord = xyz_to_abc(x1, y1, z1);
    //cout << abcCoord.vals[0] <<  abcCoord.vals[1] << abcCoord.vals[2] << endl;
    //cout << x2 <<  y2 << z2 << endl;
    //cout << calcDistanceXYZABC(x2, y2, z2, abcCoord[0], abcCoord[1], abcCoord[2]);
    return calcDistanceXYZABC(x2, y2, z2, abcCoord[0], abcCoord[1], abcCoord[2]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm5, 0x28(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rdi, %rbx
movsd 0xd0(%rdi), %xmm3
mulsd 0xc8(%rdi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0xd8(%rdi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0xf0(%rdi), %xmm3
mulsd 0xe8(%rdi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x108(%rdi), %xmm2
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x83f68
movq %r14, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm5
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
callq 0x53538
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: ATOM_NETWORK::getClosestPointInABC(double, double, double, double, double, double)
const XYZ ATOM_NETWORK::getClosestPointInABC(double x1, double y1, double z1, double x2, double y2, double z2){
    Point abcCoordStatic = xyz_to_abc(x1, y1, z1);
    Point abcCoordMobile = xyz_to_abc(x2, y2, z2);
    XYZ answer;
    getDistCalc().closest_periodic_image(abcCoordStatic[0], abcCoordStatic[1], abcCoordStatic[2],
                                         abcCoordMobile[0], abcCoordMobile[1], abcCoordMobile[2],
                                         answer.x, answer.y, answer.z);
    return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm3, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xd0(%rsi), %xmm3
mulsd 0xc8(%rsi), %xmm0
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movsd 0xd8(%rsi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd 0xf0(%rsi), %xmm3
mulsd 0xe8(%rsi), %xmm1
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm1
mulsd 0x108(%rsi), %xmm2
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x83f68
movsd 0xd0(%r14), %xmm0
movsd (%rsp), %xmm1
mulsd 0xc8(%r14), %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm0
addsd %xmm0, %xmm1
movsd 0xd8(%r14), %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xf0(%r14), %xmm1
mulsd 0xe8(%r14), %xmm3
mulsd %xmm2, %xmm1
addsd %xmm1, %xmm3
movapd %xmm3, %xmm1
mulsd 0x108(%r14), %xmm2
leaq 0x28(%rsp), %rdi
callq 0x83f68
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %rbx, %rdi
callq 0x84364
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x527f2
movq %r15, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm5
leaq 0x8(%rbx), %rdx
leaq 0x10(%rbx), %rcx
leaq 0x58(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movsd 0x18(%rsp), %xmm4
movq %rbx, %rsi
callq 0x77fcc
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x53904
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x5391e
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x53935
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x385cc
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: VORONOI_NETWORK::prune(double const&)
const VORONOI_NETWORK VORONOI_NETWORK::prune(const double& minRadius)
{
    vector<VOR_EDGE> newEdges;
    // Add edges whose radius is greater than the input minimum to a list
    for(vector<VOR_EDGE>::iterator edgeIter = edges.begin();
        edgeIter != edges.end(); edgeIter++) {
        if(edgeIter->rad_moving_sphere > minRadius){
            //VOR_EDGE newEdge = *edgeIter;
            
            // further check: keep edges only if they connect accessible nodes
            if( nodes[edgeIter->from].rad_stat_sphere > minRadius && nodes[edgeIter->to].rad_stat_sphere > minRadius )
                newEdges.push_back(*edgeIter);
            
        }
    };
    
    vector<VOR_NODE> newNodes = nodes;
    for(unsigned int i = 0; i < nodes.size(); i++)
    {
        if(nodes[i].rad_stat_sphere > minRadius) newNodes[i].active = true; else newNodes[i].active = false;
    };
    
    return VORONOI_NETWORK(v_a, v_b, v_c, newNodes, newEdges);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x60(%rsi), %r12
movq 0x68(%rsi), %rax
cmpq %rax, %r12
je 0x55db9
movq %rsp, %r13
movsd 0x8(%r12), %xmm1
movsd (%r15), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x55db0
movslq (%r12), %rdx
movq 0x48(%r14), %rcx
shlq $0x6, %rdx
movsd 0x18(%rcx,%rdx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x55db0
movslq 0x4(%r12), %rdx
shlq $0x6, %rdx
movsd 0x18(%rcx,%rdx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x55db0
movq %r13, %rdi
movq %r12, %rsi
callq 0xea2c
movq 0x68(%r14), %rax
addq $0x28, %r12
cmpq %rax, %r12
jne 0x55d62
leaq 0x48(%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0x670ee
movq 0x48(%r14), %rax
movq 0x50(%r14), %rcx
subq %rax, %rcx
je 0x55e06
sarq $0x6, %rcx
movsd (%r15), %xmm0
movl $0x1, %edx
movq 0x18(%rsp), %rsi
xorl %edi, %edi
movsd 0x18(%rax,%rdi), %xmm1
ucomisd %xmm0, %xmm1
seta 0x38(%rsi,%rdi)
movl %edx, %r8d
addq $0x40, %rdi
incl %edx
cmpq %r8, %rcx
ja 0x55de9
leaq 0x18(%r14), %rdx
leaq 0x30(%r14), %rcx
leaq 0x18(%rsp), %r8
movq %rsp, %r9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x552d0
leaq 0x18(%rsp), %rdi
callq 0xf256
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x55e41
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf256
jmp 0x55e66
jmp 0x55e63
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x55e7c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkstorage.cc
// Function: parse_group(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>>>>*, int, ATOM_NETWORK*)
void parse_group(vector<string> *token, int first_index, ATOM_NETWORK *cell) {
  bool verbose = false;
  string sym_name = token->at(first_index+0);
  if(verbose) printf("parsed group name %s\n", sym_name.c_str());
  int sym_ID = get_sym_ID(sym_name);
  if(verbose) printf("\ti.e. group ID %d\n", sym_ID);
  cell->sym_ID = sym_ID;
  cell->sym_name = sym_name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movslq %esi, %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
jbe 0x614c0
shlq $0x5, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rcx,%rsi), %rax
movq 0x8(%rcx,%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xf3ce
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xf3ce
movq %rsp, %rdi
callq 0x1066c3
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x61482
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
movl %ebp, 0x438(%rbx)
addq $0x440, %rbx            # imm = 0x440
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4240
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x614b3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4470
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xec22e(%rip), %rdi     # 0x14d6f5
xorl %eax, %eax
callq 0x4630
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x614ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4470
jmp 0x614ec
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x61503
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_FACE::getEdgeCoords()
vector< pair<Point, Point> > VOR_FACE::getEdgeCoords() {
  vector< pair<Point, Point> > results = vector< pair<Point,Point> > ();
  for(unsigned int i = 0; i < orderedVertices.size() - 1; i++){
    Point curPt = orderedVertices[i];
    Point nextPt = orderedVertices[i+1];
    results.push_back(pair<Point,Point> (curPt,nextPt));
  }
  results.push_back(pair<Point,Point> (orderedVertices[orderedVertices.size() - 1],orderedVertices[0]));
  return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x6a491
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
movups (%rax), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
xorl %esi, %esi
jmp 0x6a5a5
movq %rsi, %r14
movl $0x1, %ecx
leaq 0x18(%rsp), %r12
xorl %ebp, %ebp
movq %rsp, %r15
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq (,%rbp,2), %rdx
addq %rbp, %rdx
movq 0x10(%rax,%rdx,8), %rsi
movq %rsi, 0x60(%rsp)
movups (%rax,%rdx,8), %xmm0
movaps %xmm0, 0x50(%rsp)
movl %ecx, %ebp
leaq (%rbp,%rbp,2), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x40(%rsp)
movups (%rax,%rcx,8), %xmm1
movaps %xmm1, 0x30(%rsp)
movq %rsi, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %rdx, 0x10(%r12)
movups %xmm1, (%r12)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6a525
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6a530
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6dd04
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
decq %rdx
leal 0x1(%rbp), %ecx
cmpq %rbp, %rdx
ja 0x6a4ad
movq 0x8(%rbx), %rsi
leaq (%rdx,%rdx,2), %rcx
movq 0x10(%rax,%rcx,8), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax,%rcx,8), %xmm0
movaps %xmm0, (%rsp)
movups (%rax), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x6a5a5
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6a5b0
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x6dd04
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a5c4
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6a5db
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::addFace(VOR_FACE)
void VOR_CELL::addFace(VOR_FACE face) {
  faces.push_back(face);
  vector< pair<int,Point> > nodes = face.getNodes();
  for(unsigned int i = 0; i < nodes.size(); i++){
    pair<int, Point> node = nodes[i];
    addNode(node.first, node.second);
  }
  vector< pair<Point, Point> > edges= face.getEdgeCoords();
  for(unsigned int i = 0; i < edges.size(); i++){
    pair<Point,Point> coord = edges[i];
    addEdge(coord.first, coord.second);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6dc44
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a352
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x6b09a
movl $0x1, %ebp
xorl %ecx, %ecx
shlq $0x5, %rcx
movl (%rax,%rcx), %esi
movq 0x18(%rax,%rcx), %rdx
movq %rdx, 0x70(%rsp)
movups 0x8(%rax,%rcx), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6abe2
movl %ebp, %ecx
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x6b04a
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6a43a
movq 0x30(%rsp), %rdi
cmpq %rdi, 0x38(%rsp)
je 0x6b148
movl $0x1, %ebp
leaq 0x98(%rsp), %r14
xorl %eax, %eax
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movups (%rdi,%rax), %xmm0
movups 0x10(%rdi,%rax), %xmm1
movups 0x20(%rdi,%rax), %xmm2
movaps %xmm2, 0xa0(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movq 0x10(%r14), %rcx
movq %rcx, 0x28(%rsp)
movups (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rdi,%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rdi,%rax), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ade8
movl %ebp, %eax
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
imulq %r15, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x6b0d0
testq %rdi, %rdi
je 0x6b15a
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x6b171
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b19d
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x6b1a0
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x6b1a0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x6b1b7
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::writeVMDFilled(std::basic_fstream<char, std::char_traits<char>>&, int)
void VOR_CELL::writeVMDFilled(fstream &output, int n){
  output << "set faces(" << n << ") {" << "\n"
	 << "{color $faceColors(" << n << ") }" << "\n";
  for(unsigned int i = 0; i < faces.size(); i++){
    faces[i].writeVMDFilled(output);
  }
  output << "}" << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsi), %rbx
leaq 0xe8f3b(%rip), %rsi     # 0x15435d
movl $0xa, %edx
movq %rbx, %rdi
callq 0x44e0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4750
movq %rax, %r13
leaq 0xe8fd5(%rip), %rsi     # 0x154418
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
leaq 0xe81c7(%rip), %r12     # 0x15361e
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x44e0
leaq 0xe8efa(%rip), %rsi     # 0x154368
movl $0x13, %edx
movq %r13, %rdi
callq 0x44e0
movq %r13, %rdi
movl %ebp, %esi
callq 0x4750
movq %rax, %r13
leaq 0xe8eed(%rip), %rsi     # 0x15437c
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x44e0
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x6b4f4
movl $0x1, %ebp
xorl %ecx, %ecx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r14, %rsi
callq 0x6a5e4
movl %ebp, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r12, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x6b4c6
leaq 0xe8e83(%rip), %rsi     # 0x15437e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x44e0
leaq 0xe810f(%rip), %rsi     # 0x15361e
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x44e0
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voronoicell.cc
// Function: VOR_CELL::getVoronoiCells(std::vector<VOR_CELL, std::allocator<VOR_CELL>>*, std::vector<std::vector<VOR_FACE, std::allocator<VOR_FACE>>, std::allocator<std::vector<VOR_FACE, std::allocator<VOR_FACE>>>>, ATOM_NETWORK*, VORONOI_NETWORK*)
void VOR_CELL::getVoronoiCells(vector<VOR_CELL> *cells, vector< vector<VOR_FACE> > faceInfo,
  ATOM_NETWORK *atmnet, VORONOI_NETWORK *vornet){
  cells->clear();
  for(unsigned int i = 0; i < faceInfo.size(); i++){
    VOR_CELL newCell;
    for(unsigned int j = 0; j < faceInfo[i].size(); j++)
      newCell.addFace(faceInfo[i][j]);
    cells->push_back(newCell);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %rbx
movq (%rdi), %rsi
movq %rdi, (%rsp)
callq 0xfad6
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x6bb8b
xorl %r14d, %r14d
leaq 0x40(%rsp), %rbp
leaq 0x10(%rsp), %r12
movq %rbp, %rdi
callq 0x6a896
movq (%rbx), %rcx
movq %r14, 0x8(%rsp)
leaq (%r14,%r14,2), %r15
movq (%rcx,%r15,8), %rax
cmpq %rax, 0x8(%rcx,%r15,8)
je 0x6bb0f
movl $0x1, %r14d
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
addq %rax, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xe868
addq $0x18, %r13
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0xe8f8
movq %rbp, %rdi
movq %r12, %rsi
callq 0x6b012
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x6bac8
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6badf
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movl %r14d, %ecx
movq (%rbx), %rdx
movq (%rdx,%r15,8), %rax
movq 0x8(%rdx,%r15,8), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
incl %r14d
cmpq %rcx, %rdx
ja 0x6ba7f
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x6dcd4
leaq 0x120(%rsp), %rdi
callq 0xf5a0
leaq 0xf0(%rsp), %rdi
callq 0xf618
leaq 0xc0(%rsp), %rdi
callq 0xf668
leaq 0x90(%rsp), %rdi
callq 0xf1b6
leaq 0x60(%rsp), %rdi
callq 0xf6de
movq %rbp, %rdi
callq 0xf5e8
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movq 0x8(%rsp), %r14
incl %r14d
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %r14, %rax
ja 0x6ba54
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6bbbb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6bbcd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x6bbcd
movq %rax, %rbx
jmp 0x6bbcd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe978
leaq 0x40(%rsp), %rdi
callq 0xf55c
movq %rbx, %rdi
callq 0x4780
nop