LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movslq 0x78(%r14), %rax
cmpq %rax, %r13
jge 0x66fbe
cvtsi2sd %r13d, %xmm0
movsd %xmm0, (%rsp)
xorl %ecx, %ecx
movslq 0x7c(%r14), %rax
cmpq %rax, %rcx
jge 0x66fb6
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
movq %rcx, 0x10(%rsp)
movslq 0x80(%r14), %rax
cmpq %rax, %rbp
jge 0x66fae
movsd 0x18(%r14), %xmm0
movsd (%rsp), %xmm4
mulsd %xmm4, %xmm0
addsd (%r14), %xmm0
movsd 0x30(%r14), %xmm1
movsd 0x8(%rsp), %xmm5
mulsd %xmm5, %xmm1
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 0x6402e
xorl %r15d, %r15d
xorl %r12d, %r12d
movsd 0x9967a(%rip), %xmm0    # 0x1005a0
movslq 0x110(%rbx), %rax
cmpq %rax, %r12
jge 0x66f8d
movsd %xmm0, 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 0x3f636
movq 0x2f0(%rbx), %rax
subsd 0x30(%rax,%r15), %xmm0
minsd 0x18(%rsp), %xmm0
incq %r12
addq $0x98, %r15
jmp 0x66f26
movq 0x88(%r14), %rax
movq (%rax,%r13,8), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x66e70
incq %rcx
jmp 0x66e52
incq %r13
jmp 0x66e39
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movsd %xmm0, 0x10(%rsp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x67e56
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movsd 0x10(%rsp), %xmm0
callq 0x673f6
testl %r14d, %r14d
je 0x67389
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x45d0
movzbl %bpl, %ecx
movzbl 0xc(%rsp), %r8d
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x66fce
jmp 0x673b3
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x45d0
movzbl %bpl, %ecx
movzbl 0xc(%rsp), %r8d
leaq 0x58(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x66fce
movq %r14, %rdi
callq 0x4210
leaq 0x58(%rsp), %rdi
callq 0x6811e
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x673e9
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x67e56
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x45d0
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x676c8
leaq 0x28(%rsp), %rdi
callq 0x4210
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45d0
movzbl %r15b, %ecx
movzbl 0x4(%rsp), %r8d
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x66fce
leaq 0x8(%rsp), %rdi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x6811e
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x676b4
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x67e56
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x45d0
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x679ae
leaq 0x28(%rsp), %rdi
callq 0x4210
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45d0
movzbl %r15b, %ecx
movzbl 0x4(%rsp), %r8d
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x66fce
leaq 0x8(%rsp), %rdi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x6811e
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6799a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movq %rdi, %r12
movl %esi, %edi
shlq $0x3, %rdi
xorl %r15d, %r15d
testl %esi, %esi
pushq $-0x1
popq %r13
cmovsq %r13, %rdi
cmovlel %r15d, %esi
movq %rsi, 0x10(%rsp)
callq 0x4030
movq %rax, 0x88(%r12)
movl %r14d, %eax
movl %ebx, %ebp
shlq $0x3, %rax
shlq $0x3, %rbp
testl %ebx, %ebx
cmovsq %r13, %rbp
testl %r14d, %r14d
cmovsq %r13, %rax
movq %rax, 0x8(%rsp)
cmovlel %r15d, %r14d
movq 0x10(%rsp), %r8
cmpq %r8, %r15
je 0x681dc
movq 0x8(%rsp), %rdi
callq 0x4030
movq 0x88(%r12), %rcx
movq %rax, (%rcx,%r15,8)
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x681d7
movq %rbp, %rdi
callq 0x4030
movq 0x88(%r12), %rcx
movq (%rcx,%r15,8), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x681b5
incq %r15
jmp 0x68192
movl 0x7c(%r12), %eax
imull 0x78(%r12), %eax
imull 0x80(%r12), %eax
movl %eax, 0x84(%r12)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %r8, %rax
je 0x68236
xorl %ecx, %ecx
cmpq %r14, %rcx
je 0x68231
movq 0x88(%r12), %rdx
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x6822c
movq (%rdx,%rax,8), %rdi
movq (%rdi,%rcx,8), %rdi
andq $0x0, (%rdi,%rsi,8)
incq %rsi
jmp 0x68215
incq %rcx
jmp 0x68206
incq %rax
jmp 0x681ff
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x43463
leaq 0x24(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x9434
movq 0x90(%rsp), %rax
leaq 0x30(%rsp), %rsi
movq %rax, 0x10(%rsi)
movaps 0x80(%rsp), %xmm0
movaps %xmm0, (%rsi)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsi)
movq %rbx, %rdi
callq 0x6aa2a
movb $0x1, %al
xorl %r15d, %r15d
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x2, %rcx
decq %rcx
cmpq %r15, %rcx
jbe 0x691ac
testb $0x1, %al
je 0x691ac
movl 0x24(%rsp), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0xac00
cmpl (%rax), %ebp
setne %al
jne 0x691a7
addq $-0x4, 0x8(%r14)
addq $-0x20, 0x8(%rbx)
incq %r15
jmp 0x69170
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container_prd.hh
// Function: bool voro::container_periodic_poly::compute_ghost_cell<voro::voronoicell>(voro::voronoicell&, double, double, double, double)
inline bool compute_ghost_cell(v_cell &c,double x,double y,double z,double r) {
			int ijk;
			put_locate_block(ijk,x,y,z);
			double *pp=p[ijk]+4*co[ijk]++,tm=max_radius;
			*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
			if(r>max_radius) max_radius=r;
			bool q=compute_cell(c,ijk,co[ijk]-1);
			co[ijk]--;max_radius=tm;
			return q;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm3, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movsd %xmm0, (%r15)
leaq 0x28(%rsp), %r12
movsd %xmm1, (%r12)
leaq 0x20(%rsp), %r13
movsd %xmm2, (%r13)
leaq 0xc(%rsp), %rbp
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0xf88de
movsd 0x10(%rsp), %xmm1
movslq (%rbp), %rcx
movq 0x1a8(%rbx), %rdx
movq 0x1b0(%rbx), %rax
movq (%rdx,%rcx,8), %rdx
movslq (%rax,%rcx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rax,%rcx,4)
shlq $0x5, %rsi
movsd 0x1d8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, (%rdx,%rsi)
movsd (%r12), %xmm0
movsd %xmm0, 0x8(%rdx,%rsi)
movsd (%r13), %xmm0
movsd %xmm0, 0x10(%rdx,%rsi)
movsd %xmm1, 0x18(%rdx,%rsi)
ucomisd 0x1d8(%rbx), %xmm1
jbe 0x6a94e
movsd %xmm1, 0x1d8(%rbx)
movslq 0xc(%rsp), %rdx
movl (%rax,%rdx,4), %ecx
decl %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6a9e6
movq 0x1b0(%rbx), %rcx
movslq 0xc(%rsp), %rdx
decl (%rcx,%rdx,4)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x1d8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x3dc5a
leaq 0xa0(%r14), %r15
movq %r15, %rdi
callq 0x3dc5a
leaq 0x138(%r14), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%r14)
andq $0x0, 0x148(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x245be
movq %r13, %rdi
callq 0xa732
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
movq %r13, %rdi
callq 0xb110
movq %r15, %rdi
callq 0xa808
jmp 0x6ac9c
movq %rax, %r14
movq %rbx, %rdi
callq 0xa808
movq %r14, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/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 0x993a8(%rip), %xmm0    # 0x104c18
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
mulsd 0x9938e(%rip), %xmm1    # 0x104c10
movsd %xmm1, 0x10(%rsp)
callq 0x6cdae
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 0x6ca74
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x99352(%rip), %xmm0    # 0x104c18
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
mulsd 0x99338(%rip), %xmm1    # 0x104c10
movsd %xmm1, 0x8(%rsp)
callq 0x6c752
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 0x6cdae
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x99300(%rip), %xmm1    # 0x104c18
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x992e6(%rip), %xmm0    # 0x104c10
movsd %xmm0, 0x10(%rsp)
callq 0x6c752
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 0x6ca74
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x992b9(%rip), %xmm1    # 0x104c20
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x6b406
leal 0x6(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x6c752
leal 0xa(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x6ca74
addl $0xe, %ebx
movq %r14, %rdi
movsd (%rsp), %xmm0
movaps %xmm0, %xmm1
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6cdae
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x99244(%rip), %xmm0    # 0x104c10
movsd 0x99254(%rip), %xmm1    # 0x104c28
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x9924a(%rip), %xmm1    # 0x104c30
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x6d0d0
leal 0x8(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x6c752
leal 0xc(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x6cdae
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 0x6ca74
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x905d4(%rip), %xmm2    # 0xfc038
mulsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x991c2(%rip), %xmm0    # 0x104c38
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x6c752
leal 0x4(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x6cdae
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 0x6ca74
// File: /workspace/github_cpp_makefile_star2_O2/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 0x99158(%rip), %xmm1    # 0x104c30
movsd %xmm1, (%rsp)
movsd 0x99143(%rip), %xmm0    # 0x104c28
mulsd %xmm1, %xmm0
movsd 0x9914f(%rip), %xmm2    # 0x104c40
mulsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x99145(%rip), %xmm2    # 0x104c48
mulsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
callq 0x6b406
movsd (%rsp), %xmm0
mulsd 0x90519(%rip), %xmm0    # 0xfc038
movsd %xmm0, (%rsp)
leal 0x6(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x6d0d0
leal 0xe(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x6d0d0
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 0x6d0d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x988f6(%rip), %xmm1    # 0x104c50
movsd %xmm1, 0x20(%rsp)
movsd 0x988c0(%rip), %xmm0    # 0x104c28
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x988de(%rip), %xmm0    # 0x104c58
mulsd %xmm1, %xmm0
movapd %xmm0, %xmm2
movsd %xmm0, 0x8(%rsp)
movsd 0x988d0(%rip), %xmm0    # 0x104c60
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x988c7(%rip), %xmm0    # 0x104c68
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm1, %xmm0
callq 0x6d0d0
leal 0x8(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movaps %xmm1, %xmm2
callq 0x6d0d0
leal 0x10(%rbx), %esi
movq %r14, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
callq 0x6d0d0
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 0x6d0d0
leal 0x20(%rbx), %esi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x6d0d0
leal 0x28(%rbx), %esi
movq %r14, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x6d0d0
leal 0x30(%rbx), %esi
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x6ca74
leal 0x34(%rbx), %esi
movq %r14, %rdi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x6c752
addl $0x38, %ebx
movq %r14, %rdi
movsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl %ebx, %esi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x6cdae
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/sphere_approx.cc
// Function: AtomCluster::sphere_spiral(double, double)
void AtomCluster::sphere_spiral(double n, double shift){
        double golden_angle = PI * (3.0-sqrt(5));

        for (int i = 0; i<n; i++){
                double theta = golden_angle * i;
                double z_shift = (1-(1/n))*(1-((2*i)/(n-1)));
                double z_sq = z_shift * z_shift;
                double radius = sqrt(1-z_sq);
                double x_shift = radius * cos(theta);
                double y_shift = radius * sin(theta);

                ATOM new_sphere = translate_sphere(center, shift * x_shift, shift * y_shift, shift * z_shift, 1, 1, 1);
                atom_vector.push_back(new_sphere);
        }
        atom_vector.push_back(center);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movsd 0x93e3c(%rip), %xmm2    # 0x1002e8
movapd %xmm2, %xmm3
divsd %xmm0, %xmm3
addsd 0x8fb9c(%rip), %xmm3    # 0xfc058
movsd %xmm3, 0x10(%rsp)
movsd %xmm0, 0x20(%rsp)
addsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
leaq 0xa0(%rdi), %r15
addq $0x138, %rbx            # imm = 0x138
movapd %xmm1, 0x50(%rsp)
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd %xmm1, 0x40(%rsp)
xorl %ebp, %ebp
leaq 0x70(%rsp), %r14
leaq 0x110(%rsp), %r12
xorl %r13d, %r13d
cvtsi2sd %r13d, %xmm3
movsd 0x20(%rsp), %xmm0
ucomisd %xmm3, %xmm0
jbe 0x6c62b
mulsd 0x98751(%rip), %xmm3    # 0x104c70
cvtsi2sd %ebp, %xmm0
divsd 0x18(%rsp), %xmm0
movsd 0x8fb27(%rip), %xmm2    # 0xfc058
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x28(%rsp)
mulsd %xmm1, %xmm1
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
ucomisd 0x93d87(%rip), %xmm0    # 0x1002e0
movsd %xmm3, (%rsp)
jb 0x6c566
sqrtsd %xmm0, %xmm0
jmp 0x6c570
callq 0x4390
movsd (%rsp), %xmm3
movapd %xmm0, 0x30(%rsp)
movapd %xmm3, %xmm0
callq 0x47e0
movapd %xmm0, 0x60(%rsp)
movsd (%rsp), %xmm0
callq 0x4110
movapd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa75c
movq %r12, %rdi
callq 0x3dc5a
movsd 0x28(%rsp), %xmm1
mulsd 0x50(%rsp), %xmm1
movapd 0x30(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x60(%rsp), %xmm2
unpcklpd (%rsp), %xmm2           # xmm2 = xmm2[0],mem[0]
mulpd %xmm0, %xmm2
mulpd 0x40(%rsp), %xmm2
movsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0x140(%rsp)
addpd 0x70(%rsp), %xmm2
movapd %xmm2, 0x110(%rsp)
addsd 0x80(%rsp), %xmm1
movsd %xmm1, 0x120(%rsp)
movq %r14, %rdi
callq 0xa808
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa7d8
movq %r12, %rdi
callq 0xa808
incl %r13d
addl $0x2, %ebp
jmp 0x6c502
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa7d8
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %r14
jmp 0x6c653
movq %rax, %rbx
movq %r14, %rdi
callq 0xa808
movq %rbx, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dc5a
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
cmpl $0x1, %r12d
je 0x6c6c6
testl %r12d, %r12d
je 0x6c6bf
cmpl $-0x1, %r12d
jne 0x6c6d5
movsd (%r14), %xmm0
subsd 0x8(%rsp), %xmm0
jmp 0x6c6d1
movsd (%r14), %xmm0
jmp 0x6c6d1
movsd 0x8(%rsp), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%rbx)
cmpl $0x1, %r15d
je 0x6c6fc
testl %r15d, %r15d
je 0x6c6f4
cmpl $-0x1, %r15d
jne 0x6c70d
movsd 0x8(%r14), %xmm0
subsd 0x10(%rsp), %xmm0
jmp 0x6c708
movsd 0x8(%r14), %xmm0
jmp 0x6c708
movsd 0x10(%rsp), %xmm0
addsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
cmpl $0x1, %ebp
je 0x6c731
testl %ebp, %ebp
je 0x6c729
cmpl $-0x1, %ebp
jne 0x6c742
movsd 0x10(%r14), %xmm0
subsd 0x18(%rsp), %xmm0
jmp 0x6c73d
movsd 0x10(%r14), %xmm0
jmp 0x6c73d
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_O2/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 $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x138(%rdi), %r15
movq 0x140(%rdi), %rax
subq 0x138(%rdi), %rax
movl $0x98, %ecx
cqto
idivq %rcx
leaq 0x97351(%rip), %rsi     # 0x104cda
xorl %r12d, %r12d
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x4610
movq %rsp, %r13
leaq 0x9733d(%rip), %rbp     # 0x104cdf
movq 0x140(%r14), %rax
subq 0x138(%r14), %rax
cqto
movl $0x98, %ecx
idivq %rcx
cmpq %r12, %rax
jbe 0x6da06
movq %r15, %rdi
movq %r12, %rsi
callq 0xa73a
movq %r13, %rdi
movq %rax, %rsi
callq 0xa75c
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movsd 0x30(%rsp), %xmm3
movq %rbx, %rdi
movq %rbp, %rsi
movb $0x4, %al
callq 0x4610
movq %r13, %rdi
callq 0xa808
incq %r12
jmp 0x6d9a2
movq %rbx, %rdi
callq 0x4490
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %r15
movb %cl, 0x10(%rdi)
testl %ecx, %ecx
cmoveq %rdx, %rsi
movq %rsi, 0x8(%rdi)
movq %rdx, (%rdi)
movq %r8, 0x140(%rdi)
addq $0x18, %rdi
movq %r9, %rsi
callq 0x71324
leaq 0xa8(%rbx), %rdi
movq %r15, %rsi
callq 0x7135c
addq $0x90, %rbx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7143c
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/networkaccessibility.cc
// Function: AccessibilityClassNINF::removeOverlappedNodes()
void AccessibilityClassNINF::removeOverlappedNodes(){
  // Remove all nodes from Voronoi cells that lie within the sampling sphere
  for(unsigned int i = 0; i < vorcells.size(); i++){
    vorcells[i].removeOverlappedNodes(i, analyzedAtomNet, r_probe); // 0 is probe radious, 0 because atoms are already inflated
                                                                    // changes to r_probe as we moved away from inflating
    };
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
pushq $0x30
popq %r15
movl %eax, %r14d
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %r14, %rax
jbe 0x6f4ab
imulq $0x30, %r14, %rax
addq %rax, %rdi
movq 0x8(%rbx), %rdx
movsd 0x138(%rbx), %xmm0
movl %r14d, %esi
callq 0x4f9aa
leal 0x1(%r14), %eax
jmp 0x6f46c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4760
leaq 0x94a09(%rip), %rsi     # 0x1051b9
movq %rax, %rdi
callq 0x4480
leaq 0x94a05(%rip), %rsi     # 0x1051c4
movq %rbx, %rdi
callq 0x4480
xorl %r12d, %r12d
leaq 0x93d41(%rip), %r15     # 0x104512
movslq 0x190(%r14), %rax
cmpq %rax, %r12
jge 0x70802
movq 0x1f8(%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x46c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x4480
incq %r12
jmp 0x707d1
leaq 0x949c7(%rip), %rsi     # 0x1051d0
movq %rbx, %rdi
callq 0x4480
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x3, 0x8(%rbx,%rax)
xorl %ebp, %ebp
leaq 0x8bc9b(%rip), %r15     # 0xfc4ce
movslq 0x190(%r14), %rax
cmpq %rax, %rbp
jge 0x708be
imulq $0x18, %rbp, %r12
xorl %r13d, %r13d
cltq
cmpq %rax, %r13
jge 0x708a7
movq 0x228(%r14), %rdi
addq %r12, %rdi
movq %r13, %rsi
callq 0xaa50
movsd (%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd 0x8fa7a(%rip), %xmm1    # 0x1002e8
jne 0x70872
jnp 0x70888
movq 0x228(%r14), %rdi
addq %r12, %rdi
movq %r13, %rsi
callq 0xaa50
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x46c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x4480
incq %r13
movl 0x190(%r14), %eax
jmp 0x70846
movq %rbx, %rdi
leaq 0x91ccd(%rip), %rsi     # 0x10257e
callq 0x4480
incq %rbp
jmp 0x70833
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/poreinfo.cc
// Function: analyzePoreInfoFiles(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>>)
void  analyzePoreInfoFiles(ATOM_NETWORK *atmnet, std::string listfilename, std::string outputfilename){

 vector< vector<POREINFO> > PoreInfoFrames;

 fstream flist;
 int nfiles = 1;

 flist.open(listfilename.c_str());
 if(flist.is_open()==false){
   cerr << "Error: A file with .poreinfo frames (" << listfilename << ") failed to open. \n" ;
   }else{
   // file with a list of frames is open. proceed.
   while(!flist.eof())
    {
    string inputfilename;

    flist >> inputfilename;
    if(flist.eof()){
      nfiles--;
      break;
      };

    nfiles++;

    loadPoreInfoFile(&PoreInfoFrames, inputfilename);

    cout << "File " << inputfilename  << " read." << "\n";

    };

   flist.close();

   }; // ends while loop over a file list

 cout << nfiles << " frames loaded.\n";


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4540
movq (%rbx), %rsi
leaq 0x58(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x4410
leaq 0xd8(%rsp), %rdi
callq 0x4130
testb %al, %al
je 0x71fc8
pushq $0x1
popq %rbx
leaq 0x28(%rsp), %rbp
leaq 0x58(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %r12
movq 0x58(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x78(%rsp,%rax)
jne 0x71fbc
movq %rbp, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4580
movq 0x58(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x78(%rsp,%rax), %r13d
testb $0x2, %r13b
jne 0x71fa8
movq %r12, %rdi
movq %r15, %rsi
callq 0x45d0
movq %rsp, %rdi
movq %r12, %rsi
callq 0x72079
movq %r12, %rdi
callq 0x4210
movq 0xde051(%rip), %rdi     # 0x14ffc0
leaq 0x9298e(%rip), %rsi     # 0x104904
callq 0x4480
movq %rax, %rdi
movq %r15, %rsi
callq 0x43f0
movq %rax, %rdi
leaq 0x92925(%rip), %rsi     # 0x1048b5
callq 0x4480
movq %rax, %rdi
leaq 0x905df(%rip), %rsi     # 0x10257e
callq 0x4480
incl %ebx
jmp 0x71faa
decl %ebx
movq %r15, %rdi
callq 0x4210
testb $0x2, %r13b
je 0x71f07
leaq 0x58(%rsp), %rdi
callq 0x4080
jmp 0x71ff8
movq 0xde021(%rip), %rdi     # 0x14fff0
leaq 0x9326b(%rip), %rsi     # 0x105241
callq 0x4480
movq %rax, %rdi
movq %rbx, %rsi
callq 0x43f0
leaq 0x928eb(%rip), %rsi     # 0x1048d8
movq %rax, %rdi
callq 0x4480
pushq $0x1
popq %rbx
movq 0xddfc1(%rip), %rdi     # 0x14ffc0
movl %ebx, %esi
callq 0x4760
leaq 0x928fd(%rip), %rsi     # 0x10490a
movq %rax, %rdi
callq 0x4480
leaq 0x58(%rsp), %rdi
callq 0x4120
movq %rsp, %rdi
callq 0x7295c
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x72069
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4210
jmp 0x72055
movq %rax, %rbx
jmp 0x7205f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4210
leaq 0x58(%rsp), %rdi
callq 0x4120
movq %rsp, %rdi
callq 0x7295c
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/cluster.cc
// Function: dijkstra_sort(DIJKSTRA_NETWORK*)
void dijkstra_sort(DIJKSTRA_NETWORK* dnet)
{
    vector<DIJKSTRA_NODE>::iterator it = dnet->nodes.begin();
    for ( ; it != dnet->nodes.end(); ++it) 
        sort(it->connections.begin(), it->connections.end(), edge_comp);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
leaq -0x46(%rip), %r14       # 0x73434
cmpq 0x8(%rbx), %r15
je 0x73496
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
movq %r14, %rdx
callq 0x74d4b
addq $0x48, %r15
jmp 0x7347a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %r15
movq (%rsi), %rbx
movsd 0x40(%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x48(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x50(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%r14), %rdx
cmpq %rdx, %rbx
je 0x73528
movsd 0x8(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movsd 0x18(%rbx), %xmm2
movq %r15, %rdi
movsd 0x18(%rsp), %xmm3
movsd 0x10(%rsp), %xmm4
movsd 0x8(%rsp), %xmm5
callq 0x3f636
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7351e
cmpb $0x0, 0x40(%rbx)
je 0x73524
addq $0x48, %rbx
jmp 0x734db
movq 0x8(%r14), %rdx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x913db(%rip), %xmm0    # 0x1053f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73535
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x73b6e
movq 0x8(%rsp), %rbx
movq 0xdbf7c(%rip), %r14     # 0x14ffc0
cmpq 0x10(%rsp), %rbx
je 0x7405c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6403e
addq $0x18, %rbx
jmp 0x74044
leaq 0x8(%rsp), %rdi
callq 0xb132
leaq 0x20(%rsp), %rdi
callq 0x4bf94
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x7408a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb132
leaq 0x20(%rsp), %rdi
callq 0x4bf94
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/cluster.cc
// Function: geometry_pruning(VORONOI_NETWORK*, ATOM_NETWORK*, float, VORONOI_NETWORK*)
void geometry_pruning(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){
        if (red_vornet->nodes.size() == 0) {
            red_vornet->nodes.push_back(*vh_it);
        }
        else {
            vector<double> dists;
            double x1 = vh_it->x;
            double y1 = vh_it->y;
            double z1 = vh_it->z;
            for (VnIt vit = red_vornet->nodes.begin(); vit != red_vornet->nodes.end(); ++vit){
                double x2 = vit->x;
                double y2 = vit->y;
                double z2 = vit->z;
                double dist = atmnet->calcDistanceXYZ(x1,y1,z1,x2,y2,z2); 
                dists.push_back(dist);
            }
            sort(dists.begin(), dists.end());
            if (dists[0] > cutoff) {
                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 $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
movq 0x48(%rdi), %r12
leaq 0x48(%rdx), %rax
movq %rax, 0x8(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x10(%rsp), %rbp
leaq 0x50(%rsp), %r13
movq 0x30(%rsp), %rax
cmpq 0x50(%rax), %r12
je 0x749bb
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %rax
cmpq %r15, %rax
je 0x749a5
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movsd (%r12), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x8(%r12), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x38(%rsp)
cmpq %rax, %r15
je 0x7496e
movsd (%r15), %xmm3
movsd 0x8(%r15), %xmm4
movsd 0x10(%r15), %xmm5
movq %r14, %rdi
movsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
callq 0x3f636
movsd %xmm0, 0x50(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0xac88
addq $0x40, %r15
movq 0x50(%rbx), %rax
jmp 0x74923
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2cc88
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
ucomisd 0x28(%rsp), %xmm0
jbe 0x7499b
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xa89e
movq %rbp, %rdi
callq 0xb25c
jmp 0x749b2
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xa89e
addq $0x40, %r12
jmp 0x748cf
movq 0xdb5fe(%rip), %rdi     # 0x14ffc0
leaq 0x90b8d(%rip), %rsi     # 0x105556
callq 0x4480
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x6, %rsi
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
callq 0x4230
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x749fb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb25c
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %r12
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rdx), %r13
cmpq 0x50(%r15), %r12
je 0x74ad0
movsd (%r12), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%r12), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x2f0(%r14), %rbp
cmpq 0x2f8(%r14), %rbp
je 0x74abc
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 0x3f636
movsd 0x30(%rbp), %xmm1
subsd 0x8(%rsp), %xmm1
addq $0x98, %rbp
ucomisd %xmm0, %xmm1
jbe 0x74a70
jmp 0x74ac7
movq %r13, %rdi
movq %r12, %rsi
callq 0xa89e
addq $0x40, %r12
jmp 0x74a39
movq 0xdb4e9(%rip), %rdi     # 0x14ffc0
leaq 0x90a78(%rip), %rsi     # 0x105556
callq 0x4480
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x6, %rsi
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4230
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
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 0x6402e
leaq 0x20(%rbx), %r14
leaq 0x50(%rbx), %r15
leaq 0x60(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
andl $0x0, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x6402e
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
leaq 0x9079d(%rip), %rsi     # 0x106547
movq %r15, %rdi
callq 0x4810
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
addq $0x38, %rbx
movq %r15, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0xb132
movq %r14, %rdi
callq 0xb132
movq %r12, %rdi
callq 0x4780
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
orl $-0x1, 0xc(%rdi)
movl 0x8(%rsp), %eax
movl %r8d, 0x10(%rdi)
movl %r9d, 0x14(%rdi)
movl %eax, 0x18(%rdi)
retq