LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::create_cons(int)
std::vector<int> Graph::create_cons(int n_vertices){
    std::vector<int> cons;
    // add diamonds 
    for(int i = 0; i < n_vertices - 1; i++)
        cons.push_back(i);

    // add map
    for(int i = 1; i < n_vertices - 1; i++)
        cons.push_back(-i);
    
    std::random_device rd;
    std::mt19937 g(rd());
 
    std::shuffle(cons.begin(), cons.end(), g);

    return cons;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2710, %rsp           # imm = 0x2710
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, -0x13a8(%rbp)
cmpl $0x1, %edx
jle 0x6c45
movl %edx, %r14d
leal -0x1(%r14), %r12d
xorl %eax, %eax
leaq -0x13a8(%rbp), %r15
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6bd8
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6be3
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7d42
movl -0x13a8(%rbp), %eax
incl %eax
movl %eax, -0x13a8(%rbp)
cmpl %r12d, %eax
jl 0x6bc2
cmpl $0x2, %r14d
je 0x6c45
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq -0x13a8(%rbp), %r15
movl %r12d, -0x13a8(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6c27
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6c32
movq %rbx, %rdi
movq %r15, %rdx
callq 0x33fc
leal (%r14,%r12), %eax
decl %eax
movl %r12d, %ecx
decl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x6c09
leaq -0x13a8(%rbp), %rdi
callq 0x7742
leaq -0x13a8(%rbp), %rdi
callq 0x22a0
movl %eax, %eax
movq %rax, -0x2730(%rbp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, -0x2730(%rbp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x6c6b
leaq -0x2730(%rbp), %rdx
movq $0x270, 0x1380(%rdx) # imm = 0x270
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x77b1
leaq -0x13a8(%rbp), %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ce2
jmp 0x6cec
movq %rax, %r14
leaq -0x13a8(%rbp), %rdi
callq 0x21c0
jmp 0x6cef
movq %rax, %rdi
callq 0x3208
jmp 0x6cec
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6cfc
callq 0x21d0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::add_memory_xse()
void voronoicell_base::add_memory_xse() {
	current_xsearch_size<<=1;
	if(current_xsearch_size>max_xsearch_size) voro_fatal_error("Extra search stack memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Extra search stack memory scaled up to %d\n",current_xsearch_size);
#endif
	int *dsn=new int[current_xsearch_size],*dsnp=dsn,*dsp=xse;
	while(dsp<stackp3) *(dsnp++)=*(dsp++);
	delete [] xse;xse=dsn;stackp3=dsnp;
	stacke3=xse+current_xsearch_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %edx
addl %edx, %edx
movl %edx, 0x18(%rdi)
cmpl $0x1000001, %edx        # imm = 0x1000001
jl 0x2377
leaq 0x3691f(%rip), %rdi     # 0x38c8b
pushq $0x2
popq %rsi
callq 0x133c5
movl 0x18(%rbx), %edx
movq 0x42c62(%rip), %rax     # 0x44fe0
movq (%rax), %rdi
leaq 0x36942(%rip), %rsi     # 0x38cca
xorl %eax, %eax
callq 0x21b0
movslq 0x18(%rbx), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rax
movq %r14, %r12
cmpq %rax, %rdi
jae 0x23dc
movq %rdi, %rcx
movq %r14, %r12
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
cmpq %rax, %rcx
jb 0x23c9
testq %rdi, %rdi
je 0x23ea
callq 0x2180
movslq 0x18(%rbx), %r15
movq %r14, 0xa8(%rbx)
movq %r12, 0xb0(%rbx)
leaq (%r14,%r15,4), %rax
movq %rax, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::add_memory_ds()
void voronoicell_base::add_memory_ds() {
	current_delete_size<<=1;
	if(current_delete_size>max_delete_size) voro_fatal_error("Delete stack 1 memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Delete stack 1 memory scaled up to %d\n",current_delete_size);
#endif
	int *dsn=new int[current_delete_size],*dsnp=dsn,*dsp=ds;
	while(dsp<stackp) *(dsnp++)=*(dsp++);
	delete [] ds;ds=dsn;stackp=dsnp;
	stacke=ds+current_delete_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %edx
addl %edx, %edx
movl %edx, 0x10(%rdi)
cmpl $0x1000001, %edx        # imm = 0x1000001
jl 0x243d
leaq 0x36795(%rip), %rdi     # 0x38bc7
pushq $0x2
popq %rsi
callq 0x133c5
movl 0x10(%rbx), %edx
movq 0x42b9c(%rip), %rax     # 0x44fe0
movq (%rax), %rdi
leaq 0x367b4(%rip), %rsi     # 0x38c02
xorl %eax, %eax
callq 0x21b0
movslq 0x10(%rbx), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rax
movq %r14, %r12
cmpq %rax, %rdi
jae 0x249f
movq %rdi, %rcx
movq %r14, %r12
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
cmpq %rax, %rcx
jb 0x248c
testq %rdi, %rdi
je 0x24ad
callq 0x2180
movslq 0x10(%rbx), %r15
movq %r14, 0x78(%rbx)
movq %r12, 0x80(%rbx)
leaq (%r14,%r15,4), %rax
movq %rax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::add_memory_ds2()
void voronoicell_base::add_memory_ds2() {
	current_delete2_size<<=1;
	if(current_delete2_size>max_delete2_size) voro_fatal_error("Delete stack 2 memory allocation exceeded absolute maximum",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Delete stack 2 memory scaled up to %d\n",current_delete2_size);
#endif
	int *dsn=new int[current_delete2_size],*dsnp=dsn,*dsp=ds2;
	while(dsp<stackp2) *(dsnp++)=*(dsp++);
	delete [] ds2;ds2=dsn;stackp2=dsnp;
	stacke2=ds2+current_delete2_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %edx
addl %edx, %edx
movl %edx, 0x14(%rdi)
cmpl $0x1000001, %edx        # imm = 0x1000001
jl 0x24fd
leaq 0x36737(%rip), %rdi     # 0x38c29
pushq $0x2
popq %rsi
callq 0x133c5
movl 0x14(%rbx), %edx
movq 0x42adc(%rip), %rax     # 0x44fe0
movq (%rax), %rdi
leaq 0x36756(%rip), %rsi     # 0x38c64
xorl %eax, %eax
callq 0x21b0
movslq 0x14(%rbx), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r14
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rax
movq %r14, %r12
cmpq %rax, %rdi
jae 0x2562
movq %rdi, %rcx
movq %r14, %r12
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r12)
addq $0x4, %r12
cmpq %rax, %rcx
jb 0x254f
testq %rdi, %rdi
je 0x2570
callq 0x2180
movslq 0x14(%rbx), %r15
movq %r14, 0x90(%rbx)
movq %r12, 0x98(%rbx)
leaq (%r14,%r15,4), %rax
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x74(%rdi), %eax
addl %eax, %eax
movl %eax, 0x74(%rdi)
movslq %eax, %r13
leaq (,%r13,4), %rax
testl %r13d, %r13d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r12
movq 0x42230(%rip), %rax     # 0x44fe0
movq (%rax), %rdi
leaq 0x3666f(%rip), %rsi     # 0x39429
movl %r13d, %edx
xorl %eax, %eax
callq 0x21b0
movq (%r15), %rax
cmpq (%rbx), %rax
jbe 0x2e22
movq %r12, %r13
cmpq 0x98(%r14), %rax
jae 0x2df8
movq %r12, %r13
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %rcx, %rax
cmpq 0x98(%r14), %rcx
jb 0x2ddb
movq 0x90(%r14), %rax
movq %rax, (%r15)
cmpq (%rbx), %rax
jae 0x2e43
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %rcx, %rax
cmpq (%rbx), %rcx
jb 0x2e07
jmp 0x2e43
movq %r12, %r13
jae 0x2e43
movq %r12, %r13
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %rcx, %rax
cmpq (%rbx), %rcx
jb 0x2e2a
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0x2e54
callq 0x2180
movq %r12, 0x90(%r14)
movq %r12, (%r15)
movslq 0x74(%r14), %rax
shlq $0x2, %rax
addq 0x90(%r14), %rax
movq %rax, 0x98(%r14)
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/pre_container.cc
// Function: voro::pre_container_base::extend_chunk_index()
void pre_container_base::extend_chunk_index() {
	index_sz<<=1;
	if(index_sz>max_chunk_size)
		voro_fatal_error("Absolute memory limit on chunk index reached",VOROPP_MEMORY_ERROR);
#if VOROPP_VERBOSE >=2
	fprintf(stderr,"Pre-container chunk index scaled up to %d\n",index_sz);
#endif
	int **n_id=new int*[index_sz],**p_id=n_id,**c_id=pre_id;
	double **n_p=new double*[index_sz],**p_p=n_p,**c_p=pre_p;
	while(c_id<end_id) {
		*(p_id++)=*(c_id++);
		*(p_p++)=*(c_p++);
	}
	delete [] pre_id;pre_id=n_id;end_id=p_id;l_id=pre_id+index_sz;
	delete [] pre_p;pre_p=n_p;end_p=p_p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %edx
addl %edx, %edx
movl %edx, 0x38(%rdi)
cmpl $0x10001, %edx          # imm = 0x10001
jl 0x31e2
leaq 0x3a3e1(%rip), %rdi     # 0x3d5b8
pushq $0x2
popq %rsi
callq 0x133c5
movl 0x38(%rbx), %edx
movq 0x41df7(%rip), %rax     # 0x44fe0
movq (%rax), %rdi
leaq 0x3a3f2(%rip), %rsi     # 0x3d5e5
xorl %eax, %eax
callq 0x21b0
movslq 0x38(%rbx), %rcx
leaq (,%rcx,8), %rax
movq %rcx, (%rsp)
testq %rcx, %rcx
pushq $-0x1
popq %r14
cmovnsq %rax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r13
movq 0x40(%rbx), %r12
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0x48(%rbx), %rax
movq 0x68(%rbx), %rdi
movq %r13, %r15
movq %r14, %rbp
cmpq %rax, %r12
jae 0x3270
movq %rdi, %rcx
movq %r14, %rbp
movq %r13, %r15
movq %r12, %rdx
movq (%rdx), %rsi
addq $0x8, %rdx
movq %rsi, (%r15)
addq $0x8, %r15
movq (%rcx), %rsi
addq $0x8, %rcx
movq %rsi, (%rbp)
addq $0x8, %rbp
cmpq %rax, %rdx
jb 0x324e
testq %r12, %r12
movq (%rsp), %rax
je 0x3289
movq %r12, %rdi
callq 0x2180
movslq 0x38(%rbx), %rax
movq 0x68(%rbx), %rdi
movq %r13, 0x40(%rbx)
movq %r15, 0x48(%rbx)
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x50(%rbx)
testq %rdi, %rdi
je 0x32aa
callq 0x2180
movq %r14, 0x68(%rbx)
movq %rbp, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::~voronoicell_base()
voronoicell_base::~voronoicell_base() {
	for(int i=current_vertex_order-1;i>=0;i--) if(mem[i]>0) delete [] mep[i];
	delete [] xse;
	delete [] ds2;delete [] ds;
	delete [] mep;delete [] mec;
	delete [] mem;delete [] pts;
	delete [] mask;
	delete [] nu;delete [] ed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3dd36(%rip), %rax     # 0x44c18
movq %rax, (%rdi)
movslq 0xc(%rdi), %r14
testq %r14, %r14
jle 0x6f19
incq %r14
movq 0x60(%rbx), %rax
cmpl $0x0, -0x8(%rax,%r14,4)
jle 0x6f10
movq 0x70(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6f10
callq 0x2180
decq %r14
cmpq $0x1, %r14
ja 0x6ef1
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x6f2a
callq 0x2180
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x6f3b
callq 0x2180
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x6f49
callq 0x2180
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x6f57
callq 0x2180
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x6f65
callq 0x2180
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x6f73
callq 0x2180
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x6f81
callq 0x2180
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6f8f
callq 0x2180
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x6f9d
callq 0x2180
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x6fb2
popq %rbx
popq %r14
jmp 0x2180
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::copy(voro::voronoicell_base*)
void voronoicell_base::copy(voronoicell_base* vb) {
	int i,j;
	p=vb->p;up=0;
	for(i=0;i<current_vertex_order;i++) {
		mec[i]=vb->mec[i];
		for(j=0;j<mec[i]*(2*i+1);j++) mep[i][j]=vb->mep[i][j];
		for(j=0;j<mec[i]*(2*i+1);j+=2*i+1) ed[mep[i][j+2*i]]=mep[i]+j;
	}
	for(i=0;i<p;i++) nu[i]=vb->nu[i];
	for(i=0;i<(p<<2);i++) pts[i]=vb->pts[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x1c(%rsi), %eax
movl %eax, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
cmpl $0x0, 0xc(%rdi)
jle 0x708a
movq 0x68(%rdi), %r9
movl $0x1, %eax
movl $0x4, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
movq 0x68(%rsi), %r10
movl (%r10,%r8,4), %r11d
movl %r11d, (%r9,%r8,4)
leal (%r8,%r8), %r10d
movslq %r10d, %r10
incq %r10
imull %r10d, %r11d
testl %r11d, %r11d
jle 0x706b
movq 0x70(%rsi), %r11
movq (%r11,%r8,8), %r11
movq 0x70(%rdi), %rbx
movq (%rbx,%r8,8), %rbx
xorl %r14d, %r14d
movl (%r11,%r14,4), %ebp
movl %ebp, (%rbx,%r14,4)
incq %r14
movslq (%r9,%r8,4), %r15
imulq %r10, %r15
cmpq %r15, %r14
jl 0x7018
testl %r15d, %r15d
jle 0x706b
movslq %r10d, %r10
xorl %r11d, %r11d
xorl %ebx, %ebx
movq 0x28(%rdi), %r9
movq 0x70(%rdi), %r14
movq (%r14,%r8,8), %r14
addq %r11, %r14
movslq (%rdx,%r14), %r15
movq %r14, (%r9,%r15,8)
addq %rax, %rbx
movq 0x68(%rdi), %r9
movslq (%r9,%r8,4), %r14
imulq %r10, %r14
addq %rcx, %r11
cmpq %r14, %rbx
jl 0x703d
incq %r8
movslq 0xc(%rdi), %r10
addq $0x2, %rax
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %r10, %r8
jl 0x6fe6
movl 0x1c(%rdi), %eax
testl %eax, %eax
jle 0x70ad
movq 0x30(%rsi), %rcx
movq 0x30(%rdi), %rdx
xorl %r8d, %r8d
movl (%rcx,%r8,4), %eax
movl %eax, (%rdx,%r8,4)
incq %r8
movslq 0x1c(%rdi), %rax
cmpq %rax, %r8
jl 0x7099
shll $0x2, %eax
testl %eax, %eax
jle 0x70d2
movq 0x40(%rsi), %rcx
movq 0x40(%rdi), %rdx
movl %eax, %eax
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x70c0
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::operator=(voro::voronoicell&)
void voronoicell_neighbor::operator=(voronoicell &c) {
	voronoicell_base *vb=((voronoicell_base*) &c);
	check_memory_for_copy(*this,vb);copy(vb);
	int i,j;
	for(i=0;i<c.current_vertex_order;i++) {
		for(j=0;j<c.mec[i]*i;j++) mne[i][j]=0;
		for(j=0;j<c.mec[i];j++) ne[c.mep[i][(2*i+1)*j+2*i]]=mne[i]+(j*i);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x1104a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6fb6
cmpl $0x0, 0xc(%rbx)
jle 0x71b5
movq 0x68(%rbx), %rdi
movl $0x4, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl (%rdi,%rsi,4), %r8d
movl %r8d, %r9d
imull %esi, %r9d
testl %r9d, %r9d
jle 0x7150
movq 0xe8(%r14), %r8
movq (%r8,%rsi,8), %r9
xorl %r10d, %r10d
movl $0x0, (%r9,%r10,4)
incq %r10
movl (%rdi,%rsi,4), %r8d
movl %r8d, %r11d
imull %esi, %r11d
movslq %r11d, %r11
cmpq %r11, %r10
jl 0x7132
testl %r8d, %r8d
jle 0x7199
xorl %r8d, %r8d
movq %rdx, %r9
xorl %r10d, %r10d
movq 0xe8(%r14), %rdi
movq 0xf0(%r14), %r11
movq (%rdi,%rsi,8), %rdi
addq %r8, %rdi
movq 0x70(%rbx), %r15
movq (%r15,%rsi,8), %r15
movslq (%r15,%r9), %r15
movq %rdi, (%r11,%r15,8)
incq %r10
movq 0x68(%rbx), %rdi
movslq (%rdi,%rsi,4), %r11
addq %rax, %r9
addq %rcx, %r8
cmpq %r11, %r10
jl 0x715e
incq %rsi
movslq 0xc(%rbx), %r8
addq $0x8, %rdx
addq $0x8, %rax
addq $0x4, %rcx
cmpq %r8, %rsi
jl 0x7114
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::operator=(voro::voronoicell_neighbor&)
void voronoicell_neighbor::operator=(voronoicell_neighbor &c) {
	voronoicell_base *vb=((voronoicell_base*) &c);
	check_memory_for_copy(*this,vb);copy(vb);
	int i,j;
	for(i=0;i<c.current_vertex_order;i++) {
		for(j=0;j<c.mec[i]*i;j++) mne[i][j]=c.mne[i][j];
		for(j=0;j<c.mec[i];j++) ne[c.mep[i][(2*i+1)*j+2*i]]=mne[i]+(j*i);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x1104a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6fb6
cmpl $0x0, 0xc(%rbx)
jle 0x72a3
movq 0x68(%rbx), %rdi
movl $0x4, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl (%rdi,%rsi,4), %r10d
movl %r10d, %r8d
imull %esi, %r8d
testl %r8d, %r8d
jle 0x723e
movq 0xe8(%rbx), %r8
movq (%r8,%rsi,8), %r8
movq 0xe8(%r14), %r9
movq (%r9,%rsi,8), %r9
xorl %r11d, %r11d
movl (%r8,%r11,4), %r10d
movl %r10d, (%r9,%r11,4)
incq %r11
movl (%rdi,%rsi,4), %r10d
movl %r10d, %ebp
imull %esi, %ebp
movslq %ebp, %r15
cmpq %r15, %r11
jl 0x7221
testl %r10d, %r10d
jle 0x7287
xorl %r8d, %r8d
movq %rdx, %r9
xorl %r10d, %r10d
movq 0xe8(%r14), %rdi
movq 0xf0(%r14), %r11
movq (%rdi,%rsi,8), %rdi
addq %r8, %rdi
movq 0x70(%rbx), %r15
movq (%r15,%rsi,8), %r15
movslq (%r15,%r9), %r15
movq %rdi, (%r11,%r15,8)
incq %r10
movq 0x68(%rbx), %rdi
movslq (%rdi,%rsi,4), %r11
addq %rax, %r9
addq %rcx, %r8
cmpq %r11, %r10
jl 0x724c
incq %rsi
movslq 0xc(%rbx), %r8
addq $0x8, %rdx
addq $0x8, %rax
addq $0x4, %rcx
cmpq %r8, %rsi
jl 0x71f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::translate(double, double, double)
void voronoicell_base::translate(double x,double y,double z) {
	x*=2;y*=2;z*=2;
	double *ptsp=pts;
	while(ptsp<pts+(p<<2)) {
		*(ptsp++)+=x;*(ptsp++)+=y;*ptsp+=z;ptsp+=2;
	}
}

// Assembly:
movl 0x1c(%rdi), %ecx
shll $0x2, %ecx
testl %ecx, %ecx
jle 0x72f2
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd %xmm0, %xmm0
addsd %xmm2, %xmm2
movq 0x40(%rdi), %rax
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rcx
movupd (%rax), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rax)
movsd 0x10(%rax), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rax)
addq $0x20, %rax
cmpq %rcx, %rax
jb 0x72cf
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::construct_relations()
void voronoicell_base::construct_relations() {
	int i,j,k,l;
	for(i=0;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		l=0;
		while(ed[k][l]!=i) {
			l++;
			if(l==nu[k]) voro_fatal_error("Relation table construction failed",VOROPP_INTERNAL_ERROR);
		}
		ed[i][nu[i]+j]=l;
	}
}

// Assembly:
movl 0x1c(%rdi), %ecx
testl %ecx, %ecx
jle 0x783d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
xorl %r15d, %r15d
leaq 0x315a7(%rip), %r14     # 0x38d48
cmpl $0x0, (%rax,%r15,4)
jle 0x7820
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rdx
xorl %r12d, %r12d
movslq (%rdx,%r12,4), %rbp
movq (%rcx,%rbp,8), %rsi
movl (%rsi), %esi
xorl %r13d, %r13d
cmpq %rsi, %r15
je 0x7803
movl $0x1, %r13d
movq 0x30(%rbx), %rax
movl (%rax,%rbp,4), %eax
cmpq %rax, %r13
jne 0x77e8
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq (%rcx,%rbp,8), %rax
movl (%rax,%r13,4), %eax
incq %r13
cmpq %rax, %r15
jne 0x77cb
decl %r13d
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rdx
movslq (%rax,%r15,4), %rsi
movslq %r12d, %rdi
addq %rsi, %rdi
movl %r13d, (%rdx,%rdi,4)
incq %r12
movslq (%rax,%r15,4), %rsi
cmpq %rsi, %r12
jl 0x77b3
movl 0x1c(%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x77a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::init_octahedron_base(double)
void voronoicell_base::init_octahedron_base(double l) {
	for(int i=0;i<current_vertex_order;i++) mec[i]=0;
	up=0;
	mec[4]=p=6;l*=2;
	*pts=-l;pts[1]=0;pts[2]=0;
	pts[4]=l;pts[5]=0;pts[6]=0;
	pts[8]=0;pts[9]=-l;pts[10]=0;
	pts[12]=0;pts[13]=l;pts[14]=0;
	pts[16]=0;pts[17]=0;pts[18]=-l;
	pts[20]=0;pts[21]=0;pts[22]=l;
	int *q=mep[4];
	*q=2;q[1]=5;q[2]=3;q[3]=4;q[4]=0;q[5]=0;q[6]=0;q[7]=0;q[8]=0;
	q[9]=2;q[10]=4;q[11]=3;q[12]=5;q[13]=2;q[14]=2;q[15]=2;q[16]=2;q[17]=1;
	q[18]=0;q[19]=4;q[20]=1;q[21]=5;q[22]=0;q[23]=3;q[24]=0;q[25]=1;q[26]=2;
	q[27]=0;q[28]=5;q[29]=1;q[30]=4;q[31]=2;q[32]=3;q[33]=2;q[34]=1;q[35]=3;
	q[36]=0;q[37]=3;q[38]=1;q[39]=2;q[40]=3;q[41]=3;q[42]=1;q[43]=1;q[44]=4;
	q[45]=0;q[46]=2;q[47]=1;q[48]=3;q[49]=1;q[50]=3;q[51]=3;q[52]=1;q[53]=5;
	*ed=q;ed[1]=q+9;ed[2]=q+18;ed[3]=q+27;ed[4]=q+36;ed[5]=q+45;
	*nu=nu[1]=nu[2]=nu[3]=nu[4]=nu[5]=4;
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
movq 0x68(%rdi), %rax
jle 0x785d
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
incq %rcx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x784a
movq $0x6, 0x1c(%rdi)
movl $0x6, 0x10(%rax)
addsd %xmm0, %xmm0
movapd 0x2f7c8(%rip), %xmm1    # 0x37040
xorpd %xmm0, %xmm1
movq 0x40(%rdi), %rax
movlpd %xmm1, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%rax)
movsd %xmm0, 0x20(%rax)
xorl %ecx, %ecx
movq %rcx, 0x40(%rax)
movups %xmm2, 0x28(%rax)
movlpd %xmm1, 0x48(%rax)
movq %rcx, 0x50(%rax)
movq %rcx, 0x60(%rax)
movsd %xmm0, 0x68(%rax)
movq %rcx, 0x70(%rax)
movups %xmm2, 0x80(%rax)
movlpd %xmm1, 0x90(%rax)
movups %xmm2, 0xa0(%rax)
movsd %xmm0, 0xb0(%rax)
movq 0x70(%rdi), %rax
movq 0x20(%rax), %rax
movaps 0x30ef3(%rip), %xmm0    # 0x387d0
movups %xmm0, (%rax)
leaq 0x24(%rax), %rcx
movups %xmm2, 0x10(%rax)
movl $0x0, 0x20(%rax)
movaps 0x30eea(%rip), %xmm0    # 0x387e0
movups %xmm0, 0x24(%rax)
movaps 0x30eef(%rip), %xmm0    # 0x387f0
movups %xmm0, 0x34(%rax)
leaq 0x48(%rax), %rdx
movaps 0x30ef0(%rip), %xmm0    # 0x38800
movups %xmm0, 0x44(%rax)
movaps 0x30ef5(%rip), %xmm0    # 0x38810
movups %xmm0, 0x54(%rax)
leaq 0x6c(%rax), %rsi
movaps 0x30ef6(%rip), %xmm0    # 0x38820
movups %xmm0, 0x64(%rax)
movaps 0x30efb(%rip), %xmm0    # 0x38830
movups %xmm0, 0x74(%rax)
leaq 0x90(%rax), %r8
movaps 0x30ef9(%rip), %xmm0    # 0x38840
movups %xmm0, 0x84(%rax)
movaps 0x30efb(%rip), %xmm0    # 0x38850
movups %xmm0, 0x94(%rax)
movaps 0x30efd(%rip), %xmm0    # 0x38860
movups %xmm0, 0xa4(%rax)
leaq 0xb4(%rax), %r9
movaps 0x30ef8(%rip), %xmm0    # 0x38870
movups %xmm0, 0xb4(%rax)
movaps 0x30efa(%rip), %xmm0    # 0x38880
movups %xmm0, 0xc4(%rax)
movl $0x5, 0xd4(%rax)
movq 0x28(%rdi), %r10
movq %rax, (%r10)
movq 0x28(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rdi), %rax
movq %rdx, 0x10(%rax)
movq 0x28(%rdi), %rax
movq %rsi, 0x18(%rax)
movq 0x28(%rdi), %rax
movq %r8, 0x20(%rax)
movq 0x28(%rdi), %rax
movq %r9, 0x28(%rax)
movq 0x30(%rdi), %rax
movabsq $0x400000004, %rcx      # imm = 0x400000004
movq %rcx, 0x10(%rax)
movaps 0x30eb1(%rip), %xmm0    # 0x38890
movups %xmm0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::init_tetrahedron_base(double, double, double, double, double, double, double, double, double, double, double, double)
void voronoicell_base::init_tetrahedron_base(double x0,double y0,double z0,double x1,double y1,double z1,double x2,double y2,double z2,double x3,double y3,double z3) {
	for(int i=0;i<current_vertex_order;i++) mec[i]=0;
	up=0;
	mec[3]=p=4;
	*pts=x0*2;pts[1]=y0*2;pts[2]=z0*2;
	pts[4]=x1*2;pts[5]=y1*2;pts[6]=z1*2;
	pts[8]=x2*2;pts[9]=y2*2;pts[10]=z2*2;
	pts[12]=x3*2;pts[13]=y3*2;pts[14]=z3*2;
	int *q=mep[3];
	*q=1;q[1]=3;q[2]=2;q[3]=0;q[4]=0;q[5]=0;q[6]=0;
	q[7]=0;q[8]=2;q[9]=3;q[10]=0;q[11]=2;q[12]=1;q[13]=1;
	q[14]=0;q[15]=3;q[16]=1;q[17]=2;q[18]=2;q[19]=1;q[20]=2;
	q[21]=0;q[22]=1;q[23]=2;q[24]=1;q[25]=2;q[26]=1;q[27]=3;
	*ed=q;ed[1]=q+7;ed[2]=q+14;ed[3]=q+21;
	*nu=nu[1]=nu[2]=nu[3]=3;
}

// Assembly:
movsd 0x20(%rsp), %xmm8
movsd 0x18(%rsp), %xmm10
movsd 0x10(%rsp), %xmm9
movsd 0x8(%rsp), %xmm11
cmpl $0x0, 0xc(%rdi)
movq 0x68(%rdi), %rax
jle 0x7a1f
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
incq %rcx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x7a0c
movq $0x4, 0x1c(%rdi)
movl $0x4, 0xc(%rax)
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd %xmm0, %xmm0
movq 0x40(%rdi), %rax
movupd %xmm0, (%rax)
addsd %xmm2, %xmm2
movsd %xmm2, 0x10(%rax)
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
addpd %xmm3, %xmm3
movupd %xmm3, 0x20(%rax)
addsd %xmm5, %xmm5
movsd %xmm5, 0x30(%rax)
unpcklpd %xmm7, %xmm6            # xmm6 = xmm6[0],xmm7[0]
addpd %xmm6, %xmm6
movupd %xmm6, 0x40(%rax)
addsd %xmm11, %xmm11
movsd %xmm11, 0x50(%rax)
unpcklpd %xmm10, %xmm9           # xmm9 = xmm9[0],xmm10[0]
addpd %xmm9, %xmm9
movupd %xmm9, 0x60(%rax)
addsd %xmm8, %xmm8
movsd %xmm8, 0x70(%rax)
movq 0x70(%rdi), %rax
movq 0x18(%rax), %rax
movabsq $0x300000001, %rcx      # imm = 0x300000001
movq %rcx, (%rax)
movl $0x2, 0x8(%rax)
leaq 0x1c(%rax), %rcx
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc(%rax)
movl $0x0, 0x1c(%rax)
movaps 0x30dd9(%rip), %xmm0    # 0x388a0
movups %xmm0, 0x20(%rax)
leaq 0x38(%rax), %rdx
movaps 0x30dda(%rip), %xmm0    # 0x388b0
movups %xmm0, 0x30(%rax)
movaps 0x30ddf(%rip), %xmm0    # 0x388c0
movups %xmm0, 0x40(%rax)
leaq 0x54(%rax), %rsi
movaps 0x30de0(%rip), %xmm0    # 0x388d0
movups %xmm0, 0x50(%rax)
movaps 0x30de5(%rip), %xmm0    # 0x388e0
movups %xmm0, 0x60(%rax)
movq 0x28(%rdi), %r8
movq %rax, (%r8)
movq 0x28(%rdi), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rdi), %rax
movq %rdx, 0x10(%rax)
movq 0x28(%rdi), %rax
movq %rsi, 0x18(%rax)
movq 0x30(%rdi), %rax
movaps 0x30bb7(%rip), %xmm0    # 0x386e0
movups %xmm0, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::minkowski(double, double&, double&)
void voronoicell_base::minkowski(double r,double &ar,double &vo) {
	int i,j,k,l,m,n;
	ar=vo=0;r*=2;
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			m=ed[k][l];ed[k][l]=-1-m;
			while(m!=i) {
				n=cycle_up(ed[k][nu[k]+l],m);
				minkowski_contrib(i,k,m,r,ar,vo);
				k=m;l=n;
				m=ed[k][l];ed[k][l]=-1-m;
			}
		}
	}
	vo*=0.125;
	ar*=0.25;
	reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r9
movq %rsi, %rbp
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, (%rdx)
movq %r12, (%rsi)
movl 0x1c(%rdi), %ecx
cmpl $0x2, %ecx
jl 0x88b6
addsd %xmm0, %xmm0
movq 0x30(%rbx), %rax
movl $0x1, %esi
movsd %xmm0, 0x10(%rsp)
cmpl $0x0, (%rax,%rsi,4)
jle 0x88a7
leaq (%rax,%rsi,4), %r11
movq 0x28(%rbx), %rcx
xorl %r15d, %r15d
movq (%rcx,%rsi,8), %rdi
movslq (%rdi,%r15,4), %rdx
testq %rdx, %rdx
js 0x8891
movl %edx, %r10d
notl %r10d
movl %r10d, (%rdi,%r15,4)
movslq (%r11), %r11
movslq %r15d, %r10
addq %r11, %r10
movl (%rdi,%r10,4), %r10d
movl (%rax,%rdx,4), %edi
decl %edi
leal 0x1(%r10), %r14d
cmpl %r10d, %edi
cmovel %r12d, %r14d
movq (%rcx,%rdx,8), %r13
movslq %r14d, %r10
movl (%r13,%r10,4), %edi
movl %edi, %r11d
notl %r11d
movl %r11d, (%r13,%r10,4)
cmpq %rdi, %rsi
je 0x8891
movq %r15, 0x8(%rsp)
movl %edi, %r10d
movl %edi, 0x4(%rsp)
movslq %edx, %rdx
movq 0x30(%rbx), %rax
movslq (%rax,%rdx,4), %rcx
movslq %r14d, %rdi
addq %rcx, %rdi
movl (%r13,%rdi,4), %ecx
movslq %r10d, %r13
movl (%rax,%r13,4), %eax
decl %eax
leal 0x1(%rcx), %r14d
cmpl %ecx, %eax
cmovel %r12d, %r14d
movq %rbx, %rdi
movl %r13d, %ecx
movsd 0x10(%rsp), %xmm0
movq %rbp, %r8
movq %rsi, %r15
movq %rbx, %r12
movq %r9, %rbx
callq 0x114c6
movq %rbx, %r9
movq %r12, %rbx
xorl %r12d, %r12d
movq %r15, %rsi
movq 0x28(%rbx), %rcx
movq (%rcx,%r13,8), %r13
movslq %r14d, %rax
movl (%r13,%rax,4), %edi
movl %edi, %edx
notl %edx
movl %edx, (%r13,%rax,4)
movl 0x4(%rsp), %eax
movl %eax, %edx
cmpq %rdi, %r15
jne 0x880b
movq 0x30(%rbx), %rax
movq 0x8(%rsp), %r15
incq %r15
leaq (%rax,%rsi,4), %r11
movslq (%r11), %rdx
cmpq %rdx, %r15
jl 0x87ae
movl 0x1c(%rbx), %ecx
incq %rsi
movslq %ecx, %rdx
cmpq %rdx, %rsi
jl 0x8799
movsd (%r9), %xmm0
mulsd 0x3018d(%rip), %xmm0    # 0x38a50
movsd %xmm0, (%r9)
movsd (%rbp), %xmm0
mulsd 0x30183(%rip), %xmm0    # 0x38a58
movsd %xmm0, (%rbp)
testl %ecx, %ecx
jle 0x8943
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
leaq 0x305c9(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rax,%r15,4)
jle 0x8938
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0x8923
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movl (%rcx,%r12,4), %edx
notl %edx
movl %edx, (%rcx,%r12,4)
incq %r12
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r12
jl 0x88fe
movl 0x1c(%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x88ec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::minkowski_edge(double, double, double, double, double, double, double&, double&)
void voronoicell_base::minkowski_edge(double x0,double r1,double s1,double r2,double s2,double r,double &ar,double &vo) {
	double r12=r2-r1,s12=s2-s1,l12=r12*r12+s12*s12;
	if(l12<tol*tol) return;
	l12=1/sqrt(l12);r12*=l12;s12*=l12;
	double y0=s12*r1-r12*s1;
	if(fabs(y0)<tol) return;
	minkowski_formula(x0,y0,-r12*r1-s12*s1,r,ar,vo);
	minkowski_formula(x0,y0,r12*r2+s12*s2,r,ar,vo);
}

// Assembly:
movapd %xmm3, %xmm6
movapd %xmm3, %xmm9
subsd %xmm1, %xmm9
movapd %xmm4, %xmm10
subsd %xmm2, %xmm10
movapd %xmm10, %xmm7
mulsd %xmm10, %xmm7
movapd %xmm9, %xmm3
mulsd %xmm9, %xmm3
addsd %xmm7, %xmm3
movsd 0x48(%rdi), %xmm8
movapd %xmm8, %xmm7
mulsd %xmm8, %xmm7
ucomisd %xmm3, %xmm7
ja 0x89db
sqrtsd %xmm3, %xmm3
movsd 0x2e664(%rip), %xmm7    # 0x37008
divsd %xmm3, %xmm7
mulsd %xmm7, %xmm9
mulsd %xmm7, %xmm10
movapd %xmm9, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm10, %xmm7
mulsd %xmm1, %xmm7
subsd %xmm3, %xmm7
movapd 0x2ff20(%rip), %xmm3    # 0x388f0
andpd %xmm7, %xmm3
ucomisd %xmm3, %xmm8
jbe 0x89dc
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movapd 0x2e64a(%rip), %xmm3    # 0x37040
xorpd %xmm9, %xmm3
mulsd %xmm10, %xmm2
mulsd %xmm1, %xmm3
subsd %xmm2, %xmm3
movapd %xmm7, %xmm1
movapd %xmm3, %xmm2
movaps %xmm5, %xmm3
movsd %xmm5, 0x28(%rsp)
movsd %xmm6, 0x18(%rsp)
movsd %xmm4, 0x10(%rsp)
movsd %xmm0, 0x20(%rsp)
movapd %xmm9, 0x30(%rsp)
movsd %xmm10, 0x8(%rsp)
movapd %xmm7, 0x40(%rsp)
callq 0x8a88
movsd 0x10(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
mulsd 0x30(%rsp), %xmm2
addsd %xmm0, %xmm2
movq %r15, %rdi
movsd 0x20(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movsd 0x28(%rsp), %xmm3
movq %r14, %rsi
movq %rbx, %rdx
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8a88
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::max_radius_squared()
double voronoicell_base::max_radius_squared() {
	double r,s,*ptsp=pts+4,*ptse=pts+(p<<2);
	r=*pts*(*pts)+pts[1]*pts[1]+pts[2]*pts[2];
	while(ptsp<ptse) {
		s=*ptsp*(*ptsp);ptsp++;
		s+=*ptsp*(*ptsp);ptsp++;
		s+=*ptsp*(*ptsp);ptsp+=2;
		if(s>r) r=s;
	}
	return r;
}

// Assembly:
movq 0x40(%rdi), %rax
movl 0x1c(%rdi), %ecx
shll $0x2, %ecx
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
cmpl $0x5, %ecx
jl 0x9a84
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rcx
addq $0x20, %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm2
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
movsd 0x10(%rax), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
maxsd %xmm1, %xmm0
addq $0x20, %rax
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jb 0x9a50
retq
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::total_edge_distance()
double voronoicell_base::total_edge_distance() {
	int i,j,k;
	double dis=0,dx,dy,dz;
	for(i=0;i<p-1;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>i) {
			dx=pts[k<<2]-pts[i<<2];
			dy=pts[(k<<2)+1]-pts[(i<<2)+1];
			dz=pts[(k<<2)+2]-pts[(i<<2)+2];
			dis+=sqrt(dx*dx+dy*dy+dz*dz);
		}
	}
	return 0.5*dis;
}

// Assembly:
movl 0x1c(%rdi), %eax
xorpd %xmm0, %xmm0
cmpl $0x2, %eax
jl 0x9b7a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
decl %eax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq 0x40(%rdi), %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
movslq (%rdx,%rdi,4), %r8
testq %r8, %r8
jle 0x9b5e
movq (%rcx,%rdi,8), %r9
leal (,%rdi,4), %r10d
movslq %r10d, %r10
leal 0x1(,%rdi,4), %r11d
movslq %r11d, %r11
leal 0x2(,%rdi,4), %ebx
movslq %ebx, %rbx
xorl %r14d, %r14d
movslq (%r9,%r14,4), %r15
cmpq %r15, %rdi
jge 0x9b56
leal (,%r15,4), %ebp
movslq %ebp, %r12
movsd (%rsi,%r12,8), %xmm1
subsd (%rsi,%r10,8), %xmm1
leal 0x1(,%r15,4), %ebp
movslq %ebp, %r12
movsd (%rsi,%r12,8), %xmm2
subsd (%rsi,%r11,8), %xmm2
leal 0x2(,%r15,4), %ebp
movslq %ebp, %r15
movsd (%rsi,%r15,8), %xmm3
subsd (%rsi,%rbx,8), %xmm3
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
xorps %xmm1, %xmm1
sqrtsd %xmm3, %xmm1
addsd %xmm1, %xmm0
incq %r14
cmpq %r14, %r8
jne 0x9aea
incq %rdi
cmpq %rax, %rdi
jne 0x9ab6
mulsd 0x2d4be(%rip), %xmm0    # 0x37030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::draw_pov(double, double, double, _IO_FILE*)
void voronoicell_base::draw_pov(double x,double y,double z,FILE* fp) {
	int i,j,k;double *ptsp=pts,*pt2;
	char posbuf1[128],posbuf2[128];
	for(i=0;i<p;i++,ptsp+=4) {
		sprintf(posbuf1,"%g,%g,%g",x+*ptsp*0.5,y+ptsp[1]*0.5,z+ptsp[2]*0.5);
		fprintf(fp,"sphere{<%s>,r}\n",posbuf1);
		for(j=0;j<nu[i];j++) {
			k=ed[i][j];
			if(k<i) {
				pt2=pts+(k<<2);
				sprintf(posbuf2,"%g,%g,%g",x+*pt2*0.5,y+0.5*pt2[1],z+0.5*pt2[2]);
				if(strcmp(posbuf1,posbuf2)!=0) fprintf(fp,"cylinder{<%s>,<%s>,r}\n",posbuf1,posbuf2);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, (%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
cmpl $0x0, 0x1c(%rdi)
jle 0x9ce4
movq %rdi, %r14
movq 0x40(%rdi), %r13
leaq 0xa0(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r15d, %r15d
movsd (%r13), %xmm0
movsd 0x2d45e(%rip), %xmm3    # 0x37030
mulsd %xmm3, %xmm0
addsd 0x8(%rsp), %xmm0
movsd 0x8(%r13), %xmm1
mulsd %xmm3, %xmm1
addsd 0x10(%rsp), %xmm1
movsd 0x10(%r13), %xmm2
mulsd %xmm3, %xmm2
addsd 0x18(%rsp), %xmm2
movq %r12, %rdi
leaq 0x2f19b(%rip), %rsi     # 0x38da1
movb $0x3, %al
callq 0x2050
movq (%rsp), %rdi
leaq 0x2f192(%rip), %rsi     # 0x38daa
movq %r12, %rdx
xorl %eax, %eax
callq 0x21b0
movq 0x30(%r14), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x9cd0
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax,%rbx,4), %rax
cmpq %rax, %r15
jle 0x9cbc
movq 0x40(%r14), %rcx
shll $0x2, %eax
cltq
movsd (%rcx,%rax,8), %xmm0
movsd 0x2d3d6(%rip), %xmm3    # 0x37030
mulsd %xmm3, %xmm0
addsd 0x8(%rsp), %xmm0
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd %xmm3, %xmm1
addsd 0x10(%rsp), %xmm1
movsd 0x10(%rcx,%rax,8), %xmm2
mulsd %xmm3, %xmm2
addsd 0x18(%rsp), %xmm2
movq %rbp, %rdi
leaq 0x2f113(%rip), %rsi     # 0x38da1
movb $0x3, %al
callq 0x2050
movq %r12, %rdi
movq %rbp, %rsi
callq 0x21a0
testl %eax, %eax
je 0x9cbc
movq (%rsp), %rdi
leaq 0x2f10b(%rip), %rsi     # 0x38dba
movq %r12, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x21b0
incq %rbx
movq 0x30(%r14), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %rbx
jl 0x9c33
incq %r15
addq $0x20, %r13
movslq 0x1c(%r14), %rax
cmpq %rax, %r15
jl 0x9bc4
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::normals(std::vector<double, std::allocator<double>>&)
void voronoicell_base::normals(std::vector<double> &v) {
	int i,j,k;
	v.clear();
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) normals_search(v,i,j,k);
	}
	reset_edges();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0xa2d1
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %eax
cmpl $0x2, %eax
jl 0xa32d
movq 0x30(%rbx), %rcx
movl $0x1, %r15d
cmpl $0x0, (%rcx,%r15,4)
jle 0xa322
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %r8d
testl %r8d, %r8d
js 0xa313
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x1193a
movq 0x30(%rbx), %rcx
incq %r12
movslq (%rcx,%r15,4), %rax
cmpq %rax, %r12
jl 0xa2ed
movl 0x1c(%rbx), %eax
incq %r15
movslq %eax, %rdx
cmpq %rdx, %r15
jl 0xa2e3
testl %eax, %eax
jle 0xa396
movq 0x30(%rbx), %rcx
xorl %r15d, %r15d
leaq 0x2eb76(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rcx,%r15,4)
jle 0xa38b
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
xorl %r12d, %r12d
movl (%rax,%r12,4), %edx
testl %edx, %edx
js 0xa376
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq (%rax,%r15,8), %rax
movl (%rax,%r12,4), %edx
notl %edx
movl %edx, (%rax,%r12,4)
incq %r12
movslq (%rcx,%r15,4), %rdx
cmpq %rdx, %r12
jl 0xa351
movl 0x1c(%rbx), %eax
incq %r15
movslq %eax, %rdx
cmpq %rdx, %r15
jl 0xa33f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::number_of_faces()
int voronoicell_base::number_of_faces() {
	int i,j,k,l,m,s=0;
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			s++;
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				m=ed[k][l];
				ed[k][l]=-1-m;
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);

		}
	}
	reset_edges();
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x1c(%rdi), %edi
xorl %ebp, %ebp
cmpl $0x2, %edi
jl 0xa477
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
xorl %edx, %edx
movl $0x1, %esi
xorl %ebp, %ebp
movl (%rcx,%rsi,4), %r10d
testl %r10d, %r10d
jle 0xa468
movq (%rax,%rsi,8), %rdi
xorl %r8d, %r8d
movslq (%rdi,%r8,4), %r9
testq %r9, %r9
js 0xa456
movl %r9d, %r10d
notl %r10d
movl %r10d, (%rdi,%r8,4)
movslq (%rcx,%rsi,4), %r10
movslq %r8d, %r11
addq %r10, %r11
movl (%rdi,%r11,4), %r11d
movl (%rcx,%r9,4), %r14d
decl %r14d
leal 0x1(%r11), %r10d
cmpl %r11d, %r14d
cmovel %edx, %r10d
movslq %r9d, %r11
movq (%rax,%r11,8), %r14
movslq %r10d, %r10
movl (%r14,%r10,4), %r9d
movl %r9d, %r15d
notl %r15d
movl %r15d, (%r14,%r10,4)
movslq (%rcx,%r11,4), %r11
addq %r10, %r11
movl (%r14,%r11,4), %r11d
movslq %r9d, %r10
movl (%rcx,%r10,4), %r14d
decl %r14d
leal 0x1(%r11), %r10d
cmpl %r11d, %r14d
cmovel %edx, %r10d
cmpq %r9, %rsi
jne 0xa413
incl %ebp
movl (%rcx,%rsi,4), %r10d
incq %r8
movslq %r10d, %r9
cmpq %r9, %r8
jl 0xa3e0
movl 0x1c(%rbx), %edi
incq %rsi
movslq %edi, %r8
cmpq %r8, %rsi
jl 0xa3cc
testl %edi, %edi
jle 0xa4e0
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
leaq 0x2ea2c(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rax,%r15,4)
jle 0xa4d5
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0xa4c0
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movl (%rcx,%r12,4), %edx
notl %edx
movl %edx, (%rcx,%r12,4)
incq %r12
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r12
jl 0xa49b
movl 0x1c(%rbx), %edi
incq %r15
movslq %edi, %rcx
cmpq %rcx, %r15
jl 0xa489
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::vertices(std::vector<double, std::allocator<double>>&)
void voronoicell_base::vertices(std::vector<double> &v) {
	v.resize(3*p);
	double *ptsp=pts;
	for(int i=0;i<3*p;i+=3) {
		v[i]=*(ptsp++)*0.5;
		v[i+1]=*(ptsp++)*0.5;
		v[i+2]=*ptsp*0.5;ptsp+=2;
	}
}

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %r14
movslq 0x1c(%rdi), %rax
leaq (%rax,%rax,2), %rsi
movq %rbx, %rdi
callq 0x11df0
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movl 0x1c(%r14), %eax
testl %eax, %eax
jle 0xa77e
leaq (%rax,%rax,2), %rax
movq 0x40(%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd 0x2c8f6(%rip), %xmm0    # 0x37030
movsd (%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm4, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
movsd 0x8(%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rdx,%rsi,8)
movsd 0x10(%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rdx,%rsi,8)
addq $0x20, %rcx
addq $0x3, %rsi
cmpq %rax, %rsi
jb 0xa73a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::face_orders(std::vector<int, std::allocator<int>>&)
void voronoicell_base::face_orders(std::vector<int> &v) {
	int i,j,k,l,m,q;
	v.clear();
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			q=1;
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				q++;
				m=ed[k][l];
				ed[k][l]=-1-m;
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);
			v.push_back(q);;
		}
	}
	reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0xaddc
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %ecx
cmpl $0x2, %ecx
jl 0xaede
movq 0x30(%rbx), %rax
movl $0x1, %r12d
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
cmpl $0x0, (%rax,%r12,4)
jle 0xaecf
leaq (%rax,%r12,4), %rsi
xorl %ebp, %ebp
movq 0x28(%rbx), %rcx
movq (%rcx,%r12,8), %rdi
movslq (%rdi,%rbp,4), %rdx
testq %rdx, %rdx
js 0xaeb9
movl $0x1, 0x4(%rsp)
movl %edx, %r8d
notl %r8d
movl %r8d, (%rdi,%rbp,4)
movslq (%rsi), %rsi
movslq %ebp, %r8
addq %rsi, %r8
movl (%rdi,%r8,4), %edi
movl (%rax,%rdx,4), %r8d
decl %r8d
leal 0x1(%rdi), %esi
cmpl %edi, %r8d
cmovel %r13d, %esi
incl 0x4(%rsp)
movslq %edx, %rdi
movq (%rcx,%rdi,8), %r8
movslq %esi, %rsi
movl (%r8,%rsi,4), %edx
movl %edx, %r9d
notl %r9d
movl %r9d, (%r8,%rsi,4)
movslq (%rax,%rdi,4), %rdi
addq %rsi, %rdi
movl (%r8,%rdi,4), %edi
movslq %edx, %rsi
movl (%rax,%rsi,4), %r8d
decl %r8d
leal 0x1(%rdi), %esi
cmpl %edi, %r8d
cmovel %r13d, %esi
cmpq %rdx, %r12
jne 0xae50
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xaeaa
movl 0x4(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xaeb9
movq %r14, %rdi
movq %r15, %rdx
callq 0x12354
movq 0x30(%rbx), %rax
incq %rbp
leaq (%rax,%r12,4), %rsi
movslq (%rsi), %rcx
cmpq %rcx, %rbp
jl 0xae0b
movl 0x1c(%rbx), %ecx
incq %r12
movslq %ecx, %rdx
cmpq %rdx, %r12
jl 0xadfa
testl %ecx, %ecx
jle 0xaf47
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
leaq 0x2dfc5(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rax,%r15,4)
jle 0xaf3c
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0xaf27
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movl (%rcx,%r12,4), %edx
notl %edx
movl %edx, (%rcx,%r12,4)
incq %r12
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r12
jl 0xaf02
movl 0x1c(%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0xaef0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::face_freq_table(std::vector<int, std::allocator<int>>&)
void voronoicell_base::face_freq_table(std::vector<int> &v) {
	int i,j,k,l,m,q;
	v.clear();
	for(i=1;i<p;i++) for(j=0;j<nu[i];j++) {
		k=ed[i][j];
		if(k>=0) {
			q=1;
			ed[i][j]=-1-k;
			l=cycle_up(ed[i][nu[i]+j],k);
			do {
				q++;
				m=ed[k][l];
				ed[k][l]=-1-m;
				l=cycle_up(ed[k][nu[k]+l],m);
				k=m;
			} while (k!=i);
			if((unsigned int) q>=v.size()) v.resize(q+1,0);
			v[q]++;
		}
	}
	reset_edges();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0xaf74
movq %rax, 0x8(%r14)
movl 0x1c(%rbx), %edx
cmpl $0x2, %edx
jl 0xb07b
movq 0x30(%rbx), %rcx
movl $0x1, %r12d
xorl %r13d, %r13d
cmpl $0x0, (%rcx,%r12,4)
jle 0xb06c
leaq (%rcx,%r12,4), %rdi
xorl %ebp, %ebp
movq 0x28(%rbx), %rdx
movq (%rdx,%r12,8), %r8
movslq (%r8,%rbp,4), %rsi
testq %rsi, %rsi
js 0xb056
movl %esi, %r9d
notl %r9d
movl %r9d, (%r8,%rbp,4)
movslq (%rdi), %rdi
movslq %ebp, %r9
addq %rdi, %r9
movl (%r8,%r9,4), %r8d
movl (%rcx,%rsi,4), %r9d
decl %r9d
leal 0x1(%r8), %edi
cmpl %r8d, %r9d
cmovel %r13d, %edi
movl $0x1, %r15d
movslq %esi, %r8
movq (%rdx,%r8,8), %r9
movslq %edi, %rdi
movl (%r9,%rdi,4), %esi
movl %esi, %r10d
notl %r10d
movl %r10d, (%r9,%rdi,4)
movslq (%rcx,%r8,4), %r8
addq %rdi, %r8
movl (%r9,%r8,4), %r8d
movslq %esi, %rdi
movl (%rcx,%rdi,4), %r9d
decl %r9d
leal 0x1(%r8), %edi
cmpl %r8d, %r9d
cmovel %r13d, %edi
incq %r15
cmpq %rsi, %r12
jne 0xafe2
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
ja 0xb052
leaq 0x1(%r15), %rsi
movl $0x0, 0x4(%rsp)
movq %r14, %rdi
leaq 0x4(%rsp), %rdx
callq 0x11e22
movq (%r14), %rax
movq 0x30(%rbx), %rcx
incl (%rax,%r15,4)
incq %rbp
leaq (%rcx,%r12,4), %rdi
movslq (%rdi), %rdx
cmpq %rdx, %rbp
jl 0xaf9e
movl 0x1c(%rbx), %edx
incq %r12
movslq %edx, %rsi
cmpq %rsi, %r12
jl 0xaf8d
testl %edx, %edx
jle 0xb0e4
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
leaq 0x2de28(%rip), %r14     # 0x38eb5
cmpl $0x0, (%rax,%r15,4)
jle 0xb0d9
movq 0x28(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
testl %edx, %edx
js 0xb0c4
movq %r14, %rdi
movl $0x3, %esi
callq 0x133c5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movl (%rcx,%r12,4), %edx
notl %edx
movl %edx, (%rcx,%r12,4)
incq %r12
movslq (%rax,%r15,4), %rdx
cmpq %rdx, %r12
jl 0xb09f
movl 0x1c(%rbx), %edx
incq %r15
movslq %edx, %rcx
cmpq %rcx, %r15
jl 0xb08d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop