LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x20, %rsp
leaq 0x30(%rsp), %rbx
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm1
movsd %xmm0, 0x18(%rsp)
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x87406
sqrtsd %xmm0, %xmm0
jmp 0x8740b
callq 0x4350
movsd 0x10(%rbx), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x4380
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x40a0
movsd 0x8(%rsp), %xmm1
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/geometry.cc
// Function: projectPointOnSphere(Point, double, Point)
Point projectPointOnSphere(Point p, double circRad, Point circCenter){
  double deltaX = p[0] - circCenter[0];
  double deltaY = p[1] - circCenter[1];
  double deltaZ = p[2] - circCenter[2];
  double factor = sqrt((circRad*circRad)/(deltaX*deltaX + deltaY*deltaY + deltaZ*deltaZ));
  return Point(factor*deltaX+circCenter[0], factor*deltaY+circCenter[1], factor*deltaZ+circCenter[2]);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x58(%rsp), %xmm7
movsd 0x60(%rsp), %xmm5
movsd 0x40(%rsp), %xmm3
movsd 0x48(%rsp), %xmm4
subsd %xmm7, %xmm3
subsd %xmm5, %xmm4
movsd 0x50(%rsp), %xmm6
movsd 0x68(%rsp), %xmm8
subsd %xmm8, %xmm6
mulsd %xmm0, %xmm0
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movapd %xmm6, %xmm1
mulsd %xmm6, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x874b2
sqrtsd %xmm0, %xmm0
jmp 0x874ff
movsd %xmm3, 0x28(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm5, 0x18(%rsp)
movsd %xmm6, 0x10(%rsp)
movsd %xmm7, 0x8(%rsp)
movsd %xmm8, (%rsp)
callq 0x4350
movsd (%rsp), %xmm8
movsd 0x8(%rsp), %xmm7
movsd 0x10(%rsp), %xmm6
movsd 0x18(%rsp), %xmm5
movsd 0x20(%rsp), %xmm4
movsd 0x28(%rsp), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm7, %xmm3
mulsd %xmm0, %xmm4
addsd %xmm5, %xmm4
mulsd %xmm0, %xmm6
addsd %xmm8, %xmm6
movsd %xmm3, (%rbx)
movsd %xmm4, 0x8(%rbx)
movsd %xmm6, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %ecx, 0xc(%rsp)
movl %edx, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl %r8d, 0x14(%rsp)
testl %r8d, %r8d
jle 0x89664
movq %rsi, %r12
movl 0x14(%rsp), %eax
movq %rax, 0x48(%rsp)
movl 0xc(%rsp), %eax
movq %rax, 0x50(%rsp)
movl 0x10(%rsp), %ebx
movq $0x0, 0x18(%rsp)
leaq 0x20(%rsp), %r13
cmpl $0x0, 0xc(%rsp)
jle 0x89650
movq 0x18(%rsp), %rax
leaq (,%rax,8), %r14
xorl %r15d, %r15d
cmpl $0x0, 0x10(%rsp)
jle 0x89646
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 0x89636
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x8963e
movq %r13, %rdi
callq 0x148c4
incq %rbp
cmpq %rbp, %rbx
jne 0x8960c
incq %r15
cmpq 0x50(%rsp), %r15
jne 0x89603
movq 0x18(%rsp), %rcx
incq %rcx
movq %rcx, 0x18(%rsp)
cmpq 0x48(%rsp), %rcx
jne 0x895ec
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
imull 0x10(%rsp), %eax
imull 0x14(%rsp), %eax
movslq %eax, %rdx
movl $0x8, %esi
movq 0x40(%rsp), %rcx
callq 0x4850
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x896a0
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 0x896c9
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ab2e
movq %r12, %rdi
movq %r15, %rsi
callq 0x897b0
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 0xf32a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x89996
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8976a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x8977c
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 0x897a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x78(%rdi)
jle 0x89995
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsp)
cmpl $0x0, 0x7c(%r14)
jle 0x8996f
xorps %xmm0, %xmm0
cvtsi2sdl (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
cmpl $0x0, 0x80(%r14)
jle 0x8995f
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 0x85982
cmpl $0x0, 0x110(%rbx)
movsd 0xc9cdd(%rip), %xmm0    # 0x153598
jle 0x89934
xorl %r15d, %r15d
xorl %r12d, %r12d
movsd 0xc9ccd(%rip), %xmm1    # 0x153598
movsd %xmm1, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movq 0x2f0(%rbx), %rax
movsd (%rax,%r15), %xmm3
movsd 0x8(%rax,%r15), %xmm4
movsd 0x10(%rax,%r15), %xmm5
movq %rbx, %rdi
callq 0x5394a
movq 0x2f0(%rbx), %rax
subsd 0x30(%rax,%r15), %xmm0
minsd 0x18(%rsp), %xmm0
incq %r12
movslq 0x110(%rbx), %rax
addq $0x98, %r15
movapd %xmm0, %xmm1
cmpq %rax, %r12
jl 0x898cb
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), %rax
cmpq %rax, %rbp
jl 0x89810
incq %r13
movslq 0x7c(%r14), %rax
cmpq %rax, %r13
jl 0x897f2
movq (%rsp), %rdx
incq %rdx
movslq 0x78(%r14), %rax
movq %rdx, (%rsp)
cmpq %rax, %rdx
jl 0x897d6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ab2e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
movsd 0x10(%rsp), %xmm0
callq 0x89e80
testl %r13d, %r13d
je 0x89ddf
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 0xf32a
movzbl %bpl, %ecx
movzbl 0xc(%rsp), %r8d
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x89996
movq 0x38(%rsp), %rdi
jmp 0x89e20
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 0xf32a
movzbl %bpl, %ecx
movzbl 0xc(%rsp), %r8d
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x89996
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x89e31
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x89e43
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 0x89e67
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x89e78
movq (%r13), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ab2e
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 0xf32a
movq %r13, %rdi
movq %r12, %rsi
callq 0x8a1da
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8a13b
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 0xf32a
movzbl %bpl, %ecx
movzbl 0x4(%rsp), %r8d
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x89996
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8a18c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x8a19e
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 0x8a1c2
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8a1d2
movq (%rbx), %rsi
incq %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ab2e
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 0xf32a
movq %r13, %rdi
movq %r12, %rsi
callq 0x8a59a
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8a4fa
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 0xf32a
movzbl %bpl, %ecx
movzbl 0x4(%rsp), %r8d
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x89996
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8a54b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x8a55d
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 0x8a581
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8a591
movq (%rbx), %rsi
incq %rsi
callq 0x4470
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xc(%rsp)
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movslq %esi, %rbx
leaq (,%rbx,8), %rdi
testl %ebx, %ebx
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x4030
movq %rax, 0x88(%r14)
movl %r12d, 0x10(%rsp)
movl %r12d, %eax
movq %rax, 0x18(%rsp)
movl %ebp, %r12d
testl %ebx, %ebx
jle 0x8aee0
movslq %ebp, %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
cmovsq %r15, %rcx
movq %rcx, 0x20(%rsp)
movslq 0xc(%rsp), %rax
leaq (,%rax,8), %r13
testl %eax, %eax
cmovsq %r15, %r13
xorl %r15d, %r15d
movq 0x20(%rsp), %rdi
callq 0x4030
movq 0x88(%r14), %rcx
movq %rax, (%rcx,%r15,8)
testl %ebp, %ebp
jle 0x8aed6
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x4030
movq 0x88(%r14), %rcx
movq (%rcx,%r15,8), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq %rbx, %r12
jne 0x8aeb7
incq %r15
cmpq 0x18(%rsp), %r15
jne 0x8ae9c
movl 0x7c(%r14), %eax
imull 0x78(%r14), %eax
imull 0x80(%r14), %eax
movl %eax, 0x84(%r14)
cmpl $0x0, 0x10(%rsp)
jle 0x8af4c
movl 0xc(%rsp), %r15d
shlq $0x3, %r15
xorl %r13d, %r13d
movl %ebp, 0x14(%rsp)
testl %ebp, %ebp
jle 0x8af3e
movq 0x88(%r14), %rbp
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x8af36
movq (%rbp,%r13,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x4250
incq %rbx
cmpq %rbx, %r12
jne 0x8af1c
incq %r13
cmpq 0x18(%rsp), %r13
movl 0x14(%rsp), %ebp
jne 0x8af0f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59ecb
movl %eax, 0x24(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8c572
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x8c57f
leaq 0x24(%rsp), %rdx
movq %r14, %rdi
callq 0xf7b4
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 0x8c5bf
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x8(%rbx)
jmp 0x8c5cc
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x8e214
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x4, %rdx
je 0x8c62b
sarq $0x2, %rdx
movq 0x8(%rbx), %rdi
movb $0x1, %r9b
movl 0x24(%rsp), %r8d
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x8c635
cmpl (%rax,%rsi,4), %r8d
jne 0x8c60f
addq $-0x4, %rcx
movq %rcx, 0x8(%r14)
addq $-0x20, %rdi
movq %rdi, 0x8(%rbx)
xorl %r9d, %r9d
incq %rsi
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
leaq -0x1(%rdx), %r10
cmpq %rsi, %r10
jbe 0x8c62b
testb $0x1, %r9b
jne 0x8c5f1
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc3069(%rip), %rdi     # 0x14f6a5
xorl %eax, %eax
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5162c
leaq 0xa0(%r14), %r12
movq %r12, %rdi
callq 0x5162c
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 0x12f02
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd %xmm1, 0xa0(%r14)
movups 0x10(%r14), %xmm1
movups %xmm1, 0xa8(%r14)
movsd %xmm0, 0xd0(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x8e489
movq %rax, %r14
movq %r13, %rdi
callq 0xf236
movq %r12, %rdi
callq 0x2f814
movq %rbx, %rdi
callq 0x2f814
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7fac(%rip), %xmm0    # 0x157b78
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
mulsd 0xc7f7a(%rip), %xmm1    # 0x157b58
movsd %xmm1, 0x10(%rsp)
callq 0x927cc
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 0x91d86
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7f56(%rip), %xmm0    # 0x157b78
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
mulsd 0xc7f24(%rip), %xmm1    # 0x157b58
movsd %xmm1, 0x8(%rsp)
callq 0x91340
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 0x927cc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7f04(%rip), %xmm1    # 0x157b78
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0xc7ed2(%rip), %xmm0    # 0x157b58
movsd %xmm0, 0x10(%rsp)
callq 0x91340
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 0x91d86
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7ebd(%rip), %xmm1    # 0x157b80
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x8ecfc
leal 0x6(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x91340
leal 0xa(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x91d86
addl $0xe, %ebx
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x927cc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7e30(%rip), %xmm0    # 0x157b58
movsd 0xc7e58(%rip), %xmm1    # 0x157b88
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0xc7e4e(%rip), %xmm1    # 0x157b90
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x93212
leal 0x8(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x91340
leal 0xc(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x927cc
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 0x91d86
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbf278(%rip), %xmm2    # 0x14f038
mulsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0xc7dc6(%rip), %xmm0    # 0x157b98
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x91340
leal 0x4(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x927cc
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 0x91d86
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7d5c(%rip), %xmm1    # 0x157b90
movsd %xmm1, (%rsp)
movsd 0xc7d47(%rip), %xmm0    # 0x157b88
mulsd %xmm1, %xmm0
movsd 0xc7d53(%rip), %xmm2    # 0x157ba0
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0xc7d49(%rip), %xmm2    # 0x157ba8
mulsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
callq 0x8ecfc
movsd (%rsp), %xmm0
mulsd 0xbf1bd(%rip), %xmm0    # 0x14f038
movsd %xmm0, (%rsp)
leal 0x6(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x93212
leal 0xe(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x93212
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 0x93212
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc6dfe(%rip), %xmm1    # 0x157bb0
movsd %xmm1, 0x20(%rsp)
movsd 0xc6dc8(%rip), %xmm0    # 0x157b88
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0xc6de6(%rip), %xmm0    # 0x157bb8
mulsd %xmm1, %xmm0
movapd %xmm0, %xmm2
movsd %xmm0, 0x8(%rsp)
movsd 0xc6dd8(%rip), %xmm0    # 0x157bc0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0xc6dcf(%rip), %xmm0    # 0x157bc8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm1, %xmm0
callq 0x93212
leal 0x8(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movaps %xmm1, %xmm2
callq 0x93212
leal 0x10(%rbx), %esi
movq %r14, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
callq 0x93212
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 0x93212
leal 0x20(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x93212
leal 0x28(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x93212
leal 0x30(%rbx), %esi
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x91d86
leal 0x34(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x91340
addl $0x38, %ebx
movq %r14, %rdi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl %ebx, %esi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x927cc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5162c
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
cmpl $0x1, %r12d
je 0x912b4
testl %r12d, %r12d
je 0x912ad
cmpl $-0x1, %r12d
jne 0x912c3
movsd (%r14), %xmm0
subsd 0x8(%rsp), %xmm0
jmp 0x912bf
movsd (%r14), %xmm0
jmp 0x912bf
movsd 0x8(%rsp), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%rbx)
cmpl $0x1, %r15d
je 0x912ea
testl %r15d, %r15d
je 0x912e2
cmpl $-0x1, %r15d
jne 0x912fb
movsd 0x8(%r14), %xmm0
subsd 0x10(%rsp), %xmm0
jmp 0x912f6
movsd 0x8(%r14), %xmm0
jmp 0x912f6
movsd 0x10(%rsp), %xmm0
addsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
cmpl $0x1, %ebp
je 0x9131f
testl %ebp, %ebp
je 0x91317
cmpl $-0x1, %ebp
jne 0x91330
movsd 0x10(%r14), %xmm0
subsd 0x18(%rsp), %xmm0
jmp 0x9132b
movsd 0x10(%r14), %xmm0
jmp 0x9132b
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_O1/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 0xc3178(%rip), %rsi     # 0x157c3a
movq %rcx, 0x8(%rsp)
movq %rcx, %rdi
xorl %eax, %eax
callq 0x45f0
movq 0x138(%r14), %rbp
cmpq %rbp, 0x140(%r14)
je 0x94c0c
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 0xf32a
movq %r12, 0x70(%rsp)
movq -0x20(%rbp,%r13), %rsi
movq -0x18(%rbp,%r13), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0xf32a
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 0xc30a6(%rip), %rsi     # 0x157c3f
movb $0x4, %al
callq 0x45f0
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x94bba
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x4470
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x94bd6
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 0x94afa
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 0x94c47
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67cfa
leaq 0x78(%rbx), %rdi
addq $0x60, %r15
movq %r15, %rsi
callq 0x67b72
leaq 0xa8(%rbx), %rdi
movq %r12, %rsi
callq 0x9966c
addq $0x90, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x99742
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbf8b5(%rip), %rsi     # 0x158119
movl $0xa, %edx
movq %rax, %rdi
callq 0x44e0
leaq 0xbf8ac(%rip), %rsi     # 0x158124
movl $0xb, %edx
movq %rbx, %rdi
callq 0x44e0
cmpl $0x0, 0x190(%r14)
jle 0x988cd
xorl %r12d, %r12d
leaq 0xbebed(%rip), %r15     # 0x157486
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 0x98899
leaq 0xbf85c(%rip), %rsi     # 0x158130
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)
cmpl $0x0, 0x190(%r14)
jle 0x989aa
xorl %ebp, %ebp
leaq 0xb6b7d(%rip), %r15     # 0x14f48e
cmpl $0x0, 0x190(%r14)
jle 0x98983
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 0x989b9
movsd (%rax,%r13,8), %xmm1
movapd %xmm1, %xmm0
cmpeqsd 0xba978(%rip), %xmm0    # 0x1532d0
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 0x98929
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xbcb9c(%rip), %rsi     # 0x15552e
callq 0x44e0
incq %rbp
movslq 0x190(%r14), %rax
cmpq %rax, %rbp
jl 0x98911
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb6ce5(%rip), %rdi     # 0x14f6a5
movq %r13, %rsi
xorl %eax, %eax
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/./poreinfo.h
// Function: POREINFO::POREINFO()
POREINFO()
   {
   dim = 0;
   nodes.clear();
   prevIDs.clear();
   nextIDs.clear();
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x85436
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq $0x0, 0x80(%rbx)
cmpq $0x0, 0x48(%rbx)
je 0x9b8bb
movq $0x0, 0x48(%rbx)
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
je 0x9b8c9
movq %rax, 0x60(%rbx)
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x9b8d7
movq %rax, 0x78(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/cluster.cc
// Function: get_first_closer_nonassigned_node(XYZ, ATOM_NETWORK const&, std::vector<DIJKSTRA_NODE, std::allocator<DIJKSTRA_NODE>>, float)
pair<DnIt, DnIt> get_first_closer_nonassigned_node(const XYZ pt, const ATOM_NETWORK& atmnet,
        vector<DIJKSTRA_NODE> nodes, const float cutoff_dist)
{
    DnIt it = nodes.begin(); 
    for (; it != nodes.end(); ++it){
        double period_dist = atmnet.calcDistanceXYZ(it->x, it->y, it->z, pt.x, pt.y, pt.z);
        if (!it->active && period_dist < cutoff_dist) break;
    }
    return make_pair(it, nodes.end());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
cmpq 0x8(%rsi), %r14
je 0x9c121
movq %rdi, %r15
leaq 0x40(%rsp), %rax
movsd (%rax), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x8(%rax), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x18(%r14), %xmm2
movq %r15, %rdi
movsd 0x18(%rsp), %xmm3
movsd 0x10(%rsp), %xmm4
movsd 0x8(%rsp), %xmm5
callq 0x5394a
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9c117
cmpb $0x0, 0x40(%r14)
je 0x9c121
addq $0x48, %r14
cmpq 0x8(%rbx), %r14
jne 0x9c0d9
movq 0x8(%rbx), %rdx
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbb2af(%rip), %xmm0    # 0x158358
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9c132
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9caaf
movq 0x8(%rsp), %rbx
cmpq 0x10(%rsp), %rbx
je 0x9d0ed
movq 0xf9ee9(%rip), %r14     # 0x196fc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85992
addq $0x18, %rbx
cmpq 0x10(%rsp), %rbx
jne 0x9d0d7
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9d104
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x20(%rsp), %rdi
callq 0x68298
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x9d135
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9d135
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq 0x20(%rsp), %rdi
callq 0x68298
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq 0x48(%rdi), %r12
cmpq 0x50(%rdi), %r12
je 0x9dfdf
movq %rsi, %r14
movq %rdi, %r15
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x10(%rsp)
movl $0x1, %ebp
movq 0x2f0(%r14), %rbx
cmpq 0x2f8(%r14), %rbx
je 0x9dfc4
movsd (%r12), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%r12), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r13d, %r13d
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
movq %r14, %rdi
movsd 0x30(%rsp), %xmm3
movsd 0x28(%rsp), %xmm4
movsd 0x20(%rsp), %xmm5
callq 0x5394a
movsd 0x30(%rbx), %xmm1
subsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movzbl %r13b, %r13d
cmoval %ebp, %r13d
ja 0x9dfbe
addq $0x98, %rbx
cmpq 0x2f8(%r14), %rbx
jne 0x9df6d
testb $0x1, %r13b
jne 0x9dfd1
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xe962
addq $0x40, %r12
cmpq 0x50(%r15), %r12
jne 0x9df30
movq 0xf8fda(%rip), %r14     # 0x196fc0
leaq 0xba4c9(%rip), %rsi     # 0x1584b6
movl $0x17, %edx
movq %r14, %rdi
callq 0x44e0
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rsi
subq 0x48(%rax), %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 $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x85982
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 0x85982
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x58(%rbx), %rdx
leaq 0xba234(%rip), %rcx     # 0x1594a7
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 0x9f2aa
movq (%rbp), %rsi
incq %rsi
callq 0x4470
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5725
movq %r13, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/net.cc
// Function: CONNECTION::CONNECTION(int, int, int, int, int, int)
CONNECTION::CONNECTION(int v1_, int v2_, int e1_, int a_, int b_, int c_) {
  v1 = v1_;
  v2 = v2_;
  e1 = e1_;
  e2 = -1; //IMPORTANT! when the CONNECTION is constructed, we don't yet know the edge ID of the other side
  a = a_;
  b = b_;
  c = c_;
}

// Assembly:
movl 0x8(%rsp), %eax
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl $0xffffffff, 0xc(%rdi)  # imm = 0xFFFFFFFF
movl %r8d, 0x10(%rdi)
movl %r9d, 0x14(%rdi)
movl %eax, 0x18(%rdi)
retq