LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::ham_path_bt(int, int, bool, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
std::vector< std::vector<int> >& Graph::ham_path_bt(int source,
                                                     int last,
                                                     bool count,
                                                     const std::vector< std::pair<int,int> >& map,
                                                     const std::vector< std::pair<int,int> >& diamonds)
{
    paths.clear();
    visited.assign(n_vertices, false);
    path.resize(n_vertices);

    backtracking(source, 0, last, count);
    
    std::vector< std::vector<int> > valid_paths;
    for(auto candidate : paths)
        if(valid(candidate, map, diamonds)) valid_paths.push_back(candidate);
    
    paths = valid_paths;

    return paths;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %r8, %r15
movl %ecx, -0x2c(%rbp)
movl %edx, %r13d
movl %esi, %r12d
movq %rdi, %rbx
addq $0x78, %rdi
movq %rdi, -0x58(%rbp)
callq 0x769a
leaq 0x50(%rbx), %rdi
movslq (%rbx), %rsi
xorl %edx, %edx
callq 0x8598
leaq 0x90(%rbx), %rdi
movslq (%rbx), %rsi
callq 0x77b4
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
movl %r13d, %ecx
movl -0x2c(%rbp), %r8d
callq 0x35dc
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x78(%rbx), %r12
movq 0x80(%rbx), %rbx
cmpq %rbx, %r12
je 0x64ea
leaq -0x70(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3364
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x378c
testb %al, %al
je 0x64d3
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x74f4
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x64e1
callq 0x21d0
addq $0x18, %r12
cmpq %rbx, %r12
jne 0x64aa
leaq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x7530
leaq -0x50(%rbp), %rdi
callq 0x3136
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x652a
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x652d
callq 0x21d0
jmp 0x652d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3136
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::k_paths(int, int, int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&)
std::vector<int>&
Graph::k_paths(int k,
               int source,
               int last,
               const std::vector< std::pair<int, int> >& map,
               const std::vector< std::pair<int, int> >& diamonds)
{
    paths = ham_path_sat(source, last, false, map, diamonds);
    if(paths.size() > k){
        path.clear();
        return path;
    }

    return paths[0]; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x519a
leaq 0x78(%rbx), %rdi
movq %rax, %rsi
callq 0x7530
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
movslq %r14d, %rcx
cmpq %rcx, %rdx
jbe 0x67ea
leaq 0x90(%rbx), %rax
movq 0x90(%rbx), %rcx
cmpq %rcx, 0x98(%rbx)
je 0x67ea
movq %rcx, 0x98(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/graph.cpp
// Function: Graph::write_min_cons(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, int, std::basic_ofstream<char, std::char_traits<char>>&)
void Graph::write_min_cons(std::vector<int>& orig_path, std::vector<int>& cons, int num, std::ofstream &ofile){
    for(int v : orig_path){
        ofile << v << "\n";
    }
    
    ofile << "-1\n";

    for(int i = 0; i <= num; i++){
        int con = cons[i];

        if(con < 0){
            con = -con;
            ofile << orig_path[con] << " " << con + 1 << "\n";
        }
    }

    ofile << "-1\n";

    for(int i = 0; i <= num; i++){
        int con = cons[i];

        if(con >= 0){
            int u = orig_path[con];
            int v = orig_path[con+1];
            ofile << u << " " << v << "\n";
        }
    }

    ofile << "-1\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r15d
movq %rdx, -0x40(%rbp)
movq (%rsi), %r14
movq %rsi, -0x38(%rbp)
movq 0x8(%rsi), %r12
cmpq %r12, %r14
je 0x6b3e
leaq 0x264b(%rip), %r13      # 0x9165
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2370
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2250
addq $0x4, %r14
cmpq %r12, %r14
jne 0x6b1a
leaq 0x2696(%rip), %rsi      # 0x91db
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2250
movq %r15, -0x30(%rbp)
testl %r15d, %r15d
js 0x6bd0
movq -0x30(%rbp), %rax
leal 0x1(%rax), %r12d
xorl %r14d, %r14d
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r14,4), %r15d
testl %r15d, %r15d
jns 0x6bc8
movl %r15d, %eax
negl %eax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x2370
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2628(%rip), %rsi      # 0x91c7
callq 0x2250
movl $0x1, %esi
subl %r15d, %esi
movq %r13, %rdi
callq 0x2370
movl $0x1, %edx
movq %rax, %rdi
leaq 0x25a2(%rip), %rsi      # 0x9165
callq 0x2250
incq %r14
cmpq %r14, %r12
jne 0x6b66
leaq 0x2604(%rip), %rsi      # 0x91db
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2250
movq -0x30(%rbp), %r15
testl %r15d, %r15d
js 0x6c58
incl %r15d
xorl %r14d, %r14d
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r14,4), %rax
testq %rax, %rax
js 0x6c50
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,4), %esi
movl 0x4(%rcx,%rax,4), %r13d
movq %rbx, %rdi
callq 0x2370
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x259b(%rip), %rsi      # 0x91c7
callq 0x2250
movq %r12, %rdi
movl %r13d, %esi
callq 0x2370
movl $0x1, %edx
movq %rax, %rdi
leaq 0x251a(%rip), %rsi      # 0x9165
callq 0x2250
incq %r14
cmpq %r14, %r15
jne 0x6bf3
leaq 0x257c(%rip), %rsi      # 0x91db
movl $0x3, %edx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, -0x13a8(%rbp)
cmpl $0x2, %edx
jl 0x6cf0
leal -0x1(%r14), %r12d
xorl %eax, %eax
leaq -0x13a8(%rbp), %r15
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6cd2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6cdd
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7dec
movl -0x13a8(%rbp), %eax
incl %eax
movl %eax, -0x13a8(%rbp)
cmpl %r12d, %eax
jl 0x6cbc
cmpl $0x3, %r14d
jl 0x6d3f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq -0x13a8(%rbp), %r15
movl %r12d, -0x13a8(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6d21
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6d2c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3402
leal (%r14,%r12), %eax
decl %eax
movl %r12d, %ecx
decl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x6d03
leaq -0x13a8(%rbp), %rdi
callq 0x77ec
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 0x6d65
leaq -0x2730(%rbp), %rdx
movq $0x270, 0x1380(%rdx) # imm = 0x270
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x785b
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 0x6ddc
jmp 0x6de6
movq %rax, %r14
leaq -0x13a8(%rbp), %rdi
callq 0x21c0
jmp 0x6de9
movq %rax, %rdi
callq 0x3212
jmp 0x6de6
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6df6
callq 0x21d0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
addl %eax, %eax
movl %eax, 0x18(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x2370
leaq 0x368b3(%rip), %rdi     # 0x38c1b
pushq $0x2
popq %rsi
callq 0x1318d
movq 0x43c69(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
movl 0x18(%rbx), %edx
leaq 0x368d6(%rip), %rsi     # 0x38c5a
xorl %eax, %eax
callq 0x21b0
movslq 0x18(%rbx), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rax
movq %r14, %r15
cmpq %rax, %rdi
jae 0x23d7
movq %rdi, %rcx
movq %r14, %r15
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r15)
addq $0x4, %r15
cmpq %rax, %rcx
jb 0x23c5
testq %rdi, %rdi
je 0x23e1
callq 0x2180
movq %r14, 0xa8(%rbx)
movq %r15, 0xb0(%rbx)
movslq 0x18(%rbx), %rax
leaq (%r14,%rax,4), %rax
movq %rax, 0xb8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
addl %eax, %eax
movl %eax, 0x10(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x242a
leaq 0x36735(%rip), %rdi     # 0x38b57
pushq $0x2
popq %rsi
callq 0x1318d
movq 0x43baf(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
movl 0x10(%rbx), %edx
leaq 0x36754(%rip), %rsi     # 0x38b92
xorl %eax, %eax
callq 0x21b0
movslq 0x10(%rbx), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq 0x78(%rbx), %rdi
movq 0x80(%rbx), %rax
movq %r14, %r15
cmpq %rax, %rdi
jae 0x248e
movq %rdi, %rcx
movq %r14, %r15
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r15)
addq $0x4, %r15
cmpq %rax, %rcx
jb 0x247c
testq %rdi, %rdi
je 0x2498
callq 0x2180
movq %r14, 0x78(%rbx)
movq %r15, 0x80(%rbx)
movslq 0x10(%rbx), %rax
leaq (%r14,%rax,4), %rax
movq %rax, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl 0x14(%rdi), %eax
addl %eax, %eax
movl %eax, 0x14(%rdi)
cmpl $0x1000001, %eax        # imm = 0x1000001
jl 0x24de
leaq 0x366e3(%rip), %rdi     # 0x38bb9
pushq $0x2
popq %rsi
callq 0x1318d
movq 0x43afb(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
movl 0x14(%rbx), %edx
leaq 0x36702(%rip), %rsi     # 0x38bf4
xorl %eax, %eax
callq 0x21b0
movslq 0x14(%rbx), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rax
movq %r14, %r15
cmpq %rax, %rdi
jae 0x2545
movq %rdi, %rcx
movq %r14, %r15
movl (%rcx), %edx
addq $0x4, %rcx
movl %edx, (%r15)
addq $0x4, %r15
cmpq %rax, %rcx
jb 0x2533
testq %rdi, %rdi
je 0x254f
callq 0x2180
movq %r14, 0x90(%rbx)
movq %r15, 0x98(%rbx)
movslq 0x14(%rbx), %rax
leaq (%r14,%rax,4), %rax
movq %rax, 0xa0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %rbx
movl 0xc(%rdi), %ebp
addl %ebp, %ebp
cmpl $0x801, %ebp            # imm = 0x801
jl 0x2926
leaq 0x365f2(%rip), %rdi     # 0x38f10
pushq $0x2
popq %rsi
callq 0x1318d
movq 0x436b3(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
leaq 0x36612(%rip), %rsi     # 0x38f49
xorl %r14d, %r14d
movl %ebp, %edx
xorl %eax, %eax
callq 0x21b0
movslq %ebp, %r15
leaq (,%r15,4), %r12
testl %ebp, %ebp
pushq $-0x1
popq %rax
cmovsq %rax, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
movslq 0xc(%rbx), %rax
testq %rax, %rax
jle 0x2983
movq 0x60(%rbx), %rcx
xorl %r14d, %r14d
movl (%rcx,%r14,4), %edx
movl %edx, (%r13,%r14,4)
incq %r14
cmpq %r14, %rax
jne 0x2972
cmpl %ebp, %r14d
jge 0x29ab
movl %r14d, %eax
leaq (,%rax,4), %rdi
addq %r13, %rdi
notl %r14d
addl %ebp, %r14d
leaq 0x4(,%r14,4), %rdx
xorl %esi, %esi
callq 0x20c0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x29b9
callq 0x2180
shlq $0x3, %r15
testl %ebp, %ebp
movq %r13, 0x60(%rbx)
pushq $-0x1
popq %rax
cmovsq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r13
movslq 0xc(%rbx), %rax
testq %rax, %rax
movq (%rsp), %r14
jle 0x29f9
movq 0x70(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%r13,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x29e8
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x2a07
callq 0x2180
movq %r13, 0x70(%rbx)
movq %r12, %rdi
callq 0x2030
movq %rax, %r12
movslq 0xc(%rbx), %rcx
testq %rcx, %rcx
jle 0x2a36
movq 0x68(%rbx), %rdx
xorl %eax, %eax
movl (%rdx,%rax,4), %esi
movl %esi, (%r12,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x2a25
jmp 0x2a38
xorl %eax, %eax
cmpl %ebp, %eax
jge 0x2a55
movl %eax, %ecx
leaq (%r12,%rcx,4), %rdi
notl %eax
addl %ebp, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x20c0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x2a63
callq 0x2180
movq %r12, 0x68(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
movslq 0xc(%r14), %rax
testq %rax, %rax
jle 0x2a94
movq 0xe8(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x2a84
movq 0xe8(%r14), %rdi
testq %rdi, %rdi
je 0x2aa5
callq 0x2180
movq %r15, 0xe8(%r14)
movl %ebp, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/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 0x432d0(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
leaq 0x3668f(%rip), %rsi     # 0x393a9
movl %r13d, %edx
xorl %eax, %eax
callq 0x21b0
movq (%r15), %rax
cmpq (%rbx), %rax
jbe 0x2d85
movq (%r15), %rax
movq %r12, %r13
cmpq 0x98(%r14), %rax
jae 0x2d5b
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 0x2d3e
movq 0x90(%r14), %rax
movq %rax, (%r15)
cmpq (%rbx), %rax
jae 0x2dac
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movl (%rax), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %rcx, %rax
cmpq (%rbx), %rcx
jb 0x2d6a
jmp 0x2dac
movq (%r15), %rax
movq %r12, %r13
cmpq (%rbx), %rax
jae 0x2dac
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 0x2d93
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0x2dbd
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
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
addl %eax, %eax
movl %eax, 0x38(%rdi)
cmpl $0x10001, %eax          # imm = 0x10001
jl 0x315e
leaq 0x3a3d2(%rip), %rdi     # 0x3d528
pushq $0x2
popq %rsi
callq 0x1318d
movq 0x42e7b(%rip), %rax     # 0x45fe0
movq (%rax), %rdi
movl 0x38(%rbx), %edx
leaq 0x3a3e3(%rip), %rsi     # 0x3d555
xorl %eax, %eax
callq 0x21b0
movslq 0x38(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %r14
cmovnsq %rcx, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq 0x40(%rbx), %r12
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0x48(%rbx), %rax
movq %r15, %rbp
movq %r14, %r13
cmpq %rax, %r12
jae 0x31e9
movq 0x68(%rbx), %rcx
movq %r14, %r13
movq %r15, %rbp
movq %r12, %rdx
movq (%rdx), %rsi
addq $0x8, %rdx
movq %rsi, (%rbp)
addq $0x8, %rbp
movq (%rcx), %rsi
addq $0x8, %rcx
movq %rsi, (%r13)
addq $0x8, %r13
cmpq %rax, %rdx
jb 0x31c6
testq %r12, %r12
je 0x31f6
movq %r12, %rdi
callq 0x2180
movq %r15, 0x40(%rbx)
movq %rbp, 0x48(%rbx)
movslq 0x38(%rbx), %rax
leaq (%r15,%rax,8), %rax
movq %rax, 0x50(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x3218
callq 0x2180
movq %r14, 0x68(%rbx)
movq %r13, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::~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 0x3ed40(%rip), %rax     # 0x45c18
movq %rax, (%rdi)
movslq 0xc(%rdi), %r14
testq %r14, %r14
jle 0x6f0f
incq %r14
movq 0x60(%rbx), %rax
cmpl $0x0, -0x8(%rax,%r14,4)
jle 0x6f06
movq 0x70(%rbx), %rax
movq -0x10(%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6f06
callq 0x2180
decq %r14
cmpq $0x1, %r14
jg 0x6ee7
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x6f20
callq 0x2180
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x6f31
callq 0x2180
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x6f3f
callq 0x2180
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x6f4d
callq 0x2180
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x6f5b
callq 0x2180
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x6f69
callq 0x2180
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x6f77
callq 0x2180
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6f85
callq 0x2180
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x6f93
callq 0x2180
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x6fa8
popq %rbx
popq %r14
jmp 0x2180
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl 0x1c(%rsi), %eax
movl %eax, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
cmpl $0x0, 0xc(%rdi)
jle 0x708f
movl $0x1, %eax
movl $0x4, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
movq 0x68(%rsi), %r9
movl (%r9,%r8,4), %r11d
movq 0x68(%rdi), %r10
movl %r11d, (%r10,%r8,4)
leaq 0x1(,%r8,2), %r9
movl %r9d, %ebx
imull %r11d, %ebx
testl %ebx, %ebx
jle 0x702b
movq 0x70(%rsi), %r11
movq (%r11,%r8,8), %r11
movq 0x70(%rdi), %rbx
movq (%rbx,%r8,8), %rbx
movslq %r9d, %r14
xorl %r15d, %r15d
movl (%r11,%r15,4), %ebp
movl %ebp, (%rbx,%r15,4)
incq %r15
movslq (%r10,%r8,4), %r12
imulq %r14, %r12
cmpq %r12, %r15
jl 0x7013
movq 0x68(%rdi), %r10
movl (%r10,%r8,4), %r10d
imull %r9d, %r10d
testl %r10d, %r10d
jle 0x7073
movslq %r9d, %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
movq 0x28(%rdi), %rbx
movq 0x70(%rdi), %r14
movq (%r14,%r8,8), %r14
addq %r10, %r14
movslq (%rdx,%r14), %r15
movq %r14, (%rbx,%r15,8)
addq %rax, %r11
movq 0x68(%rdi), %rbx
movslq (%rbx,%r8,4), %rbx
imulq %r9, %rbx
addq %rcx, %r10
cmpq %rbx, %r11
jl 0x7045
incq %r8
movslq 0xc(%rdi), %r9
addq $0x2, %rax
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %r9, %r8
jl 0x6fda
movl 0x1c(%rdi), %eax
testl %eax, %eax
jle 0x70b5
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 0x70a1
shll $0x2, %eax
testl %eax, %eax
jle 0x70da
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 0x70c8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_neighbor::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 0x110f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6fac
cmpl $0x0, 0xc(%rbx)
jle 0x71bd
movl $0x4, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq 0x68(%rbx), %rdi
movl (%rdi,%rsi,4), %r8d
imull %esi, %r8d
testl %r8d, %r8d
jle 0x7154
movq 0xe8(%r14), %r8
movq (%r8,%rsi,8), %r8
movslq %esi, %r9
xorl %r10d, %r10d
movl $0x0, (%r8,%r10,4)
incq %r10
movslq (%rdi,%rsi,4), %r11
imulq %r9, %r11
cmpq %r11, %r10
jl 0x713c
movq 0x68(%rbx), %rdi
cmpl $0x0, (%rdi,%rsi,4)
jle 0x71a1
xorl %edi, %edi
movq %rdx, %r8
xorl %r9d, %r9d
movq 0xe8(%r14), %r10
movq 0xf0(%r14), %r11
movq (%r10,%rsi,8), %r10
addq %rdi, %r10
movq 0x70(%rbx), %r15
movq (%r15,%rsi,8), %r15
movslq (%r15,%r8), %r15
movq %r10, (%r11,%r15,8)
incq %r9
movq 0x68(%rbx), %r10
movslq (%r10,%rsi,4), %r10
addq %rax, %r8
addq %rcx, %rdi
cmpq %r10, %r9
jl 0x7166
incq %rsi
movslq 0xc(%rbx), %rdi
addq $0x8, %rdx
addq $0x8, %rax
addq $0x4, %rcx
cmpq %rdi, %rsi
jl 0x711a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x110f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6fac
cmpl $0x0, 0xc(%rbx)
jle 0x72aa
movl $0x4, %eax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movq 0x68(%rbx), %rdi
movl (%rdi,%rsi,4), %r8d
imull %esi, %r8d
testl %r8d, %r8d
jle 0x7241
movq 0xe8(%rbx), %r8
movq (%r8,%rsi,8), %r8
movq 0xe8(%r14), %r9
movq (%r9,%rsi,8), %r9
movslq %esi, %r10
xorl %r11d, %r11d
movl (%r8,%r11,4), %ebp
movl %ebp, (%r9,%r11,4)
incq %r11
movslq (%rdi,%rsi,4), %r15
imulq %r10, %r15
cmpq %r15, %r11
jl 0x7229
movq 0x68(%rbx), %rdi
cmpl $0x0, (%rdi,%rsi,4)
jle 0x728e
xorl %edi, %edi
movq %rdx, %r8
xorl %r9d, %r9d
movq 0xe8(%r14), %r10
movq 0xf0(%r14), %r11
movq (%r10,%rsi,8), %r10
addq %rdi, %r10
movq 0x70(%rbx), %r15
movq (%r15,%rsi,8), %r15
movslq (%r15,%r8), %r15
movq %r10, (%r11,%r15,8)
incq %r9
movq 0x68(%rbx), %r10
movslq (%r10,%rsi,4), %r10
addq %rax, %r8
addq %rcx, %rdi
cmpq %r10, %r9
jl 0x7253
incq %rsi
movslq 0xc(%rbx), %rdi
addq $0x8, %rdx
addq $0x8, %rax
addq $0x4, %rcx
cmpq %rdi, %rsi
jl 0x71fc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::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 0x7308
addsd %xmm0, %xmm0
addsd %xmm1, %xmm1
addsd %xmm2, %xmm2
movq 0x40(%rdi), %rax
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rcx
movsd (%rax), %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, (%rax)
movsd 0x8(%rax), %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rax)
movsd 0x10(%rax), %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rax)
addq $0x20, %rax
cmpq %rcx, %rax
jb 0x72d7
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x1c(%rdi)
jle 0x78a2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x314d8(%rip), %r14     # 0x38cd8
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x7884
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rcx
movslq (%rcx,%r12,4), %rbp
movq (%rax,%rbp,8), %rcx
movl (%rcx), %ecx
xorl %r13d, %r13d
cmpq %rcx, %r15
je 0x785e
movl $0x1, %r13d
movq 0x30(%rbx), %rax
movl (%rax,%rbp,4), %eax
cmpq %rax, %r13
jne 0x7847
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%rbp,8), %rcx
movl (%rcx,%r13,4), %ecx
incq %r13
cmpq %rcx, %r15
jne 0x782e
decl %r13d
movq (%rax,%r15,8), %rax
movq 0x30(%rbx), %rcx
movslq (%rcx,%r15,4), %rcx
movslq %r12d, %rdx
addq %rcx, %rdx
movl %r13d, (%rax,%rdx,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0x780e
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0x7800
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::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)
jle 0x78c3
movq 0x68(%rdi), %rax
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
incq %rcx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x78b0
movq $0x6, 0x1c(%rdi)
movq 0x68(%rdi), %rax
movl $0x6, 0x10(%rax)
addsd %xmm0, %xmm0
movapd 0x2f74e(%rip), %xmm1    # 0x37030
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 0x30e69(%rip), %xmm0    # 0x387b0
movups %xmm0, (%rax)
leaq 0x24(%rax), %rcx
movups %xmm2, 0x10(%rax)
movl $0x0, 0x20(%rax)
movaps 0x30e60(%rip), %xmm0    # 0x387c0
movups %xmm0, 0x24(%rax)
movaps 0x30e65(%rip), %xmm0    # 0x387d0
movups %xmm0, 0x34(%rax)
movaps 0x30e6a(%rip), %xmm0    # 0x387e0
movups %xmm0, 0x44(%rax)
leaq 0x48(%rax), %rdx
movaps 0x30e6b(%rip), %xmm0    # 0x387f0
movups %xmm0, 0x54(%rax)
movaps 0x30e70(%rip), %xmm0    # 0x38800
movups %xmm0, 0x64(%rax)
leaq 0x6c(%rax), %rsi
movaps 0x30e71(%rip), %xmm0    # 0x38810
movups %xmm0, 0x74(%rax)
movaps 0x30e76(%rip), %xmm0    # 0x38820
movups %xmm0, 0x84(%rax)
leaq 0x90(%rax), %r8
movaps 0x30e71(%rip), %xmm0    # 0x38830
movups %xmm0, 0x94(%rax)
movaps 0x30e73(%rip), %xmm0    # 0x38840
movups %xmm0, 0xa4(%rax)
leaq 0xb4(%rax), %r9
movaps 0x30e6e(%rip), %xmm0    # 0x38850
movups %xmm0, 0xb4(%rax)
movaps 0x30e70(%rip), %xmm0    # 0x38860
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)
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm9
movsd 0x10(%rsp), %xmm10
movsd 0x8(%rsp), %xmm11
cmpl $0x0, 0xc(%rdi)
jle 0x7a85
movq 0x68(%rdi), %rax
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
incq %rcx
movslq 0xc(%rdi), %rdx
cmpq %rdx, %rcx
jl 0x7a72
movq $0x4, 0x1c(%rdi)
movq 0x68(%rdi), %rax
movl $0x4, 0xc(%rax)
addsd %xmm0, %xmm0
movq 0x40(%rdi), %rax
movsd %xmm0, (%rax)
addsd %xmm1, %xmm1
movsd %xmm1, 0x8(%rax)
addsd %xmm2, %xmm2
movsd %xmm2, 0x10(%rax)
addsd %xmm3, %xmm3
movsd %xmm3, 0x20(%rax)
addsd %xmm4, %xmm4
movsd %xmm4, 0x28(%rax)
addsd %xmm5, %xmm5
movsd %xmm5, 0x30(%rax)
addsd %xmm6, %xmm6
movsd %xmm6, 0x40(%rax)
addsd %xmm7, %xmm7
movsd %xmm7, 0x48(%rax)
addsd %xmm11, %xmm11
movsd %xmm11, 0x50(%rax)
addsd %xmm10, %xmm10
movsd %xmm10, 0x60(%rax)
addsd %xmm9, %xmm9
movsd %xmm9, 0x68(%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 0x30d2a(%rip), %xmm0    # 0x38870
movups %xmm0, 0x20(%rax)
movaps 0x30d2f(%rip), %xmm0    # 0x38880
movups %xmm0, 0x30(%rax)
leaq 0x38(%rax), %rdx
movaps 0x30d30(%rip), %xmm0    # 0x38890
movups %xmm0, 0x40(%rax)
movaps 0x30d35(%rip), %xmm0    # 0x388a0
movups %xmm0, 0x50(%rax)
leaq 0x54(%rax), %rsi
movaps 0x30d36(%rip), %xmm0    # 0x388b0
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
movabsq $0x300000003, %rcx      # imm = 0x300000003
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rsi, %r8
movq %rdi, %rbx
xorl %r11d, %r11d
movq %r11, (%rdx)
movq %r11, (%rsi)
movl 0x1c(%rdi), %eax
cmpl $0x2, %eax
jl 0x8958
addsd %xmm0, %xmm0
movl $0x1, %esi
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rbx), %rcx
cmpl $0x0, (%rcx,%rsi,4)
jle 0x8948
leaq (%rcx,%rsi,4), %rdx
xorl %r10d, %r10d
movq 0x28(%rbx), %r15
movq (%r15,%rsi,8), %rdi
movq %r10, 0x8(%rsp)
movslq (%rdi,%r10,4), %rax
testq %rax, %rax
js 0x892c
movl %eax, %r10d
notl %r10d
movq 0x8(%rsp), %r14
movl %r10d, (%rdi,%r14,4)
movslq (%rdx), %rdx
movslq %r14d, %r10
addq %rdx, %r10
movl (%rdi,%r10,4), %edx
movl (%rcx,%rax,4), %ecx
decl %ecx
leal 0x1(%rdx), %r14d
cmpl %edx, %ecx
cmovel %r11d, %r14d
movq (%r15,%rax,8), %rdx
movslq %r14d, %r10
movl (%rdx,%r10,4), %ecx
movl %ecx, %edi
notl %edi
movl %edi, (%rdx,%r10,4)
cmpq %rcx, %rsi
je 0x892c
movl %ecx, %ebp
movl %ecx, 0x4(%rsp)
movslq %eax, %rdx
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq (%rax,%rdx,8), %rax
movslq (%rcx,%rdx,4), %r10
movslq %r14d, %rdi
addq %r10, %rdi
movl (%rax,%rdi,4), %eax
movslq %ebp, %r13
movl (%rcx,%r13,4), %ecx
decl %ecx
leal 0x1(%rax), %r14d
cmpl %eax, %ecx
cmovel %r11d, %r14d
movq %rbx, %rdi
movl %r13d, %ecx
movsd 0x10(%rsp), %xmm0
movq %r8, %rbp
movq %r12, %r9
movq %rbx, %r15
movq %rsi, %rbx
callq 0x11542
xorl %r11d, %r11d
movq %rbx, %rsi
movq %r15, %rbx
movq %rbp, %r8
movq 0x28(%r15), %rax
movq (%rax,%r13,8), %rax
movslq %r14d, %rdx
movl (%rax,%rdx,4), %ecx
movl %ecx, %edi
notl %edi
movl %edi, (%rax,%rdx,4)
movl 0x4(%rsp), %eax
jmp 0x88ae
movq 0x8(%rsp), %r10
incq %r10
movq 0x30(%rbx), %rcx
leaq (%rcx,%rsi,4), %rdx
movslq (%rdx), %rax
cmpq %rax, %r10
jl 0x8856
incq %rsi
movslq 0x1c(%rbx), %rax
cmpq %rax, %rsi
jl 0x8841
movsd (%r12), %xmm0
mulsd 0x3007a(%rip), %xmm0    # 0x389e0
movsd %xmm0, (%r12)
movsd (%r8), %xmm0
mulsd 0x3006f(%rip), %xmm0    # 0x389e8
movsd %xmm0, (%r8)
testl %eax, %eax
jle 0x89de
xorl %r15d, %r15d
leaq 0x304b9(%rip), %r14     # 0x38e45
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x89d2
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x0, (%rax,%r12,4)
js 0x89b6
movq %r14, %rdi
movl $0x3, %esi
callq 0x1318d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rax
notl (%rax,%r12,4)
incq %r12
movq 0x30(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jl 0x899a
incq %r15
movslq 0x1c(%rbx), %rax
cmpq %rax, %r15
jl 0x898c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movapd %xmm2, %xmm9
movaps %xmm0, %xmm6
movapd %xmm3, %xmm7
subsd %xmm1, %xmm7
movapd %xmm4, %xmm8
subsd %xmm2, %xmm8
movapd %xmm8, %xmm2
mulsd %xmm8, %xmm2
movapd %xmm7, %xmm0
mulsd %xmm7, %xmm0
addsd %xmm2, %xmm0
movsd 0x48(%rdi), %xmm2
mulsd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
ja 0x8af6
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movsd %xmm5, 0x18(%rsp)
movsd %xmm3, 0x58(%rsp)
movsd %xmm4, 0x50(%rsp)
movsd %xmm6, 0x10(%rsp)
jb 0x8a6b
sqrtsd %xmm0, %xmm0
jmp 0x8ab0
movapd %xmm7, 0x30(%rsp)
movsd %xmm8, 0x8(%rsp)
movsd %xmm9, 0x20(%rsp)
movsd %xmm1, 0x48(%rsp)
callq 0x20f0
movsd 0x48(%rsp), %xmm1
movsd 0x20(%rsp), %xmm9
movsd 0x8(%rsp), %xmm8
movapd 0x30(%rsp), %xmm7
movsd 0x10(%rsp), %xmm6
movsd 0x18(%rsp), %xmm5
movsd 0x2e550(%rip), %xmm2    # 0x37008
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm7
mulsd %xmm2, %xmm8
movapd %xmm7, %xmm0
mulsd %xmm9, %xmm0
movapd %xmm8, %xmm10
mulsd %xmm1, %xmm10
subsd %xmm0, %xmm10
movapd 0x2fddb(%rip), %xmm0    # 0x388c0
andpd %xmm10, %xmm0
movsd 0x48(%r15), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x8b00
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movapd 0x2e528(%rip), %xmm2    # 0x37030
xorpd %xmm7, %xmm2
mulsd %xmm8, %xmm9
mulsd %xmm1, %xmm2
subsd %xmm9, %xmm2
movq %r15, %rdi
movaps %xmm6, %xmm0
movapd %xmm10, %xmm1
movaps %xmm5, %xmm3
movq %r14, %rsi
movq %rbx, %rdx
movapd %xmm7, 0x30(%rsp)
movsd %xmm8, 0x8(%rsp)
movapd %xmm10, 0x20(%rsp)
callq 0x8b8c
movsd 0x50(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x58(%rsp), %xmm2
mulsd 0x30(%rsp), %xmm2
addsd %xmm0, %xmm2
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm3
movq %r14, %rsi
movq %rbx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8b8c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9b7a
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 0x9b46
retq
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorpd %xmm3, %xmm3
cmpl $0x2, 0x1c(%rdi)
jl 0x9ca0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm4, %xmm4
xorl %r14d, %r14d
xorpd %xmm3, %xmm3
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x9c77
leal (,%r14,4), %eax
movslq %eax, %r15
leal 0x1(,%r14,4), %eax
movslq %eax, %r12
leal 0x2(,%r14,4), %eax
movslq %eax, %r13
xorl %ebp, %ebp
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movslq (%rax,%rbp,4), %rax
cmpq %rax, %r14
jge 0x9c63
movq 0x40(%rbx), %rcx
leal (,%rax,4), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm1
subsd (%rcx,%r15,8), %xmm1
leal 0x1(,%rax,4), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
subsd (%rcx,%r12,8), %xmm2
leal 0x2(,%rax,4), %eax
cltq
movsd (%rcx,%rax,8), %xmm0
subsd (%rcx,%r13,8), %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jb 0x9c4c
sqrtsd %xmm0, %xmm0
jmp 0x9c5f
movsd %xmm3, (%rsp)
callq 0x20f0
xorpd %xmm4, %xmm4
movsd (%rsp), %xmm3
addsd %xmm0, %xmm3
incq %rbp
movq 0x30(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %rbp
jl 0x9bd9
incq %r14
movslq 0x1c(%rbx), %rax
decq %rax
cmpq %rax, %r14
jl 0x9ba7
mulsd 0x2d396(%rip), %xmm3    # 0x37028
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movapd %xmm3, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9e0e
movq %rdi, %r14
movq 0x40(%rdi), %r13
leaq 0xa0(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r15d, %r15d
movsd (%r13), %xmm0
movsd 0x2d32c(%rip), %xmm3    # 0x37028
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 0x2f001(%rip), %rsi     # 0x38d31
movb $0x3, %al
callq 0x2050
movq (%rsp), %rdi
leaq 0x2eff8(%rip), %rsi     # 0x38d3a
movq %r12, %rdx
xorl %eax, %eax
callq 0x21b0
movq 0x30(%r14), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x9dfa
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rax
movslq (%rax,%rbx,4), %rax
cmpq %rax, %r15
jle 0x9de6
movq 0x40(%r14), %rcx
shll $0x2, %eax
cltq
movsd (%rcx,%rax,8), %xmm0
movsd 0x2d2a4(%rip), %xmm3    # 0x37028
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 0x2ef79(%rip), %rsi     # 0x38d31
movb $0x3, %al
callq 0x2050
movq %r12, %rdi
movq %rbp, %rsi
callq 0x21a0
testl %eax, %eax
je 0x9de6
movq (%rsp), %rdi
leaq 0x2ef71(%rip), %rsi     # 0x38d4a
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 0x9d5d
incq %r15
addq $0x20, %r13
movslq 0x1c(%r14), %rax
cmpq %rax, %r15
jl 0x9cee
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/voro++/src/cell.cc
// Function: voro::voronoicell_base::m_calc(int, double&)
unsigned int voronoicell_base::m_calc(int n,double &ans) {
	double *pp=pts+4*n;
	ans=*(pp++)*px;
	ans+=*(pp++)*py;
	ans+=*(pp++)*pz-prsq;
	*pp=ans;
	unsigned int maskr=ans<-tol?0:(ans>tol?2:1);
	mask[n]=maskc|maskr;
	return maskr;
}

// Assembly:
movq 0x40(%rdi), %rax
leal (,%rsi,4), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd 0xc8(%rdi), %xmm0
movsd %xmm0, (%rdx)
movsd 0x8(%rax,%rcx,8), %xmm1
mulsd 0xd0(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdx)
movsd 0x10(%rax,%rcx,8), %xmm0
mulsd 0xd8(%rdi), %xmm0
subsd 0xe0(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
movsd %xmm0, 0x18(%rax,%rcx,8)
movsd (%rdx), %xmm0
movsd 0x48(%rdi), %xmm1
movapd 0x2ccae(%rip), %xmm2    # 0x37030
xorpd %xmm1, %xmm2
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
incl %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm2
cmovbel %ecx, %eax
movl 0xc0(%rdi), %ecx
orl %eax, %ecx
movq 0x38(%rdi), %rdx
movslq %esi, %rsi
movl %ecx, (%rdx,%rsi,4)
retq
nop