LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x287aa
testl %eax, %eax
jne 0x287ba
jmp 0x287bf
movzbl 0x1(%rsi), %eax
testl %eax, %eax
je 0x287bf
cmpl $0x6e, %eax
je 0x287c2
incq %rsi
incq %rsi
jmp 0x2879c
xorl %eax, %eax
retq
movb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_sphere::cut_cell_base<voro::voronoicell>(voro::voronoicell&, 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 0xcb81(%rip), %xmm4     # 0x354f0
jbe 0x2898f
sqrtsd %xmm4, %xmm3
mulsd 0x28(%rdi), %xmm3
subsd %xmm4, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x1374e
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_cylinder::cut_cell_base<voro::voronoicell>(voro::voronoicell&, 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 0xc9ed(%rip), %xmm4     # 0x354f0
jbe 0x28b23
sqrtsd %xmm4, %xmm3
mulsd 0x48(%rdi), %xmm3
subsd %xmm4, %xmm3
addsd %xmm3, %xmm3
movl 0x8(%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x1374e
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_cone::cut_cell_base<voro::voronoicell>(voro::voronoicell&, 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 0xc872(%rip), %xmm1     # 0x354f0
jbe 0x28cad
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
sqrtsd %xmm1, %xmm1
movsd 0x637f(%rip), %xmm3     # 0x2f018
divsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x28cb0
sqrtsd %xmm0, %xmm0
jmp 0x28d0f
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 0x20e0
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 0x6323(%rip), %xmm2     # 0x2f040
mulsd 0x58(%r14), %xmm3
mulsd %xmm0, %xmm2
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), %esi
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0x1374e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x290ab
callq 0x2170
movq 0x48(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x290bc
callq 0x2170
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rax
cmpq %rdi, %rax
je 0x290f5
movq 0x70(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x70(%rbx)
movq -0x8(%rcx), %rdi
testq %rdi, %rdi
je 0x290e7
callq 0x2170
movq 0x48(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq -0x8(%rax), %rdi
jmp 0x290b2
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x2910a
movq %rax, %rdi
callq 0x2170
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x29115
popq %rbx
jmp 0x2170
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movsd 0x8(%rdi), %xmm1
movsd 0x18(%rdi), %xmm0
subsd (%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
subsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r15
movsd 0x28(%rdi), %xmm0
subsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x29902
cvtsi2sd %eax, %xmm0
movsd 0xc3ee(%rip), %xmm1     # 0x35558
mulsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0xc3d8(%rip), %xmm1     # 0x35560
callq 0x2210
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x5e79(%rip), %xmm1     # 0x2f018
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29208
ucomisd (%rbx), %xmm0
jb 0x29294
movsd 0x8(%rbx), %xmm3
ucomisd %xmm0, %xmm3
jb 0x29294
cmpb $0x0, 0x31(%rbx)
jne 0x29220
ucomisd 0x10(%rbx), %xmm1
jb 0x29294
movsd 0x18(%rbx), %xmm3
ucomisd %xmm1, %xmm3
jb 0x29294
cmpb $0x0, 0x32(%rbx)
jne 0x29238
ucomisd 0x20(%rbx), %xmm2
jb 0x29294
movsd 0x28(%rbx), %xmm3
ucomisd %xmm2, %xmm3
jb 0x29294
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x29270
movq %rbx, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
callq 0x2929c
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_O2/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
jne 0x292c6
movq %rbx, %rdi
callq 0x29802
movq 0x48(%rbx), %r14
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
pushq $-0x1
popq %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
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29338
ucomisd (%rbx), %xmm0
jb 0x293df
movsd 0x8(%rbx), %xmm4
ucomisd %xmm0, %xmm4
jb 0x293df
cmpb $0x0, 0x31(%rbx)
jne 0x29358
ucomisd 0x10(%rbx), %xmm1
jb 0x293df
movsd 0x18(%rbx), %xmm4
ucomisd %xmm1, %xmm4
jb 0x293df
cmpb $0x0, 0x32(%rbx)
jne 0x29370
ucomisd 0x20(%rbx), %xmm2
jb 0x293df
movsd 0x28(%rbx), %xmm4
ucomisd %xmm2, %xmm4
jb 0x293df
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
jne 0x293b6
movq %rbx, %rdi
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x2929c
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_O2/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, %r14
movq 0x40(%rdi), %r13
movq 0x68(%rdi), %rbp
movq %rdi, (%rsp)
movq (%r13), %r15
movq (%rbp), %r12
cmpq 0x48(%r14), %r13
jae 0x2947c
xorl %r14d, %r14d
cmpq $0xfff, %r14            # imm = 0xFFF
ja 0x29447
movl (%r15,%r14), %esi
addq $0x4, %r14
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
addq $0x18, %r12
movq %rbx, %rdi
callq 0x106fa
jmp 0x29414
addq $0x8, %r13
addq $0x8, %rbp
movq (%rsp), %r14
jmp 0x29403
movl (%r15), %esi
addq $0x4, %r15
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
addq $0x18, %r12
movq %rbx, %rdi
callq 0x106fa
cmpq 0x58(%r14), %r15
jb 0x29455
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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 0x40(%rdi), %r13
movq %rdi, (%rsp)
movq 0x68(%rdi), %rbp
movq (%r13), %r15
movq (%rbp), %r12
movq (%rsp), %rax
cmpq 0x48(%rax), %r13
jae 0x29530
xorl %eax, %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x294f8
leaq 0x4(%rax), %r14
movl (%r15,%rax), %esi
movsd (%r12,%rax,8), %xmm0
movsd 0x8(%r12,%rax,8), %xmm1
movsd 0x10(%r12,%rax,8), %xmm2
movsd 0x18(%r12,%rax,8), %xmm3
movq %rbx, %rdi
callq 0x107d4
movq %r14, %rax
jmp 0x294c0
addq $0x8, %r13
addq $0x8, %rbp
jmp 0x294ac
movl (%r15), %esi
addq $0x4, %r15
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
movsd 0x18(%r12), %xmm3
addq $0x20, %r12
movq %rbx, %rdi
callq 0x107d4
movq (%rsp), %rax
cmpq 0x58(%rax), %r15
jb 0x29502
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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, %r15
movq 0x40(%rdi), %rbp
movq 0x68(%rdi), %rax
movq %rdi, 0x8(%rsp)
movq (%rbp), %r12
movq %rax, 0x10(%rsp)
movq (%rax), %r13
cmpq 0x48(%r15), %rbp
jae 0x295f4
xorl %r15d, %r15d
cmpq $0xfff, %r15            # imm = 0xFFF
ja 0x295b7
movl (%r12,%r15), %edx
addq $0x4, %r15
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movsd 0x10(%r13), %xmm2
addq $0x18, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1089e
jmp 0x29583
addq $0x8, %rbp
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %r15
jmp 0x2956e
movl (%r12), %edx
addq $0x4, %r12
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movsd 0x10(%r13), %xmm2
addq $0x18, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1089e
cmpq 0x58(%r15), %r12
jb 0x295cb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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 0x40(%rdi), %rbp
movq %rdi, 0x8(%rsp)
movq 0x68(%rdi), %rax
movq (%rbp), %r12
movq %rax, 0x10(%rsp)
movq (%rax), %r13
movq 0x8(%rsp), %rax
cmpq 0x48(%rax), %rbp
jae 0x296be
xorl %eax, %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x29680
leaq 0x4(%rax), %r15
movl (%r12,%rax), %edx
movsd (%r13,%rax,8), %xmm0
movsd 0x8(%r13,%rax,8), %xmm1
movsd 0x10(%r13,%rax,8), %xmm2
movsd 0x18(%r13,%rax,8), %xmm3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10958
movq %r15, %rax
jmp 0x29644
addq $0x8, %rbp
movq 0x10(%rsp), %rax
addq $0x8, %rax
jmp 0x2962b
movl (%r12), %edx
addq $0x4, %r12
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movsd 0x10(%r13), %xmm2
movsd 0x18(%r13), %xmm3
addq $0x20, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10958
movq 0x8(%rsp), %rax
cmpq 0x58(%rax), %r12
jb 0x2968f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::extend_chunk_index()
void pre_container_base::extend_chunk_index() {
	index_sz<<=1;
	if(index_sz>max_chunk_size)
		voro_fatal_error("Absolute memory limit on chunk index reached",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Pre-container chunk index scaled up to %d\n",index_sz);
#endif
	int **n_id=new int*[index_sz],**p_id=n_id,**c_id=pre_id;
	double **n_p=new double*[index_sz],**p_p=n_p,**c_p=pre_p;
	while(c_id<end_id) {
		*(p_id++)=*(c_id++);
		*(p_p++)=*(c_p++);
	}
	delete [] pre_id;pre_id=n_id;end_id=p_id;l_id=pre_id+index_sz;
	delete [] pre_p;pre_p=n_p;end_p=p_p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %edx
addl %edx, %edx
movl %edx, 0x38(%rdi)
cmpl $0x10001, %edx          # imm = 0x10001
jl 0x29832
leaq 0xbd41(%rip), %rdi      # 0x35568
pushq $0x2
popq %rsi
callq 0xfdaf
movl 0x38(%rbx), %edx
movq 0x157a7(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0xbd52(%rip), %rsi      # 0x35595
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x21a0
movslq 0x38(%rbx), %rcx
leaq (,%rcx,8), %rax
movq %rcx, (%rsp)
testq %rcx, %rcx
pushq $-0x1
popq %r14
cmovnsq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq 0x40(%rbx), %r12
movq %r14, %rdi
callq 0x2030
movq %rax, %rbp
movq %rax, %r14
movq 0x48(%rbx), %rax
movq 0x68(%rbx), %rdi
leaq (%r12,%r13), %rcx
cmpq %rax, %rcx
jae 0x298ab
movq (%rcx), %rcx
movq %rcx, (%r15,%r13)
movq (%rdi,%r13), %rcx
movq %rcx, (%r14,%r13)
addq $0x8, %r13
jmp 0x2988d
leaq (%r15,%r13), %rcx
testq %r12, %r12
movq (%rsp), %rax
je 0x298ce
movq %r12, %rdi
movq %rcx, %r12
callq 0x2170
movq %r12, %rcx
movslq 0x38(%rbx), %rax
movq 0x68(%rbx), %rdi
addq %r13, %rbp
movq %r15, 0x40(%rbx)
movq %rcx, 0x48(%rbx)
leaq (%r15,%rax,8), %rax
movq %rax, 0x50(%rbx)
testq %rdi, %rdi
je 0x298eb
callq 0x2170
movq %r14, 0x68(%rbx)
movq %rbp, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x198(%rdi), %r14d
testl %r14d, %r14d
jle 0x29c81
movq 0x1b8(%rbx), %rax
cmpl $0x0, -0x4(%rax,%r14,4)
jle 0x29c7c
movq 0x1a8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x29c66
callq 0x2170
movq 0x1a0(%rbx), %rax
movq -0x8(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x29c7c
callq 0x2170
decq %r14
jmp 0x29c3c
movq 0x1c0(%rbx), %rdi
testq %rdi, %rdi
je 0x29c92
callq 0x2170
movq 0x1b8(%rbx), %rdi
testq %rdi, %rdi
je 0x29ca3
callq 0x2170
movq 0x1b0(%rbx), %rdi
testq %rdi, %rdi
je 0x29cb4
callq 0x2170
movq 0x1a0(%rbx), %rdi
testq %rdi, %rdi
je 0x29cc5
callq 0x2170
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x29cd6
callq 0x2170
leaq 0x128(%rbx), %rdi
callq 0x11bcc
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5744
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x28(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x20(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x1c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x29ee2
movslq (%r13), %r13
movsd (%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movsd (%r12), %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r15
jge 0x29e89
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0xfd44
incq %r15
addq $0x18, %r14
jmp 0x29e3b
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
imulq $0x18, %rdx, %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r10d
subl %eax, %r10d
setns %al
movl 0x130(%rdi), %r9d
cmpl %r9d, %r10d
setl %dl
testb %dl, %al
jne 0x29f7c
testl %r10d, %r10d
js 0x29f2d
movl %r10d, %eax
cltd
idivl %r9d
jmp 0x29f37
leal 0x1(%r10), %eax
cltd
idivl %r9d
decl %eax
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, %r9d
subl %r9d, %r10d
movsd (%rcx), %xmm1
movsd 0x160(%rdi), %xmm2
mulsd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
seta %al
cvttsd2si %xmm2, %r9d
subl %eax, %r9d
setns %al
movl 0x12c(%rdi), %r8d
cmpl %r8d, %r9d
setl %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x29fbb
movsd (%r11), %xmm0
jmp 0x2a002
testl %r9d, %r9d
js 0x29fc9
movl %r9d, %eax
cltd
idivl %r8d
jmp 0x29fd3
leal 0x1(%r9), %eax
cltd
idivl %r8d
decl %eax
cvtsi2sd %eax, %xmm2
movsd 0x10(%rdi), %xmm0
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
movsd (%r11), %xmm0
mulsd 0x8(%rdi), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%r11)
imull %eax, %r8d
subl %r8d, %r9d
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 0x2a06d
testl %ecx, %ecx
js 0x2a043
movl %ecx, %eax
cltd
idivl %r8d
jmp 0x2a04c
leal 0x1(%rcx), %eax
cltd
idivl %r8d
decl %eax
cvtsi2sd %eax, %xmm1
mulsd (%rdi), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%r11)
imull %eax, %r8d
subl %r8d, %ecx
movl %ecx, (%rsi)
movl 0x128(%rdi), %r8d
addl 0x180(%rdi), %r9d
addl 0x184(%rdi), %r10d
imull 0x190(%rdi), %r10d
addl %r9d, %r10d
imull %r8d, %r10d
addl %ecx, %r10d
movl %r10d, (%rsi)
movslq %r10d, %rax
movq 0x1b0(%rdi), %rcx
movq 0x1b8(%rdi), %rdx
movl (%rcx,%rax,4), %ecx
cmpl (%rdx,%rax,4), %ecx
jne 0x2a0b1
movl %r10d, %esi
jmp 0x2a822
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm3, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x38(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x30(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x2c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x29ee2
movslq (%r13), %r13
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
movsd (%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r15
jge 0x2a17b
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xfd44
incq %r15
addq $0x20, %r14
jmp 0x2a12c
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
shlq $0x5, %rdx
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rdx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rdx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x2a1e4
movsd %xmm0, 0x1d8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x28(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x20(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x1c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
pushq %rax
pushq %r10
callq 0x2a31e
addq $0x10, %rsp
movslq (%r13), %r13
movsd (%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movsd (%r12), %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r15
jge 0x2a2c5
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0xfd44
incq %r15
addq $0x18, %r14
jmp 0x2a277
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
imulq $0x18, %rdx, %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rax
movq %rcx, %r10
movq %rdx, %r9
movsd %xmm3, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movsd %xmm0, (%r14)
leaq 0x38(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x30(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x2c(%rsp), %r13
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
pushq %rax
pushq %r10
callq 0x2a31e
addq $0x10, %rsp
movslq (%r13), %r13
movsd (%r14), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
movsd (%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movq 0x1b0(%rbx), %rax
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r15
jge 0x2a5f3
movq 0x1a0(%rbx), %rax
movq 0x1a8(%rbx), %rcx
movq (%rax,%r13,8), %rax
movl (%rax,%r15,4), %esi
movq (%rcx,%r13,8), %rdx
addq %r14, %rdx
movl %ebp, %edi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xfd44
incq %r15
addq $0x20, %r14
jmp 0x2a5a4
movq 0x1a0(%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movl %ebp, (%rdx,%rcx,4)
movq 0x1a8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movslq (%rax,%r13,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rax,%r13,4)
shlq $0x5, %rdx
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rcx,%rdx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rdx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rdx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rdx)
ucomisd 0x1d8(%rbx), %xmm0
jbe 0x2a65c
movsd %xmm0, 0x1d8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq %rax, %rdx
leaq 0x20(%rsp), %r14
movsd %xmm1, (%r14)
leaq 0x18(%rsp), %r15
movsd %xmm2, (%r15)
leaq 0x14(%rsp), %rbx
movq %rbx, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x29ee2
movslq (%rbx), %rbx
movq 0x1a0(%r12), %rax
movq 0x1b0(%r12), %rcx
movq (%rax,%rbx,8), %rax
movslq (%rcx,%rbx,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rcx,%rbx,4), %edx
movq %r13, %rdi
movl %ebx, %esi
callq 0x11bda
movq 0x1a8(%r12), %rax
movq 0x1b0(%r12), %rcx
movq (%rax,%rbx,8), %rax
movslq (%rcx,%rbx,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%rbx,4)
imulq $0x18, %rdx, %rcx
leaq 0x8(%rsp), %rdx
movsd (%rdx), %xmm0
movsd %xmm0, (%rax,%rcx)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rax,%rcx)
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%rax,%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, (%rsp)
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq %rax, %rdx
leaq 0x20(%rsp), %r15
movsd %xmm1, (%r15)
leaq 0x18(%rsp), %r12
movsd %xmm2, (%r12)
leaq 0x14(%rsp), %r14
movq %r14, %rsi
movq %r15, %rcx
movq %r12, %r8
callq 0x29ee2
movslq (%r14), %r14
movq 0x1a0(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movq (%rax,%r14,8), %rax
movslq (%rcx,%r14,4), %rdx
movl %ebp, (%rax,%rdx,4)
movl (%rcx,%r14,4), %edx
movq %r13, %rdi
movl %r14d, %esi
callq 0x11bda
movsd (%rsp), %xmm1
movq 0x1a8(%rbx), %rax
movq 0x1b0(%rbx), %rcx
movq (%rax,%r14,8), %rax
movslq (%rcx,%r14,4), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%r14,4)
shlq $0x5, %rdx
leaq 0x8(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax,%rdx)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rax,%rdx)
movsd (%r12), %xmm0
movsd %xmm0, 0x10(%rax,%rdx)
movsd %xmm1, 0x18(%rax,%rdx)
ucomisd 0x1d8(%rbx), %xmm1
jbe 0x2a813
movsd %xmm1, 0x1d8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x1b8(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %ebp
testl %ebp, %ebp
je 0x2a94e
addl %ebp, %ebp
cmpl $0x1000001, %ebp        # imm = 0x1000001
jl 0x2a862
leaq 0x68ed(%rip), %rdi      # 0x31147
pushq $0x2
popq %rsi
callq 0xfdaf
movslq %ebp, %rdi
shlq $0x2, %rdi
testl %ebp, %ebp
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq 0x1a0(%rbx), %r13
movq %rbx, 0x8(%rsp)
movq 0x1b0(%rbx), %rax
movslq (%rax,%r12,4), %rbx
xorl %eax, %eax
cmpq %rbx, %rax
jge 0x2a8aa
movq (%r13,%r12,8), %rcx
movl (%rcx,%rax,4), %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
jmp 0x2a894
movq 0x8(%rsp), %rax
movl 0x1cc(%rax), %eax
movl %eax, 0x14(%rsp)
imull %ebp, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
imull 0x14(%rsp), %ebx
movq 0x8(%rsp), %rax
movq 0x1a8(%rax), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x2a905
movq (%rax,%r12,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
incq %rcx
jmp 0x2a8ec
movq 0x8(%rsp), %rbx
movq 0x1b8(%rbx), %rax
movl %ebp, (%rax,%r12,4)
movq (%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x2a92b
callq 0x2170
movq 0x1a0(%rbx), %r13
movq %r14, (%r13,%r12,8)
movq 0x1a8(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x2a9a6
callq 0x2170
movq 0x1a8(%rbx), %rax
jmp 0x2a9a6
movq %rbx, %r13
movslq 0x1c8(%rbx), %rbx
leaq (,%rbx,4), %rdi
testq %rbx, %rbx
movl %ebx, (%rax,%r12,4)
pushq $-0x1
popq %r14
cmovsq %r14, %rdi
callq 0x2030
movq 0x1a0(%r13), %rcx
movq %rax, (%rcx,%r12,8)
movslq 0x1cc(%r13), %rax
imulq %rbx, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq 0x1a8(%r13), %rax
movq %r15, (%rax,%r12,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/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 0x10(%rsp), %rsi
leaq 0x24(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x14(%rsp), %rbp
leaq 0x48(%rsp), %rbx
movq %rbp, %r8
movq %rbx, %r9
pushq %rax
pushq %r12
pushq %r13
pushq %r14
pushq %r10
callq 0x2c3e0
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 0x210b4
popq %rax
popq %rcx
movslq (%rbx), %rcx
cmpq $-0x1, %rcx
je 0x2ab73
movl 0xc(%rsp), %eax
addl 0x4c(%rsp), %eax
movl %eax, 0xc(%rsp)
setns %dl
movl 0x128(%r15), %esi
cmpl %esi, %eax
setl %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x2aabb
movl 0x8(%rsp), %eax
jmp 0x2aad3
testl %eax, %eax
js 0x2aac4
cltd
idivl %esi
jmp 0x2aacb
incl %eax
cltd
idivl %esi
decl %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x1a8(%r15), %rdx
movq (%rdx,%rcx,8), %rsi
movslq 0x48(%rsp), %rdx
imulq $0x18, %rdx, %rdi
cvtsi2sdl 0x18(%rsp), %xmm0
movsd 0x18(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsi,%rdi), %xmm1
cvtsi2sdl 0x1c(%rsp), %xmm2
movsd 0x8(%r15), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
cvtsi2sd %eax, %xmm1
mulsd (%r15), %xmm1
addsd %xmm3, %xmm1
movq 0x20(%rsp), %rax
movsd %xmm1, (%rax)
movsd 0x20(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rsi,%rdi), %xmm1
mulsd 0x10(%r15), %xmm2
addsd %xmm1, %xmm2
movq 0x28(%rsp), %rax
movsd %xmm2, (%rax)
mulsd 0x28(%r15), %xmm0
addsd 0x10(%rsi,%rdi), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x1a0(%r15), %rax
movq (%rax,%rcx,8), %rax
movl (%rax,%rdx,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_O2/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 0x10(%rsp), %rsi
leaq 0x24(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x14(%rsp), %rbp
leaq 0x48(%rsp), %rbx
movq %rbp, %r8
movq %rbx, %r9
pushq %rax
pushq %r12
pushq %r13
pushq %r14
pushq %r10
callq 0x2c3e0
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 0x26e26
popq %rax
popq %rcx
movslq (%rbx), %rcx
cmpq $-0x1, %rcx
je 0x2ad55
movl 0xc(%rsp), %eax
addl 0x4c(%rsp), %eax
movl %eax, 0xc(%rsp)
setns %dl
movl 0x128(%r15), %esi
cmpl %esi, %eax
setl %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x2ac89
movl 0x8(%rsp), %eax
jmp 0x2aca1
testl %eax, %eax
js 0x2ac92
cltd
idivl %esi
jmp 0x2ac99
incl %eax
cltd
idivl %esi
decl %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x1a8(%r15), %rdx
movq (%rdx,%rcx,8), %rsi
movslq 0x48(%rsp), %rdx
movq %rdx, %rdi
shlq $0x5, %rdi
cvtsi2sdl 0x18(%rsp), %xmm0
movsd 0x18(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsi,%rdi), %xmm1
cvtsi2sdl 0x1c(%rsp), %xmm2
leaq (,%rdx,4), %rdi
movsd 0x8(%r15), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
cvtsi2sd %eax, %xmm1
mulsd (%r15), %xmm1
addsd %xmm3, %xmm1
movq 0x20(%rsp), %rax
movsd %xmm1, (%rax)
leal 0x1(%rdi), %eax
cltq
movsd 0x20(%r15), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsi,%rax,8), %xmm1
mulsd 0x10(%r15), %xmm2
addsd %xmm1, %xmm2
movq 0x28(%rsp), %rax
movsd %xmm2, (%rax)
orl $0x2, %edi
mulsd 0x28(%r15), %xmm0
movslq %edi, %rax
addsd (%rsi,%rax,8), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x1a0(%r15), %rax
movq (%rax,%rcx,8), %rax
movl (%rax,%rdx,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_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c9a6
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c5c6
leaq 0x8(%rsp), %rdi
callq 0x2c9c4
testb %al, %al
je 0x2b1d9
leaq 0x68(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2ca08
movq %r15, %rdi
callq 0x2ca2e
testb %al, %al
jne 0x2b1bf
leaq 0x68(%rsp), %rdi
callq 0x5744
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2b1f2
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5744
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::sum_cell_volumes()
double container_periodic::sum_cell_volumes() {
	voronoicell c(*this);
	double vol=0;
	c_loop_all_periodic vl(*this);
	if(vl.start()) do if(compute_cell(c,vl)) vol+=c.volume();while(vl.inc());
	return vol;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c9a6
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c5c6
leaq 0x8(%rsp), %rdi
callq 0x2c9c4
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
testb %al, %al
je 0x2b315
movsd %xmm0, (%rsp)
leaq 0x68(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2ca08
testb %al, %al
je 0x2b309
movq %r14, %rdi
callq 0x69f6
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r15, %rdi
callq 0x2ca2e
testb %al, %al
jne 0x2b2e1
leaq 0x68(%rsp), %rdi
callq 0x5744
movsd (%rsp), %xmm0
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2b333
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5744
movq %rbx, %rdi
callq 0x2220