LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xf8(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xf2b70
movq -0xf0(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xf0e80
movq -0xf8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x5220
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movzbl -0x12(%rbp), %r8d
movzbl -0x11(%rbp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
callq 0xf1130
jmp 0xf0e31
leaq -0xc8(%rbp), %rdi
callq 0x5300
leaq -0xa8(%rbp), %rdi
callq 0xf2ec0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x5300
movq -0xd0(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl %r8d, -0x12c(%rbp)
movq %rcx, %rax
movl -0x12c(%rbp), %ecx
movq %rax, -0x128(%rbp)
movl %edx, %eax
movq -0x128(%rbp), %rdx
movl %eax, -0x11c(%rbp)
movq %rsi, %rax
movl -0x11c(%rbp), %esi
movq %rax, -0x118(%rbp)
movq %rdi, %r8
movq -0x118(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %sil
movb %sil, -0x11(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
andb $0x1, %cl
movb %cl, -0x29(%rbp)
andb $0x1, %al
movb %al, -0x2a(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xf2b70
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movb -0x11(%rbp), %al
movsd -0x20(%rbp), %xmm0
leaq -0xc0(%rbp), %rdi
andb $0x1, %al
movzbl %al, %ecx
callq 0xf1850
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xf17a9
movq -0x128(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x5220
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
movzbl -0x2a(%rbp), %r8d
movzbl -0x29(%rbp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq -0xc0(%rbp), %rdi
callq 0xf1130
jmp 0xf1775
leaq -0xe0(%rbp), %rdi
callq 0x5300
jmp 0xf1828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x5300
jmp 0xf183d
movq -0x128(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x110(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x5220
movq -0x150(%rbp), %rsi
movq -0x148(%rbp), %rdx
movzbl -0x2a(%rbp), %r8d
movzbl -0x29(%rbp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq -0xc0(%rbp), %rdi
callq 0xf1130
jmp 0xf17fa
leaq -0x110(%rbp), %rdi
callq 0x5300
jmp 0xf1828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x5300
jmp 0xf183d
leaq -0xc0(%rbp), %rdi
callq 0xf2ec0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x58f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdx, -0x120(%rbp)
movq %rsi, -0x118(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xf2b70
movq -0x118(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x5220
movq -0x110(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0xf1d80
jmp 0xf1ca9
leaq -0xd0(%rbp), %rdi
callq 0x5300
movq -0x120(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x100(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x5220
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
movzbl -0x1a(%rbp), %r8d
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq -0xb0(%rbp), %rdi
callq 0xf1130
jmp 0xf1d06
leaq -0x100(%rbp), %rdi
callq 0x5300
leaq -0xb0(%rbp), %rdi
callq 0xf2ec0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5300
jmp 0xf1d65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x5300
movq -0xd8(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdx, -0x120(%rbp)
movq %rsi, -0x118(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xf2b70
movq -0x118(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x5220
movq -0x110(%rbp), %rdi
movq -0x108(%rbp), %rsi
callq 0xf22f0
jmp 0xf2219
leaq -0xd0(%rbp), %rdi
callq 0x5300
movq -0x120(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x100(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x5220
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
movzbl -0x1a(%rbp), %r8d
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq -0xb0(%rbp), %rdi
callq 0xf1130
jmp 0xf2276
leaq -0x100(%rbp), %rdi
callq 0x5300
leaq -0xb0(%rbp), %rdi
callq 0xf2ec0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x5300
jmp 0xf22d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x5300
movq -0xd8(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x88(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xf2ffb
movslq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xf2feb
movslq -0x14(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf2f95
jmp 0xf2fed
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf2f47
movq -0x30(%rbp), %rax
movl 0x78(%rax), %ecx
imull 0x7c(%rax), %ecx
imull 0x80(%rax), %ecx
movl %ecx, 0x84(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xf308c
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xf307f
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xf3072
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xf3038
jmp 0xf3074
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf3029
jmp 0xf3081
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xf301a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x9f4c0
movl %eax, -0x2c(%rbp)
movb $0x1, -0x49(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xd1b0
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xf6f60
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xf6f30
movl $0x0, -0x74(%rbp)
movslq -0x74(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10090
movq -0x98(%rbp), %rcx
movq %rax, %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x89(%rbp)
jae 0xf4858
movb -0x49(%rbp), %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xf4864
jmp 0xf48ad
movl -0x2c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x74(%rbp), %rsi
callq 0x101d0
movq %rax, %rcx
movl -0x9c(%rbp), %eax
cmpl (%rcx), %eax
jne 0xf489d
movq -0x18(%rbp), %rdi
callq 0xaefa0
movq -0x20(%rbp), %rdi
callq 0xf7000
movb $0x0, -0x49(%rbp)
jmp 0xf489f
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0xf4820
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x1ec260
movq -0x58(%rbp), %rax
movq 0x1a8(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rsi
movslq -0x34(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movsd 0x1d8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x20(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
ucomisd 0x1d8(%rax), %xmm0
jbe 0xf6ed0
movq -0x58(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x1d8(%rax)
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movq 0x1b0(%rdi), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
subl $0x1, %ecx
callq 0xf72f0
movb %al, %cl
movq -0x58(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x49(%rbp)
movq 0x1b0(%rax), %rcx
movslq -0x34(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $-0x1, %esi
movl %esi, (%rcx,%rdx,4)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x1d8(%rax)
movb -0x49(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x954b0
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x30(%rbp)
callq 0x954b0
jmp 0xf7ca4
movq -0x38(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq %rdi, -0x50(%rbp)
callq 0x59bd0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rdi)
addq $0x8, %rdi
callq 0x595e0
jmp 0xf7cd4
movq -0x38(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0xf040
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0xa0(%rax)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0xa8(%rax)
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0xb0(%rax)
movsd (%rax), %xmm0
movsd %xmm0, 0xd0(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xf7d4d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x12310
movq -0x30(%rbp), %rdi
callq 0xf200
movq -0x40(%rbp), %rdi
callq 0xf200
movq -0x20(%rbp), %rdi
callq 0x58f0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x10387a(%rip), %xmm0   # 0x1fc928
callq 0x53f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x3, %edi
callq 0x94d40
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd 0xf8f64(%rip), %xmm1    # 0x1f2050
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
callq 0xfaf90
movq -0x30(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x4, %esi
callq 0xfab70
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x1037ca(%rip), %xmm0   # 0x1fc928
callq 0x53f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x3, %edi
callq 0x94d40
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd 0xf8eb4(%rip), %xmm1    # 0x1f2050
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
callq 0xfa750
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x4, %esi
callq 0xfaf90
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x10371a(%rip), %xmm0   # 0x1fc928
callq 0x53f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x3, %edi
callq 0x94d40
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd 0xf8e04(%rip), %xmm1    # 0x1f2050
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x14(%rbp), %esi
callq 0xfa750
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x4, %esi
callq 0xfab70
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x2, %edi
callq 0x94d40
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xf8da9(%rip), %xmm0    # 0x1f2078
mulsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movl -0x14(%rbp), %esi
callq 0xf8a70
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x6, %esi
callq 0xfa750
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0xa, %esi
callq 0xfab70
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0xe, %esi
callq 0xfaf90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x3, %edi
callq 0x94d40
movaps %xmm0, %xmm1
movsd 0xf8cdf(%rip), %xmm0    # 0x1f2050
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x5, %edi
callq 0x94d40
movaps %xmm0, %xmm1
movsd 0xf8cc1(%rip), %xmm0    # 0x1f2050
addsd %xmm1, %xmm0
movsd 0xf8cad(%rip), %xmm1    # 0x1f2048
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xf8ca4(%rip), %xmm0    # 0x1f2050
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0xf8c8d(%rip), %xmm0    # 0x1f2078
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movl $0x5, %edi
callq 0x94d40
movq -0x60(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x68(%rbp), %xmm0
movsd 0xf8c3d(%rip), %xmm1    # 0x1f2050
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0xf8c25(%rip), %xmm1    # 0x1f2048
divsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0xf8c44(%rip), %xmm0    # 0x1f2078
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movl -0x14(%rbp), %esi
callq 0xfb3b0
movq -0x60(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x8, %esi
callq 0xfa750
movq -0x60(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0xc, %esi
callq 0xfaf90
movq -0x60(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x10, %esi
callq 0xfab70
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd 0xf8ba4(%rip), %xmm0    # 0x1f2078
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x5, %edi
callq 0x94d40
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd 0xf8b54(%rip), %xmm1    # 0x1f2050
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0xf8b3c(%rip), %xmm1    # 0x1f2048
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xf8b5b(%rip), %xmm0    # 0x1f2078
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
callq 0xfa750
movq -0x30(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x4, %esi
callq 0xfaf90
movq -0x30(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x14(%rbp), %esi
addl $0x8, %esi
callq 0xfab70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x5, %edi
callq 0x94d40
movq -0x60(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xf8a9b(%rip), %xmm0    # 0x1f2050
addsd %xmm1, %xmm0
movsd 0xf8a87(%rip), %xmm1    # 0x1f2048
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0xf8aa6(%rip), %xmm0    # 0x1f2078
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xf8a6c(%rip), %xmm0    # 0x1f2050
addsd -0x20(%rbp), %xmm0
movsd 0xf8a87(%rip), %xmm1    # 0x1f2078
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xf8a4e(%rip), %xmm0    # 0x1f2050
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x48(%rbp), %xmm0
movl -0x14(%rbp), %esi
callq 0xf8a70
movq -0x60(%rbp), %rdi
movsd 0xf8a17(%rip), %xmm0    # 0x1f2078
mulsd -0x40(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
movl -0x14(%rbp), %esi
addl $0x6, %esi
callq 0xfb3b0
movq -0x60(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movsd 0xf89e7(%rip), %xmm2    # 0x1f2078
mulsd -0x40(%rbp), %xmm2
movl -0x14(%rbp), %esi
addl $0xe, %esi
callq 0xfb3b0
movq -0x60(%rbp), %rdi
movsd -0x58(%rbp), %xmm0
movsd 0xf89c6(%rip), %xmm1    # 0x1f2078
mulsd -0x40(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movl -0x14(%rbp), %esi
addl $0x16, %esi
callq 0xfb3b0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movl %r8d, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movb $0x0, -0x3d(%rbp)
callq 0x954b0
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rdi
movsd 0x30(%rdx), %xmm0
movsd %xmm0, 0x30(%rdi)
cmpl $-0x1, -0x34(%rbp)
jne 0xfa645
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd (%rcx), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xfa67c
cmpl $0x1, -0x34(%rbp)
jne 0xfa662
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd (%rcx), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xfa67a
cmpl $0x0, -0x34(%rbp)
jne 0xfa678
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0xfa67a
jmp 0xfa67c
cmpl $-0x1, -0x38(%rbp)
jne 0xfa69b
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xfa6d6
cmpl $0x1, -0x38(%rbp)
jne 0xfa6ba
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xfa6d4
cmpl $0x0, -0x38(%rbp)
jne 0xfa6d2
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xfa6d4
jmp 0xfa6d6
cmpl $-0x1, -0x3c(%rbp)
jne 0xfa6f5
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0xfa730
cmpl $0x1, -0x3c(%rbp)
jne 0xfa714
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0xfa72e
cmpl $0x0, -0x3c(%rbp)
jne 0xfa72c
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0xfa72e
jmp 0xfa730
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0xfa743
movq -0x48(%rbp), %rdi
callq 0xf200
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x138, %rdi            # imm = 0x138
callq 0xf060
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x100897(%rip), %rsi    # 0x1fc992
movb $0x0, %al
callq 0x5750
movl $0x0, -0x18(%rbp)
movq -0xb8(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x138, %rdi            # imm = 0x138
callq 0xf060
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0xfc1a5
movq -0xb8(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movslq -0x18(%rbp), %rsi
callq 0xf090
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0xf0d0
movq -0x10(%rbp), %rdi
movsd -0xb0(%rbp), %xmm0
movsd -0xa8(%rbp), %xmm1
movsd -0xa0(%rbp), %xmm2
movsd -0x80(%rbp), %xmm3
leaq 0x100813(%rip), %rsi    # 0x1fc997
movb $0x4, %al
callq 0x5750
leaq -0xb0(%rbp), %rdi
callq 0xf200
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xfc109
movq -0x10(%rbp), %rdi
callq 0x5550
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
testb $0x1, -0x19(%rbp)
je 0xfe927
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xfe93a
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x140(%rdi)
movq -0x30(%rbp), %rsi
addq $0x18, %rdi
callq 0x102090
movq -0x38(%rbp), %rdi
movq 0x18(%rbp), %rsi
addq $0xa8, %rdi
callq 0x1020f0
movq -0x38(%rbp), %rdi
movq 0x10(%rbp), %rsi
addq $0x90, %rdi
callq 0x102350
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
addq $0x90, %rdi
callq 0x16550
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xfee29
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x162f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x8(%rax), %rdx
movsd 0x138(%rax), %xmm0
callq 0xbd500
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfedcb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl 0x190(%rax), %esi
callq 0x58d0
movq %rax, %rdi
leaq 0xfc0a0(%rip), %rsi     # 0x1fce71
callq 0x5540
movq -0x10(%rbp), %rdi
leaq 0xfc09b(%rip), %rsi     # 0x1fce7c
callq 0x5540
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x190(%rcx), %eax
jge 0x100e3f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x1f8, %rdi            # imm = 0x1F8
movslq -0x14(%rbp), %rsi
callq 0xedb0
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0xfb47f(%rip), %rsi     # 0x1fc2ae
callq 0x5540
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x100ded
movq -0x10(%rbp), %rdi
leaq 0xfc03e(%rip), %rsi     # 0x1fce88
callq 0x5540
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x102730
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x3, %esi
callq 0xf930
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x190(%rcx), %eax
jge 0x100f5d
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x190(%rcx), %eax
jge 0x100f3f
movq -0x30(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
movslq -0x18(%rbp), %rsi
callq 0x162d0
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xfc80
movsd (%rax), %xmm0
movsd 0xf189f(%rip), %xmm1    # 0x1f2778
ucomisd %xmm1, %xmm0
jne 0x100eeb
jp 0x100eeb
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x100f14
movq -0x30(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
movslq -0x18(%rbp), %rsi
callq 0x162d0
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xfc80
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0xf155b(%rip), %rsi     # 0x1f2487
callq 0x5540
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x100e9a
movq -0x10(%rbp), %rdi
leaq 0xf86db(%rip), %rsi     # 0x1f9625
callq 0x5540
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x100e80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/./poreinfo.h
// Function: POREINFO::POREINFO()
POREINFO()
   {
   dim = 0;
   nodes.clear();
   prevIDs.clear();
   nextIDs.clear();
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x20, %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x107b50
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xd0d0
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0xd0d0
movq -0x10(%rbp), %rdi
movl $0x0, (%rdi)
addq $0x40, %rdi
callq 0x107b70
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x163b0
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x163b0
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a000
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29c80
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x67c30
testb $0x1, %al
jne 0x109e69
jmp 0x109eba
leaq -0x10(%rbp), %rdi
callq 0x10c8c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2a8e0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x10c8c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2a710
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0xea(%rip), %rdx       # 0x109dc0
callq 0x10c870
leaq -0x10(%rbp), %rdi
callq 0x67c70
jmp 0x109e49
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
leaq 0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movss %xmm0, -0x24(%rbp)
callq 0x2a000
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rdi
callq 0x29c80
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x67c30
testb $0x1, %al
jne 0x109f14
jmp 0x109fb2
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10c8c0
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10c8c0
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10c8c0
movq -0x70(%rbp), %rdi
movsd -0x68(%rbp), %xmm0
movsd -0x60(%rbp), %xmm1
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsd 0x18(%rcx), %xmm2
movsd (%rax), %xmm3
movsd 0x8(%rax), %xmm4
movsd 0x10(%rax), %xmm5
callq 0x97a10
movsd %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10c8c0
testb $0x1, 0x40(%rax)
jne 0x109fa2
movsd -0x40(%rbp), %xmm1
movss -0x24(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x109fa2
jmp 0x109fb2
jmp 0x109fa4
leaq -0x30(%rbp), %rdi
callq 0x67c70
jmp 0x109ef1
movq -0x58(%rbp), %rdi
callq 0x29c80
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x10c8e0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movss 0xf1e48(%rip), %xmm0    # 0x1fd108
callq 0x109ff0
movq -0x60(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x10aa60
jmp 0x10b2d8
leaq -0x38(%rbp), %rdi
callq 0xb2b00
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb2b30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10cdb0
testb $0x1, %al
jne 0x10b305
jmp 0x10b351
leaq -0x50(%rbp), %rdi
callq 0x10cdf0
movq %rax, %rdi
movq 0x167ca8(%rip), %rsi    # 0x272fc0
callq 0xea920
jmp 0x10b31f
jmp 0x10b321
leaq -0x50(%rbp), %rdi
callq 0x10ce10
jmp 0x10b2e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10b369
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x12210
jmp 0x10b369
leaq -0x38(%rbp), %rdi
callq 0x12210
leaq -0x20(%rbp), %rdi
callq 0xafe50
addq $0x60, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xafe50
movq -0x40(%rbp), %rdi
callq 0x58f0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xea8e0
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0xada60
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x60(%rbp)
callq 0xada60
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5720
movq -0x50(%rbp), %rax
movl $0x0, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
leaq -0x38(%rbp), %rdi
callq 0xea8e0
jmp 0x110999
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x10(%rdi)
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rdi)
addq $0x50, %rdi
leaq 0xeeb28(%rip), %rsi     # 0x1ff4df
callq 0x5710
jmp 0x1109be
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x5300
movq -0x60(%rbp), %rdi
callq 0x12210
movq -0x68(%rbp), %rdi
callq 0x12210
movq -0x40(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl -0x18(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)