LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: voro::wall_cone::point_inside(double, double, double)
bool wall_cone::point_inside(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*=gra;
	if (pa<0) return false;
	pa*=pa;
	return xd*xd+yd*yd+zd*zd<pa;
}

// Assembly:
subsd 0x10(%rdi), %xmm0
subsd 0x18(%rdi), %xmm1
subsd 0x20(%rdi), %xmm2
movsd 0x28(%rdi), %xmm3
movsd 0x30(%rdi), %xmm5
movapd %xmm1, %xmm4
mulsd %xmm5, %xmm4
movapd %xmm0, %xmm8
mulsd %xmm3, %xmm8
addsd %xmm4, %xmm8
movsd 0x38(%rdi), %xmm7
movapd %xmm2, %xmm6
mulsd %xmm7, %xmm6
addsd %xmm8, %xmm6
mulsd 0x40(%rdi), %xmm6
movsd 0x48(%rdi), %xmm4
mulsd %xmm6, %xmm4
xorpd %xmm8, %xmm8
ucomisd %xmm4, %xmm8
jbe 0x2f2cb
xorl %eax, %eax
retq
mulsd %xmm6, %xmm7
subsd %xmm7, %xmm2
mulsd %xmm6, %xmm5
subsd %xmm5, %xmm1
mulsd %xmm6, %xmm3
subsd %xmm3, %xmm0
mulsd %xmm4, %xmm4
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
ucomisd %xmm2, %xmm4
seta %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movapd %xmm0, %xmm4
subsd 0x10(%rdi), %xmm4
subsd 0x18(%rdi), %xmm1
subsd 0x20(%rdi), %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movapd %xmm4, %xmm3
mulsd %xmm4, %xmm3
addsd %xmm0, %xmm3
movapd %xmm2, %xmm5
mulsd %xmm2, %xmm5
addsd %xmm3, %xmm5
ucomisd 0xe0af(%rip), %xmm5     # 0x3d4b0
jbe 0x2f423
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, %r14
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jb 0x2f426
xorps %xmm3, %xmm3
sqrtsd %xmm5, %xmm3
jmp 0x2f463
movb $0x1, %al
retq
movapd %xmm5, %xmm0
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x20f0
movsd 0x8(%rsp), %xmm5
movsd 0x10(%rsp), %xmm4
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movapd %xmm0, %xmm3
mulsd 0x28(%rbx), %xmm3
subsd %xmm5, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%rbx), %edx
movq %r14, %rdi
movq %r14, %rsi
movapd %xmm4, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xe6fa
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movapd %xmm0, %xmm7
subsd 0x10(%rdi), %xmm7
subsd 0x18(%rdi), %xmm1
subsd 0x20(%rdi), %xmm2
movsd 0x28(%rdi), %xmm0
movsd 0x30(%rdi), %xmm6
movapd %xmm1, %xmm4
mulsd %xmm6, %xmm4
movapd %xmm7, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
movsd 0x38(%rdi), %xmm5
movapd %xmm2, %xmm4
mulsd %xmm5, %xmm4
addsd %xmm3, %xmm4
mulsd 0x40(%rdi), %xmm4
mulsd %xmm4, %xmm0
subsd %xmm0, %xmm7
mulsd %xmm4, %xmm6
subsd %xmm6, %xmm1
mulsd %xmm5, %xmm4
subsd %xmm4, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movapd %xmm7, %xmm3
mulsd %xmm7, %xmm3
addsd %xmm0, %xmm3
movapd %xmm2, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm3, %xmm4
ucomisd 0xde01(%rip), %xmm4     # 0x3d4b0
jbe 0x2f6d1
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm4
jb 0x2f6d4
xorps %xmm3, %xmm3
sqrtsd %xmm4, %xmm3
jmp 0x2f711
movb $0x1, %al
retq
movapd %xmm4, %xmm0
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
callq 0x20f0
movsd 0x8(%rsp), %xmm4
movsd 0x10(%rsp), %xmm7
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movapd %xmm0, %xmm3
mulsd 0x48(%r14), %xmm3
subsd %xmm4, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%r14), %edx
movq %rbx, %rdi
movq %rbx, %rsi
movapd %xmm7, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xe6fa
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %xmm0, %xmm7
movapd %xmm0, %xmm10
subsd 0x10(%rdi), %xmm10
movapd %xmm1, %xmm9
subsd 0x18(%rdi), %xmm9
movapd %xmm2, %xmm8
subsd 0x20(%rdi), %xmm8
movsd 0x28(%rdi), %xmm0
movsd 0x30(%rdi), %xmm6
movapd %xmm9, %xmm4
mulsd %xmm6, %xmm4
movapd %xmm10, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
movsd 0x38(%rdi), %xmm5
movapd %xmm8, %xmm4
mulsd %xmm5, %xmm4
addsd %xmm3, %xmm4
mulsd 0x40(%rdi), %xmm4
mulsd %xmm4, %xmm0
subsd %xmm0, %xmm10
mulsd %xmm4, %xmm6
subsd %xmm6, %xmm9
mulsd %xmm5, %xmm4
subsd %xmm4, %xmm8
movapd %xmm9, %xmm0
mulsd %xmm9, %xmm0
movapd %xmm10, %xmm3
mulsd %xmm10, %xmm3
addsd %xmm0, %xmm3
movapd %xmm8, %xmm0
mulsd %xmm8, %xmm0
addsd %xmm3, %xmm0
ucomisd 0xdaed(%rip), %xmm0     # 0x3d4b0
jbe 0x2fa08
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm7, 0x18(%rsp)
movsd %xmm8, 0x10(%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm10, (%rsp)
jb 0x2fa0b
sqrtsd %xmm0, %xmm0
jmp 0x2fa14
movb $0x1, %al
retq
callq 0x20f0
xorpd %xmm3, %xmm3
movsd 0x75eb(%rip), %xmm8     # 0x37008
divsd %xmm0, %xmm8
movsd 0x40(%r14), %xmm0
ucomisd %xmm3, %xmm0
jb 0x2fa34
sqrtsd %xmm0, %xmm0
jmp 0x2fa47
movsd %xmm8, 0x30(%rsp)
callq 0x20f0
movsd 0x30(%rsp), %xmm8
movsd 0x28(%rsp), %xmm5
movsd 0x20(%rsp), %xmm6
movsd 0x18(%rsp), %xmm3
movsd 0x10(%rsp), %xmm4
movsd 0x8(%rsp), %xmm7
movsd (%rsp), %xmm1
movsd 0x50(%r14), %xmm2
xorpd 0x75b8(%rip), %xmm2     # 0x37030
mulsd %xmm0, %xmm2
mulsd 0x58(%r14), %xmm8
mulsd %xmm8, %xmm1
movsd 0x28(%r14), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm8, %xmm7
movsd 0x30(%r14), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm7, %xmm1
mulsd %xmm8, %xmm4
mulsd 0x38(%r14), %xmm2
addsd %xmm4, %xmm2
movsd 0x10(%r14), %xmm4
subsd %xmm3, %xmm4
movsd 0x18(%r14), %xmm3
subsd %xmm6, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd 0x20(%r14), %xmm3
subsd %xmm5, %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 0xe6fa
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fcb3
callq 0x2180
movq 0x48(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2fcc4
callq 0x2180
movq 0x48(%rbx), %rax
cmpq 0x40(%rbx), %rax
je 0x2fcfa
movq 0x70(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq -0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2fce8
callq 0x2180
movq 0x48(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq -0x8(%rax), %rdi
jmp 0x2fcba
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x2fd08
callq 0x2180
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2fd17
popq %rbx
jmp 0x2180
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd789(%rip), %xmm1     # 0x3d518
mulsd %xmm4, %xmm1
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xd779(%rip), %xmm1     # 0x3d520
callq 0x2220
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x724a(%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_O1/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 0x2fe26
ucomisd (%rbx), %xmm0
jb 0x2feca
movsd 0x8(%rbx), %xmm3
ucomisd %xmm0, %xmm3
jb 0x2feca
cmpb $0x0, 0x31(%rbx)
jne 0x2fe46
ucomisd 0x10(%rbx), %xmm1
jb 0x2feca
movsd 0x18(%rbx), %xmm3
ucomisd %xmm1, %xmm3
jb 0x2feca
cmpb $0x0, 0x32(%rbx)
jne 0x2fe5e
ucomisd 0x20(%rbx), %xmm2
jb 0x2feca
movsd 0x28(%rbx), %xmm3
ucomisd %xmm2, %xmm3
jb 0x2feca
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x2fe92
movq %rbx, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x2fed2
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
leaq 0x8(%rax), %rcx
movq %rcx, 0x78(%rbx)
movsd %xmm0, (%rax)
leaq 0x10(%rax), %rcx
movq %rcx, 0x78(%rbx)
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_O1/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 %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rax
addq $0x8, %rax
movq %rax, 0x48(%rdi)
addq $0x8, 0x70(%rdi)
cmpq 0x50(%rdi), %rax
je 0x2ff37
movl $0x1000, %edi           # imm = 0x1000
callq 0x2030
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
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)
popq %rbx
retq
movq %rbx, %rdi
callq 0x3132
jmp 0x2feed
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ff6c
ucomisd (%rbx), %xmm0
jb 0x30033
movsd 0x8(%rbx), %xmm4
ucomisd %xmm0, %xmm4
jb 0x30033
cmpb $0x0, 0x31(%rbx)
jne 0x2ff8c
ucomisd 0x10(%rbx), %xmm1
jb 0x30033
movsd 0x18(%rbx), %xmm4
ucomisd %xmm1, %xmm4
jb 0x30033
cmpb $0x0, 0x32(%rbx)
jne 0x2ffac
ucomisd 0x20(%rbx), %xmm2
jb 0x30033
movsd 0x28(%rbx), %xmm4
ucomisd %xmm2, %xmm4
jb 0x30033
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x2ffee
movq %rbx, %rdi
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x2fed2
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
leaq 0x8(%rax), %rcx
movq %rcx, 0x78(%rbx)
movsd %xmm0, (%rax)
leaq 0x10(%rax), %rcx
movq %rcx, 0x78(%rbx)
movsd %xmm1, 0x8(%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x78(%rbx)
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_O1/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 0x300aa
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 0x13b94
addq $0x4, %r14
cmpq $0xffc, %r14            # imm = 0xFFC
jb 0x3006b
addq $0x8, %r12
addq $0x8, %r15
movq (%rsp), %r13
cmpq 0x48(%r13), %r12
jb 0x3005d
movq (%r12), %r12
cmpq 0x58(%r13), %r12
jae 0x300e2
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 0x13b94
cmpq 0x58(%r13), %r12
jb 0x300b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/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 0x3016b
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 0x13c6e
addq $0x4, %r14
cmpq $0xffc, %r14            # imm = 0xFFC
jb 0x30123
addq $0x8, %r12
addq $0x8, %r15
movq (%rsp), %r14
cmpq 0x48(%r14), %r12
jb 0x30115
movq (%r12), %r12
cmpq 0x58(%r14), %r12
jae 0x301a9
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 0x13c6e
cmpq 0x58(%r14), %r12
jb 0x30178
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30240
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 0x13d38
addq $0x4, %r12
cmpq $0xffc, %r12            # imm = 0xFFC
jb 0x301f5
addq $0x8, %r13
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %r12
cmpq 0x48(%r12), %r13
jb 0x301e2
movq (%r13), %r13
cmpq 0x58(%r12), %r13
jae 0x3027d
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 0x13d38
cmpq 0x58(%r12), %r13
jb 0x3024e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3031a
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 0x13e26
addq $0x4, %r12
cmpq $0xffc, %r12            # imm = 0xFFC
jb 0x302c9
addq $0x8, %r13
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %r15
cmpq 0x48(%r15), %r13
jb 0x302b6
movq (%r13), %r13
cmpq 0x58(%r15), %r13
jae 0x3035f
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 0x13e26
cmpq 0x58(%r15), %r13
jb 0x30327
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::~container_periodic_base()
container_periodic_base::~container_periodic_base() {
	for(int l=oxyz-1;l>=0;l--) if(mem[l]>0) {
		delete [] p[l];
		delete [] id[l];
	}
	delete [] img;
	delete [] mem;
	delete [] co;
	delete [] id;
	delete [] p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x198(%rdi), %r14
testq %r14, %r14
jle 0x3085c
incq %r14
movq 0x1b8(%rbx), %rax
cmpl $0x0, -0x8(%rax,%r14,4)
jle 0x30853
movq 0x1a8(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x3083d
callq 0x2180
movq 0x1a0(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x30853
callq 0x2180
decq %r14
cmpq $0x1, %r14
jg 0x30818
movq 0x1c0(%rbx), %rdi
testq %rdi, %rdi
je 0x3086d
callq 0x2180
movq 0x1b8(%rbx), %rdi
testq %rdi, %rdi
je 0x3087e
callq 0x2180
movq 0x1b0(%rbx), %rdi
testq %rdi, %rdi
je 0x3088f
callq 0x2180
movq 0x1a0(%rbx), %rdi
testq %rdi, %rdi
je 0x308a0
callq 0x2180
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x308b1
callq 0x2180
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x308c2
callq 0x2180
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6eca
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(int, double, double, double)
void container_periodic::put(int n,double x,double y,double z) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+3*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x10(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x8(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x3c(%rsp), %r14
movq %r14, %rsi
callq 0x30acc
movslq (%r14), %r14
movq 0x1b0(%rbx), %rax
movl (%rax,%r14,4), %ecx
testl %ecx, %ecx
jle 0x30a71
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r14,8), %rax
movl (%rax,%r12,4), %esi
movq (%rcx,%r14,8), %rdx
addq %r15, %rdx
movl %ebp, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0x13120
incq %r12
movq 0x1b0(%rbx), %rax
movslq (%rax,%r14,4), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x30a24
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r14,8), %rdx
movslq %ecx, %rcx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movslq (%rax,%r14,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r14,4)
leaq (%rdx,%rdx,2), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax,8)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax,8)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::put_locate_block(int&, double&, double&, double&)
void container_periodic_base::put_locate_block(int &ijk,double &x,double &y,double &z) {

	// Remap particle in the z direction if necessary
	int k=step_int(z*zsp);
	if(k<0||k>=nz) {
		int ak=step_div(k,nz);
		z-=ak*bz;y-=ak*byz;x-=ak*bxz;k-=ak*nz;
	}

	// Remap particle in the y direction if necessary
	int j=step_int(y*ysp);
	if(j<0||j>=ny) {
		int aj=step_div(j,ny);
		y-=aj*by;x-=aj*bxy;j-=aj*ny;
	}

	// Remap particle in the x direction if necessary
	ijk=step_int(x*xsp);
	if(ijk<0||ijk>=nx) {
		int ai=step_div(ijk,nx);
		x-=ai*bx;ijk-=ai*nx;
	}

	// Compute the block index and check memory allocation
	j+=ey;k+=ez;
	ijk+=nx*(j+oy*k);
	if(co[ijk]==mem[ijk]) add_particle_memory(ijk);
}

// Assembly:
movq %rdx, %r11
movsd (%r8), %xmm1
movsd 0x168(%rdi), %xmm2
mulsd %xmm1, %xmm2
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm2, %xmm0
seta %al
cvttsd2si %xmm2, %r9d
subl %eax, %r9d
setns %al
movl 0x130(%rdi), %r10d
cmpl %r10d, %r9d
setl %dl
testb %dl, %al
jne 0x30b69
testl %r9d, %r9d
js 0x30b17
movl %r9d, %eax
cltd
idivl %r10d
jmp 0x30b21
leal 0x1(%r9), %eax
cltd
idivl %r10d
decl %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movsd 0x28(%rdi), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, (%r8)
movsd (%rcx), %xmm1
movsd 0x20(%rdi), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, (%rcx)
movsd (%r11), %xmm1
mulsd 0x18(%rdi), %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, (%r11)
imull %eax, %r10d
subl %r10d, %r9d
movsd (%rcx), %xmm1
movsd 0x160(%rdi), %xmm2
mulsd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
seta %al
cvttsd2si %xmm2, %r10d
subl %eax, %r10d
setns %al
movl 0x12c(%rdi), %r8d
cmpl %r8d, %r10d
setl %dl
testb %dl, %al
jne 0x30be8
testl %r10d, %r10d
js 0x30bac
movl %r10d, %eax
cltd
idivl %r8d
jmp 0x30bb6
leal 0x1(%r10), %eax
cltd
idivl %r8d
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x10(%rdi), %xmm2
mulsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd %xmm1, (%rcx)
movsd (%r11), %xmm1
mulsd 0x8(%rdi), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%r11)
imull %eax, %r8d
subl %r8d, %r10d
movsd (%r11), %xmm0
movsd 0x158(%rdi), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %ecx
subl %eax, %ecx
movl %ecx, (%rsi)
setns %al
movl 0x128(%rdi), %r8d
cmpl %r8d, %ecx
setl %dl
testb %dl, %al
jne 0x30c54
testl %ecx, %ecx
js 0x30c2e
movl %ecx, %eax
cltd
idivl %r8d
jmp 0x30c37
leal 0x1(%rcx), %eax
cltd
idivl %r8d
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd (%rdi), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r11)
imull %eax, %r8d
subl %r8d, %ecx
movl %ecx, (%rsi)
addl 0x180(%rdi), %r10d
addl 0x184(%rdi), %r9d
imull 0x190(%rdi), %r9d
movslq 0x128(%rdi), %rax
addl %r10d, %r9d
movslq %r9d, %rcx
imulq %rax, %rcx
movslq (%rsi), %rax
addq %rcx, %rax
movl %eax, (%rsi)
movq 0x1b0(%rdi), %rcx
movq 0x1b8(%rdi), %rdx
movl (%rcx,%rax,4), %ecx
cmpl (%rdx,%rax,4), %ecx
jne 0x30ca0
movl %eax, %esi
jmp 0x3144a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(int, double, double, double, double)
void container_periodic_poly::put(int n,double x,double y,double z,double r) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+4*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+4*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
	if(max_radius<r) max_radius=r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movsd %xmm3, 0x18(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
movsd %xmm1, (%rcx)
movq %rsp, %r8
movsd %xmm2, (%r8)
leaq 0x3c(%rsp), %r14
movq %r14, %rsi
callq 0x30acc
movslq (%r14), %r14
movq 0x1b0(%rbx), %rax
movl (%rax,%r14,4), %ecx
testl %ecx, %ecx
jle 0x30d68
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r14,8), %rax
movl (%rax,%r12,4), %esi
movq (%rcx,%r14,8), %rdx
addq %r15, %rdx
movl %ebp, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0x13120
incq %r12
movq 0x1b0(%rbx), %rax
movslq (%rax,%r14,4), %rcx
addq $0x20, %r15
cmpq %rcx, %r12
jl 0x30d1b
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r14,8), %rdx
movslq %ecx, %rcx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movslq (%rax,%r14,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r14,4)
shlq $0x5, %rdx
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rdx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rdx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x30dd3
movsd %xmm0, 0x1d8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(int, double, double, double, int&, int&, int&)
void container_periodic::put(int n,double x,double y,double z,int &ai,int &aj,int &ak) {
	int ijk;
	put_locate_block(ijk,x,y,z,ai,aj,ak);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+3*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x10(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x8(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x3c(%rsp), %r14
movq %r14, %rsi
pushq %rax
pushq %r10
callq 0x30f0e
addq $0x10, %rsp
movslq (%r14), %r14
movq 0x1b0(%rbx), %rax
movl (%rax,%r14,4), %ecx
testl %ecx, %ecx
jle 0x30eb3
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r14,8), %rax
movl (%rax,%r12,4), %esi
movq (%rcx,%r14,8), %rdx
addq %r15, %rdx
movl %ebp, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0x13120
incq %r12
movq 0x1b0(%rbx), %rax
movslq (%rax,%r14,4), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x30e66
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r14,8), %rdx
movslq %ecx, %rcx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movslq (%rax,%r14,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r14,4)
leaq (%rdx,%rdx,2), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax,8)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax,8)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(int, double, double, double, double, int&, int&, int&)
void container_periodic_poly::put(int n,double x,double y,double z,double r,int &ai,int &aj,int &ak) {
	int ijk;
	put_locate_block(ijk,x,y,z,ai,aj,ak);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+4*l);

	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+4*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
	if(max_radius<r) max_radius=r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movsd %xmm3, 0x18(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
movsd %xmm1, (%rcx)
movq %rsp, %r8
movsd %xmm2, (%r8)
leaq 0x3c(%rsp), %r14
movq %r14, %rsi
pushq %rax
pushq %r10
callq 0x30f0e
addq $0x10, %rsp
movslq (%r14), %r14
movq 0x1b0(%rbx), %rax
movl (%rax,%r14,4), %ecx
testl %ecx, %ecx
jle 0x311f0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r14,8), %rax
movl (%rax,%r12,4), %esi
movq (%rcx,%r14,8), %rdx
addq %r15, %rdx
movl %ebp, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
callq 0x13120
incq %r12
movq 0x1b0(%rbx), %rax
movslq (%rax,%r14,4), %rcx
addq $0x20, %r15
cmpq %rcx, %r12
jl 0x311a3
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r14,8), %rdx
movslq %ecx, %rcx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movslq (%rax,%r14,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r14,4)
shlq $0x5, %rdx
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rdx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rdx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x3125b
movsd %xmm0, 0x1d8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(voro::particle_order&, int, double, double, double)
void container_periodic::put(particle_order &vo,int n,double x,double y,double z) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	id[ijk][co[ijk]]=n;
	vo.add(ijk,co[ijk]);
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x10(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x8(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x24(%rsp), %r15
movq %r15, %rsi
callq 0x30acc
movl (%r15), %eax
movslq %eax, %r15
movq 0x1a0(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movq (%rax,%r15,8), %rax
movslq (%rcx,%r15,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rcx,%r15,4), %ebp
movslq 0x10(%r14), %rax
shlq $0x2, %rax
addq (%r14), %rax
cmpq %rax, 0x8(%r14)
jne 0x312df
movq %r14, %rdi
callq 0x2eb52
movq 0x8(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %r15d, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %ebp, 0x4(%rax)
movq 0x1a8(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movq (%rax,%r15,8), %rax
movslq (%rcx,%r15,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%r15,4)
leaq (%rdx,%rdx,2), %rcx
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rcx,8)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax,%rcx,8)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(voro::particle_order&, int, double, double, double, double)
void container_periodic_poly::put(particle_order &vo,int n,double x,double y,double z,double r) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	id[ijk][co[ijk]]=n;
	vo.add(ijk,co[ijk]);
	double *pp=p[ijk]+4*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
	if(max_radius<r) max_radius=r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, (%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x10(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x8(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x24(%rsp), %r15
movq %r15, %rsi
callq 0x30acc
movl (%r15), %eax
movslq %eax, %r15
movq 0x1a0(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movq (%rax,%r15,8), %rax
movslq (%rcx,%r15,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rcx,%r15,4), %ebp
movslq 0x10(%r14), %rax
shlq $0x2, %rax
addq (%r14), %rax
cmpq %rax, 0x8(%r14)
jne 0x313c4
movq %r14, %rdi
callq 0x2eb52
movq 0x8(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %r15d, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %ebp, 0x4(%rax)
movq 0x1a8(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movq (%rax,%r15,8), %rax
movslq (%rcx,%r15,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%r15,4)
shlq $0x5, %rdx
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax,%rdx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rdx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax,%rdx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rax,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x3143f
movsd %xmm0, 0x1d8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::add_particle_memory(int)
void container_periodic_base::add_particle_memory(int i) {

	// Handle the case when no memory has been allocated for this block
	if(mem[i]==0) {
		mem[i]=init_mem;
		id[i]=new int[init_mem];
		p[i]=new double[ps*init_mem];
		return;
	}

	// Otherwise, double the memory allocation for this block. Carry out a
	// check on the memory allocation size, and print a status message if
	// requested.
	int l,nmem(mem[i]<<1);
	if(nmem>max_particle_memory)
		voro_fatal_error("Absolute maximum memory allocation exceeded",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=3
	fprintf(stderr,"Particle memory in region %d scaled up to %d\n",i,nmem);
#endif

	// Allocate new memory and copy in the contents of the old arrays
	int *idp=new int[nmem];
	for(l=0;l<co[i];l++) idp[l]=id[i][l];
	double *pp=new double[ps*nmem];
	for(l=0;l<ps*co[i];l++) pp[l]=p[i][l];

	// Update pointers and delete old arrays
	mem[i]=nmem;
	delete [] id[i];id[i]=idp;
	delete [] p[i];p[i]=pp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b8(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %ebp
testl %ebp, %ebp
je 0x31577
addl %ebp, %ebp
cmpl $0x1000001, %ebp        # imm = 0x1000001
jl 0x31489
leaq 0x7c88(%rip), %rdi      # 0x39107
movl $0x2, %esi
callq 0x1318d
movslq %ebp, %rdi
shlq $0x2, %rdi
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq 0x1b0(%rbx), %r13
cmpl $0x0, (%r13,%r12,4)
jle 0x314d9
movq 0x1a0(%rbx), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
movslq (%r13,%r12,4), %rdx
cmpq %rdx, %rcx
jl 0x314c5
movl 0x1cc(%rbx), %ebp
movl %ebp, %eax
imull 0x4(%rsp), %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
imull (%r13,%r12,4), %ebp
testl %ebp, %ebp
jle 0x3152a
movq 0x1a8(%rbx), %rax
movq (%rax,%r12,8), %rax
movl %ebp, %ecx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x31517
movq 0x1b8(%rbx), %rax
movl 0x4(%rsp), %ecx
movl %ecx, (%rax,%r12,4)
movq 0x1a0(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x3154e
callq 0x2180
movq 0x1a0(%rbx), %rax
movq %r14, (%rax,%r12,8)
movq 0x1a8(%rbx), %rax
addq $0x1a8, %rbx            # imm = 0x1A8
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x315d5
callq 0x2180
jmp 0x315d5
movl 0x1c8(%rbx), %ecx
movl %ecx, (%rax,%r12,4)
movslq 0x1c8(%rbx), %r14
leaq (,%r14,4), %rdi
testq %r14, %r14
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq 0x1a0(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movslq 0x1cc(%rbx), %rax
imulq %r14, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
addq $0x1a8, %rbx            # imm = 0x1A8
movq (%rbx), %rax
movq %r15, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::find_voronoi_cell(double, double, double, double&, double&, double&, int&)
bool container_periodic::find_voronoi_cell(double x,double y,double z,double &rx,double &ry,double &rz,int &pid) {
	int ai,aj,ak,ci,cj,ck,ijk;
	particle_record w;
	double mrs;

	// Remap the vector into the primary domain and then search for the
	// Voronoi cell that it is within
	remap(ai,aj,ak,ci,cj,ck,x,y,z,ijk);
	vc.find_voronoi_cell(x,y,z,ci,cj,ck,ijk,w,mrs);

	if(w.ijk!=-1) {

		// Assemble the position vector of the particle to be returned,
		// applying a periodic remapping if necessary
		ci+=w.di;if(ci<0||ci>=nx) ai+=step_div(ci,nx);
		rx=p[w.ijk][3*w.l]+ak*bxz+aj*bxy+ai*bx;
		ry=p[w.ijk][3*w.l+1]+ak*byz+aj*by;
		rz=p[w.ijk][3*w.l+2]+ak*bz;
		pid=id[w.ijk][w.l];
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r15
leaq 0x70(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x68(%rsp), %r13
movsd %xmm1, (%r13)
leaq 0x60(%rsp), %r12
movsd %xmm2, (%r12)
subq $0x8, %rsp
leaq 0x18(%rsp), %rax
leaq 0x1c(%rsp), %r10
leaq 0x14(%rsp), %rsi
leaq 0x24(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %rbp
leaq 0x48(%rsp), %rbx
movq %rbp, %r8
movq %rbx, %r9
pushq %rax
pushq %r12
pushq %r13
pushq %r14
pushq %r10
callq 0x337e4
addq $0x30, %rsp
leaq 0x1d0(%r15), %rdi
movsd (%r14), %xmm0
movsd (%r13), %xmm1
movsd (%r12), %xmm2
movl (%rbp), %esi
movl (%rbx), %edx
leaq 0x14(%rsp), %rax
movl (%rax), %ecx
leaq 0x10(%rsp), %rax
movl (%rax), %r8d
subq $0x8, %rsp
leaq 0x60(%rsp), %rax
leaq 0x4c(%rsp), %rbx
movq %rbx, %r9
pushq %rax
callq 0x26eee
addq $0x10, %rsp
movslq (%rbx), %rcx
cmpq $-0x1, %rcx
je 0x317a4
movl 0x8(%rsp), %eax
addl 0x4c(%rsp), %eax
movl %eax, 0x8(%rsp)
setns %dl
movl 0x128(%r15), %esi
cmpl %esi, %eax
setl %dil
testb %dil, %dl
jne 0x316f9
testl %eax, %eax
js 0x316ee
cltd
idivl %esi
jmp 0x316f5
incl %eax
cltd
idivl %esi
decl %eax
addl %eax, 0xc(%rsp)
movq 0x1a8(%r15), %rax
movq (%rax,%rcx,8), %rdx
movslq 0x48(%rsp), %rax
leaq (%rax,%rax,2), %rsi
xorps %xmm0, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm0
movsd 0x18(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rsi,8), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x1c(%rsp), %xmm2
movsd 0x8(%r15), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtsi2sdl 0xc(%rsp), %xmm1
mulsd (%r15), %xmm1
addsd %xmm3, %xmm1
movq 0x20(%rsp), %rdi
movsd %xmm1, (%rdi)
movsd 0x20(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rdx,%rsi,8), %xmm1
mulsd 0x10(%r15), %xmm2
addsd %xmm1, %xmm2
movq 0x28(%rsp), %rdi
movsd %xmm2, (%rdi)
mulsd 0x28(%r15), %xmm0
addsd 0x10(%rdx,%rsi,8), %xmm0
movq 0x30(%rsp), %rdx
movsd %xmm0, (%rdx)
movq 0x1a0(%r15), %rdx
movq (%rdx,%rcx,8), %rdx
movl (%rdx,%rax,4), %eax
movq 0x38(%rsp), %rdx
movl %eax, (%rdx)
cmpl $-0x1, %ecx
setne %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::find_voronoi_cell(double, double, double, double&, double&, double&, int&)
bool container_periodic_poly::find_voronoi_cell(double x,double y,double z,double &rx,double &ry,double &rz,int &pid) {
	int ai,aj,ak,ci,cj,ck,ijk;
	particle_record w;
	double mrs;

	// Remap the vector into the primary domain and then search for the
	// Voronoi cell that it is within
	remap(ai,aj,ak,ci,cj,ck,x,y,z,ijk);
	vc.find_voronoi_cell(x,y,z,ci,cj,ck,ijk,w,mrs);

	if(w.ijk!=-1) {

		// Assemble the position vector of the particle to be returned,
		// applying a periodic remapping if necessary
		ci+=w.di;if(ci<0||ci>=nx) ai+=step_div(ci,nx);
		rx=p[w.ijk][4*w.l]+ak*bxz+aj*bxy+ai*bx;
		ry=p[w.ijk][4*w.l+1]+ak*byz+aj*by;
		rz=p[w.ijk][4*w.l+2]+ak*bz;
		pid=id[w.ijk][w.l];
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r15
leaq 0x70(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x68(%rsp), %r13
movsd %xmm1, (%r13)
leaq 0x60(%rsp), %r12
movsd %xmm2, (%r12)
subq $0x8, %rsp
leaq 0x18(%rsp), %rax
leaq 0x1c(%rsp), %r10
leaq 0x14(%rsp), %rsi
leaq 0x24(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %rbp
leaq 0x48(%rsp), %rbx
movq %rbp, %r8
movq %rbx, %r9
pushq %rax
pushq %r12
pushq %r13
pushq %r14
pushq %r10
callq 0x337e4
addq $0x30, %rsp
leaq 0x1f8(%r15), %rdi
movsd (%r14), %xmm0
movsd (%r13), %xmm1
movsd (%r12), %xmm2
movl (%rbp), %esi
movl (%rbx), %edx
leaq 0x14(%rsp), %rax
movl (%rax), %ecx
leaq 0x10(%rsp), %rax
movl (%rax), %r8d
subq $0x8, %rsp
leaq 0x60(%rsp), %rax
leaq 0x4c(%rsp), %rbx
movq %rbx, %r9
pushq %rax
callq 0x2d42e
addq $0x10, %rsp
movslq (%rbx), %rcx
cmpq $-0x1, %rcx
je 0x31987
movl 0x8(%rsp), %eax
addl 0x4c(%rsp), %eax
movl %eax, 0x8(%rsp)
setns %dl
movl 0x128(%r15), %esi
cmpl %esi, %eax
setl %dil
testb %dil, %dl
jne 0x318c7
testl %eax, %eax
js 0x318bc
cltd
idivl %esi
jmp 0x318c3
incl %eax
cltd
idivl %esi
decl %eax
addl %eax, 0xc(%rsp)
movq 0x1a8(%r15), %rax
movq (%rax,%rcx,8), %rdx
movslq 0x48(%rsp), %rax
movq %rax, %rsi
shlq $0x5, %rsi
xorps %xmm0, %xmm0
cvtsi2sdl 0x18(%rsp), %xmm0
movsd 0x18(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rsi), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x1c(%rsp), %xmm2
leaq (,%rax,4), %rsi
movsd 0x8(%r15), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
xorps %xmm1, %xmm1
cvtsi2sdl 0xc(%rsp), %xmm1
mulsd (%r15), %xmm1
addsd %xmm3, %xmm1
movq 0x20(%rsp), %rdi
movsd %xmm1, (%rdi)
leal 0x1(%rsi), %edi
movslq %edi, %rdi
movsd 0x20(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rdi,8), %xmm1
mulsd 0x10(%r15), %xmm2
addsd %xmm1, %xmm2
movq 0x28(%rsp), %rdi
movsd %xmm2, (%rdi)
orl $0x2, %esi
mulsd 0x28(%r15), %xmm0
movslq %esi, %rsi
addsd (%rdx,%rsi,8), %xmm0
movq 0x30(%rsp), %rdx
movsd %xmm0, (%rdx)
movq 0x1a0(%r15), %rdx
movq (%rdx,%rcx,8), %rdx
movl (%rdx,%rax,4), %eax
movq 0x38(%rsp), %rdx
movl %eax, (%rdx)
cmpl $-0x1, %ecx
setne %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::compute_all_cells()
void container_periodic::compute_all_cells() {
	voronoicell c(*this);
	c_loop_all_periodic vl(*this);
	if(vl.start()) do compute_cell(c,vl);
	while(vl.inc());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %r15
movsd 0x178(%rdi), %xmm0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x6c50
leaq 0x13ca8(%rip), %rax     # 0x45bc8
movq %rax, (%r14)
movl 0x128(%r15), %eax
movl 0x180(%r15), %r14d
movq 0x1b0(%r15), %rbx
movl 0x184(%r15), %r12d
movl 0x188(%r15), %ecx
movl %ecx, 0x20(%rsp)
movl 0x18c(%r15), %ecx
movl %ecx, 0x1c(%rsp)
movq %r15, 0x28(%rsp)
movl 0x190(%r15), %r15d
imull %r12d, %r15d
addl %r14d, %r15d
imull %eax, %r15d
movl %eax, 0x24(%rsp)
imull %r14d, %eax
leal 0x1(,%rax,2), %eax
movl %eax, 0x18(%rsp)
movslq %r15d, %rax
xorl %ebp, %ebp
cmpl $0x0, (%rbx,%rax,4)
setne %al
movl %r14d, 0x14(%rsp)
jne 0x31fda
xorl %eax, %eax
xorl %ebp, %ebp
incl %ebp
movl $0x1, %ecx
cmpl 0x24(%rsp), %ebp
jne 0x31fc4
incl %r14d
xorl %ebp, %ebp
cmpl 0x20(%rsp), %r14d
jne 0x31fc4
incl %r12d
xorl %ebp, %ebp
movl 0x14(%rsp), %r14d
movl 0x18(%rsp), %ecx
cmpl 0x1c(%rsp), %r12d
je 0x31fd5
addl %ecx, %r15d
movslq %r15d, %rax
cmpl $0x0, (%rbx,%rax,4)
setne %al
je 0x31f96
jmp 0x31fda
movl 0x14(%rsp), %r14d
testb $0x1, %al
je 0x32075
addq $0x1d0, 0x28(%rsp)      # imm = 0x1D0
xorl %r13d, %r13d
movl %r12d, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %r15d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
movl %r14d, %r9d
callq 0x22e18
incl %r13d
movslq %r15d, %rcx
movb $0x1, %al
cmpl (%rbx,%rcx,4), %r13d
jl 0x3205d
movl %r15d, %ecx
incl %ebp
movl $0x1, %r15d
cmpl 0x24(%rsp), %ebp
jne 0x3204e
incl %r14d
xorl %ebp, %ebp
cmpl 0x20(%rsp), %r14d
jne 0x3204e
incl %r12d
xorl %ebp, %ebp
cmpl 0x1c(%rsp), %r12d
je 0x32069
movl 0x14(%rsp), %r14d
movl 0x18(%rsp), %r15d
addl %ecx, %r15d
movslq %r15d, %rcx
cmpl $0x0, (%rbx,%rcx,4)
je 0x3201b
xorl %r13d, %r13d
movl %r15d, %ecx
movl %ecx, %r15d
testb %al, %al
jne 0x31fee
jmp 0x32075
movl 0x14(%rsp), %r14d
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x32060
leaq 0x30(%rsp), %rdi
callq 0x6eca
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6eca
movq %rbx, %rdi
callq 0x2230