LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::normals(std::vector<double, std::allocator<double>>&)
void voronoicell_base::normals(std::vector<double> &v) {
	int i,j,k;
	v.clear();
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) normals_search(v,i,j,k);
	}
	reset_edges();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0xa3c9
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
jl 0xa423
movl $0x1, %r15d
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xa417
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %r8d
testl %r8d, %r8d
js 0xa407
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x11a78
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xa3e5
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xa3d7
testl %eax, %eax
jle 0xa483
xorl %r15d, %r15d
leaq 0x2ea14(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xa477
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0xa45b
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xa43f
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xa431
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::number_of_faces()
int voronoicell_base::number_of_faces() {
	int i,j,k,l,m,s=0;
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			s++;
			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();
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x1c(%rdi), %edi
xorl %ebp, %ebp
cmpl $0x2, %edi
jl 0xa559
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
xorl %edx, %edx
movl $0x1, %esi
xorl %ebp, %ebp
cmpl $0x0, (%rcx,%rsi,4)
jle 0xa549
movq (%rax,%rsi,8), %rdi
xorl %r8d, %r8d
movslq (%rdi,%r8,4), %r9
testq %r9, %r9
js 0xa53d
movl %r9d, %r10d
notl %r10d
movl %r10d, (%rdi,%r8,4)
movslq (%rcx,%rsi,4), %r10
movslq %r8d, %r11
addq %r10, %r11
movl (%rdi,%r11,4), %r11d
movl (%rcx,%r9,4), %r14d
decl %r14d
leal 0x1(%r11), %r10d
cmpl %r11d, %r14d
cmovel %edx, %r10d
movslq %r9d, %r11
movq (%rax,%r11,8), %r14
movslq %r10d, %r10
movl (%r14,%r10,4), %r9d
movl %r9d, %r15d
notl %r15d
movl %r15d, (%r14,%r10,4)
movslq (%rcx,%r11,4), %r11
addq %r10, %r11
movl (%r14,%r11,4), %r11d
movslq %r9d, %r10
movl (%rcx,%r10,4), %r14d
decl %r14d
leal 0x1(%r11), %r10d
cmpl %r11d, %r14d
cmovel %edx, %r10d
cmpq %r9, %rsi
jne 0xa4fe
incl %ebp
incq %r8
movslq (%rcx,%rsi,4), %r9
cmpq %r9, %r8
jl 0xa4cb
incq %rsi
movslq 0x1c(%rbx), %rdi
cmpq %rdi, %rsi
jl 0xa4ba
testl %edi, %edi
jle 0xa5b9
xorl %r15d, %r15d
leaq 0x2e8de(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xa5ad
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0xa591
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xa575
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xa567
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::vertices(std::vector<double, std::allocator<double>>&)
void voronoicell_base::vertices(std::vector<double> &v) {
	v.resize(3*p);
	double *ptsp=pts;
	for(int i=0;i<3*p;i+=3) {
		v[i]=*(ptsp++)*0.5;
		v[i+1]=*(ptsp++)*0.5;
		v[i+2]=*ptsp*0.5;ptsp+=2;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x1c(%rdi), %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
callq 0x11f2e
movl 0x1c(%r14), %eax
testl %eax, %eax
jle 0xa6e7
leaq (%rax,%rax,2), %rax
movq 0x40(%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x2c979(%rip), %xmm0    # 0x37028
movsd (%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x20, %rcx
addq $0x3, %rsi
cmpq %rax, %rsi
jb 0xa6af
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::vertices(double, double, double, std::vector<double, std::allocator<double>>&)
void voronoicell_base::vertices(double x,double y,double z,std::vector<double> &v) {
	v.resize(3*p);
	double *ptsp=pts;
	for(int i=0;i<3*p;i+=3) {
		v[i]=x+*(ptsp++)*0.5;
		v[i+1]=y+*(ptsp++)*0.5;
		v[i+2]=z+*ptsp*0.5;ptsp+=2;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %r14
movslq 0x1c(%rdi), %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
callq 0x11f2e
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movl 0x1c(%r14), %eax
testl %eax, %eax
jle 0xa856
leaq (%rax,%rax,2), %rax
movq 0x40(%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x2c816(%rip), %xmm0    # 0x37028
movsd (%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm4, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x20, %rcx
addq $0x3, %rsi
cmpq %rax, %rsi
jb 0xa812
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::face_orders(std::vector<int, std::allocator<int>>&)
void voronoicell_base::face_orders(std::vector<int> &v) {
	int i,j,k,l,m,q;
	v.clear();
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			q=1;
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				q++;
				m=ed[k][l];
				ed[k][l]=-1-m;
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);
			v.push_back(q);;
		}
	}
	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 0xaebe
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
jl 0xafbe
movl $0x1, %r12d
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0xafae
leaq (%rax,%r12,4), %rsi
xorl %ebp, %ebp
movq 0x28(%rbx), %rcx
movq (%rcx,%r12,8), %rdi
movslq (%rdi,%rbp,4), %rdx
testq %rdx, %rdx
js 0xaf97
movl $0x1, 0x4(%rsp)
movl %edx, %r8d
notl %r8d
movl %r8d, (%rdi,%rbp,4)
movslq (%rsi), %rsi
movslq %ebp, %r8
addq %rsi, %r8
movl (%rdi,%r8,4), %edi
movl (%rax,%rdx,4), %r8d
decl %r8d
leal 0x1(%rdi), %esi
cmpl %edi, %r8d
cmovel %r13d, %esi
incl 0x4(%rsp)
movslq %edx, %rdi
movq (%rcx,%rdi,8), %r8
movslq %esi, %rsi
movl (%r8,%rsi,4), %edx
movl %edx, %r9d
notl %r9d
movl %r9d, (%r8,%rsi,4)
movslq (%rax,%rdi,4), %rdi
addq %rsi, %rdi
movl (%r8,%rdi,4), %edi
movslq %edx, %rsi
movl (%rax,%rsi,4), %r8d
decl %r8d
leal 0x1(%rdi), %esi
cmpl %edi, %r8d
cmovel %r13d, %esi
cmpq %rdx, %r12
jne 0xaf32
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xaf8c
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xaf97
movq %r14, %rdi
movq %r15, %rdx
callq 0x12486
incq %rbp
movq 0x30(%rbx), %rax
leaq (%rax,%r12,4), %rsi
movslq (%rsi), %rcx
cmpq %rcx, %rbp
jl 0xaeed
incq %r12
movslq 0x1c(%rbx), %rax
cmpq %rax, %r12
jl 0xaed8
testl %eax, %eax
jle 0xb01e
xorl %r15d, %r15d
leaq 0x2de79(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xb012
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0xaff6
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xafda
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xafcc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::face_freq_table(std::vector<int, std::allocator<int>>&)
void voronoicell_base::face_freq_table(std::vector<int> &v) {
	int i,j,k,l,m,q;
	v.clear();
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			q=1;
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				q++;
				m=ed[k][l];
				ed[k][l]=-1-m;
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);
			if((unsigned int) q>=v.size()) v.resize(q+1,0);
			v[q]++;
		}
	}
	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 0xb04c
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
jl 0xb14f
movl $0x1, %r12d
xorl %r13d, %r13d
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0xb13f
leaq (%rax,%r12,4), %rsi
xorl %ebp, %ebp
movq 0x28(%rbx), %rcx
movq (%rcx,%r12,8), %rdi
movslq (%rdi,%rbp,4), %rdx
testq %rdx, %rdx
js 0xb128
movl %edx, %r8d
notl %r8d
movl %r8d, (%rdi,%rbp,4)
movslq (%rsi), %rsi
movslq %ebp, %r8
addq %rsi, %r8
movl (%rdi,%r8,4), %edi
movl (%rax,%rdx,4), %r8d
decl %r8d
leal 0x1(%rdi), %esi
cmpl %edi, %r8d
cmovel %r13d, %esi
movl $0x1, %r15d
movslq %edx, %rdi
movq (%rcx,%rdi,8), %r8
movslq %esi, %rsi
movl (%r8,%rsi,4), %edx
movl %edx, %r9d
notl %r9d
movl %r9d, (%r8,%rsi,4)
movslq (%rax,%rdi,4), %rdi
addq %rsi, %rdi
movl (%r8,%rdi,4), %edi
movslq %edx, %rsi
movl (%rax,%rsi,4), %r8d
decl %r8d
leal 0x1(%rdi), %esi
cmpl %edi, %r8d
cmovel %r13d, %esi
incq %r15
cmpq %rdx, %r12
jne 0xb0b9
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x2, %rax
cmpq %r15, %rax
ja 0xb121
leaq 0x1(%r15), %rsi
movl $0x0, 0x4(%rsp)
movq %r14, %rdi
leaq 0x4(%rsp), %rdx
callq 0x11f60
movq (%r14), %rax
incl (%rax,%r15,4)
incq %rbp
movq 0x30(%rbx), %rax
leaq (%rax,%r12,4), %rsi
movslq (%rsi), %rcx
cmpq %rcx, %rbp
jl 0xb076
incq %r12
movslq 0x1c(%rbx), %rax
cmpq %rax, %r12
jl 0xb061
testl %eax, %eax
jle 0xb1af
xorl %r15d, %r15d
leaq 0x2dce8(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xb1a3
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0xb187
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xb16b
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xb15d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/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 0xb3d3
movl 0x1c(%rdi), %edx
movl %edx, %esi
sarl $0x3, %esi
cmpl $0x2, %esi
jl 0xb346
leaq 0x30(%rcx), %r8
movl $0x1, %r9d
movl $0x1, %r10d
movsd -0x8(%r8), %xmm5
mulsd %xmm1, %xmm5
movsd -0x10(%r8), %xmm6
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd (%r8), %xmm5
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
ucomisd %xmm4, %xmm5
jbe 0xb337
ucomisd %xmm3, %xmm5
ja 0xb3d3
movl %r9d, 0x20(%rdi)
movapd %xmm5, %xmm4
addl %r9d, %r10d
incl %r9d
addq $0x20, %r8
cmpl %esi, %r10d
jl 0xb2fa
testl %edx, %edx
setg %al
jle 0xb3d3
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
ucomisd %xmm3, %xmm4
movb $0x1, %al
ja 0xb3d3
movl $0x1, %edi
movl $0x6, %eax
movq %rdi, %rsi
cmpq %rdi, %rdx
je 0xb3cd
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 0xb385
cmpq %rdx, %rsi
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x730a
movq 0xe8(%rbx), %rax
movq 0x18(%rax), %rax
movaps 0x2d0e5(%rip), %xmm0    # 0x388e0
movups %xmm0, (%rax)
leaq 0xc(%rax), %rcx
movaps 0x2d0e7(%rip), %xmm0    # 0x388f0
movups %xmm0, 0x10(%rax)
leaq 0x18(%rax), %rdx
movaps 0x2d0e8(%rip), %xmm0    # 0x38900
movups %xmm0, 0x20(%rax)
leaq 0x24(%rax), %rsi
leaq 0x30(%rax), %rdi
movaps 0x2d0e5(%rip), %xmm0    # 0x38910
movups %xmm0, 0x30(%rax)
leaq 0x3c(%rax), %r8
movaps 0x2d0e6(%rip), %xmm0    # 0x38920
movups %xmm0, 0x40(%rax)
leaq 0x48(%rax), %r9
movaps 0x2d0e7(%rip), %xmm0    # 0x38930
movups %xmm0, 0x50(%rax)
movq 0xf0(%rbx), %r10
movq %rax, (%r10)
addq $0x54, %rax
movq 0xf0(%rbx), %r10
movq %rcx, 0x8(%r10)
movq 0xf0(%rbx), %rcx
movq %rdx, 0x10(%rcx)
movq 0xf0(%rbx), %rcx
movq %rsi, 0x18(%rcx)
movq 0xf0(%rbx), %rcx
movq %rdi, 0x20(%rcx)
movq 0xf0(%rbx), %rcx
movq %r8, 0x28(%rcx)
movq 0xf0(%rbx), %rcx
movq %r9, 0x30(%rcx)
movq 0xf0(%rbx), %rcx
movq %rax, 0x38(%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x78a4
movq 0xe8(%rbx), %rax
movq 0x20(%rax), %rax
movaps 0x2d07b(%rip), %xmm0    # 0x38940
movups %xmm0, (%rax)
leaq 0x10(%rax), %rcx
movaps 0x2d07d(%rip), %xmm0    # 0x38950
movups %xmm0, 0x10(%rax)
leaq 0x20(%rax), %rdx
movaps 0x2d07e(%rip), %xmm0    # 0x38960
movups %xmm0, 0x20(%rax)
leaq 0x30(%rax), %rsi
movaps 0x2d07f(%rip), %xmm0    # 0x38970
movups %xmm0, 0x30(%rax)
leaq 0x40(%rax), %rdi
movaps 0x2d080(%rip), %xmm0    # 0x38980
movups %xmm0, 0x40(%rax)
leaq 0x50(%rax), %r8
movaps 0x2d081(%rip), %xmm0    # 0x38990
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_O1/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 0x7a4a
movq 0xe8(%rbx), %rax
movq 0x18(%rax), %rax
movaps 0x2d014(%rip), %xmm0    # 0x389a0
movups %xmm0, (%rax)
leaq 0xc(%rax), %rcx
movaps 0x2d016(%rip), %xmm0    # 0x389b0
movups %xmm0, 0x10(%rax)
leaq 0x18(%rax), %rdx
movaps 0x2d017(%rip), %xmm0    # 0x389c0
movups %xmm0, 0x20(%rax)
movq 0xf0(%rbx), %rsi
movq %rax, (%rsi)
addq $0x24, %rax
movq 0xf0(%rbx), %rsi
movq %rcx, 0x8(%rsi)
movq 0xf0(%rbx), %rcx
movq %rdx, 0x10(%rcx)
movq 0xf0(%rbx), %rcx
movq %rax, 0x18(%rcx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl $0x2, %eax
jl 0xbb1b
movl $0x1, %r14d
xorl %r9d, %r9d
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0xbb0b
leaq (%rax,%r14,4), %rcx
xorl %r10d, %r10d
movq 0x28(%rbx), %rdx
movq (%rdx,%r14,8), %rsi
movslq (%rsi,%r10,4), %rdx
testq %rdx, %rdx
js 0xbaf4
movl %edx, %edi
notl %edi
movl %edi, (%rsi,%r10,4)
movq 0xf0(%rbx), %rdi
movq (%rdi,%r14,8), %rdi
movl (%rdi,%r10,4), %r13d
movslq (%rcx), %rcx
movslq %r10d, %rdi
addq %rcx, %rdi
movl (%rsi,%rdi,4), %esi
movl (%rax,%rdx,4), %eax
decl %eax
leal 0x1(%rsi), %ecx
cmpl %esi, %eax
cmovel %r9d, %ecx
movq %r10, (%rsp)
movq 0x28(%rbx), %rax
movslq %edx, %r12
movq (%rax,%r12,8), %rax
movslq %ecx, %rbp
movl (%rax,%rbp,4), %r15d
movl %r15d, %esi
notl %esi
movl %esi, (%rax,%rbp,4)
movq 0xf0(%rbx), %rax
movq (%rax,%r12,8), %rax
movl (%rax,%rbp,4), %r8d
cmpl %r13d, %r8d
jne 0xbac7
movslq %r15d, %rax
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
movq (%rcx,%r12,8), %rcx
movslq (%rdx,%r12,4), %rsi
addq %rbp, %rsi
movl (%rcx,%rsi,4), %esi
movl (%rdx,%rax,4), %eax
decl %eax
leal 0x1(%rsi), %ecx
cmpl %esi, %eax
cmovel %r9d, %ecx
movl %r15d, %eax
movl %r15d, %edx
cmpq %rax, %r14
jne 0xba65
jmp 0xbaf4
movq 0x3a512(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
leaq 0x2d2fc(%rip), %rsi     # 0x38dd4
movl %r14d, %r9d
xorl %eax, %eax
pushq %r13
pushq %r10
callq 0x21b0
movq 0x10(%rsp), %r10
xorl %r9d, %r9d
addq $0x10, %rsp
jmp 0xba93
incq %r10
movq 0x30(%rbx), %rax
leaq (%rax,%r14,4), %rcx
movslq (%rcx), %rdx
cmpq %rdx, %r10
jl 0xba1b
incq %r14
movslq 0x1c(%rbx), %rax
cmpq %rax, %r14
jl 0xba05
testl %eax, %eax
jle 0xbb7b
xorl %r15d, %r15d
leaq 0x2d31c(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xbb6f
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0xbb53
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xbb37
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xbb29
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/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 0xbbe0
movl $0xc00, %edi            # imm = 0xC00
callq 0x2030
movq 0xe8(%rbx), %rcx
movq %rax, 0x18(%rcx)
cmpl $0x5, %r15d
jl 0xbc4b
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 0xbc2b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbcf0
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
jl 0xbde9
movl $0x1, %r15d
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xbdd9
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
movslq (%rax,%r13,4), %rbp
testq %rbp, %rbp
js 0xbdc5
movq 0xf0(%rbx), %rax
leaq (,%r13,4), %rdx
addq (%rax,%r15,8), %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xbd57
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xbd5f
movq %r14, %rdi
callq 0x12486
movl %ebp, %ecx
notl %ecx
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdx
movl %ecx, (%rdx,%r13,4)
movq 0x30(%rbx), %rcx
movslq (%rcx,%r15,4), %rsi
movslq %r13d, %rdi
addq %rsi, %rdi
movl (%rdx,%rdi,4), %esi
movl (%rcx,%rbp,4), %edi
decl %edi
leal 0x1(%rsi), %edx
cmpl %esi, %edi
cmovel %r12d, %edx
movslq %ebp, %rsi
movq (%rax,%rsi,8), %rdi
movslq %edx, %rdx
movl (%rdi,%rdx,4), %ebp
movl %ebp, %r8d
notl %r8d
movl %r8d, (%rdi,%rdx,4)
movslq (%rcx,%rsi,4), %rsi
addq %rdx, %rsi
movl (%rdi,%rsi,4), %esi
movslq %ebp, %rdx
movl (%rcx,%rdx,4), %edi
decl %edi
leal 0x1(%rsi), %edx
cmpl %esi, %edi
cmovel %r12d, %edx
cmpq %rbp, %r15
jne 0xbd8e
incq %r13
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r13
jl 0xbd17
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xbd05
testl %eax, %eax
jle 0xbe49
xorl %r15d, %r15d
leaq 0x2d04e(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0xbe3d
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0xbe21
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0xbe05
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0xbdf7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/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 0xbfce
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r12
leaq 0x2cf97(%rip), %r15     # 0x38e12
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movl (%rax,%r14,4), %edx
leaq 0x2cf7b(%rip), %rdi     # 0x38e08
movl %r14d, %esi
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
movl $0x0, %r13d
jle 0xbed1
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 0xbeab
leaq 0x2cf35(%rip), %rdi     # 0x38e0d
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
movl (%rax,%r14,4), %eax
addl %eax, %eax
movl %r13d, %ebp
cmpl %eax, %r13d
jge 0xbf12
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
jmp 0xbeec
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%rbp,4), %esi
leaq 0x2ceec(%rip), %rdi     # 0x38e10
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 0x2cebc(%rip), %rdi     # 0x38e16
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 0xbfa0
movl $0xa, %edi
callq 0x2190
jmp 0xbfac
leaq 0x2ce7d(%rip), %rdi     # 0x38e24
callq 0x21d0
incq %r14
addq $0x20, %r12
movslq 0x1c(%rbx), %rax
cmpq %rax, %r14
jl 0xbe7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/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 0xc063
movq %rdi, %rbx
leaq 0x2ce42(%rip), %rdi     # 0x38e32
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x2040
movq 0x30(%rbx), %rax
cmpl $0x2, (%rax,%r15,4)
jl 0xc03b
leaq 0x2ce2d(%rip), %r14     # 0x38e39
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 0xc00f
movq 0xf0(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %esi
leaq 0x2d0ad(%rip), %rdi     # 0x390fe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
leaq 0x2cdd3(%rip), %rdi     # 0x38e3d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rdi), %r13
movq %r13, %rdx
subq 0x90(%rdi), %rdx
movl (%rsi), %eax
leaq 0x4(%r13), %rcx
movq %rcx, 0x98(%rdi)
movl %eax, (%r13)
shrq $0x2, %rdx
movq %rdx, 0x10(%rsp)
movslq %edx, %rbp
leaq 0x4(,%rbp,4), %rax
movq %rax, 0x18(%rsp)
movb $0x1, %al
movb %al, 0xf(%rsp)
movslq (%r13), %rax
movl %eax, (%r14)
movq 0x30(%rbx), %rcx
cmpl $0x0, (%rcx,%rax,4)
jle 0x12867
xorl %r15d, %r15d
movq 0x28(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq (%rcx,%rax,8), %rax
movl (%rax,%r15,4), %r12d
movslq %r12d, %rcx
movl (%rdx,%rcx,4), %eax
cmpl 0xc0(%rbx), %eax
jae 0x127c5
movq %rbx, %rdi
movl %r12d, %esi
leaq 0x20(%rsp), %rdx
callq 0xa318
jmp 0x127dc
movq 0x40(%rbx), %rdx
shlq $0x5, %rcx
movsd 0x18(%rdx,%rcx), %xmm0
movsd %xmm0, 0x20(%rsp)
andl $0x3, %eax
cmpl $0x1, %eax
je 0x127ea
testl %eax, %eax
jne 0x12844
jmp 0x1287d
movq 0x90(%rbx), %rcx
movq 0x98(%rbx), %rax
leaq (%rcx,%rbp,4), %rsi
cmpq %rax, %rsi
setb %dl
jae 0x12826
cmpl %r12d, (%rsi)
je 0x12822
addq 0x18(%rsp), %rcx
cmpq %rax, %rcx
setb %dl
jae 0x12826
leaq 0x4(%rcx), %rsi
cmpl %r12d, (%rcx)
movq %rsi, %rcx
jne 0x1280e
testb %dl, %dl
jne 0x12844
cmpq 0xa0(%rbx), %rax
je 0x1285d
movq 0x98(%rbx), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x98(%rbx)
movl %r12d, (%rax)
incq %r15
movq 0x30(%rbx), %rcx
movslq (%r14), %rax
movslq (%rcx,%rax,4), %rcx
cmpq %rcx, %r15
jl 0x12795
jmp 0x12867
movq %rbx, %rdi
callq 0x24b8
jmp 0x1282f
addq $0x4, %r13
cmpq 0x98(%rbx), %r13
setb %al
jb 0x12779
jmp 0x12881
movb 0xf(%rsp), %al
movslq 0x10(%rsp), %rcx
shlq $0x2, %rcx
addq 0x90(%rbx), %rcx
movq %rcx, 0x98(%rbx)
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: bool voro::voronoicell_base::collapse_order1<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&)
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)
setle %bpl
jle 0x12ddd
movq %rsi, %rbx
movq %rdi, %r14
movq 0x33370(%rip), %r12     # 0x45fe0
leaq 0x2626b(%rip), %r15     # 0x38ee2
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 0x12df2
testb %al, %al
je 0x12ddd
movl 0x1c(%r14), %eax
movl 0x20(%r14), %ecx
decl %eax
movl %eax, 0x1c(%r14)
cmpl %r13d, %ecx
jne 0x12ce2
movl $0x0, 0x20(%r14)
cmpl %r13d, %eax
je 0x12dcb
cmpl %eax, 0x20(%r14)
jne 0x12cf5
movl %r13d, 0x20(%r14)
movq 0x40(%r14), %rcx
leal (,%rax,4), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
leal (,%r13,4), %edx
movslq %edx, %rdx
movsd %xmm0, (%rcx,%rdx,8)
leal 0x1(,%rax,4), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
leal 0x1(,%r13,4), %edx
movslq %edx, %rdx
movsd %xmm0, (%rcx,%rdx,8)
leal 0x2(,%rax,4), %eax
cltq
movsd (%rcx,%rax,8), %xmm0
leal 0x2(,%r13,4), %eax
cltq
movsd %xmm0, (%rcx,%rax,8)
movq 0x30(%r14), %rcx
movslq 0x1c(%r14), %rax
movl (%rcx,%rax,4), %edi
testl %edi, %edi
jle 0x12d93
movq 0x28(%r14), %rdx
xorl %esi, %esi
movq (%rdx,%rax,8), %rax
movslq (%rax,%rsi,4), %r8
movq (%rdx,%r8,8), %r8
movslq %edi, %rdi
addq %rsi, %rdi
movslq (%rax,%rdi,4), %rax
movl %r13d, (%r8,%rax,4)
incq %rsi
movslq 0x1c(%r14), %rax
movslq (%rcx,%rax,4), %rdi
cmpq %rdi, %rsi
jl 0x12d69
movslq %r13d, %rcx
movq 0xf0(%rbx), %rdx
movq (%rdx,%rax,8), %rsi
movq %rsi, (%rdx,%rcx,8)
movq 0x28(%r14), %rdx
movq (%rdx,%rax,8), %rsi
movq %rsi, (%rdx,%rcx,8)
movq 0x30(%r14), %rdx
movl (%rdx,%rax,4), %eax
movl %eax, (%rdx,%rcx,4)
movq 0x28(%r14), %rdx
movq (%rdx,%rcx,8), %rcx
addl %eax, %eax
cltq
movl %r13d, (%rcx,%rax,4)
movq 0x68(%r14), %rax
cmpl $0x0, 0x4(%rax)
setle %bpl
jg 0x12c77
andb $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_O1/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 0x25efa(%rip), %xmm6    # 0x39060
ucomisd %xmm8, %xmm6
ja 0x1316e
retq
pushq %rax
movl %esi, %eax
movl %edi, %esi
leaq 0x25eee(%rip), %rdi     # 0x39068
movl %eax, %edx
movb $0x6, %al
callq 0x2040
movl $0x1, %edi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1325d
popq %rbx
retq
movq %rbx, %rdi
callq 0x2cad
// File: /workspace/github_cpp_makefile_star2_O1/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 0x132c5
leaq 0x25e3a(%rip), %r15     # 0x390c6
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 0x1328f
leal 0x4(%r13), %eax
jmp 0x132cd
movl $0x4, %eax
xorl %r13d, %r13d
movl %r13d, %esi
orl $0x3, %esi
cmpl %r12d, %esi
jle 0x13308
movl %r13d, %eax
orl $0x2, %r13d
movq (%r14), %rcx
movl (%rcx,%rax,4), %edx
cmpl %r12d, %r13d
jne 0x13341
movl 0x4(%rcx,%rax,4), %ecx
leaq 0x25de4(%rip), %rsi     # 0x390d9
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 0x1335b
movl %esi, %eax
movl (%rdi,%rax,4), %r9d
leaq 0x25da5(%rip), %rsi     # 0x390d3
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25acb(%rip), %rsi     # 0x38e13
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25d74(%rip), %rsi     # 0x390d6
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x133dd
xorl %r13d, %r13d
leaq 0x25d40(%rip), %r15     # 0x390df
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 0x1339f
leal 0x4(%r13), %eax
jmp 0x133e5
movl $0x4, %eax
xorl %r13d, %r13d
movl %r13d, %ecx
orl $0x3, %ecx
cmpl %r12d, %ecx
jle 0x13424
movl %r13d, %eax
orl $0x2, %r13d
movq (%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
cmpl %r12d, %r13d
jne 0x13461
movsd 0x8(%rcx,%rax,8), %xmm1
leaq 0x25ce1(%rip), %rsi     # 0x390f2
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 0x1347b
movl %ecx, %eax
movsd (%rdx,%rax,8), %xmm3
leaq 0x25c9e(%rip), %rsi     # 0x390ec
movq %rbx, %rdi
movb $0x4, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25c8d(%rip), %rsi     # 0x390f5
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
leaq 0x25c6d(%rip), %rsi     # 0x390ef
movq %rbx, %rdi
movb $0x3, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x10(%rdi)
jle 0x139ab
xorl %r14d, %r14d
movq 0xb8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1399f
callq 0x2180
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x1398a
cmpl $0x0, 0x10(%rbx)
jle 0x139d5
xorl %r14d, %r14d
movq 0xb0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x139c9
callq 0x2180
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x139b4
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x139e6
callq 0x2180
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x139f7
callq 0x2180
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x13a08
callq 0x2180
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x13a19
callq 0x2180
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x13a27
callq 0x2180
movq 0x48(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x13a3c
popq %rbx
popq %r14
jmp 0x2180
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::put(int, double, double, double)
void container::put(int n,double x,double y,double z) {
	int ijk;
	if(put_locate_block(ijk,x,y,z)) {
		id[ijk][co[ijk]]=n;
		double *pp=p[ijk]+3*co[ijk]++;
		*(pp++)=x;*(pp++)=y;*pp=z;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
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 0x13c30
testb %al, %al
je 0x13c28
movslq 0xc(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movq 0xb8(%rbx), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rdx,%rcx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rcx,4)
leaq (%rsi,%rsi,2), %rcx
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rcx,8)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax,%rcx,8)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_poly::put(int, double, double, double, double)
void container_poly::put(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;
		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 %rbx
subq $0x28, %rsp
movsd %xmm3, 0x8(%rsp)
movl %esi, %ebp
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 0x13c30
testb %al, %al
je 0x13d30
movslq 0x4(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movq 0xb8(%rbx), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rdx,%rcx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rcx,4)
shlq $0x5, %rsi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%rsi)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rsi)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax,%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rax,%rsi)
ucomisd 0xe0(%rbx), %xmm0
jbe 0x13d30
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xe0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13c30
testb %al, %al
je 0x13e1a
movslq 0xc(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movslq 0xc(%rsp), %r15
movl (%rdx,%r15,4), %ebp
movslq 0x10(%r14), %rax
shlq $0x2, %rax
addq (%r14), %rax
cmpq %rax, 0x8(%r14)
jne 0x13db8
movq %r14, %rdi
callq 0x2eb52
movq 0x8(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %r15d, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %ebp, 0x4(%rax)
movslq 0xc(%rsp), %rax
movq 0xb8(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rax,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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13c30
testb %al, %al
je 0x13f2c
movslq 0x4(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movslq 0x4(%rsp), %r15
movl (%rdx,%r15,4), %ebp
movslq 0x10(%r14), %rax
shlq $0x2, %rax
addq (%r14), %rax
cmpq %rax, 0x8(%r14)
jne 0x13eac
movq %r14, %rdi
callq 0x2eb52
movq 0x8(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %r15d, (%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl %ebp, 0x4(%rax)
movslq 0x4(%rsp), %rax
movq 0xb8(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rax,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 0x13f2c
movsd %xmm0, 0xe0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
addl %eax, %eax
movl %eax, 0x4(%rsp)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x13f72
leaq 0x2519f(%rip), %rdi     # 0x39107
movl $0x2, %esi
callq 0x1318d
movl 0x4(%rsp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
testl %eax, %eax
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq 0xc0(%rbx), %r13
cmpl $0x0, (%r13,%r12,4)
jle 0x13fc2
movq 0xb0(%rbx), %rax
movq (%rax,%r12,8), %rax
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
movslq (%r13,%r12,4), %rdx
cmpq %rdx, %rcx
jl 0x13fae
movl 0xd0(%rbx), %ebp
movl %ebp, %eax
imull 0x4(%rsp), %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
imull (%r13,%r12,4), %ebp
testl %ebp, %ebp
jle 0x14013
movq 0xb8(%rbx), %rax
movq (%rax,%r12,8), %rax
movl %ebp, %ecx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x14000
movq 0xc8(%rbx), %rax
movl 0x4(%rsp), %ecx
movl %ecx, (%rax,%r12,4)
movq 0xb0(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x14037
callq 0x2180
movq 0xb0(%rbx), %rax
movq %r14, (%rax,%r12,8)
movq 0xb8(%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x14057
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
nop