LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/./container.hh
// Function: voro::container_base::region_index(int, int, int, int, int, int, double&, double&, double&, int&)
inline int region_index(int ci,int cj,int ck,int ei,int ej,int ek,double &qx,double &qy,double &qz,int &disp) {
			if(xperiodic) {if(ci+ei<nx) {ei+=nx;qx=-(bx-ax);} else if(ci+ei>=(nx<<1)) {ei-=nx;qx=bx-ax;} else qx=0;}
			if(yperiodic) {if(cj+ej<ny) {ej+=ny;qy=-(by-ay);} else if(cj+ej>=(ny<<1)) {ej-=ny;qy=by-ay;} else qy=0;}
			if(zperiodic) {if(ck+ek<nz) {ek+=nz;qz=-(bz-az);} else if(ck+ek>=(nz<<1)) {ek-=nz;qz=bz-az;} else qz=0;}
			return disp+ei+nx*(ej+ny*ek);
		}

// Assembly:
cmpb $0x1, 0xa8(%rdi)
jne 0x18515
movq 0x10(%rsp), %rax
addl %r8d, %esi
movl (%rdi), %r10d
cmpl %r10d, %esi
jge 0x184f7
movsd 0x78(%rdi), %xmm0
subsd 0x70(%rdi), %xmm0
addl %r8d, %r10d
xorpd 0x1eb4e(%rip), %xmm0    # 0x37040
movl %r10d, %r8d
jmp 0x18511
leal (%r10,%r10), %r11d
xorpd %xmm0, %xmm0
cmpl %r11d, %esi
jl 0x18511
subl %r10d, %r8d
movsd 0x78(%rdi), %xmm0
subsd 0x70(%rdi), %xmm0
movsd %xmm0, (%rax)
cmpb $0x1, 0xa9(%rdi)
jne 0x18571
movq 0x18(%rsp), %rax
addl %r9d, %edx
movl 0x4(%rdi), %esi
cmpl %esi, %edx
jge 0x1854d
movsd 0x88(%rdi), %xmm0
subsd 0x80(%rdi), %xmm0
addl %r9d, %esi
xorpd 0x1eaf8(%rip), %xmm0    # 0x37040
movl %esi, %r9d
jmp 0x1856d
leal (%rsi,%rsi), %r10d
xorpd %xmm0, %xmm0
cmpl %r10d, %edx
jl 0x1856d
subl %esi, %r9d
movsd 0x88(%rdi), %xmm0
subsd 0x80(%rdi), %xmm0
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rdx
movl 0x8(%rsp), %eax
cmpb $0x1, 0xaa(%rdi)
jne 0x185d7
movq 0x20(%rsp), %rsi
addl %eax, %ecx
movl 0x8(%rdi), %r10d
cmpl %r10d, %ecx
jge 0x185b3
movsd 0x98(%rdi), %xmm0
subsd 0x90(%rdi), %xmm0
addl %eax, %r10d
xorpd 0x1ea92(%rip), %xmm0    # 0x37040
movl %r10d, %eax
jmp 0x185d3
leal (%r10,%r10), %r11d
xorpd %xmm0, %xmm0
cmpl %r11d, %ecx
jl 0x185d3
subl %r10d, %eax
movsd 0x98(%rdi), %xmm0
subsd 0x90(%rdi), %xmm0
movsd %xmm0, (%rsi)
addl (%rdx), %r8d
imull 0x4(%rdi), %eax
addl %r9d, %eax
imull (%rdi), %eax
addl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container>::scan_bits_mask_add(unsigned int, unsigned int*, int, int, int, int*&)
inline void voro_compute<c_class>::scan_bits_mask_add(unsigned int q,unsigned int *mijk,int ei,int ej,int ek,int *&qu_e) {
	const unsigned int b1=1<<21,b2=1<<22,b3=1<<24,b4=1<<25,b5=1<<27,b6=1<<28;
	if((q&b2)==b2) {
		if(ei>0) {*(mijk-1)=mv;*(qu_e++)=ei-1;*(qu_e++)=ej;*(qu_e++)=ek;}
		if((q&b1)==0&&ei<hx-1) {*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
	} else if((q&b1)==b1&&ei<hx-1) {*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
	if((q&b4)==b4) {
		if(ej>0) {*(mijk-hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej-1;*(qu_e++)=ek;}
		if((q&b3)==0&&ej<hy-1) {*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
	} else if((q&b3)==b3&&ej<hy-1) {*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
	if((q&b6)==b6) {
		if(ek>0) {*(mijk-hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek-1;}
		if((q&b5)==0&&ek<hz-1) {*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
	} else if((q&b5)==b5&&ek<hz-1) {*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
}

// Assembly:
pushq %rbx
movq 0x10(%rsp), %rax
btl $0x16, %esi
jb 0x185fc
btl $0x15, %esi
jb 0x18627
jmp 0x18654
testl %ecx, %ecx
jle 0x18621
movl 0x70(%rdi), %r10d
movl %r10d, -0x4(%rdx)
leal -0x1(%rcx), %r10d
movq (%rax), %r11
movl %r10d, (%r11)
movl %r8d, 0x4(%r11)
leaq 0xc(%r11), %r10
movq %r10, (%rax)
movl %r9d, 0x8(%r11)
btl $0x15, %esi
jb 0x18654
movl 0x38(%rdi), %r10d
decl %r10d
cmpl %ecx, %r10d
jle 0x18654
movl 0x70(%rdi), %r10d
movl %r10d, 0x4(%rdx)
leal 0x1(%rcx), %r10d
movq (%rax), %r11
movl %r10d, (%r11)
movl %r8d, 0x4(%r11)
leaq 0xc(%r11), %r10
movq %r10, (%rax)
movl %r9d, 0x8(%r11)
btl $0x19, %esi
jb 0x18662
btl $0x18, %esi
jb 0x1869b
jmp 0x186cc
testl %r8d, %r8d
jle 0x18695
movl 0x70(%rdi), %r10d
movslq 0x38(%rdi), %r11
shlq $0x2, %r11
movq %rdx, %rbx
subq %r11, %rbx
movl %r10d, (%rbx)
movq (%rax), %r10
movl %ecx, (%r10)
leal -0x1(%r8), %r11d
movl %r11d, 0x4(%r10)
leaq 0xc(%r10), %r11
movq %r11, (%rax)
movl %r9d, 0x8(%r10)
btl $0x18, %esi
jb 0x186cc
movl 0x3c(%rdi), %r10d
decl %r10d
cmpl %r8d, %r10d
jle 0x186cc
movl 0x70(%rdi), %r10d
movslq 0x38(%rdi), %r11
movl %r10d, (%rdx,%r11,4)
movq (%rax), %r10
movl %ecx, (%r10)
leal 0x1(%r8), %r11d
movl %r11d, 0x4(%r10)
leaq 0xc(%r10), %r11
movq %r11, (%rax)
movl %r9d, 0x8(%r10)
btl $0x1c, %esi
jb 0x186da
btl $0x1b, %esi
jb 0x18713
jmp 0x1873e
testl %r9d, %r9d
jle 0x1870d
movl 0x70(%rdi), %r10d
movslq 0x44(%rdi), %r11
shlq $0x2, %r11
movq %rdx, %rbx
subq %r11, %rbx
movl %r10d, (%rbx)
movq (%rax), %r10
movl %ecx, (%r10)
movl %r8d, 0x4(%r10)
leal -0x1(%r9), %r11d
leaq 0xc(%r10), %rbx
movq %rbx, (%rax)
movl %r11d, 0x8(%r10)
btl $0x1b, %esi
jb 0x1873e
movl 0x40(%rdi), %esi
decl %esi
cmpl %r9d, %esi
jle 0x1873e
movl 0x70(%rdi), %esi
movslq 0x44(%rdi), %rdi
movl %esi, (%rdx,%rdi,4)
movq (%rax), %rdx
movl %ecx, (%rdx)
movl %r8d, 0x4(%rdx)
incl %r9d
leaq 0xc(%rdx), %rcx
movq %rcx, (%rax)
movl %r9d, 0x8(%rdx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::edge_z_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double, double)
inline bool voro_compute<c_class>::edge_z_test(v_cell &c,double xl,double yl,double z0,double xh,double yh,double z1) {
	con.r_prime(xl*xl+yl*yl);
	if(c.plane_intersects_guess(xl,yh,z0,con.r_cutoff(xl*xl+yl*yh))) return false;
	if(c.plane_intersects(xl,yh,z1,con.r_cutoff(xl*xl+yl*yh))) return false;
	if(c.plane_intersects(xl,yl,z1,con.r_cutoff(xl*xl+yl*yl))) return false;
	if(c.plane_intersects(xl,yl,z0,con.r_cutoff(xl*xl+yl*yl))) return false;
	if(c.plane_intersects(xh,yl,z0,con.r_cutoff(xl*xh+yl*yl))) return false;
	if(c.plane_intersects(xh,yl,z1,con.r_cutoff(xl*xh+yl*yl))) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm5, 0x10(%rsp)
movapd %xmm4, %xmm5
movsd %xmm3, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm3, %xmm6
movapd %xmm3, %xmm1
movsd %xmm4, 0x30(%rsp)
addsd %xmm4, %xmm1
movsd 0xf0(%rax), %xmm3
movsd %xmm1, 0x28(%rsp)
divsd %xmm1, %xmm3
addsd 0x18000(%rip), %xmm3    # 0x37008
movsd %xmm3, 0xf8(%rax)
movsd %xmm6, 0x38(%rsp)
mulsd %xmm6, %xmm3
movq %rsi, %rdi
movsd %xmm0, (%rsp)
movsd %xmm5, 0x40(%rsp)
movapd %xmm5, %xmm1
movsd %xmm2, 0x20(%rsp)
callq 0xb1d8
testb %al, %al
jne 0x1f10e
movq (%r14), %rax
movsd 0x38(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f10e
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x28(%rsp), %xmm3
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f10e
movq (%r14), %rax
movsd 0x28(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f10e
movq (%r14), %rax
movsd (%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x30(%rsp), %xmm1
movsd 0xf8(%rax), %xmm3
movsd %xmm1, (%rsp)
mulsd %xmm1, %xmm3
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
je 0x1f118
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movsd (%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0xb0f4
xorb $0x1, %al
jmp 0x1f110
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::edge_y_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double, double)
inline bool voro_compute<c_class>::edge_y_test(v_cell &c,double xl,double y0,double zl,double xh,double y1,double zh) {
	con.r_prime(xl*xl+zl*zl);
	if(c.plane_intersects_guess(xl,y0,zh,con.r_cutoff(xl*xl+zl*zh))) return false;
	if(c.plane_intersects(xl,y1,zh,con.r_cutoff(xl*xl+zl*zh))) return false;
	if(c.plane_intersects(xl,y1,zl,con.r_cutoff(xl*xl+zl*zl))) return false;
	if(c.plane_intersects(xl,y0,zl,con.r_cutoff(xl*xl+zl*zl))) return false;
	if(c.plane_intersects(xh,y0,zl,con.r_cutoff(xl*xh+zl*zl))) return false;
	if(c.plane_intersects(xh,y1,zl,con.r_cutoff(xl*xh+zl*zl))) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm4, 0x10(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm2, 0x8(%rsp)
movapd %xmm2, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm3, %xmm6
movapd %xmm3, %xmm2
movsd %xmm4, 0x30(%rsp)
addsd %xmm4, %xmm2
movsd 0xf0(%rax), %xmm3
movsd %xmm2, 0x28(%rsp)
divsd %xmm2, %xmm3
addsd 0x17e5c(%rip), %xmm3    # 0x37008
movsd %xmm3, 0xf8(%rax)
movsd %xmm6, 0x38(%rsp)
mulsd %xmm6, %xmm3
movq %rsi, %rdi
movsd %xmm0, (%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm5, 0x40(%rsp)
movapd %xmm5, %xmm2
callq 0xb1d8
testb %al, %al
jne 0x1f2b2
movq (%r14), %rax
movsd 0x38(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f2b2
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x28(%rsp), %xmm3
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f2b2
movq (%r14), %rax
movsd 0x28(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f2b2
movq (%r14), %rax
movsd (%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm1
addsd 0x30(%rsp), %xmm1
movsd 0xf8(%rax), %xmm3
movsd %xmm1, (%rsp)
mulsd %xmm1, %xmm3
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
je 0x1f2bc
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movsd (%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
xorb $0x1, %al
jmp 0x1f2b4
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::face_x_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double)
inline bool voro_compute<c_class>::face_x_test(v_cell &c,double xl,double y0,double z0,double y1,double z1) {
	con.r_prime(xl*xl);
	if(c.plane_intersects_guess(xl,y0,z0,con.r_cutoff(xl*xl))) return false;
	if(c.plane_intersects(xl,y0,z1,con.r_cutoff(xl*xl))) return false;
	if(c.plane_intersects(xl,y1,z1,con.r_cutoff(xl*xl))) return false;
	if(c.plane_intersects(xl,y1,z0,con.r_cutoff(xl*xl))) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
movsd 0xf0(%rax), %xmm3
divsd %xmm4, %xmm3
addsd 0x17ce6(%rip), %xmm3    # 0x37008
movsd %xmm3, 0xf8(%rax)
movsd %xmm4, 0x8(%rsp)
mulsd %xmm4, %xmm3
movq %rsi, %rdi
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd %xmm2, 0x28(%rsp)
callq 0xb1d8
testb %al, %al
jne 0x1f3b0
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x8(%rsp), %xmm3
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f3b0
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x8(%rsp), %xmm3
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
je 0x1f3ba
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movsd 0x8(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
callq 0xb0f4
xorb $0x1, %al
jmp 0x1f3b2
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::edge_x_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double, double)
inline bool voro_compute<c_class>::edge_x_test(v_cell &c,double x0,double yl,double zl,double x1,double yh,double zh) {
	con.r_prime(yl*yl+zl*zl);
	if(c.plane_intersects_guess(x0,yl,zh,con.r_cutoff(yl*yl+zl*zh))) return false;
	if(c.plane_intersects(x1,yl,zh,con.r_cutoff(yl*yl+zl*zh))) return false;
	if(c.plane_intersects(x1,yl,zl,con.r_cutoff(yl*yl+zl*zl))) return false;
	if(c.plane_intersects(x0,yl,zl,con.r_cutoff(yl*yl+zl*zl))) return false;
	if(c.plane_intersects(x0,yh,zl,con.r_cutoff(yl*yh+zl*zl))) return false;
	if(c.plane_intersects(x1,yh,zl,con.r_cutoff(yl*yh+zl*zl))) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm4, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movsd %xmm2, 0x8(%rsp)
movapd %xmm2, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm3, %xmm6
movapd %xmm3, %xmm2
movsd %xmm4, 0x30(%rsp)
addsd %xmm4, %xmm2
movsd 0xf0(%rax), %xmm3
movsd %xmm2, 0x28(%rsp)
divsd %xmm2, %xmm3
addsd 0x17bb8(%rip), %xmm3    # 0x37008
movsd %xmm3, 0xf8(%rax)
movsd %xmm6, 0x38(%rsp)
mulsd %xmm6, %xmm3
movq %rsi, %rdi
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, (%rsp)
movsd %xmm5, 0x40(%rsp)
movapd %xmm5, %xmm2
callq 0xb1d8
testb %al, %al
jne 0x1f556
movq (%r14), %rax
movsd 0x38(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f556
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x28(%rsp), %xmm3
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f556
movq (%r14), %rax
movsd 0x28(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f556
movq (%r14), %rax
movsd 0x18(%rsp), %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
addsd 0x30(%rsp), %xmm0
movsd 0xf8(%rax), %xmm3
movsd %xmm0, (%rsp)
mulsd %xmm0, %xmm3
movq %rbx, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
je 0x1f560
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movsd (%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb0f4
xorb $0x1, %al
jmp 0x1f558
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::face_y_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double)
inline bool voro_compute<c_class>::face_y_test(v_cell &c,double x0,double yl,double z0,double x1,double z1) {
	con.r_prime(yl*yl);
	if(c.plane_intersects_guess(x0,yl,z0,con.r_cutoff(yl*yl))) return false;
	if(c.plane_intersects(x0,yl,z1,con.r_cutoff(yl*yl))) return false;
	if(c.plane_intersects(x1,yl,z1,con.r_cutoff(yl*yl))) return false;
	if(c.plane_intersects(x1,yl,z0,con.r_cutoff(yl*yl))) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
movsd 0xf0(%rax), %xmm3
divsd %xmm4, %xmm3
addsd 0x17a42(%rip), %xmm3    # 0x37008
movsd %xmm3, 0xf8(%rax)
movsd %xmm4, 0x8(%rsp)
mulsd %xmm4, %xmm3
movq %rsi, %rdi
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x28(%rsp)
callq 0xb1d8
testb %al, %al
jne 0x1f654
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x8(%rsp), %xmm3
movq %rbx, %rdi
movsd 0x30(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
jne 0x1f654
movq (%r14), %rax
movsd 0xf8(%rax), %xmm3
mulsd 0x8(%rsp), %xmm3
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0xb0f4
testb %al, %al
je 0x1f65e
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movsd 0x8(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
callq 0xb0f4
xorb $0x1, %al
jmp 0x1f656
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container_poly>::compute_min_radius(int, int, int, double, double, double, double)
bool voro_compute<c_class>::compute_min_radius(int di,int dj,int dk,double fx,double fy,double fz,double mrs) {
	double t,crs;

	if(di>0) {t=di*boxx-fx;crs=t*t;}
	else if(di<0) {t=(di+1)*boxx-fx;crs=t*t;}
	else crs=0;

	if(dj>0) {t=dj*boxy-fy;crs+=t*t;}
	else if(dj<0) {t=(dj+1)*boxy-fy;crs+=t*t;}

	if(dk>0) {t=dk*boxz-fz;crs+=t*t;}
	else if(dk<0) {t=(dk+1)*boxz-fz;crs+=t*t;}

	return crs>con.r_max_add(mrs);
}

// Assembly:
testl %esi, %esi
jle 0x23068
xorps %xmm4, %xmm4
cvtsi2sd %esi, %xmm4
mulsd 0x8(%rdi), %xmm4
subsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
jmp 0x2306e
xorpd %xmm4, %xmm4
js 0x230c9
testl %edx, %edx
jle 0x2308c
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd 0x10(%rdi), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm4
jmp 0x2308e
js 0x230cd
testl %ecx, %ecx
jle 0x230ac
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd 0x18(%rdi), %xmm0
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm4
jmp 0x230ae
js 0x230d1
movq (%rdi), %rax
movsd 0xe0(%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm0, %xmm4
seta %al
retq
incl %esi
jmp 0x23052
incl %edx
jmp 0x23072
incl %ecx
jmp 0x23092
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/./container_prd.hh
// Function: voro::container_periodic_base::region_index(int, int, int, int, int, int, double&, double&, double&, int&)
inline int region_index(int ci,int cj,int ck,int ei,int ej,int ek,double &qx,double &qy,double &qz,int &disp) {
			int qi=ci+(ei-nx),qj=cj+(ej-ey),qk=ck+(ek-ez);
			int iv(step_div(qi,nx));if(iv!=0) {qx=iv*bx;qi-=nx*iv;} else qx=0;
			create_periodic_image(qi,qj,qk);
			return qi+nx*(qj+oy*qk);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %ebx
movl %edx, %r8d
movq %rdi, %r14
movl 0x128(%rdi), %edi
movl 0x180(%r14), %r9d
subl %edi, %ebx
addl %esi, %ebx
movl 0x184(%r14), %esi
js 0x24f2c
movl %ebx, %eax
cltd
idivl %edi
jmp 0x24f34
leal 0x1(%rbx), %eax
cltd
idivl %edi
decl %eax
movq 0x38(%rsp), %rdx
movl 0x30(%rsp), %r15d
testl %eax, %eax
je 0x24f52
cvtsi2sd %eax, %xmm0
mulsd (%r14), %xmm0
imull %edi, %eax
subl %eax, %ebx
jmp 0x24f56
xorpd %xmm0, %xmm0
movsd %xmm0, (%rdx)
subl %esi, %r15d
addl %ecx, %r15d
subl %r9d, %ebp
addl %r8d, %ebp
testl %ebx, %ebx
js 0x24f89
testl %ebp, %ebp
js 0x24f89
cmpl %ebx, %edi
jle 0x24f89
testl %r15d, %r15d
js 0x24f89
cmpl %ebp, 0x190(%r14)
jle 0x24f89
cmpl %r15d, 0x194(%r14)
jg 0x24fa1
leaq 0x1441a(%rip), %rdi     # 0x393aa
movl $0x3, %esi
callq 0x133c5
movl 0x184(%r14), %esi
cmpl %r15d, %esi
jg 0x24fd2
cmpl %r15d, 0x18c(%r14)
jle 0x24fd2
cmpl %ebp, 0x180(%r14)
jg 0x24fc1
cmpl %ebp, 0x188(%r14)
jg 0x24fe1
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x32eea
jmp 0x24fe1
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x33302
imull 0x190(%r14), %r15d
addl %ebp, %r15d
imull 0x128(%r14), %r15d
addl %ebx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::start()
bool c_loop_subset::start() {
	while(co[ijk]==0) {if(!next_block()) return false;}
	while(mode!=no_check&&out_of_bounds()) {
		q++;
		while(q>=co[ijk]) {q=0;if(!next_block()) return false;}
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%r14), %rax
movslq 0x3c(%r14), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x2ed4d
movq %r14, %rdi
callq 0x2ed98
testb %al, %al
jne 0x2ed31
jmp 0x2ed8b
movb $0x1, %bl
cmpl $0x2, 0x44(%r14)
je 0x2ed8d
movq %r14, %rdi
callq 0x2ef14
testb %al, %al
je 0x2ed8d
incl 0x40(%r14)
movl 0x40(%r14), %eax
movq 0x28(%r14), %rcx
movslq 0x3c(%r14), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x2ed4f
movl $0x0, 0x40(%r14)
movq %r14, %rdi
callq 0x2ed98
testb %al, %al
jne 0x2ed66
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::next_block()
bool c_loop_subset::next_block() {
	if(i<bi) {
		i++;
		if(ci<nx-1) {ci++;ijk++;} else {ci=0;ijk+=1-nx;px+=sx;}
		return true;
	} else if(j<bj) {
		i=ai;ci=di;px=apx;j++;
		if(cj<ny-1) {cj++;ijk+=inc1;} else {cj=0;ijk+=inc1-nxy;py+=sy;}
		return true;
	} else if(k<bk) {
		i=ai;ci=di;j=aj;cj=dj;px=apx;py=apy;k++;
		if(ck<nz-1) {ck++;ijk+=inc2;} else {ck=0;ijk+=inc2-nxyz;pz+=sz;}
		return true;
	} else return false;
}

// Assembly:
movl 0x30(%rdi), %eax
cmpl 0xfc(%rdi), %eax
jge 0x2edc7
incl %eax
movl %eax, 0x30(%rdi)
movl (%rdi), %eax
movl 0x110(%rdi), %ecx
leal -0x1(%rax), %edx
cmpl %edx, %ecx
jge 0x2ee22
incl %ecx
movl %ecx, 0x110(%rdi)
incl 0x3c(%rdi)
jmp 0x2ef11
movl 0x34(%rdi), %eax
cmpl 0x104(%rdi), %eax
jge 0x2ee50
movl 0xf8(%rdi), %ecx
movl %ecx, 0x30(%rdi)
movl 0x11c(%rdi), %ecx
movl %ecx, 0x110(%rdi)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, 0x98(%rdi)
incl %eax
movl %eax, 0x34(%rdi)
movl 0x114(%rdi), %eax
movl 0x4(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x2eeb6
incl %eax
movl %eax, 0x114(%rdi)
movl 0x128(%rdi), %eax
jmp 0x2eeb1
movl $0x0, 0x110(%rdi)
movl 0x3c(%rdi), %ecx
subl %eax, %ecx
incl %ecx
movl %ecx, 0x3c(%rdi)
movsd 0x60(%rdi), %xmm0
addsd 0x98(%rdi), %xmm0
movsd %xmm0, 0x98(%rdi)
jmp 0x2ef11
movl 0x38(%rdi), %eax
cmpl 0x10c(%rdi), %eax
jge 0x2eee3
movl 0xf8(%rdi), %ecx
movl %ecx, 0x30(%rdi)
movl 0x100(%rdi), %ecx
movl %ecx, 0x34(%rdi)
movq 0x11c(%rdi), %rcx
movq %rcx, 0x110(%rdi)
movupd 0xb0(%rdi), %xmm0
movupd %xmm0, 0x98(%rdi)
incl %eax
movl %eax, 0x38(%rdi)
movl 0x118(%rdi), %eax
movl 0x8(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x2eee6
incl %eax
movl %eax, 0x118(%rdi)
movl 0x12c(%rdi), %eax
addl %eax, 0x3c(%rdi)
jmp 0x2ef11
movl $0x0, 0x114(%rdi)
movl 0x128(%rdi), %eax
subl 0xc(%rdi), %eax
addl %eax, 0x3c(%rdi)
movsd 0x68(%rdi), %xmm0
addsd 0xa0(%rdi), %xmm0
movsd %xmm0, 0xa0(%rdi)
jmp 0x2ef11
xorl %eax, %eax
retq
movl $0x0, 0x118(%rdi)
movl 0x12c(%rdi), %eax
subl 0x10(%rdi), %eax
addl %eax, 0x3c(%rdi)
movsd 0x70(%rdi), %xmm0
addsd 0xa8(%rdi), %xmm0
movsd %xmm0, 0xa8(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::out_of_bounds()
bool c_loop_subset::out_of_bounds() {
	double *pp=p[ijk]+ps*q;
	if(mode==sphere) {
		double fx(*pp+px-v0),fy(pp[1]+py-v1),fz(pp[2]+pz-v2);
		return fx*fx+fy*fy+fz*fz>v3;
	} else {
		double f(*pp+px);if(f<v0||f>v1) return true;
		f=pp[1]+py;if(f<v2||f>v3) return true;
		f=pp[2]+pz;return f<v4||f>v5;
	}
}

// Assembly:
movq 0x18(%rdi), %rax
movslq 0x3c(%rdi), %rcx
movq (%rax,%rcx,8), %rcx
movslq 0x14(%rdi), %rax
movslq 0x40(%rdi), %rdx
imulq %rax, %rdx
cmpl $0x0, 0x44(%rdi)
movsd (%rcx,%rdx,8), %xmm0
addsd 0x98(%rdi), %xmm0
movsd 0xc8(%rdi), %xmm1
je 0x2efc1
ucomisd %xmm0, %xmm1
movb $0x1, %al
ja 0x2f010
ucomisd 0xd0(%rdi), %xmm0
ja 0x2f010
movsd 0x8(%rcx,%rdx,8), %xmm0
addsd 0xa0(%rdi), %xmm0
movsd 0xd8(%rdi), %xmm1
ucomisd %xmm0, %xmm1
ja 0x2f010
ucomisd 0xe0(%rdi), %xmm0
ja 0x2f010
movsd 0x10(%rcx,%rdx,8), %xmm0
addsd 0xa8(%rdi), %xmm0
movsd 0xf0(%rdi), %xmm1
cmpltpd %xmm0, %xmm1
movsd 0xe8(%rdi), %xmm2
cmpltpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movd %xmm0, %eax
jmp 0x2f010
subsd %xmm1, %xmm0
movsd 0x8(%rcx,%rdx,8), %xmm1
movsd 0x10(%rcx,%rdx,8), %xmm2
addsd 0xa0(%rdi), %xmm1
subsd 0xd0(%rdi), %xmm1
addsd 0xa8(%rdi), %xmm2
subsd 0xd8(%rdi), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
ucomisd 0xe0(%rdi), %xmm2
seta %al
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::setup_box(double, double, double, double, double, double, bool)
void c_loop_subset::setup_box(double xmin,double xmax,double ymin,double ymax,double zmin,double zmax,bool bounds_test) {
	if(bounds_test) {mode=box;v0=xmin;v1=xmax;v2=ymin;v3=ymax;v4=zmin;v5=zmax;} else mode=no_check;
	ai=step_int((xmin-ax)*xsp);
	bi=step_int((xmax-ax)*xsp);
	aj=step_int((ymin-ay)*ysp);
	bj=step_int((ymax-ay)*ysp);
	ak=step_int((zmin-az)*zsp);
	bk=step_int((zmax-az)*zsp);
	setup_common();
}

// Assembly:
movl $0x2, %eax
testl %esi, %esi
je 0x2f052
movsd %xmm0, 0xc8(%rdi)
movsd %xmm1, 0xd0(%rdi)
movsd %xmm2, 0xd8(%rdi)
movsd %xmm3, 0xe0(%rdi)
movsd %xmm4, 0xe8(%rdi)
movsd %xmm5, 0xf0(%rdi)
movl $0x1, %eax
movl %eax, 0x44(%rdi)
movupd 0x48(%rdi), %xmm7
movupd 0x58(%rdi), %xmm6
movupd 0x78(%rdi), %xmm8
movapd %xmm7, %xmm9
unpcklpd %xmm7, %xmm9            # xmm9 = xmm9[0],xmm7[0]
unpckhpd %xmm7, %xmm7            # xmm7 = xmm7[1,1]
movapd %xmm8, %xmm10
unpckhpd %xmm8, %xmm10           # xmm10 = xmm10[1],xmm8[1]
unpcklpd %xmm8, %xmm8            # xmm8 = xmm8[0,0]
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
subpd %xmm9, %xmm0
mulpd %xmm8, %xmm0
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
subpd %xmm7, %xmm2
mulpd %xmm10, %xmm2
cvttpd2dq %xmm2, %xmm1
cvttpd2dq %xmm0, %xmm3
movupd 0x88(%rdi), %xmm7
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
xorpd %xmm1, %xmm1
cmpltpd %xmm1, %xmm2
cmpltpd %xmm1, %xmm0
shufps $0x88, %xmm2, %xmm0     # xmm0 = xmm0[0,2],xmm2[0,2]
paddd %xmm3, %xmm0
movdqu %xmm0, 0xf8(%rdi)
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
subpd %xmm6, %xmm4
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
mulpd %xmm4, %xmm7
cvttpd2dq %xmm7, %xmm0
cmpltpd %xmm1, %xmm7
shufps $0xe8, %xmm7, %xmm7     # xmm7 = xmm7[0,2,2,3]
paddd %xmm0, %xmm7
movq %xmm7, 0x108(%rdi)
jmp 0x2ea40
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::particle_order::add_ordering_memory()
void particle_order::add_ordering_memory() {
	int *no=new int[size<<2],*nop=no,*opp=o;
	while(opp<op) *(nop++)=*(opp++);
	delete [] o;
	size<<=1;o=no;op=nop;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
leal (,%r15,4), %eax
cltq
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %r14, %r12
cmpq %rax, %rdi
jae 0x2f160
movq %rdi, %rcx
movq %r14, %r12
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
cmpq %rax, %rcx
jb 0x2f14d
testq %rdi, %rdi
je 0x2f16e
callq 0x2180
movl 0x10(%rbx), %r15d
addl %r15d, %r15d
movl %r15d, 0x10(%rbx)
movq %r14, (%rbx)
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_base.cc
// Function: voro::voro_base::compute_minimum(double&, double&, double&, double&, double&, double&, double&, int, int, int)
void voro_base::compute_minimum(double &minr,double &xlo,double &xhi,double &ylo,double &yhi,double &zlo,double &zhi,int ti,int tj,int tk) {
	double radsq,temp;
	if(ti>0) {temp=boxx*ti-xhi;radsq=temp*temp;}
	else if(ti<0) {temp=xlo-boxx*(1+ti);radsq=temp*temp;}
	else radsq=0;

	if(tj>0) {temp=boxy*tj-yhi;radsq+=temp*temp;}
	else if(tj<0) {temp=ylo-boxy*(1+tj);radsq+=temp*temp;}

	if(tk>0) {temp=boxz*tk-zhi;radsq+=temp*temp;}
	else if(tk<0) {temp=zlo-boxz*(1+tk);radsq+=temp*temp;}

	if(radsq<minr) minr=radsq;
}

// Assembly:
movl 0x20(%rsp), %r10d
movl 0x18(%rsp), %eax
testl %eax, %eax
jle 0x2f6ca
cvtsi2sd %eax, %xmm0
mulsd 0x18(%rdi), %xmm0
subsd (%rcx), %xmm0
mulsd %xmm0, %xmm0
jmp 0x2f6d4
xorpd %xmm0, %xmm0
js 0x2f773
movl 0x28(%rsp), %eax
testl %r10d, %r10d
jle 0x2f6f9
xorps %xmm1, %xmm1
cvtsi2sd %r10d, %xmm1
mulsd 0x20(%rdi), %xmm1
subsd (%r9), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x2f71c
jns 0x2f71c
incl %r10d
xorps %xmm1, %xmm1
cvtsi2sd %r10d, %xmm1
mulsd 0x20(%rdi), %xmm1
movsd (%r8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
testl %eax, %eax
jle 0x2f73f
movq 0x10(%rsp), %rcx
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
subsd (%rcx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x2f764
jns 0x2f764
movq 0x8(%rsp), %rcx
incl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
movsd (%rcx), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
movsd (%rsi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2f772
movsd %xmm0, (%rsi)
retq
movsd (%rdx), %xmm0
incl %eax
cvtsi2sd %eax, %xmm1
mulsd 0x18(%rdi), %xmm1
subsd %xmm1, %xmm0
jmp 0x2f6c4
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/v_base.cc
// Function: voro::voro_base::contains_neighbor(char const*)
bool voro_base::contains_neighbor(const char *format) {
	char *fmp=(const_cast<char*>(format));

	// Check to see if "%n" appears in the format sequence
	while(*fmp!=0) {
		if(*fmp=='%') {
			fmp++;
			if(*fmp=='n') return true;
			else if(*fmp==0) return false;
		}
		fmp++;
	}

	return false;
}

// Assembly:
movzbl (%rsi), %eax
cmpl $0x25, %eax
je 0x2f79a
testl %eax, %eax
jne 0x2f7aa
jmp 0x2f7af
movzbl 0x1(%rsi), %eax
testl %eax, %eax
je 0x2f7af
cmpl $0x6e, %eax
je 0x2f7b2
incq %rsi
incq %rsi
jmp 0x2f78c
xorl %eax, %eax
retq
movb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_sphere::cut_cell_base<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&, double, double, double)
bool wall_sphere::cut_cell_base(v_cell &c,double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc,dq=xd*xd+yd*yd+zd*zd;
	if (dq>1e-5) {
		dq=2*(sqrt(dq)*rc-dq);
		return c.nplane(xd,yd,zd,dq,w_id);
	}
	return true;
}

// Assembly:
subsd 0x10(%rdi), %xmm0
subsd 0x18(%rdi), %xmm1
subsd 0x20(%rdi), %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm3, %xmm5
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
ucomisd 0xdb87(%rip), %xmm4     # 0x3d540
jbe 0x2f9da
xorps %xmm3, %xmm3
sqrtsd %xmm4, %xmm3
mulsd 0x28(%rdi), %xmm3
subsd %xmm4, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%rdi), %edx
movq %rsi, %rdi
jmp 0xe636
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_cylinder::cut_cell_base<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&, double, double, double)
bool wall_cylinder::cut_cell_base(v_cell &c,double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xd*xa+yd*ya+zd*za)*asi;
	xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
	pa=xd*xd+yd*yd+zd*zd;
	if(pa>1e-5) {
		pa=2*(sqrt(pa)*rc-pa);
		return c.nplane(xd,yd,zd,pa,w_id);
	}
	return true;
}

// Assembly:
subsd 0x10(%rdi), %xmm0
subsd 0x18(%rdi), %xmm1
subsd 0x20(%rdi), %xmm2
movsd 0x28(%rdi), %xmm3
movsd 0x30(%rdi), %xmm4
movapd %xmm1, %xmm5
mulsd %xmm4, %xmm5
movapd %xmm0, %xmm6
mulsd %xmm3, %xmm6
addsd %xmm5, %xmm6
movsd 0x38(%rdi), %xmm5
movapd %xmm2, %xmm7
mulsd %xmm5, %xmm7
addsd %xmm6, %xmm7
mulsd 0x40(%rdi), %xmm7
mulsd %xmm7, %xmm3
subsd %xmm3, %xmm0
mulsd %xmm7, %xmm4
subsd %xmm4, %xmm1
mulsd %xmm5, %xmm7
subsd %xmm7, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm3, %xmm5
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
ucomisd 0xd9ab(%rip), %xmm4     # 0x3d540
jbe 0x2fbb6
xorps %xmm3, %xmm3
sqrtsd %xmm4, %xmm3
mulsd 0x48(%rdi), %xmm3
subsd %xmm4, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%rdi), %edx
movq %rsi, %rdi
jmp 0xe636
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_cone::cut_cell_base<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&, double, double, double)
bool wall_cone::cut_cell_base(v_cell &c,double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc,xf,yf,zf,q,pa=(xd*xa+yd*ya+zd*za)*asi;
	xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
	pa=xd*xd+yd*yd+zd*zd;
	if(pa>1e-5) {
		pa=1/sqrt(pa);
		q=sqrt(asi);
		xf=-sang*q*xa+cang*pa*xd;
		yf=-sang*q*ya+cang*pa*yd;
		zf=-sang*q*za+cang*pa*zd;
		pa=2*(xf*(xc-x)+yf*(yc-y)+zf*(zc-z));
		return c.nplane(xf,yf,zf,pa,w_id);
	}
	return true;
}

// Assembly:
movapd %xmm2, %xmm6
movapd %xmm1, %xmm7
movapd %xmm0, %xmm8
movapd %xmm0, %xmm11
subsd 0x10(%rdi), %xmm11
movapd %xmm1, %xmm10
subsd 0x18(%rdi), %xmm10
movapd %xmm2, %xmm9
subsd 0x20(%rdi), %xmm9
movsd 0x28(%rdi), %xmm1
movsd 0x30(%rdi), %xmm2
movapd %xmm10, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm11, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd 0x38(%rdi), %xmm4
movapd %xmm9, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm3, %xmm5
movsd 0x40(%rdi), %xmm0
mulsd %xmm0, %xmm5
mulsd %xmm5, %xmm1
subsd %xmm1, %xmm11
mulsd %xmm5, %xmm2
subsd %xmm2, %xmm10
mulsd %xmm4, %xmm5
subsd %xmm5, %xmm9
movapd %xmm10, %xmm1
mulsd %xmm10, %xmm1
movapd %xmm11, %xmm2
mulsd %xmm11, %xmm2
addsd %xmm1, %xmm2
movapd %xmm9, %xmm1
mulsd %xmm9, %xmm1
addsd %xmm2, %xmm1
ucomisd 0xd6f6(%rip), %xmm1     # 0x3d540
jbe 0x2fe79
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
sqrtsd %xmm1, %xmm1
movsd 0x71a3(%rip), %xmm3     # 0x37008
divsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2fe7c
sqrtsd %xmm0, %xmm0
jmp 0x2fedb
movb $0x1, %al
retq
movsd %xmm6, 0x30(%rsp)
movsd %xmm7, 0x28(%rsp)
movsd %xmm8, 0x20(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm3, (%rsp)
callq 0x20f0
movsd (%rsp), %xmm3
movsd 0x8(%rsp), %xmm11
movsd 0x10(%rsp), %xmm10
movsd 0x18(%rsp), %xmm9
movsd 0x20(%rsp), %xmm8
movsd 0x28(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
movsd 0x50(%r14), %xmm2
xorpd 0x7157(%rip), %xmm2     # 0x37040
mulsd %xmm0, %xmm2
mulsd 0x58(%r14), %xmm3
mulsd %xmm3, %xmm11
movsd 0x28(%r14), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm11, %xmm0
mulsd %xmm3, %xmm10
movsd 0x30(%r14), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm10, %xmm1
mulsd %xmm3, %xmm9
mulsd 0x38(%r14), %xmm2
addsd %xmm9, %xmm2
movsd 0x10(%r14), %xmm4
subsd %xmm8, %xmm4
movsd 0x18(%r14), %xmm3
subsd %xmm7, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x20(%r14), %xmm3
subsd %xmm6, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%r14), %edx
movq %rbx, %rdi
movq %rbx, %rsi
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0xe636
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::~pre_container_base()
pre_container_base::~pre_container_base() {
	delete [] *end_p;
	delete [] *end_id;
	while (end_id!=pre_id) {
		end_p--;
		delete [] *end_p;
		end_id--;
		delete [] *end_id;
	}
	delete [] pre_p;
	delete [] pre_id;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x30127
callq 0x2180
movq 0x48(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3013c
callq 0x2180
movq 0x48(%rbx), %rax
movq 0x40(%rbx), %rdi
cmpq %rdi, %rax
je 0x30189
movq 0x70(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x70(%rbx)
movq -0x8(%rcx), %rdi
testq %rdi, %rdi
je 0x30163
callq 0x2180
movq 0x48(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq -0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3017d
callq 0x2180
movq 0x48(%rbx), %rcx
movq 0x40(%rbx), %rdi
movq %rcx, %rax
cmpq %rdi, %rcx
jne 0x30145
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x3019e
movq %rax, %rdi
callq 0x2180
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x301a9
popq %rbx
jmp 0x2180
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::guess_optimal(int&, int&, int&)
void pre_container_base::guess_optimal(int &nx,int &ny,int &nz) {
	double dx=bx-ax,dy=by-ay,dz=bz-az;
	double ilscale=pow(total_particles()/(optimal_particles*dx*dy*dz),1/3.0);
	nx=int(dx*ilscale+1);
	ny=int(dy*ilscale+1);
	nz=int(dz*ilscale+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movsd 0x8(%rdi), %xmm1
movsd 0x18(%rdi), %xmm0
subsd (%rdi), %xmm1
movapd %xmm1, %xmm4
movsd %xmm1, 0x8(%rsp)
subsd 0x10(%rdi), %xmm0
movapd %xmm0, %xmm3
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rdi), %xmm0
subsd 0x20(%rdi), %xmm0
movapd %xmm0, %xmm2
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rdi), %rax
movl 0x40(%rdi), %ecx
movq 0x58(%rdi), %rdx
subq (%rax), %rdx
subl %ecx, %eax
shll $0x7, %eax
shrq $0x2, %rdx
addl %eax, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd 0xd387(%rip), %xmm1     # 0x3d5a8
mulsd %xmm4, %xmm1
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xd377(%rip), %xmm1     # 0x3d5b0
callq 0x2220
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x6db8(%rip), %xmm1     # 0x37008
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, (%r15)
movsd 0x10(%rsp), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, (%r14)
movsd 0x18(%rsp), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container::put(int, double, double, double)
void pre_container::put(int n,double x,double y,double z) {
	if((xperiodic||(x>=ax&&x<=bx))&&(yperiodic||(y>=ay&&y<=by))&&(zperiodic||(z>=az&&z<=bz))) {
		if(ch_id==e_id) new_chunk();
		*(ch_id++)=n;
		*(ch_p++)=x;*(ch_p++)=y;*(ch_p++)=z;
	}
#if VOROPP_REPORT_OUT_OF_BOUNDS ==1
	else fprintf(stderr,"Out of bounds: (x,y,z)=(%g,%g,%g)\n",x,y,z);
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x302b8
ucomisd (%rbx), %xmm0
jb 0x30344
movsd 0x8(%rbx), %xmm3
ucomisd %xmm0, %xmm3
jb 0x30344
cmpb $0x0, 0x31(%rbx)
jne 0x302d0
ucomisd 0x10(%rbx), %xmm1
jb 0x30344
movsd 0x18(%rbx), %xmm3
ucomisd %xmm1, %xmm3
jb 0x30344
cmpb $0x0, 0x32(%rbx)
jne 0x302e8
ucomisd 0x20(%rbx), %xmm2
jb 0x30344
movsd 0x28(%rbx), %xmm3
ucomisd %xmm2, %xmm3
jb 0x30344
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x30320
movq %rbx, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x3034c
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movq 0x58(%rbx), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x58(%rbx)
movl %ebp, (%rax)
movq 0x78(%rbx), %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x78(%rbx)
movsd %xmm2, 0x10(%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::new_chunk()
void pre_container_base::new_chunk() {
	end_id++;end_p++;
	if(end_id==l_id) extend_chunk_index();
	ch_id=*end_id=new int[pre_container_chunk_size];
	e_id=ch_id+pre_container_chunk_size;
	ch_p=*end_p=new double[ps*pre_container_chunk_size];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
addq $0x8, %r14
movq %r14, 0x48(%rdi)
addq $0x8, 0x70(%rdi)
cmpq 0x50(%rdi), %r14
je 0x303b6
movl $0x1000, %edi           # imm = 0x1000
callq 0x2030
movq %rax, (%r14)
movq %rax, 0x58(%rbx)
addq $0x1000, %rax           # imm = 0x1000
movq %rax, 0x60(%rbx)
movslq 0x34(%rbx), %rax
movq %rax, %rcx
shlq $0xd, %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq 0x70(%rbx), %rcx
movq %rax, (%rcx)
movq %rax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x31b2
movq 0x48(%rbx), %r14
jmp 0x3036a
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_poly::put(int, double, double, double, double)
void pre_container_poly::put(int n,double x,double y,double z,double r) {
	if((xperiodic||(x>=ax&&x<=bx))&&(yperiodic||(y>=ay&&y<=by))&&(zperiodic||(z>=az&&z<=bz))) {
		if(ch_id==e_id) new_chunk();
		*(ch_id++)=n;
		*(ch_p++)=x;*(ch_p++)=y;*(ch_p++)=z;*(ch_p++)=r;
	}
#if VOROPP_REPORT_OUT_OF_BOUNDS ==1
	else fprintf(stderr,"Out of bounds: (x,y,z)=(%g,%g,%g)\n",x,y,z);
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x303ee
ucomisd (%rbx), %xmm0
jb 0x30495
movsd 0x8(%rbx), %xmm4
ucomisd %xmm0, %xmm4
jb 0x30495
cmpb $0x0, 0x31(%rbx)
jne 0x3040e
ucomisd 0x10(%rbx), %xmm1
jb 0x30495
movsd 0x18(%rbx), %xmm4
ucomisd %xmm1, %xmm4
jb 0x30495
cmpb $0x0, 0x32(%rbx)
jne 0x30426
ucomisd 0x20(%rbx), %xmm2
jb 0x30495
movsd 0x28(%rbx), %xmm4
ucomisd %xmm2, %xmm4
jb 0x30495
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x3046c
movq %rbx, %rdi
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x3034c
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movq 0x58(%rbx), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x58(%rbx)
movl %ebp, (%rax)
movq 0x78(%rbx), %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
movsd %xmm2, 0x10(%rax)
leaq 0x20(%rax), %rcx
movq %rcx, 0x78(%rbx)
movsd %xmm3, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container::setup(voro::container&)
void pre_container::setup(container &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
			con.put(n,x,y,z);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
		con.put(n,x,y,z);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r13
movq 0x40(%rdi), %r12
movq 0x68(%rdi), %r15
cmpq 0x48(%rdi), %r12
jae 0x3050c
movq %r13, (%rsp)
movq (%r12), %r13
movq (%r15), %rbp
movq $-0x4, %r14
movl 0x4(%r13,%r14), %esi
movsd (%rbp), %xmm0
movsd 0x8(%rbp), %xmm1
movsd 0x10(%rbp), %xmm2
addq $0x18, %rbp
movq %rbx, %rdi
callq 0x13e86
addq $0x4, %r14
cmpq $0xffc, %r14            # imm = 0xFFC
jb 0x304cd
addq $0x8, %r12
addq $0x8, %r15
movq (%rsp), %r13
cmpq 0x48(%r13), %r12
jb 0x304bf
movq (%r12), %r12
cmpq 0x58(%r13), %r12
jae 0x30544
movq (%r15), %r14
movl (%r12), %esi
addq $0x4, %r12
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x10(%r14), %xmm2
addq $0x18, %r14
movq %rbx, %rdi
callq 0x13e86
cmpq 0x58(%r13), %r12
jb 0x30519
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_poly::setup(voro::container_poly&)
void pre_container_poly::setup(container_poly &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z,r;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);r=*(pp++);
			con.put(n,x,y,z,r);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);r=*(pp++);
		con.put(n,x,y,z,r);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %r12
movq 0x68(%rdi), %r15
cmpq 0x48(%rdi), %r12
jae 0x305cd
movq %r14, (%rsp)
movq (%r12), %r13
movq (%r15), %rbp
movq $-0x4, %r14
movl 0x4(%r13,%r14), %esi
movsd 0x20(%rbp,%r14,8), %xmm0
movsd 0x28(%rbp,%r14,8), %xmm1
movsd 0x30(%rbp,%r14,8), %xmm2
movsd 0x38(%rbp,%r14,8), %xmm3
movq %rbx, %rdi
callq 0x13f60
addq $0x4, %r14
cmpq $0xffc, %r14            # imm = 0xFFC
jb 0x30585
addq $0x8, %r12
addq $0x8, %r15
movq (%rsp), %r14
cmpq 0x48(%r14), %r12
jb 0x30577
movq (%r12), %r12
cmpq 0x58(%r14), %r12
jae 0x3060b
movq (%r15), %r15
movl (%r12), %esi
addq $0x4, %r12
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
movsd 0x18(%r15), %xmm3
addq $0x20, %r15
movq %rbx, %rdi
callq 0x13f60
cmpq 0x58(%r14), %r12
jb 0x305da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container::setup(voro::particle_order&, voro::container&)
void pre_container::setup(particle_order &vo,container &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
			con.put(vo,n,x,y,z);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
		con.put(vo,n,x,y,z);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x40(%rdi), %r13
movq 0x68(%rdi), %rax
cmpq 0x48(%rdi), %r13
jae 0x306a2
movq %r12, 0x8(%rsp)
movq (%r13), %rbp
movq %rax, 0x10(%rsp)
movq (%rax), %r15
movq $-0x4, %r12
movl 0x4(%rbp,%r12), %edx
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
addq $0x18, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1402a
addq $0x4, %r12
cmpq $0xffc, %r12            # imm = 0xFFC
jb 0x30657
addq $0x8, %r13
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %r12
cmpq 0x48(%r12), %r13
jb 0x30644
movq (%r13), %r13
cmpq 0x58(%r12), %r13
jae 0x306df
movq (%rax), %r15
movl (%r13), %edx
addq $0x4, %r13
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movsd 0x10(%r15), %xmm2
addq $0x18, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1402a
cmpq 0x58(%r12), %r13
jb 0x306b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_poly::setup(voro::particle_order&, voro::container_poly&)
void pre_container_poly::setup(particle_order &vo,container_poly &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z,r;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);r=*(pp++);
			con.put(vo,n,x,y,z,r);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);r=*(pp++);
		con.put(vo,n,x,y,z,r);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rdi), %r13
movq 0x68(%rdi), %rax
cmpq 0x48(%rdi), %r13
jae 0x3077c
movq %r15, 0x8(%rsp)
movq (%r13), %rbp
movq %rax, 0x10(%rsp)
movq (%rax), %r15
movq $-0x4, %r12
movl 0x4(%rbp,%r12), %edx
movsd 0x20(%r15,%r12,8), %xmm0
movsd 0x28(%r15,%r12,8), %xmm1
movsd 0x30(%r15,%r12,8), %xmm2
movsd 0x38(%r15,%r12,8), %xmm3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14112
addq $0x4, %r12
cmpq $0xffc, %r12            # imm = 0xFFC
jb 0x3072b
addq $0x8, %r13
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %r15
cmpq 0x48(%r15), %r13
jb 0x30718
movq (%r13), %r13
cmpq 0x58(%r15), %r13
jae 0x307c1
movq (%rax), %r12
movl (%r13), %edx
addq $0x4, %r13
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
movsd 0x18(%r12), %xmm3
addq $0x20, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14112
cmpq 0x58(%r15), %r13
jb 0x30789
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq