LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::print_edges()
void voronoicell_base::print_edges() {
	int j;
	double *ptsp=pts;
	for(int i=0;i<p;i++,ptsp+=4) {
		printf("%d %d  ",i,nu[i]);
		for(j=0;j<nu[i];j++) printf(" %d",ed[i][j]);
		printf("  ");
		while(j<(nu[i]<<1)) printf(" %d",ed[i][j]);
		printf("   %d",ed[i][j]);
		print_edges_neighbors(i);
		printf("  %g %g %g %p",*ptsp,ptsp[1],ptsp[2],(void*) ed[i]);
		if(ed[i]>=mep[nu[i]]+mec[nu[i]]*((nu[i]<<1)+1)) puts(" Memory error");
		else puts("");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r12
leaq 0x27667(%rip), %r15     # 0x30e52
leaq 0x27664(%rip), %rbp     # 0x30e56
xorl %r14d, %r14d
movslq 0x1c(%rbx), %rax
cmpq %rax, %r14
jge 0x9910
movq 0x30(%rbx), %rax
movl (%rax,%r14,4), %edx
leaq 0x27637(%rip), %rdi     # 0x30e48
movl %r14d, %esi
xorl %eax, %eax
callq 0x2040
xorl %r13d, %r13d
movq 0x30(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r13
jge 0x9846
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
incq %r13
jmp 0x981e
leaq 0x27600(%rip), %rdi     # 0x30e4d
xorl %eax, %eax
callq 0x2040
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movl (%rcx,%r14,4), %ecx
addl %ecx, %ecx
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %esi
cmpl %r13d, %ecx
jle 0x987b
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
jmp 0x9854
leaq 0x275ce(%rip), %rdi     # 0x30e50
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x10(%rax)
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movsd 0x10(%r12), %xmm2
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbp, %rdi
movb $0x3, %al
callq 0x2040
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x70(%rbx), %rdx
movslq (%rcx,%r14,4), %rcx
movq 0x68(%rbx), %rsi
movslq (%rsi,%rcx,4), %rsi
leal (%rcx,%rcx), %edi
movslq %edi, %rdi
incq %rdi
imulq %rsi, %rdi
shlq $0x2, %rdi
addq (%rdx,%rcx,8), %rdi
cmpq %rdi, (%rax,%r14,8)
jae 0x98f8
pushq $0xa
popq %rdi
callq 0x2180
jmp 0x9904
leaq 0x27565(%rip), %rdi     # 0x30e64
callq 0x21c0
incq %r14
addq $0x20, %r12
jmp 0x97f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::print_edges_neighbors(int)
void voronoicell_neighbor::print_edges_neighbors(int i) {
	if(nu[i]>0) {
		int j=0;
		printf("     (");
		while(j<nu[i]-1) printf("%d,",ne[i][j++]);
		printf("%d)",ne[i][j]);
	} else printf("     ()");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movslq %esi, %r15
cmpl $0x0, (%rax,%r15,4)
jle 0x999c
movq %rdi, %rbx
leaq 0x27532(%rip), %rdi     # 0x30e72
xorl %eax, %eax
callq 0x2040
leaq 0x2752b(%rip), %r14     # 0x30e79
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movq 0xf0(%rbx), %rcx
movslq (%rax,%r15,4), %rdx
decq %rdx
movq (%rcx,%r15,8), %rax
cmpq %rdx, %r12
jge 0x997f
movl (%rax,%r12,4), %esi
incq %r12
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
jmp 0x9951
movl (%rax,%r12,4), %esi
leaq 0x277b4(%rip), %rdi     # 0x3113e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
leaq 0x274da(%rip), %rdi     # 0x30e7d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::m_test(int, double&)
inline unsigned int voronoicell_base::m_test(int n,double &ans) {
	if(mask[n]>=maskc) {
		ans=pts[4*n+3];
		return mask[n]&3;
	} else return m_calc(n,ans);
}

// Assembly:
movq 0x38(%rdi), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xc0(%rdi), %eax
jae 0xa0c7
jmp 0x82d6
movq 0x40(%rdi), %rcx
leal 0x3(,%rsi,4), %esi
movslq %esi, %rsi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx)
andl $0x3, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::search_downward(unsigned int&, int&, int&, int&, double&, double&)
inline bool voronoicell_base::search_downward(unsigned int &lw,int &lp,int &ls,int &us,double &l,double &u) {
	int vs;

	// The test point is outside of the cutting space
	for(us=0;us<nu[up];us++) {
		lp=ed[up][us];
		lw=m_test(lp,l);
		if(u>l) break;
	}
	if(us==nu[up]) if(definite_min(lp,us,l,u,lw)) return false;

	while(lw==2) {
		//if(++count>=p) failsafe_find(lp,ls,us,l,u);

		// Test all the neighbors of the current point
		// and find the one which is closest to the
		// plane
		vs=ed[up][nu[up]+us];up=lp;u=l;
		for(us=0;us<nu[up];us++) {
			if(us==vs) continue;
			lp=ed[up][us];
			lw=m_test(lp,l);
			if(u>l) break;
		}
		if(us==nu[up]&&definite_min(lp,us,l,u,lw)) return false;
	}
	ls=ed[up][nu[up]+us];
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %eax, %eax
movl %eax, (%r15)
movq 0x30(%rbp), %rcx
movslq 0x20(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jge 0xa154
movq 0x28(%rbp), %rcx
movq (%rcx,%rdx,8), %rcx
cltq
movl (%rcx,%rax,4), %esi
movl %esi, (%r12)
movq %rbp, %rdi
movq %rbx, %rdx
callq 0xa0b0
movl %eax, (%r13)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
ucomisd (%rbx), %xmm0
movl (%r15), %eax
ja 0xa149
incl %eax
jmp 0xa101
movq 0x30(%rbp), %rcx
movslq 0x20(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jne 0xa179
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq 0x40(%rsp), %r8
movq %r13, %r9
callq 0x6754
testb %al, %al
jne 0xa243
movq %r14, (%rsp)
movslq 0x20(%rbp), %rcx
movq 0x28(%rbp), %rdx
movq 0x30(%rbp), %rax
movslq (%rax,%rcx,4), %rsi
movslq (%r15), %rdi
addq %rsi, %rdi
cmpl $0x2, (%r13)
movq (%rdx,%rcx,8), %rcx
movl (%rcx,%rdi,4), %r14d
jne 0xa247
movl (%r12), %ecx
movl %ecx, 0x20(%rbp)
movsd (%rbx), %xmm0
movq 0x40(%rsp), %rcx
movsd %xmm0, (%rcx)
xorl %edx, %edx
movl %edx, (%r15)
movslq 0x20(%rbp), %rdi
movl (%rax,%rdi,4), %esi
cmpl %esi, %edx
jge 0xa20f
movl %r14d, %ecx
cmpl %r14d, %edx
je 0xa209
movq 0x28(%rbp), %rax
movq (%rax,%rdi,8), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %esi
movl %esi, (%r12)
movq %rbp, %rdi
movq %rbx, %rdx
callq 0xa0b0
movl %eax, (%r13)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
ucomisd (%rbx), %xmm0
movl (%r15), %ecx
movq 0x30(%rbp), %rax
ja 0xa213
incl %ecx
movl %ecx, %edx
jmp 0xa1bc
movl %edx, %ecx
jmp 0xa21a
movslq 0x20(%rbp), %rdx
movl (%rax,%rdx,4), %esi
cmpl %esi, %ecx
jne 0xa17d
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq 0x40(%rsp), %r8
movq %r13, %r9
callq 0x6754
testb %al, %al
je 0xa17d
xorl %eax, %eax
jmp 0xa250
movq (%rsp), %rax
movl %r14d, (%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::search_upward(unsigned int&, int&, int&, int&, double&, double&)
inline bool voronoicell_base::search_upward(unsigned int &uw,int &lp,int &ls,int &us,double &l,double &u) {
	int vs;
	lp=up;l=u;

	// The test point is outside of the cutting space
	for(ls=0;ls<nu[lp];ls++) {
		up=ed[lp][ls];
		uw=m_test(up,u);
		if(u>l) break;
	}
	if(ls==nu[lp]) if(definite_max(lp,ls,l,u,uw)) {
		up=lp;
		return false;
	}

	while(uw==0) {
		//if(++count>=p) failsafe_find(lp,ls,us,l,u);

		// Test all the neighbors of the current point
		// and find the one which is closest to the
		// plane
		vs=ed[lp][nu[lp]+ls];lp=up;l=u;
		for(ls=0;ls<nu[lp];ls++) {
			if(ls==vs) continue;
			up=ed[lp][ls];
			uw=m_test(up,u);
			if(u>l) break;
		}
		if(ls==nu[lp]&&definite_max(lp,ls,l,u,uw)) {
			up=lp;
			return false;
		}
	}
	us=ed[lp][nu[lp]+ls];
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movq 0x50(%rsp), %rcx
movl 0x20(%rdi), %eax
movl %eax, (%rdx)
movsd (%rcx), %xmm0
movq %r9, %rbp
movsd %xmm0, (%r9)
xorl %eax, %eax
movq %r8, 0x10(%rsp)
movl %eax, (%r13)
movq 0x30(%r15), %rcx
movslq (%r12), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jge 0xa2f2
movq 0x28(%r15), %rcx
movq (%rcx,%rdx,8), %rcx
cltq
movl (%rcx,%rax,4), %esi
movl %esi, 0x20(%r15)
movq %r15, %rdi
movq 0x50(%rsp), %rbx
movq %rbx, %rdx
callq 0xa0b0
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movsd (%rbx), %xmm0
ucomisd (%rbp), %xmm0
movl (%r13), %eax
ja 0xa2e7
incl %eax
jmp 0xa299
movq 0x30(%r15), %rcx
movslq (%r12), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl %ecx, %eax
jne 0xa319
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq 0x50(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0x64c4
testb %al, %al
jne 0xa3d8
movslq (%r12), %rcx
movq 0x28(%r15), %rdx
movq 0x30(%r15), %rax
movslq (%rax,%rcx,4), %rsi
movslq (%r13), %rdi
addq %rsi, %rdi
movq 0x8(%rsp), %rsi
cmpl $0x0, (%rsi)
movq (%rdx,%rcx,8), %rcx
movl (%rcx,%rdi,4), %ebx
jne 0xa3cd
movl 0x20(%r15), %ecx
movl %ecx, (%r12)
movq 0x50(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rbp)
xorl %edx, %edx
movl %edx, (%r13)
movslq (%r12), %rdi
movl (%rax,%rdi,4), %esi
cmpl %esi, %edx
jge 0xa3b5
movl %ebx, %ecx
cmpl %ebx, %edx
je 0xa3af
movq 0x28(%r15), %rax
movq (%rax,%rdi,8), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %esi
movl %esi, 0x20(%r15)
movq %r15, %rdi
movq 0x50(%rsp), %r14
movq %r14, %rdx
callq 0xa0b0
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movsd (%r14), %xmm0
ucomisd (%rbp), %xmm0
movl (%r13), %ecx
movq 0x30(%r15), %rax
ja 0xa3b9
incl %ecx
movl %ecx, %edx
jmp 0xa35d
movl %edx, %ecx
jmp 0xa3c0
movslq (%r12), %rdx
movl (%rax,%rdx,4), %esi
cmpl %esi, %ecx
je 0xa2f6
jmp 0xa319
movq 0x10(%rsp), %rax
movl %ebx, (%rax)
movb $0x1, %al
jmp 0xa3e2
movl (%r12), %eax
movl %eax, 0x20(%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: void voro::voronoicell_base::add_memory_vorder<voro::voronoicell_neighbor>(voro::voronoicell_neighbor&)
void voronoicell_base::add_memory_vorder(vc_class &vc) {
	int i=(current_vertex_order<<1),j,*p1,**p2;
	if(i>max_vertex_order) voro_fatal_error("Vertex order memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Vertex order memory scaled up to %d\n",i);
#endif
	p1=new int[i];
	for(j=0;j<current_vertex_order;j++) p1[j]=mem[j];
	while(j<i) p1[j++]=0;
	delete [] mem;mem=p1;
	p2=new int*[i];
	for(j=0;j<current_vertex_order;j++) p2[j]=mep[j];
	delete [] mep;mep=p2;
	p1=new int[i];
	for(j=0;j<current_vertex_order;j++) p1[j]=mec[j];
	while(j<i) p1[j++]=0;
	delete [] mec;mec=p1;
	vc.n_add_memory_vorder(i);
	current_vertex_order=i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl 0xc(%rdi), %ebp
addl %ebp, %ebp
cmpl $0x801, %ebp            # imm = 0x801
jl 0xd9e8
leaq 0x23570(%rip), %rdi     # 0x30f50
pushq $0x2
popq %rsi
callq 0xfdaf
movq 0x315f1(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x23590(%rip), %rsi     # 0x30f89
xorl %r15d, %r15d
movl %ebp, %edx
xorl %eax, %eax
callq 0x21a0
movslq %ebp, %r13
leaq (,%r13,4), %rdi
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0x2030
movq %rax, %r12
movl 0xc(%rbx), %r14d
movq 0x60(%rbx), %rdi
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0xda47
movl (%rdi,%r15,4), %eax
movl %eax, (%r12,%r15,4)
incq %r15
jmp 0xda35
movq %r14, %rax
cmpq %r13, %rax
jge 0xda59
andl $0x0, (%r12,%rax,4)
incq %rax
jmp 0xda4a
testq %rdi, %rdi
je 0xda6f
callq 0x2170
movl 0xc(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
leaq (,%r13,8), %rdi
testl %ebp, %ebp
movq %r12, 0x60(%rbx)
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, %r12
movq 0x70(%rbx), %rdi
xorl %eax, %eax
cmpq %rax, %r14
je 0xdaa4
movq (%rdi,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
jmp 0xda92
testq %rdi, %rdi
je 0xdaba
callq 0x2170
movl 0xc(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
movq %r12, 0x70(%rbx)
movq 0x8(%rsp), %rdi
callq 0x2030
movq %rax, %r15
movq 0x68(%rbx), %rdi
xorl %eax, %eax
cmpq %rax, %r14
je 0xdaea
movl (%rdi,%rax,4), %ecx
movl %ecx, (%r15,%rax,4)
incq %rax
jmp 0xdad1
andl $0x0, (%r15,%r14,4)
incq %r14
cmpq %r13, %r14
jl 0xdae2
testq %rdi, %rdi
je 0xdaf9
callq 0x2170
movq %r15, 0x68(%rbx)
movq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0xfbf4
movl %ebp, 0xc(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: void voro::voronoicell_base::add_memory_vertices<voro::voronoicell>(voro::voronoicell&)
void voronoicell_base::add_memory_vertices(vc_class &vc) {
	int i=(current_vertices<<1),j,**pp,*pnu;
	unsigned int* pmask;
	if(i>max_vertices) voro_fatal_error("Vertex memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Vertex memory scaled up to %d\n",i);
#endif
	double *ppts;
	pp=new int*[i];
	for(j=0;j<current_vertices;j++) pp[j]=ed[j];
	delete [] ed;ed=pp;
	vc.n_add_memory_vertices(i);
	pnu=new int[i];
	for(j=0;j<current_vertices;j++) pnu[j]=nu[j];
	delete [] nu;nu=pnu;
	pmask=new unsigned int[i];
	for(j=0;j<current_vertices;j++) pmask[j]=mask[j];
	while(j<i) pmask[j++]=0;
	delete [] mask;mask=pmask;
	ppts=new double[i<<2];
	for(j=0;j<(current_vertices<<2);j++) ppts[j]=pts[j];
	delete [] pts;pts=ppts;
	current_vertices=i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movq %rax, 0x10(%rsp)
addl %eax, %eax
movl %eax, 0xc(%rsp)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0xd7bd
leaq 0x23896(%rip), %rdi     # 0x3104b
pushq $0x2
popq %rsi
callq 0xfdaf
movq 0x3181c(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x238b0(%rip), %rsi     # 0x3107e
xorl %r14d, %r14d
movl 0xc(%rsp), %ebp
movl %ebp, %edx
xorl %eax, %eax
callq 0x21a0
movslq %ebp, %r12
leaq (,%r12,8), %rdi
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, %r15
movl 0x8(%rbx), %r13d
movq 0x28(%rbx), %rdi
testl %r13d, %r13d
movl $0x0, %ebp
cmovgl %r13d, %ebp
cmpq %r14, %rbp
je 0xd820
movq (%rdi,%r14,8), %rax
movq %rax, (%r15,%r14,8)
incq %r14
jmp 0xd80e
testq %rdi, %rdi
je 0xd837
callq 0x2170
movl 0x8(%rbx), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovgl %r13d, %ebp
leaq (,%r12,4), %r14
cmpl $0x0, 0xc(%rsp)
movq %r15, 0x28(%rbx)
pushq $-0x1
popq %rax
cmovsq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq 0x30(%rbx), %rdi
xorl %eax, %eax
cmpq %rax, %rbp
je 0xd871
movl (%rdi,%rax,4), %ecx
movl %ecx, (%r15,%rax,4)
incq %rax
jmp 0xd860
testq %rdi, %rdi
je 0xd888
callq 0x2170
movl 0x8(%rbx), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovgl %r13d, %ebp
movq %r15, 0x30(%rbx)
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0x38(%rbx), %rdi
xorl %eax, %eax
cmpq %rax, %rbp
je 0xd8b6
movl (%rdi,%rax,4), %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
jmp 0xd89d
andl $0x0, (%r14,%rbp,4)
incq %rbp
cmpq %r12, %rbp
jl 0xd8ae
testq %rdi, %rdi
je 0xd8c9
callq 0x2170
movl 0x8(%rbx), %r13d
movq %r14, 0x38(%rbx)
movq 0x10(%rsp), %rax
shll $0x3, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, %r14
shll $0x2, %r13d
movq 0x40(%rbx), %rdi
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
cmpq %rax, %r13
je 0xd916
movsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0xd901
testq %rdi, %rdi
je 0xd920
callq 0x2170
movq %r14, 0x40(%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::reset_edges()
inline void voronoicell_base::reset_edges() {
	int i,j;
	for(i=0;i<p;i++) for(j=0;j<nu[i];j++) {
		if(ed[i][j]>=0) voro_fatal_error("Edge reset routine found a previously untested edge",VOROPP_INTERNAL_ERROR);
		ed[i][j]=-1-ed[i][j];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x22e4c(%rip), %r14     # 0x30e85
pushq $0x3
popq %rbp
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jge 0xe08b
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jge 0xe086
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %ecx
testl %ecx, %ecx
js 0xe07b
movq %r14, %rdi
movl %ebp, %esi
callq 0xfdaf
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %ecx
notl %ecx
movl %ecx, (%rax,%r12,4)
incq %r12
jmp 0xe048
incq %r15
jmp 0xe03c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::search_edge(int, int&, int&)
inline bool voronoicell_base::search_edge(int l,int &m,int &k) {
	for(m=0;m<nu[l];m++) {
		k=ed[l][m];
		if(k>=0) return true;
	}
	return false;
}

// Assembly:
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rdi
movslq %esi, %rsi
xorl %r8d, %r8d
movl %r8d, (%rdx)
movl (%rdi,%rsi,4), %r9d
cmpl %r9d, %r8d
jge 0xe53d
movq (%rax,%rsi,8), %r10
movslq %r8d, %r11
movl (%r10,%r11,4), %r10d
movl %r10d, (%rcx)
testl %r10d, %r10d
jns 0xe53d
movl (%rdx), %r8d
incl %r8d
jmp 0xe516
cmpl %r9d, %r8d
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::search_for_outside_edge(int&)
inline bool voronoicell_base::search_for_outside_edge(int &up) {
	int i,lp,lw,*j=stackp2,sc2=stackp2-ds2;
	double l;
	*(stackp2++)=up;
	while(j<stackp2) {
		up=*(j++);
		for(i=0;i<nu[up];i++) {
			lp=ed[up][i];
			lw=m_test(lp,l);
			if(lw==0) {
				stackp2=ds2+sc2;
				return true;
			}
			else if(lw==1) add_to_stack(sc2,lp);
		}
	}
	stackp2=ds2+sc2;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x98(%rdi), %rcx
movq %rcx, %r14
subq 0x90(%rdi), %r14
shrq $0x2, %r14
movl (%rsi), %eax
leaq 0x4(%rcx), %rdx
movq %rdx, 0x98(%rdi)
movl %eax, (%rcx)
leaq 0x20(%rsp), %r12
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpq %rdx, %rcx
jae 0xf33e
movq 0x8(%rsp), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %eax
movl %eax, (%r15)
xorl %r13d, %r13d
movq 0x30(%rbx), %rcx
cltq
movslq (%rcx,%rax,4), %rcx
cmpq %rcx, %r13
jge 0xf330
movq 0x28(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax,%r13,4), %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xa0b0
cmpl $0x1, %eax
je 0xf31b
testl %eax, %eax
jne 0xf328
jmp 0xf33e
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xf432
incq %r13
movl (%r15), %eax
jmp 0xf2e8
movq 0x98(%rbx), %rdx
movq 0x18(%rsp), %rcx
jmp 0xf2c3
movq 0x10(%rsp), %rax
cmpq %rax, 0x8(%rsp)
setb %al
movslq %r14d, %rcx
shlq $0x2, %rcx
addq 0x90(%rbx), %rcx
movq %rcx, 0x98(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::m_testx(int, double&)
inline unsigned int voronoicell_base::m_testx(int n,double &ans) {
	unsigned int maskr;
	if(mask[n]>=maskc) {
		ans=pts[4*n+3];
		maskr=mask[n]&3;
	} else maskr=m_calc(n,ans);
	if(maskr==0&&ans>-big_tol&&ed[n][nu[n]<<1]!=-1) {
		ed[n][nu[n]<<1]=-1;
		if(stackp3==stacke3) add_memory_xse();
		*(stackp3++)=n;
	}
	return maskr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x38(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %ebp
cmpl 0xc0(%rdi), %ebp
jae 0xf3a4
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x82d6
movl %eax, %ebp
jmp 0xf3bf
movq 0x40(%r14), %rax
leal 0x3(,%rbx,4), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r15)
andl $0x3, %ebp
testl %ebp, %ebp
jne 0xf427
movsd (%r15), %xmm0
movsd 0x58(%r14), %xmm1
xorpd 0x1fc6a(%rip), %xmm1    # 0x2f040
ucomisd %xmm1, %xmm0
jbe 0xf427
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
movq (%rax,%r12,8), %rax
movl (%rcx,%r12,4), %ecx
addl %ecx, %ecx
movslq %ecx, %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0xf427
orl $-0x1, (%rax,%rcx,4)
movq 0xb0(%r14), %rax
cmpq 0xb8(%r14), %rax
jne 0xf41a
movq %r14, %rdi
callq 0x537c
movq 0xb0(%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0xb0(%r14)
movl %ebx, (%rax)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: bool voro::voronoicell_base::collapse_order1<voro::voronoicell>(voro::voronoicell&)
bool voronoicell_base::collapse_order1(vc_class &vc) {
	int i,j,k;
	while(mec[1]>0) {
		up=0;
#if VOROPP_VERBOSE >=1
		fputs("Order one collapse\n",stderr);
#endif
		i=--mec[1];
		j=mep[1][3*i];k=mep[1][3*i+1];
		i=mep[1][3*i+2];
		if(!delete_connection(vc,j,k,false)) return false;
		--p;
		if(up==i) up=0;
		if(p!=i) {
			if(up==p) up=i;
			pts[i<<2]=pts[p<<2];
			pts[(i<<2)+1]=pts[(p<<2)+1];
			pts[(i<<2)+2]=pts[(p<<2)+2];
			for(k=0;k<nu[p];k++) ed[ed[p][k]][ed[p][nu[p]+k]]=i;
			vc.n_copy_pointer(i,p);
			ed[i]=ed[p];
			nu[i]=nu[p];
			ed[i][nu[i]<<1]=i;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2fb38(%rip), %r12     # 0x3efe0
leaq 0x21a73(%rip), %r15     # 0x30f22
movq 0x68(%r14), %rax
movl 0x4(%rax), %ebp
testl %ebp, %ebp
jle 0xf5f7
andl $0x0, 0x20(%r14)
movq (%r12), %rsi
movq %r15, %rdi
callq 0x2130
movq 0x68(%r14), %rax
movslq 0x4(%rax), %rcx
decq %rcx
movl %ecx, 0x4(%rax)
movq 0x70(%r14), %rax
movq 0x8(%rax), %rax
imulq $0xc, %rcx, %rsi
movl (%rax,%rsi), %edx
movl 0x4(%rax,%rsi), %ecx
movl 0x8(%rax,%rsi), %r13d
movq %r14, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0xf60c
testb %al, %al
je 0xf5f7
movl 0x1c(%r14), %ecx
movl 0x20(%r14), %eax
decl %ecx
movl %ecx, 0x1c(%r14)
cmpl %r13d, %eax
jne 0xf525
andl $0x0, 0x20(%r14)
xorl %eax, %eax
cmpl %r13d, %ecx
je 0xf4af
cmpl %ecx, %eax
jne 0xf532
movl %r13d, 0x20(%r14)
movslq %r13d, %rax
movq 0x40(%r14), %rdx
leal (,%rcx,4), %esi
movslq %esi, %rsi
movsd (%rdx,%rsi,8), %xmm0
leal (,%r13,4), %esi
movslq %esi, %rsi
movsd %xmm0, (%rdx,%rsi,8)
leal 0x1(,%rcx,4), %esi
movslq %esi, %rsi
movsd (%rdx,%rsi,8), %xmm0
leal 0x1(,%r13,4), %esi
movslq %esi, %rsi
movsd %xmm0, (%rdx,%rsi,8)
leal 0x2(,%rcx,4), %esi
movslq %esi, %rsi
movsd (%rdx,%rsi,8), %xmm0
leal 0x2(,%r13,4), %esi
movslq %esi, %rsi
movsd %xmm0, (%rdx,%rsi,8)
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rsi
xorl %edi, %edi
movslq %ecx, %r8
movslq (%rsi,%r8,4), %r9
movq (%rdx,%r8,8), %rcx
cmpq %r9, %rdi
jge 0xf5d2
movl %r9d, %r8d
movslq (%rcx,%rdi,4), %r9
movq (%rdx,%r9,8), %r9
addl %edi, %r8d
movslq %r8d, %r8
movslq (%rcx,%r8,4), %rcx
movl %r13d, (%r9,%rcx,4)
incq %rdi
movl 0x1c(%r14), %ecx
jmp 0xf5a0
movq %rcx, (%rdx,%rax,8)
movq 0x30(%r14), %rcx
movl (%rcx,%r8,4), %edx
movl %edx, (%rcx,%rax,4)
movq 0x28(%r14), %rcx
movq (%rcx,%rax,8), %rax
addl %edx, %edx
movslq %edx, %rcx
movl %r13d, (%rax,%rcx,4)
jmp 0xf4af
testl %ebp, %ebp
setle %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::check_duplicate(int, double, double, double, int, double*)
void check_duplicate(int n,double x,double y,double z,int id,double *qp) {
	double dx=*qp-x,dy=qp[1]-y,dz=qp[2]-z;
	if(dx*dx+dy*dy+dz*dz<1e-10) {
		printf("Duplicate: %d (%g,%g,%g) matches %d (%g,%g,%g)\n",n,x,y,z,id,*qp,qp[1],qp[2]);
		exit(1);
	}
}

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2140
testq %rax, %rax
je 0xfe6b
popq %rbx
retq
movq 0x2f16e(%rip), %rax     # 0x3efe0
movq (%rax), %rdi
leaq 0x21268(%rip), %rsi     # 0x310e4
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21a0
pushq $0x1
popq %rdi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::voro_print_vector(std::vector<int, std::allocator<int>>&, _IO_FILE*)
void voro_print_vector(std::vector<int> &v,FILE *fp) {
	int k=0,s=v.size();
	while(k+4<s) {
		fprintf(fp,"%d %d %d %d ",v[k],v[k+1],v[k+2],v[k+3]);
		k+=4;
	}
	if(k+3<=s) {
		if(k+4==s) fprintf(fp,"%d %d %d %d",v[k],v[k+1],v[k+2],v[k+3]);
		else fprintf(fp,"%d %d %d",v[k],v[k+1],v[k+2]);
	} else {
		if(k+2==s) fprintf(fp,"%d %d",v[k],v[k+1]);
		else fprintf(fp,"%d",v[k]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x2, %r12
movslq %r12d, %r13
leaq 0x21252(%rip), %r15     # 0x31106
xorl %eax, %eax
leaq 0x4(%rax), %rbp
cmpq %r13, %rbp
jge 0xfee5
movq (%r14), %rsi
movl (%rsi,%rax,4), %edx
movl 0x4(%rsi,%rax,4), %ecx
movl 0x8(%rsi,%rax,4), %r8d
movl 0xc(%rsi,%rax,4), %r9d
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21a0
movq %rbp, %rax
jmp 0xfeb6
leal 0x3(%rax), %ecx
movq (%r14), %rsi
movl (%rsi,%rax,4), %edx
cmpl %r12d, %ecx
jle 0xff20
movl %eax, %ecx
subl %r12d, %ecx
cmpl $-0x2, %ecx
jne 0xff57
movl 0x4(%rsi,%rax,4), %ecx
leaq 0x21211(%rip), %rsi     # 0x31119
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
movl %eax, %edi
subl %r12d, %edi
movl 0x4(%rsi,%rax,4), %ecx
movl 0x8(%rsi,%rax,4), %r8d
cmpl $-0x4, %edi
jne 0xff76
movl 0xc(%rsi,%rax,4), %r9d
leaq 0x211d4(%rip), %rsi     # 0x31113
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x20ef5(%rip), %rsi     # 0x30e53
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x21199(%rip), %rsi     # 0x31116
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/common.cc
// Function: voro::voro_print_vector(std::vector<double, std::allocator<double>>&, _IO_FILE*)
void voro_print_vector(std::vector<double> &v,FILE *fp) {
	int k=0,s=v.size();
	while(k+4<s) {
		fprintf(fp,"%g %g %g %g ",v[k],v[k+1],v[k+2],v[k+3]);
		k+=4;
	}
	if(k+3<=s) {
		if(k+4==s) fprintf(fp,"%g %g %g %g",v[k],v[k+1],v[k+2],v[k+3]);
		else fprintf(fp,"%g %g %g",v[k],v[k+1],v[k+2]);
	} else {
		if(k+2==s) fprintf(fp,"%g %g",v[k],v[k+1]);
		else fprintf(fp,"%g",v[k]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
subq (%rdi), %r12
shrq $0x3, %r12
movslq %r12d, %r13
xorl %eax, %eax
leaq 0x21162(%rip), %r15     # 0x3111f
leaq 0x4(%rax), %rbp
cmpq %r13, %rbp
jge 0xfff2
movq (%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd 0x8(%rcx,%rax,8), %xmm1
movsd 0x10(%rcx,%rax,8), %xmm2
movsd 0x18(%rcx,%rax,8), %xmm3
movq %rbx, %rdi
movq %r15, %rsi
movb $0x4, %al
callq 0x21a0
movq %rbp, %rax
jmp 0xffbd
leal 0x3(%rax), %edx
movq (%r14), %rcx
movsd (%rcx,%rax,8), %xmm0
cmpl %r12d, %edx
jle 0x10031
movl %eax, %edx
subl %r12d, %edx
cmpl $-0x2, %edx
jne 0x1006c
movsd 0x8(%rcx,%rax,8), %xmm1
leaq 0x21119(%rip), %rsi     # 0x31132
movq %rbx, %rdi
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
movl %eax, %edx
subl %r12d, %edx
movsd 0x8(%rcx,%rax,8), %xmm1
movsd 0x10(%rcx,%rax,8), %xmm2
cmpl $-0x4, %edx
jne 0x1008b
movsd 0x18(%rcx,%rax,8), %xmm3
leaq 0x210d8(%rip), %rsi     # 0x3112c
movq %rbx, %rdi
movb $0x4, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x210c2(%rip), %rsi     # 0x31135
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
leaq 0x2109d(%rip), %rsi     # 0x3112f
movq %rbx, %rdi
movb $0x3, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::~container_base()
container_base::~container_base() {
	int l;
	for(l=0;l<nxyz;l++) delete [] p[l];
	for(l=0;l<nxyz;l++) delete [] id[l];
	delete [] id;
	delete [] p;
	delete [] co;
	delete [] mem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x1052b
movq 0xb8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x10526
callq 0x2170
incq %r14
jmp 0x10508
xorl %r14d, %r14d
movslq %eax, %rcx
movq 0xb0(%rbx), %rdi
cmpq %rcx, %r14
jge 0x10553
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x1054e
callq 0x2170
movl 0x10(%rbx), %eax
incq %r14
jmp 0x1052e
testq %rdi, %rdi
je 0x1055d
callq 0x2170
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x1056e
callq 0x2170
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x1057f
callq 0x2170
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x10590
callq 0x2170
leaq 0x50(%rbx), %rdi
callq 0x104f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11bcc
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::put(int, double, double, double)
void container::put(int n,double x,double y,double z) {
	int ijk;
	if(put_locate_block(ijk,x,y,z)) {
		id[ijk][co[ijk]]=n;
		double *pp=p[ijk]+3*co[ijk]++;
		*(pp++)=x;*(pp++)=y;*pp=z;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x18(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x10(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0xc(%rsp), %rsi
callq 0x10796
testb %al, %al
je 0x1078e
movslq 0xc(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movq 0xb8(%rbx), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rdx,%rcx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rcx,4)
imulq $0x18, %rsi, %rcx
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rcx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax,%rcx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_poly::put(int, double, double, double, double)
void container_poly::put(int n,double x,double y,double z,double r) {
	int ijk;
	if(put_locate_block(ijk,x,y,z)) {
		id[ijk][co[ijk]]=n;
		double *pp=p[ijk]+4*co[ijk]++;
		*(pp++)=x;*(pp++)=y;*(pp++)=z;*pp=r;
		if(max_radius<r) max_radius=r;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movsd %xmm0, (%rdx)
leaq 0x18(%rsp), %rcx
movsd %xmm1, (%rcx)
leaq 0x10(%rsp), %r8
movsd %xmm2, (%r8)
leaq 0x4(%rsp), %rsi
callq 0x10796
testb %al, %al
je 0x10896
movslq 0x4(%rsp), %rax
movq 0xb0(%rbx), %rcx
movq 0xc0(%rbx), %rdx
movq (%rcx,%rax,8), %rcx
movslq (%rdx,%rax,4), %rax
movl %ebp, (%rcx,%rax,4)
movq 0xb8(%rbx), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rdx,%rcx,4), %rsi
leal 0x1(%rsi), %edi
movl %edi, (%rdx,%rcx,4)
shlq $0x5, %rsi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax,%rsi)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax,%rsi)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax,%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rax,%rsi)
ucomisd 0xe0(%rbx), %xmm0
jbe 0x10896
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xe0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container::put(voro::particle_order&, int, double, double, double)
void container::put(particle_order &vo,int n,double x,double y,double z) {
	int ijk;
	if(put_locate_block(ijk,x,y,z)) {
		id[ijk][co[ijk]]=n;
		vo.add(ijk,co[ijk]);
		double *pp=p[ijk]+3*co[ijk]++;
		*(pp++)=x;*(pp++)=y;*pp=z;
	}
}

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbp
movq 0xc8(%rdi), %rax
movslq %esi, %r12
movl (%rax,%r12,4), %eax
addl %eax, %eax
movl %eax, 0xc(%rsp)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x10a7b
leaq 0x206d4(%rip), %rdi     # 0x31147
pushq $0x2
popq %rsi
callq 0xfdaf
movl 0xc(%rsp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
testl %eax, %eax
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r14
movq 0xb0(%rbp), %r13
movq 0xc0(%rbp), %rax
movslq (%rax,%r12,4), %rbx
xorl %eax, %eax
cmpq %rbx, %rax
jge 0x10ac2
movq (%r13,%r12,8), %rcx
movl (%rcx,%rax,4), %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
jmp 0x10aac
movq %rbp, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0xd0(%rax), %ebp
movl %ebp, %eax
imull 0xc(%rsp), %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r15, %rdi
callq 0x2030
movq %rax, %r15
imull %ebp, %ebx
movq 0x10(%rsp), %rbp
movq 0xb8(%rbp), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x10b20
movq (%rax,%r12,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
incq %rcx
jmp 0x10b07
movq 0xc8(%rbp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, (%rax,%r12,4)
movq (%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x10b45
callq 0x2170
movq 0xb0(%rbp), %r13
movq %r14, (%r13,%r12,8)
movq 0xb8(%rbp), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x10b66
callq 0x2170
movq 0xb8(%rbp), %rax
movq %r15, (%rax,%r12,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.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 %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x52ec
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f28
movq %r14, %rdi
callq 0x5188
testb %al, %al
je 0x1143a
leaq 0x48(%rsp), %r14
movq %rsp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5356
movq %r15, %rdi
callq 0x51e6
testb %al, %al
jne 0x11420
leaq 0x48(%rsp), %rdi
callq 0x5744
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
jmp 0x11453
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5744
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
callq 0x52ec
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f28
movq %r14, %rdi
callq 0x5188
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testb %al, %al
je 0x11576
movsd %xmm0, 0x8(%rsp)
leaq 0x58(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5356
testb %al, %al
je 0x1156a
movq %r14, %rdi
callq 0x69f6
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0x51e6
testb %al, %al
jne 0x11540
leaq 0x58(%rsp), %rdi
callq 0x5744
movsd 0x8(%rsp), %xmm0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
jmp 0x11595
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5744
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::draw_domain_gnuplot(_IO_FILE*)
void container_base::draw_domain_gnuplot(FILE *fp) {
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",ax,ay,az,bx,ay,az,bx,by,az,ax,by,az);
	fprintf(fp,"%g %g %g\n%g %g %g\n%g %g %g\n%g %g %g\n",ax,by,bz,bx,by,bz,bx,ay,bz,ax,ay,bz);
	fprintf(fp,"%g %g %g\n\n%g %g %g\n%g %g %g\n\n",ax,by,bz,ax,ay,az,ax,ay,bz);
	fprintf(fp,"%g %g %g\n%g %g %g\n\n%g %g %g\n%g %g %g\n\n",bx,ay,az,bx,ay,bz,bx,by,az,bx,by,bz);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x80(%rdi), %xmm1
movsd 0x90(%rdi), %xmm2
movsd 0x70(%rdi), %xmm0
movsd 0x78(%rdi), %xmm3
movsd 0x88(%rdi), %xmm7
movsd %xmm2, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
leaq 0x1fac5(%rip), %r15     # 0x311c8
movq %rsi, %rdi
movq %r15, %rsi
movaps %xmm1, %xmm4
movaps %xmm2, %xmm5
movaps %xmm3, %xmm6
movb $0x8, %al
callq 0x21a0
movsd 0x88(%r14), %xmm1
movsd 0x98(%r14), %xmm2
movsd 0x70(%r14), %xmm0
movsd 0x78(%r14), %xmm3
movsd 0x80(%r14), %xmm7
movsd %xmm2, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movaps %xmm1, %xmm4
movaps %xmm2, %xmm5
movaps %xmm3, %xmm6
movb $0x8, %al
callq 0x21a0
movsd 0x88(%r14), %xmm1
movsd 0x98(%r14), %xmm2
movsd 0x70(%r14), %xmm0
movsd 0x80(%r14), %xmm4
movsd 0x90(%r14), %xmm5
movsd %xmm2, (%rsp)
leaq 0x1fa53(%rip), %rsi     # 0x311f6
movq %rbx, %rdi
movaps %xmm0, %xmm3
movaps %xmm0, %xmm6
movaps %xmm4, %xmm7
movb $0x8, %al
callq 0x21a0
movsd 0x78(%r14), %xmm0
movsd 0x80(%r14), %xmm1
movsd 0x90(%r14), %xmm2
movsd 0x98(%r14), %xmm5
movsd 0x88(%r14), %xmm7
movsd %xmm5, 0x18(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
leaq 0x1f9ef(%rip), %rsi     # 0x311ed
movq %rbx, %rdi
movaps %xmm0, %xmm3
movaps %xmm1, %xmm4
movaps %xmm0, %xmm6
movb $0x8, %al
callq 0x21a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::wall_list::increase_wall_memory()
void wall_list::increase_wall_memory() {
	current_wall_size<<=1;
	if(current_wall_size>max_wall_size)
		voro_fatal_error("Wall memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
	wall **nwalls=new wall*[current_wall_size],**nwp=nwalls,**wp=walls;
	while(wp<wep) *(nwp++)=*(wp++);
	delete [] walls;
	walls=nwalls;wel=walls+current_wall_size;wep=nwp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
addl %eax, %eax
movl %eax, 0x18(%rdi)
cmpl $0x801, %eax            # imm = 0x801
jl 0x11b62
leaq 0x1f75d(%rip), %rdi     # 0x312b4
pushq $0x2
popq %rsi
callq 0xfdaf
movl 0x18(%rbx), %eax
movslq %eax, %r15
leaq (,%r15,8), %rax
testl %r15d, %r15d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %r14, %r12
movq %rdi, %rcx
cmpq %rax, %rcx
jae 0x11ba2
movq (%rcx), %rdx
addq $0x8, %rcx
movq %rdx, (%r12)
addq $0x8, %r12
jmp 0x11b8c
testq %rdi, %rdi
je 0x11bb0
callq 0x2170
movslq 0x18(%rbx), %r15
movq %r14, (%rbx)
leaq (%r14,%r15,8), %rax
movq %rax, 0x10(%rbx)
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/voro++/src/container.cc
// Function: voro::container_base::put_remap(int&, double&, double&, double&)
inline bool container_base::put_remap(int &ijk,double &x,double &y,double &z) {
	int l;

	ijk=step_int((x-ax)*xsp);
	if(xperiodic) {l=step_mod(ijk,nx);x+=boxx*(l-ijk);ijk=l;}
	else if(ijk<0||ijk>=nx) return false;

	int j=step_int((y-ay)*ysp);
	if(yperiodic) {l=step_mod(j,ny);y+=boxy*(l-j);j=l;}
	else if(j<0||j>=ny) return false;

	int k=step_int((z-az)*zsp);
	if(zperiodic) {l=step_mod(k,nz);z+=boxz*(l-k);k=l;}
	else if(k<0||k>=nz) return false;

	ijk+=nx*j+nxy*k;
	return true;
}

// Assembly:
movsd (%rdx), %xmm0
movapd %xmm0, %xmm1
subsd 0x70(%rdi), %xmm1
mulsd 0x30(%rdi), %xmm1
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %r9d
subl %eax, %r9d
movl %r9d, (%rsi)
cmpb $0x1, 0xa8(%rdi)
jne 0x11c5f
movq %rdx, %r10
movl (%rdi), %r11d
testl %r9d, %r9d
js 0x11c6c
movl %r9d, %eax
cltd
idivl %r11d
jmp 0x11c7e
xorl %eax, %eax
testl %r9d, %r9d
js 0x11c6b
cmpl (%rdi), %r9d
jl 0x11c9a
retq
leal -0x1(%r11), %eax
subl %r9d, %eax
cltd
idivl %r11d
negl %edx
addl %r11d, %edx
decl %edx
movl %edx, %eax
subl %r9d, %eax
cvtsi2sd %eax, %xmm1
mulsd 0x18(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r10)
movl %edx, (%rsi)
movl %edx, %r9d
movsd (%rcx), %xmm0
movapd %xmm0, %xmm1
subsd 0x80(%rdi), %xmm1
mulsd 0x38(%rdi), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %r10d
subl %eax, %r10d
cmpb $0x1, 0xa9(%rdi)
jne 0x11cdb
movl 0x4(%rdi), %r11d
testl %r10d, %r10d
js 0x11cea
movl %r10d, %eax
cltd
idivl %r11d
jmp 0x11cfc
xorl %eax, %eax
testl %r10d, %r10d
js 0x11c6b
cmpl 0x4(%rdi), %r10d
jl 0x11d15
jmp 0x11c6b
leal -0x1(%r11), %eax
subl %r10d, %eax
cltd
idivl %r11d
negl %edx
addl %r11d, %edx
decl %edx
movl %edx, %eax
subl %r10d, %eax
cvtsi2sd %eax, %xmm1
mulsd 0x20(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
movl %edx, %r10d
movsd (%r8), %xmm0
movapd %xmm0, %xmm1
subsd 0x90(%rdi), %xmm1
mulsd 0x40(%rdi), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
cvttsd2si %xmm1, %ecx
subl %eax, %ecx
cmpb $0x1, 0xaa(%rdi)
jne 0x11d53
movl 0x8(%rdi), %r11d
testl %ecx, %ecx
js 0x11d67
movl %ecx, %eax
cltd
idivl %r11d
jmp 0x11d78
xorl %eax, %eax
testl %ecx, %ecx
js 0x11c6b
cmpl 0x8(%rdi), %ecx
jl 0x11d90
jmp 0x11c6b
leal -0x1(%r11), %eax
subl %ecx, %eax
cltd
idivl %r11d
negl %edx
addl %r11d, %edx
decl %edx
movl %edx, %eax
subl %ecx, %eax
cvtsi2sd %eax, %xmm1
mulsd 0x28(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r8)
movl %edx, %ecx
imull (%rdi), %r10d
imull 0xc(%rdi), %ecx
addl %r10d, %ecx
addl %r9d, %ecx
movl %ecx, (%rsi)
movb $0x1, %al
retq
nop