LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::put_locate_block(int&, double&, double&, double&)
bool container_base::put_locate_block(int &ijk,double &x,double &y,double &z) {
	if(put_remap(ijk,x,y,z)) {
		if(co[ijk]==mem[ijk]) add_particle_memory(ijk);
		return true;
	}
#if VOROPP_REPORT_OUT_OF_BOUNDS ==1
	fprintf(stderr,"Out of bounds: (x,y,z)=(%g,%g,%g)\n",x,y,z);
#endif
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1e980
testb $0x1, %al
jne 0x1caff
jmp 0x1cb3c
movq -0x38(%rbp), %rcx
movq 0xc0(%rcx), %rax
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
movl (%rax,%rdx,4), %eax
movq 0xc8(%rcx), %rcx
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x1cb36
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x1cee0
movb $0x1, -0x1(%rbp)
jmp 0x1cb40
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
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 0x1cac0
testb $0x1, %al
jne 0x1cb99
jmp 0x1cc75
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0xb0(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0xc0(%rax), %rdx
movslq -0x34(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0xb8(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0xc0(%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 0xe0(%rax), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1cc73
movq -0x48(%rbp), %rax
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0xe0(%rax)
jmp 0x1cc75
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x1cac0
testb $0x1, %al
jne 0x1ccc8
jmp 0x1cd81
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0xb0(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0xc0(%rax), %rdx
movslq -0x34(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
movq 0xc0(%rax), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x1e910
movq -0x48(%rbp), %rcx
movq 0xb8(%rcx), %rax
movslq -0x34(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq 0xc0(%rcx), %rdx
movslq -0x34(%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, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x40(%rbp)
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x3c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x1cac0
testb $0x1, %al
jne 0x1cddd
jmp 0x1ced7
movq -0x50(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0xb0(%rax), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0xc0(%rax), %rdx
movslq -0x3c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq 0xc0(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x1e910
movq -0x50(%rbp), %rax
movq 0xb8(%rax), %rcx
movslq -0x3c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0xc0(%rax), %rsi
movslq -0x3c(%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, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x28(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x30(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x48(%rbp)
movsd %xmm0, (%rcx)
movsd -0x38(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd 0xe0(%rax), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1ced5
movq -0x50(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xe0(%rax)
jmp 0x1ced7
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::import(_IO_FILE*)
void container::import(FILE *fp) {
	int i,j;
	double x,y,z;
	while((j=fscanf(fp,"%d %lg %lg %lg",&i,&x,&y,&z))==4) put(i,x,y,z);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3a800(%rip), %rsi     # 0x57e83
leaq -0x14(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
movb $0x0, %al
callq 0x2230
movl %eax, -0x18(%rbp)
cmpl $0x4, %eax
jne 0x1d6bf
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
callq 0x1c9d0
jmp 0x1d678
cmpl $-0x1, -0x18(%rbp)
je 0x1d6d6
leaq 0x3a7c6(%rip), %rdi     # 0x57e92
movl $0x1, %esi
callq 0x1b690
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::import(voro::particle_order&, _IO_FILE*)
void container::import(particle_order &vo,FILE *fp) {
	int i,j;
	double x,y,z;
	while((j=fscanf(fp,"%d %lg %lg %lg",&i,&x,&y,&z))==4) put(vo,i,x,y,z);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3a77c(%rip), %rsi     # 0x57e83
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
movb $0x0, %al
callq 0x2230
movl %eax, -0x20(%rbp)
cmpl $0x4, %eax
jne 0x1d747
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x1cc80
jmp 0x1d6fc
cmpl $-0x1, -0x20(%rbp)
je 0x1d75e
leaq 0x3a73e(%rip), %rdi     # 0x57e92
movl $0x1, %esi
callq 0x1b690
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_poly::import(_IO_FILE*)
void container_poly::import(FILE *fp) {
	int i,j;
	double x,y,z,r;
	while((j=fscanf(fp,"%d %lg %lg %lg %lg",&i,&x,&y,&z,&r))==5) put(i,x,y,z,r);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3a711(%rip), %rsi     # 0x57ea4
leaq -0x14(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2230
movl %eax, -0x18(%rbp)
cmpl $0x5, %eax
jne 0x1d7dc
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
callq 0x1cb50
jmp 0x1d788
cmpl $-0x1, -0x18(%rbp)
je 0x1d7f3
leaq 0x3a6a9(%rip), %rdi     # 0x57e92
movl $0x1, %esi
callq 0x1b690
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_poly::import(voro::particle_order&, _IO_FILE*)
void container_poly::import(particle_order &vo,FILE *fp) {
	int i,j;
	double x,y,z,r;
	while((j=fscanf(fp,"%d %lg %lg %lg %lg",&i,&x,&y,&z,&r))==5) put(vo,i,x,y,z,r);
	if(j!=EOF) voro_fatal_error("File import error",VOROPP_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3a67d(%rip), %rsi     # 0x57ea4
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2230
movl %eax, -0x20(%rbp)
cmpl $0x5, %eax
jne 0x1d874
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
callq 0x1cd90
jmp 0x1d81c
cmpl $-0x1, -0x20(%rbp)
je 0x1d88b
leaq 0x3a611(%rip), %rdi     # 0x57e92
movl $0x1, %esi
callq 0x1b690
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::compute_all_cells()
void container::compute_all_cells() {
	voronoicell c(*this);
	c_loop_all vl(*this);
	if(vl.start()) do compute_cell(c,vl);
	while(vl.inc());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x150(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6d50
movq -0x150(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x5de0
jmp 0x1db7b
leaq -0x138(%rbp), %rdi
callq 0x6a60
movb %al, -0x151(%rbp)
jmp 0x1db8f
movb -0x151(%rbp), %al
testb $0x1, %al
jne 0x1db9b
jmp 0x1dbfd
jmp 0x1db9d
movq -0x150(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x138(%rbp), %rdx
callq 0x6e60
jmp 0x1dbb9
jmp 0x1dbbb
leaq -0x138(%rbp), %rdi
callq 0x6b30
movb %al, -0x152(%rbp)
jmp 0x1dbcf
movb -0x152(%rbp), %al
testb $0x1, %al
jne 0x1db9d
jmp 0x1dbdb
jmp 0x1dbfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6810
jmp 0x1dc12
leaq -0xf0(%rbp), %rdi
callq 0x6810
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x140(%rbp), %rdi
callq 0x2220
nop
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::sum_cell_volumes()
double container::sum_cell_volumes() {
	voronoicell c(*this);
	double vol=0;
	c_loop_all vl(*this);
	if(vl.start()) do if(compute_cell(c,vl)) vol+=c.volume();while(vl.inc());
	return vol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x158(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6d50
movq -0x158(%rbp), %rsi
movq $0x0, -0xf8(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x5de0
jmp 0x1dd46
leaq -0x140(%rbp), %rdi
callq 0x6a60
movb %al, -0x159(%rbp)
jmp 0x1dd5a
movb -0x159(%rbp), %al
testb $0x1, %al
jne 0x1dd69
jmp 0x1de11
jmp 0x1dd6b
movq -0x158(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x6e60
movb %al, -0x15a(%rbp)
jmp 0x1dd8d
movb -0x15a(%rbp), %al
testb $0x1, %al
jne 0x1dd99
jmp 0x1dde9
leaq -0xf0(%rbp), %rdi
callq 0x9c90
movsd %xmm0, -0x168(%rbp)
jmp 0x1ddaf
movsd -0x168(%rbp), %xmm0
addsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0xf8(%rbp)
jmp 0x1dde9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6810
jmp 0x1de3e
jmp 0x1ddeb
leaq -0x140(%rbp), %rdi
callq 0x6b30
movb %al, -0x169(%rbp)
jmp 0x1ddff
movb -0x169(%rbp), %al
testb $0x1, %al
jne 0x1dd6b
jmp 0x1de0f
jmp 0x1de11
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0x178(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x6810
movsd -0x178(%rbp), %xmm0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x148(%rbp), %rdi
callq 0x2220
nopw (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::draw_domain_gnuplot(_IO_FILE*)
void container_base::draw_domain_gnuplot(FILE *fp) {
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",ax,ay,az,bx,ay,az,bx,by,az,ax,by,az);
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",ax,by,bz,bx,by,bz,bx,ay,bz,ax,ay,bz);
	fprintf(fp,"%g %g %g\n\n%g %g %g\n%g %g %g\n\n",ax,by,bz,ax,ay,az,ax,ay,bz);
	fprintf(fp,"%g %g %g\n%g %g %g\n\n%g %g %g\n%g %g %g\n\n",bx,ay,az,bx,ay,bz,bx,by,az,bx,by,bz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movsd 0x70(%rax), %xmm0
movsd 0x80(%rax), %xmm1
movsd 0x90(%rax), %xmm2
movsd 0x78(%rax), %xmm3
movsd 0x80(%rax), %xmm4
movsd 0x90(%rax), %xmm5
movsd 0x78(%rax), %xmm6
movsd 0x88(%rax), %xmm7
movsd 0x90(%rax), %xmm11
movsd 0x70(%rax), %xmm10
movsd 0x88(%rax), %xmm9
movsd 0x90(%rax), %xmm8
leaq 0x39ded(%rip), %rsi     # 0x57ed8
movsd %xmm11, (%rsp)
movsd %xmm10, 0x8(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x18(%rsp)
movb $0x8, %al
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x70(%rax), %xmm0
movsd 0x88(%rax), %xmm1
movsd 0x98(%rax), %xmm2
movsd 0x78(%rax), %xmm3
movsd 0x88(%rax), %xmm4
movsd 0x98(%rax), %xmm5
movsd 0x78(%rax), %xmm6
movsd 0x80(%rax), %xmm7
movsd 0x98(%rax), %xmm11
movsd 0x70(%rax), %xmm10
movsd 0x80(%rax), %xmm9
movsd 0x98(%rax), %xmm8
leaq 0x39d64(%rip), %rsi     # 0x57ed8
movsd %xmm11, (%rsp)
movsd %xmm10, 0x8(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x18(%rsp)
movb $0x8, %al
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x70(%rax), %xmm0
movsd 0x88(%rax), %xmm1
movsd 0x98(%rax), %xmm2
movsd 0x70(%rax), %xmm3
movsd 0x80(%rax), %xmm4
movsd 0x90(%rax), %xmm5
movsd 0x70(%rax), %xmm6
movsd 0x80(%rax), %xmm7
movsd 0x98(%rax), %xmm8
leaq 0x39d21(%rip), %rsi     # 0x57f06
movsd %xmm8, (%rsp)
movb $0x8, %al
callq 0x21a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x78(%rax), %xmm0
movsd 0x80(%rax), %xmm1
movsd 0x90(%rax), %xmm2
movsd 0x78(%rax), %xmm3
movsd 0x80(%rax), %xmm4
movsd 0x98(%rax), %xmm5
movsd 0x78(%rax), %xmm6
movsd 0x88(%rax), %xmm7
movsd 0x90(%rax), %xmm11
movsd 0x78(%rax), %xmm10
movsd 0x88(%rax), %xmm9
movsd 0x98(%rax), %xmm8
leaq 0x39ca4(%rip), %rsi     # 0x57efd
movsd %xmm11, (%rsp)
movsd %xmm10, 0x8(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x18(%rsp)
movb $0x8, %al
callq 0x21a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::wall_list::increase_wall_memory()
void wall_list::increase_wall_memory() {
	current_wall_size<<=1;
	if(current_wall_size>max_wall_size)
		voro_fatal_error("Wall memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
	wall **nwalls=new wall*[current_wall_size],**nwp=nwalls,**wp=walls;
	while(wp<wep) *(nwp++)=*(wp++);
	delete [] walls;
	walls=nwalls;wel=walls+current_wall_size;wep=nwp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x18(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
cmpl $0x800, 0x18(%rax)      # imm = 0x800
jle 0x1e7f6
leaq 0x397d8(%rip), %rdi     # 0x57fc4
movl $0x2, %esi
callq 0x1b690
movq -0x28(%rbp), %rax
movslq 0x18(%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 -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 0x1e86d
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)
jmp 0x1e839
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1e887
movq -0x30(%rbp), %rdi
callq 0x2180
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movslq 0x18(%rax), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container>::add_list_memory(int*&, int*&)
inline void voro_compute<c_class>::add_list_memory(int*& qu_s,int*& qu_e) {
	qu_size<<=1;
	int *qu_n=new int[qu_size],*qu_c=qu_n;
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"List memory scaled up to %d\n",qu_size);
#endif
	if(qu_s<=qu_e) {
		while(qu_s<qu_e) *(qu_c++)=*(qu_s++);
	} else {
		while(qu_s<qu_l) *(qu_c++)=*(qu_s++);
		qu_s=qu;
		while(qu_s<qu_e) *(qu_c++)=*(qu_s++);
	}
	delete [] qu;
	qu_s=qu=qu_n;
	qu_l=qu+qu_size;
	qu_e=qu_c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x74(%rax), %ecx
shll %ecx
movl %ecx, 0x74(%rax)
movslq 0x74(%rax), %rax
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 -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x426cd(%rip), %rcx     # 0x65fe0
movq (%rcx), %rdi
movl 0x74(%rax), %edx
leaq 0x347d9(%rip), %rsi     # 0x580f9
movb $0x0, %al
callq 0x21a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
ja 0x23974
jmp 0x23939
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x2396f
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, (%rcx)
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
jmp 0x23939
jmp 0x239fa
jmp 0x23976
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq 0x98(%rcx), %rax
jae 0x239b0
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, (%rcx)
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
jmp 0x23976
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x239f8
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, (%rcx)
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
jmp 0x239c2
jmp 0x239fa
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x23a18
movq -0x38(%rbp), %rdi
callq 0x2180
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rdx
movq %rdx, 0x90(%rax)
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq 0x90(%rax), %rcx
movslq 0x74(%rax), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container>::face_x_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double)
inline bool voro_compute<c_class>::face_x_test(v_cell &c,double xl,double y0,double z0,double y1,double z1) {
	con.r_prime(xl*xl);
	if(c.plane_intersects_guess(xl,y0,z0,con.r_cutoff(xl*xl))) return false;
	if(c.plane_intersects(xl,y0,z1,con.r_cutoff(xl*xl))) return false;
	if(c.plane_intersects(xl,y1,z1,con.r_cutoff(xl*xl))) return false;
	if(c.plane_intersects(xl,y1,z0,con.r_cutoff(xl*xl))) return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x49820
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x49830
movq -0x60(%rbp), %rdi
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x48(%rbp), %xmm0
callq 0xd600
testb $0x1, %al
jne 0x24b03
jmp 0x24b0c
movb $0x0, -0x1(%rbp)
jmp 0x24c72
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x49830
movq -0x88(%rbp), %rdi
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x70(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x24b6f
jmp 0x24b78
movb $0x0, -0x1(%rbp)
jmp 0x24c72
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x49830
movq -0xa8(%rbp), %rdi
movsd -0xa0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x90(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x24bed
jmp 0x24bf3
movb $0x0, -0x1(%rbp)
jmp 0x24c72
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x49830
movq -0xc8(%rbp), %rdi
movsd -0xc0(%rbp), %xmm1
movsd -0xb8(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xb0(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x24c68
jmp 0x24c6e
movb $0x0, -0x1(%rbp)
jmp 0x24c72
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container>::face_y_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double)
inline bool voro_compute<c_class>::face_y_test(v_cell &c,double x0,double yl,double z0,double x1,double z1) {
	con.r_prime(yl*yl);
	if(c.plane_intersects_guess(x0,yl,z0,con.r_cutoff(yl*yl))) return false;
	if(c.plane_intersects(x0,yl,z1,con.r_cutoff(yl*yl))) return false;
	if(c.plane_intersects(x1,yl,z1,con.r_cutoff(yl*yl))) return false;
	if(c.plane_intersects(x1,yl,z0,con.r_cutoff(yl*yl))) return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x49820
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x49830
movq -0x60(%rbp), %rdi
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x48(%rbp), %xmm0
callq 0xd600
testb $0x1, %al
jne 0x250d3
jmp 0x250dc
movb $0x0, -0x1(%rbp)
jmp 0x25242
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x49830
movq -0x88(%rbp), %rdi
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x70(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x2513f
jmp 0x25148
movb $0x0, -0x1(%rbp)
jmp 0x25242
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x49830
movq -0xa8(%rbp), %rdi
movsd -0xa0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x90(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x251bd
jmp 0x251c3
movb $0x0, -0x1(%rbp)
jmp 0x25242
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
callq 0x49830
movq -0xc8(%rbp), %rdi
movsd -0xc0(%rbp), %xmm1
movsd -0xb8(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xb0(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x25238
jmp 0x2523e
movb $0x0, -0x1(%rbp)
jmp 0x25242
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: bool voro::voro_compute<voro::container>::face_z_test<voro::voronoicell>(voro::voronoicell&, double, double, double, double, double)
inline bool voro_compute<c_class>::face_z_test(v_cell &c,double x0,double y0,double zl,double x1,double y1) {
	con.r_prime(zl*zl);
	if(c.plane_intersects_guess(x0,y0,zl,con.r_cutoff(zl*zl))) return false;
	if(c.plane_intersects(x0,y1,zl,con.r_cutoff(zl*zl))) return false;
	if(c.plane_intersects(x1,y1,zl,con.r_cutoff(zl*zl))) return false;
	if(c.plane_intersects(x1,y0,zl,con.r_cutoff(zl*zl))) return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x49820
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x49830
movq -0x60(%rbp), %rdi
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x48(%rbp), %xmm0
callq 0xd600
testb $0x1, %al
jne 0x252f3
jmp 0x252fc
movb $0x0, -0x1(%rbp)
jmp 0x25462
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x49830
movq -0x88(%rbp), %rdi
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x70(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x2535f
jmp 0x25368
movb $0x0, -0x1(%rbp)
jmp 0x25462
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x49830
movq -0xa8(%rbp), %rdi
movsd -0xa0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x90(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x253dd
jmp 0x253e3
movb $0x0, -0x1(%rbp)
jmp 0x25462
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
callq 0x49830
movq -0xc8(%rbp), %rdi
movsd -0xc0(%rbp), %xmm1
movsd -0xb8(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xb0(%rbp), %xmm0
callq 0xd530
testb $0x1, %al
jne 0x25458
jmp 0x2545e
movb $0x0, -0x1(%rbp)
jmp 0x25462
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
// File: Luthaf[P]zeopp/voro++/src/./container.hh
// Function: voro::container_base::initialize_search(int, int, int, int, int&, int&, int&, int&)
inline void initialize_search(int ci,int cj,int ck,int ijk,int &i,int &j,int &k,int &disp) {
			i=xperiodic?nx:ci;
			j=yperiodic?ny:cj;
			k=zperiodic?nz:ck;
			disp=ijk-i-nx*(j+ny*k);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0xa8(%rax)
je 0x29f81
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x29f87
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rcx
movl %edx, (%rcx)
testb $0x1, 0xa9(%rax)
je 0x29fa9
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x29faf
movl -0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %edx
movq 0x10(%rbp), %rcx
movl %edx, (%rcx)
testb $0x1, 0xaa(%rax)
je 0x29fd1
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x29fd7
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
subl (%rax), %ecx
movl (%rsi), %eax
movq 0x10(%rbp), %rdx
movl (%rdx), %edx
movl 0x4(%rsi), %esi
movq 0x18(%rbp), %rdi
imull (%rdi), %esi
addl %esi, %edx
imull %edx, %eax
subl %eax, %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/voro++/src/v_compute.cc
// Function: voro::voro_compute<voro::container>::scan_all(int, double, double, double, int, int, int, voro::particle_record&, double&)
inline void voro_compute<c_class>::scan_all(int ijk,double x,double y,double z,int di,int dj,int dk,particle_record &w,double &mrs) {
	double x1,y1,z1,rs;bool in_block=false;
	for(int l=0;l<co[ijk];l++) {
		x1=p[ijk][ps*l]-x;
		y1=p[ijk][ps*l+1]-y;
		z1=p[ijk][ps*l+2]-z;
		rs=con.r_current_sub(x1*x1+y1*y1+z1*z1,ijk,l);
		if(rs<mrs) {mrs=rs;w.l=l;in_block=true;}
	}
	if(in_block) {w.ijk=ijk;w.di=di;w.dj=dj,w.dk=dk;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq %r9, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x61(%rbp)
movl $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movl -0x68(%rbp), %eax
movq 0x60(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2a163
movq -0x70(%rbp), %rax
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x4c(%rax), %edx
imull -0x68(%rbp), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x4c(%rax), %edx
imull -0x68(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq 0x58(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x4c(%rax), %edx
imull -0x68(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq (%rax), %rdi
movsd -0x48(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movsd -0x50(%rbp), %xmm0
mulsd -0x50(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movl -0xc(%rbp), %esi
movl -0x68(%rbp), %edx
callq 0x498e0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm1
movq 0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2a153
movsd -0x60(%rbp), %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x68(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, -0x61(%rbp)
jmp 0x2a155
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2a053
testb $0x1, -0x61(%rbp)
je 0x2a190
movl -0xc(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x30(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x34(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/./container_prd.hh
// Function: bool voro::container_periodic_base::initialize_voronoicell<voro::voronoicell>(voro::voronoicell&, int, int, int, int, int, int&, int&, int&, double&, double&, double&, int&)
inline bool initialize_voronoicell(v_cell &c,int ijk,int q,int ci,int cj,int ck,int &i,int &j,int &k,double &x,double &y,double &z,int &disp) {
			c=unit_voro;
			double *pp=p[ijk]+ps*q;
			x=*(pp++);y=*(pp++);z=*pp;
			i=nx;j=ey;k=ez;
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
callq 0x499d0
movq -0x30(%rbp), %rax
movq 0x1a8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x1cc(%rax), %edx
imull -0x18(%rbp), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x28(%rbp)
movsd (%rcx), %xmm0
movq 0x30(%rbp), %rcx
movsd %xmm0, (%rcx)
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x8, %rdx
movq %rdx, -0x28(%rbp)
movsd (%rcx), %xmm0
movq 0x38(%rbp), %rcx
movsd %xmm0, (%rcx)
movq -0x28(%rbp), %rcx
movsd (%rcx), %xmm0
movq 0x40(%rbp), %rcx
movsd %xmm0, (%rcx)
movl 0x128(%rax), %edx
movq 0x18(%rbp), %rcx
movl %edx, (%rcx)
movl 0x180(%rax), %edx
movq 0x20(%rbp), %rcx
movl %edx, (%rcx)
movl 0x184(%rax), %ecx
movq 0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/./container_prd.hh
// Function: voro::container_periodic_base::region_index(int, int, int, int, int, int, double&, double&, double&, int&)
inline int region_index(int ci,int cj,int ck,int ei,int ej,int ek,double &qx,double &qy,double &qz,int &disp) {
			int qi=ci+(ei-nx),qj=cj+(ej-ey),qk=ck+(ek-ez);
			int iv(step_div(qi,nx));if(iv!=0) {qx=iv*bx;qi-=nx*iv;} else qx=0;
			create_periodic_image(qi,qj,qk);
			return qi+nx*(qj+oy*qk);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movl -0x18(%rbp), %edx
subl 0x128(%rax), %edx
addl %edx, %ecx
movl %ecx, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movl -0x1c(%rbp), %edx
subl 0x180(%rax), %edx
addl %edx, %ecx
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %ecx
movl 0x10(%rbp), %edx
subl 0x184(%rax), %edx
addl %edx, %ecx
movl %ecx, -0x28(%rbp)
movq %rax, %rdi
addq $0x128, %rdi            # imm = 0x128
movl -0x20(%rbp), %esi
movl 0x128(%rax), %edx
callq 0x1ee80
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x389a5
movq -0x38(%rbp), %rax
cvtsi2sdl -0x2c(%rbp), %xmm0
mulsd (%rax), %xmm0
movq 0x18(%rbp), %rcx
movsd %xmm0, (%rcx)
movl 0x128(%rax), %ecx
imull -0x2c(%rbp), %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x389b0
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x49650
movq -0x38(%rbp), %rsi
movl -0x20(%rbp), %eax
movl 0x128(%rsi), %ecx
movl -0x24(%rbp), %edx
movl 0x190(%rsi), %esi
imull -0x28(%rbp), %esi
addl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Luthaf[P]zeopp/voro++/src/./container_prd.hh
// Function: voro::container_periodic_base::create_periodic_image(int, int, int)
inline void create_periodic_image(int di,int dj,int dk) {
			if(di<0||di>=nx||dj<0||dj>=oy||dk<0||dk>=oz)
				voro_fatal_error("Constructing periodic image for nonexistent point",VOROPP_INTERNAL_ERROR);
			if(dk>=ez&&dk<wz) {
				if(dj<ey||dj>=wy) create_side_image(di,dj,dk);
			} else create_vertical_image(di,dj,dk);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x496ac
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x128(%rcx), %eax
jge 0x496ac
cmpl $0x0, -0x10(%rbp)
jl 0x496ac
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x190(%rcx), %eax
jge 0x496ac
cmpl $0x0, -0x14(%rbp)
jl 0x496ac
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x194(%rcx), %eax
jl 0x496bd
leaq 0xe9c7(%rip), %rdi      # 0x5807a
movl $0x3, %esi
callq 0x1b690
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x184(%rcx), %eax
jl 0x4970d
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x18c(%rcx), %eax
jge 0x4970d
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x180(%rcx), %eax
jl 0x496f9
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x188(%rcx), %eax
jl 0x4970b
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x50600
jmp 0x4971f
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x50c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::setup_sphere(double, double, double, double, bool)
void c_loop_subset::setup_sphere(double vx,double vy,double vz,double r,bool bounds_test) {
	if(bounds_test) {mode=sphere;v0=vx;v1=vy;v2=vz;v3=r*r;} else mode=no_check;
	ai=step_int((vx-ax-r)*xsp);
	bi=step_int((vx-ax+r)*xsp);
	aj=step_int((vy-ay-r)*ysp);
	bj=step_int((vy-ay+r)*ysp);
	ak=step_int((vz-az-r)*zsp);
	bk=step_int((vz-az+r)*zsp);
	setup_common();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x29(%rbp)
je 0x49a8c
movq -0x38(%rbp), %rax
movl $0x0, 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
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0xe0(%rax)
jmp 0x49a97
movq -0x38(%rbp), %rax
movl $0x2, 0x44(%rax)
movq -0x38(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
subsd 0x48(%rdi), %xmm0
subsd -0x28(%rbp), %xmm0
mulsd 0x78(%rdi), %xmm0
callq 0x4a620
movq -0x38(%rbp), %rdi
movl %eax, 0xf8(%rdi)
movsd -0x10(%rbp), %xmm0
subsd 0x48(%rdi), %xmm0
addsd -0x28(%rbp), %xmm0
mulsd 0x78(%rdi), %xmm0
callq 0x4a620
movq -0x38(%rbp), %rdi
movl %eax, 0xfc(%rdi)
movsd -0x18(%rbp), %xmm0
subsd 0x50(%rdi), %xmm0
subsd -0x28(%rbp), %xmm0
mulsd 0x80(%rdi), %xmm0
callq 0x4a620
movq -0x38(%rbp), %rdi
movl %eax, 0x100(%rdi)
movsd -0x18(%rbp), %xmm0
subsd 0x50(%rdi), %xmm0
addsd -0x28(%rbp), %xmm0
mulsd 0x80(%rdi), %xmm0
callq 0x4a620
movq -0x38(%rbp), %rdi
movl %eax, 0x104(%rdi)
movsd -0x20(%rbp), %xmm0
subsd 0x58(%rdi), %xmm0
subsd -0x28(%rbp), %xmm0
mulsd 0x88(%rdi), %xmm0
callq 0x4a620
movq -0x38(%rbp), %rdi
movl %eax, 0x108(%rdi)
movsd -0x20(%rbp), %xmm0
subsd 0x58(%rdi), %xmm0
addsd -0x28(%rbp), %xmm0
mulsd 0x88(%rdi), %xmm0
callq 0x4a620
movq -0x38(%rbp), %rdi
movl %eax, 0x10c(%rdi)
callq 0x49b90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::start()
bool c_loop_subset::start() {
	while(co[ijk]==0) {if(!next_block()) return false;}
	while(mode!=no_check&&out_of_bounds()) {
		q++;
		while(q>=co[ijk]) {q=0;if(!next_block()) return false;}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
movslq 0x3c(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x49f6b
movq -0x18(%rbp), %rdi
callq 0x49fe0
testb $0x1, %al
jne 0x49f69
movb $0x0, -0x1(%rbp)
jmp 0x49fd4
jmp 0x49f44
jmp 0x49f6d
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x2, 0x44(%rcx)
movb %al, -0x19(%rbp)
je 0x49f88
movq -0x18(%rbp), %rdi
callq 0x4a200
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x49f91
jmp 0x49fd0
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rdx
movl 0x40(%rdx), %eax
movq 0x28(%rdx), %rcx
movslq 0x3c(%rdx), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x49fce
movq -0x18(%rbp), %rdi
movl $0x0, 0x40(%rdi)
callq 0x49fe0
testb $0x1, %al
jne 0x49fcc
movb $0x0, -0x1(%rbp)
jmp 0x49fd4
jmp 0x49f9e
jmp 0x49f6d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Luthaf[P]zeopp/voro++/src/c_loops.cc
// Function: voro::c_loop_subset::next_block()
bool c_loop_subset::next_block() {
	if(i<bi) {
		i++;
		if(ci<nx-1) {ci++;ijk++;} else {ci=0;ijk+=1-nx;px+=sx;}
		return true;
	} else if(j<bj) {
		i=ai;ci=di;px=apx;j++;
		if(cj<ny-1) {cj++;ijk+=inc1;} else {cj=0;ijk+=inc1-nxy;py+=sy;}
		return true;
	} else if(k<bk) {
		i=ai;ci=di;j=aj;cj=dj;px=apx;py=apy;k++;
		if(ck<nz-1) {ck++;ijk+=inc2;} else {ck=0;ijk+=inc2-nxyz;pz+=sz;}
		return true;
	} else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x30(%rcx), %eax
cmpl 0xfc(%rcx), %eax
jge 0x4a06e
movq -0x18(%rbp), %rcx
movl 0x30(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x30(%rcx)
movl 0x110(%rcx), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4a035
movq -0x18(%rbp), %rax
movl 0x110(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x110(%rax)
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x4a065
movq -0x18(%rbp), %rax
movl $0x0, 0x110(%rax)
movl $0x1, %ecx
subl (%rax), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
movsd 0x60(%rax), %xmm0
addsd 0x98(%rax), %xmm0
movsd %xmm0, 0x98(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4a1f6
movq -0x18(%rbp), %rcx
movl 0x34(%rcx), %eax
cmpl 0x104(%rcx), %eax
jge 0x4a11f
movq -0x18(%rbp), %rcx
movl 0xf8(%rcx), %eax
movl %eax, 0x30(%rcx)
movl 0x11c(%rcx), %eax
movl %eax, 0x110(%rcx)
movsd 0xb0(%rcx), %xmm0
movsd %xmm0, 0x98(%rcx)
movl 0x34(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x34(%rcx)
movl 0x114(%rcx), %eax
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4a0e4
movq -0x18(%rbp), %rax
movl 0x114(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x114(%rax)
movl 0x128(%rax), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
jmp 0x4a116
movq -0x18(%rbp), %rax
movl $0x0, 0x114(%rax)
movl 0x128(%rax), %ecx
subl 0xc(%rax), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
movsd 0x68(%rax), %xmm0
addsd 0xa0(%rax), %xmm0
movsd %xmm0, 0xa0(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4a1f6
movq -0x18(%rbp), %rcx
movl 0x38(%rcx), %eax
cmpl 0x10c(%rcx), %eax
jge 0x4a1f2
movq -0x18(%rbp), %rcx
movl 0xf8(%rcx), %eax
movl %eax, 0x30(%rcx)
movl 0x11c(%rcx), %eax
movl %eax, 0x110(%rcx)
movl 0x100(%rcx), %eax
movl %eax, 0x34(%rcx)
movl 0x120(%rcx), %eax
movl %eax, 0x114(%rcx)
movsd 0xb0(%rcx), %xmm0
movsd %xmm0, 0x98(%rcx)
movsd 0xb8(%rcx), %xmm0
movsd %xmm0, 0xa0(%rcx)
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl 0x118(%rcx), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4a1ba
movq -0x18(%rbp), %rax
movl 0x118(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x118(%rax)
movl 0x12c(%rax), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
jmp 0x4a1ec
movq -0x18(%rbp), %rax
movl $0x0, 0x118(%rax)
movl 0x12c(%rax), %ecx
subl 0x10(%rax), %ecx
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
movsd 0x70(%rax), %xmm0
addsd 0xa8(%rax), %xmm0
movsd %xmm0, 0xa8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4a1f6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)