LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::compute_all_cells()
void container::compute_all_cells() {
	voronoicell c(*this);
	c_loop_all 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, %rbx
movsd 0xa0(%rdi), %xmm0
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x6c50
leaq 0x3124a(%rip), %rax     # 0x45bc8
movq %rax, (%r14)
movl (%rbx), %r12d
movl 0x4(%rbx), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rbx), %eax
movq %rax, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
movq 0xc0(%rbx), %rax
xorl %r14d, %r14d
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rax)
setne %al
movl $0x0, %ebx
movl $0x0, %ebp
movl $0x0, %r15d
jne 0x14a07
xorl %ebx, %ebx
movl $0x1, %ecx
xorl %ebp, %ebp
xorl %eax, %eax
xorl %r15d, %r15d
movq %rcx, %r14
incl %r15d
cmpl %r12d, %r15d
jne 0x149f4
incl %ebp
xorl %r15d, %r15d
cmpl 0xc(%rsp), %ebp
jne 0x149f4
incl %ebx
xorl %ebp, %ebp
movl $0x0, %r15d
cmpl %r14d, 0x20(%rsp)
je 0x14a07
leaq 0x1(%r14), %rcx
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax,%r14,4)
setne %al
je 0x149cd
testb $0x1, %al
je 0x14ab7
addq $0xd8, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
xorl %r13d, %r13d
movl %ebx, (%rsp)
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %r14d, %edx
movl %r13d, %ecx
movl %r15d, %r8d
movl %ebp, %r9d
callq 0x164d0
incl %r13d
movslq %r14d, %rcx
movb $0x1, %al
movq 0x10(%rsp), %rdx
cmpl (%rdx,%rcx,4), %r13d
jl 0x14aaf
movq 0x28(%rsp), %rdx
leaq (%rdx,%rcx,4), %rcx
incl %r14d
movl %r14d, %esi
movl %ebp, %edx
movl %esi, %r14d
incl %r15d
cmpl %r12d, %r15d
jne 0x14a95
incl %edx
xorl %r15d, %r15d
cmpl 0xc(%rsp), %edx
jne 0x14a93
incl %ebx
xorl %ebp, %ebp
cmpl %r14d, 0x20(%rsp)
je 0x14aa7
xorl %r15d, %r15d
xorl %edx, %edx
jmp 0x14a95
movl %edx, %ebp
cmpl $0x0, (%rcx)
leaq 0x4(%rcx), %rcx
leal 0x1(%r14), %esi
je 0x14a6b
xorl %r13d, %r13d
jmp 0x14aaf
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %eax, %eax
testb %al, %al
jne 0x14a29
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
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::sum_cell_volumes()
double container::sum_cell_volumes() {
	voronoicell c(*this);
	double vol=0;
	c_loop_all vl(*this);
	if(vl.start()) do if(compute_cell(c,vl)) vol+=c.volume();while(vl.inc());
	return vol;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
movsd 0xa0(%rdi), %xmm0
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x6c50
leaq 0x30f16(%rip), %rax     # 0x45bc8
movq %rax, (%r14)
movl (%rbx), %r12d
movl 0x4(%rbx), %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rbx), %eax
movq %rax, 0x30(%rsp)
movq %rbx, 0x28(%rsp)
movq 0xc0(%rbx), %rax
xorl %r14d, %r14d
movq %rax, 0x20(%rsp)
cmpl $0x0, (%rax)
setne %al
movl $0x0, %ebx
movl $0x0, %ebp
movl $0x0, %r15d
jne 0x14d3b
xorl %ebx, %ebx
movl $0x1, %ecx
xorl %ebp, %ebp
xorl %eax, %eax
xorl %r15d, %r15d
movq %rcx, %r14
incl %r15d
cmpl %r12d, %r15d
jne 0x14d28
incl %ebp
xorl %r15d, %r15d
cmpl 0x14(%rsp), %ebp
jne 0x14d28
incl %ebx
xorl %ebp, %ebp
movl $0x0, %r15d
cmpl %r14d, 0x30(%rsp)
je 0x14d3b
leaq 0x1(%r14), %rcx
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax,%r14,4)
setne %al
je 0x14d01
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
testb $0x1, %al
je 0x14e19
addq $0xd8, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x38(%rsp)
movsd %xmm0, 0x18(%rsp)
xorl %r13d, %r13d
movl %ebx, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl %r14d, %edx
movl %r13d, %ecx
movl %r15d, %r8d
movl %ebp, %r9d
callq 0x164d0
testb %al, %al
je 0x14da9
leaq 0x40(%rsp), %rdi
callq 0x84ce
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
incl %r13d
movslq %r14d, %rcx
movb $0x1, %al
movq 0x20(%rsp), %rdx
cmpl (%rdx,%rcx,4), %r13d
jl 0x14e11
movq 0x38(%rsp), %rdx
leaq (%rdx,%rcx,4), %rcx
incl %r14d
movl %r14d, %esi
movl %ebp, %edx
movl %esi, %r14d
incl %r15d
cmpl %r12d, %r15d
jne 0x14df7
incl %edx
xorl %r15d, %r15d
cmpl 0x14(%rsp), %edx
jne 0x14df5
incl %ebx
xorl %ebp, %ebp
cmpl %r14d, 0x30(%rsp)
je 0x14e09
xorl %r15d, %r15d
xorl %edx, %edx
jmp 0x14df7
movl %edx, %ebp
cmpl $0x0, (%rcx)
leaq 0x4(%rcx), %rcx
leal 0x1(%r14), %esi
je 0x14dcd
xorl %r13d, %r13d
jmp 0x14e11
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %eax, %eax
testb %al, %al
jne 0x14d6d
leaq 0x40(%rsp), %rdi
callq 0x6eca
movsd 0x18(%rsp), %xmm0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6eca
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::draw_domain_gnuplot(_IO_FILE*)
void container_base::draw_domain_gnuplot(FILE *fp) {
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",ax,ay,az,bx,ay,az,bx,by,az,ax,by,az);
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",ax,by,bz,bx,by,bz,bx,ay,bz,ax,ay,bz);
	fprintf(fp,"%g %g %g\n\n%g %g %g\n%g %g %g\n\n",ax,by,bz,ax,ay,az,ax,ay,bz);
	fprintf(fp,"%g %g %g\n%g %g %g\n\n%g %g %g\n%g %g %g\n\n",bx,ay,az,bx,ay,bz,bx,by,az,bx,by,bz);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x80(%rdi), %xmm1
movsd 0x90(%rdi), %xmm2
movsd 0x70(%rdi), %xmm0
movsd 0x78(%rdi), %xmm3
movsd 0x88(%rdi), %xmm7
movsd %xmm2, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
leaq 0x2403d(%rip), %r15     # 0x39188
movq %rsi, %rdi
movq %r15, %rsi
movaps %xmm1, %xmm4
movaps %xmm2, %xmm5
movaps %xmm3, %xmm6
movb $0x8, %al
callq 0x21b0
movsd 0x88(%r14), %xmm1
movsd 0x98(%r14), %xmm2
movsd 0x70(%r14), %xmm0
movsd 0x78(%r14), %xmm3
movsd 0x80(%r14), %xmm7
movsd %xmm2, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm1, %xmm4
movaps %xmm2, %xmm5
movaps %xmm3, %xmm6
movb $0x8, %al
callq 0x21b0
movsd 0x88(%r14), %xmm1
movsd 0x98(%r14), %xmm2
movsd 0x70(%r14), %xmm0
movsd 0x80(%r14), %xmm4
movsd 0x90(%r14), %xmm5
movsd %xmm2, (%rsp)
leaq 0x23fcb(%rip), %rsi     # 0x391b6
movq %rbx, %rdi
movaps %xmm0, %xmm3
movaps %xmm0, %xmm6
movaps %xmm4, %xmm7
movb $0x8, %al
callq 0x21b0
movsd 0x78(%r14), %xmm0
movsd 0x80(%r14), %xmm1
movsd 0x90(%r14), %xmm2
movsd 0x98(%r14), %xmm5
movsd 0x88(%r14), %xmm7
movsd %xmm5, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
leaq 0x23f67(%rip), %rsi     # 0x391ad
movq %rbx, %rdi
movaps %xmm0, %xmm3
movaps %xmm1, %xmm4
movaps %xmm0, %xmm6
movb $0x8, %al
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::wall_list::increase_wall_memory()
void wall_list::increase_wall_memory() {
	current_wall_size<<=1;
	if(current_wall_size>max_wall_size)
		voro_fatal_error("Wall memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
	wall **nwalls=new wall*[current_wall_size],**nwp=nwalls,**wp=walls;
	while(wp<wep) *(nwp++)=*(wp++);
	delete [] walls;
	walls=nwalls;wel=walls+current_wall_size;wep=nwp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
addl %eax, %eax
movl %eax, 0x18(%rdi)
cmpl $0x801, %eax            # imm = 0x801
jl 0x155d0
leaq 0x23cae(%rip), %rdi     # 0x39274
movl $0x2, %esi
callq 0x1318d
movslq 0x18(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %r14, %r15
cmpq %rax, %rdi
jae 0x1561a
movq %rdi, %rcx
movq %r14, %r15
movq (%rcx), %rdx
addq $0x8, %rcx
movq %rdx, (%r15)
addq $0x8, %r15
cmpq %rax, %rcx
jb 0x15607
testq %rdi, %rdi
je 0x15624
callq 0x2180
movq %r14, (%rbx)
movslq 0x18(%rbx), %rax
leaq (%r14,%rax,8), %rax
movq %rax, 0x10(%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::put_remap(int&, double&, double&, double&)
inline bool container_base::put_remap(int &ijk,double &x,double &y,double &z) {
	int l;

	ijk=step_int((x-ax)*xsp);
	if(xperiodic) {l=step_mod(ijk,nx);x+=boxx*(l-ijk);ijk=l;}
	else if(ijk<0||ijk>=nx) return false;

	int j=step_int((y-ay)*ysp);
	if(yperiodic) {l=step_mod(j,ny);y+=boxy*(l-j);j=l;}
	else if(j<0||j>=ny) return false;

	int k=step_int((z-az)*zsp);
	if(zperiodic) {l=step_mod(k,nz);z+=boxz*(l-k);k=l;}
	else if(k<0||k>=nz) return false;

	ijk+=nx*j+nxy*k;
	return true;
}

// Assembly:
movsd (%rdx), %xmm0
movapd %xmm0, %xmm1
subsd 0x70(%rdi), %xmm1
mulsd 0x30(%rdi), %xmm1
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %r10d
subl %eax, %r10d
movl %r10d, (%rsi)
cmpb $0x1, 0xa8(%rdi)
jne 0x15685
movq %rdx, %r9
movl (%rdi), %r11d
testl %r10d, %r10d
js 0x15692
movl %r10d, %eax
cltd
idivl %r11d
jmp 0x156a4
xorl %eax, %eax
testl %r10d, %r10d
js 0x15691
cmpl (%rdi), %r10d
jl 0x156c0
retq
leal -0x1(%r11), %eax
subl %r10d, %eax
cltd
idivl %r11d
negl %edx
addl %r11d, %edx
decl %edx
movl %edx, %eax
subl %r10d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x18(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r9)
movl %edx, (%rsi)
movsd (%rcx), %xmm0
movapd %xmm0, %xmm1
subsd 0x80(%rdi), %xmm1
mulsd 0x38(%rdi), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %r9d
subl %eax, %r9d
cmpb $0x1, 0xa9(%rdi)
jne 0x15701
movl 0x4(%rdi), %r10d
testl %r9d, %r9d
js 0x15710
movl %r9d, %eax
cltd
idivl %r10d
jmp 0x15722
xorl %eax, %eax
testl %r9d, %r9d
js 0x15691
cmpl 0x4(%rdi), %r9d
jl 0x1573e
jmp 0x15691
leal -0x1(%r10), %eax
subl %r9d, %eax
cltd
idivl %r10d
negl %edx
addl %r10d, %edx
decl %edx
movl %edx, %eax
subl %r9d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x20(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
movl %edx, %r9d
movsd (%r8), %xmm0
movapd %xmm0, %xmm1
subsd 0x90(%rdi), %xmm1
mulsd 0x40(%rdi), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %ecx
subl %eax, %ecx
cmpb $0x1, 0xaa(%rdi)
jne 0x1577c
movl 0x8(%rdi), %r10d
testl %ecx, %ecx
js 0x15790
movl %ecx, %eax
cltd
idivl %r10d
jmp 0x157a1
xorl %eax, %eax
testl %ecx, %ecx
js 0x15691
cmpl 0x8(%rdi), %ecx
jl 0x157bc
jmp 0x15691
leal -0x1(%r10), %eax
subl %ecx, %eax
cltd
idivl %r10d
negl %edx
addl %r10d, %edx
decl %edx
movl %edx, %eax
subl %ecx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r8)
movl %edx, %ecx
imull (%rdi), %r9d
imull 0xc(%rdi), %ecx
addl %r9d, %ecx
addl %ecx, (%rsi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::remap(int&, int&, int&, int&, int&, int&, double&, double&, double&, int&)
inline bool container_base::remap(int &ai,int &aj,int &ak,int &ci,int &cj,int &ck,double &x,double &y,double &z,int &ijk) {
	ci=step_int((x-ax)*xsp);
	if(ci<0||ci>=nx) {
		if(xperiodic) {ai=step_div(ci,nx);x-=ai*(bx-ax);ci-=ai*nx;}
		else return false;
	} else ai=0;

	cj=step_int((y-ay)*ysp);
	if(cj<0||cj>=ny) {
		if(yperiodic) {aj=step_div(cj,ny);y-=aj*(by-ay);cj-=aj*ny;}
		else return false;
	} else aj=0;

	ck=step_int((z-az)*zsp);
	if(ck<0||ck>=nz) {
		if(zperiodic) {ak=step_div(ck,nz);z-=ak*(bz-az);ck-=ak*nz;}
		else return false;
	} else ak=0;

	ijk=ci+nx*cj+nxy*ck;
	return true;
}

// Assembly:
pushq %rbp
pushq %rbx
movq %rdx, %r10
movq 0x20(%rsp), %r11
movsd (%r11), %xmm0
movsd 0x70(%rdi), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
mulsd 0x30(%rdi), %xmm2
xorpd %xmm3, %xmm3
xorl %edx, %edx
ucomisd %xmm2, %xmm3
seta %dl
cvttsd2si %xmm2, %eax
subl %edx, %eax
movl %eax, (%r8)
setns %dl
movl (%rdi), %ebx
cmpl %ebx, %eax
setl %bpl
testb %bpl, %dl
je 0x1581b
movl $0x0, (%rsi)
jmp 0x1585d
cmpb $0x1, 0xa8(%rdi)
jne 0x15958
testl %eax, %eax
js 0x15831
cltd
idivl %ebx
jmp 0x15838
incl %eax
cltd
idivl %ebx
decl %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movl %eax, (%rsi)
movsd 0x78(%rdi), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, (%r11)
imull (%rdi), %eax
subl %eax, (%r8)
movq 0x28(%rsp), %rsi
movsd (%rsi), %xmm0
movsd 0x80(%rdi), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
mulsd 0x38(%rdi), %xmm2
xorpd %xmm3, %xmm3
xorl %edx, %edx
ucomisd %xmm2, %xmm3
seta %dl
cvttsd2si %xmm2, %eax
subl %edx, %eax
movl %eax, (%r9)
setns %dl
movl 0x4(%rdi), %r11d
cmpl %r11d, %eax
setl %bl
testb %bl, %dl
je 0x158ab
movl $0x0, (%r10)
jmp 0x158f3
cmpb $0x1, 0xa9(%rdi)
jne 0x15958
testl %eax, %eax
js 0x158c2
cltd
idivl %r11d
jmp 0x158ca
incl %eax
cltd
idivl %r11d
decl %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movl %eax, (%r10)
movsd 0x88(%rdi), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, (%rsi)
imull 0x4(%rdi), %eax
subl %eax, (%r9)
movq 0x30(%rsp), %r10
movsd (%r10), %xmm0
movsd 0x90(%rdi), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
mulsd 0x40(%rdi), %xmm2
xorpd %xmm3, %xmm3
xorl %edx, %edx
ucomisd %xmm2, %xmm3
seta %dl
cvttsd2si %xmm2, %eax
movq 0x18(%rsp), %rsi
subl %edx, %eax
movl %eax, (%rsi)
setns %dl
movl 0x8(%rdi), %r11d
cmpl %r11d, %eax
setl %bl
testb %bl, %dl
je 0x15945
movl $0x0, (%rcx)
jmp 0x1598c
cmpb $0x1, 0xaa(%rdi)
jne 0x15958
testl %eax, %eax
js 0x1595c
cltd
idivl %r11d
jmp 0x15964
xorl %eax, %eax
jmp 0x159a6
incl %eax
cltd
idivl %r11d
decl %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movl %eax, (%rcx)
movsd 0x98(%rdi), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, (%r10)
imull 0x8(%rdi), %eax
subl %eax, (%rsi)
movl (%r9), %eax
imull (%rdi), %eax
addl (%r8), %eax
movl (%rsi), %ecx
imull 0xc(%rdi), %ecx
movq 0x38(%rsp), %rdx
addl %eax, %ecx
movl %ecx, (%rdx)
movb $0x1, %al
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/./container.hh
// Function: voro::container_base::region_index(int, int, int, int, int, int, double&, double&, double&, int&)
inline int region_index(int ci,int cj,int ck,int ei,int ej,int ek,double &qx,double &qy,double &qz,int &disp) {
			if(xperiodic) {if(ci+ei<nx) {ei+=nx;qx=-(bx-ax);} else if(ci+ei>=(nx<<1)) {ei-=nx;qx=bx-ax;} else qx=0;}
			if(yperiodic) {if(cj+ej<ny) {ej+=ny;qy=-(by-ay);} else if(cj+ej>=(ny<<1)) {ej-=ny;qy=by-ay;} else qy=0;}
			if(zperiodic) {if(ck+ek<nz) {ek+=nz;qz=-(bz-az);} else if(ck+ek>=(nz<<1)) {ek-=nz;qz=bz-az;} else qz=0;}
			return disp+ei+nx*(ej+ny*ek);
		}

// Assembly:
cmpb $0x1, 0xa8(%rdi)
jne 0x18367
movq 0x10(%rsp), %rax
addl %r8d, %esi
movl (%rdi), %r10d
cmpl %r10d, %esi
jge 0x18349
movsd 0x78(%rdi), %xmm0
subsd 0x70(%rdi), %xmm0
addl %r8d, %r10d
xorpd 0x1ecec(%rip), %xmm0    # 0x37030
movl %r10d, %r8d
jmp 0x18363
leal (%r10,%r10), %r11d
xorpd %xmm0, %xmm0
cmpl %r11d, %esi
jl 0x18363
subl %r10d, %r8d
movsd 0x78(%rdi), %xmm0
subsd 0x70(%rdi), %xmm0
movsd %xmm0, (%rax)
cmpb $0x1, 0xa9(%rdi)
jne 0x183c3
movq 0x18(%rsp), %rax
addl %r9d, %edx
movl 0x4(%rdi), %esi
cmpl %esi, %edx
jge 0x1839f
movsd 0x88(%rdi), %xmm0
subsd 0x80(%rdi), %xmm0
addl %r9d, %esi
xorpd 0x1ec96(%rip), %xmm0    # 0x37030
movl %esi, %r9d
jmp 0x183bf
leal (%rsi,%rsi), %r10d
xorpd %xmm0, %xmm0
cmpl %r10d, %edx
jl 0x183bf
subl %esi, %r9d
movsd 0x88(%rdi), %xmm0
subsd 0x80(%rdi), %xmm0
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rdx
movl 0x8(%rsp), %eax
cmpb $0x1, 0xaa(%rdi)
jne 0x18429
movq 0x20(%rsp), %rsi
addl %eax, %ecx
movl 0x8(%rdi), %r10d
cmpl %r10d, %ecx
jge 0x18405
movsd 0x98(%rdi), %xmm0
subsd 0x90(%rdi), %xmm0
addl %eax, %r10d
xorpd 0x1ec30(%rip), %xmm0    # 0x37030
movl %r10d, %eax
jmp 0x18425
leal (%r10,%r10), %r11d
xorpd %xmm0, %xmm0
cmpl %r11d, %ecx
jl 0x18425
subl %r10d, %eax
movsd 0x98(%rdi), %xmm0
subsd 0x90(%rdi), %xmm0
movsd %xmm0, (%rsi)
addl (%rdx), %r8d
imull 0x4(%rdi), %eax
addl %r9d, %eax
imull (%rdi), %eax
addl %r8d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::corner_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double, double)
bool voro_compute<c_class>::corner_test(v_cell &c,double xl,double yl,double zl,double xh,double yh,double zh) {
	con.r_prime(xl*xl+yl*yl+zl*zl);
	if(c.plane_intersects_guess(xh,yl,zl,con.r_cutoff(xl*xh+yl*yl+zl*zl))) return false;
	if(c.plane_intersects(xh,yh,zl,con.r_cutoff(xl*xh+yl*yh+zl*zl))) return false;
	if(c.plane_intersects(xl,yh,zl,con.r_cutoff(xl*xl+yl*yh+zl*zl))) return false;
	if(c.plane_intersects(xl,yh,zh,con.r_cutoff(xl*xl+yl*yh+zl*zh))) return false;
	if(c.plane_intersects(xl,yl,zh,con.r_cutoff(xl*xl+yl*yl+zl*zh))) return false;
	if(c.plane_intersects(xh,yl,zh,con.r_cutoff(xl*xh+yl*yl+zl*zh))) return false;
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x30(%rsp)
movapd %xmm3, %xmm6
movq %rdi, %rbx
movq (%rdi), %rax
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rsp)
movapd %xmm3, %xmm7
addsd %xmm4, %xmm7
movapd %xmm2, %xmm5
mulsd %xmm2, %xmm5
movapd %xmm5, %xmm3
movsd %xmm7, 0x58(%rsp)
addsd %xmm7, %xmm3
movsd 0xf0(%rax), %xmm7
divsd %xmm3, %xmm7
addsd 0x18505(%rip), %xmm7    # 0x37008
movq %rsi, %r14
movsd %xmm7, 0xf8(%rax)
movsd %xmm0, 0x18(%rsp)
mulsd %xmm6, %xmm0
movsd %xmm0, 0x60(%rsp)
addsd %xmm0, %xmm4
movsd %xmm5, 0x40(%rsp)
movapd %xmm5, %xmm3
movsd %xmm4, 0x50(%rsp)
addsd %xmm4, %xmm3
mulsd %xmm7, %xmm3
movq %rsi, %rdi
movsd %xmm6, 0x38(%rsp)
movapd %xmm6, %xmm0
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0xb2a4
testb %al, %al
jne 0x1ec6a
movq (%rbx), %rax
movsd 0x20(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x60(%rsp), %xmm3
movsd %xmm0, 0x48(%rsp)
addsd %xmm0, %xmm3
addsd 0x40(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %r14, %rdi
movsd 0x38(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
callq 0xb1be
testb %al, %al
jne 0x1ec6a
movq (%rbx), %rax
movsd 0x28(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movsd 0x40(%rsp), %xmm3
movsd %xmm0, 0x28(%rsp)
addsd %xmm0, %xmm3
mulsd 0xf8(%rax), %xmm3
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0xb1be
testb %al, %al
jne 0x1ec6a
movq (%rbx), %rax
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm3
addsd %xmm0, %xmm3
mulsd 0xf8(%rax), %xmm3
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq 0xb1be
testb %al, %al
jne 0x1ec6a
movq (%rbx), %rax
movsd 0x58(%rsp), %xmm3
addsd 0x8(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0xb1be
testb %al, %al
je 0x1ec74
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
movsd 0x8(%rsp), %xmm3
addsd 0x50(%rsp), %xmm3
mulsd 0xf8(%rax), %xmm3
movq %r14, %rdi
movsd 0x38(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0xb1be
xorb $0x1, %al
jmp 0x1ec6c
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container_poly>::edge_z_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double, double)
inline bool voro_compute<c_class>::edge_z_test(v_cell &c,double xl,double yl,double z0,double xh,double yh,double z1) {
	con.r_prime(xl*xl+yl*yl);
	if(c.plane_intersects_guess(xl,yh,z0,con.r_cutoff(xl*xl+yl*yh))) return false;
	if(c.plane_intersects(xl,yh,z1,con.r_cutoff(xl*xl+yl*yh))) return false;
	if(c.plane_intersects(xl,yl,z1,con.r_cutoff(xl*xl+yl*yl))) return false;
	if(c.plane_intersects(xl,yl,z0,con.r_cutoff(xl*xl+yl*yl))) return false;
	if(c.plane_intersects(xh,yl,z0,con.r_cutoff(xl*xh+yl*yl))) return false;
	if(c.plane_intersects(xh,yl,z1,con.r_cutoff(xl*xh+yl*yl))) return false;
	return true;
}

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

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

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

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

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

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

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

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

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

	return crs>con.r_max_add(mrs);
}

// Assembly:
testl %esi, %esi
jle 0x22a8e
xorps %xmm4, %xmm4
cvtsi2sd %esi, %xmm4
mulsd 0x8(%rdi), %xmm4
subsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
jmp 0x22a94
xorpd %xmm4, %xmm4
js 0x22aef
testl %edx, %edx
jle 0x22ab2
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
mulsd 0x10(%rdi), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm4
jmp 0x22ab4
js 0x22af3
testl %ecx, %ecx
jle 0x22ad2
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd 0x18(%rdi), %xmm0
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm4
jmp 0x22ad4
js 0x22af7
movq (%rdi), %rax
movsd 0xe0(%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm0, %xmm4
seta %al
retq
incl %esi
jmp 0x22a78
incl %edx
jmp 0x22a98
incl %ecx
jmp 0x22ab8
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/./container_prd.hh
// Function: voro::container_periodic_base::region_index(int, int, int, int, int, int, double&, double&, double&, int&)
inline int region_index(int ci,int cj,int ck,int ei,int ej,int ek,double &qx,double &qy,double &qz,int &disp) {
			int qi=ci+(ei-nx),qj=cj+(ej-ey),qk=ck+(ek-ez);
			int iv(step_div(qi,nx));if(iv!=0) {qx=iv*bx;qi-=nx*iv;} else qx=0;
			create_periodic_image(qi,qj,qk);
			return qi+nx*(qj+oy*qk);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %ebx
movl %edx, %r8d
movq %rdi, %r14
movl 0x128(%rdi), %edi
movl 0x180(%r14), %r9d
subl %edi, %ebx
addl %esi, %ebx
movl 0x184(%r14), %esi
js 0x24960
movl %ebx, %eax
cltd
idivl %edi
jmp 0x24968
leal 0x1(%rbx), %eax
cltd
idivl %edi
decl %eax
movq 0x38(%rsp), %rdx
movl 0x30(%rsp), %r15d
testl %eax, %eax
je 0x2498a
cvtsi2sd %eax, %xmm0
mulsd (%r14), %xmm0
movsd %xmm0, (%rdx)
imull %edi, %eax
subl %eax, %ebx
jmp 0x24991
movq $0x0, (%rdx)
subl %esi, %r15d
addl %ecx, %r15d
subl %r9d, %ebp
addl %r8d, %ebp
testl %ebx, %ebx
js 0x249c0
testl %ebp, %ebp
js 0x249c0
cmpl %ebx, %edi
jle 0x249c0
testl %r15d, %r15d
js 0x249c0
cmpl %ebp, 0x190(%r14)
jle 0x249c0
cmpl %r15d, 0x194(%r14)
jg 0x249d1
leaq 0x14963(%rip), %rdi     # 0x3932a
movl $0x3, %esi
callq 0x1318d
cmpl %r15d, 0x184(%r14)
jg 0x24a06
cmpl %r15d, 0x18c(%r14)
jle 0x24a06
cmpl %ebp, 0x180(%r14)
jg 0x249f5
cmpl %ebp, 0x188(%r14)
jg 0x24a15
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x32968
jmp 0x24a15
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x32d96
imull 0x190(%r14), %r15d
addl %ebp, %r15d
imull 0x128(%r14), %r15d
addl %ebx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::setup_sphere(double, double, double, double, bool)
void c_loop_subset::setup_sphere(double vx,double vy,double vz,double r,bool bounds_test) {
	if(bounds_test) {mode=sphere;v0=vx;v1=vy;v2=vz;v3=r*r;} else mode=no_check;
	ai=step_int((vx-ax-r)*xsp);
	bi=step_int((vx-ax+r)*xsp);
	aj=step_int((vy-ay-r)*ysp);
	bj=step_int((vy-ay+r)*ysp);
	ak=step_int((vz-az-r)*zsp);
	bk=step_int((vz-az+r)*zsp);
	setup_common();
}

// Assembly:
testl %esi, %esi
je 0x2e351
movl $0x0, 0x44(%rdi)
movsd %xmm0, 0xc8(%rdi)
movsd %xmm1, 0xd0(%rdi)
movsd %xmm2, 0xd8(%rdi)
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movsd %xmm4, 0xe0(%rdi)
jmp 0x2e358
movl $0x2, 0x44(%rdi)
subsd 0x48(%rdi), %xmm0
movapd %xmm0, %xmm6
subsd %xmm3, %xmm6
movsd 0x78(%rdi), %xmm7
mulsd %xmm7, %xmm6
xorpd %xmm4, %xmm4
xorl %eax, %eax
ucomisd %xmm6, %xmm4
seta %al
movsd 0x80(%rdi), %xmm5
cvttsd2si %xmm6, %ecx
subl %eax, %ecx
movl %ecx, 0xf8(%rdi)
addsd %xmm3, %xmm0
mulsd %xmm7, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm4
seta %al
cvttsd2si %xmm0, %ecx
subl %eax, %ecx
movl %ecx, 0xfc(%rdi)
subsd 0x50(%rdi), %xmm1
movapd %xmm1, %xmm0
subsd %xmm3, %xmm0
mulsd %xmm5, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm4
seta %al
cvttsd2si %xmm0, %ecx
subl %eax, %ecx
addsd %xmm3, %xmm1
mulsd %xmm5, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm4
seta %al
movl %ecx, 0x100(%rdi)
cvttsd2si %xmm1, %ecx
subl %eax, %ecx
movl %ecx, 0x104(%rdi)
subsd 0x58(%rdi), %xmm2
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
movsd 0x88(%rdi), %xmm1
mulsd %xmm1, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm4
seta %al
cvttsd2si %xmm0, %ecx
subl %eax, %ecx
addsd %xmm3, %xmm2
mulsd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm4
seta %al
cvttsd2si %xmm2, %edx
movl %ecx, 0x108(%rdi)
subl %eax, %edx
movl %edx, 0x10c(%rdi)
jmp 0x2e440
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::start()
bool c_loop_subset::start() {
	while(co[ijk]==0) {if(!next_block()) return false;}
	while(mode!=no_check&&out_of_bounds()) {
		q++;
		while(q>=co[ijk]) {q=0;if(!next_block()) return false;}
	}
	return true;
}

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

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

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

// Assembly:
testl %esi, %esi
je 0x2ea69
movl $0x1, 0x44(%rdi)
movsd %xmm0, 0xc8(%rdi)
movsd %xmm1, 0xd0(%rdi)
movsd %xmm2, 0xd8(%rdi)
movsd %xmm3, 0xe0(%rdi)
movsd %xmm4, 0xe8(%rdi)
movsd %xmm5, 0xf0(%rdi)
jmp 0x2ea70
movl $0x2, 0x44(%rdi)
movsd 0x48(%rdi), %xmm8
subsd %xmm8, %xmm0
movsd 0x78(%rdi), %xmm9
mulsd %xmm9, %xmm0
xorpd %xmm6, %xmm6
xorl %eax, %eax
ucomisd %xmm0, %xmm6
seta %al
movsd 0x50(%rdi), %xmm7
cvttsd2si %xmm0, %ecx
subl %eax, %ecx
movl %ecx, 0xf8(%rdi)
subsd %xmm8, %xmm1
mulsd %xmm9, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm6
seta %al
cvttsd2si %xmm1, %ecx
subl %eax, %ecx
movl %ecx, 0xfc(%rdi)
subsd %xmm7, %xmm2
movsd 0x80(%rdi), %xmm0
mulsd %xmm0, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm6
seta %al
cvttsd2si %xmm2, %ecx
subl %eax, %ecx
subsd %xmm7, %xmm3
mulsd %xmm0, %xmm3
xorl %eax, %eax
ucomisd %xmm3, %xmm6
seta %al
cvttsd2si %xmm3, %edx
movl %ecx, 0x100(%rdi)
subl %eax, %edx
movl %edx, 0x104(%rdi)
movsd 0x58(%rdi), %xmm0
subsd %xmm0, %xmm4
movsd 0x88(%rdi), %xmm1
mulsd %xmm1, %xmm4
xorl %eax, %eax
ucomisd %xmm4, %xmm6
seta %al
cvttsd2si %xmm4, %ecx
subl %eax, %ecx
subsd %xmm0, %xmm5
mulsd %xmm1, %xmm5
xorl %eax, %eax
ucomisd %xmm5, %xmm6
seta %al
cvttsd2si %xmm5, %edx
movl %ecx, 0x108(%rdi)
subl %eax, %edx
movl %edx, 0x10c(%rdi)
jmp 0x2e440
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::particle_order::add_ordering_memory()
void particle_order::add_ordering_memory() {
	int *no=new int[size<<2],*nop=no,*opp=o;
	while(opp<op) *(nop++)=*(opp++);
	delete [] o;
	size<<=1;o=no;op=nop;
}

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

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

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

	if(radsq<minr) minr=radsq;
}

// Assembly:
movl 0x20(%rsp), %r10d
movl 0x18(%rsp), %eax
testl %eax, %eax
jle 0x2f0a8
cvtsi2sd %eax, %xmm0
mulsd 0x18(%rdi), %xmm0
subsd (%rcx), %xmm0
mulsd %xmm0, %xmm0
jmp 0x2f0b2
xorpd %xmm0, %xmm0
js 0x2f151
movl 0x28(%rsp), %eax
testl %r10d, %r10d
jle 0x2f0d7
xorps %xmm1, %xmm1
cvtsi2sd %r10d, %xmm1
mulsd 0x20(%rdi), %xmm1
subsd (%r9), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x2f0fa
jns 0x2f0fa
incl %r10d
xorps %xmm1, %xmm1
cvtsi2sd %r10d, %xmm1
mulsd 0x20(%rdi), %xmm1
movsd (%r8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
testl %eax, %eax
jle 0x2f11d
movq 0x10(%rsp), %rcx
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
subsd (%rcx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x2f142
jns 0x2f142
movq 0x8(%rsp), %rcx
incl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
movsd (%rcx), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
movsd (%rsi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2f150
movsd %xmm0, (%rsi)
retq
movsd (%rdx), %xmm0
incl %eax
cvtsi2sd %eax, %xmm1
mulsd 0x18(%rdi), %xmm1
subsd %xmm1, %xmm0
jmp 0x2f0a2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f178
testl %eax, %eax
jne 0x2f188
jmp 0x2f18d
movzbl 0x1(%rsi), %eax
testl %eax, %eax
je 0x2f18d
cmpl $0x6e, %eax
je 0x2f190
incq %rsi
incq %rsi
jmp 0x2f16a
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/wall.cc
// Function: voro::wall_cylinder::point_inside(double, double, double)
bool wall_cylinder::point_inside(double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc;
	double pa=(xd*xa+yd*ya+zd*za)*asi;
	xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
	return xd*xd+yd*yd+zd*zd<rc*rc;
}

// 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
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
movsd 0x48(%rdi), %xmm0
mulsd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
seta %al
retq