LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11df0
andl $0x0, (%rsi)
jmp 0x11e2f
cmpb $0x1, 0xa8(%rdi)
jne 0x11f24
testl %eax, %eax
js 0x11e06
cltd
idivl %ebx
jmp 0x11e0d
incl %eax
cltd
idivl %ebx
decl %eax
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 0x11e7a
andl $0x0, (%r10)
jmp 0x11ebf
cmpb $0x1, 0xa9(%rdi)
jne 0x11f24
testl %eax, %eax
js 0x11e91
cltd
idivl %r11d
jmp 0x11e99
incl %eax
cltd
idivl %r11d
decl %eax
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), %rsi
movsd (%rsi), %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), %r10
subl %edx, %eax
movl %eax, (%r10)
setns %dl
movl 0x8(%rdi), %r11d
cmpl %r11d, %eax
setl %bl
testb %bl, %dl
je 0x11f11
andl $0x0, (%rcx)
movl (%r10), %ecx
jmp 0x11f5a
cmpb $0x1, 0xaa(%rdi)
jne 0x11f24
testl %eax, %eax
js 0x11f28
cltd
idivl %r11d
jmp 0x11f30
xorl %eax, %eax
jmp 0x11f72
incl %eax
cltd
idivl %r11d
decl %eax
cvtsi2sd %eax, %xmm2
movl %eax, (%rcx)
movsd 0x98(%rdi), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, (%rsi)
imull 0x8(%rdi), %eax
movl (%r10), %ecx
subl %eax, %ecx
movl %ecx, (%r10)
movl (%r9), %eax
imull (%rdi), %eax
addl (%r8), %eax
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_O2/Luthaf[P]zeopp/voro++/src/./container.hh
// Function: void voro::container::print_custom<voro::c_loop_all>(voro::c_loop_all&, char const*, _IO_FILE*)
void print_custom(c_loop &vl,const char *format,FILE *fp) {
			int ijk,q;double *pp;
			if(contains_neighbor(format)) {
				voronoicell_neighbor c(*this);
				if(vl.start()) do if(compute_cell(c,vl)) {
					ijk=vl.ijk;q=vl.q;pp=p[ijk]+ps*q;
					c.output_custom(format,id[ijk][q],*pp,pp[1],pp[2],default_radius,fp);
				} while(vl.inc());
			} else {
				voronoicell c(*this);
				if(vl.start()) do if(compute_cell(c,vl)) {
					ijk=vl.ijk;q=vl.q;pp=p[ijk]+ps*q;
					c.output_custom(format,id[ijk][q],*pp,pp[1],pp[2],default_radius,fp);
				} while(vl.inc());
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rsi
callq 0x2879c
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
testb %al, %al
je 0x12043
callq 0x5280
movq %r15, %rdi
callq 0x5188
testb %al, %al
je 0x12034
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5330
testb %al, %al
je 0x12028
movslq 0x3c(%r15), %rax
movslq 0x40(%r15), %rcx
movq 0xb0(%r12), %rdx
movq 0xb8(%r12), %rsi
movq (%rsi,%rax,8), %rsi
movslq 0xd0(%r12), %rdi
imulq %rcx, %rdi
movq (%rdx,%rax,8), %rax
movl (%rax,%rcx,4), %edx
movsd (%rsi,%rdi,8), %xmm0
movsd 0x8(%rsi,%rdi,8), %xmm1
movsd 0x10(%rsi,%rdi,8), %xmm2
movq %r13, %rdi
movq %r14, %rsi
movsd 0x1d010(%rip), %xmm3    # 0x2f030
movq %rbx, %rcx
callq 0x8edc
movq %r15, %rdi
callq 0x51e6
testb %al, %al
jne 0x11fc0
leaq 0x8(%rsp), %rdi
callq 0x965e
jmp 0x120d7
callq 0x52ec
movq %r15, %rdi
callq 0x5188
testb %al, %al
je 0x120cd
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5356
testb %al, %al
je 0x120c1
movslq 0x3c(%r15), %rax
movslq 0x40(%r15), %rcx
movq 0xb0(%r12), %rdx
movq 0xb8(%r12), %rsi
movq (%rsi,%rax,8), %rsi
movslq 0xd0(%r12), %rdi
imulq %rcx, %rdi
movq (%rdx,%rax,8), %rax
movl (%rax,%rcx,4), %edx
movsd (%rsi,%rdi,8), %xmm0
movsd 0x8(%rsi,%rdi,8), %xmm1
movsd 0x10(%rsi,%rdi,8), %xmm2
movq %r13, %rdi
movq %r14, %rsi
movsd 0x1cf77(%rip), %xmm3    # 0x2f030
movq %rbx, %rcx
callq 0x8edc
movq %r15, %rdi
callq 0x51e6
testb %al, %al
jne 0x12059
leaq 0x8(%rsp), %rdi
callq 0x5744
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x120ec
jmp 0x120fb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5744
jmp 0x12108
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x965e
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./container.hh
// Function: void voro::container_poly::print_custom<voro::c_loop_all>(voro::c_loop_all&, char const*, _IO_FILE*)
void print_custom(c_loop &vl,const char *format,FILE *fp) {
			int ijk,q;double *pp;
			if(contains_neighbor(format)) {
				voronoicell_neighbor c(*this);
				if(vl.start()) do if(compute_cell(c,vl)) {
					ijk=vl.ijk;q=vl.q;pp=p[ijk]+ps*q;
					c.output_custom(format,id[ijk][q],*pp,pp[1],pp[2],pp[3],fp);
				} while(vl.inc());
			} else {
				voronoicell c(*this);
				if(vl.start()) do if(compute_cell(c,vl)) {
					ijk=vl.ijk;q=vl.q;pp=p[ijk]+ps*q;
					c.output_custom(format,id[ijk][q],*pp,pp[1],pp[2],pp[3],fp);
				} while(vl.inc());
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rsi
callq 0x2879c
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
testb %al, %al
je 0x121db
callq 0x4f90
movq %r15, %rdi
callq 0x5188
testb %al, %al
je 0x121cc
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x51c0
testb %al, %al
je 0x121c0
movslq 0x3c(%r15), %rax
movslq 0x40(%r15), %rcx
movq 0xb0(%r12), %rdx
movq 0xb8(%r12), %rsi
movq (%rsi,%rax,8), %rsi
movslq 0xd0(%r12), %rdi
imulq %rcx, %rdi
movq (%rdx,%rax,8), %rax
movl (%rax,%rcx,4), %edx
movsd (%rsi,%rdi,8), %xmm0
movsd 0x8(%rsi,%rdi,8), %xmm1
movsd 0x10(%rsi,%rdi,8), %xmm2
movsd 0x18(%rsi,%rdi,8), %xmm3
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8edc
movq %r15, %rdi
callq 0x51e6
testb %al, %al
jne 0x1215a
leaq 0x8(%rsp), %rdi
callq 0x965e
jmp 0x1226d
callq 0x50fa
movq %r15, %rdi
callq 0x5188
testb %al, %al
je 0x12263
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5222
testb %al, %al
je 0x12257
movslq 0x3c(%r15), %rax
movslq 0x40(%r15), %rcx
movq 0xb0(%r12), %rdx
movq 0xb8(%r12), %rsi
movq (%rsi,%rax,8), %rsi
movslq 0xd0(%r12), %rdi
imulq %rcx, %rdi
movq (%rdx,%rax,8), %rax
movl (%rax,%rcx,4), %edx
movsd (%rsi,%rdi,8), %xmm0
movsd 0x8(%rsi,%rdi,8), %xmm1
movsd 0x10(%rsi,%rdi,8), %xmm2
movsd 0x18(%rsi,%rdi,8), %xmm3
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8edc
movq %r15, %rdi
callq 0x51e6
testb %al, %al
jne 0x121f1
leaq 0x8(%rsp), %rdi
callq 0x5744
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x12282
jmp 0x12291
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5744
jmp 0x1229e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x965e
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/./container.hh
// Function: bool voro::container_base::initialize_voronoicell<voro::voronoicell>(voro::voronoicell&, int, int, int, int, int, int&, int&, int&, double&, double&, double&, int&)
inline bool initialize_voronoicell(v_cell &c,int ijk,int q,int ci,int cj,int ck,
				int &i,int &j,int &k,double &x,double &y,double &z,int &disp) {
			double x1,x2,y1,y2,z1,z2,*pp=p[ijk]+ps*q;
			x=*(pp++);y=*(pp++);z=*pp;
			if(xperiodic) {x1=-(x2=0.5*(bx-ax));i=nx;} else {x1=ax-x;x2=bx-x;i=ci;}
			if(yperiodic) {y1=-(y2=0.5*(by-ay));j=ny;} else {y1=ay-y;y2=by-y;j=cj;}
			if(zperiodic) {z1=-(z2=0.5*(bz-az));k=nz;} else {z1=az-z;z2=bz-z;k=ck;}
			c.init(x1,x2,y1,y2,z1,z2);
			if(!apply_walls(c,x,y,z)) return false;
			disp=ijk-i-nx*(j+ny*k);
			return true;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %r12
movq 0x60(%rsp), %r13
movq 0x48(%rsp), %rbp
movq 0xb8(%r14), %rax
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq 0xd0(%r14), %rdx
movslq %ecx, %rcx
imulq %rdx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r13)
movsd 0x8(%rax,%rcx,8), %xmm0
movsd %xmm0, (%r12)
movsd 0x10(%rax,%rcx,8), %xmm6
movsd %xmm6, (%rdi)
cmpb $0x1, 0xa8(%r14)
jne 0x13617
movsd 0x78(%r14), %xmm1
subsd 0x70(%r14), %xmm1
mulsd 0x1ba2a(%rip), %xmm1    # 0x2f030
movapd 0x1ba32(%rip), %xmm0    # 0x2f040
xorpd %xmm1, %xmm0
movl (%r14), %r8d
jmp 0x13631
movsd (%r13), %xmm2
movsd 0x70(%r14), %xmm0
movsd 0x78(%r14), %xmm1
subsd %xmm2, %xmm0
subsd %xmm2, %xmm1
movq 0x50(%rsp), %rax
movl %r8d, (%rbp)
cmpb $0x1, 0xa9(%r14)
jne 0x13670
movsd 0x88(%r14), %xmm3
subsd 0x80(%r14), %xmm3
mulsd 0x1b9d2(%rip), %xmm3    # 0x2f030
movapd 0x1b9da(%rip), %xmm2    # 0x2f040
xorpd %xmm3, %xmm2
movl 0x4(%r14), %r9d
jmp 0x13690
movsd (%r12), %xmm4
movsd 0x80(%r14), %xmm2
movsd 0x88(%r14), %xmm3
subsd %xmm4, %xmm2
subsd %xmm4, %xmm3
movq 0x58(%rsp), %rcx
movl %r9d, (%rax)
cmpb $0x1, 0xaa(%r14)
jne 0x136ce
movsd 0x98(%r14), %xmm5
subsd 0x90(%r14), %xmm5
mulsd 0x1b974(%rip), %xmm5    # 0x2f030
movapd 0x1b97c(%rip), %xmm4    # 0x2f040
xorpd %xmm5, %xmm4
movl 0x8(%r14), %eax
jmp 0x136ec
movl 0x40(%rsp), %eax
movsd 0x90(%r14), %xmm4
movsd 0x98(%r14), %xmm5
subsd %xmm6, %xmm4
subsd %xmm6, %xmm5
movl %eax, (%rcx)
movq %r15, %rdi
callq 0x5bdc
leaq 0x50(%r14), %rdi
movsd (%r13), %xmm0
movsd (%r12), %xmm1
movq 0x70(%rsp), %rax
movsd (%rax), %xmm2
movq %r15, %rsi
callq 0x27924
testb %al, %al
je 0x1373e
movq 0x78(%rsp), %rcx
movq 0x58(%rsp), %rdx
movl (%rdx), %edx
imull 0x4(%r14), %edx
movq 0x50(%rsp), %rsi
addl (%rsi), %edx
imull (%r14), %edx
addl (%rbp), %edx
subl %edx, %ebx
movl %ebx, (%rcx)
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/./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 0x140b7
movq 0x10(%rsp), %rax
addl %r8d, %esi
movl (%rdi), %r10d
cmpl %r10d, %esi
jge 0x14099
movsd 0x78(%rdi), %xmm0
subsd 0x70(%rdi), %xmm0
addl %r8d, %r10d
xorpd 0x1afac(%rip), %xmm0    # 0x2f040
movl %r10d, %r8d
jmp 0x140b3
leal (%r10,%r10), %r11d
xorpd %xmm0, %xmm0
cmpl %r11d, %esi
jl 0x140b3
subl %r10d, %r8d
movsd 0x78(%rdi), %xmm0
subsd 0x70(%rdi), %xmm0
movsd %xmm0, (%rax)
cmpb $0x1, 0xa9(%rdi)
jne 0x14113
movq 0x18(%rsp), %rax
addl %r9d, %edx
movl 0x4(%rdi), %esi
cmpl %esi, %edx
jge 0x140ef
movsd 0x88(%rdi), %xmm0
subsd 0x80(%rdi), %xmm0
addl %r9d, %esi
xorpd 0x1af56(%rip), %xmm0    # 0x2f040
movl %esi, %r9d
jmp 0x1410f
leal (%rsi,%rsi), %r10d
xorpd %xmm0, %xmm0
cmpl %r10d, %edx
jl 0x1410f
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 0x14179
movq 0x20(%rsp), %rsi
addl %eax, %ecx
movl 0x8(%rdi), %r10d
cmpl %r10d, %ecx
jge 0x14155
movsd 0x98(%rdi), %xmm0
subsd 0x90(%rdi), %xmm0
addl %eax, %r10d
xorpd 0x1aef0(%rip), %xmm0    # 0x2f040
movl %r10d, %eax
jmp 0x14175
leal (%r10,%r10), %r11d
xorpd %xmm0, %xmm0
cmpl %r11d, %ecx
jl 0x14175
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_O2/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container>::add_list_memory(int*&, int*&)
inline void voro_compute<c_class>::add_list_memory(int*& qu_s,int*& qu_e) {
	qu_size<<=1;
	int *qu_n=new int[qu_size],*qu_c=qu_n;
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"List memory scaled up to %d\n",qu_size);
#endif
	if(qu_s<=qu_e) {
		while(qu_s<qu_e) *(qu_c++)=*(qu_s++);
	} else {
		while(qu_s<qu_l) *(qu_c++)=*(qu_s++);
		qu_s=qu;
		while(qu_s<qu_e) *(qu_c++)=*(qu_s++);
	}
	delete [] qu;
	qu_s=qu=qu_n;
	qu_l=qu+qu_size;
	qu_e=qu_c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x74(%rdi), %eax
addl %eax, %eax
movl %eax, 0x74(%rdi)
movslq %eax, %r13
leaq (,%r13,4), %rax
testl %r13d, %r13d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r12
movq 0x2ae18(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x1d207(%rip), %rsi     # 0x313d9
movl %r13d, %edx
xorl %eax, %eax
callq 0x21a0
movq (%r15), %rax
movq (%rbx), %rcx
movq %r12, %r13
cmpq %rcx, %rax
ja 0x1421c
cmpq %rcx, %rax
jae 0x1424a
leaq 0x4(%rax), %rdx
movq %rdx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq (%rbx), %rcx
movq %rdx, %rax
jmp 0x141ea
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %rcx, %rax
cmpq 0x98(%r14), %rax
jb 0x14208
movq 0x90(%r14), %rax
movq %rax, (%r15)
cmpq (%rbx), %rax
jae 0x1424a
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %rcx, %rax
jmp 0x1422f
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0x1425b
callq 0x2170
movq %r12, 0x90(%r14)
movq %r12, (%r15)
movslq 0x74(%r14), %rax
shlq $0x2, %rax
addq 0x90(%r14), %rax
movq %rax, 0x98(%r14)
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container>::scan_bits_mask_add(unsigned int, unsigned int*, int, int, int, int*&)
inline void voro_compute<c_class>::scan_bits_mask_add(unsigned int q,unsigned int *mijk,int ei,int ej,int ek,int *&qu_e) {
	const unsigned int b1=1<<21,b2=1<<22,b3=1<<24,b4=1<<25,b5=1<<27,b6=1<<28;
	if((q&b2)==b2) {
		if(ei>0) {*(mijk-1)=mv;*(qu_e++)=ei-1;*(qu_e++)=ej;*(qu_e++)=ek;}
		if((q&b1)==0&&ei<hx-1) {*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
	} else if((q&b1)==b1&&ei<hx-1) {*(mijk+1)=mv;*(qu_e++)=ei+1;*(qu_e++)=ej;*(qu_e++)=ek;}
	if((q&b4)==b4) {
		if(ej>0) {*(mijk-hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej-1;*(qu_e++)=ek;}
		if((q&b3)==0&&ej<hy-1) {*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
	} else if((q&b3)==b3&&ej<hy-1) {*(mijk+hx)=mv;*(qu_e++)=ei;*(qu_e++)=ej+1;*(qu_e++)=ek;}
	if((q&b6)==b6) {
		if(ek>0) {*(mijk-hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek-1;}
		if((q&b5)==0&&ek<hz-1) {*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
	} else if((q&b5)==b5&&ek<hz-1) {*(mijk+hxy)=mv;*(qu_e++)=ei;*(qu_e++)=ej;*(qu_e++)=ek+1;}
}

// Assembly:
pushq %rbx
movq 0x10(%rsp), %rax
btl $0x16, %esi
jb 0x1429c
btl $0x15, %esi
jb 0x142c7
jmp 0x142f4
testl %ecx, %ecx
jle 0x142c1
movl 0x70(%rdi), %r10d
movl %r10d, -0x4(%rdx)
leal -0x1(%rcx), %r10d
movq (%rax), %r11
movl %r10d, (%r11)
movl %r8d, 0x4(%r11)
leaq 0xc(%r11), %r10
movq %r10, (%rax)
movl %r9d, 0x8(%r11)
btl $0x15, %esi
jb 0x142f4
movl 0x38(%rdi), %r10d
decl %r10d
cmpl %ecx, %r10d
jle 0x142f4
movl 0x70(%rdi), %r10d
movl %r10d, 0x4(%rdx)
leal 0x1(%rcx), %r10d
movq (%rax), %r11
movl %r10d, (%r11)
movl %r8d, 0x4(%r11)
leaq 0xc(%r11), %r10
movq %r10, (%rax)
movl %r9d, 0x8(%r11)
btl $0x19, %esi
jb 0x14302
btl $0x18, %esi
jb 0x1433b
jmp 0x1436c
testl %r8d, %r8d
jle 0x14335
movl 0x70(%rdi), %r10d
movslq 0x38(%rdi), %r11
shlq $0x2, %r11
movq %rdx, %rbx
subq %r11, %rbx
movl %r10d, (%rbx)
movq (%rax), %r10
movl %ecx, (%r10)
leal -0x1(%r8), %r11d
movl %r11d, 0x4(%r10)
leaq 0xc(%r10), %r11
movq %r11, (%rax)
movl %r9d, 0x8(%r10)
btl $0x18, %esi
jb 0x1436c
movl 0x3c(%rdi), %r10d
decl %r10d
cmpl %r8d, %r10d
jle 0x1436c
movl 0x70(%rdi), %r10d
movslq 0x38(%rdi), %r11
movl %r10d, (%rdx,%r11,4)
movq (%rax), %r10
movl %ecx, (%r10)
leal 0x1(%r8), %r11d
movl %r11d, 0x4(%r10)
leaq 0xc(%r10), %r11
movq %r11, (%rax)
movl %r9d, 0x8(%r10)
btl $0x1c, %esi
jb 0x1437a
btl $0x1b, %esi
jb 0x143b3
jmp 0x143de
testl %r9d, %r9d
jle 0x143ad
movl 0x70(%rdi), %r10d
movslq 0x44(%rdi), %r11
shlq $0x2, %r11
movq %rdx, %rbx
subq %r11, %rbx
movl %r10d, (%rbx)
movq (%rax), %r10
movl %ecx, (%r10)
movl %r8d, 0x4(%r10)
leal -0x1(%r9), %r11d
leaq 0xc(%r10), %rbx
movq %rbx, (%rax)
movl %r11d, 0x8(%r10)
btl $0x1b, %esi
jb 0x143de
movl 0x40(%rdi), %esi
decl %esi
cmpl %r9d, %esi
jle 0x143de
movl 0x70(%rdi), %esi
movslq 0x44(%rdi), %rdi
movl %esi, (%rdx,%rdi,4)
movq (%rax), %rdx
movl %ecx, (%rdx)
movl %r8d, 0x4(%rdx)
incl %r9d
leaq 0xc(%rdx), %rcx
movq %rcx, (%rax)
movl %r9d, 0x8(%rdx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x152fc(%rip), %xmm3    # 0x2f018
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 0x8e2a
testb %al, %al
jne 0x19e22
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 0x8dd4
testb %al, %al
jne 0x19e22
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 0x8dd4
testb %al, %al
jne 0x19e22
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 0x8dd4
testb %al, %al
jne 0x19e22
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 0x8dd4
testb %al, %al
je 0x19e2c
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 0x8dd4
xorb $0x1, %al
jmp 0x19e24
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15158(%rip), %xmm3    # 0x2f018
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 0x8e2a
testb %al, %al
jne 0x19fc6
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 0x8dd4
testb %al, %al
jne 0x19fc6
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 0x8dd4
testb %al, %al
jne 0x19fc6
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 0x8dd4
testb %al, %al
jne 0x19fc6
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 0x8dd4
testb %al, %al
je 0x19fd0
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 0x8dd4
xorb $0x1, %al
jmp 0x19fc8
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14fe2(%rip), %xmm3    # 0x2f018
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 0x8e2a
testb %al, %al
jne 0x1a0c4
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 0x8dd4
testb %al, %al
jne 0x1a0c4
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 0x8dd4
testb %al, %al
je 0x1a0ce
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 0x8dd4
xorb $0x1, %al
jmp 0x1a0c6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14eb4(%rip), %xmm3    # 0x2f018
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 0x8e2a
testb %al, %al
jne 0x1a26a
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 0x8dd4
testb %al, %al
jne 0x1a26a
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 0x8dd4
testb %al, %al
jne 0x1a26a
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 0x8dd4
testb %al, %al
jne 0x1a26a
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 0x8dd4
testb %al, %al
je 0x1a274
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 0x8dd4
xorb $0x1, %al
jmp 0x1a26c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14d3e(%rip), %xmm3    # 0x2f018
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 0x8e2a
testb %al, %al
jne 0x1a368
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 0x8dd4
testb %al, %al
jne 0x1a368
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 0x8dd4
testb %al, %al
je 0x1a372
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 0x8dd4
xorb $0x1, %al
jmp 0x1a36a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14c3e(%rip), %xmm3    # 0x2f018
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 0x8e2a
testb %al, %al
jne 0x1a468
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 0x8dd4
testb %al, %al
jne 0x1a468
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 0x8dd4
testb %al, %al
je 0x1a472
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 0x8dd4
xorb $0x1, %al
jmp 0x1a46a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container_poly>::scan_all(int, double, double, double, int, int, int, voro::particle_record&, double&)
inline void voro_compute<c_class>::scan_all(int ijk,double x,double y,double z,int di,int dj,int dk,particle_record &w,double &mrs) {
	double x1,y1,z1,rs;bool in_block=false;
	for(int l=0;l<co[ijk];l++) {
		x1=p[ijk][ps*l]-x;
		y1=p[ijk][ps*l+1]-y;
		z1=p[ijk][ps*l+2]-z;
		rs=con.r_current_sub(x1*x1+y1*y1+z1*z1,ijk,l);
		if(rs<mrs) {mrs=rs;w.l=l;in_block=true;}
	}
	if(in_block) {w.ijk=ijk;w.di=di;w.dj=dj,w.dk=dk;}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, -0x4(%rsp)
movq 0x38(%rsp), %r8
movq 0x60(%rdi), %r10
movslq %esi, %r11
movsd (%r8), %xmm3
movq (%rdi), %rbx
movq 0x58(%rdi), %r14
movslq 0x4c(%rdi), %rdi
shlq $0x3, %rdi
movabsq $0x18, %r15
movabsq $0x10, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq (%r10,%r11,4), %rax
cmpq %rax, %r13
jge 0x1cefe
movq (%r14,%r11,8), %rax
movsd -0x10(%rax,%r12), %xmm5
movsd -0x8(%rax,%r12), %xmm6
subsd %xmm0, %xmm5
subsd %xmm1, %xmm6
movsd (%rax,%r12), %xmm4
subsd %xmm2, %xmm4
mulsd %xmm6, %xmm6
mulsd %xmm5, %xmm5
addsd %xmm6, %xmm5
mulsd %xmm4, %xmm4
addsd %xmm5, %xmm4
movq 0xd8(%rbx), %rax
movq (%rax,%r11,8), %rax
movsd (%rax,%r15), %xmm5
mulsd %xmm5, %xmm5
subsd %xmm5, %xmm4
ucomisd %xmm4, %xmm3
jbe 0x1cef2
movsd %xmm4, (%r8)
movl %r13d, 0x4(%r9)
movb $0x1, %bpl
movapd %xmm4, %xmm3
incq %r13
addq $0x20, %r15
addq %rdi, %r12
jmp 0x1ce82
testb $0x1, %bpl
je 0x1cf17
movl %esi, (%r9)
movl %edx, 0x8(%r9)
movl %ecx, 0xc(%r9)
movl -0x4(%rsp), %eax
movl %eax, 0x10(%r9)
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/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 0x1cf39
cvtsi2sd %esi, %xmm4
mulsd 0x8(%rdi), %xmm4
subsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
jmp 0x1cf3f
xorpd %xmm4, %xmm4
js 0x1cf94
testl %edx, %edx
jle 0x1cf5a
cvtsi2sd %edx, %xmm0
mulsd 0x10(%rdi), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm4
jmp 0x1cf5c
js 0x1cf98
testl %ecx, %ecx
jle 0x1cf77
cvtsi2sd %ecx, %xmm0
mulsd 0x18(%rdi), %xmm0
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm4
jmp 0x1cf79
js 0x1cf9c
movq (%rdi), %rax
movsd 0xe0(%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm0, %xmm4
seta %al
retq
incl %esi
jmp 0x1cf26
incl %edx
jmp 0x1cf43
incl %ecx
jmp 0x1cf60
// File: /workspace/github_cpp_makefile_star2_O2/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), %r9d
movl 0x180(%rdi), %edi
subl %r9d, %ebx
addl %esi, %ebx
movl 0x184(%r14), %esi
js 0x1ec4c
movl %ebx, %eax
cltd
idivl %r9d
jmp 0x1ec55
leal 0x1(%rbx), %eax
cltd
idivl %r9d
decl %eax
movq 0x38(%rsp), %rdx
movl 0x30(%rsp), %r15d
testl %eax, %eax
je 0x1ec75
cvtsi2sd %eax, %xmm0
mulsd (%r14), %xmm0
imull %eax, %r9d
subl %r9d, %ebx
jmp 0x1ec79
xorpd %xmm0, %xmm0
movsd %xmm0, (%rdx)
subl %esi, %r15d
addl %ecx, %r15d
subl %edi, %ebp
addl %r8d, %ebp
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x2787c
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_O2/Luthaf[P]zeopp/voro++/src/./container_prd.hh
// Function: voro::container_periodic_base::create_periodic_image(int, int, int)
inline void create_periodic_image(int di,int dj,int dk) {
			if(di<0||di>=nx||dj<0||dj>=oy||dk<0||dk>=oz)
				voro_fatal_error("Constructing periodic image for nonexistent point",VOROPP_INTERNAL_ERROR);
			if(dk>=ez&&dk<wz) {
				if(dj<ey||dj>=wy) create_side_image(di,dj,dk);
			} else create_vertical_image(di,dj,dk);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
testl %esi, %esi
js 0x278b4
testl %ebp, %ebp
js 0x278b4
cmpl %r14d, 0x128(%r15)
jle 0x278b4
testl %ebx, %ebx
js 0x278b4
cmpl %ebp, 0x190(%r15)
jle 0x278b4
cmpl %ebx, 0x194(%r15)
jg 0x278c3
leaq 0x9a9f(%rip), %rdi      # 0x3135a
pushq $0x3
popq %rsi
callq 0xfdaf
cmpl %ebx, 0x184(%r15)
jg 0x278f2
cmpl %ebx, 0x18c(%r15)
jle 0x278f2
cmpl %ebp, 0x180(%r15)
jg 0x2790b
cmpl %ebp, 0x188(%r15)
jle 0x2790b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2ba3a
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b64a
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27a4c
movsd %xmm0, 0xc8(%rdi)
movsd %xmm1, 0xd0(%rdi)
movsd %xmm2, 0xd8(%rdi)
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
movsd %xmm4, 0xe0(%rdi)
xorl %eax, %eax
jmp 0x27a4f
pushq $0x2
popq %rax
movl %eax, 0x44(%rdi)
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movupd 0x48(%rdi), %xmm1
subpd %xmm1, %xmm0
movupd 0x78(%rdi), %xmm4
movupd 0x88(%rdi), %xmm1
movapd %xmm0, %xmm5
unpckhpd %xmm0, %xmm5            # xmm5 = xmm5[1],xmm0[1]
movapd %xmm4, %xmm6
unpckhpd %xmm4, %xmm6            # xmm6 = xmm6[1],xmm4[1]
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
movapd %xmm3, %xmm7
unpcklpd %xmm3, %xmm7            # xmm7 = xmm7[0],xmm3[0]
movapd %xmm0, %xmm8
subpd %xmm3, %xmm8
subpd %xmm3, %xmm5
movapd %xmm0, %xmm9
addsd %xmm3, %xmm9
unpcklpd %xmm9, %xmm8            # xmm8 = xmm8[0],xmm9[0]
mulpd %xmm4, %xmm8
addpd %xmm0, %xmm7
movsd %xmm5, %xmm7            # xmm7 = xmm5[0],xmm7[1]
mulpd %xmm6, %xmm7
cvttpd2dq %xmm7, %xmm0
cvttpd2dq %xmm8, %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
xorpd %xmm0, %xmm0
cmpltpd %xmm0, %xmm7
cmpltpd %xmm0, %xmm8
shufps $0x88, %xmm7, %xmm8     # xmm8 = xmm8[0,2],xmm7[0,2]
paddd %xmm4, %xmm8
movdqu %xmm8, 0xf8(%rdi)
subsd 0x58(%rdi), %xmm2
movapd %xmm2, %xmm4
subsd %xmm3, %xmm4
addsd %xmm3, %xmm2
unpcklpd %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
cvttpd2dq %xmm1, %xmm2
cmpltpd %xmm0, %xmm1
shufps $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
paddd %xmm2, %xmm1
movq %xmm1, 0x108(%rdi)
jmp 0x27b20
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rbx), %rax
movslq 0x3c(%rbx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x27e4c
movq %rbx, %rdi
callq 0x27e58
testb %al, %al
jne 0x27df6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x27fcc
testb %al, %al
je 0x27e12
incl 0x40(%rbx)
movl 0x40(%rbx), %eax
movq 0x28(%rbx), %rcx
movslq 0x3c(%rbx), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x27e4c
andl $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x27e58
testb %al, %al
jne 0x27e2a
jmp 0x27e10
movb $0x1, %bpl
cmpl $0x2, 0x44(%rbx)
jne 0x27e1b
jmp 0x27e12
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27e87
incl %eax
movl %eax, 0x30(%rdi)
movl (%rdi), %eax
movl 0x110(%rdi), %ecx
leal -0x1(%rax), %edx
cmpl %edx, %ecx
jge 0x27ee2
incl %ecx
movl %ecx, 0x110(%rdi)
incl 0x3c(%rdi)
jmp 0x27fc8
movl 0x34(%rdi), %eax
cmpl 0x104(%rdi), %eax
jge 0x27f0d
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 0x27f73
incl %eax
movl %eax, 0x114(%rdi)
movl 0x128(%rdi), %eax
jmp 0x27f6e
andl $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 0x27fc8
movl 0x38(%rdi), %eax
cmpl 0x10c(%rdi), %eax
jge 0x27f9d
movl 0xf8(%rdi), %ecx
movl %ecx, 0x30(%rdi)
movl 0x100(%rdi), %ecx
movl %ecx, 0x34(%rdi)
movq 0x11c(%rdi), %rcx
movq %rcx, 0x110(%rdi)
movupd 0xb0(%rdi), %xmm0
movupd %xmm0, 0x98(%rdi)
incl %eax
movl %eax, 0x38(%rdi)
movl 0x118(%rdi), %eax
movl 0x8(%rdi), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x27fa0
incl %eax
movl %eax, 0x118(%rdi)
movl 0x12c(%rdi), %eax
addl %eax, 0x3c(%rdi)
jmp 0x27fc8
andl $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 0x27fc8
xorl %eax, %eax
retq
andl $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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28079
ucomisd %xmm0, %xmm1
movb $0x1, %al
ja 0x280c8
ucomisd 0xd0(%rdi), %xmm0
ja 0x280c8
movsd 0x8(%rcx,%rdx,8), %xmm0
addsd 0xa0(%rdi), %xmm0
movsd 0xd8(%rdi), %xmm1
ucomisd %xmm0, %xmm1
ja 0x280c8
ucomisd 0xe0(%rdi), %xmm0
ja 0x280c8
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 0x280c8
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_O2/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 0x28104
movsd %xmm0, 0xc8(%rdi)
movsd %xmm1, 0xd0(%rdi)
movsd %xmm2, 0xd8(%rdi)
movsd %xmm3, 0xe0(%rdi)
movsd %xmm4, 0xe8(%rdi)
movsd %xmm5, 0xf0(%rdi)
pushq $0x1
jmp 0x28106
pushq $0x2
popq %rax
movl %eax, 0x44(%rdi)
movupd 0x48(%rdi), %xmm7
movupd 0x58(%rdi), %xmm6
movupd 0x78(%rdi), %xmm8
movapd %xmm7, %xmm9
unpcklpd %xmm7, %xmm9            # xmm9 = xmm9[0],xmm7[0]
unpckhpd %xmm7, %xmm7            # xmm7 = xmm7[1,1]
movapd %xmm8, %xmm10
unpckhpd %xmm8, %xmm10           # xmm10 = xmm10[1],xmm8[1]
unpcklpd %xmm8, %xmm8            # xmm8 = xmm8[0,0]
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
subpd %xmm9, %xmm0
mulpd %xmm8, %xmm0
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
subpd %xmm7, %xmm2
mulpd %xmm10, %xmm2
cvttpd2dq %xmm2, %xmm1
cvttpd2dq %xmm0, %xmm3
movupd 0x88(%rdi), %xmm7
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
xorpd %xmm1, %xmm1
cmpltpd %xmm1, %xmm2
cmpltpd %xmm1, %xmm0
shufps $0x88, %xmm2, %xmm0     # xmm0 = xmm0[0,2],xmm2[0,2]
paddd %xmm3, %xmm0
movdqu %xmm0, 0xf8(%rdi)
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
unpcklpd %xmm6, %xmm6            # xmm6 = xmm6[0,0]
subpd %xmm6, %xmm4
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
mulpd %xmm4, %xmm7
cvttpd2dq %xmm7, %xmm0
cmpltpd %xmm1, %xmm7
shufps $0xe8, %xmm7, %xmm7     # xmm7 = xmm7[0,2,2,3]
paddd %xmm0, %xmm7
movq %xmm7, 0x108(%rdi)
jmp 0x27b20
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::particle_order::add_ordering_memory()
void particle_order::add_ordering_memory() {
	int *no=new int[size<<2],*nop=no,*opp=o;
	while(opp<op) *(nop++)=*(opp++);
	delete [] o;
	size<<=1;o=no;op=nop;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
leal (,%r15,4), %eax
cltq
leaq (,%rax,4), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %r14, %r12
movq %rdi, %rcx
cmpq %rax, %rcx
jae 0x2820a
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
jmp 0x281f5
testq %rdi, %rdi
je 0x28218
callq 0x2170
movl 0x10(%rbx), %r15d
addl %r15d, %r15d
movl %r15d, 0x10(%rbx)
movq %r14, (%rbx)
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x286e6
cvtsi2sd %eax, %xmm0
mulsd 0x18(%rdi), %xmm0
subsd (%rcx), %xmm0
mulsd %xmm0, %xmm0
jmp 0x286f0
xorpd %xmm0, %xmm0
js 0x28783
movl 0x28(%rsp), %eax
testl %r10d, %r10d
jle 0x28712
cvtsi2sd %r10d, %xmm1
mulsd 0x20(%rdi), %xmm1
subsd (%r9), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x28732
jns 0x28732
incl %r10d
cvtsi2sd %r10d, %xmm1
mulsd 0x20(%rdi), %xmm1
movsd (%r8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
testl %eax, %eax
jle 0x28752
movq 0x10(%rsp), %rcx
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
subsd (%rcx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x28774
jns 0x28774
movq 0x8(%rsp), %rcx
incl %eax
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 0x28782
movsd %xmm0, (%rsi)
retq
movsd (%rdx), %xmm0
incl %eax
cvtsi2sd %eax, %xmm1
mulsd 0x18(%rdi), %xmm1
subsd %xmm1, %xmm0
jmp 0x286e0
nop