LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/geometry.cc
// Function: pointIsLess(Point, Point)
bool pointIsLess(Point p1, Point p2){
  double tol = 0.0000001;
  if (abs(p1[0] - p2[0]) > tol)
    return p1[0] < p2[0];
  else if (abs(p1[1] - p2[1]) > tol)
    return p1[1] < p2[1];
  else if (abs(p1[2] - p2[2]) > tol)
    return p1[2] < p2[2];
  else
    return false;
}

// Assembly:
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0xc8e33(%rip), %xmm2    # 0x14d0a0
ucomisd 0xce003(%rip), %xmm2    # 0x152278
ja 0x842c9
leaq 0x20(%rsp), %rax
leaq 0x8(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd 0x8(%rax), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0xc8e05(%rip), %xmm2    # 0x14d0a0
ucomisd 0xcdfd5(%rip), %xmm2    # 0x152278
ja 0x842c9
movsd 0x10(%rcx), %xmm0
movsd 0x10(%rax), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd 0xc8de1(%rip), %xmm2    # 0x14d0a0
ucomisd 0xcdfb1(%rip), %xmm2    # 0x152278
jbe 0x842d1
ucomisd %xmm0, %xmm1
seta %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/geometry.cc
// Function: TRIPLET::operator[](int)
int& TRIPLET::operator[](int index){
  if(index < 0 || index > 2){
    cerr << "Error: Invalid index to [] operator for TRIPLET instance" << "\n"
	 << "Exiting..." << "\n";
    exit(1);
  }
  return vals[index];
}

// Assembly:
cmpl $0x3, %esi
jae 0x842f2
movl %esi, %eax
leaq (%rdi,%rax,4), %rax
retq
pushq %rbx
movq 0x110cf6(%rip), %rdi    # 0x194ff0
leaq 0xd0e25(%rip), %rsi     # 0x155126
callq 0x4440
leaq 0xcf311(%rip), %rbx     # 0x15361e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4440
leaq 0xd03ab(%rip), %rsi     # 0x1546ca
movq %rax, %rdi
callq 0x4440
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4440
movl $0x1, %edi
callq 0x72bc
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/geometry.cc
// Function: XYZ::operator[](int)
double& XYZ::operator[](const int index){
     if (index==0)
       return x;
     if (index==1)
       return y;
     if (index==2)
       return z;
     cerr << "Error: Invalid index to [] operator for XYZ instance" << "\n"
	  << "Exiting..." << "\n";
     exit(1);
}

// Assembly:
testl %esi, %esi
je 0x845d0
cmpl $0x2, %esi
je 0x845cc
cmpl $0x1, %esi
jne 0x845d4
addq $0x8, %rdi
jmp 0x845d0
addq $0x10, %rdi
movq %rdi, %rax
retq
pushq %rbx
movq 0x110a14(%rip), %rdi    # 0x194ff0
leaq 0xd0b7c(%rip), %rsi     # 0x15515f
callq 0x4440
leaq 0xcf02f(%rip), %rbx     # 0x15361e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4440
leaq 0xd00c9(%rip), %rsi     # 0x1546ca
movq %rax, %rdi
callq 0x4440
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4440
movl $0x1, %edi
callq 0x72bc
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/geometry.cc
// Function: calcSphereDistance(Point, Point, double)
double calcSphereDistance(Point p1, Point p2, double circRad){
  pair<double,double> coords1 = findLongAndLat(p1);
  pair<double,double> coords2 = findLongAndLat(p2);
  double phi1 = coords1.first; double phi2 = coords2.first;
  double lambda1 = coords1.second; double lambda2 = coords2.second;
  double deltaLambda = lambda1-lambda2;

  double deltaSigma = atan( (sqrt (pow(cos(phi1)*sin(deltaLambda),2.0) +  pow(cos(phi2)*sin(phi1)-sin(phi2)*cos(phi1)*cos(deltaLambda),2))) 
			    / (sin(phi1)*sin(phi2) + cos(phi1)*cos(phi2)*cos(deltaLambda)));
  return circRad*deltaSigma;
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x40(%rsp)
movsd 0x50(%rsp), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x58(%rsp), %xmm1
movsd %xmm1, (%rsp)
movsd 0x60(%rsp), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x4380
movsd %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x40a0
movsd %xmm0, (%rsp)
movsd 0x68(%rsp), %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x70(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x78(%rsp), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x4380
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x40a0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
callq 0x4800
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4100
mulsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4800
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
callq 0x4100
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4100
movsd %xmm0, 0x38(%rsp)
movsd (%rsp), %xmm0
callq 0x4800
movsd %xmm0, 0x30(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4800
movsd 0x30(%rsp), %xmm1
mulsd 0x38(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
addsd 0x10(%rsp), %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x4100
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4100
movsd %xmm0, 0x28(%rsp)
movsd (%rsp), %xmm0
callq 0x4800
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4800
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4800
mulsd (%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x4380
mulsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/geometry.cc
// Function: findLongAndLat(Point)
pair<double,double> findLongAndLat(Point pt){
  double r = sqrt(pt[0]*pt[0] + pt[1]*pt[1]);
  double phi = atan(pt[2]/r);
  double lambda = atan2(pt[1],pt[0]);
  return pair<double,double> (lambda, phi);
}

// Assembly:
subq $0x18, %rsp
movsd 0x20(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm1
movsd 0x30(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x4380
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x40a0
movsd (%rsp), %xmm1
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/grid.cc
// Function: write_distances(_IO_FILE*, double***, int, int, int)
void write_distances(FILE *f, double ***grid, int x_grid_steps, int y_grid_steps, int z_grid_steps) {
	vector <double> visit_friendly_array;
	for(int k=0; k<z_grid_steps; k++) {
		for(int j=0; j<y_grid_steps; j++) {
			for(int i=0; i<x_grid_steps; i++) { //for some reason, the convention is to write out the data in the z,y,x order, i.e., when you read the data, x iterates the fastest, and z the slowest
				visit_friendly_array.push_back(grid[i][j][k]);
			}
		}
	}
	fwrite(&visit_friendly_array[0], sizeof(double), x_grid_steps*y_grid_steps*z_grid_steps, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movl %r8d, 0x1c(%rsp)
movl %r8d, %eax
movq %rax, 0x48(%rsp)
movl %ecx, 0x8(%rsp)
movl %ecx, %eax
movq %rax, 0x50(%rsp)
movl %edx, 0xc(%rsp)
movl %edx, %ebx
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x8(%rsp)
jle 0x876b4
movq 0x10(%rsp), %rax
leaq (,%rax,8), %r14
xorl %r15d, %r15d
cmpl $0x0, 0xc(%rsp)
jle 0x876aa
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rax
movq (%rax,%r15,8), %rdx
addq %r14, %rdx
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x8769a
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x876a2
movq %r13, %rdi
callq 0x1481e
incq %rbp
cmpq %rbp, %rbx
jne 0x87670
incq %r15
cmpq 0x50(%rsp), %r15
jne 0x87667
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
cmpq 0x48(%rsp), %rcx
jne 0x87650
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %eax
imull 0xc(%rsp), %eax
imull 0x1c(%rsp), %eax
movslq %eax, %rdx
movl $0x8, %esi
movq 0x40(%rsp), %rcx
callq 0x4850
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x87704
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8772d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/grid.cc
// Function: generateGaussianGrid(ATOM_NETWORK*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
void generateGaussianGrid(ATOM_NETWORK *atmnet, string cubefilename, bool angstrom_to_bohr, bool useMassFlag){

 GaussianCube cube(atmnet);

 cube.calculateDistanceGrid(atmnet);
 cube.writeGrid(atmnet,cubefilename, angstrom_to_bohr, useMassFlag);
 cube.deinit();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x88b98
movq %r12, %rdi
movq %r15, %rsi
callq 0x87814
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf3ce
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x87a02
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x877ce
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x877e0
callq 0x4570
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8780c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/grid.cc
// Function: GaussianCube::calculateDistanceGrid(ATOM_NETWORK*)
void GaussianCube::calculateDistanceGrid(ATOM_NETWORK *atmnet){

 for(int x=0; x<na; x++)
   for(int y=0; y<nb; y++)
     for(int z=0; z<nc; z++)
       {
       XYZ point(o.x+x*va.x+y*vb.x+z*vc.x,
                 o.y+x*va.y+y*vb.y+z*vc.y,
                 o.z+x*va.z+y*vb.z+z*vc.z);
       double dist=10000;

       for(int i=0;i<atmnet->numAtoms; i++){
           double atmDist = atmnet->calcDistanceXYZ(point.x, point.y, point.z, atmnet->atoms[i].x, atmnet->atoms[i].y, atmnet->atoms[i].z);
           double radius = atmnet->atoms[i].radius;
           atmDist -= radius;
           if(atmDist<dist) dist=atmDist;
           };


       cube[x][y][z]=dist;
       };

}

// Assembly:
movl 0x78(%rdi), %ecx
testl %ecx, %ecx
jle 0x87a01
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x7c(%rdi), %eax
movq $0x0, (%rsp)
testl %eax, %eax
jle 0x879dc
xorps %xmm0, %xmm0
cvtsi2sdl (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x80(%r14), %ecx
xorl %r13d, %r13d
testl %ecx, %ecx
jle 0x879c9
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %ebp, %ebp
movsd 0x18(%r14), %xmm0
movsd 0x8(%rsp), %xmm4
mulsd %xmm4, %xmm0
addsd (%r14), %xmm0
movsd 0x30(%r14), %xmm1
movsd 0x10(%rsp), %xmm5
mulsd %xmm5, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
addsd %xmm0, %xmm1
movsd 0x48(%r14), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%r14), %xmm1
mulsd %xmm4, %xmm1
addsd 0x8(%r14), %xmm1
movsd 0x38(%r14), %xmm3
mulsd %xmm5, %xmm3
addsd %xmm1, %xmm3
movsd 0x50(%r14), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
movsd 0x28(%r14), %xmm3
mulsd %xmm4, %xmm3
addsd 0x10(%r14), %xmm3
movsd 0x40(%r14), %xmm4
mulsd %xmm5, %xmm4
addsd %xmm3, %xmm4
mulsd 0x58(%r14), %xmm2
addsd %xmm4, %xmm2
leaq 0x20(%rsp), %rdi
callq 0x84364
cmpl $0x0, 0x110(%rbx)
movsd 0xc9d07(%rip), %xmm0    # 0x151628
jle 0x8799a
movq 0x2f0(%rbx), %rax
xorl %r15d, %r15d
xorl %r12d, %r12d
movsd 0xc9cf0(%rip), %xmm1    # 0x151628
movsd %xmm1, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd (%rax,%r15), %xmm3
movsd 0x8(%rax,%r15), %xmm4
movsd 0x10(%rax,%r15), %xmm5
movq %rbx, %rdi
callq 0x5364c
movq 0x2f0(%rbx), %rax
subsd 0x30(%rax,%r15), %xmm0
minsd 0x18(%rsp), %xmm0
incq %r12
movslq 0x110(%rbx), %rcx
addq $0x98, %r15
movapd %xmm0, %xmm1
cmpq %rcx, %r12
jl 0x87938
movq 0x88(%r14), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movslq 0x80(%r14), %rcx
cmpq %rcx, %rbp
jl 0x87876
movl 0x7c(%r14), %eax
incq %r13
movslq %eax, %rdx
cmpq %rdx, %r13
jl 0x8785e
movl 0x78(%r14), %ecx
movq (%rsp), %rdi
incq %rdi
movslq %ecx, %rdx
movq %rdi, (%rsp)
cmpq %rdx, %rdi
jl 0x8783e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/grid.cc
// Function: generateGaussianGridWithAccessibilityInfo(ATOM_NETWORK*, ATOM_NETWORK*, bool, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
void generateGaussianGridWithAccessibilityInfo(ATOM_NETWORK *atmnet, ATOM_NETWORK *orgAtomnet, bool highAccuracy, double probe_radius, string cubefilename, bool angstrom_to_bohr, bool useMassFlag){

 GaussianCube cube(atmnet);

 cube.calculateDistanceGridWithAccessibilityInfo(atmnet, orgAtomnet, highAccuracy, probe_radius);

 if(highAccuracy==true) cube.writeGrid(orgAtomnet,cubefilename, angstrom_to_bohr, useMassFlag);
                  else  cube.writeGrid(atmnet,cubefilename, angstrom_to_bohr, useMassFlag);
 cube.deinit();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %ebp
movq %rcx, %r12
movsd %xmm0, 0x10(%rsp)
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r15
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88b98
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
movsd 0x10(%rsp), %xmm0
callq 0x87ee2
testl %r13d, %r13d
je 0x87e41
leaq 0x48(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xf3ce
movzbl %bpl, %ecx
movzbl 0xc(%rsp), %r8d
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x87a02
movq 0x38(%rsp), %rdi
jmp 0x87e82
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xf3ce
movzbl %bpl, %ecx
movzbl 0xc(%rsp), %r8d
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x87a02
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x87e93
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x87ea5
callq 0x4570
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
jmp 0x87ec9
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x87eda
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/grid.cc
// Function: calculateAverageGrid(ATOM_NETWORK*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
void calculateAverageGrid(ATOM_NETWORK *atmnet, std::string inputfilename, std::string cubefilename, bool angstrom_to_bohr, bool useMassFlag){

 GaussianCube cube(atmnet);

 cube.loadHistogramData(inputfilename);
 cube.writeGrid(atmnet,cubefilename, angstrom_to_bohr, useMassFlag);
 cube.deinit();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x88b98
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xf3ce
movq %r13, %rdi
movq %r12, %rsi
callq 0x88244
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x881a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4470
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf3ce
movzbl %bpl, %ecx
movzbl 0x4(%rsp), %r8d
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x87a02
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x881f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x88207
callq 0x4570
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
jmp 0x8822b
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8823b
movq (%rbx), %rsi
incq %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/grid.cc
// Function: calculateAverageGridPerFrame(ATOM_NETWORK*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, bool)
void calculateAverageGridPerFrame(ATOM_NETWORK *atmnet, std::string inputfilename, std::string cubefilename, bool angstrom_to_bohr, bool useMassFlag){

 GaussianCube cube(atmnet);

 cube.loadHistogramDataPerFrame(inputfilename);
 cube.writeGrid(atmnet,cubefilename, angstrom_to_bohr, useMassFlag);
 cube.deinit();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x88b98
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xf3ce
movq %r13, %rdi
movq %r12, %rsi
callq 0x88604
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x88564
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4470
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf3ce
movzbl %bpl, %ecx
movzbl 0x4(%rsp), %r8d
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x87a02
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x885b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x885c7
callq 0x4570
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
jmp 0x885eb
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x885fb
movq (%rbx), %rsi
incq %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/./grid.h
// Function: GaussianCube::allocate(int, int, int)
void allocate(int size_a, int size_b, int size_c)
  {
  cube = new double**[size_a];
  for(int i=0; i<size_a; i++) {
     cube[i] = new double*[size_b];
     for(int j=0; j<size_b; j++) {
        cube[i][j] = new double[size_c];
        }
     }
  gridsize = na * nb *nc;

  // zeroing the grid
  for(int i=0; i<size_a; i++) 
    for(int j=0; j<size_b; j++)
      for(int k=0; k<size_c; k++)
        cube[i][j][k] = 0.0;

  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %eax
movq %rax, 0x10(%rsp)
leaq (,%rax,8), %rdi
testl %esi, %esi
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x4030
movq %rax, 0x88(%rbx)
testl %r14d, %r14d
jle 0x88fd5
movl %r14d, 0xc(%rsp)
movl %r15d, %r14d
leaq (,%r14,8), %rax
testl %r15d, %r15d
cmovsq %r13, %rax
movq %rax, 0x20(%rsp)
movl %ebp, %eax
movq %rax, 0x18(%rsp)
leaq (,%rax,8), %r12
testl %ebp, %ebp
cmovsq %r13, %r12
xorl %r13d, %r13d
movl %r15d, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4030
movq 0x88(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
testl %r15d, %r15d
jle 0x88f61
xorl %r15d, %r15d
movq %r12, %rdi
callq 0x4030
movq 0x88(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x88f42
incq %r13
cmpq 0x10(%rsp), %r13
movl 0x8(%rsp), %r15d
jne 0x88f25
movl 0x7c(%rbx), %eax
imull 0x78(%rbx), %eax
imull 0x80(%rbx), %eax
movl %eax, 0x84(%rbx)
cmpl $0x0, 0xc(%rsp)
jle 0x88fe9
shlq $0x3, 0x18(%rsp)
xorl %r12d, %r12d
testl %r15d, %r15d
jle 0x88fc4
movq 0x88(%rbx), %r13
xorl %r15d, %r15d
testl %ebp, %ebp
jle 0x88fbc
movq (%r13,%r12,8), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq 0x18(%rsp), %rdx
callq 0x4250
incq %r15
cmpq %r15, %r14
jne 0x88fa3
incq %r12
cmpq 0x10(%rsp), %r12
movl 0x8(%rsp), %r15d
jne 0x88f94
jmp 0x88fe9
movl 0x7c(%rbx), %eax
imull 0x78(%rbx), %eax
imull 0x80(%rbx), %eax
movl %eax, 0x84(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/psd.cc
// Function: checkDuplicates(ATOM_NETWORK*, VORONOI_NETWORK*, std::vector<int, std::allocator<int>>&, std::vector<std::pair<Point, double>, std::allocator<std::pair<Point, double>>>&, Point, double)
void checkDuplicates(ATOM_NETWORK *atomnetwork, VORONOI_NETWORK *vornet, vector <int> &listNodeIDs, vector <pair <Point, double> > &nodeAndRadii, Point nodePt, double newRadius){
  int newNodeID = getNodeID(nodePt, atomnetwork, vornet);
	bool unique = true;
  listNodeIDs.push_back(newNodeID);
  nodeAndRadii.push_back(pair <Point, double> (nodePt, newRadius));
  for (int i=0; i<(listNodeIDs.size()-1) && unique; i++){
    if (newNodeID == listNodeIDs.at(i)){
      listNodeIDs.pop_back();
      nodeAndRadii.pop_back();
			unique = false;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x70(%rsp), %r15
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movaps (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x59a2a
movl %eax, 0x24(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8a59a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x8a5a7
leaq 0x24(%rsp), %rdx
movq %r14, %rdi
callq 0xf864
movq 0x10(%r15), %rax
movq %rax, 0x40(%rsp)
movups (%r15), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8a5e7
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%rbx)
jmp 0x8a5f4
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x8c25c
movq (%r14), %rcx
movq 0x8(%r14), %rax
movq %rax, %rdi
subq %rcx, %rdi
cmpq $0x4, %rdi
je 0x8a651
movq %rdi, %rdx
sarq $0x2, %rdx
movq 0x8(%rbx), %r8
movl 0x24(%rsp), %r9d
sarq $0x2, %rdi
leaq -0x1(%rdi), %r10
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x8a65b
movl (%rcx,%rsi,4), %r11d
cmpl %r11d, %r9d
je 0x8a641
incq %rsi
cmpq %rsi, %r10
jbe 0x8a651
movq %rdi, %rdx
cmpl %r11d, %r9d
jne 0x8a621
jmp 0x8a651
addq $-0x4, %rax
movq %rax, 0x8(%r14)
addq $-0x20, %r8
movq %r8, 0x8(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc3093(%rip), %rdi     # 0x14d6f5
xorl %eax, %eax
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::AtomCluster(ATOM, double)
AtomCluster::AtomCluster(ATOM orgatm, double replacementSphereRadii) {

 smallSphereRadius = replacementSphereRadii;

 orgAtom = orgatm;

 atom_vector.clear();

 center.x = orgAtom.x;
 center.y = orgAtom.y;
 center.z = orgAtom.z;
 center.radius = smallSphereRadius;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x51264
leaq 0xa0(%r14), %r12
movq %r12, %rdi
callq 0x51264
leaq 0x138(%r14), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%r14)
movq $0x0, 0x148(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x30(%r15), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x48(%r14), %rdi
leaq 0x40(%r15), %rsi
callq 0x4240
leaq 0x68(%r14), %rdi
leaq 0x60(%r15), %rsi
callq 0x4240
movb 0x90(%r15), %al
movb %al, 0x98(%r14)
movups 0x80(%r15), %xmm0
movups %xmm0, 0x88(%r14)
movq 0x138(%r14), %rsi
movq %r13, %rdi
callq 0x12ea6
movups 0x8(%r14), %xmm0
movups %xmm0, 0xa0(%r14)
movsd 0x18(%r14), %xmm0
movsd %xmm0, 0xb0(%r14)
movsd (%r14), %xmm0
movsd %xmm0, 0xd0(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x8c4d1
movq %rax, %r14
movq %r13, %rdi
callq 0xf2da
movq %r12, %rdi
callq 0x2f5e8
movq %rbx, %rdi
callq 0x2f5e8
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::rotate_xy_cube(double, int)
void AtomCluster::rotate_xy_cube(double shift, int i){

	double axis_shift = shift * sqrt(2.0/3.0);
	double height_shift = shift * (1.0/sqrt(3));

	plusMinus_yz(axis_shift, height_shift, i);
	plusMinus_xz(axis_shift, height_shift, i+4);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm1
movq %rdi, %r14
movsd 0xc8098(%rip), %xmm0    # 0x155cd8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
mulsd 0xc8066(%rip), %xmm1    # 0x155cb8
movsd %xmm1, 0x10(%rsp)
callq 0x90824
addl $0x4, %ebx
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x8fdde
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::rotate_xz_cube(double, int)
void AtomCluster::rotate_xz_cube(double shift, int i){

	double axis_shift = shift * sqrt(2.0/3.0);
	double height_shift = shift * (1.0/sqrt(3));

	plusMinus_xy(axis_shift, height_shift, i);
	plusMinus_yz(height_shift, axis_shift, i+4);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm1
movq %rdi, %r14
movsd 0xc8042(%rip), %xmm0    # 0x155cd8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
mulsd 0xc8010(%rip), %xmm1    # 0x155cb8
movsd %xmm1, 0x8(%rsp)
callq 0x8f3ba
addl $0x4, %ebx
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x90824
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::rotate_yz_cube(double, int)
void AtomCluster::rotate_yz_cube(double shift, int i){
	double axis_shift = shift * sqrt(2.0/3.0);
	double height_shift = shift * (1.0/sqrt(3));

	plusMinus_xy(height_shift, axis_shift, i);
	plusMinus_xz(height_shift, axis_shift, i+4);

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsd 0xc7ff0(%rip), %xmm1    # 0x155cd8
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0xc7fbe(%rip), %xmm0    # 0x155cb8
movsd %xmm0, 0x10(%rsp)
callq 0x8f3ba
addl $0x4, %ebx
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x8fdde
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::translate_axes(double, int)
void AtomCluster::translate_axes(double shift, int i){
	double axis_shift = shift;
	double quad_shift = 0.5 * sqrt(2) * shift;

	plusMinus_axes(axis_shift, i);
	plusMinus_xy(quad_shift, quad_shift, i+6);
	plusMinus_xz(quad_shift, quad_shift, i+10);
	plusMinus_yz(quad_shift, quad_shift, i+14);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movsd 0xc7fa9(%rip), %xmm1    # 0x155ce0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x8cd44
leal 0x6(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x8f3ba
leal 0xa(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x8fdde
addl $0xe, %ebx
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x90824
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::translate_dodecahedron(double, int)
void AtomCluster::translate_dodecahedron(double shift, int i){
	double scale = 1/(sqrt(3));
	double golden_ratio = (1+sqrt(5))/2.0;
	double inverse_ratio = 1.0/golden_ratio;
	double scaled_shift = scale * shift;
	double scaled_ratio = golden_ratio * scaled_shift;
	double scaled_inverse = inverse_ratio * scaled_shift;

	double half_ratio = 0.5*shift * (1+sqrt(5))/2.0;
	double half_shift = 0.5*shift;

	plusMinus_all(scaled_shift, scaled_shift, scaled_shift, i);
	plusMinus_xy(scaled_inverse, scaled_ratio, i+8);
	plusMinus_yz(scaled_inverse, scaled_ratio, i+12);
	plusMinus_xz(scaled_ratio, scaled_inverse, i+16);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
mulsd 0xc7f1c(%rip), %xmm0    # 0x155cb8
movsd 0xc7f44(%rip), %xmm1    # 0x155ce8
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0xc7f3a(%rip), %xmm1    # 0x155cf0
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x91254
leal 0x8(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x8f3ba
leal 0xc(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x90824
addl $0x10, %ebx
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x8fdde
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::rotate_icosahedron(double, int)
void AtomCluster::rotate_icosahedron(double shift, int i){
	double half_ratio = 0.5*shift * (1+sqrt(5))/2.0;
	double half_shift = 0.5*shift;

	plusMinus_xy(half_ratio, half_shift, i);
	plusMinus_yz(half_ratio, half_shift, i+4);
	plusMinus_xz(half_shift, half_ratio, i+8);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm1
movq %rdi, %r14
movsd 0xbf204(%rip), %xmm2    # 0x14d038
mulsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0xc7eb2(%rip), %xmm0    # 0x155cf8
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x8f3ba
leal 0x4(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x90824
addl $0x8, %ebx
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x8fdde
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::translate_icosidodecahedron(double, int)
void AtomCluster::translate_icosidodecahedron(double shift, int i){
	double golden_ratio = (1+sqrt(5))/2.0;
	double half_ratio = golden_ratio * 0.5;
	double oth_ratio = (1+golden_ratio)*0.5;

	double scale = 1.0/golden_ratio;
	double scaled_shift = shift * scale;
	double scaled_ratio = golden_ratio * scaled_shift;
	double scaled_half = half_ratio * scaled_shift;
	double scaled_oth = oth_ratio * scaled_shift;

	plusMinus_axes(scaled_ratio, i);
	plusMinus_all(0.5 * scaled_shift, scaled_half, scaled_oth, i+6);
	plusMinus_all(scaled_half, scaled_oth, 0.5 * scaled_shift, i+14);
	plusMinus_all(scaled_oth, 0.5 * scaled_shift, scaled_half, i+22);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm1
movq %rdi, %r14
mulsd 0xc7e48(%rip), %xmm1    # 0x155cf0
movsd %xmm1, (%rsp)
movsd 0xc7e33(%rip), %xmm0    # 0x155ce8
mulsd %xmm1, %xmm0
movsd 0xc7e3f(%rip), %xmm2    # 0x155d00
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0xc7e35(%rip), %xmm2    # 0x155d08
mulsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
callq 0x8cd44
movsd (%rsp), %xmm0
mulsd 0xbf149(%rip), %xmm0    # 0x14d038
movsd %xmm0, (%rsp)
leal 0x6(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x91254
leal 0xe(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x91254
addl $0x16, %ebx
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movl %ebx, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x91254
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::translate_rhombi(double, int)
void AtomCluster::translate_rhombi(double shift, int i){
	double golden_ratio = (1+sqrt(5))/2.0;
	double ratio_square = golden_ratio * golden_ratio;
	double ratio_cube = ratio_square * golden_ratio;
	double length = sqrt(2+(ratio_cube*ratio_cube));
	double scale = 1.0/length;

	double scaled_shift = shift * scale;
	double scaled_ratio = scaled_shift * golden_ratio;
	double scaled_cube = scaled_shift * ratio_cube;
	double scaled_square = scaled_shift * ratio_square;
	double scaled_plus = scaled_shift * (2.0 + golden_ratio);

	plusMinus_all(scaled_shift, scaled_shift, scaled_cube, i);
	plusMinus_all(scaled_cube, scaled_shift, scaled_shift, i+8);
	plusMinus_all(scaled_shift, scaled_cube, scaled_shift, i+16);
	plusMinus_all(scaled_square, scaled_ratio, 2.0*scaled_ratio, i+24);
	plusMinus_all(2.0*scaled_ratio, scaled_square, scaled_ratio, i+32);
	plusMinus_all(scaled_ratio, 2.0*scaled_ratio, scaled_square, i+40);
	plusMinus_xz(scaled_plus, scaled_square, i+48);
	plusMinus_xy(scaled_square, scaled_plus, i+52);
	plusMinus_yz(scaled_square, scaled_plus, i+56);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm1
movq %rdi, %r14
mulsd 0xc6eea(%rip), %xmm1    # 0x155d10
movsd %xmm1, 0x20(%rsp)
movsd 0xc6eb4(%rip), %xmm0    # 0x155ce8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0xc6ed2(%rip), %xmm0    # 0x155d18
mulsd %xmm1, %xmm0
movapd %xmm0, %xmm2
movsd %xmm0, 0x8(%rsp)
movsd 0xc6ec4(%rip), %xmm0    # 0x155d20
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0xc6ebb(%rip), %xmm0    # 0x155d28
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm1, %xmm0
callq 0x91254
leal 0x8(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movaps %xmm1, %xmm2
callq 0x91254
leal 0x10(%rbx), %esi
movq %r14, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
callq 0x91254
movsd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
leal 0x18(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x91254
leal 0x20(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x91254
leal 0x28(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x91254
leal 0x30(%rbx), %esi
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x8fdde
leal 0x34(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8f3ba
addl $0x38, %ebx
movq %r14, %rdi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl %ebx, %esi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x90824
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::translate_sphere(ATOM, double, double, double, int, int, int)
ATOM AtomCluster::translate_sphere(ATOM sphere, double x_step, double y_step, double z_step, int x_sign, int y_sign, int z_sign){
	ATOM new_sphere_pos; new_sphere_pos.radius = sphere.radius;
//sign: -1 = negative, 0 = no change, 1 = positive
	if (x_sign == -1) new_sphere_pos.x = sphere.x - x_step;
	else if (x_sign == 1) new_sphere_pos.x = sphere.x + x_step;
	else if (x_sign == 0) new_sphere_pos.x = sphere.x;

	if (y_sign == -1) new_sphere_pos.y = sphere.y - y_step;
	else if (y_sign == 1) new_sphere_pos.y = sphere.y + y_step;
	else if (y_sign == 0) new_sphere_pos.y = sphere.y;

	if (z_sign == -1) new_sphere_pos.z = sphere.z - z_step;
	else if (z_sign == 1) new_sphere_pos.z = sphere.z + z_step;
	else if (z_sign == 0) new_sphere_pos.z = sphere.z;

	return new_sphere_pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
callq 0x51264
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
cmpl $0x1, %r12d
je 0x8f32e
testl %r12d, %r12d
je 0x8f327
cmpl $-0x1, %r12d
jne 0x8f33d
movsd (%r14), %xmm0
subsd 0x8(%rsp), %xmm0
jmp 0x8f339
movsd (%r14), %xmm0
jmp 0x8f339
movsd 0x8(%rsp), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%rbx)
cmpl $0x1, %r15d
je 0x8f364
testl %r15d, %r15d
je 0x8f35c
cmpl $-0x1, %r15d
jne 0x8f375
movsd 0x8(%r14), %xmm0
subsd 0x10(%rsp), %xmm0
jmp 0x8f370
movsd 0x8(%r14), %xmm0
jmp 0x8f370
movsd 0x10(%rsp), %xmm0
addsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
cmpl $0x1, %ebp
je 0x8f399
testl %ebp, %ebp
je 0x8f391
cmpl $-0x1, %ebp
jne 0x8f3aa
movsd 0x10(%r14), %xmm0
subsd 0x18(%rsp), %xmm0
jmp 0x8f3a5
movsd 0x10(%r14), %xmm0
jmp 0x8f3a5
movsd 0x18(%rsp), %xmm0
addsd 0x10(%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::print_xyz_coords(_IO_FILE*)
void AtomCluster::print_xyz_coords(FILE *output){
	int size = atom_vector.size();
	fprintf(output, "%d\n\n", size);
	for (int a = 0; a<atom_vector.size(); a++){
		ATOM atom = atom_vector.at(a);
		fprintf(output, "H %f %f %f %f\n", atom.x, atom.y, atom.z, atom.radius);
	}
	fclose(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rcx
movq %rdi, %r14
movq 0x140(%rdi), %rax
subq 0x138(%rdi), %rax
shrq $0x3, %rax
imull $0x286bca1b, %eax, %edx # imm = 0x286BCA1B
leaq 0xc333c(%rip), %rsi     # 0x155d9a
movq %rcx, 0x8(%rsp)
movq %rcx, %rdi
xorl %eax, %eax
callq 0x45f0
movq 0x138(%r14), %rbp
cmpq %rbp, 0x140(%r14)
je 0x92ba8
leaq 0x50(%rsp), %r15
leaq 0x80(%rsp), %r12
movl $0x80, %r13d
xorl %ebx, %ebx
movups -0x80(%rbp,%r13), %xmm0
movups -0x70(%rbp,%r13), %xmm1
movups -0x60(%rbp,%r13), %xmm2
movups -0x50(%rbp,%r13), %xmm3
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq -0x40(%rbp,%r13), %rsi
movq -0x38(%rbp,%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xf3ce
movq %r12, 0x70(%rsp)
movq -0x20(%rbp,%r13), %rsi
movq -0x18(%rbp,%r13), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0xf3ce
movb 0x10(%rbp,%r13), %al
movb %al, 0x50(%r15)
movups (%rbp,%r13), %xmm0
movups %xmm0, 0x40(%r15)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x40(%rsp), %xmm3
movq 0x8(%rsp), %rdi
leaq 0xc326a(%rip), %rsi     # 0x155d9f
movb $0x4, %al
callq 0x45f0
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x92b56
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x92b72
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x4470
incq %rbx
movq 0x138(%r14), %rbp
movq 0x140(%r14), %rax
subq %rbp, %rax
sarq $0x3, %rax
movabsq $-0x79435e50d79435e5, %rcx # imm = 0x86BCA1AF286BCA1B
imulq %rcx, %rax
addq $0x98, %r13
cmpq %rbx, %rax
ja 0x92a96
movq 0x8(%rsp), %rdi
callq 0x4450
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x92be3
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkaccessibility.cc
// Function: AccessibilityClassNINF::AccessibilityClassSetup(ATOM_NETWORK*, ATOM_NETWORK*, bool, voro::container_periodic_poly*, VORONOI_NETWORK*, std::vector<BASIC_VCELL, std::allocator<BASIC_VCELL>>*, std::vector<VOR_CELL, std::allocator<VOR_CELL>>*)
void AccessibilityClassNINF::AccessibilityClassSetup(ATOM_NETWORK *atmnet, ATOM_NETWORK *orgatmnet, bool highAccuracy,
                                                    voro::container_periodic_poly *p,VORONOI_NETWORK *v, std::vector<BASIC_VCELL> *bvc, std::vector<VOR_CELL> *vc){
 highAccuracyFlag = highAccuracy;
 if(highAccuracy)
   {
   analyzedAtomNet = atmnet;
   orgAtomNet = orgatmnet;
   }else{
   analyzedAtomNet = orgatmnet;
   orgAtomNet = orgatmnet;
   };

 /* Making a local copy of the Voronoi Network (because it will be modified during the channel detection */
 new_rad_con = p;
 vornet = *v;
 advCells = *vc;
 vorcells = *bvc;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %rdi, %rbx
movq 0x30(%rsp), %r14
movq 0x38(%rsp), %r12
movb %cl, 0x10(%rdi)
testl %ecx, %ecx
cmoveq %rdx, %rsi
movq %rsi, 0x8(%rdi)
movq %rdx, (%rdi)
movq %r8, 0x140(%rdi)
addq $0x18, %rdi
movl $0x9, %ecx
movq %r9, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rbx), %rdi
leaq 0x48(%r9), %rsi
callq 0x673a2
leaq 0x78(%rbx), %rdi
addq $0x60, %r15
movq %r15, %rsi
callq 0x67218
leaq 0xa8(%rbx), %rdi
movq %r12, %rsi
callq 0x9755a
addq $0x90, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x97630
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/networkaccessibility.cc
// Function: AccessibilityClassNINF::reportPLD(std::ostream&)
void AccessibilityClassNINF::reportPLD(ostream &output){ 

 output <<  n_segments << " segments\n";

 output << "segmentDi: ";
 for(int i=0; i < n_segments; i++) output << segmentDiFinal[i] << " ";

 output << "\n====Pairwise===PLDs===between===segments==============\n";
 output.setf(ios::fixed);
 output.precision(3);
 for(int i=0; i < n_segments; i++)
    {
    for(int j=0; j < n_segments; j++)
      {
      double pld;
      if(PLDtable[i].at(j)==-1) pld = 0.000; else pld = PLDtable[i].at(j);
      output <<  pld << "   ";
      };
    output << "\n";
    };

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x190(%rdi), %esi
movq %rbx, %rdi
callq 0x4750
leaq 0xbfb0d(%rip), %rsi     # 0x156279
movl $0xa, %edx
movq %rax, %rdi
callq 0x44e0
leaq 0xbfb04(%rip), %rsi     # 0x156284
movl $0xb, %edx
movq %rbx, %rdi
callq 0x44e0
cmpl $0x0, 0x190(%r14)
jle 0x967d5
xorl %r12d, %r12d
leaq 0xbee35(%rip), %r15     # 0x1555d6
movq 0x1f8(%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x46b0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
incq %r12
movslq 0x190(%r14), %rax
cmpq %rax, %r12
jl 0x967a1
leaq 0xbfab4(%rip), %rsi     # 0x156290
movl $0x38, %edx
movq %rbx, %rdi
callq 0x44e0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x3, 0x8(%rbx,%rax)
movl 0x190(%r14), %eax
testl %eax, %eax
jle 0x968ad
xorl %ebp, %ebp
leaq 0xb6cc4(%rip), %r15     # 0x14d4de
testl %eax, %eax
jle 0x96886
leaq (,%rbp,2), %r12
addq %rbp, %r12
xorl %r13d, %r13d
movq 0x228(%r14), %rcx
movq (%rcx,%r12,8), %rax
movq 0x8(%rcx,%r12,8), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
jbe 0x968bc
movsd (%rax,%r13,8), %xmm1
movapd %xmm1, %xmm0
cmpeqsd 0xbab05(%rip), %xmm0    # 0x151360
andnpd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x46b0
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x44e0
incq %r13
movslq 0x190(%r14), %rax
cmpq %rax, %r13
jl 0x9682c
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xbcd89(%rip), %rsi     # 0x15361e
callq 0x44e0
incq %rbp
movslq 0x190(%r14), %rax
cmpq %rax, %rbp
jl 0x9681a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb6e32(%rip), %rdi     # 0x14d6f5
movq %r13, %rsi
xorl %eax, %eax
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/cluster.cc
// Function: simplify_ha_vornet(ATOM_NETWORK*)
void simplify_ha_vornet(ATOM_NETWORK* atmnet)
{
    vector <vector<XYZ> > clusters =  cluster_partition(atmnet, 0.2);
    vector<XYZ> reduced_clusters = cluster_aggregate(clusters, atmnet);
    
    vector<XYZ>::iterator it = reduced_clusters.begin();
    for (; it != reduced_clusters.end(); ++it) {
        it->print(cout);
        ;
    }
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movss 0xbb025(%rip), %xmm0    # 0x156518
movq %r14, %rdi
movq %rbx, %rsi
callq 0x99fba
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9aef9
movq 0x8(%rsp), %rbx
cmpq 0x10(%rsp), %rbx
je 0x9b53c
movq 0xf9a9f(%rip), %r14     # 0x194fc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x84374
addq $0x18, %rbx
cmpq 0x10(%rsp), %rbx
jne 0x9b521
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x9b551
movq 0x18(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x4470
leaq 0x20(%rsp), %rdi
callq 0x67966
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x9b582
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9b582
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x20(%rsp), %rdi
callq 0x67966
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/cluster.cc
// Function: ha_prune_within_atom(VORONOI_NETWORK*, ATOM_NETWORK*, float, VORONOI_NETWORK*)
void ha_prune_within_atom(VORONOI_NETWORK* ha_vornet, ATOM_NETWORK* atmnet, 
                      float cutoff, VORONOI_NETWORK* red_vornet)
{
    for (VnIt vh_it = ha_vornet->nodes.begin(); vh_it != ha_vornet->nodes.end(); ++vh_it){
        double x2 = vh_it->x;
        double y2 = vh_it->y;
        double z2 = vh_it->z;
        bool near_flag = false;
        for (AtmIt ait = atmnet->atoms.begin(); ait != atmnet->atoms.end(); ++ait) {
            double x1 = ait->x;
            double y1 = ait->y;
            double z1 = ait->z;
            double dist = atmnet->calcDistanceXYZ(x1,y1,z1,x2,y2,z2); 
            if (dist < ait->radius-cutoff) {
                near_flag = true;
                break;
            }
        }
        if (not near_flag) 
            red_vornet->nodes.push_back(*vh_it);
    }

    cout << "size of reduced vornet " << red_vornet->nodes.size() << endl;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq 0x48(%rdi), %r12
cmpq 0x50(%rdi), %r12
je 0x9c47d
movq %rsi, %r14
movq %rdi, %r15
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rbx), %r13
movq 0x2f0(%r14), %rbp
cmpq 0x2f8(%r14), %rbp
je 0x9c464
movsd (%r12), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%r12), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rbp), %xmm0
movsd 0x8(%rbp), %xmm1
movsd 0x10(%rbp), %xmm2
movq %r14, %rdi
movsd 0x20(%rsp), %xmm3
movsd 0x18(%rsp), %xmm4
movsd 0x10(%rsp), %xmm5
callq 0x5364c
movsd 0x30(%rbp), %xmm1
subsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x9c46f
addq $0x98, %rbp
cmpq 0x2f8(%r14), %rbp
jne 0x9c41a
movq %r13, %rdi
movq %r12, %rsi
callq 0xe9d4
addq $0x40, %r12
cmpq 0x50(%r15), %r12
jne 0x9c3e4
movq 0xf8b3c(%rip), %r14     # 0x194fc0
leaq 0xba1eb(%rip), %rsi     # 0x156676
movl $0x17, %edx
movq %r14, %rdi
callq 0x44e0
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x6, %rsi
movq %r14, %rdi
callq 0x42b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4420
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/net.cc
// Function: VERTEX::VERTEX(double, double, double)
VERTEX::VERTEX(double a0, double b0, double c0){
  expected_edges = 0;
  XYZ abc1(a0,b0,c0);
  abc = abc1;
  name = "V";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x84364
leaq 0x20(%rbx), %r14
leaq 0x38(%rbx), %r15
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rbp, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
movl $0x0, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x84364
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x58(%rbx), %rdx
leaq 0xb9fe0(%rip), %rcx     # 0x157667
movl $0x1, %r8d
movq %r12, %rdi
xorl %esi, %esi
callq 0x4670
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x9d6be
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5826
movq %r13, %rdi
callq 0x4780