LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::out_of_bounds()
bool c_loop_subset::out_of_bounds() {
	double *pp=p[ijk]+ps*q;
	if(mode==sphere) {
		double fx(*pp+px-v0),fy(pp[1]+py-v1),fz(pp[2]+pz-v2);
		return fx*fx+fy*fy+fz*fz>v3;
	} else {
		double f(*pp+px);if(f<v0||f>v1) return true;
		f=pp[1]+py;if(f<v2||f>v3) return true;
		f=pp[2]+pz;return f<v4||f>v5;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rax), %rcx
movslq 0x3c(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x14(%rax), %edx
imull 0x40(%rax), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x18(%rbp)
cmpl $0x0, 0x44(%rax)
jne 0x4a2db
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
addsd 0x98(%rax), %xmm0
subsd 0xc8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
addsd 0xa0(%rax), %xmm0
subsd 0xd0(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
addsd 0xa8(%rax), %xmm0
subsd 0xd8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
ucomisd 0xe0(%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4a3ba
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
addsd 0x98(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0xc8(%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0x4a31a
movq -0x40(%rbp), %rax
movsd -0x38(%rbp), %xmm0
ucomisd 0xd0(%rax), %xmm0
jbe 0x4a323
movb $0x1, -0x1(%rbp)
jmp 0x4a3ba
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
addsd 0xa0(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0xd8(%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0x4a363
movq -0x40(%rbp), %rax
movsd -0x38(%rbp), %xmm0
ucomisd 0xe0(%rax), %xmm0
jbe 0x4a369
movb $0x1, -0x1(%rbp)
jmp 0x4a3ba
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
addsd 0xa8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0xe8(%rax), %xmm0
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
ja 0x4a3b2
movq -0x40(%rbp), %rax
movsd -0x38(%rbp), %xmm0
ucomisd 0xf0(%rax), %xmm0
seta %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::setup_box(double, double, double, double, double, double, bool)
void c_loop_subset::setup_box(double xmin,double xmax,double ymin,double ymax,double zmin,double zmax,bool bounds_test) {
	if(bounds_test) {mode=box;v0=xmin;v1=xmax;v2=ymin;v3=ymax;v4=zmin;v5=zmax;} else mode=no_check;
	ai=step_int((xmin-ax)*xsp);
	bi=step_int((xmax-ax)*xsp);
	aj=step_int((ymin-ay)*ysp);
	bj=step_int((ymax-ay)*ysp);
	ak=step_int((zmin-az)*zsp);
	bk=step_int((zmax-az)*zsp);
	setup_common();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, -0x39(%rbp)
je 0x4a46b
movq -0x48(%rbp), %rax
movl $0x1, 0x44(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0xc8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0xd0(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0xd8(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0xe0(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0xe8(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xf0(%rax)
jmp 0x4a476
movq -0x48(%rbp), %rax
movl $0x2, 0x44(%rax)
movq -0x48(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
subsd 0x48(%rdi), %xmm0
mulsd 0x78(%rdi), %xmm0
callq 0x4a620
movq -0x48(%rbp), %rdi
movl %eax, 0xf8(%rdi)
movsd -0x18(%rbp), %xmm0
subsd 0x48(%rdi), %xmm0
mulsd 0x78(%rdi), %xmm0
callq 0x4a620
movq -0x48(%rbp), %rdi
movl %eax, 0xfc(%rdi)
movsd -0x20(%rbp), %xmm0
subsd 0x50(%rdi), %xmm0
mulsd 0x80(%rdi), %xmm0
callq 0x4a620
movq -0x48(%rbp), %rdi
movl %eax, 0x100(%rdi)
movsd -0x28(%rbp), %xmm0
subsd 0x50(%rdi), %xmm0
mulsd 0x80(%rdi), %xmm0
callq 0x4a620
movq -0x48(%rbp), %rdi
movl %eax, 0x104(%rdi)
movsd -0x30(%rbp), %xmm0
subsd 0x58(%rdi), %xmm0
mulsd 0x88(%rdi), %xmm0
callq 0x4a620
movq -0x48(%rbp), %rdi
movl %eax, 0x108(%rdi)
movsd -0x38(%rbp), %xmm0
subsd 0x58(%rdi), %xmm0
mulsd 0x88(%rdi), %xmm0
callq 0x4a620
movq -0x48(%rbp), %rdi
movl %eax, 0x10c(%rdi)
callq 0x49b90
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::particle_order::add_ordering_memory()
void particle_order::add_ordering_memory() {
	int *no=new int[size<<2],*nop=no,*opp=o;
	while(opp<op) *(nop++)=*(opp++);
	delete [] o;
	size<<=1;o=no;op=nop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rax), %eax
shll $0x2, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x4a5d9
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
jmp 0x4a5a7
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4a5f3
movq -0x30(%rbp), %rdi
callq 0x2180
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/voro++/src/v_base.cc
// Function: voro::voro_base::contains_neighbor(char const*)
bool voro_base::contains_neighbor(const char *format) {
	char *fmp=(const_cast<char*>(format));

	// Check to see if "%n" appears in the format sequence
	while(*fmp!=0) {
		if(*fmp=='%') {
			fmp++;
			if(*fmp=='n') return true;
			else if(*fmp==0) return false;
		}
		fmp++;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4b26e
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x4b260
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x4b24a
movb $0x1, -0x1(%rbp)
jmp 0x4b272
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4b25c
movb $0x0, -0x1(%rbp)
jmp 0x4b272
jmp 0x4b25e
jmp 0x4b260
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4b214
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/wall.cc
// Function: voro::wall_cylinder::point_inside(double, double, double)
bool wall_cylinder::point_inside(double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc;
	double pa=(xd*xa+yd*ya+zd*za)*asi;
	xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
	return xd*xd+yd*yd+zd*zd<rc*rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm0
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm1
movsd 0x28(%rax), %xmm2
movsd -0x30(%rbp), %xmm0
mulsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movsd 0x38(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x40(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x28(%rax), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x30(%rax), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x38(%rax), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x48(%rax), %xmm0
mulsd 0x48(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/wall.cc
// Function: voro::wall_cone::point_inside(double, double, double)
bool wall_cone::point_inside(double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xd*xa+yd*ya+zd*za)*asi;
	xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
	pa*=gra;
	if (pa<0) return false;
	pa*=pa;
	return xd*xd+yd*yd+zd*zd<pa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm1
movsd 0x28(%rax), %xmm2
movsd -0x38(%rbp), %xmm0
mulsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
movsd 0x38(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x40(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x28(%rax), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x30(%rax), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x38(%rax), %xmm0
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x48(%rax), %xmm0
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x48(%rbp), %xmm0
jbe 0x4b5fc
movb $0x0, -0x1(%rbp)
jmp 0x4b64a
movsd -0x48(%rbp), %xmm0
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x40(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_sphere::cut_cell_base<voro::voronoicell>(voro::voronoicell&, double, double, double)
bool wall_sphere::cut_cell_base(v_cell &c,double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc,dq=xd*xd+yd*yd+zd*zd;
	if (dq>1e-5) {
		dq=2*(sqrt(dq)*rc-dq);
		return c.nplane(xd,yd,zd,dq,w_id);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x20(%rbp), %xmm0
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0x10b0c(%rip), %xmm1    # 0x5c200
ucomisd %xmm1, %xmm0
jbe 0x4b76c
movsd -0x50(%rbp), %xmm0
callq 0x20f0
movq -0x58(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x28(%rax), %xmm2
movsd -0x50(%rbp), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xbecc(%rip), %xmm0     # 0x57608
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movsd -0x50(%rbp), %xmm3
movl 0x8(%rax), %esi
callq 0x21ec0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4b770
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/wall.cc
// Function: bool voro::wall_cylinder::cut_cell_base<voro::voronoicell>(voro::voronoicell&, double, double, double)
bool wall_cylinder::cut_cell_base(v_cell &c,double x,double y,double z) {
	double xd=x-xc,yd=y-yc,zd=z-zc,pa=(xd*xa+yd*ya+zd*za)*asi;
	xd-=xa*pa;yd-=ya*pa;zd-=za*pa;
	pa=xd*xd+yd*yd+zd*zd;
	if(pa>1e-5) {
		pa=2*(sqrt(pa)*rc-pa);
		return c.nplane(xd,yd,zd,pa,w_id);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x20(%rbp), %xmm0
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0x28(%rax), %xmm2
movsd -0x40(%rbp), %xmm0
mulsd 0x30(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movsd 0x38(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x40(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x28(%rax), %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x30(%rax), %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x38(%rax), %xmm0
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0x1063b(%rip), %xmm1    # 0x5c200
ucomisd %xmm1, %xmm0
jbe 0x4bc3d
movsd -0x50(%rbp), %xmm0
callq 0x20f0
movq -0x58(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x48(%rax), %xmm2
movsd -0x50(%rbp), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xb9fb(%rip), %xmm0     # 0x57608
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movsd -0x50(%rbp), %xmm3
movl 0x8(%rax), %esi
callq 0x21ec0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4bc41
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::~pre_container_base()
pre_container_base::~pre_container_base() {
	delete [] *end_p;
	delete [] *end_id;
	while (end_id!=pre_id) {
		end_p--;
		delete [] *end_p;
		end_id--;
		delete [] *end_id;
	}
	delete [] pre_p;
	delete [] pre_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x70(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4c9ce
movq -0x10(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4c9ec
movq -0x20(%rbp), %rdi
callq 0x2180
jmp 0x4c9ee
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rax
cmpq 0x40(%rcx), %rax
je 0x4ca52
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x70(%rax)
movq 0x70(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4ca26
movq -0x28(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x48(%rax)
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4ca50
movq -0x30(%rbp), %rdi
callq 0x2180
jmp 0x4c9ee
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4ca6d
movq -0x38(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4ca88
movq -0x40(%rbp), %rdi
callq 0x2180
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::guess_optimal(int&, int&, int&)
void pre_container_base::guess_optimal(int &nx,int &ny,int &nz) {
	double dx=bx-ax,dy=by-ay,dz=bz-az;
	double ilscale=pow(total_particles()/(optimal_particles*dx*dy*dz),1/3.0);
	nx=int(dx*ilscale+1);
	ny=int(dy*ilscale+1);
	nz=int(dz*ilscale+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x8(%rdi), %xmm0
subsd (%rdi), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x18(%rdi), %xmm0
subsd 0x10(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x28(%rdi), %xmm0
subsd 0x20(%rdi), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x4d8f0
cvtsi2sd %eax, %xmm0
movsd 0xf77f(%rip), %xmm1     # 0x5c268
mulsd -0x28(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0xf75c(%rip), %xmm1     # 0x5c260
callq 0x2210
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x94ec(%rip), %xmm1     # 0x56010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movsd -0x30(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x94c8(%rip), %xmm1     # 0x56010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x94a4(%rip), %xmm1     # 0x56010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container::put(int, double, double, double)
void pre_container::put(int n,double x,double y,double z) {
	if((xperiodic||(x>=ax&&x<=bx))&&(yperiodic||(y>=ay&&y<=by))&&(zperiodic||(z>=az&&z<=bz))) {
		if(ch_id==e_id) new_chunk();
		*(ch_id++)=n;
		*(ch_p++)=x;*(ch_p++)=y;*(ch_p++)=z;
	}
#if VOROPP_REPORT_OUT_OF_BOUNDS ==1
	else fprintf(stderr,"Out of bounds: (x,y,z)=(%g,%g,%g)\n",x,y,z);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x30(%rax)
jne 0x4cbd7
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm0
ucomisd (%rax), %xmm0
jb 0x4ccb6
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4ccb6
movq -0x30(%rbp), %rax
testb $0x1, 0x31(%rax)
jne 0x4cc0d
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm0
ucomisd 0x10(%rax), %xmm0
jb 0x4ccb6
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm1
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4ccb6
movq -0x30(%rbp), %rax
testb $0x1, 0x32(%rax)
jne 0x4cc3f
movq -0x30(%rbp), %rax
movsd -0x28(%rbp), %xmm0
ucomisd 0x20(%rax), %xmm0
jb 0x4ccb6
movq -0x30(%rbp), %rax
movsd -0x28(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4ccb6
movq -0x30(%rbp), %rcx
movq 0x58(%rcx), %rax
cmpq 0x60(%rcx), %rax
jne 0x4cc56
movq -0x30(%rbp), %rdi
callq 0x4ccc0
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %edx
movq 0x58(%rcx), %rax
movq %rax, %rsi
addq $0x4, %rsi
movq %rsi, 0x58(%rcx)
movl %edx, (%rax)
movsd -0x18(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::new_chunk()
void pre_container_base::new_chunk() {
	end_id++;end_p++;
	if(end_id==l_id) extend_chunk_index();
	ch_id=*end_id=new int[pre_container_chunk_size];
	e_id=ch_id+pre_container_chunk_size;
	ch_p=*end_p=new double[ps*pre_container_chunk_size];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x48(%rcx), %rax
addq $0x8, %rax
movq %rax, 0x48(%rcx)
movq 0x70(%rcx), %rax
addq $0x8, %rax
movq %rax, 0x70(%rcx)
movq 0x48(%rcx), %rax
cmpq 0x50(%rcx), %rax
jne 0x4ccff
movq -0x10(%rbp), %rdi
callq 0x4d740
movl $0x1000, %edi           # imm = 0x1000
callq 0x2030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
movq %rcx, (%rdx)
movq %rcx, 0x58(%rax)
movq 0x58(%rax), %rcx
addq $0x1000, %rcx           # imm = 0x1000
movq %rcx, 0x60(%rax)
movl 0x34(%rax), %eax
shll $0xa, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdx
movq %rcx, (%rdx)
movq %rcx, 0x78(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_poly::put(int, double, double, double, double)
void pre_container_poly::put(int n,double x,double y,double z,double r) {
	if((xperiodic||(x>=ax&&x<=bx))&&(yperiodic||(y>=ay&&y<=by))&&(zperiodic||(z>=az&&z<=bz))) {
		if(ch_id==e_id) new_chunk();
		*(ch_id++)=n;
		*(ch_p++)=x;*(ch_p++)=y;*(ch_p++)=z;*(ch_p++)=r;
	}
#if VOROPP_REPORT_OUT_OF_BOUNDS ==1
	else fprintf(stderr,"Out of bounds: (x,y,z)=(%g,%g,%g)\n",x,y,z);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x30(%rax)
jne 0x4cdcc
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
ucomisd (%rax), %xmm0
jb 0x4cec7
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4cec7
movq -0x38(%rbp), %rax
testb $0x1, 0x31(%rax)
jne 0x4ce02
movq -0x38(%rbp), %rax
movsd -0x20(%rbp), %xmm0
ucomisd 0x10(%rax), %xmm0
jb 0x4cec7
movq -0x38(%rbp), %rax
movsd -0x20(%rbp), %xmm1
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4cec7
movq -0x38(%rbp), %rax
testb $0x1, 0x32(%rax)
jne 0x4ce38
movq -0x38(%rbp), %rax
movsd -0x28(%rbp), %xmm0
ucomisd 0x20(%rax), %xmm0
jb 0x4cec7
movq -0x38(%rbp), %rax
movsd -0x28(%rbp), %xmm1
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4cec7
movq -0x38(%rbp), %rcx
movq 0x58(%rcx), %rax
cmpq 0x60(%rcx), %rax
jne 0x4ce4f
movq -0x38(%rbp), %rdi
callq 0x4ccc0
movq -0x38(%rbp), %rcx
movl -0xc(%rbp), %edx
movq 0x58(%rcx), %rax
movq %rax, %rsi
addq $0x4, %rsi
movq %rsi, 0x58(%rcx)
movl %edx, (%rax)
movsd -0x18(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq 0x78(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x78(%rcx)
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container::setup(voro::container&)
void pre_container::setup(container &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
			con.put(n,x,y,z);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
		con.put(n,x,y,z);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x48(%rcx), %rax
jae 0x4cfcf
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x4cfca
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
callq 0x1c9d0
jmp 0x4cf44
jmp 0x4cef8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x4d06f
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
callq 0x1c9d0
jmp 0x4cfe5
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_poly::setup(voro::container_poly&)
void pre_container_poly::setup(container_poly &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z,r;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);r=*(pp++);
			con.put(n,x,y,z,r);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);r=*(pp++);
		con.put(n,x,y,z,r);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x48(%rcx), %rax
jae 0x4d1a0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x4d19b
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm3
callq 0x1cb50
jmp 0x4d0f4
jmp 0x4d0a8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x4d261
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm3
callq 0x1cb50
jmp 0x4d1b6
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container::setup(voro::particle_order&, voro::container&)
void pre_container::setup(particle_order &vo,container &con) {
	int **c_id=pre_id,*idp,*ide,n;
	double **c_p=pre_p,*pp,x,y,z;
	while(c_id<end_id) {
		idp=*(c_id++);ide=idp+pre_container_chunk_size;
		pp=*(c_p++);
		while(idp<ide) {
			n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
			con.put(vo,n,x,y,z);
		}
	}
	idp=*c_id;
	pp=*c_p;
	while(idp<ch_id) {
		n=*(idp++);x=*(pp++);y=*(pp++);z=*(pp++);
		con.put(vo,n,x,y,z);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x68(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x48(%rcx), %rax
jae 0x4d37b
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x4d376
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movsd -0x50(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
callq 0x1cc80
jmp 0x4d2e8
jmp 0x4d29c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x4d423
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movsd -0x50(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
callq 0x1cc80
jmp 0x4d391
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::extend_chunk_index()
void pre_container_base::extend_chunk_index() {
	index_sz<<=1;
	if(index_sz>max_chunk_size)
		voro_fatal_error("Absolute memory limit on chunk index reached",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Pre-container chunk index scaled up to %d\n",index_sz);
#endif
	int **n_id=new int*[index_sz],**p_id=n_id,**c_id=pre_id;
	double **n_p=new double*[index_sz],**p_p=n_p,**c_p=pre_p;
	while(c_id<end_id) {
		*(p_id++)=*(c_id++);
		*(p_p++)=*(c_p++);
	}
	delete [] pre_id;pre_id=n_id;end_id=p_id;l_id=pre_id+index_sz;
	delete [] pre_p;pre_p=n_p;end_p=p_p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x38(%rax), %ecx
shll %ecx
movl %ecx, 0x38(%rax)
cmpl $0x10000, 0x38(%rax)    # imm = 0x10000
jle 0x4d776
leaq 0xeb04(%rip), %rdi      # 0x5c270
movl $0x2, %esi
callq 0x1b690
movq -0x40(%rbp), %rax
movq 0x1885f(%rip), %rcx     # 0x65fe0
movq (%rcx), %rdi
movl 0x38(%rax), %edx
leaq 0xeb0f(%rip), %rsi      # 0x5c29d
movb $0x0, %al
callq 0x21a0
movq -0x40(%rbp), %rax
movslq 0x38(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x20(%rbp)
movslq 0x38(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x48(%rcx), %rax
jae 0x4d871
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x18(%rbp)
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x30(%rbp)
movq %rcx, (%rax)
jmp 0x4d819
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4d88c
movq -0x48(%rbp), %rdi
callq 0x2180
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq 0x40(%rax), %rcx
movslq 0x38(%rax), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x50(%rax)
movq 0x68(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x4d8ca
movq -0x50(%rbp), %rdi
callq 0x2180
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_base::~container_periodic_base()
container_periodic_base::~container_periodic_base() {
	for(int l=oxyz-1;l>=0;l--) if(mem[l]>0) {
		delete [] p[l];
		delete [] id[l];
	}
	delete [] img;
	delete [] mem;
	delete [] co;
	delete [] id;
	delete [] p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x198(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4dfc6
movq -0x18(%rbp), %rax
movq 0x1b8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x4dfb9
movq -0x18(%rbp), %rax
movq 0x1a8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4df91
movq -0x20(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x1a0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4dfb7
movq -0x28(%rbp), %rdi
callq 0x2180
jmp 0x4dfb9
jmp 0x4dfbb
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4df50
movq -0x18(%rbp), %rax
movq 0x1c0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4dfe4
movq -0x30(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4e002
movq -0x38(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4e020
movq -0x40(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4e03e
movq -0x48(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x4e05c
movq -0x50(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x1e8c0
movq -0x18(%rbp), %rdi
callq 0x51c30
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(int, double, double, double)
void container_periodic::put(int n,double x,double y,double z) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+3*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x2c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x4e3c0
movl $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movl -0x30(%rbp), %eax
movq 0x1b0(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x4e311
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movq 0x1a0(%rax), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x30(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x1a8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
imull $0x3, -0x30(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x1b5a0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4e2a2
movq -0x40(%rbp), %rcx
movl -0xc(%rbp), %esi
movq 0x1a0(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x1b0(%rcx), %rdx
movslq -0x2c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rax,%rdx,4)
movq 0x1a8(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x1b0(%rcx), %rdx
movslq -0x2c(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(int, double, double, double, double)
void container_periodic_poly::put(int n,double x,double y,double z,double r) {
	int ijk;
	put_locate_block(ijk,x,y,z);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+4*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+4*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
	if(max_radius<r) max_radius=r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x4e3c0
movl $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rcx
movl -0x38(%rbp), %eax
movq 0x1b0(%rcx), %rcx
movslq -0x34(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x4e7b8
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movq 0x1a0(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x38(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x1a8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl -0x38(%rbp), %eax
shll $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x1b5a0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4e747
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x1a0(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rdx
movslq -0x34(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x1a8(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rsi
movslq -0x34(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x20(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0x1d8(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4e892
movq -0x48(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x1d8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic::put(int, double, double, double, int&, int&, int&)
void container_periodic::put(int n,double x,double y,double z,int &ai,int &aj,int &ak) {
	int ijk;
	put_locate_block(ijk,x,y,z,ai,aj,ak);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+3*l);
	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+3*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*pp=z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %r10
movq -0x40(%rbp), %rax
leaq -0x44(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4ea20
movl $0x0, -0x48(%rbp)
movq -0x58(%rbp), %rcx
movl -0x48(%rbp), %eax
movq 0x1b0(%rcx), %rcx
movslq -0x44(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x4e972
movq -0x58(%rbp), %rax
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movq 0x1a0(%rax), %rcx
movslq -0x44(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x48(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x1a8(%rax), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
imull $0x3, -0x48(%rbp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x1b5a0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4e903
movq -0x58(%rbp), %rcx
movl -0xc(%rbp), %esi
movq 0x1a0(%rcx), %rax
movslq -0x44(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x1b0(%rcx), %rdx
movslq -0x44(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rax,%rdx,4)
movq 0x1a8(%rcx), %rax
movslq -0x44(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0x1b0(%rcx), %rdx
movslq -0x44(%rbp), %rsi
movl (%rdx,%rsi,4), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rdx,%rsi,4)
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x50(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x50(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container_prd.cc
// Function: voro::container_periodic_poly::put(int, double, double, double, double, int&, int&, int&)
void container_periodic_poly::put(int n,double x,double y,double z,double r,int &ai,int &aj,int &ak) {
	int ijk;
	put_locate_block(ijk,x,y,z,ai,aj,ak);
	for(int l=0;l<co[ijk];l++) check_duplicate(n,x,y,z,id[ijk][l],p[ijk]+4*l);

	id[ijk][co[ijk]]=n;
	double *pp=p[ijk]+4*co[ijk]++;
	*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
	if(max_radius<r) max_radius=r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %r10
movq -0x48(%rbp), %rax
leaq -0x4c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4ea20
movl $0x0, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movl -0x50(%rbp), %eax
movq 0x1b0(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x4ee99
movq -0x60(%rbp), %rax
movl -0xc(%rbp), %edi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movq 0x1a0(%rax), %rcx
movslq -0x4c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x50(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq 0x1a8(%rax), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl -0x50(%rbp), %eax
shll $0x2, %eax
cltq
shlq $0x3, %rax
addq %rax, %rdx
callq 0x1b5a0
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x4ee28
movq -0x60(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x1a0(%rax), %rcx
movslq -0x4c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rdx
movslq -0x4c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x1a8(%rax), %rcx
movslq -0x4c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x1b0(%rax), %rsi
movslq -0x4c(%rbp), %rdi
movl (%rsi,%rdi,4), %edx
movl %edx, %r8d
addl $0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movsd %xmm0, (%rcx)
movsd -0x20(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x58(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0x1d8(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4ef73
movq -0x60(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x1d8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)