LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::plane_intersects_guess(double, double, double, double)
bool voronoicell_base::plane_intersects_guess(double x,double y,double z,double rsq) {
	up=0;
	double g=x*pts[up<<2]+y*pts[(up<<2)+1]+z*pts[(up<<2)+2];
	if(g<rsq) {
		int ca=1,cc=p>>3,mp=1;
		double m;
		while(ca<cc) {
			m=x*pts[4*mp]+y*pts[4*mp+1]+z*pts[4*mp+2];
			if(m>g) {
				if(m>rsq) return true;
				g=m;up=mp;
			}
			ca+=mp++;
		}
		return plane_intersects_track(x,y,z,rsq,g);
	}
	return true;
}

// Assembly:
movl $0x0, 0x20(%rdi)
movq 0x40(%rdi), %rcx
movsd 0x8(%rcx), %xmm4
mulsd %xmm1, %xmm4
movsd (%rcx), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x10(%rcx), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
movb $0x1, %al
ucomisd %xmm4, %xmm3
jbe 0xb2dc
movl 0x1c(%rdi), %edx
movl %edx, %esi
sarl $0x3, %esi
cmpl $0x2, %esi
jl 0xb27a
leaq 0x30(%rcx), %r8
movl $0x1, %r9d
movl $0x1, %r10d
movapd %xmm4, %xmm5
movsd -0x8(%r8), %xmm6
mulsd %xmm1, %xmm6
movsd -0x10(%r8), %xmm7
mulsd %xmm0, %xmm7
addsd %xmm6, %xmm7
movsd (%r8), %xmm6
mulsd %xmm2, %xmm6
addsd %xmm7, %xmm6
ucomisd %xmm5, %xmm6
jbe 0xb26b
ucomisd %xmm3, %xmm6
ja 0xb2dc
movl %r10d, 0x20(%rdi)
movapd %xmm6, %xmm5
addl %r10d, %r9d
incq %r10
addq $0x20, %r8
cmpl %esi, %r9d
jl 0xb232
testl %edx, %edx
jle 0xb2dd
ucomisd %xmm3, %xmm4
ja 0xb2dc
movl $0x1, %edi
movl $0x6, %eax
movq %rdi, %rsi
cmpq %rdi, %rdx
je 0xb2d6
leal -0x2(%rax), %edi
movslq %edi, %rdi
leal -0x1(%rax), %r8d
movslq %r8d, %r8
movsd (%rcx,%r8,8), %xmm4
mulsd %xmm1, %xmm4
movsd (%rcx,%rdi,8), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
cltq
movsd (%rcx,%rax,8), %xmm4
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
leaq 0x1(%rsi), %rdi
addl $0x4, %eax
ucomisd %xmm3, %xmm4
jbe 0xb28e
cmpq %rdx, %rsi
setb %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::init(double, double, double, double, double, double)
void voronoicell_neighbor::init(double xmin,double xmax,double ymin,double ymax,double zmin,double zmax) {
	init_base(xmin,xmax,ymin,ymax,zmin,zmax);
	int *q=mne[3];
	*q=-5;q[1]=-3;q[2]=-1;
	q[3]=-5;q[4]=-2;q[5]=-3;
	q[6]=-5;q[7]=-1;q[8]=-4;
	q[9]=-5;q[10]=-4;q[11]=-2;
	q[12]=-6;q[13]=-1;q[14]=-3;
	q[15]=-6;q[16]=-3;q[17]=-2;
	q[18]=-6;q[19]=-4;q[20]=-1;
	q[21]=-6;q[22]=-2;q[23]=-4;
	*ne=q;ne[1]=q+3;ne[2]=q+6;ne[3]=q+9;
	ne[4]=q+12;ne[5]=q+15;ne[6]=q+18;ne[7]=q+21;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x72f4
movq 0xe8(%rbx), %rax
movq 0x18(%rax), %rax
leaq 0xc(%rax), %rcx
movaps 0x2d205(%rip), %xmm0    # 0x38910
movups %xmm0, (%rax)
leaq 0x18(%rax), %rdx
movaps 0x2d207(%rip), %xmm0    # 0x38920
movups %xmm0, 0x10(%rax)
leaq 0x24(%rax), %rsi
movaps 0x2d208(%rip), %xmm0    # 0x38930
movups %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rdi
leaq 0x3c(%rax), %r8
movaps 0x2d205(%rip), %xmm0    # 0x38940
movups %xmm0, 0x30(%rax)
leaq 0x48(%rax), %r9
movaps 0x2d206(%rip), %xmm0    # 0x38950
movups %xmm0, 0x40(%rax)
leaq 0x54(%rax), %r10
movaps 0x2d207(%rip), %xmm0    # 0x38960
movups %xmm0, 0x50(%rax)
movq 0xf0(%rbx), %r11
movq %rax, (%r11)
movq 0xf0(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0xf0(%rbx), %rax
movq %rdx, 0x10(%rax)
movq 0xf0(%rbx), %rax
movq %rsi, 0x18(%rax)
movq 0xf0(%rbx), %rax
movq %rdi, 0x20(%rax)
movq 0xf0(%rbx), %rax
movq %r8, 0x28(%rax)
movq 0xf0(%rbx), %rax
movq %r9, 0x30(%rax)
movq 0xf0(%rbx), %rax
movq %r10, 0x38(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::init_octahedron(double)
void voronoicell_neighbor::init_octahedron(double l) {
	init_octahedron_base(l);
	int *q=mne[4];
	*q=-5;q[1]=-6;q[2]=-7;q[3]=-8;
	q[4]=-1;q[5]=-2;q[6]=-3;q[7]=-4;
	q[8]=-6;q[9]=-5;q[10]=-2;q[11]=-1;
	q[12]=-8;q[13]=-7;q[14]=-4;q[15]=-3;
	q[16]=-5;q[17]=-8;q[18]=-3;q[19]=-2;
	q[20]=-7;q[21]=-6;q[22]=-1;q[23]=-4;
	*ne=q;ne[1]=q+4;ne[2]=q+8;ne[3]=q+12;ne[4]=q+16;ne[5]=q+20;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x783e
movq 0xe8(%rbx), %rax
movq 0x20(%rax), %rax
movaps 0x2d19f(%rip), %xmm0    # 0x38970
movups %xmm0, (%rax)
leaq 0x10(%rax), %rcx
movaps 0x2d1a1(%rip), %xmm0    # 0x38980
movups %xmm0, 0x10(%rax)
leaq 0x20(%rax), %rdx
movaps 0x2d1a2(%rip), %xmm0    # 0x38990
movups %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rsi
movaps 0x2d1a3(%rip), %xmm0    # 0x389a0
movups %xmm0, 0x30(%rax)
leaq 0x40(%rax), %rdi
movaps 0x2d1a4(%rip), %xmm0    # 0x389b0
movups %xmm0, 0x40(%rax)
leaq 0x50(%rax), %r8
movaps 0x2d1a5(%rip), %xmm0    # 0x389c0
movups %xmm0, 0x50(%rax)
movq 0xf0(%rbx), %r9
movq %rax, (%r9)
movq 0xf0(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0xf0(%rbx), %rax
movq %rdx, 0x10(%rax)
movq 0xf0(%rbx), %rax
movq %rsi, 0x18(%rax)
movq 0xf0(%rbx), %rax
movq %rdi, 0x20(%rax)
movq 0xf0(%rbx), %rax
movq %r8, 0x28(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::init_tetrahedron(double, double, double, double, double, double, double, double, double, double, double, double)
void voronoicell_neighbor::init_tetrahedron(double x0,double y0,double z0,double x1,double y1,double z1,double x2,double y2,double z2,double x3,double y3,double z3) {
	init_tetrahedron_base(x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3);
	int *q=mne[3];
	*q=-4;q[1]=-3;q[2]=-2;
	q[3]=-3;q[4]=-4;q[5]=-1;
	q[6]=-4;q[7]=-2;q[8]=-1;
	q[9]=-2;q[10]=-3;q[11]=-1;
	*ne=q;ne[1]=q+3;ne[2]=q+6;ne[3]=q+9;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x30(%rsp), %xmm8
movaps 0x40(%rsp), %xmm9
movups %xmm9, 0x10(%rsp)
movups %xmm8, (%rsp)
callq 0x79e4
movq 0xe8(%rbx), %rax
movq 0x18(%rax), %rax
leaq 0xc(%rax), %rcx
movaps 0x2d134(%rip), %xmm0    # 0x389d0
movups %xmm0, (%rax)
leaq 0x18(%rax), %rdx
movaps 0x2d136(%rip), %xmm0    # 0x389e0
movups %xmm0, 0x10(%rax)
leaq 0x24(%rax), %rsi
movaps 0x2d137(%rip), %xmm0    # 0x389f0
movups %xmm0, 0x20(%rax)
movq 0xf0(%rbx), %rdi
movq %rax, (%rdi)
movq 0xf0(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0xf0(%rbx), %rax
movq %rdx, 0x10(%rax)
movq 0xf0(%rbx), %rax
movq %rsi, 0x18(%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::check_facets()
void voronoicell_neighbor::check_facets() {
	int i,j,k,l,m,q;
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			ed[i][j]=-1-k;
			q=ne[i][j];
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				m=ed[k][l];
				ed[k][l]=-1-m;
				if(ne[k][l]!=q) fprintf(stderr,"Facet error at (%d,%d)=%d, started from (%d,%d)=%d\n",k,l,ne[k][l],i,j,q);
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);
		}
	}
	reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rdi), %ecx
cmpl $0x2, %ecx
jl 0xba2f
movq 0x30(%rbx), %rax
movl $0x1, %r14d
xorl %r9d, %r9d
movq %rbx, (%rsp)
cmpl $0x0, (%rax,%r14,4)
jle 0xba20
leaq (%rax,%r14,4), %rcx
movq 0x28(%rbx), %rsi
xorl %r10d, %r10d
movq (%rsi,%r14,8), %rdi
movslq (%rdi,%r10,4), %rdx
testq %rdx, %rdx
js 0xba0a
movl %edx, %r8d
notl %r8d
movl %r8d, (%rdi,%r10,4)
movq 0xf0(%rbx), %r8
movq (%r8,%r14,8), %r8
movl (%r8,%r10,4), %r13d
movslq (%rcx), %rcx
movslq %r10d, %r8
addq %rcx, %r8
movl (%rdi,%r8,4), %edi
movl (%rax,%rdx,4), %r8d
decl %r8d
leal 0x1(%rdi), %ecx
cmpl %edi, %r8d
cmovel %r9d, %ecx
movslq %edx, %r12
movq (%rsi,%r12,8), %rdi
movslq %ecx, %rbp
movl (%rdi,%rbp,4), %r15d
movl %r15d, %r8d
notl %r8d
movl %r8d, (%rdi,%rbp,4)
movq 0xf0(%rbx), %rdi
movq (%rdi,%r12,8), %rdi
movl (%rdi,%rbp,4), %r8d
cmpl %r13d, %r8d
jne 0xb9cf
movslq %r15d, %rcx
movq (%rsi,%r12,8), %rdx
movslq (%rax,%r12,4), %rdi
addq %rbp, %rdi
movl (%rdx,%rdi,4), %edx
movl (%rax,%rcx,4), %edi
decl %edi
leal 0x1(%rdx), %ecx
cmpl %edx, %edi
cmovel %r9d, %ecx
movl %r15d, %edi
movl %r15d, %edx
cmpq %rdi, %r14
jne 0xb977
jmp 0xba0a
movq 0x3960a(%rip), %rax     # 0x44fe0
movq (%rax), %rdi
leaq 0x2d464(%rip), %rsi     # 0x38e44
movl %r14d, %r9d
xorl %eax, %eax
pushq %r13
pushq %r10
movq %r10, %rbx
callq 0x21b0
movq %rbx, %r10
movq 0x10(%rsp), %rbx
xorl %r9d, %r9d
addq $0x10, %rsp
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rax
jmp 0xb9a3
incq %r10
leaq (%rax,%r14,4), %rcx
movslq (%rcx), %rdx
cmpq %rdx, %r10
jl 0xb92f
movl 0x1c(%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0xb919
testl %ecx, %ecx
jle 0xba98
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
leaq 0x2d474(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rax,%r15,4)
jle 0xba8d
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0xba78
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movl (%rcx,%r12,4), %edx
notl %edx
movl %edx, (%rcx,%r12,4)
incq %r12
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r12
jl 0xba53
movl 0x1c(%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xba41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::memory_setup()
void voronoicell_neighbor::memory_setup() {
	int i;
	mne=new int*[current_vertex_order];
	ne=new int*[current_vertices];
	for(i=0;i<3;i++) mne[i]=new int[init_n_vertices*i];
	mne[3]=new int[init_3_vertices*3];
	for(i=4;i<current_vertex_order;i++) mne[i]=new int[init_n_vertices*i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xc(%rdi), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0xe8(%rbx)
movslq 0x8(%rbx), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0xf0(%rbx)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x2030
movq 0xe8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
addq $0x20, %r14
cmpq $0x3, %r12
jne 0xbafe
movl $0xc00, %edi            # imm = 0xC00
callq 0x2030
movq 0xe8(%rbx), %rcx
movq %rax, 0x18(%rcx)
cmpl $0x5, %r15d
jl 0xbb69
shlq $0x5, %r15
movl $0x80, %r14d
movl $0x8, %r12d
movq %r14, %rdi
callq 0x2030
movq 0xe8(%rbx), %rcx
movq %rax, (%rcx,%r12,4)
addq $0x20, %r14
addq $0x2, %r12
cmpq %r14, %r15
jne 0xbb49
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::neighbors(std::vector<int, std::allocator<int>>&)
void voronoicell_neighbor::neighbors(std::vector<int> &v) {
	v.clear();
	int i,j,k,l,m;
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			v.push_back(ne[i][j]);
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				m=ed[k][l];
				ed[k][l]=-1-m;
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);
		}
	}
	reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0xbc0e
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %ecx
cmpl $0x2, %ecx
jl 0xbd05
movq 0x30(%rbx), %rax
movl $0x1, %r15d
xorl %r12d, %r12d
cmpl $0x0, (%rax,%r15,4)
jle 0xbcf6
movq 0x28(%rbx), %rcx
xorl %r13d, %r13d
movq (%rcx,%r15,8), %rdx
movslq (%rdx,%r13,4), %rbp
testq %rbp, %rbp
js 0xbce3
movq 0xf0(%rbx), %rsi
leaq (,%r13,4), %rdx
addq (%rsi,%r15,8), %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xbc75
movl (%rdx), %edx
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xbc85
movq %r14, %rdi
callq 0x12354
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movl %ebp, %edx
notl %edx
movq (%rcx,%r15,8), %rsi
movl %edx, (%rsi,%r13,4)
movslq (%rax,%r15,4), %rdx
movslq %r13d, %rdi
addq %rdx, %rdi
movl (%rsi,%rdi,4), %esi
movl (%rax,%rbp,4), %edi
decl %edi
leal 0x1(%rsi), %edx
cmpl %esi, %edi
cmovel %r12d, %edx
movslq %ebp, %rsi
movq (%rcx,%rsi,8), %rdi
movslq %edx, %rdx
movl (%rdi,%rdx,4), %ebp
movl %ebp, %r8d
notl %r8d
movl %r8d, (%rdi,%rdx,4)
movslq (%rax,%rsi,4), %rsi
addq %rdx, %rsi
movl (%rdi,%rsi,4), %esi
movslq %ebp, %rdx
movl (%rax,%rdx,4), %edi
decl %edi
leal 0x1(%rsi), %edx
cmpl %esi, %edi
cmovel %r12d, %edx
cmpq %rbp, %r15
jne 0xbcac
incq %r13
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r13
jl 0xbc39
movl 0x1c(%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xbc27
testl %ecx, %ecx
jle 0xbd6e
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
leaq 0x2d19e(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rax,%r15,4)
jle 0xbd63
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0xbd4e
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movl (%rcx,%r12,4), %edx
notl %edx
movl %edx, (%rcx,%r12,4)
incq %r12
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r12
jl 0xbd29
movl 0x1c(%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xbd17
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::print_edges()
void voronoicell_base::print_edges() {
	int j;
	double *ptsp=pts;
	for(int i=0;i<p;i++,ptsp+=4) {
		printf("%d %d  ",i,nu[i]);
		for(j=0;j<nu[i];j++) printf(" %d",ed[i][j]);
		printf("  ");
		while(j<(nu[i]<<1)) printf(" %d",ed[i][j]);
		printf("   %d",ed[i][j]);
		print_edges_neighbors(i);
		printf("  %g %g %g %p",*ptsp,ptsp[1],ptsp[2],(void*) ed[i]);
		if(ed[i]>=mep[nu[i]]+mec[nu[i]]*((nu[i]<<1)+1)) puts(" Memory error");
		else puts("");
	}
}

// Assembly:
cmpl $0x0, 0x1c(%rdi)
jle 0xbef6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r12
leaq 0x2d0e1(%rip), %r15     # 0x38e82
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movl (%rax,%r14,4), %edx
leaq 0x2d0c5(%rip), %rdi     # 0x38e78
movl %r14d, %esi
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
movl $0x0, %r13d
jle 0xbdf7
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
incq %r13
movq 0x30(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r13
jl 0xbdd1
leaq 0x2d07f(%rip), %rdi     # 0x38e7d
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
movl (%rax,%r14,4), %eax
addl %eax, %eax
movl %r13d, %ebp
cmpl %eax, %r13d
jge 0xbe3a
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
movl (%rax,%r14,4), %eax
addl %eax, %eax
cmpl %eax, %ebp
jl 0xbe17
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%rbp,4), %esi
leaq 0x2d034(%rip), %rdi     # 0x38e80
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x10(%rax)
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rsi
leaq 0x2d004(%rip), %rdi     # 0x38e86
movb $0x3, %al
callq 0x2040
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x70(%rbx), %rdx
movslq (%rcx,%r14,4), %rcx
movq 0x68(%rbx), %rsi
movslq (%rsi,%rcx,4), %rsi
leal (%rcx,%rcx), %edi
movslq %edi, %rdi
incq %rdi
imulq %rsi, %rdi
shlq $0x2, %rdi
addq (%rdx,%rcx,8), %rdi
cmpq %rdi, (%rax,%r14,8)
jae 0xbec8
movl $0xa, %edi
callq 0x2190
jmp 0xbed4
leaq 0x2cfc5(%rip), %rdi     # 0x38e94
callq 0x21d0
incq %r14
addq $0x20, %r12
movslq 0x1c(%rbx), %rax
cmpq %rax, %r14
jl 0xbda4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::print_edges_neighbors(int)
void voronoicell_neighbor::print_edges_neighbors(int i) {
	if(nu[i]>0) {
		int j=0;
		printf("     (");
		while(j<nu[i]-1) printf("%d,",ne[i][j++]);
		printf("%d)",ne[i][j]);
	} else printf("     ()");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movslq %esi, %r15
cmpl $0x0, (%rax,%r15,4)
jle 0xbf8b
movq %rdi, %rbx
leaq 0x2cf8a(%rip), %rdi     # 0x38ea2
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
cmpl $0x2, (%rax,%r15,4)
jl 0xbf63
leaq 0x2cf75(%rip), %r14     # 0x38ea9
xorl %r12d, %r12d
movq 0xf0(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %esi
incq %r12
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
decq %rax
cmpq %rax, %r12
jl 0xbf37
movq 0xf0(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %esi
leaq 0x2d1f5(%rip), %rdi     # 0x3916e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
leaq 0x2cf1b(%rip), %rdi     # 0x38ead
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::search_for_outside_edge(int&)
inline bool voronoicell_base::search_for_outside_edge(int &up) {
	int i,lp,lw,*j=stackp2,sc2=stackp2-ds2;
	double l;
	*(stackp2++)=up;
	while(j<stackp2) {
		up=*(j++);
		for(i=0;i<nu[up];i++) {
			lp=ed[up][i];
			lw=m_test(lp,l);
			if(lw==0) {
				stackp2=ds2+sc2;
				return true;
			}
			else if(lw==1) add_to_stack(sc2,lp);
		}
	}
	stackp2=ds2+sc2;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rdi), %r13
movq %r13, %rax
subq 0x90(%rdi), %rax
movl (%rsi), %edx
leaq 0x4(%r13), %rcx
movq %rcx, 0x98(%rdi)
movl %edx, (%r13)
shrq $0x2, %rax
movslq %eax, %r12
movq 0x30(%rdi), %rax
shlq $0x2, %r12
movslq (%r13), %rdx
movl %edx, (%r14)
cmpl $0x0, (%rax,%rdx,4)
jle 0x12abf
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq 0x38(%rbx), %rsi
movq (%rax,%rdx,8), %rax
movl (%rax,%r15,4), %ebp
movslq %ebp, %rcx
movl (%rsi,%rcx,4), %eax
cmpl 0xc0(%rbx), %eax
jae 0x12a37
movq %rbx, %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0xa220
jmp 0x12a4d
movq 0x40(%rbx), %rdx
shlq $0x5, %rcx
movsd 0x18(%rdx,%rcx), %xmm0
movsd %xmm0, (%rsp)
andl $0x3, %eax
cmpl $0x1, %eax
je 0x12a58
testl %eax, %eax
jne 0x12a8e
jmp 0x12ad0
movq 0x90(%rbx), %rcx
addq %r12, %rcx
movq 0x98(%rbx), %rax
cmpq %rax, %rcx
jae 0x12a78
cmpl %ebp, (%rcx)
je 0x12a8e
addq $0x4, %rcx
jmp 0x12a69
cmpq 0xa0(%rbx), %rax
je 0x12aa7
leaq 0x4(%rax), %rcx
movq %rcx, 0x98(%rbx)
movl %ebp, (%rax)
incq %r15
movq 0x30(%rbx), %rax
movslq (%r14), %rdx
movslq (%rax,%rdx,4), %rcx
cmpq %rcx, %r15
jl 0x12a0a
jmp 0x12ab8
movq %rbx, %rdi
callq 0x24d0
movq 0x98(%rbx), %rax
jmp 0x12a81
movq 0x98(%rbx), %rcx
addq $0x4, %r13
cmpq %rcx, %r13
jb 0x129f6
xorl %eax, %eax
jmp 0x12ad2
movb $0x1, %al
addq 0x90(%rbx), %r12
movq %r12, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: bool voro::voronoicell_base::collapse_order1<voro::voronoicell>(voro::voronoicell&)
bool voronoicell_base::collapse_order1(vc_class &vc) {
	int i,j,k;
	while(mec[1]>0) {
		up=0;
#if VOROPP_VERBOSE >=1
		fputs("Order one collapse\n",stderr);
#endif
		i=--mec[1];
		j=mep[1][3*i];k=mep[1][3*i+1];
		i=mep[1][3*i+2];
		if(!delete_connection(vc,j,k,false)) return false;
		--p;
		if(up==i) up=0;
		if(p!=i) {
			if(up==p) up=i;
			pts[i<<2]=pts[p<<2];
			pts[(i<<2)+1]=pts[(p<<2)+1];
			pts[(i<<2)+2]=pts[(p<<2)+2];
			for(k=0;k<nu[p];k++) ed[ed[p][k]][ed[p][nu[p]+k]]=i;
			vc.n_copy_pointer(i,p);
			ed[i]=ed[p];
			nu[i]=nu[p];
			ed[i][nu[i]<<1]=i;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rax
cmpl $0x0, 0x4(%rax)
jle 0x12c76
movq %rsi, %rbx
movq %rdi, %r14
movq 0x324ca(%rip), %r12     # 0x44fe0
leaq 0x26435(%rip), %r15     # 0x38f52
xorl %ebp, %ebp
movl $0x0, 0x20(%r14)
movq (%r12), %rsi
movq %r15, %rdi
callq 0x2140
movq 0x68(%r14), %rax
movslq 0x4(%rax), %rcx
decq %rcx
movl %ecx, 0x4(%rax)
movq 0x70(%r14), %rax
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rsi
movl (%rax,%rsi,4), %edx
movl 0x4(%rax,%rsi,4), %ecx
movl 0x8(%rax,%rsi,4), %r13d
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0x12c8a
testb %al, %al
je 0x12c79
movslq 0x1c(%r14), %rdx
leaq -0x1(%rdx), %rcx
movl %ecx, 0x1c(%r14)
movl 0x20(%r14), %esi
cmpl %r13d, %esi
jne 0x12b8e
movl $0x0, 0x20(%r14)
xorl %esi, %esi
cmpl %r13d, %ecx
je 0x12c64
cmpl %ecx, %esi
jne 0x12b9f
movl %r13d, 0x20(%r14)
movq 0x40(%r14), %rsi
leal (,%rcx,4), %edi
movslq %edi, %rdi
movsd (%rsi,%rdi,8), %xmm0
leal (,%r13,4), %edi
movslq %edi, %rdi
movsd %xmm0, (%rsi,%rdi,8)
leal 0x1(,%rcx,4), %edi
movslq %edi, %rdi
movsd (%rsi,%rdi,8), %xmm0
leal 0x1(,%r13,4), %edi
movslq %edi, %rdi
movsd %xmm0, (%rsi,%rdi,8)
leal 0x2(,%rcx,4), %edi
movslq %edi, %rdi
movsd (%rsi,%rdi,8), %xmm0
leal 0x2(,%r13,4), %edi
movslq %edi, %rdi
movsd %xmm0, (%rsi,%rdi,8)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdi
movl -0x4(%rdi,%rdx,4), %r8d
testl %r8d, %r8d
jle 0x12c3e
xorl %edx, %edx
movq (%rsi,%rcx,8), %rcx
movslq (%rcx,%rdx,4), %r9
movq (%rsi,%r9,8), %r9
movslq %r8d, %r8
addq %rdx, %r8
movslq (%rcx,%r8,4), %rcx
movl %r13d, (%r9,%rcx,4)
incq %rdx
movslq 0x1c(%r14), %rcx
movslq (%rdi,%rcx,4), %r8
cmpq %r8, %rdx
jl 0x12c14
movslq %r13d, %rdx
movq (%rsi,%rcx,8), %rdi
movq %rdi, (%rsi,%rdx,8)
movq 0x30(%r14), %rsi
movl (%rsi,%rcx,4), %ecx
movl %ecx, (%rsi,%rdx,4)
movq 0x28(%r14), %rsi
movq (%rsi,%rdx,8), %rdx
addl %ecx, %ecx
movslq %ecx, %rcx
movl %r13d, (%rdx,%rcx,4)
movq 0x68(%r14), %rcx
cmpl $0x0, 0x4(%rcx)
jg 0x12b1f
movl %eax, %ebp
jmp 0x12c79
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::check_duplicate(int, double, double, double, int, double*)
void check_duplicate(int n,double x,double y,double z,int id,double *qp) {
	double dx=*qp-x,dy=qp[1]-y,dz=qp[2]-z;
	if(dx*dx+dy*dy+dz*dz<1e-10) {
		printf("Duplicate: %d (%g,%g,%g) matches %d (%g,%g,%g)\n",n,x,y,z,id,*qp,qp[1],qp[2]);
		exit(1);
	}
}

// Assembly:
movsd (%rdx), %xmm3
movsd 0x8(%rdx), %xmm4
movapd %xmm3, %xmm6
subsd %xmm0, %xmm6
movapd %xmm4, %xmm7
subsd %xmm1, %xmm7
movsd 0x10(%rdx), %xmm5
movapd %xmm5, %xmm8
subsd %xmm2, %xmm8
mulsd %xmm7, %xmm7
mulsd %xmm6, %xmm6
addsd %xmm7, %xmm6
mulsd %xmm8, %xmm8
addsd %xmm6, %xmm8
movsd 0x25d32(%rip), %xmm6    # 0x390d0
ucomisd %xmm8, %xmm6
ja 0x133a6
retq
pushq %rax
movl %esi, %eax
movl %edi, %esi
leaq 0x25d26(%rip), %rdi     # 0x390d8
movl %eax, %edx
movb $0x6, %al
callq 0x2040
movl $0x1, %edi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::safe_fopen(char const*, char const*)
FILE* safe_fopen(const char *filename,const char *mode) {
	FILE *fp=fopen(filename,mode);
	if(fp==NULL) {
		fprintf(stderr,"voro++: Unable to open file '%s'\n",filename);
		exit(VOROPP_FILE_ERROR);
	}
	return fp;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2150
testq %rax, %rax
je 0x13495
popq %rbx
retq
movq %rbx, %rdi
callq 0x2d4d
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::voro_print_vector(std::vector<int, std::allocator<int>>&, _IO_FILE*)
void voro_print_vector(std::vector<int> &v,FILE *fp) {
	int k=0,s=v.size();
	while(k+4<s) {
		fprintf(fp,"%d %d %d %d ",v[k],v[k+1],v[k+2],v[k+3]);
		k+=4;
	}
	if(k+3<=s) {
		if(k+4==s) fprintf(fp,"%d %d %d %d",v[k],v[k+1],v[k+2],v[k+3]);
		else fprintf(fp,"%d %d %d",v[k],v[k+1],v[k+2]);
	} else {
		if(k+2==s) fprintf(fp,"%d %d",v[k],v[k+1]);
		else fprintf(fp,"%d",v[k]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x2, %r12
cmpl $0x5, %r12d
jl 0x134fd
leaq 0x25c72(%rip), %r15     # 0x39136
xorl %r13d, %r13d
movq (%r14), %rax
movl (%rax,%r13,4), %edx
movl 0x4(%rax,%r13,4), %ecx
movl 0x8(%rax,%r13,4), %r8d
movl 0xc(%rax,%r13,4), %r9d
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21b0
addq $0x4, %r13
leal 0x4(%r13), %eax
cmpl %r12d, %eax
jl 0x134c7
leal 0x4(%r13), %eax
jmp 0x13505
movl $0x4, %eax
xorl %r13d, %r13d
movl %r13d, %esi
orl $0x3, %esi
cmpl %r12d, %esi
jle 0x13540
movl %r13d, %eax
orl $0x2, %r13d
movq (%r14), %rcx
movl (%rcx,%rax,4), %edx
cmpl %r12d, %r13d
jne 0x13579
movl 0x4(%rcx,%rax,4), %ecx
leaq 0x25c1c(%rip), %rsi     # 0x39149
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
movl %r13d, %r8d
movq (%r14), %rdi
movl (%rdi,%r8,4), %edx
movl 0x4(%rdi,%r8,4), %ecx
movl 0x8(%rdi,%r8,4), %r8d
cmpl %r12d, %eax
jne 0x13593
movl %esi, %eax
movl (%rdi,%rax,4), %r9d
leaq 0x25bdd(%rip), %rsi     # 0x39143
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25903(%rip), %rsi     # 0x38e83
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25bac(%rip), %rsi     # 0x39146
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::voro_print_vector(std::vector<double, std::allocator<double>>&, _IO_FILE*)
void voro_print_vector(std::vector<double> &v,FILE *fp) {
	int k=0,s=v.size();
	while(k+4<s) {
		fprintf(fp,"%g %g %g %g ",v[k],v[k+1],v[k+2],v[k+3]);
		k+=4;
	}
	if(k+3<=s) {
		if(k+4==s) fprintf(fp,"%g %g %g %g",v[k],v[k+1],v[k+2],v[k+3]);
		else fprintf(fp,"%g %g %g",v[k],v[k+1],v[k+2]);
	} else {
		if(k+2==s) fprintf(fp,"%g %g",v[k],v[k+1]);
		else fprintf(fp,"%g",v[k]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x3, %r12
cmpl $0x5, %r12d
jl 0x13615
xorl %r13d, %r13d
leaq 0x25b78(%rip), %r15     # 0x3914f
movq (%r14), %rax
movsd (%rax,%r13,8), %xmm0
movsd 0x8(%rax,%r13,8), %xmm1
movsd 0x10(%rax,%r13,8), %xmm2
movsd 0x18(%rax,%r13,8), %xmm3
movq %rbx, %rdi
movq %r15, %rsi
movb $0x4, %al
callq 0x21b0
addq $0x4, %r13
leal 0x4(%r13), %eax
cmpl %r12d, %eax
jl 0x135d7
leal 0x4(%r13), %eax
jmp 0x1361d
movl $0x4, %eax
xorl %r13d, %r13d
movl %r13d, %ecx
orl $0x3, %ecx
cmpl %r12d, %ecx
jle 0x1365c
movl %r13d, %eax
orl $0x2, %r13d
movq (%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
cmpl %r12d, %r13d
jne 0x13699
movsd 0x8(%rcx,%rax,8), %xmm1
leaq 0x25b19(%rip), %rsi     # 0x39162
movq %rbx, %rdi
movb $0x2, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
movl %r13d, %esi
movq (%r14), %rdx
movsd (%rdx,%rsi,8), %xmm0
movsd 0x8(%rdx,%rsi,8), %xmm1
movsd 0x10(%rdx,%rsi,8), %xmm2
cmpl %r12d, %eax
jne 0x136b3
movl %ecx, %eax
movsd (%rdx,%rax,8), %xmm3
leaq 0x25ad6(%rip), %rsi     # 0x3915c
movq %rbx, %rdi
movb $0x4, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25ac5(%rip), %rsi     # 0x39165
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25aa5(%rip), %rsi     # 0x3915f
movq %rbx, %rdi
movb $0x3, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::~container_base()
container_base::~container_base() {
	int l;
	for(l=0;l<nxyz;l++) delete [] p[l];
	for(l=0;l<nxyz;l++) delete [] id[l];
	delete [] id;
	delete [] p;
	delete [] co;
	delete [] mem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x13cc6
xorl %r14d, %r14d
movq 0xb8(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x13c91
callq 0x2180
movl 0x10(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x13c79
testl %eax, %eax
jle 0x13cc6
xorl %r14d, %r14d
movq 0xb0(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x13cbb
callq 0x2180
movl 0x10(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x13ca3
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x13cd7
callq 0x2180
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x13ce8
callq 0x2180
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x13cf9
callq 0x2180
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x13d0a
callq 0x2180
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x13d18
callq 0x2180
movq 0x48(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x13d2d
popq %rbx
popq %r14
jmp 0x2180
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::put(voro::particle_order&, int, double, double, double)
void container::put(particle_order &vo,int n,double x,double y,double z) {
	int ijk;
	if(put_locate_block(ijk,x,y,z)) {
		id[ijk][co[ijk]]=n;
		vo.add(ijk,co[ijk]);
		double *pp=p[ijk]+3*co[ijk]++;
		*(pp++)=x;*(pp++)=y;*pp=z;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x18(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x10(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0xc(%rsp), %rsi
callq 0x13f22
testb %al, %al
je 0x14107
movslq 0xc(%rsp), %rcx
movq 0xb0(%rbx), %rdx
movq 0xc0(%rbx), %rax
movq (%rdx,%rcx,8), %rdx
movslq (%rax,%rcx,4), %rcx
movl %ebp, (%rdx,%rcx,4)
movslq 0xc(%rsp), %r15
movl (%rax,%r15,4), %ebp
movq 0x8(%r14), %rcx
movslq 0x10(%r14), %rdx
shlq $0x2, %rdx
addq (%r14), %rdx
cmpq %rdx, %rcx
jne 0x140b8
movq %r14, %rdi
callq 0x2f102
movq 0x8(%r14), %rcx
movq 0xc0(%rbx), %rax
movl %r15d, (%rcx)
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl %ebp, 0x4(%rcx)
movq 0xb8(%rbx), %rcx
movslq 0xc(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rax,%rdx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rax,%rdx,4)
leaq (%rsi,%rsi,2), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rcx,%rax,8)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rax,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rax,8)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_poly::put(voro::particle_order&, int, double, double, double, double)
void container_poly::put(particle_order &vo,int n,double x,double y,double z,double r) {
	int ijk;
	if(put_locate_block(ijk,x,y,z)) {
		id[ijk][co[ijk]]=n;
		vo.add(ijk,co[ijk]);
		double *pp=p[ijk]+4*co[ijk]++;
		*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
		if(max_radius<r) max_radius=r;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, 0x8(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x18(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x10(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x4(%rsp), %rsi
callq 0x13f22
testb %al, %al
je 0x14213
movslq 0x4(%rsp), %rcx
movq 0xb0(%rbx), %rdx
movq 0xc0(%rbx), %rax
movq (%rdx,%rcx,8), %rdx
movslq (%rax,%rcx,4), %rcx
movl %ebp, (%rdx,%rcx,4)
movslq 0x4(%rsp), %r15
movl (%rax,%r15,4), %ebp
movq 0x8(%r14), %rcx
movslq 0x10(%r14), %rdx
shlq $0x2, %rdx
addq (%r14), %rdx
cmpq %rdx, %rcx
jne 0x141a6
movq %r14, %rdi
callq 0x2f102
movq 0x8(%r14), %rcx
movq 0xc0(%rbx), %rax
movl %r15d, (%rcx)
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl %ebp, 0x4(%rcx)
movq 0xb8(%rbx), %rcx
movslq 0x4(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rax,%rdx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rax,%rdx,4)
shlq $0x5, %rsi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rcx,%rsi)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx,%rsi)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rcx,%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rcx,%rsi)
ucomisd 0xe0(%rbx), %xmm0
jbe 0x14213
movsd %xmm0, 0xe0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::add_particle_memory(int)
void container_base::add_particle_memory(int i) {
	int l,nmem=mem[i]<<1;

	// Carry out a check on the memory allocation size, and
	// print a status message if requested
	if(nmem>max_particle_memory)
		voro_fatal_error("Absolute maximum memory allocation exceeded",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=3
	fprintf(stderr,"Particle memory in region %d scaled up to %d\n",i,nmem);
#endif

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %ebp
addl %ebp, %ebp
cmpl $0x1000001, %ebp        # imm = 0x1000001
jl 0x14255
leaq 0x24f45(%rip), %rdi     # 0x39190
movl $0x2, %esi
callq 0x133c5
movslq %ebp, %rdi
shlq $0x2, %rdi
testl %ebp, %ebp
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq 0xc0(%rbx), %rax
movslq (%rax,%r12,4), %r13
testq %r13, %r13
jle 0x1429d
movq 0xb0(%rbx), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
cmpq %r13, %rcx
jb 0x1428e
movq %r12, (%rsp)
movl 0xd0(%rbx), %r12d
movl %r12d, %eax
imull %ebp, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
imull %r12d, %r13d
movq (%rsp), %r12
testl %r13d, %r13d
jle 0x142f6
movq 0xb8(%rbx), %rax
movq (%rax,%r12,8), %rax
movl %r13d, %ecx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x142e3
movq 0xc8(%rbx), %rax
movl %ebp, (%rax,%r12,4)
movq 0xb0(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x1431d
callq 0x2180
movq 0xb0(%rbx), %rax
movq %r14, (%rax,%r12,8)
movq 0xb8(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x1433d
callq 0x2180
movq 0xb8(%rbx), %rax
movq %r15, (%rax,%r12,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/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 0x6c5c
movq %rbx, %rdi
leaq 0x2ff87(%rip), %rax     # 0x44bc8
movq %rax, (%r14)
movl (%rbx), %eax
movl %eax, 0x10(%rsp)
movl 0x4(%rbx), %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rbx), %eax
movq 0xc0(%rbx), %rsi
xorl %r12d, %r12d
cmpl $0x0, (%rsi)
movl $0x0, %r15d
movl $0x0, %r9d
movl $0x0, %ebp
movl $0x0, %r14d
jne 0x14cbf
movq %rax, %rdx
decl %eax
xorl %r9d, %r9d
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %r15, %r8
incl %r14d
cmpl 0x10(%rsp), %r14d
jne 0x14cb0
incl %ebp
cmpl 0x14(%rsp), %ebp
jne 0x14cad
cmpl %r8d, %eax
je 0x14d58
incl %r9d
xorl %ebp, %ebp
xorl %r14d, %r14d
leaq 0x1(%r8), %r15
cmpl $0x0, 0x4(%rsi,%r8,4)
je 0x14c8a
movq %rdx, %rax
addq $0xd8, %rdi
movq %rsi, 0x20(%rsp)
leaq 0x4(%rsi), %rdx
movq %rdx, 0x18(%rsp)
decl %eax
movq %rax, 0x28(%rsp)
movq %r9, %r13
movl %r9d, (%rsp)
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x1668c
incl %r12d
movslq %r15d, %rax
movq 0x20(%rsp), %rcx
cmpl (%rcx,%rax,4), %r12d
movq %rbx, %rdi
movq %r13, %r9
jl 0x14cdb
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movl 0x10(%rsp), %ecx
incl %r14d
cmpl %ecx, %r14d
jne 0x14d47
incl %ebp
cmpl 0x14(%rsp), %ebp
jne 0x14d44
cmpl %r15d, 0x28(%rsp)
je 0x14d58
incl %r9d
xorl %ebp, %ebp
xorl %r14d, %r14d
movl 0x10(%rsp), %ecx
jmp 0x14d47
xorl %r14d, %r14d
incl %r15d
cmpl $0x0, (%rax)
leaq 0x4(%rax), %rax
je 0x14d1f
xorl %r12d, %r12d
jmp 0x14cdb
leaq 0x30(%rsp), %rdi
callq 0x6ed4
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 0x6ed4
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6c5c
leaq 0x2fc92(%rip), %rax     # 0x44bc8
movq %rax, (%r14)
movl (%rbx), %r13d
movl 0x4(%rbx), %r8d
movl 0x10(%rbx), %eax
movq 0xc0(%rbx), %rdi
cmpl $0x0, (%rdi)
movl $0x0, %r15d
movl $0x0, %r12d
movl $0x0, %ebp
movl $0x0, %r14d
jne 0x14fa6
movq %rax, %rsi
decl %eax
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %r15, %rcx
incl %r14d
cmpl %r13d, %r14d
jne 0x14f98
incl %ebp
cmpl %r8d, %ebp
jne 0x14f95
cmpl %ecx, %eax
je 0x15068
incl %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
leaq 0x1(%rcx), %r15
cmpl $0x0, 0x4(%rdi,%rcx,4)
je 0x14f76
movq %rsi, %rax
movl %r8d, 0x1c(%rsp)
addq $0xd8, %rbx
movq %rbx, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x4(%rdi), %rcx
movq %rcx, 0x20(%rsp)
decl %eax
movq %rax, 0x38(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r8d, %r8d
movl %r12d, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl %r15d, %edx
movl %r8d, %ebx
movl %r8d, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x1668c
testb %al, %al
je 0x15019
leaq 0x40(%rsp), %rdi
callq 0x843c
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movl %ebx, %r8d
incl %r8d
movslq %r15d, %rax
movq 0x28(%rsp), %rcx
cmpl (%rcx,%rax,4), %r8d
jl 0x14fd9
movq 0x20(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movl 0x1c(%rsp), %ecx
incl %r14d
cmpl %r13d, %r14d
jne 0x15057
incl %ebp
cmpl %ecx, %ebp
jne 0x15054
cmpl %r15d, 0x38(%rsp)
je 0x15072
incl %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
incl %r15d
cmpl $0x0, (%rax)
leaq 0x4(%rax), %rax
je 0x1503a
jmp 0x14fd6
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6ed4
movsd 0x10(%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 0x6ed4
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23ecc(%rip), %r15     # 0x39211
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 0x23e5a(%rip), %rsi     # 0x3923f
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 0x23df6(%rip), %rsi     # 0x39236
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_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
addl %eax, %eax
movl %eax, 0x18(%rdi)
cmpl $0x801, %eax            # imm = 0x801
jl 0x157d6
leaq 0x23b34(%rip), %rdi     # 0x392fd
movl $0x2, %esi
callq 0x133c5
movl 0x18(%rbx), %eax
movslq %eax, %r15
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %r14, %r12
cmpq %rax, %rdi
jae 0x15820
movq %rdi, %rcx
movq %r14, %r12
movq (%rcx), %rdx
addq $0x8, %rcx
movq %rdx, (%r12)
addq $0x8, %r12
cmpq %rax, %rcx
jb 0x1580c
testq %rdi, %rdi
je 0x1582e
callq 0x2180
movslq 0x18(%rbx), %r15
movq %r14, (%rbx)
leaq (%r14,%r15,8), %rax
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r9d
subl %eax, %r9d
movl %r9d, (%rsi)
cmpb $0x1, 0xa8(%rdi)
jne 0x15891
movq %rdx, %r10
movl (%rdi), %r11d
testl %r9d, %r9d
js 0x1589e
movl %r9d, %eax
cltd
idivl %r11d
jmp 0x158b0
xorl %eax, %eax
testl %r9d, %r9d
js 0x1589d
cmpl (%rdi), %r9d
jl 0x158cf
retq
leal -0x1(%r11), %eax
subl %r9d, %eax
cltd
idivl %r11d
negl %edx
addl %r11d, %edx
decl %edx
movl %edx, %eax
subl %r9d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x18(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r10)
movl %edx, (%rsi)
movl %edx, %r9d
movsd (%rcx), %xmm0
movapd %xmm0, %xmm1
subsd 0x80(%rdi), %xmm1
mulsd 0x38(%rdi), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %r10d
subl %eax, %r10d
cmpb $0x1, 0xa9(%rdi)
jne 0x15910
movl 0x4(%rdi), %r11d
testl %r10d, %r10d
js 0x15922
movl %r10d, %eax
cltd
idivl %r11d
jmp 0x15934
xorl %eax, %eax
testl %r10d, %r10d
js 0x1589d
cmpl 0x4(%rdi), %r10d
jl 0x15950
jmp 0x1589d
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 0x20(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
movl %edx, %r10d
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 0x1598e
movl 0x8(%rdi), %r11d
testl %ecx, %ecx
js 0x159a2
movl %ecx, %eax
cltd
idivl %r11d
jmp 0x159b3
xorl %eax, %eax
testl %ecx, %ecx
js 0x1589d
cmpl 0x8(%rdi), %ecx
jl 0x159ce
jmp 0x1589d
leal -0x1(%r11), %eax
subl %ecx, %eax
cltd
idivl %r11d
negl %edx
addl %r11d, %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), %r10d
imull 0xc(%rdi), %ecx
addl %r10d, %ecx
addl %r9d, %ecx
movl %ecx, (%rsi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15a31
movl $0x0, (%rsi)
jmp 0x15a73
cmpb $0x1, 0xa8(%rdi)
jne 0x15b71
testl %eax, %eax
js 0x15a47
cltd
idivl %ebx
jmp 0x15a4e
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 0x15ac1
movl $0x0, (%r10)
jmp 0x15b09
cmpb $0x1, 0xa9(%rdi)
jne 0x15b71
testl %eax, %eax
js 0x15ad8
cltd
idivl %r11d
jmp 0x15ae0
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), %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 0x15b5e
movl $0x0, (%rcx)
movl (%r10), %ecx
jmp 0x15baa
cmpb $0x1, 0xaa(%rdi)
jne 0x15b71
testl %eax, %eax
js 0x15b75
cltd
idivl %r11d
jmp 0x15b7d
xorl %eax, %eax
jmp 0x15bc2
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, (%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